python - 网络编程

发布时间：2020-12-17 00:02:39 所属栏目：Python 来源：网络整理

导读：一,引入你现在已经学会了写python代码，假如你写了两个python文件a.py和b.py，分别去运行，你就会发现，这两个python的文件分别运行的很好。但是如果这两个程序之间想要传递一个数据，你要怎么做呢？这个问题以你现在的知识就可以解决了，我们可以创建一个

一,引入

你现在已经学会了写python代码，假如你写了两个python文件a.py和b.py，分别去运行，你就会发现，这两个python的文件分别运行的很好。但是如果这两个程序之间想要传递一个数据，你要怎么做呢？

这个问题以你现在的知识就可以解决了，我们可以创建一个文件，把a.py想要传递的内容写到文件中，然后b.py从这个文件中读取内容就可以了。

但是当你的a.py和b.py分别在不同电脑上的时候，你要怎么办呢？

类似的机制有计算机网盘，qq等等。我们可以在我们的电脑上和别人聊天，可以在自己的电脑上向网盘中上传、下载内容。这些都是两个程序在通信。

二,软件开发的架构

我们了解的涉及到两个程序之间通讯的应用大致可以分为两种：

第一种是应用类：qq、微信、网盘、优酷这一类是属于需要安装的桌面应用

第二种是web类：比如百度、知乎、博客园等使用浏览器访问就可以直接使用的应用

这些应用的本质其实都是两个程序之间的通讯。而这两个分类又对应了两个软件开发的架构～

1,C/S 架构

C/S即：Client与Server ，中文意思：客户端与服务器端架构，这种架构也是从用户层面（也可以是物理层面）来划分的。

这里的客户端一般泛指客户端应用程序EXE，程序需要先安装后，才能运行在用户的电脑上，对用户的电脑操作系统环境依赖较大。

?2,B/S 架构

B/S即：Browser与Server,中文意思：浏览器端与服务器端架构，这种架构是从用户层面来划分的。

Browser浏览器，其实也是一种Client客户端，只是这个客户端不需要大家去安装什么应用程序，只需在浏览器上通过HTTP请求服务器端相关的资源（网页资源），客户端Browser浏览器就能进行增删改查。

三,网络基础

1,一个程序如何在网络上找到另一个程序?

首先，程序必须要启动，其次，必须有这台机器的地址，我们都知道我们人的地址大概就是国家省市区街道楼门牌号这样字。那么每一台联网的机器在网络上也有自己的地址，它的地址是怎么表示的呢？

就是使用一串数字来表示的，例如：100.4.5.6

IP地址是指互联网协议地址（英语：Internet Protocol Address，又译为网际协议地址），是IP Address的缩写。IP地址是IP协议提供的一种统一的地址格式，它为互联网上的每一个网络和每一台主机分配一个逻辑地址，以此来屏蔽物理地址的差异。

IP地址是一个32位的二进制数，通常被分割为4个“8位二进制数”（也就是4个字节）。IP地址通常用“点分十进制”表示成（a.b.c.d）的形式，其中，a,b,c,d都是0~255之间的十进制整数。例：点分十进IP地址（100.4.5.6），实际上是32位二进制数（01100100.00000100.00000101.00000110）。

什么是端口?

"端口"是英文port的意译，可以认为是设备与外界通讯交流的出口。

因此ip地址精确到具体的一台电脑，而端口精确到具体的程序。

2,osi七层模型

人们按照分工不同把互联网协议从逻辑上划分了层级:

<div class="cnblogs_code" onclick="cnblogs_code_show('69714ff2-47cb-449b-8f8a-b408d0f95f83')">
<img id="code_img_closed_69714ff2-47cb-449b-8f8a-b408d0f95f83" class="code_img_closed" src="https://www.52php.cn/res/2019/02-14/22/1c53668bcee393edac0d7b3b3daff1ae.gif" alt=""><img id="code_img_opened_69714ff2-47cb-449b-8f8a-b408d0f95f83" class="code_img_opened" style="display: none;" onclick="cnblogs_code_hide('69714ff2-47cb-449b-8f8a-b408d0f95f83',event)" src="https://www.52php.cn/res/2019/02-14/22/405b18b4b6584ae338e0f6ecaf736533.gif" alt=""><div id="cnblogs_code_open_69714ff2-47cb-449b-8f8a-b408d0f95f83" class="cnblogs_code_hide">

