Python网络（socket）编程
一 C/S、B/S架构简述
C/S 架构即“客户端-服务器” 架构（C = Client, S = Server）。这里的“客户端”可以是有 GUI （图形用户界面）的定制软件，也可以是浏览器，甚至可以是通过 SSH 访问服务器的命令行脚本。只要是客户端通过访问服务器调取计算或者存储资源的，统统都是 C/S 架构。所谓的B/S（ Browser-Server） 架构其实是 C/S 架构的一种特殊的实现形式，而不是其对立面。
C/S架构服务器特点：
- 持续提供服务
- 绑定一个唯一的地址（IP+port）
C/S架构与socket的关系：
学习socket主要是为了完成C/S架构的开发
二 互联网协议
我们知道一台完整的计算机系统是由硬件、操作系统、应用软件三者组成，具备了这三个条件，一台计算机系统就可以自己跟自己玩了（比如：单机游戏）。但如果需要和别人一起玩，就必须进行联网。
何为互联网？
互联网的核心就是由一堆协议组成，协议就是标准，比如全世界人通信的标准是讲英语。
为何学习socket一定要学习互联网协议？
- 基于socket的编程，主要是为了开发一款自己的C/S架构软件
- C/S架构的软件（软件属于应用层）是基于网络进行通信的
- 网络的核心即一堆协议（标准），你想开发一款基于网络通信的软件，就必须遵循这些标准
总结：想要学习socket的编程，就必须掌握互联网协议。
如需了解详细互联网协议，请参考另外一篇文章：计算机基础之互联网协议
三 什么是socket
socket是应用层与TCP/IP协议族通信的中间软件抽象层(如下图所示），它是一组接口。在设计模式中，socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在socket接口后面，对用户来说，一组简单的接口就是全部，让socket去组织数据，以符合指定的协议。所以，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循TCP/UDP标准。
socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。
其他理解：
也有人将socket说成ip+port（端口），ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序，ip地址是配置到网卡上的，而port是应用程序开启的，ip与port的绑定就标识了互联网中独一无二的一个应用程序，而程序的pid是同一台机器上不同进程或者线程的标识。
四 套接字的发展史和分类
套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix，即人们所说的 BSD Unix。因此，有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始，套接字被设计用在同 一台主机上多个应用程序之间的通讯，这也被称进程间通讯或 IPC。套接字有两种（或者称为有两个种族），分别是基于文件型的和基于网络型的。
基于文件类型的套接字家族（AF_UNIX）
unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信。
基于网络类型的套接字家族（AF_INET）
还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET。
五 套接字的工作流程
先从服务器端说起。服务器端先初始化socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束。
六 socket模块
import socket # socket.socket(socket_family, socket_type, protocal=0) # socket_family 可以是 AF_UNIX 或 AF_INET（默认）；socket_type可以是SOCK_STREAM（TCP，默认）或 SOCK_DGRAM（UDP）。protocol 一般不填,默认值为0。 # 获取TCP/IP套接字 # tcp_socket = socket.socket() tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 获取UDP/IP套接字 udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 为了简便，我们可以采用from socket import *，例如： from socket import * tcp_socket = socket(AF_INET, SOCK_STREAM)
s.bind() 绑定(主机,端口号)到套接字 s.listen() 开始TCP监听 s.accept() 被动接受TCP客户的连接,(阻塞式)等待连接的到来
s.connect() 主动初始化TCP服务器连接 s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
s.recv() 接收TCP数据
s.send() 发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完)
s.sendall() 发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)
s.recvfrom() 接收UDP数据
s.sendto() 发送UDP数据
s.getpeername() 连接到当前套接字的远端的地址
s.getsockname() 当前套接字的地址
s.getsockopt() 返回指定套接字的参数
s.setsockopt() 设置指定套接字的参数
s.close() 关闭套接字
s.setblocking() 设置套接字的阻塞与非阻塞模式 s.settimeout() 设置阻塞套接字操作的超时时间 s.gettimeout() 得到阻塞套接字操作的超时时间
s.fileno() 套接字的文件描述符 s.makefile() 创建一个与该套接字相关的文件
注意：以上s代表套接字对象
七 基于TCP的套接字
TCP是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端，话不多说，下面我们创建一组基于TCP的服务端、客户端。
import socket tcp_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 创建TCP套接字对象 tcp_server.bind(('127.0.0.1',8080)) # 绑定ip+port tcp_server.listen(5) # 监听，5代表的是最多挂起5个，可以自定义 conn,addr = tcp_server.accept() # 等待连接 recv_data = conn.recv(1024) # 接收消息，1024为收数据大小 print(recv_data.decode('utf8')) # 打印消息 conn.send('已收到消息'.encode('utf8')) # 发送消息 conn.close() # 关闭此次连接 tcp_server.close() # 关闭套接字对象
import socket tcp_client = socket.socket() # 创建TCP套接字对象 tcp_client.connect(("127.0.0.1", 8080)) # 连接服务端ip+port send_data = input(">>:") # 客户端输入发送消息内容 tcp_client.send(send_data.encode("utf-8")) # 发送消息 recv_data = tcp_client.recv(1024) # 接收服务端消息，1024为收数据大小 print(recv_data.decode("utf-8")) # 打印消息 tcp_client.close() # 关闭
import socket ip_port = ("127.0.0.1", 8080) # 自定义ip+port buf_size = 1024 # 自定义接受数据大小 tcp_socket = socket.socket() # 创建TCP套接字对象 tcp_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) # 加入此行 tcp_socket.bind(ip_port) # 绑定ip+port tcp_socket.listen(5) # 监听，5代表的是最多挂起5个，可以自定义 while True: # 链接循环 conn,addr = tcp_socket.accept() # 等待连接 # print(conn) # <socket.socket fd=560, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, # laddr=('127.0.0.1', 8080), raddr=('127.0.0.1', 52889)> # print(addr) # ('127.0.0.1', 52889) print('接到来自%s的连接' %addr[0]) while True: # 通信循环 try: # 针对win的异常处理，如果不进行try...except，则会报错，因为我们不知道客户端什么时候会断开 recv_data = conn.recv(buf_size) # 接收消息，1024为收数据大小 # if len(recv_data) == 0: break # 针对Linux，如果不加，那么正在链接的客户端突然断开，recv便不再阻塞，死循环发生 print(recv_data.decode('utf8')) # 打印消息 send_data = input(">>:") # 输入服务端发送消息内容 conn.send(send_data.encode('utf8')) # 发送消息 except Exception: break conn.close() # 关闭此次连接 tcp_socket.close() # 关闭套接字对象
import socket ip_port = ("127.0.0.1", 8080) # 自定义ip+port buf_size = 1024 # 自定义接受数据大小 tcp_client = socket.socket() # 创建TCP套接字对象 tcp_client.connect(ip_port) # 连接服务端 while True: send_data = input(">>:").strip() # 客户端输入发送消息内容 if len(send_data) == 0: continue # 发送消息为空，则返回继续发送 tcp_client.send(send_data.encode("utf-8")) # 发送消息 recv_data = tcp_client.recv(buf_size) # 接收服务端消息 print(recv_data.decode("utf-8")) # 打印消息 tcp_client.close() # 关闭
改进版主要加入链接循环和通讯循环
注意点：在重启服务端时可能会遇到以下错误信息：
OSError: [WinError 10048] 通常每个套接字地址(协议/网络地址/端口)只允许使用一次。
这是因为服务端仍然存在四次挥手的time_wait状态在占用地址，这时我们可以这样处理：
tcp_server = socket.socket() # 创建TCP套接字对象 tcp_server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) # 加入此行 tcp_server.bind(ip_port) # 绑定ip+port
实例应用--基于TCP协议模拟ssh远程执行命令
import socket import subprocess ip_port = ("127.0.0.1", 8080) buf_size = 1024 ssh_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM) ssh_server.bind(ip_port) ssh_server.listen(5) print('starting....') while True: conn,addr = ssh_server.accept() print('接到来自%s的连接' %addr[0]) while True: try: cmd = conn.recv(buf_size) if not cmd :break print('接收的指令是：%s' %cmd.decode('utf-8')) # 处理过程，Popen是执行命令的方法 ret = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE ) stdout = ret.stdout.read() stuerr = ret.stderr.read() conn.send(stdout+stuerr) except Exception: break conn.close() ssh_server.close()
import socket ip_port = ("127.0.0.1", 8080) buf_size = 1024 ssh_client = socket.socket(socket.AF_INET,socket.SOCK_STREAM) ssh_client.connect(ip_port) while True: cmd = input('请输入需要执行的指令:>>').strip() if not cmd: continue ssh_client.send(cmd.encode('utf-8')) recv_data = ssh_client.recv(1024) print(recv_data.decode('gbk')) # linux则为utf8 tcp_client.close()
八 基于UDP的套接字
UDP是无链接的，先启动哪一端都不会报错。发送数据用sendto()；接收数据用recvfrom()。
import socket ip_port = ("127.0.0.1", 8080) buf_size = 1024 udp_server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) udp_server.bind(ip_port) print('starting....') while True: # 服务器通讯循环 msg, addr = udp_server.recvfrom(buf_size) # 接受信息，元组（信息，ip+port） print(msg.decode('utf-8')) # print(addr) # ip+port ('127.0.0.1', 62570) send_msg = input('>>:') udp_server.sendto(send_msg.encode('utf8'),addr) # 发送信息，元组（信息，ip+port） udp_server.close() # 关闭服务器套接字
import socket ip_port = ("127.0.0.1", 8080) buf_size = 1024 udp_client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 创建客户端套接字 while True: # 通信循环 send_msg = input('>>:').strip() if not send_msg: continue udp_client.sendto(send_msg.encode('utf-8'),ip_port) # 发消息 recv_msg,addr = udp_client.recvfrom(buf_size) # 收消息 print(recv_msg.decode('utf-8')) # linux则为utf8 udp_client.close() # 关闭客户端套接字
实例应用--模拟聊天软件
import socket ip_port = ("127.0.0.1", 8080) buf_size = 1024 udp_server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) udp_server.bind(ip_port) while True: recv_msg, addr = udp_server.recvfrom(buf_size) print('来自[%s:%s]的一条消息:%s' % (addr[0], addr[1], recv_msg.decode('utf-8'))) send_msg = input('请输入回复消息，回车发送：>>').strip() if not send_msg: continue udp_server.sendto(send_msg.encode('utf8'),addr) udp_socket.close()
import socket ip_port = ("127.0.0.1", 8080) buf_size = 1024 udp_client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 创建客户端套接字 chat_obj_dic = {'张三': ('127.0.0.1', 8080), '李四': ('127.0.0.1', 8080), '王五': ('127.0.0.1', 8080), } while True: print('可供聊天对象如下：%s' %chat_obj_dic) chat_obj = input('请输入聊天对象或’q‘退出：>>').strip() if chat_obj == 'q' or chat_obj == 'Q': break if chat_obj not in chat_obj_dic or not chat_obj: print('输入对象不在对象列表中，请重新输入！') continue while True: send_msg = input('请输入消息，回车发送：>>').strip() if send_msg == 'q' or send_msg == 'Q': break if not send_msg: continue udp_client.sendto(send_msg.encode('utf-8'),chat_obj_dic[chat_obj]) recv_msg,addr = udp_client.recvfrom(buf_size) print('来自[%s:%s]的一条消息:%s' % (addr[0], addr[1], recv_msg.decode('utf-8'))) udp_client.close()
因为udp无连接，所以可以同时多个客户端去跟服务端通信，如下：
九 其他补充
9.1 TCP/UDP的不同点
- TCP是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住。而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，UDP协议会帮你封装上消息头
- TCP的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包
- UDP的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y)，收完了x个字节的数据就算完成，若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠
9.2 为什么TCP是可靠传输，而UDP是不可靠传输
TCP在数据传输时，发送端先把数据发送到自己的缓存中，然后协议控制将缓存中的数据发往对端，对端返回一个ack=1，发送端则清理缓存中的数据，对端返回ack=0，则重新发送数据，所以TCP是可靠的，而UDP发送数据，对端是不会返回确认信息的，因此不可靠
9.3 recv(1024)、send(字节流)及sendall
recv里指定的1024意思是从缓存里一次拿出1024个字节的数据
send的字节流是先放入己端缓存，然后由协议控制将缓存内容发往对端，如果待发送的字节流大小大于缓存剩余空间，那么数据丢失
sendall会循环调用send，数据不会丢失
参考：http://www.cnblogs.com/linhaifeng/articles/6129246.html#_label1
浙公网安备 33010602011771号