Python network programming

Understand Socket

Socket is also commonly called "socket", which is used to describe IP addresses and ports. It is the handle of a communication chain. Applications usually make requests to the network or respond to network requests through "sockets".

Socket originated from Unix, and one of the basic philosophies of Unix/Linux is "everything is a file". For files, use the [Open] [Read and Write] [Close] mode to operate. Socket is an implementation of this mode. Socket is a special file. Some socket functions are operations on it (read/write IO, open, close). The difference between socket and file:

file module is for [Open] [Read and Write] [Close] a specified file

The socket module is for server-side and client-side Sockets to [Open] [Read and Write] [Close]

ython (version 3.5 ) To achieve the simplest socket communication

#!/usr/bin/env python
# coding=utf-8
# Author:Majh

import socket

ip_port = ('127.0.0.1', 9999)
sk = socket.socket()

sk.connect(ip_port)
send_data = input('>>').strip()
sk.send(bytes(send_data, encoding='utf-8'))
recv_data = sk.recv(1024)
print(str(recv_data, encoding='utf-8'))
sk.close()

客户端代码

#!/usr/bin/env python
# coding=utf-8
# Author:Majh

import socket

sk = socket.socket()
ip_port = ('127.0.0.1', 9999)

sk.bind(ip_port)
print('sk.bind......')
sk.listen(5)
print('sk.listen......')
conn, addr = sk.accept()
print('conn:', conn)
print('addr:', addr)

read_data = conn.recv(1024)
print('read_data', read_data)
read_data = read_data.upper()

conn.send(read_data)
conn.close()

服务器端代码

socket keyword parameters:

sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)

Parameter 1: Address cluster

　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

Parameter 2: Type

　　socket.SOCK_STREAM　Streaming socket, for TCP (default)

　　socket.SOCK_DGRAM　　Datagram socket , for UDP

　 socket.SOCK_RAW raw socket. Ordinary sockets cannot process network messages such as ICMP and IGMP, but SOCK_RAW can. Secondly, SOCK_RAW can also process special IPv4 messages. In addition, using raw sockets word, the IP header can be constructed by the user via 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

Parameter three: Protocol

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

sk.bind(address)

　s.bind(address) binds the socket to the address. The format of address depends on the address family. Under AF_INET, the address is expressed in the form of a tuple (host, port).

sk.listen(backlog)

Start listening for incoming connections. The backlog specifies the maximum number of connections that can be pending before the connection is rejected.

Backlog equals 5, indicating that the kernel has received the connection request, but the server has not yet called accept for processing. The maximum number of connections is 5

This value cannot be infinite because the connection queue must be maintained in the kernel

sk.setblocking( bool)

　Whether to block (default True), if set to False, an error will be reported if there is no data during accept and recv.

sk.accept()

　 Accept the connection and return (conn, address), where conn is a new socket object that can be used to receive and send data. address is the address to connect to the client.

　Receive the connection from the TCP client (blocking) and wait for the connection to arrive

sk.connect(address)

　Connect to the socket at address. Generally, the format of address is a tuple (hostname, port). If a connection error occurs, a socket.error error is returned.

sk.connect_ex(address)

　 Same as above, except there will be a return value, 0 is returned when the connection is successful, and the code is returned when the connection fails, for example: 10061

sk.close()

　Close the socket

sk .recv(bufsize[,flag])

　Accepts socket data. The data is returned as a string, and bufsize specifies the maximum number that can be received. flag provides additional information about the message and can usually be ignored.

sk.recvfrom(bufsize[.flag])

　 Similar to recv(), but the return value is (data, address). Where data is a string containing the received data, and address is the socket address to which the data is sent.

sk.send(string[,flag])

　 Send the data in string to the connected socket. The return value is the number of bytes to send, which may be less than the string's byte size. That is: all specified content may not be sent.

sk.sendall(string[,flag])

　 Sends the data in string to the connected socket, but attempts to send all data before returning. Returns None on success, throws an exception on failure.

Internally, all content is sent out by calling send recursively.

sk.sendto(string[,flag],address)

　 Send data to the socket, address is a tuple in the form of (ipaddr, port), specifying the remote address. The return value is the number of bytes sent. This function is mainly used for UDP protocol.

sk.settimeout(timeout)

Set the timeout period for socket operations. timeout is a floating point number in seconds. A value of None means there is no timeout period. Generally, the timeout period should be set when the socket is first created, because they may be used for connection operations (such as client connections waiting up to 5s)

sk.getpeername()

　 Returns the remote address of the connected socket. The return value is usually a tuple (ipaddr, port).

sk.getsockname()

　 Returns the socket’s own address. Usually a tuple (ipaddr,port)