Python의 소켓 및 소켓 서버를 사용하는 방법

1. TCP 프로토콜 기반 소켓 프로그래밍

1. 소켓 작업 흐름

서버 쪽부터 시작해 보겠습니다. 서버는 먼저 소켓을 초기화한 다음 포트에 바인드하고 포트를 수신하며 차단을 위해 승인을 호출하고 클라이언트가 연결될 때까지 기다립니다. 이때 클라이언트가 Socket을 초기화한 후 서버에 연결(connect)하면, 연결에 성공하면 클라이언트와 서버 간의 연결이 성립된다. 클라이언트는 데이터 요청을 보내고, 서버는 요청을 수신하고 요청을 처리한 다음 클라이언트에 응답 데이터를 보내고, 클라이언트는 데이터를 읽고 마지막으로 연결을 종료합니다. 구현하려면 다음을 수행합니다.

import socket
# socket_family 可以是 AF_UNIX 或 AF_INET。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填，默认值为 0
socket.socket(socket_family, socket_type, protocal=0)
# 获取tcp/ip套接字
tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 获取udp/ip套接字
udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

1. 서버 소켓 기능

• s.bind(): (호스트, 포트 번호)를 소켓에 바인딩

• s.listen(): TCP 수신 시작

• s.accept() : Passive TCP 클라이언트로부터의 연결을 수락하고, 연결이 도착하기를 기다립니다.

2. 클라이언트 소켓 기능

• s.connect(): TCP 서버 연결

• s을 적극적으로 초기화합니다. connect_ex() : 오류 발생 시 예외를 발생시키지 않고 오류 코드를 반환하는 connect() 함수의 확장 버전

3. 공용 소켓 함수

• s.recv(): TCP 수신 data

• s.send(): TCP 데이터를 보냅니다. (전송할 데이터의 양이 자체 버퍼의 남은 공간보다 클 경우 데이터가 손실되어 완전히 전송되지 않습니다.)

• s.sendall(): 완전한 TCP 데이터를 전송합니다. (본질적으로 send를 루프로 호출하는 것입니다. 전송하려는 데이터의 양이 자체 버퍼의 남은 공간보다 클 경우 데이터가 손실되지 않습니다. Send를 호출합니다. 전송될 때까지 루프를 반복합니다.)

• s.recvfrom(): UDP 데이터 수신

• s. sendto(): UDP 데이터 전송

• s.getpeername(): 원격지의 주소 현재 소켓에 연결된 end

• s.getsockname(): 현재 소켓의 주소

• s. getsockopt(): 지정된 소켓의 매개변수를 반환합니다.

• s.setsockopt(): 설정 지정된 소켓의 매개변수

• s.close(): 소켓을 닫습니다.

4. 잠금 지향 소켓 메서드

• s.setblocking(): 소켓의 차단 및 비차단 모드를 설정합니다. 소켓

• s.settimeout(): 소켓 작업 차단에 대한 시간 초과를 설정합니다.

• s.gettimeout(): 차단 소켓 작업의 시간 초과를 가져옵니다

5.

s.fileno(): 소켓의 파일 디스크립터

• s.makefile(): 소켓과 관련된 파일을 생성합니다

• 2. TCP 프로토콜 기반의 소켓 프로그래밍

소켓 상태를 확인할 수 있습니다. netstat -an | findstr 8080

1. 서버

import socket
# 1、买手机
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # tcp称为流式协议,udp称为数据报协议SOCK_DGRAM
# print(phone)
# 2、插入/绑定手机卡
# phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
phone.bind(('127.0.0.1', 8080))
# 3、开机
phone.listen(5) # 半连接池，限制的是请求数
# 4、等待电话连接
print('start....')
while True: # 连接循环
conn, client_addr = phone.accept() # （三次握手建立的双向连接，（客户端的ip，端口））
# print(conn)
print('已经有一个连接建立成功', client_addr)
# 5、通信：收\发消息
while True: # 通信循环
try:
print('服务端正在收数据...')
data = conn.recv(1024) # 最大接收的字节数，没有数据会在原地一直等待收，即发送者发送的数据量必须>0bytes
# print('===>')
if len(data) == 0: break # 在客户端单方面断开连接，服务端才会出现收空数据的情况
print('来自客户端的数据', data)
conn.send(data.upper())
except ConnectionResetError:
break
# 6、挂掉电话连接
 conn.close()
