Detailed introduction to socket for advanced python learning

The original English meaning of Socket is "hole" or "socket". As the process communication mechanism of BSD UNIX, it is also commonly called "socket", which is used to describe IP addresses and ports. It is the handle of a communication chain and can be used to implement communication between different virtual machines or different computers.

Two programs on the network exchange data through a two-way communication connection. One end of this connection is called a socket.

Establishing a network communication connection requires at least a pair of port numbers (socket). The essence of socket is ProgrammingInterface(API). For the encapsulation of TCP/IP, TCP/IP must also provide it for programmers The interface used for network development is the Socket programming interface; HTTP is the car, which provides a specific form of encapsulating or displaying data; Socket is the engine, which provides the ability for network communication.

Let’s talk about the socket of python.

1.socket module

Use socket.socket()function to create a socket. The syntax is as follows:

socket.socket(socket_family,socket_type,protocol=0)

socket_family can be the following parameters:

socket.AF_INET IPv4 (default)

socket.AF_INET6 IPv6

socket.AF_UNIX can only be used for inter-process communication in a single Unix system

socket_type can be the following parameters:

socket.SOCK_STREAM streaming socket, for TCP (default)

socket.SOCK_DGRAM datagram socket, for UDP

socket.SOCK_RAW raw socket, ordinary socket cannot handle ICMP, IGMP and other network messages, but SOCK_RAW can; secondly, SOCK_RAW can also handle special IPv4 messages; in addition, using raw sockets, the IP header can be constructed by the user through the IP_HDRINCL socket option.

　socket.SOCK_RDM is a reliable form of UDP, which guarantees the delivery of datagrams but does not guarantee the order. SOCK_RAM is used to provide low-level access to the original protocol and is used when certain special operations need to be performed, such as sending ICMP messages. SOCK_RAM is usually restricted to programs run by power users or administrators.

socket.SOCK_SEQPACKET Reliable continuous packet service

protocol parameter:

0　(Default) The protocol related to the specific address family. If it is 0, the system will A suitable protocol will be automatically selected based on the address format and socket category

2. SocketObjectBuilt-in method

Server-side socket function

s.bind()　 Bind the address (ip address, port) to the socket. The parameters must be in the format of tuples. For example: s.bind(('127.0.0.1',8009))

s.listen(5) Start listening, 5 is the maximum number of pending connections

s.accept() Passively accept client connections, block, and wait for connections

Client socket Word function

s.connect() To connect to the server, the parameters must be in tuple format. For example: s.connect(('127,0.0.1',8009))

Public purpose Socket function

s.recv(1024) Receive TCP data, 1024 is the size of one data reception

s.send(bytes) Send TCP data, the format of python3 sending data must be bytes format

s.sendall() Send data completely, internal loopCall send

s.close() Close the socket

Example 1 .Simple implementation of socket program

server side

#!/usr/bin/env python
# _*_ coding:utf-8 _*_
import socket
import time
IP_PORT = ('127.0.0.1',8009)
BUF_SIZE = 1024
 
tcp_server = socket.socket()
tcp_server.bind(IP_PORT)
tcp_server.listen(5)
 
while True:
    print("waiting for connection...")
    conn,addr = tcp_server.accept()
    print("...connected from:",addr)
    while True:
        data = tcp_server.recv(BUF_SIZE)
        if not data:break
        tcp_server.send('[%s] %s'%(time.ctime(),data))
 
tcp_server.close()

Explanation of the above code:

1~4 lines

The first line is the Unix startup information line, Then import the time module and socket module

5~10 lines

IP_PORT declares the IP address and port for the global variable, indicating that the bind() function is bound to this address Above, set the buffer size to 1K, and the listen() function indicates the maximum number of connections allowed to come in at the same time, and subsequent connections will be rejected

11~到最后一行

在进入服务器的循环后，被动等待连接的到来。当有连接时，进入对话循环，等待客户端发送数据。如果消息为空，表示客户端已经退出，就跳出循环等待下一个连接到来。得到客户端消息后，在消息前面加一个时间戳然后返回。最后一行不会执行，因为循环不会退出所以服务端也不会执行close()。只是提醒不要忘记调用close()函数。

