Implementing TCP and UDP Clients and Servers with asyncio

Understanding asynchronous programming especially important for effective network programming in Python. The asyncio library provides a framework for writing single-threaded concurrent code using the async/await syntax, which can be advantageous when handling I/O-bound tasks.

At its core, asyncio allows you to write code that can run at the same time by using coroutines, which are special functions defined with the async def syntax. These coroutines can pause execution and yield control back to the event loop, allowing other tasks to run in the meantime.

The event loop is the heart of an asyncio application. It manages the execution of coroutines, handling the scheduling and execution of tasks in a non-blocking manner. You can think of it as a conductor of an orchestra, ensuring that all the musicians (tasks) play in harmony without stepping on each other’s toes.

To create an asyncio event loop, you typically start with the following code:

import asyncio

async def main():
    print("Hello, asyncio!")

asyncio.run(main())

This simple example demonstrates the creation of a coroutine (main) and its execution within the event loop. The asyncio.run() function is a convenient way to run the main coroutine and manage the event loop for you.

Another important concept within asyncio is the use of tasks. Tasks are a way to schedule coroutines concurrently. You can create a task with the asyncio.create_task() function, which allows you to run multiple coroutines concurrently without waiting for each to finish before starting the next.

Here’s an example of creating and running multiple tasks:

async def task_one():
    await asyncio.sleep(1)
    print("Task One Completed")

async def task_two():
    await asyncio.sleep(2)
    print("Task Two Completed")

async def main():
    task1 = asyncio.create_task(task_one())
    task2 = asyncio.create_task(task_two())

    await task1
    await task2

asyncio.run(main())

In this snippet, task_one sleeps for one second and then prints a message, while task_two sleeps for two seconds. The main coroutine schedules these tasks at the same time, and you can see that “Task One Completed” will be printed before “Task Two Completed,” even though the second task takes longer to finish.

Understanding how to leverage the power of coroutines and the event loop will enable you to write efficient network applications that can handle many connections simultaneously without the overhead of multi-threading or multi-processing.

Apple Watch Series 11 [GPS 42mm] Smartwatch with Rose Gold Aluminum Case with Light Blush Sport Band - S/M. Sleep Score, Fitness Tracker, Health Monitoring, Always-On Display, Water Resistant

(4755613)

$260.28 (as of July 1, 2026 22:47 GMT +00:00 - More infoProduct prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on [relevant Amazon Site(s), as applicable] at the time of purchase will apply to the purchase of this product.)

A FULL-FEATURED HEALTH TRACKER—Apple Watch Series 11 gives you invaluable insights about your body, right from your wrist. Take an ECG anytime* and get alerts for a high and low heart rate or an irregular rhythm*—so you can stay closer to your heart.... read more

Building a TCP client and server

To build a TCP client and server using asyncio, we first need to create the server that listens for incoming connections. The server will accept connections and handle each client in a separate coroutine, allowing it to manage multiple clients at once.

Here’s a basic implementation of a TCP server:

import asyncio

async def handle_client(reader, writer):
    data = await reader.read(100)
    message = data.decode()
    addr = writer.get_extra_info('peername')

    print(f"Received {message} from {addr}")

    response = f"Echo: {message}"
    writer.write(response.encode())
    await writer.drain()

    print("Closing the connection")
    writer.close()

async def main():
    server = await asyncio.start_server(handle_client, '127.0.0.1', 8888)

    addr = server.sockets[0].getsockname()
    print(f'Serving on {addr}')

    async with server:
        await server.serve_forever()

asyncio.run(main())

This TCP server listens on localhost (127.0.0.1) at port 8888. The handle_client coroutine is invoked for each client connection. It reads data sent by the client, processes it, and sends back an echo response. The writer.drain() method ensures that the response is sent before closing the connection.

Now that we have a server set up, we can create a corresponding TCP client. The client will connect to the server, send a message, and wait for the response.

import asyncio

async def tcp_client(message):
    reader, writer = await asyncio.open_connection('127.0.0.1', 8888)

    print(f'Sending: {message}')
    writer.write(message.encode())

    data = await reader.read(100)
    print(f'Received: {data.decode()}')

    print("Closing the connection")
    writer.close()

async def main():
    await tcp_client("Hello, Server!")

asyncio.run(main())

The client connects to the same address and port as the server and sends a message. After sending, it waits for the response from the server and then closes the connection. This simple example illustrates the basic communication between a TCP client and server using asyncio.

It’s important to handle exceptions and edge cases in a production application. For instance, you should consider what happens if the server is unavailable or if the connection is interrupted. Using try-except blocks can help manage these situations gracefully.

As you develop more complex applications, you can extend this basic framework to include features such as authentication, logging, or even support for multiple protocols. The asyncio library provides a solid foundation for building scalable network applications that can handle a significant number of concurrent connections.

Next, we will explore how to create a UDP client and server, which differs from TCP in handling connections and data transmission.

Creating a UDP client and server

Creating a UDP client and server involves a different approach compared to TCP, as UDP is connectionless and does not guarantee delivery. This means that messages can be lost, duplicated, or arrive out of order. However, the simplicity and speed of UDP can be advantageous for certain applications, such as real-time communications or streaming.

To implement a UDP server using asyncio, you can use the loop.create_datagram_endpoint method. This method allows you to create a datagram endpoint and handle incoming datagrams in a coroutine.

import asyncio

class UDPServerProtocol:
    def connection_made(self, transport):
        self.transport = transport

    def datagram_received(self, data, addr):
        print(f"Received {data.decode()} from {addr}")
        response = f"Echo: {data.decode()}"
        self.transport.sendto(response.encode(), addr)

async def main():
    loop = asyncio.get_running_loop()
    print("Starting UDP server")
    
    listen = loop.create_datagram_endpoint(UDPServerProtocol, local_addr=('127.0.0.1', 9999))
    transport, protocol = await listen

    try:
        await asyncio.sleep(3600)  # Run for 1 hour
    finally:
        transport.close()

asyncio.run(main())

This UDP server listens on localhost (127.0.0.1) at port 9999. The UDPServerProtocol class handles incoming datagrams and sends back an echo response to the sender. The server runs indefinitely, waiting for incoming messages.

Now, let’s create a corresponding UDP client that will send a message to the server and wait for a response. The client will also use the loop.create_datagram_endpoint method to handle sending and receiving datagrams.

import asyncio

class UDPClientProtocol:
    def connection_made(self, transport):
        self.transport = transport

    def datagram_received(self, data):
        print(f"Received: {data.decode()}")
        self.transport.close()

async def main():
    loop = asyncio.get_running_loop()
    print("Starting UDP client")
    
    connect = loop.create_datagram_endpoint(UDPClientProtocol, remote_addr=('127.0.0.1', 9999))
    transport, protocol = await connect

    message = "Hello, UDP Server!"
    print(f'Sending: {message}')
    transport.sendto(message.encode())

    await asyncio.sleep(1)  # Wait for response

asyncio.run(main())

The UDP client connects to the server at the same address and port. It sends a message and waits for a response. The datagram_received method in the UDPClientProtocol class handles the incoming response from the server. After receiving the response, the transport is closed.

When working with UDP, it is essential to consider the reliability of your application. Since UDP does not guarantee message delivery, you may need to implement your own mechanisms for acknowledgment and retransmission if necessary. This could involve adding sequence numbers to messages or using a different protocol for critical data.

As you build applications that leverage UDP, keep in mind the trade-offs between speed and reliability, and design your protocols accordingly to meet the needs of your specific use case.