# 7、关机
phone.close()
# start....
# 已经有一个连接建立成功 ('127.0.0.1', 4065)
# 服务端正在收数据...
# 来自客户端的数据 b'\xad'
# 服务端正在收数据...

netstat -an | findstr 8080查看套接字状态

1、 服务端

import socket
# 1、买手机
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# print(phone)
# 2、拨电话
phone.connect(('127.0.0.1', 8080)) # 指定服务端ip和端口
# 3、通信：发\收消息
while True: # 通信循环
msg = input('>>: ').strip() # msg=''
if len(msg) == 0: continue
phone.send(msg.encode('utf-8'))
# print('has send----->')
data = phone.recv(1024)
# print('has recv----->')
print(data)
# 4、关闭
phone.close()
# >>: 啊
# b'a'
# >>: 啊啊
# b'\xb0\xa1\xb0\xa1'
# >>:

2、 客户端

# 

phone=socket(AF_INET,SOCK_STREAM)
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
phone.bind(('127.0.0.1',8080))

3、地址占用问题

这个是由于你的服务端仍然存在四次挥手的time_wait状态在占用地址（如果不懂，请深入研究1.tcp三次握手，四次挥手 2.syn洪水攻击 3.服务器高并发情况下会有大量的time_wait状态的优化方法）

1、 方法一：加入一条socket配置，重用ip和端口

发现系统存在大量TIME_WAIT状态的连接，通过调整linux内核参数解决，
vi /etc/sysctl.conf
编辑文件，加入以下内容：
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_fin_timeout = 30
然后执行 /sbin/sysctl -p 让参数生效。
net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭；
net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭；
net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。
net.ipv4.tcp_fin_timeout 修改系統默认的 TIMEOUT 时间

2、 方法二：通过调整linux内核参数

from socket import *
import subprocess
server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 8000))
server.listen(5)
print('start...')
while True:
conn, client_addr = server.accept()
while True:
print('from client:', client_addr)
cmd = conn.recv(1024)
if len(cmd) == 0: break
print('cmd:', cmd)
obj = subprocess.Popen(cmd.decode('utf8'), # 输入的cmd命令
shell=True, # 通过shell运行
stderr=subprocess.PIPE, # 把错误输出放入管道，以便打印
stdout=subprocess.PIPE) # 把正确输出放入管道，以便打印

stdout = obj.stdout.read() # 打印正确输出
stderr = obj.stderr.read() # 打印错误输出

conn.send(stdout)
conn.send(stderr)
conn.close()
server.close()

4、模拟ssh远程执行命令

服务端通过subprocess执行该命令,然后返回命令的结果。

服务端：

import socket
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8000))
while True:
data = input('please enter your data')
client.send(data.encode('utf8'))
data = client.recv(1024)
print('from server:', data)
client.close()

客户端

# _*_coding:utf-8_*_
from socket import *
ip_port = ('127.0.0.1', 8080)
TCP_socket_server = socket(AF_INET, SOCK_STREAM)
TCP_socket_server.bind(ip_port)
TCP_socket_server.listen(5)
conn, addr = TCP_socket_server.accept()

data1 = conn.recv(10)
data2 = conn.recv(10)
print('----->', data1.decode('utf-8'))
print('----->', data2.decode('utf-8'))
conn.close()

输入dir命令，由于服务端发送字节少于1024字节，客户端可以接受。