client端

#!/usr/bin/env python
# _*_ coding:utf-8 _*_
import socket
 
HOST = '127.0.0.1'
PORT = 8009
BUF_SIZE = 1024
ADDR = (HOST,PORT)
 
client = socket.socket()
client.connect(ADDR)
 
while True:
    data = input(">>> ")
    if not data:break
    client.send(bytes(data,encoding='utf-8'))
    recv_data = client.recv(BUF_SIZE)
    if not recv_data:break
    print(recv_data.decode())
     
client.close()

5~11行

HOST和PORT变量表示服务器的IP地址与端口号。由于演示是在同一台服务器所以IP地址都是127.0.0.1，如果运行在其他服务器上要做相应的修改。端口号要与服务器端完全相同否则无法通信。缓冲区大小还是1K。

客户端套接字在10行创建然后就去连接服务器端

13~21行

客户端也无限循环，客户端的循环在以下两个条件的任意一个发生后就退出：1.用户输入为空的情况或者服务器端响应的消息为空。否则客户端会把用户输入的字符串发送给服务器进行处理，然后接收显示服务器返回来的带有时间戳的字符串。

运行客户端程序与服务端程序

以下是客户端的输入与输出

[root@pythontab]# python client.py 
>>> hello python
[Thu Sep 15 22:29:12 2016] b'hello python'

以下是服务端输出

[root@pythontab]# python server.py 
waiting for connection...
...connected from: ('127.0.0.1', 55378)

3.socketserver模块

socketserver是标准库中的一个高级别的模块。用于简化实现网络客户端与服务器所需要的大量样板代码。模块中已经实现了一些可以使用的类。

实例1：使用socketserver实现与上面socket()实例一样的功能

服务端程序代码

#!/usr/bin/env python
# _*_ coding:utf-8 _*_
import socketserver
import time
 
HOST = '127.0.0.1'
PORT = 8009
ADDR = (HOST,PORT)
BUF_SIZE = 1024
 
class Myserver(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            print("...connected from:",self.client_address)
            data = self.request.recv(BUF_SIZE)
            if not data:break
            self.request.send(bytes("%s %s"%(time.ctime(),data)))
 
server = socketserver.ThreadingTCPServer(ADDR,Myserver)
print("waiting for connection...")
server.serve_forever()

11~17行

主要的工作在这里。从socketserver的BaseRequestHandler类中派生出一个子类，并重写handle()函数。

在有客户端发进来的消息的时候，handle()函数就会被调用。

19~21行

代码的最后一部分用给定的IP地址和端口加上自定义处理请求的类(Myserver)。然后进入等待客户端请求与处理客户端请求的无限循环中。

客户端程序代码

import socket
HOST = '127.0.0.1'
PORT = 8009
ADDR = (HOST,PORT)
BUF_SIZE = 1024
 
client = socket.socket()
client.connect(ADDR)
 
while True:
    data = input(">>> ")
    if not data:continue
    client.send(bytes(data,encoding='utf-8'))
    recv_data = client.recv(BUF_SIZE)
    if not recv_data:break
    print(recv_data.decode())
 
client.close()

执行服务端和客户端代码　　

下面是客户端输出

[root@pythontab]# python socketclient.py 
>>> hello python
Thu Sep 15 23:53:31 2016 b'hello python'
>>> hello pythontab
Thu Sep 15 23:53:49 2016 b'hello pythontab'

下面是服务端输出

[root@pythontab]# python socketserver.py 
waiting for connection...
...connected from: ('127.0.0.1', 55385)
...connected from: ('127.0.0.1', 55385)
...connected from: ('127.0.0.1', 55385)
...connected from: ('127.0.0.1', 55385)

The above is the detailed content of Detailed introduction to socket for advanced python learning. For more information, please follow other related articles on the PHP Chinese website!