一,面向连接的传输服务 —-1,传输特征：
可靠的数据传输
可靠性指数据传输中无失序无差错无丢失无重复
所有消息传输前一定会建立连接，传输后一定会断开连接

2,三次握手：在进行面向连接的数据传输前进行传输连接的过程
客户端向服务器发送连接请求（问是否可以连接）
服务器接收到连接请求进行确认，返回报文
客户端收到回复，进行连接建立

3,四次挥手：在进行面向连接的数据传输时，断开连接的过程
主动方发送报文告知被动方要断开连接
被动方返回报文，告知收到请求，准备断开
被动方再次发送报文给主动方，告知准备完毕可以断开
主动方发送报文进行断开

4,应用情况：适用于传输较大的内容或文件，网络情况良好，需要保证传输可靠性的情况
比如：聊天信息，文件的上传下载，邮件传输,网页获取

二,面向无连接的传输服务 —》 udp协议

三,传输特点：

1,不保证可靠的数据传输
2,没有连接过程
3,数据的收发都比较自由，不会受另一端制约
4,适用情况：网络情况较差，对传输可靠情形要求不高。需要提升传输效率的情况
比如：网络视频，群聊，发送广播

3,socket 概念

socket层

理解socket

Socket是应用层与

+

4,套接字 (socket) 的发展史

起源 :?套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。?

基于文件类型的套接字家族

套接字家族的名字：AF_UNIX

unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信

基于网络类型的套接字家族

套接字家族的名字：AF_INET

(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)

?5,tcp协议和udp协议

TCP（Transmission Control Protocol）可靠的、面向连接的协议（eg:打电话）、传输效率低全双工通信（发送缓存&接收缓存）、面向字节流。使用TCP的应用：Web浏览器；电子邮件、文件传输程序。

UDP（User Datagram Protocol）不可靠的、无连接的服务，传输效率高（发送前时延小），一对一、一对多、多对一、多对多、面向报文，尽最大努力服务，无拥塞控制。使用UDP的应用：域名系统?(DNS)；视频流；IP语音(VoIP)。

先上个图:

<div class="cnblogs_code" onclick="cnblogs_code_show('6efe2f13-ab2f-4f7d-a0f9-52509a070b9b')">
<img id="code_img_closed_6efe2f13-ab2f-4f7d-a0f9-52509a070b9b" class="code_img_closed" src="https://www.52php.cn/res/2019/02-14/22/1c53668bcee393edac0d7b3b3daff1ae.gif" alt=""><img id="code_img_opened_6efe2f13-ab2f-4f7d-a0f9-52509a070b9b" class="code_img_opened" style="display: none;" onclick="cnblogs_code_hide('6efe2f13-ab2f-4f7d-a0f9-52509a070b9b',event)" src="https://www.52php.cn/res/2019/02-14/22/405b18b4b6584ae338e0f6ecaf736533.gif" alt=""><div id="cnblogs_code_open_6efe2f13-ab2f-4f7d-a0f9-52509a070b9b" class="cnblogs_code_hide">

1234,绑定地址（IP 端口号）

1,格式： sockfd.bind() 2,功能：绑定地址 3,参数：一个元组包含两项第一项为IP第二项为端口号（’172.60.50.50’,8888）

5,将套接字设置可监听

格式：sockfd.listen(n) 功能：将套接字设置为监听套接字参数： n是一个正整数表示监听等待队列的大小

6,等待接收连接请求

格式：connfd,addr = sockfd.accept() 功能：阻塞等待处理客户端连接返回值：第一个：一个新的套接字用来和客户端通信第二个：连接的客户端的地址阻塞函数：程序运行到阻塞函数的位置，如果某种期待条件没有达成则暂停继续运行。当条件达成后会结束阻塞继续运行。

