Introduction
In this article we will look at how to write a simple Python service and client that can communicate with each other over the network. Building networked applications is an important programming skill, and Python provides many built-in tools to help make the process straightforward. By the end, we will have a working Python service that runs continuously and waits for client connections, and a Python client that can connect to the service and exchange messages.
The service we will create will simply echo back any messages sent to it by clients. This is a basic example, but it covers the core concepts of writing a service, establishing a network connection and sending/receiving data that apply to building more sophisticated services as well. The client will connect to the service, send a message, and print out the echoed response.
Writing the Service
We’ll start by creating our echo service Python file, which we’ll call echo_service.py. The first step is to import the socket module, which provides network connection capabilities:
python
Copy
import socket
Now we need to create a socket object to listen for incoming connections on. Sockets are bound to specific network interfaces and ports – we’ll use port 5000 and accept connections from any network interface:
python
Copy
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind((”, 5000))
The socket.AF_INET parameter specifies that we want to use Internet protocols like IP/TCP. SOCK_STREAM means this will be a TCP socket.
Next, we call server_socket.listen(), which places the socket into a listening state, waiting for client connections. The backlog parameter specifies how many unaccepted connections can be queued up before refuses are issued:
python
Copy
server_socket.listen(1)
Now the main loop – we call accept() on the server socket to wait for a new client connection. This returns a new socket object connected specifically to that client:
python
Copy
while True:
client_socket, address = server_socket.accept()
To echo messages back, we need to read from the client socket, then write the response back. We’ll use a 1024 byte buffer:
python
Copy
buffer = client_socket.recv(1024)
client_socket.send(buffer)
To close the connection cleanly, call close() on the client socket:
python
Copy
client_socket.close()
Finally, put it all together in a try/except block to catch any errors:
python
Copy
import socket
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind((”, 5000))
server_socket.listen(1)
print(‘Listening on port 5000…’)
while True:
try:
client_socket, address = server_socket.accept()
print(f”Connection from {address} has been established.”)
buffer = client_socket.recv(1024)
client_socket.send(buffer)
client_socket.close()
except IOError:
print(“IOError occurred”)
This creates a continuously running socket service listening on port 5000 that will echo messages from any connecting client.
Writing the Client
Now we’ll create the client Python file, called echo_client.py, that connects to the service and exchanges messages:
python
Copy
import socket
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect((‘localhost’, 5000))
Similar to the service, we create a socket specifying the address family (AF_INET) and socket type (SOCK_STREAM). But instead of binding and listening, we call connect() to initiate a connection to the service listening on localhost port 5000.
Next, we’ll prompt the user for a message to send, encode it for transmission, and send it to the service:
python
Copy
message = input(“Enter a message to echo: “)
client_socket.send(message.encode())
To receive the echoed response, we use recv() on the socket:
python
Copy
buffer = client_socket.recv(1024)
print(buffer.decode())
Then close the socket and we’re done:
python
Copy
client_socket.close()
Put together, the full client code is:
python
Copy
import socket
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect((‘localhost’, 5000))
message = input(“Enter a message to echo: “)
client_socket.send(message.encode())
buffer = client_socket.recv(1024)
print(buffer.decode())
client_socket.close()
Testing it Out
To test the service and client, open two terminal windows. In one, run the echo_service.py file:
Copy
python3 echo_service.py
This will start the server listening on port 5000.
In the other terminal, run the echo_client.py:
Copy
python3 echo_client.py
It will prompt for a message. Enter some text and press enter. The message should be echoed back and printed by the client.
You can run the client multiple times, entering different messages each time, and observe that the server handles each connection independently, echoing back the message sent over that connection before closing it.
Expanding the Example
This covers the basic concepts required to build networked Python applications using sockets. There are many ways this example could be expanded, such as:
Add error handling and input validation
Allow sending larger data or files
Have the service do something more complex than echoing
Implement a message protocol instead of raw sockets
Add threading to handle multiple clients simultaneously
Use asynchronous networking for better performance
It also only demonstrates TCP communication – Python’s socket module also supports UDP sockets which have different characteristics better suited for things like broadcasting.
Building networked applications is an important programming skill, and this simple example demonstrates the basic building blocks required in Python – creating sockets, binding ports, listening for connections, exchanging data over connected sockets. With Python’s excellent standard library and community libraries, many real-world networked services can be implemented with relatively little code. I hope this helps provide a starting point for exploring Python networking further.
Andrew Stroud