输入tasklist命令，由于服务端发送字节多于1024字节，客户端只接受部分数据，并且当你再次输入dir命令的时候，客户端会接收dir2. 클라이언트

# _*_coding:utf-8_*_
import socket
BUFSIZE = 1024
ip_port = ('127.0.0.1', 8080)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
res = s.connect_ex(ip_port)
s.send('hello'.encode('utf-8'))
s.send('world'.encode('utf-8'))

# 服务端一起收到b'helloworld'

3. 주소 점유 문제

서버가 여전히 주소를 점유하고 있기 때문입니다( 이해가 안가시면 자세히 공부해주세요 1.tcp 3방향 핸드셰이크, 4방향 웨이브 2.syn 플러드 공격 3. 서버 동시성이 높을 때 다수의 time_wait 상태에 대한 최적화 방법)

1. 1: 소켓 구성을 추가하고 IP 및 포트

# _*_coding:utf-8_*_
from socket import *
ip_port = ('127.0.0.1', 8080)
TCP_socket_server = socket(AF_INET, SOCK_STREAM)
TCP_socket_server.bind(ip_port)
TCP_socket_server.listen(5)
conn, addr = TCP_socket_server.accept()
data1 = conn.recv(2) # 一次没有收完整
data2 = conn.recv(10) # 下次收的时候,会先取旧的数据,然后取新的
print('----->', data1.decode('utf-8'))
print('----->', data2.decode('utf-8'))
conn.close()

2 재사용, 방법 2: Linux 커널 매개변수

# _*_coding:utf-8_*_
import socket
BUFSIZE = 1024
ip_port = ('127.0.0.1', 8080)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
res = s.connect_ex(ip_port)
s.send('hello feng'.encode('utf-8'))

4를 조정하여 SSH 원격 실행 명령

서버가 하위 프로세스를 통해 명령을 실행한 후 결과를 반환합니다. 명령의.

Server:

import socket, subprocess
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('127.0.0.1', 8000))
server.listen(5)
while True:
conn, addr = server.accept()
print('start...')
while True:
cmd = conn.recv(1024)
print('cmd:', cmd)
obj = subprocess.Popen(cmd.decode('utf8'),
shell=True,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE)
stdout = obj.stdout.read()
if stdout:
ret = stdout
else:
stderr = obj.stderr.read()
ret = stderr
ret_len = len(ret)
 conn.send(str(ret_len).encode('utf8'))
data = conn.recv(1024).decode('utf8')
if data == 'recv_ready':
conn.sendall(ret)
conn.close()
server.close()

Client