7,收发消息

收消息格式：data = connfd.recv(buffersize) 功能：流式套接字接收消息参数：一次最多接收多大的消息字节返回值：返回接收到的内容发消息格式：n = connfd.send(data) 功能：流式套接字发送消息参数：要发送的内容要求bytes格式返回值：返回实际发送的字节数

8,关闭套接字

格式：close（）功能：关闭套接字 tcp套接字连接断开 </pre>

12格式： connect() 功能：发起连接请求参数：是一个元组，表示服务器的地址

3,消息收发
recv() send()

4,关闭套接字
close()
5,recv() 特性
如果连接双方断开连接，则recv会立即结束阻塞返回空字符串
当接收缓冲区为空的时候会阻塞
如果recv一次接收不完缓存去内容，下一次会继续接收
6,send（）特性
如果一段不存在，另一端还在试图send操作时会产生BrokenPipeError异常
当发送缓冲区慢的时候会阻塞
7,网络收发缓冲区
发送和接收消息均先放到缓冲区中，在进行处理
即 recv和send实际是从缓冲区接收内容，向缓冲区发送消息

四,套接字 (socket) 初使用

1,基于TCP协议的socket

tcp是基于链接的,必须先启动服务端,然后再启动客户端去链接服务端

=,8898)) sk.listen() conn,addr = sk.accept() ret = conn.recv(1024) (ret) conn.send(b) conn.close() sk.close()

