Network streams, subprocesses, and non-blocking integration patterns.
TCP clients and stream I/O.
import asyncio
async def main():
reader, writer = await asyncio.open_connection("example.com", 80)
writer.write(b"GET / HTTP/1.1
Host: example.com
Connection: close
")
await writer.drain()
data = await reader.read(200)
print(data.decode(errors="replace"))
writer.close()
await writer.wait_closed()
asyncio.run(main())High-level streams are convenient for simple protocol clients.
import asyncio
async def handle(reader, writer):
data = await reader.readline()
writer.write(b"echo: " + data)
await writer.drain()
writer.close()
await writer.wait_closed()
async def main():
server = await asyncio.start_server(handle, "127.0.0.1", 9000)
async with server:
await server.serve_forever()
asyncio.run(main())Use `start_server()` for lightweight TCP services.
Run and communicate with child processes asynchronously.
import asyncio
async def main():
proc = await asyncio.create_subprocess_exec(
"python",
"-c",
"print('hello from child')",
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
stdout, stderr = await proc.communicate()
print(stdout.decode().strip(), proc.returncode)
asyncio.run(main())Use `create_subprocess_exec()` when you want argument-safe subprocess calls.
import asyncio
async def main():
proc = await asyncio.create_subprocess_shell(
"echo one && echo two",
stdout=asyncio.subprocess.PIPE,
)
stdout, _ = await proc.communicate()
print(stdout.decode())
asyncio.run(main())Convenient for shell pipelines, but avoid untrusted input.
Offload blocking work without freezing the event loop.
import asyncio
import time
def blocking_read():
time.sleep(1)
return "finished"
async def main():
result = await asyncio.to_thread(blocking_read)
print(result)
asyncio.run(main())`asyncio.to_thread()` is a high-level helper for running I/O-bound blocking functions in a separate thread.
import asyncio
import time
def blocking():
time.sleep(1)
return 42
async def main():
loop = asyncio.get_running_loop()
result = await loop.run_in_executor(None, blocking)
print(result)
asyncio.run(main())A lower-level alternative to `to_thread()` when you need more control.