import socket
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8000))
while True:
msg = input('please enter your cmd you want>>>').strip()
if len(msg) == 0: continue
client.send(msg.encode('utf8'))
length = int(client.recv(1024))
client.send('recv_ready'.encode('utf8'))
send_size = 0
recv_size = 0
data = b''
while recv_size < length:
data = client.recv(1024)
recv_size += len(data)
print(data.decode(&#39;utf8&#39;))

dir 명령을 입력하세요. 서버가 1024바이트 미만을 전송하므로 클라이언트가 이를 수락할 수 있습니다.

tasklist 명령을 입력하세요. 서버가 1024바이트보다 많은 바이트를 전송하기 때문에 클라이언트는 데이터의 일부만 수락하며, dir 명령을 다시 입력하면 클라이언트 끝은 dir 명령의 결과를 수신하지만 마지막으로 전송되지 않은 나머지 데이터를 인쇄합니다. 이것은 어려운 문제입니다.

5. 끈적한 패킷

1. 송신자는 버퍼가 가득 찰 때까지 기다려야 보내기 때문에 끈적한 패킷이 발생합니다.

데이터 전송 간격이 매우 짧고 데이터 양이 매우 많습니다. 서로 수렴하여 끈끈한 패킷이 생성됩니다.

Server

import struct
import json
# 'i'是格式
try:
obj = struct.pack('i', 1222222222223)
except Exception as e:
print(e)
obj = struct.pack('i', 1222)
print(obj, len(obj))
# &#39;i&#39; format requires -2147483648 <= number <= 2147483647
# b&#39;\xc6\x04\x00\x00&#39; 4

res = struct.unpack(&#39;i&#39;, obj)
print(res[0])
# 1222

Client

import json
import struct
header_dic = {
'filename': 'a.txt',
'total_size':111111111111111111111111111111111222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222223131232,
'hash': 'asdf123123x123213x'
}
header_json = json.dumps(header_dic)
header_bytes = header_json.encode('utf-8')
print(len(header_bytes))# 223
# 'i'是格式
obj = struct.pack('i', len(header_bytes))
print(obj, len(obj))
# b'\xdf\x00\x00\x00' 4

res = struct.unpack('i', obj)
print(res[0])
# 223

🎜2. 수신자가 버퍼에 있는 패킷을 제때 수신하지 못해 여러 개의 패킷을 수신했습니다.🎜🎜클라이언트는 데이터의 일부를 보냈지만 서버는 일부만 수신했습니다. 다운로드된 서버가 다시 수집할 때 지난 번에 남은 데이터를 여전히 버퍼에서 가져오므로 끈적한 패킷이 발생합니다. 🎜🎜Server🎜

from socket import *
import subprocess
import struct
import json
server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 8000))
server.listen(5)
print('start...')
while True:
conn, client_addr = server.accept()
print(conn, client_addr)
while True:
cmd = conn.recv(1024)
obj = subprocess.Popen(cmd.decode('utf8'),
shell=True,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE)
stderr = obj.stderr.read()
stdout = obj.stdout.read()
# 制作报头
header_dict = {
'filename': 'a.txt',
'total_size': len(stdout) + len(stderr),
'hash': 'xasf123213123'
}
header_json = json.dumps(header_dict)
header_bytes = header_json.encode('utf8')
# 1. 先把报头的长度len(header_bytes)打包成4个bytes，然后发送
conn.send(struct.pack('i', len(header_bytes)))
# 2. 发送报头
 conn.send(header_bytes)
# 3. 发送真实的数据
 conn.send(stdout)
conn.send(stderr)
conn.close()
server.close()

🎜Client🎜

from socket import *
import json
import struct
client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8000))
while True:
cmd = input('please enter your cmd you want>>>')
if len(cmd) == 0: continue
client.send(cmd.encode('utf8'))
# 1. 先收4个字节，这4个字节中包含报头的长度
header_len = struct.unpack('i', client.recv(4))[0]
# 2. 再接收报头
header_bytes = client.recv(header_len)
# 3. 从包头中解析出想要的东西
header_json = header_bytes.decode('utf8')
header_dict = json.loads(header_json)
total_size = header_dict['total_size']
# 4. 再收真实的数据
recv_size = 0
res = b''
while recv_size < total_size:
data = client.recv(1024)
res += data
recv_size += len(data)
print(res.decode(&#39;utf8&#39;))
client.close()

🎜6. 끈적이는 문제 해결🎜🎜1. 먼저 보낸 바이트 스트림의 전체 크기(낮은 버전)🎜🎜문제의 근본 원인은 수신측에서 무엇을 알 수 없다는 것입니다. 송신 측에서는 바이트 스트림의 길이를 전송하므로 끈적한 패킷을 해결하는 방법은 데이터를 보내기 전에 송신자에게 전송할 바이트 스트림의 전체 크기를 알리는 방법에 초점을 맞추는 것입니다. 그런 다음 수신자는 무한한 패킷을 생성합니다. 모든 데이터를 수신하는 루프입니다. 🎜🎜낮은 이유: 프로그램은 네트워크 전송 속도보다 훨씬 빠르게 실행되므로 바이트 세그먼트를 전송하기 전에 send를 사용하여 바이트 스트림 길이를 전송합니다. 이 방법은 네트워크 지연으로 인한 성능 손실을 증폭시킵니다. 🎜🎜서버: 🎜

import socket
server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 数据报协议-》UDP
server.bind(('127.0.0.1', 8080))
while True:
data, client_addr = server.recvfrom(1024)
print('===>', data, client_addr)
server.sendto(data.upper(), client_addr)
server.close()

🎜클라이언트: 🎜

import socket
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8000))
while True:
msg = input('please enter your cmd you want>>>').strip()
if len(msg) == 0: continue
client.send(msg.encode('utf8'))
length = int(client.recv(1024))
client.send('recv_ready'.encode('utf8'))
send_size = 0
recv_size = 0
data = b''
while recv_size < length:
data = client.recv(1024)
recv_size += len(data)
print(data.decode(&#39;utf8&#39;))

2、自定义固定长度报头（struct模块）

struct模块解析

import struct
import json
# 'i'是格式
try:
obj = struct.pack('i', 1222222222223)
except Exception as e:
print(e)
obj = struct.pack('i', 1222)
print(obj, len(obj))
# &#39;i&#39; format requires -2147483648 <= number <= 2147483647
# b&#39;\xc6\x04\x00\x00&#39; 4

res = struct.unpack(&#39;i&#39;, obj)
print(res[0])
# 1222

解决粘包问题的核心就是：为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据。

1、 使用struct模块创建报头：

import json
import struct
header_dic = {
'filename': 'a.txt',
'total_size':111111111111111111111111111111111222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222223131232,
'hash': 'asdf123123x123213x'
}
header_json = json.dumps(header_dic)
header_bytes = header_json.encode('utf-8')
print(len(header_bytes))# 223
# 'i'是格式
obj = struct.pack('i', len(header_bytes))
print(obj, len(obj))
# b'\xdf\x00\x00\x00' 4

res = struct.unpack('i', obj)
print(res[0])
# 223

2、服务端：

from socket import *
import subprocess
import struct
import json
server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 8000))
server.listen(5)
print('start...')
while True:
conn, client_addr = server.accept()
print(conn, client_addr)
while True:
cmd = conn.recv(1024)
obj = subprocess.Popen(cmd.decode('utf8'),
shell=True,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE)
stderr = obj.stderr.read()
stdout = obj.stdout.read()
# 制作报头
header_dict = {
'filename': 'a.txt',
'total_size': len(stdout) + len(stderr),
'hash': 'xasf123213123'
}
header_json = json.dumps(header_dict)
header_bytes = header_json.encode('utf8')
# 1. 先把报头的长度len(header_bytes)打包成4个bytes，然后发送
conn.send(struct.pack('i', len(header_bytes)))
# 2. 发送报头
 conn.send(header_bytes)
# 3. 发送真实的数据
 conn.send(stdout)
conn.send(stderr)
conn.close()
server.close()

3、 客户端：

from socket import *
import json
import struct
client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8000))
while True:
cmd = input('please enter your cmd you want>>>')
if len(cmd) == 0: continue
client.send(cmd.encode('utf8'))
# 1. 先收4个字节，这4个字节中包含报头的长度
header_len = struct.unpack('i', client.recv(4))[0]
# 2. 再接收报头
header_bytes = client.recv(header_len)
# 3. 从包头中解析出想要的东西
header_json = header_bytes.decode('utf8')
header_dict = json.loads(header_json)
total_size = header_dict['total_size']
# 4. 再收真实的数据
recv_size = 0
res = b''
while recv_size < total_size:
data = client.recv(1024)
res += data
recv_size += len(data)
print(res.decode(&#39;utf8&#39;))
client.close()

二、基于UDP协议的socket套接字编程

• UDP是无链接的，先启动哪一端都不会报错，并且可以同时多个客户端去跟服务端通信

• UDP协议是数据报协议，发空的时候也会自带报头，因此客户端输入空，服务端也能收到。

• UPD协议一般不用于传输大数据。

• UPD套接字无粘包问题，但是不能替代TCP套接字，因为UPD协议有一个缺陷：如果数据发送的途中，数据丢失，则数据就丢失了，而TCP协议则不会有这种缺陷，因此一般UPD套接字用户无关紧要的数据发送，例如qq聊天。

UDP套接字简单示例

1、服务端

import socket
server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 数据报协议-》UDP
server.bind(('127.0.0.1', 8080))
while True:
data, client_addr = server.recvfrom(1024)
print('===>', data, client_addr)
server.sendto(data.upper(), client_addr)
server.close()

2、客户端

import socket
client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 数据报协议-》UDP
while True:
msg = input('>>: ').strip() # msg=''
client.sendto(msg.encode('utf-8'), ('127.0.0.1', 8080))
data, server_addr = client.recvfrom(1024)
print(data)
client.close()

三、基于socketserver实现并发的socket编程

1、基于TCP协议

基于tcp的套接字，关键就是两个循环，一个链接循环，一个通信循环

socketserver模块中分两大类：server类（解决链接问题）和request类（解决通信问题）。

1、 server类

2、 request类

基于tcp的socketserver我们自己定义的类中的。

• self.server即套接字对象

• self.request即一个链接

• self.client_address即客户端地址

3、 服务端

import socketserver
class MyHandler(socketserver.BaseRequestHandler):
def handle(self):
# 通信循环
while True:
# print(self.client_address)
# print(self.request) #self.request=conn
try:
data = self.request.recv(1024)
if len(data) == 0: break
self.request.send(data.upper())
except ConnectionResetError:
break
if __name__ == '__main__':
s = socketserver.ThreadingTCPServer(('127.0.0.1', 8080), MyHandler, bind_and_activate=True)
s.serve_forever() # 代表连接循环
# 循环建立连接，每建立一个连接就会启动一个线程（服务员）+调用Myhanlder类产生一个对象，调用该对象下的handle方法，专门与刚刚建立好的连接做通信循环

4、 客户端

import socket
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
phone.connect(('127.0.0.1', 8080)) # 指定服务端ip和端口
while True:
# msg=input('>>: ').strip() #msg=''
msg = 'client33333' # msg=''
if len(msg) == 0: continue
phone.send(msg.encode('utf-8'))
data = phone.recv(1024)
print(data)
phone.close()

2、基于UDP协议

基于udp的socketserver我们自己定义的类中的

• self.request是一个元组（第一个元素是客户端发来的数据，第二部分是服务端的udp套接字对象），如(b'adsf', )

• self.client_address即客户端地址

1、 服务端

import socketserver
class MyHandler(socketserver.BaseRequestHandler):
def handle(self):
# 通信循环
print(self.client_address)
print(self.request)
data = self.request[0]
print('客户消息', data)
self.request[1].sendto(data.upper(), self.client_address)
if __name__ == '__main__':
s = socketserver.ThreadingUDPServer(('127.0.0.1', 8080), MyHandler)
s.serve_forever()

2、 客户端

import socket
client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 数据报协议-》udp
while True:
# msg=input('>>: ').strip() #msg=''
msg = 'client1111'
client.sendto(msg.encode('utf-8'), ('127.0.0.1', 8080))
data, server_addr = client.recvfrom(1024)
print(data)
client.close()

四、Python Internet 模块

以下列出了 Python 网络编程的一些重要模块：

协议	功能用处	端口号	Python 模块
HTTP	网页访问	80	httplib, urllib, xmlrpclib
NNTP	阅读和张贴新闻文章，俗称为"帖子"	119	nntplib
FTP	文件传输	20	ftplib, urllib
SMTP	发送邮件	25	smtplib
POP3	接收邮件	110	poplib
IMAP4	获取邮件	143	imaplib
Telnet	命令行	23	telnetlib
Gopher	信息查找	70	gopherlib, urllib

위 내용은 Python의 소켓 및 소켓 서버를 사용하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!