socket的起源
socket一词的起源
在组网领域的首次使用是在1970年2月12日发布的文献IETF RFC33中发现的，撰写者为Stephen Carr、Steve Crocker和Vint Cerf。根据美国计算机历史博物馆的记载，Croker写道：“命名空间的元素都可称为套接字接口。一个套接字接口构成一个连接的一端，而一个连接可完全由一对套接字接口规定。”计算机历史博物馆补充道：“这比BSD的套接字接口定义早了大约12年。”socket起源于Unix，而Unix/Linux 基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –> 关闭close”模式 来操作。Socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）
套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。
今天，SOCKET接口是TCP/IP网络最为通用的API，也是在INTERNET上进行应用开发最为通用的API。
九十年代初，由Microsoft联合了其他几家公司共同制定了一套 WINDOWS下的网络编程接口，即Windows
Sockets规范。它是Berkeley Sockets的重要扩充，主要是增加了一些异步函数，并增加了符合 Windows 消息驱动特性的网络事件异步选择机制。 WindowsSockets规范是一套开放的、支持多种协议的 Windows下的网络编程接口。目前，在实际应用中的Windows Sockets规范主要有1.1版和2.0版。两者的最重要区别是1.1版只支持TCP/IP协议，而2.0版可以支持多协议，2.0版有良好的向后兼容性，目前，Windows下的Internet软件都是基于 WinSock开发的。
| 参数 | 描述 |
| socket.AF-INET | IPv4（默认） |
| socket.AF_INET6 | IPv6 |
| socket.AF_UNIX | 只能够用于单一的Unix系统进程间通信 |
基于文件类型的套接字家族
套接字家族的名字：AF_UNIX
unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信
基于网络类型的套接字家族
套接字家族的名字：AF_INET
(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)
你想给另一台计算机发消息，你知道他的IP地址，他的机器上同时运行着qq、迅雷、word、浏览器等程序，你想给他的qq发消息，那想一下，你现在只能通过ip找到他的机器，但如果让这台机器知道把消息发给qq程序呢？答案就是通过port,一个机器上可以有0-65535个端口，你的程序想从网络上收发数据，就必须绑定一个端口，这样，远程发到这个端口上的数据，就全会转给这个程序啦
什么是socket
Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部。对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。
所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的
也有人将socket说成ip+port，ip是用来标识互联网中的一台主机的位置，
而port是用来标识这台机器上的一个应用程序，ip地址是配置到网卡上的，
而port是应用程序开启的，ip与port的绑定就标识了互联网中独一无二的一个应用程序
而程序的pid是同一台机器上不同进程或者线程的标识Socket是网络编程的一个抽象概念。通常我们用一个Socket表示“打开了一个网络链接”，而打开一个Socket需要知道目标计算机的IP地址和端口号，再指定协议类型即可。
Socket的英文原意为 “孔” 或者 “ 插座” 。作为BSD UNIX的进程通信机制，通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。
网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。
建立网络通信连接至少要一对端口号(socket)。socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口；HTTP是轿车，提供了封装或者显示数据的具体形式;Socket是发动机，提供了网络通信的能力。
（1）服务器
和客户端编程相比，服务器编程就要复杂一些。
服务器进程首先要绑定一个端口并监听来自其他客户端的连接。如果某个客户端连接过来了，服务器就与该客户端建立Socket连接，随后的通信就靠这个Socket连接了。
所以，服务器会打开固定端口（比如80）监听，每来一个客户端连接，就创建该Socket连接。由于服务器会有大量来自客户端的连接，所以，服务器要能够区分一个Socket连接是和哪个客户端绑定的。一个Socket依赖4项：服务器地址、服务器端口、客户端地址、客户端端口来唯一确定一个Socket。
但是服务器还需要同时响应多个客户端的请求，所以，每个连接都需要一个新的进程或者新的线程来处理，否则，服务器一次就只能服务一个客户端
import socket
#开启ip和端口
ip_port = ('127.0.0.1',9999)
#生成一个句柄
sk = socket.socket()
#绑定ip端口
sk.bind(ip_port)
#最多连接数
sk.listen(5)
#开启死循环
while True:
print ('server waiting...')
#等待链接,阻塞，直到渠道链接 conn打开一个新的对象 专门给当前链接的客户端 addr是ip地址
conn,addr = sk.accept()
#获取客户端请求数据
client_data = conn.recv(1024)
#打印对方的数据
print (str(client_data,'utf8'))
#向对方发送数据
conn.sendall(bytes('不要回答,不要回答,不要回答','utf8'))
#关闭链接
conn.close()（2）客户端
大多数连接都是可靠的TCP连接。创建TCP连接时，主动发起连接的叫客户端，被动响应连接的叫服务器。
举个例子，当我们在浏览器中访问新浪时，我们自己的计算机就是客户端，浏览器会主动向新浪的服务器发起连接。如果一切顺利，新浪的服务器接受了我们的连接，一个TCP连接就建立起来的，后面的通信就是发送网页内容了。
所以，我们要创建一个基于TCP连接的Socket
创建Socket时，AF_INET指定使用IPv4协议，如果要用更先进的IPv6，就指定为AF_INET6。SOCK_STREAM指定使用面向流的TCP协议，这样，一个Socket对象就创建成功，但是还没有建立连接。
客户端要主动发起TCP连接，必须知道服务器的IP地址和端口号。新浪网站的IP地址可以用域名www.sina.com.cn自动转换到IP地址，但是怎么知道新浪服务器的端口号呢？
答案是作为服务器，提供什么样的服务，端口号就必须固定下来。由于我们想要访问网页，因此新浪提供网页服务的服务器必须把端口号固定在80端口，因为80端口是Web服务的标准端口。其他服务都有对应的标准端口号，例如SMTP服务是25端口，FTP服务是21端口，等等。端口号小于1024的是Internet标准服务的端口，端口号大于1024的，可以任意使用。
TCP连接创建的是双向通道，双方都可以同时给对方发数据。但是谁先发谁后发，怎么协调，要根据具体的协议来决定。例如，HTTP协议规定客户端必须先发请求给服务器，服务器收到后才发数据给客户端
import socket
#链接服务端ip和端口
ip_port = ('127.0.0.1',9999)
#生成一个句柄
sk = socket.socket()
#请求连接服务端
sk.connect(ip_port)
#发送数据
sk.sendall(bytes('yaoyao','utf8'))
#接受数据
server_reply = sk.recv(1024)
#打印接受的数据
print (str(server_reply,'utf8'))
#关闭连接
sk.close()（3）小结
用TCP协议进行Socket编程在Python中十分简单，对于客户端，要主动连接服务器的IP和指定端口，对于服务器，要首先监听指定端口，然后，对每一个新的连接，创建一个线程或进程来处理。通常，服务器程序会无限运行下去。
同一个端口，被一个Socket绑定了以后，就不能被别的Socket绑定了。
（4）其他功能
更多功能
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
参数一：地址簇
socket.AF_INET IPv4（默认）
socket.AF_INET6 IPv6
socket.AF_UNIX 只能够用于单一的Unix系统进程间通信
参数二：类型
socket.SOCK_STREAM 流式socket , for TCP （默认）
socket.SOCK_DGRAM 数据报式socket , for UDP
socket.SOCK_RAW 原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而
SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以
通过IP_HDRINCL套接字选项由用户构造IP头。
socket.SOCK_RDM 是一种可靠的UDP形式，即保证交付数据报但不保证顺序。
SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，
如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。
socket.SOCK_SEQPACKET 可靠的连续数据包服务
参数三：协议
0 （默认）与特定的地址家族相关的协议,如果是 0 ，
则系统就会根据地址格式和套接类别,自动选择一个合适的协议SOCKET通信流程
是为实现以上各个协议而建立的一个通信管道，实际上就是代表了客户端与服务器端的一个通信进程，双方都是通过指定的socked进行通信，客户端与服务器端都是通过指定的协议去进行通信的。而socket只能是一种连接模式，它也是完全基于TCP,以及UDP这两个在传输层最基本的协议的。实际上有很多应用层上的协议是完全基于这两个协议的，比如，HTTP协议就是基于TCP协议（TCP协议是可靠的，在发送和接收时都要计算校验和，在传输字节流时是基于三次握手的）的，而socked则可以创建TCP或则UDP的连接，这就说明Socked可以创建任意在应用层上的连接，因为在应用层上的协议完全就是基于UDP与TCP的。
网络编程对所有开发语言都是一样的，Python也不例外。用Python进行网络编程，就是在Python程序本身这个进程内，连接别的服务器进程的通信端口进行通信。
流程如下
1 服务器根据地址类型（ipv4,ipv6）、socket类型、协议创建socket
2 服务器为socket绑定ip地址和端口号
3 服务器socket监听端口号请求，随时准备接收客户端发来的连接，这时候服务器的socket并没有被打开
4 客户端创建socket
5 客户端打开socket，根据服务器ip地址和端口号试图连接服务器socket
6 服务器socket接收到客户端socket请求，被动打开，开始接收客户端请求，直到客户端返回连接信息。这时候socket进入阻塞状态，所谓阻塞即accept()方法一直等到客户端返回连接信息后才返回，开始接收下一个客户端连接请求
7 客户端连接成功，向服务器发送连接状态信息
8 服务器accept方法返回，连接成功
9 客户端向socket写入信息(或服务端向socket写入信息)
10 服务器读取信息(客户端读取信息)
11 客户端关闭
12 服务器端关闭图表示如下：
连接原理（三次握手）
根据连接启动的方法以及本地套接字要连接的目标，套接字之间的连接过程可以分为三个步骤：服务端监听，客户端请求，连接确认。
（1）服务器监听：是服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态。
（2）客户端请求：是指由客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端套接字的地址和端口号，然后就向服务器端套接字提出连接请求。
（3）连接确认：是指当服务器端套接字监听到或者说接收到客户端套接字的连接请求，它就响应客户端套接字的请求，建立一个新的线程，把服务器端套接 字的描述发给客户端，一旦客户端确认了此描述，连接就建立好了。而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。
更加详细的三次握手，四次挥手手请参考一位大佬的博客 https://blog.csdn.net/qzcsu/article/details/72861891
socket套接字相关方法和参数介绍
sk.bind(address) #s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。
sk.listen(backlog) #开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。
#backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
#这个值不能无限大，因为要在内核中维护连接队列
sk.setblocking(bool) #是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。
sk.accept() #接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。
#接收TCP 客户的连接（阻塞式）等待连接的到来
sk.connect(address) #连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。
sk.connect_ex(address) #同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061
sk.close() #关闭套接字
sk.recv(bufsize[,flag]) #接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。
sk.recvfrom(bufsize[.flag])
#与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
sk.send(string[,flag])
#将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。
sk.sendall(string[,flag])
#将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
#内部通过递归调用send，将所有内容发送出去。
sk.sendto(string[,flag],address)
#将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。
sk.settimeout(timeout)
#设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）
sk.getpeername()
#返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
sk.getsockname()
#返回套接字自己的地址。通常是一个元组(ipaddr,port)
sk.fileno() #套接字的文件描述符Socket通信套路
当通过socket建立起2台机器的连接后，本质上socket只干2件事，一是收数据，一是发数据，没数据时就等着。
socket 建立连接的过程跟我们现实中打电话比较像，打电话必须是打电话方和接电话方共同完成的事情，我们分别看看他们是怎么建立起通话的
接电话方：
1.首先你得有个电话 2.你的电话要有号码 3.你的电话必须连上电话线 4.开始在家等电话 5.电话铃响了，接起电话，听到对方的声音
打电话方：
1.首先你得有个电话 2.输入你想拨打的电话 3.等待对方接听 4.say “hi 约么，我有七天酒店的打折卡噢~” 5.等待回应——》响应回应——》等待回应。。。。
把它翻译成socket通信
接电话方(socket服务器端)：
1.首先你得有个电话\(生成socket对象\) 2.你的电话要有号码\(绑定本机ip+port\) 3.你的电话必须连上电话线\(连网\) 4.开始在家等电话\(开始监听电话listen\) 5.电话铃响了，接起电话，听到对方的声音\(接受新连接\)
打电话方(socket客户端)：
1.首先你得有个电话\(生成socket对象\) 2.输入你想拨打的电话\(connect 远程主机ip+port\) 3.等待对方接听 4.say “hi 约么，我有七天酒店的打折卡噢~”\(send\(\) 发消息。。。\) 5.等待回应——》响应回应——》等待回应。。。。
Socket套接字方法
socket实例类
socket.socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None
family(socket家族)
socket.AF_UNIX：用于本机进程间通讯，为了保证程序安全，两个独立的程序(进程)间是不能互相访问彼此的内存的，但为了实现进程间的通讯，可以通过创建一个本地的socket来完成
socket.AF_INET:(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)
socket type类型
socket.SOCK_STREAM #for tcp socket.SOCK_DGRAM #for udp socket.SOCK_RAW #原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文， 而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外， 利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。 socket.SOCK_RDM #是一种可靠的UDP形式，即保证交付数据报但不保证顺序。 SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用， 如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。 socket.SOCK_SEQPACKET #废弃了
(Only SOCK_STREAM and SOCK_DGRAM appear to be generally useful.)
proto=0 请忽略，特殊用途
fileno=None 请忽略，特殊用途
服务端套接字函数
s.bind() 绑定(主机,端口号)到套接字
s.listen() 开始TCP监听
s.accept() 被动接受TCP客户的连接,(阻塞式)等待连接的到来
客户端套接字函数
s.connect() 主动初始化TCP服务器连接
s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
公共用途套接字函数
s.recv() 接收数据 s.send() 发送数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完，可后面通过实例解释) s.sendall() 发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时, 数据不丢失,循环调用send直到发完) s.recvfrom() Receive data from the socket. The return value is a pair (bytes, address) s.getpeername() 连接到当前套接字的远端的地址 s.close() 关闭套接字 socket.setblocking(flag) #True or False,设置socket为非阻塞模式，以后讲io异步时会用 socket.getaddrinfo(host, port, family=0, type=0, proto=0, flags=0) 返回远程主机的地址信息，例子 socket.getaddrinfo('luffycity.com',80) socket.getfqdn() 拿到本机的主机名 socket.gethostbyname() 通过域名解析ip地址
面向锁的套接字方法
s.setblocking() 设置套接字的阻塞与非阻塞模式
s.settimeout() 设置阻塞套接字操作的超时时间
s.gettimeout() 得到阻塞套接字操作的超时时间面向文件的套接字的函数
s.fileno() 套接字的文件描述符
s.makefile() 创建一个与该套接字相关的文件基于TCP的套接字（基于TCP的Socket网络编程）
tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端
tcp服务端
ss = socket() #创建服务器套接字 ss.bind() #把地址绑定到套接字 ss.listen() #监听链接 inf_loop: #服务器无限循环 cs = ss.accept() #接受客户端链接 comm_loop: #通讯循环 cs.recv()/cs.send() #对话(接收与发送) cs.close() #关闭客户端套接字 ss.close() #关闭服务器套接字(可选)
import socket # 将 socket 属性引入到命名空间 HOST = '127.0.0.1' # 这是对 bind()方法的标识表示可以使用任何可用的地址 PORT = 8000 # 端口号 BUFSIZ = 1024 # 缓冲区大小，1kb ADDR = (HOST, PORT) # 地址元组 tcpSerSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 创建 tcp 套接字 tcpSerSocket.bind(ADDR) # 将地址绑定到套接字上 tcpSerSocket.listen(5) # 设置并启动套接字监听 while True: # 无限循环，等待客户端连接 print('waiting for connection...') tcpCliSocket, addr = tcpSerSocket.accept() # 被动接受客户端连接 print('...connected from:', addr) while True: # 对话循环，等待客户端发送消息 try: data = tcpCliSocket.recv(BUFSIZ) # 接收客户端消息 if not data: # 如果消息是空白，跳出对话循环，关闭当前连接 #在linux中 客户端异常关闭 服务器也会收空 print('client closed') tcpCliSocket.close() break #解码 print(data) tcpCliSocket.send(data) # 如果收到消息，将消息原封不动返回客户端 except ConnectionResetError: print('客户端异常关闭！') tcpCliSocket.close() break #关闭资源 tcpSerSocket.close()
tcp客户端
cs = socket() # 创建客户套接字 cs.connect() # 尝试连接服务器 comm_loop: # 通讯循环 cs.send()/cs.recv() # 对话(发送/接收) cs.close() # 关闭客户套接字
import socket HOST = '127.0.0.1' # 服务器的主机名 PORT = 8000 # 端口号 BUFSIZ = 1024 # 缓冲区 ADDR = (HOST, PORT) # 地址元组 tcpCliSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 创建客户端套接字 tcpCliSocket.connect(ADDR) # 连接服务器 while True: # 通信循环 data = input('> ') # 客户端输入信息 if not data: # 如果输入信息为空，则跳出循环，关闭通信 break # if not data:continue #这样可以再次输入,不过这种需要加一个判断才行退出连接，上面直接回车就断开连接了 # data = str.encode(data) #这种写法用到了调用类里面的方法，不推荐 data=data.encode('utf-8') tcpCliSocket.send(data) # 发送客户端信息 msg = tcpCliSocket.recv(BUFSIZ) # 接受服务器返回信息 if not msg: # 如果服务器未返回信息，关闭通信循环 break print('get:', msg.decode('utf-8')) tcpCliSocket.close()
我验证了一下accpet返回的新的套接字对象和客户端用socket产生的套接字对象的id是不相同的，所以在这一点上一定不能混淆
七、基于UDP的套接字
UDP是无链接的，先启动哪一段都不会报错
UDP服务端
ss = socket() #创建一个服务器的套接字 ss.bind() #绑定服务器套接字 inf_loop: #服务器无限循环 cs = ss.recvfrom()/ss.sendto() # 对话(接收与发送) ss.close() # 关闭服务器套接字
UDP客户端
cs = socket() # 创建客户套接字 comm_loop: # 通讯循环 cs.sendto()/cs.recvfrom() # 对话(发送/接收) cs.close() # 关闭客户套接字
简单示例
UDP服务端
import socket ip_port=('127.0.0.1',9000) BUFSIZE=1024 udp_server_client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) udp_server_client.bind(ip_port) while True: msg,addr=udp_server_client.recvfrom(BUFSIZE) print(msg,addr) udp_server_client.sendto(msg.upper(),addr)
UDP客户端
import socket ip_port=('127.0.0.1',9000) BUFSIZE=1024 udp_server_client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) while True: msg=input('>>: ').strip() if not msg:continue udp_server_client.sendto(msg.encode('utf-8'),ip_port) back_msg,addr=udp_server_client.recvfrom(BUFSIZE) print(back_msg.decode('utf-8'),addr)
UDP不会发生粘包现象，下面举例说明
客户端
# _*_ coding: utf-8 _*_ importsocket ip_port =('127.0.0.1',8989) client =socket.socket(socket.AF_INET,socket.SOCK_DGRAM) client.sendto('hello'.encode('utf-8'),ip_port) client.sendto('james'.encode('utf-8'),ip_port) client.close()
服务端
# _*_ coding: utf-8 _*_ importsocket ip_port =('127.0.0.1',8989) server =socket.socket(socket.AF_INET,socket.SOCK_DGRAM) server.bind(ip_port) res1 =server.recvfrom(5) print("res1:",res1) res2 =server.recvfrom(5) print("res2:",res2) server.close()
时间服务器
客户端
# _*_ coding: utf-8 _*_ from socket import * ip_port = ('127.0.0.1',9000) udp_client =socket(AF_INET,SOCK_DGRAM) while True: msg = input("请输入时间格式(例%Y %m %d)>>: ')").strip() udp_client.sendto(msg.encode('utf-8'),ip_port) data = udp_client.recv(1024) print(data.decode('utf-8')) udp_client.close()
服务端
# # _*_ coding: utf-8 _*_ from socket import * from time import strftime ip_port = ('127.0.0.1',9000) udp_server =socket(AF_INET,SOCK_DGRAM) udp_server.bind(ip_port) while True: conn,addr = udp_server.recvfrom(1024) print("conn: ",conn) if not conn: time_fmt ='%Y-%m-%d %X' else: time_fmt = conn.decode('utf-8') back_msg = strftime(time_fmt) udp_server.sendto(back_msg.encode('utf-8'),addr) udp_server.close()
TCP VS UDP
tcp基于链接通信
基于链接，则需要listen（backlog），指定连接池的大小 基于链接，必须先运行的服务端，然后客户端发起链接请求 对于mac系统：如果一端断开了链接，那另外一端的链接也跟着完蛋recv将不会阻塞， 收到的是空(解决方法是：服务端在收消息后加上if判断，空消息就break掉通信循环) 对于windows/linux系统：如果一端断开了链接，那另外一端的链接也跟着完蛋recv将不会阻塞， 收到的是空(解决方法是：服务端通信循环内加异常处理，捕捉到异常后就break掉通讯循环)
udp基于无链接通信
无链接，因而无需listen（backlog），更加没有什么连接池之说了
无链接，udp的sendinto不用管是否有一个正在运行的服务端，可以己端一个劲的发消息，只不过数据丢失
recvfrom收的数据小于sendinto发送的数据时，在mac和linux系统上数据直接丢失，
在windows系统上发送的比接收的大直接报错
只有sendinto发送数据没有recvfrom收数据，数据丢失
粘包现象
只有TCP有粘包现象，UDP永远不会粘包
粘包问题详情
1，只有TCP有粘包现象，UDP永远不会粘包
你的程序实际上无权直接操作网卡的，你操作网卡都是通过操作系统给用户程序暴露出来的接口，那每次你的程序要给远程发数据时，其实是先把数据从用户态copy到内核态，这样的操作是耗资源和时间的，频繁的在内核态和用户态之前交换数据势必会导致发送效率降低， 因此socket 为提高传输效率，发送方往往要收集到足够多的数据后才发送一次数据给对方。若连续几次需要send的数据都很少，通常TCP socket 会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。
首先需要掌握一个socket收发消息的原理
发送端可以是1k，1k的发送数据而接受端的应用程序可以2k，2k的提取数据，当然也有可能是3k或者多k提取数据，也就是说，应用程序是不可见的，因此TCP协议是面来那个流的协议，这也是容易出现粘包的原因而UDP是面向无连接的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任一字节的数据，这一点和TCP是很同的。怎样定义
消息呢？认为对方一次性write/send的数据为一个消息，需要命的是当对方send一条信息的时候，无论鼎城怎么样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。
例如基于TCP的套接字客户端往服务器端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看来更笨不知道文件的字节流从何初开始，在何处结束。 粘包的原因
直接原因
所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的
根本原因
发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。
总结
TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头，实验略
udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠
tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。
两种情况下会发生粘包：
1 发送端需要等到本机的缓冲区满了以后才发出去，造成粘包（发送数据时间间隔很短，数据很小，python使用了优化算法，合在一起，产生粘包）
客户端
#_*_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('feng'.encode('utf-8'))
服务端
#_*_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()
2 接收端不及时接受缓冲区的包，造成多个包接受（客户端发送一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，就产生粘包）
客户端
#_*_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'))
服务端
#_*_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()
粘包实例：
服务端：
服务端 import socket import subprocess din=socket.socket(socket.AF_INET,socket.SOCK_STREAM) ip_port=('127.0.0.1',8080) din.bind(ip_port) din.listen(5) conn,deer=din.accept() data1=conn.recv(1024) data2=conn.recv(1024) print(data1) print(data2)
客户端：
客户端 import socket import subprocess din=socket.socket(socket.AF_INET,socket.SOCK_STREAM) ip_port=('127.0.0.1',8080) din.connect(ip_port) din.send('helloworld'.encode('utf-8')) din.send('sb'.encode('utf-8'))
拆包的发生情况
当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送过去
补充问题一：为何tcp是可靠传输，udp是不可靠传输
关于tcp传输请参考：http://www.cnblogs.com/wj-1314/p/8298025.html
tcp在数据传输时，发送端先把数据发送到自己的缓存中，然后协议控制将缓存中的数据发往对端，对端返回一个ack=1，发送端则清理缓存中的数据，对端返回ack=0，则重新发送数据，所以tcp是可靠的
而udp发送数据，对端是不会返回确认信息的，因此不可靠
补充问题二：send（字节流）和recv(1024）及sendall是什么意思？
recv里指定的1024意思是从缓存里一次拿出1024个字节的数据
send的字节流是先放入己端缓存，然后由协议控制将缓存内容发往对端，如果字节流大小大于缓存剩余空间，那么数据丢失，用sendall就会循环调用send，数据不会丢失。
粘包问题如何解决？
问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据。
简单的解决方法（从表面解决）：
在客户端发送下边添加一个时间睡眠，就可以避免粘包现象。在服务端接收的时候也要进行时间睡眠，才能有效的避免粘包情况。
客户端：
#客户端 import socket import time import subprocess din=socket.socket(socket.AF_INET,socket.SOCK_STREAM) ip_port=('127.0.0.1',8080) din.connect(ip_port) din.send('helloworld'.encode('utf-8')) time.sleep(3) din.send('sb'.encode('utf-8'))
服务端：
#服务端 import socket import time import subprocess din=socket.socket(socket.AF_INET,socket.SOCK_STREAM) ip_port=('127.0.0.1',8080) din.bind(ip_port) din.listen(5) conn,deer=din.accept() data1=conn.recv(1024) time.sleep(4) data2=conn.recv(1024) print(data1) print(data2)
上面解决方法肯定会出现很多纰漏，因为你不知道什么时候传输完，时间暂停的长短都会有问题，长的话效率低，短的话不合适，所以这种方法是不合适的。
普通的解决方法（从根本看问题）：
问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据
为字节流加上自定义固定长度报头，报头中包含字节流长度，然后依次send到对端，对端在接受时，先从缓存中取出定长的报头，然后再取真是数据。
使用struct模块对打包的长度为固定4个字节或者八个字节，struct.pack.format参数是“i”时，只能打包长度为10的数字，那么还可以先将长度转化为json字符串，再打包。
普通的客户端
# _*_ coding: utf-8 _*_ import socket import struct phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.connect(('127.0.0.1',8880)) #连接服 while True: # 发收消息 cmd = input('请你输入命令>>：').strip() if not cmd:continue phone.send(cmd.encode('utf-8')) #发送 #先收报头 header_struct = phone.recv(4) #收四个 unpack_res = struct.unpack('i',header_struct) total_size = unpack_res[0] #总长度 #后收数据 recv_size = 0 total_data=b'' while recv_size<total_size: #循环的收 recv_data = phone.recv(1024) #1024只是一个最大的限制 recv_size+=len(recv_data) # total_data+=recv_data # print('返回的消息：%s'%total_data.decode('gbk')) phone.close()
普通的服务端
# _*_ coding: utf-8 _*_ import socket import subprocess import struct phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机 phone.bind(('127.0.0.1',8880)) #绑定手机卡 phone.listen(5) #阻塞的最大数 print('start runing.....') while True: #链接循环 coon,addr = phone.accept()# 等待接电话 print(coon,addr) while True: #通信循环 # 收发消息 cmd = coon.recv(1024) #接收的最大数 print('接收的是：%s'%cmd.decode('utf-8')) #处理过程 res = subprocess.Popen(cmd.decode('utf-8'),shell = True, stdout=subprocess.PIPE, #标准输出 stderr=subprocess.PIPE #标准错误 ) stdout = res.stdout.read() stderr = res.stderr.read() #先发报头(转成固定长度的bytes类型，那么怎么转呢？就用到了struct模块) #len(stdout) + len(stderr)#统计数据的长度 header = struct.pack('i',len(stdout)+len(stderr))#制作报头 coon.send(header) #再发命令的结果 coon.send(stdout) coon.send(stderr) coon.close() phone.close()
优化版的解决方法（从根本解决问题）
优化的解决粘包问题的思路就是服务端将报头信息进行优化，对要发送的内容用字典进行描述，首先字典不能直接进行网络传输，需要进行序列化转成json格式化字符串，然后转成bytes格式服务端进行发送，因为bytes格式的json字符串长度不是固定的，所以要用struct模块将bytes格式的json字符串长度压缩成固定长度，发送给客户端，客户端进行接受，反解就会得到完整的数据包。
终极版的客户端
# _*_ coding: utf-8 _*_ import socket import struct import json phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.connect(('127.0.0.1',8080)) #连接服务器 while True: # 发收消息 cmd = input('请你输入命令>>：').strip() if not cmd:continue phone.send(cmd.encode('utf-8')) #发送 #先收报头的长度 header_len = struct.unpack('i',phone.recv(4))[0] #吧bytes类型的反解 #在收报头 header_bytes = phone.recv(header_len) #收过来的也是bytes类型 header_json = header_bytes.decode('utf-8') #拿到json格式的字典 header_dic = json.loads(header_json) #反序列化拿到字典了 total_size = header_dic['total_size'] #就拿到数据的总长度了 #最后收数据 recv_size = 0 total_data=b'' while recv_size<total_size: #循环的收 recv_data = phone.recv(1024) #1024只是一个最大的限制 recv_size+=len(recv_data) #有可能接收的不是1024个字节，或许比1024多呢， # 那么接收的时候就接收不全，所以还要加上接收的那个长度 total_data+=recv_data #最终的结果 print('返回的消息：%s'%total_data.decode('gbk')) phone.close()
终极版的服务端
# _*_ coding: utf-8 _*_ import socket import subprocess import struct import json phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) phone.bind(('127.0.0.1',8080)) #绑定手机卡 phone.listen(5) #阻塞的最大数 print('start runing.....') while True: #链接循环 coon,addr = phone.accept()# 等待接电话 print(coon,addr) while True: #通信循环 # 收发消息 cmd = coon.recv(1024) #接收的最大数 print('接收的是：%s'%cmd.decode('utf-8')) #处理过程 res = subprocess.Popen(cmd.decode('utf-8'),shell = True, stdout=subprocess.PIPE, #标准输出 stderr=subprocess.PIPE #标准错误 ) stdout = res.stdout.read() stderr = res.stderr.read() # 制作报头 header_dic = { 'total_size': len(stdout)+len(stderr), # 总共的大小 'filename': None, 'md5': None } header_json = json.dumps(header_dic) #字符串类型 header_bytes = header_json.encode('utf-8') #转成bytes类型(但是长度是可变的) #先发报头的长度 coon.send(struct.pack('i',len(header_bytes))) #发送固定长度的报头 #再发报头 coon.send(header_bytes) #最后发命令的结果 coon.send(stdout) coon.send(stderr) coon.close() phone.close()
struct模块
了解c语言的人，一定会知道struct结构体在c语言中的作用，它定义了一种结构，里面包含不同类型的数据(int,char,bool等等)，方便对某一结构对象进行处理。而在网络通信当中，大多传递的数据是以二进制流（binary data）存在的。当传递字符串时，不必担心太多的问题，而当传递诸如int、char之类的基本数据的时候，就需要有一种机制将某些特定的结构体类型打包成二进制流的字符串然后再网络传输，而接收端也应该可以通过某种机制进行解包还原出原始的结构体数据。python中的struct模块就提供了这样的机制，该模块的主要作用就是对python基本类型值与用python字符串格式表示的C struct类型间的转化（This module performs conversions between Python values and C structs represented as Python strings.）。stuct模块提供了很简单的几个函数，下面写几个例子。
1 基本的pack和unpack
struct提供用format specifier方式对数据进行打包和解包（Packing and Unpacking）。例如:
#该模块可以把一个类型，如数字，转成固定长度的bytes类型 import struct # res = struct.pack('i',12345) # print(res,len(res),type(res)) #长度是4 res2 = struct.pack('i',12345111) print(res2,len(res2),type(res2)) #长度也是4 unpack_res =struct.unpack('i',res2) print(unpack_res) #(12345111,) # print(unpack_res[0]) #12345111
代码中，首先定义了一个元组数据，包含int、string、float三种数据类型，然后定义了struct对象，并制定了format‘I3sf’，I 表示int，3s表示三个字符长度的字符串，f 表示 float。最后通过struct的pack和unpack进行打包和解包。通过输出结果可以发现，value被pack之后，转化为了一段二进制字节串，而unpack可以把该字节串再转换回一个元组，但是值得注意的是对于float的精度发生了改变，这是由一些比如操作系统等客观因素所决定的。打包之后的数据所占用的字节数与C语言中的struct十分相似。
2 定义format可以参照官方api提供的对照表：
3 基本用法
我们可以把报头做成字典，字典里包含将要发送的真实数据的详细信息，然后json序列化，然后用struck将序列化后的数据长度打包成4个字节（4个自己足够用了）
发送时：
先发报头长度
再编码报头内容然后发送
最后发真实内容
接收时：
先手报头长度，用struct取出来
根据取出的长度收取报头内容，然后解码，反序列化
从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容
小练习：
编写C/S架构的程序，实现远程执行命令，思路如下
1、客户端接收用户输入的命令，然后发送给服务端，
2、服务端根据传来的数据调用subprocess模块执行系统命令，然后将结果返回给客户端，在客户端打印
# 1.服务器先启动 -> 客户端发送指令 -> 服务器接收后使用subprocess执行命令->将执行结果返回给客户端 import socket,subprocess # 使用TCP 可以直接默认 server = socket.socket() # 指定端口 和 ip 端口 0 - 1023是系统保留的 server.bind(("127.0.0.1",65535)) # 监听请求 参数为最大半连接数(三次握手未完成的请求 可能是服务器来不及 客户端恶意攻击) server.listen(5) # 为了可以不断的接受客户端连接请求 while True: # 接受连接请求 c,addr = server.accept() print('>>>>>>>',id(c)) # 为了可以重复收发数据 while True: try: # 1024 程序的最大缓冲区容量 返回值类型为bytes类型 cmd = c.recv(1024).decode("utf-8") # 如果客户端断开连接(客户端调用了close) recv 返回值为kong 此时应该结束循环 if not cmd:# 在linux中 客户端异常关闭 服务器也会收空 print("client closed!") c.close() break #解码 print(cmd) # 执行命令 p = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE) # 将错误信息和正确信息拼接到一起 res = p.stdout.read() + p.stderr.read() print("执行结果长",len(res)) # 将执行结果发送给客户端 c.send(res) except ConnectionResetError: print("客户端异常关闭!!") c.close() break # 关闭资源 server.close() # TCP断开连接的正确姿势 # 客户端调用close # 服务器判断如果接收数据为空则相应的调用close
import socket c = socket.socket() print(id(c)) # 连接服务器 c.connect(("127.0.0.1", 65535)) while True: # 发送数据 msg = input(">>>:") if not msg: continue c.send(msg.encode("utf-8")) # while True: # # 收数据 data = c.recv(1024).decode("gbk") print(data) # 关闭资源 c.close()
FTP作业：上传下载文件
import socket import struct import json import subprocess import os class MYTCPServer: address_family = socket.AF_INET socket_type = socket.SOCK_STREAM allow_reuse_address = False max_packet_size = 8192 coding='utf-8' request_queue_size = 5 server_dir='file_upload' def __init__(self, server_address, bind_and_activate=True): """Constructor. May be extended, do not override.""" self.server_address=server_address self.socket = socket.socket(self.address_family, self.socket_type) if bind_and_activate: try: self.server_bind() self.server_activate() except: self.server_close() raise def server_bind(self): """Called by constructor to bind the socket. """ if self.allow_reuse_address: self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.socket.bind(self.server_address) self.server_address = self.socket.getsockname() def server_activate(self): """Called by constructor to activate the server. """ self.socket.listen(self.request_queue_size) def server_close(self): """Called to clean-up the server. """ self.socket.close() def get_request(self): """Get the request and client address from the socket. """ return self.socket.accept() def close_request(self, request): """Called to clean up an individual request.""" request.close() def run(self): while True: self.conn,self.client_addr=self.get_request() print('from client ',self.client_addr) while True: try: head_struct = self.conn.recv(4) if not head_struct:break head_len = struct.unpack('i', head_struct)[0] head_json = self.conn.recv(head_len).decode(self.coding) head_dic = json.loads(head_json) print(head_dic) #head_dic={'cmd':'put','filename':'a.txt','filesize':123123} cmd=head_dic['cmd'] if hasattr(self,cmd): func=getattr(self,cmd) func(head_dic) except Exception: break def put(self,args): file_path=os.path.normpath(os.path.join( self.server_dir, args['filename'] )) filesize=args['filesize'] recv_size=0 print('----->',file_path) with open(file_path,'wb') as f: while recv_size < filesize: recv_data=self.conn.recv(self.max_packet_size) f.write(recv_data) recv_size+=len(recv_data) print('recvsize:%s filesize:%s' %(recv_size,filesize)) tcpserver1=MYTCPServer(('127.0.0.1',8080)) tcpserver1.run() #下列代码与本题无关 class MYUDPServer: """UDP server class.""" address_family = socket.AF_INET socket_type = socket.SOCK_DGRAM allow_reuse_address = False max_packet_size = 8192 coding='utf-8' def get_request(self): data, client_addr = self.socket.recvfrom(self.max_packet_size) return (data, self.socket), client_addr def server_activate(self): # No need to call listen() for UDP. pass def shutdown_request(self, request): # No need to shutdown anything. self.close_request(request) def close_request(self, request): # No need to close anything. pass
import socket import struct import json import os class MYTCPClient: address_family = socket.AF_INET socket_type = socket.SOCK_STREAM allow_reuse_address = False max_packet_size = 8192 coding='utf-8' request_queue_size = 5 def __init__(self, server_address, connect=True): self.server_address=server_address self.socket = socket.socket(self.address_family, self.socket_type) if connect: try: self.client_connect() except: self.client_close() raise def client_connect(self): self.socket.connect(self.server_address) def client_close(self): self.socket.close() def run(self): while True: inp=input(">>: ").strip() if not inp:continue l=inp.split() cmd=l[0] if hasattr(self,cmd): func=getattr(self,cmd) func(l) def put(self,args): cmd=args[0] filename=args[1] if not os.path.isfile(filename): print('file:%s is not exists' %filename) return else: filesize=os.path.getsize(filename) head_dic={'cmd':cmd,'filename':os.path.basename(filename),'filesize':filesize} print(head_dic) head_json=json.dumps(head_dic) head_json_bytes=bytes(head_json,encoding=self.coding) head_struct=struct.pack('i',len(head_json_bytes)) self.socket.send(head_struct) self.socket.send(head_json_bytes) send_size=0 with open(filename,'rb') as f: for line in f: self.socket.send(line) send_size+=len(line) print(send_size) else: print('upload successful') client=MYTCPClient(('127.0.0.1',8080)) client.run()
扫一扫
12万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