= socket.socket() sk.connect((,8898)) sk.send(b= sk.recv(1024)

问题 : 有的人在重启服务端时可能会遇到

OSError: [WinError 10048] 通常每个套接字地址(协议/网络地址/端口)只允许使用一次。

socket =1) sk.bind((,addr = sk.accept() ret = conn.recv(1024) (ret) conn.send(b) conn.close() sk.close()

2,基于UDP协议的socket

udp是无链接的,启动服务之后可以直接接收消息,不需要提前建立链接

1,简单使用

= socket.socket(type=socket.SOCK_DGRAM) udp_sk.bind((,9000)) msg,addr = udp_sk.recvfrom(1024,addr) udp_sk.close()

=(,9000=socket.socket(type==udp_sk.recvfrom(1024(back_msg.decode(),addr)

2,QQ聊天

=(,8081=socket.socket(type =while True:
qq_msg,addr=udp_server_sock.recvfrom(1024)
print('来自[%s:%s]的一条消息:33[1;44m%s33[0m' %(addr[0],addr[1],qq_msg.decode('utf-8')))
back_msg=input('回复消息: ').strip()

udp_server_sock.sendto(back_msg.encode('utf-8'),addr)</pre>

=1024=socket.socket(type =qq_name_dic={
'悟空':('127.0.0.1',8081),'哪吒':('127.0.0.1','八戒':('127.0.0.1','沙僧':('127.0.0.1',}

while True:
qq_name=input('请选择聊天对象: ').strip()
while True:
msg=input('请输入消息,回车发送,输入q结束和他的聊天: ').strip()
if msg == 'q':break
if not msg or not qq_name or qq_name not in qq_name_dic:continue
udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])

back_msg,addr=udp_client_socket.recvfrom(BUFSIZE) print('来自[%s:%s]的一条消息:33[1;44m%s33[0m' %(addr[0],back_msg.decode('utf-8')))

udp_client_socket.close()

3,时间服务器

socket * time ip_port = ('127.0.0.1',9000)
bufsize = 1024

tcp_server = socket(AF_INET,SOCK_DGRAM)
tcp_server.setsockopt(SOL_SOCKET,1)
tcp_server.bind(ip_port)

while True:
msg,addr = tcp_server.recvfrom(bufsize)
print('===>',msg)

if not msg: time_fmt = '%Y-%m-%d %X' else: time_fmt = msg.decode('utf-8') back_msg = strftime(time_fmt) tcp_server.sendto(back_msg.encode('utf-8'),addr)

tcp_server.close()

socket *=(,9000=1024tcp_client=socket(AF_INET,SOCK_DGRAM)

while True:
msg=input('请输入时间格式(例%Y %m %d)>>: ').strip()
tcp_client.sendto(msg.encode('utf-8'),ip_port)

data=tcp_client.recv(bufsize)</pre>

3,socket 参数的详解

socket.socket(family=AF_INET,type=SOCK_STREAM,proto=0,fileno=None)

创建socket对象的参数说明 :
family</tr>
<tr>
<td>type</td>
<td>
套接字类型应为SOCK_STREAM(默认值),SOCK_DGRAM,SOCK_RAW或其他SOCK_常量之一。SOCK_STREAM?是基于TCP的，有保障的（即能保证数据正确传送到对方）面向连接的SOCKET，多用于资料传送。?SOCK_DGRAM?是基于UDP的，无保障的面向消息的socket，多用于在网络上发广播信息。</td>

</tr>
<tr>
<td>proto</td>
<td>协议号通常为零,可以省略,或者在地址族为AF_CAN的情况下,协议应为CAN_RAW或CAN_BCM之一。</td>

</tr>
<tr>
<td>fileno</td>
<td>如果指定了fileno,则其他参数将被忽略,导致带有指定文件描述符的套接字返回。与socket.fromfd()不同,fileno将返回相同的套接字,而不是重复的。这可能有助于使用socket.close()关闭一个独立的插座。<pre data-source-line="11">
</td>
</tr>
五,黏包
1,黏包现象

让我们基于tcp先制作一个远程执行命令的程序（命令ls -l ; lllllll ; pwd）

res=subprocess.Popen(cmd.decode(===的结果的编码是以当前所在的系统为准的，如果是windows，那么res.stdout.read()读出的就是GBK编码的，在接收端需要用GBK解码

且只能从管道里读一次结果

同时执行多条命令之后，得到的结果很可能只有一部分，在执行其他命令的时候又接收到之前执行的另外一部分结果，这种显现就是黏包。

基于tcp协议实现的黏包

socket * ip_port=('127.0.0.1',8888)
BUFSIZE=1024

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.setsockopt(SOL_SOCKET,1)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)

while True:
conn,addr=tcp_socket_server.accept()
print('客户端',addr)

while True: cmd=conn.recv(BUFSIZE) if len(cmd) == 0:break res=subprocess.Popen(cmd.decode('utf-8'),shell=True,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE) stderr=res.stderr.read() stdout=res.stdout.read() conn.send(stderr) conn.send(stdout)</pre>

=1024=(,8888s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)

while True:
msg=input('>>: ').strip()
if len(msg) == 0:continue
if msg == 'quit':break

s.send(msg.encode('utf-8')) act_res=s.recv(BUFSIZE) print(act_res.decode('utf-8'),end='')</pre>

基于udp协议实现的黏包

socket * ip_port=('127.0.0.1',9000)
bufsize=1024

udp_server=socket(AF_INET,SOCK_DGRAM)
udp_server.setsockopt(SOL_SOCKET,1)
udp_server.bind(ip_port)

while True:
#收消息
cmd,addr=udp_server.recvfrom(bufsize)
print('用户命令----->',cmd)

#逻辑处理 res=subprocess.Popen(cmd.decode('utf-8'),shell=True,stderr=subprocess.PIPE,stdin=subprocess.PIPE,stdout=subprocess.PIPE) stderr=res.stderr.read() stdout=res.stdout.read() #发消息

 udp_server.sendto(stderr,addr)
udp_server.sendto(stdout,addr)
udp_server.close()

socket *=(,9000=1024udp_client=socket(AF_INET,SOCK_DGRAM)

while True:
msg=input('>>: ').strip()
udp_client.sendto(msg.encode('utf-8'),ip_port)
err,addr=udp_client.recvfrom(bufsize)
out,addr=udp_client.recvfrom(bufsize)
if err:
print('error : %s'%err.decode('utf-8'),end='')
if out:
print(out.decode('utf-8'),end='')

注意：只有TCP有粘包现象，UDP永远不会粘包

2,黏包成因

1,TCP协议中的数据传递

tcp协议的拆包机制

面向流的通信特点和Nagle算法

基于tcp协议特点的黏包现象成因

/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束

此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

2,UDP不会发生黏包

补充说明:

用UDP协议发送时，用sendto函数最大能发送数据的长度为：65535- IP头(20) – UDP头(8用TCP协议发送时，由于TCP是数据流协议，因此不存在包大小的限制（暂不考虑缓冲区的大小），这是指在用send函数时，数据长度参数不受限制。而实际上，所指定的这段数据并不一定会一次性发送出去，如果这段数据比较长，会被分段发送，如果比较短，可能会等待和下一次数据一起发送。</pre>

3,会发生黏包的两种情况

情况一? 发送方的缓存机制

发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）

socket *=(,8080tcp_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()

=1024=(,8080s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)

s.send('hello'.encode('utf-8'))
s.send('egg'.encode('utf-8'))

?情况二? 接收方的缓存机制

接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）?

socket *=(,addr=data1=conn.recv(2) #一次没有收完整
data2=conn.recv(10)#下次收的时候,会先取旧的数据,然后取新的

print('----->',data2.decode('utf-8'))

conn.close()

=1024=(,socket.SOCK_STREAM) res=s.send('hello egg'.encode('utf-8'))

总结:

黏包现象只发生在tcp协议中：

1.从表面上看，黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。

2.实际上，主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的

3,黏包的解决方案

解决方案一

问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据。

=(,8080=1s.bind(ip_port)
s.listen(5)

while True:
conn,addr=s.accept()
print('客户端',addr)
while True:
msg=conn.recv(1024)
if not msg:break
res=subprocess.Popen(msg.decode('utf-8'),
stdin=subprocess.PIPE,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE)
err=res.stderr.read()
if err:
ret=err
else:
ret=res.stdout.read()
data_length=len(ret)
conn.send(str(data_length).encode('utf-8'))
data=conn.recv(1024).decode('utf-8')
if data == 'recv_ready':
conn.sendall(ret)
conn.close()

==s.connect_ex((,8080while True:
msg=input('>>: ').strip()
if len(msg) == 0:continue
if msg == 'quit':break

s.send(msg.encode('utf-8')) length=int(s.recv(1024).decode('utf-8')) s.send('recv_ready'.encode('utf-8')) send_size=0 recv_size=0 data=b'' while recv_size < length: data+=s.recv(1024) recv_size+=len(data) print(data.decode('utf-8'))</pre>

解决方案进阶

刚刚的方法，问题在于我们我们在发送

我们可以借助一个模块，这个模块可以把要发送的数据长度转换成固定长度的字节。这样客户端每次接收消息之前只要先接受这个固定长度字节的内容看一看接下来要接收的信息大小，那么最终接受的数据只要达到这个值就停止，就能刚好不多不少的接收完整的数据了。

struct模块

该模块可以把一个类型，如数字，转成固定长度的bytes

>>> struct.pack(,2222222222111struct.error: 'i' format requires -2147483648 <= number <= 2147483647 #这个是范围

#为避免粘包,必须自定制报头
header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T数据,文件路径和md5值

#为了该报头能传送,需要序列化并且转为bytes
head_bytes=bytes(json.dumps(header),encoding='utf-8') #序列化并转成bytes,用于传输

#为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节
head_len_bytes=struct.pack('i',len(head_bytes)) #这4个字节里只包含了一个数字,该数字是报头的长度

#客户端开始发送
conn.send(head_len_bytes) #先发报头的长度,4个bytes
conn.send(head_bytes) #再发报头的字节格式
conn.sendall(文件内容) #然后发真实内容的字节格式

#服务端开始接收
head_len_bytes=s.recv(4) #先收报头4个bytes,得到报头长度的字节格式
x=struct.unpack('i',head_len_bytes)[0] #提取报头的长度

head_bytes=s.recv(x) #按照报头长度x,收取报头的bytes格式
header=json.loads(json.dumps(header)) #提取报头

#最后根据报头的内容提取真实的数据,比如
real_data_len=s.recv(header['file_size'])
s.recv(real_data_len)

values1 = (1,'abc'.encode('utf-8'),2.7)
values2 = ('defg'.encode('utf-8'),101)
s1 = struct.Struct('I3sf')
s2 = struct.Struct('4sI')

print(s1.size,s2.size)
prebuffer=ctypes.create_string_buffer(s1.size+s2.size)
print('Before : ',binascii.hexlify(prebuffer))
# t=binascii.hexlify('asdfaf'.encode('utf-8'))

 print(t)



s1.pack_into(prebuffer,values1)
s2.pack_into(prebuffer,s1.size,values2)

print('After pack',binascii.hexlify(prebuffer))
print(s1.unpack_from(prebuffer,0))
print(s2.unpack_from(prebuffer,s1.size))

s3=struct.Struct('ii')
s3.pack_into(prebuffer,123,123)
print('After pack',binascii.hexlify(prebuffer))
print(s3.unpack_from(prebuffer,0))

使用struct解决黏包

借助struct模块，我们知道长度数字可以被转换成一个标准大小的4字节数字。因此可以利用这个特点来预先发送数据长度。

<table style="height: 99px; width: 506px;" border="0">

<tr>
<td>发送时</td>
<td>接收时</td>
</tr>
<tr>
<td>先发送struct转换好的数据长度4字节</td>
<td>先接受4个字节使用struct转换成数字来获取要接收的数据长度</td>
</tr>
<tr>
<td>再发送数据</td>
<td>再按照长度接收数据
</td>
</tr>
=1) ,8080phone.listen(5)

while True:
conn,addr=phone.accept()
while True:
cmd=conn.recv(1024)
if not cmd:break
print('cmd: %s' %cmd)

res=subprocess.Popen(cmd.decode('utf-8'),stderr=subprocess.PIPE) err=res.stderr.read() print(err) if err: back_msg=err else: back_msg=res.stdout.read() conn.send(struct.pack('i',len(back_msg))) #先发back_msg的长度 conn.sendall(back_msg) #在发真实的内容


conn.close()

s=socket.socket(socket.AF_INET,8080))

while True:
msg=input('>>: ').strip()
if len(msg) == 0:continue
if msg == 'quit':break

s.send(msg.encode('utf-8')) l=s.recv(4) x=struct.unpack('i',l)[0] print(type(x),x) # print(struct.unpack('I',l)) r_s=0 data=b'' while r_s < x: r_d=s.recv(1024) data+=r_d r_s+=len(r_d) # print(data.decode('utf-8')) print(data.decode('gbk')) #windows默认gbk编码</pre>

我们还可以把报头做成字典，字典里包含将要发送的真实数据的详细信息，然后json序列化，然后用struck将序列化后的数据长度打包成4个字节（4个自己足够用了）

====headers={'data_size':len(back_msg)} head_json=json.dumps(headers) head_json_bytes=bytes(head_json,encoding='utf-8') conn.send(struct.pack('i',len(head_json_bytes))) #先发报头的长度 conn.send(head_json_bytes) #再发报头 conn.sendall(back_msg) #在发真实的内容

conn.close()

socket * ip_port=('127.0.0.1',8080)
client=socket(AF_INET,SOCK_STREAM)
client.connect(ip_port)

while True:
cmd=input('>>: ')
if not cmd:continue
client.send(bytes(cmd,encoding='utf-8'))

head=client.recv(4) head_json_len=struct.unpack('i',head)[0] head_json=json.loads(client.recv(head_json_len).decode('utf-8')) data_len=head_json['data_size'] recv_size=0 recv_data=b'' while recv_size < data_len: recv_data+=client.recv(1024) recv_size+=len(recv_data) print(recv_data.decode('utf-8')) #print(recv_data.decode('gbk')) #windows默认gbk编码</pre>

练习 : 上传下载文件

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,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</pre>

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,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()

六,socket 的更多方法介绍

客户端套接字函数
s.connect() 主动初始化TCP服务器连接
s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

公共用途的套接字函数
s.recv() 接收TCP数据
s.send() 发送TCP数据
s.sendall() 发送TCP数据
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() 创建一个与该套接字相关的文件

socket.send(string[,flags])
Send data to the socket. The socket must be connected to a remote socket. The optional flags argument has the same meaning as for recv() above. Returns the number of bytes sent. Applications are responsible for checking that all data has been sent; if only some of the data was transmitted,the application needs to attempt delivery of the remaining data.

send()的返回值是发送的字节数量，这个数量值可能小于要发送的string的字节数，也就是说可能无法发送string中所有的数据。如果有错误则会抛出异常。

–

socket.sendall(string[,flags])
Send data to the socket. The socket must be connected to a remote socket. The optional flags argument has the same meaning as for recv() above. Unlike send(),this method continues to send data from string until either all data has been sent or an error occurs. None is returned on success. On error,an exception is raised,and there is no way to determine how much data,if any,was successfully sent.

尝试发送string的所有数据，成功则返回None，失败则抛出异常。

故，下面两段代码是等价的：

#sock.sendall('Hello worldn')

#buffer = 'Hello worldn'

while buffer:

 bytes = sock.send(buffer)

 buffer = buffer[bytes:]

七,验证客户端链接的合法性

如果你想在分布式系统中实现一个简单的客户端链接认证功能，又不像SSL那么复杂，那么利用hmac+加盐的方式来实现

socket * secret_key=b'linhaifeng bang bang bang'
def conn_auth(conn):
'''
认证客户端链接
:param conn:
:return:
'''
print('开始验证新链接的合法性')
msg=os.urandom(32)
conn.sendall(msg)
h=hmac.new(secret_key,msg)
digest=h.digest()
respone=conn.recv(len(digest))
return hmac.compare_digest(respone,digest)

def data_handler(conn,bufsize=1024):
if not conn_auth(conn):
print('该链接不合法,关闭')
conn.close()
return
print('链接合法,开始通信')
while True:
data=conn.recv(bufsize)
if not data:break
conn.sendall(data.upper())

def server_handler(ip_port,bufsize,backlog=5):
'''
只处理链接
:param ip_port:
:return:
'''
tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(backlog)
while True:
conn,addr=tcp_socket_server.accept()
print('新连接[%s:%s]' %(addr[0],addr[1]))
data_handler(conn,bufsize)

if name == 'main':
ip_port=('127.0.0.1',9999)
bufsize=1024
server_handler(ip_port,bufsize)

socket * secret_key=b'linhaifeng bang bang bang'
def conn_auth(conn):
'''
验证客户端到服务器的链接
:param conn:
:return:
'''
msg=conn.recv(32)
h=hmac.new(secret_key,msg)
digest=h.digest()
conn.sendall(digest)

def client_handler(ip_port,bufsize=1024):
tcp_socket_client=socket(AF_INET,SOCK_STREAM)
tcp_socket_client.connect(ip_port)

conn_auth(tcp_socket_client) while True: data=input('>>: ').strip() if not data:continue if data == 'quit':break tcp_socket_client.sendall(data.encode('utf-8')) respone=tcp_socket_client.recv(bufsize) print(respone.decode('utf-8')) tcp_socket_client.close()

if name == 'main':
ip_port=('127.0.0.1',9999)
bufsize=1024
client_handler(ip_port,bufsize)

socket *
def client_handler(ip_port,SOCK_STREAM)
tcp_socket_client.connect(ip_port)

while True: data=input('>>: ').strip() if not data:continue if data == 'quit':break tcp_socket_client.sendall(data.encode('utf-8')) respone=tcp_socket_client.recv(bufsize) print(respone.decode('utf-8')) tcp_socket_client.close()

if name == 'main':
ip_port=('127.0.0.1',bufsize)

socket * secret_key=b'linhaifeng bang bang bang1111'
def conn_auth(conn):
'''
验证客户端到服务器的链接
:param conn:
:return:
'''
msg=conn.recv(32)
h=hmac.new(secret_key,bufsize)

八,socketserver

= self.request.recv(1024(if name == "main":
HOST,PORT = "127.0.0.1",9999

# 设置allow_reuse_address允许服务器重用地址 socketserver.TCPServer.allow_reuse_address = True # 创建一个server,将服务地址绑定到127.0.0.1:9999 server = socketserver.TCPServer((HOST,PORT),Myserver) # 让server永远运行下去，除非强制停止程序 server.serve_forever()</pre>

HOST,9999
data = "hello"

# 创建一个socket链接，SOCK_STREAM代表使用TCP协议
with socket.socket(socket.AF_INET,socket.SOCK_STREAM) as sock:
sock.connect((HOST,PORT)) # 链接到客户端
sock.sendall(bytes(data + "n","utf-8")) # 向服务端发送数据
received = str(sock.recv(1024),"utf-8")# 从服务端接收数据

print("Sent: {}".format(data))
print("Received: {}".format(received))

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!

相关内容

python – emacs jedi不起作用
Python函数初始
在python中设置默认的日期时间格式
详解Python的Django框架中Manager方法的使用
python与MySQL
50行Python代码实现视频中物体颜色识别和跟踪（必须以红色为
python双向链表实现实例代码
pytorch 中pad函数toch.nn.functional.pad()的用法
python – Fabric可以在远程机器上运行本地脚本吗？
python – 在Flask-SQLAlchemy中的同一个类中使用不同的绑定

推荐文章

站长推荐

python – Heroku的新手 – “没有像web这样的
Yocto
Python TCP/IP协议下实现端口转发及重定向菜鸟教
python – 别名方法和传递静态参数
python3.6连接MySQL和表的创建与删除实例代码
python – 我们如何修改搁置中的数据？
使用PyCrypto做AES加密
python中的矢量化球形bessel函数？
AQQ批量网站工具集之目标URL存活判断
python生成图片

热点阅读

【免责声明】本站内容转载自互联网，其发布内容言论不代表本站观点，如果其链接、内容的侵犯您的权益，烦请提交相关链接至邮箱bqsm@foxmail.com我们将及时予以处理。

建议您使用1920×1080分辨率、谷歌浏览器Google Chrome、Microsoft Edge以获得本站的最佳浏览效果

Copygight © 2008-2022 https://www.lidatong.com.cn/ All Rights Reserved. 李大同

python - 网络编程

一,引入

二,软件开发的架构

1,C/S 架构

?2,B/S 架构

三,网络基础

1,一个程序如何在网络上找到另一个程序?

2,osi七层模型

3,socket 概念

4,套接字 (socket) 的发展史

基于文件类型的套接字家族

基于网络类型的套接字家族

?5,tcp协议和udp协议

四,套接字 (socket) 初使用

1,基于TCP协议的socket

2,基于UDP协议的socket

1,简单使用

2,QQ聊天

3,时间服务器

3,socket 参数的详解

创建socket对象的参数说明 :

1,黏包现象

基于tcp协议实现的黏包

基于udp协议实现的黏包

2,黏包成因

1,TCP协议中的数据传递

面向流的通信特点和Nagle算法

基于tcp协议特点的黏包现象成因

2,UDP不会发生黏包

补充说明:

3,会发生黏包的两种情况

总结:

3,黏包的解决方案

解决方案一

解决方案进阶

struct模块

<span style="color: #008000;"> print(t)

使用struct解决黏包

练习 : 上传下载文件

六,socket 的更多方法介绍

<span style="color: #008000;">while buffer:<span style="color: #008000;">

<span style="color: #008000;"> bytes = sock.send(buffer)<span style="color: #008000;">

<span style="color: #008000;"> buffer = buffer[bytes:]

七,验证客户端链接的合法性

八,socketserver