How to implement TCP connection and communication with Python?

Network connection and communication are the knowledge points that we cannot avoid when learning any programming language. Python is no exception. The following will introduce the core protocol of the Internet, TCP, and how to implement TCP connection and communication with Python.

[[286840]]

TCP

TCP (Transmission Control Protocol) is a connection-oriented transport layer communication protocol that provides high-reliability communication. Network services such as HTTP/HTTPS use TCP for communication. Network communication involves socket programming, including TCP.

Network Socket

Let's look at the definition:

A Network Socket is a data stream endpoint for inter-process communication in a computer network. In a broad sense, it also represents an inter-process communication mechanism provided by the operating system.

These computer terms are very academic and difficult to understand. You may know each word individually, but not all of them together. We can understand it in a simple way as sending a courier: A needs to send a courier to B. First, he needs to know B's address and mobile phone number. This address is equivalent to the host IP address in the network, and the mobile phone is equivalent to the host port number. Then A also needs to specify which courier company to use, SF Express or ZTO Express? This courier company is equivalent to the transmission protocol of the communication.

TCP connection process

In the above express delivery example, the one who sends the express delivery can be called the client, and the one who receives the express delivery can be called the server. In a more professional way, the party that actively initiates the connection is called the client, and the party that passively responds is called the server. For example, when we access Baidu search in a browser, our own computer is the client, and the browser will send a connection request to Baidu's server. If Baidu's server accepts our request, then a TCP connection is established, and then Baidu will transmit the search results to us.

Let's look at a flow chart:

The establishment of a TCP server can be summarized in these steps:

• Create a socket
• Bind the socket to the IP address and port number
• Listen for client connection requests
• Accept the client's connection request
• Talk to the client
• Close the connection

The creation of a TCP client can be summarized in these steps:

• Create a socket
• Connect to server socket
• Talking to the server
• Close the connection

It should be noted here that the IP and port number of the TCP client connecting to the server must be the IP and listening port number of the TCP server. The server calls listen() to start listening to the port, and then calls accept() to be ready to accept the client's connection request. At this time, the server is in a blocked state until the server listens to the client's request, receives the request and establishes a connection.

TCP Client

To create a socket connection, you can do this:

 # Import the socket library import socket # Create a socket s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Establish a connection s.connect ( ( "127.0.0.1" , 6000))

When creating a socket, the first parameter socket.AF_INET indicates that the IPv4 protocol is specified. If the IPv6 protocol is to be used, it is specified as socket.AF_INET6. SOCK_STREAM specifies the use of the stream-oriented TCP protocol. Then we call the connect() method, pass in the IP address (or domain name), and specify the port number to establish a connection.

Next we can send data to the server:

 s.send(b 'Hello, Mr Right!' )

When receiving data, the recv(max) method is called to receive a maximum of the specified number of bytes at a time. Therefore, the data is received repeatedly in a while loop until recv() returns empty data, indicating that the data is received and the loop is exited.

 #Receive data buffer=[] whileTrue: #Receive at most 1k bytes each time d=s.recv(1024) ifd: buffer.append(d) else :break data=b '' . join (buffer)

Finally, we need to close the connection, which is simple:

 s.close ( )

TCP Server

Compared with the client, the server is slightly more complicated. It needs to bind an IP address and port number first, then listen to the client's request, and after receiving the request, it will be sent to a thread for processing.

Creating a socket is the same as the client method:

 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

Next you need to bind the listening address and port:

 s.bind(( '127.0.0.1' , 6000))

Then you can start listening to the port. When listening, you need to pass in a parameter to specify the maximum number of waiting connections:

 s.listen(5)

The next step is to wait for the client's connection in an infinite loop until a connection request comes, and then use a thread to process it:

 whileTrue: #Accept a new connection sock,addr=s.accept() #Create a new thread to handle TCP connection t=threading.Thread(target=tcplink,args=(sock,addr)) t.start()

Why is multi-threaded processing needed here? Imagine the Cainiao Post Station. If there is only one person inside, then multiple people who want to send parcels will need to queue up one by one. But if there are multiple people, then each of them can handle a delivery request.

Let's take a look at the method that handles client requests:

 # Processing TCP connection def tcplink(conn, addr): print( "Accept new connection from %s:%s" % addr) # Send a welcome message to the client conn.send(b "Server: Welcome!\n" ) while True : conn.send(b "Server: What's your name?" ) data = conn.recv(1024) # If the client sends exit to request exit, end the loop if data == b "exit" : conn.send(b "Server: Good bye!\n" ) break conn.send(b "Server: Hello %s!\n" % data) # Close the connection conn. close () print( "Connection from %s:%s is closed" % addr)

In this example, we first send a welcome message to the client, then ask the client name, and after receiving the name, send a welcome message until we receive the client's 'exit' command, exit the loop, and close the connection.

Examples

We combine the above step-by-step code into a runnable example.

Server side code:

 import socketimport threadingimport time # Processing TCP connection def tcplink(conn, addr): print( "Accept new connection from %s:%s" % addr) # Send a welcome message to the client conn.send(b "Server: Welcome!\n" ) while True : conn.send(b "Server: What's your name?" ) data = conn.recv(1024) # If the client sends exit to request to exit, end the loop if data == b "exit" : conn.send(b "Server: Good bye!\n" ) break conn.send(b "Server: Hello %s!\n" % data) time .sleep(5) # Close the connection conn.close () print( "Connection from %s:%s is closed " % addr) # Create sockets = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Listening port s.bind(( "127.0.0.1" , 6000)) # Set the maximum number of waiting connections to 5 s.listen(5)print( "Waiting for connection..." )# Waiting to receive a connection while True : # Accept a new connection conn, addr = s.accept() # Create a new thread to handle TCP connections t = threading.Thread(target=tcplink, args=(conn, addr)) t.start()

Client code:

 import socketimport time # Create sockets = socket.socket(socket.AF_INET, socket.SOCK_STREAM)# Establish connection s. connect (( "127.0.0.1" , 6000))# Receive server message print(s.recv(1024).decode()) for data in [b 'Michael' , b 'Tracy' , b 'Sarah' ]: # Send data s.send(data) time .sleep(2) # Print received data print(s.recv(1024).decode( 'utf-8' )) time .sleep(1) time .sleep(3)# Request to exit s.send(b 'exit' ) time .sleep(2)print(s.recv(1024).decode( 'utf-8' ))# Close the connection s. close ()

Note that I added some sleep operations in the code, mainly to ensure that the console can print smoothly. Otherwise, the program runs too fast and the printing order and content may be different from expectations.

Run the server-side code first, then run the client-side code, we can see that the server-side console prints the following:

 #The server prints the message Waitingforconnection... Acceptnewconnectionfrom127.0.0.1:53503 Connectionfrom127.0.0.1:53503isclosed

The client console prints the following:

 #Client print message Server:Welcome!Server:What 'syourname? Server:HelloMichael! Server:What' syourname? Server:HelloTracy! Server:What 'syourname? Server:HelloSarah! Server:What' syourname? Server:Goodbye!

You can compare the printed content and code to understand the principle of communication between the server and the client.

Summarize

This article introduces the basic principles of TCP programming and how to use Python to implement the simplest TCP communication process. Through the introduction and examples, you should form a TCP communication process in your mind. Being familiar with this process is the basis for handling subsequent complex communication needs.