1.TCP
2.补充异常处理
3.UDP
一TCP.
1.socket基础版本通讯
服务端&＃xff1a;
1 import socket
2
3 server &＃61; socket.socket()# 生成一个对象
4 server.bind((&＃39;127.0.0.1&＃39;,8080))# 绑定ip和端口
5 server.listen(5)# 连接池
6
7 conn,addr &＃61; server.accept()# 等待别人 一个是ip 一个是地址 阻塞
8 data &＃61; conn.recv(1024) # 听别人说话 阻塞
9 print(data)
10 conn.send(b&＃39;hello boby&＃39;)# 给对方回信息
11
12 conn.close()# 断开链接
13 server.close()# 结束掉进程
客户端&＃xff1a;
1 import socket
2
3
4 client &＃61; socket.socket()# 生成一个对象
5
6 client.connect((&＃39;127.0.0.1&＃39;,8080))# 发送你的ip和端口号
7
8 client.send(b&＃39;hello word&＃39;)# 对别人说话
9 data &＃61; client.recv(1024) # 听别人说话
10 print(data)
11
12 client.close()# 断开链接
2 升级版实现多条通讯
服务端&＃xff1a;
1 import socket
2
3 server &＃61; socket.socket() # 创建一个对象
4 server.bind((&＃39;127.0.0.1&＃39;,8989)) # 绑定 ip 和端口
5 server.listen(5)# 最大连接数
6
7 while True:
8 conn,addr &＃61; server.accept() # 等待 别人链接进来 ip和端口 # 等到别人来 conn就类似于是双向通道
9 print(conn)
10 print(addr)## (&＃39;127.0.0.1&＃39;, 51323) 客户端的地址
11 while True:
12 try:
13 data &＃61; conn.recv(1024)# 接收数据
14 # 判断接收的数据为不为空
15 if not data:break## b&＃39;&＃39; 针对mac与linux 客户端异常退出之后 服务端不会报错 只会一直收b&＃39;&＃39;
16 conn.send(data.upper())
17 except ConnectionResetError as e:
18 print(e)
19 break
20 conn.close()
客户端&＃xff1a;
1 import socket
2
3 client &＃61; socket.socket() # 创建一个对象
4 client.connect((&＃39;127.0.0.1&＃39;,8989))# 写入要链接的ip 和端口号
5
6 while True:
7 msg &＃61; input(&＃39;请输入:>>>&＃39;).encode(&＃39;utf-8&＃39;)# 发送数据
8 # 判断数据是否为空
9 if not msg:continue
10 client.send(msg)
11 # 接收数据
12 data &＃61; client.recv(1024)
13 print(data)
tcp的沾包问题
客户端&＃xff1a;
import time
import socketclient &＃61; socket.socket()
client.connect((&＃39;127.0.0.1&＃39;,8080))client.send(b&＃39;hello&＃39;)
# time.sleep(5)
client.send(b&＃39;word&＃39;)
服务端&＃xff1a;
import socketserver &＃61; socket.socket()
server.bind((&＃39;127.0.0.1&＃39;,8080))
server.listen(5)
conn,addr &＃61; server.accept()data &＃61; conn.recv(5)
print(data)
data &＃61; conn.recv(5)
print(data)&＃39;&＃39;&＃39;
可以规定接收的数据长度&＃xff0c;但是你不知道对方每次要发多少数据&＃xff0c;这个接收数据的1024不能随便改&＃xff0c;所以说要想其他的方法
解决方案就是你要提前告知收方数据的长度
&＃39;&＃39;&＃39;
那么沾包是如何产生的&＃xff1a;
TCP流式协议, 数据之间没有分界, 就像水 一杯水和一杯牛奶倒在一起了!UDP 用户数据报协议 粘包 仅发生在TCP协议中 1. 发送端 发送的数据量小 并且间隔短 会粘
2. 接收端 一次性读取了两次数据的内容 会粘
3. 接收端 没有接收完整 剩余的内容 和下次发送的粘在一起无论是那种情况,其根本原因在于 接收端不知道数据到底有多少 解决方案就是 提前告知接收方 数据的长度
那么如何解决沾包&＃xff1a;
.TCP粘包问题
struct模块 对数据进行打包处理 固定长度
pack
unpack
服务端
1.生成一个字典
2.制作该字典的报头
json序列化
编码 统计长度
3.发送字典的报头
4.发送字典
5.最后发真实数据
客户端
1.先接受固定长度的4个字节字典报头
2.解析获取字典数据的长度
unpack(...)[0]
3.接受字典数据
解码 反序列化
4.接受真实数据
ps:为什么要多加一个字典
1.打包的数据大小有限
2.可以携带更多的信息
代码实现解决沾包问题&＃xff1a;
客户端&＃xff1a;
1 import socket
2 import struct
3 import json
4
5 client &＃61; socket.socket()
6 client.connect((&＃39;127.0.0.1&＃39;,8080))
7
8 while True:
9 msg &＃61; input(&＃39;msg:>>>&＃39;).encode(&＃39;utf-8&＃39;)
10 if not msg:continue
11 client.send(msg)
12 # 接收字典报头
13 header &＃61; client.recv(4)
14 # 解析报头&＃xff0c;拿到真实的数据长度
15 header_dict &＃61; struct.unpack(&＃39;i&＃39;,header)[0]
16 # 接收字典数据
17 dict_bytes &＃61; client.recv(header_dict)
18 json_dict &＃61; json.loads(dict_bytes.decode(&＃39;utf-8&＃39;))
19 # 从字典中获取信息
20 print(json_dict)
21 recv_size &＃61; 0
22 real_data &＃61; b&＃39;&＃39;
23 # 循环接收字典中的信息
24 while recv_size
25 data &＃61; client.recv(1024)
26 recv_size &＃43;&＃61;len(data)
27 real_data &＃43;&＃61;data
28 print(data.decode(&＃39;gbk&＃39;))
29 print(recv_size)
服务端&＃xff1a;
1 import socket
2 import struct
3 import json
4 import subprocess
5
6 server &＃61; socket.socket()
7 server.bind((&＃39;127.0.0.1&＃39;,8080))
8 server.listen(5)
9
10 while True:
11 conn,addr &＃61; server.accept()
12 while True:
13 try:
14 cmd &＃61; conn.recv(1024)
15 if not cmd:break
16 cmd &＃61; cmd.decode(&＃39;utf-8&＃39;)
17 obj &＃61; subprocess.Popen(cmd,shell&＃61;True,stdout&＃61;subprocess.PIPE,stderr&＃61;subprocess.PIPE)
18 res &＃61; obj.stdout.read()&＃43;obj.stderr.read()
19 # 定义一个字典
20 d &＃61; {&＃39;name&＃39;:&＃39;zy&＃39;,&＃39;file_size&＃39;:len(res)}
21 json_d &＃61; json.dumps(d)
22 #1.制作字典报头
23 header &＃61; struct.pack(&＃39;i&＃39;,len(json_d))
24 #2. 发送字典报头
25 conn.send(header)
26 #3.发送字典
27 conn.send(json_d.encode(&＃39;utf-8&＃39;))
28 #4.发送正式数据
29 conn.send(res)
30 except ConnectionResetError as e:
31 print(e)
32 break
33 conn.close()
补充&＃xff1a;
解决沾包问题需要用到的struct模块&＃xff1a;
1 import struct
2 #
3 # res &＃61; &＃39;dgbdushfgcbdsjhgbcshjdgcbidjhgvKADJFCNalskCNkfjcnLJCHSDNCKLSD&＃39;
4 # print(&＃39;最开始的&＃39;,len(res))
5 #
6 # res1 &＃61; struct.pack(&＃39;i&＃39;,len(res))
7 # print(&＃39;打包好的&＃39;,len(res1))
8 #
9 # res2 &＃61; struct.unpack(&＃39;i&＃39;,res1)[0] # 如果不加索引解包后的结果就是解包后的 (61,)&＃xff0c;索引拿到的是0号位
10 # print(&＃39;解包后的&＃39;,res2)
11
12
13
14 &＃39;&＃39;&＃39;
15 当原始数据特别大的时候 i模式打包不了 需要更换模式?
16 如果遇到数据量特别大的情况 该如何解决?
17 可以定义一个字典
18 &＃39;&＃39;&＃39;
19 d &＃61; {
20 &＃39;name&＃39;:&＃39;zy&＃39;,
21 &＃39;file_size&＃39;:&＃39;123473985961732617417324627346723641746723462374613274164&＃39;,
22 &＃39;info&＃39;:&＃39;你好&＃39;,
23 }
24
25 import json
26 json_d &＃61; json.dumps(d)
27 print(len(json_d))
28
29 res1 &＃61; struct.pack(&＃39;i&＃39;,len(json_d))
30 print(len(res1))
31
32 res2 &＃61; struct.unpack(&＃39;i&＃39;,res1)[0]
33 print(&＃39;解包后的数据&＃39;,res2)
补充&＃xff1a;复习subprocess模块
1 import subprocess
2
3 while True:
4 cmd &＃61; input(&＃39;cmg:>>>&＃39;)
5 if cmd &＃61;&＃61; &＃39;q&＃39;:break
6 if not cmd:continue
7 obj &＃61; subprocess.Popen(cmd,shell&＃61;True,stdout&＃61;subprocess.PIPE,stderr&＃61;subprocess.PIPE)
8 print(obj.stdout.read().decode(&＃39;gbk&＃39;))# 正确命令返回的结果
9 print(obj.stderr.read().decode(&＃39;gbk&＃39;))# 错误的命令返回的结果
10
11 #注意&＃xff1a;subprocess获取到的数据&＃xff0c;拿完就没有了&＃xff0c;不能重复的拿
练习&＃xff1a;大文件上传&＃xff1a;
客户端&＃xff1a;
1 mport struct
2 import json
3 import socket
4 import os
5
6 client &＃61; socket.socket()
7 client.connect((&＃39;127.0.0.1&＃39;,8080))
8
9 while True:
10 # 获取文件路径
11 MOVIE_DIR &＃61; r&＃39;H:\python视频\python10期\day29\视频&＃39;
12 # 显示文件里的电影
13 movie_list &＃61; os.listdir(MOVIE_DIR)
14 # 循环打印电影
15 for i,movie in enumerate(movie_list,1):
16 print(i,movie)
17 # 选取电影
18 choice &＃61; input(&＃39;请选择电影:>>>&＃39;).strip()
19 if choice.isdigit():
20 choice &＃61; int(choice)-1
21 # 判断是否在索引范围内
22 if choice in range(0,len(movie_list)):
23 # 获取要上传电影的文件路径
24 path &＃61; movie_list[choice]
25 # 获取要上传电影的绝对路径,拼接
26 file_path &＃61; os.path.join(MOVIE_DIR,path)
27 # 获取文件的大小
28 file_size &＃61; os.path.getsize(file_path)
29 # 定义一个字典
30 d &＃61; {
31 &＃39;file_name&＃39;:&＃39;qwer.mp4&＃39;,
32 &＃39;file_size&＃39;:file_size,
33 }
34 # 序列化字典
35 json_d &＃61; json.dumps(d)
36 json_bytes &＃61; json_d.encode(&＃39;utf-8&＃39;)
37 # 制作字典报头
38 header &＃61; struct.pack(&＃39;i&＃39;,len(json_bytes))
39 # 发送字典报头
40 client.send(header)
41 # 发送字典数据
42 client.send(json_bytes)
43 # 循环发送文件数据
44 with open(file_path,&＃39;rb&＃39;) as f:
45 for line in f:
46 client.send(line)
47 else:
48 print(&＃39;序号不在索引范围内&＃39;)
49 else:
50 print(&＃39;请输入数字&＃39;)
服务端&＃xff1a;
1 import socket
2 import struct
3 import json
4
5
6 server &＃61; socket.socket()
7 server.bind((&＃39;127.0.0.1&＃39;,8080))
8 server.listen(5)
9
10 while True:
11 conn,addr &＃61; server.accept()
12 while True:
13 try:
14 # 先接收报头
15 header &＃61; conn.recv(4)
16 # 解析字典报头
17 header_len &＃61;struct.unpack(&＃39;i&＃39;,header)[0]
18 # 接收字典数据
19 json_bytes &＃61; conn.recv(header_len)
20 json_dict &＃61; json.loads(json_bytes.decode(&＃39;utf-8&＃39;))
21 # 获取字典长度
22 len_size &＃61; json_dict.get(&＃39;file_size&＃39;)
23 # 循环接收文件数据
24 recv_size &＃61; 0
25 with open(json_dict.get(&＃39;file_name&＃39;),&＃39;wb&＃39;) as f:
26 while recv_size < len_size:
27 data &＃61; conn.recv(1024)
28 f.write(data)
29 recv_size&＃43;&＃61;len(data)
30 print(&＃39;上传成功&＃39;)
31 print(recv_size)
32 except ConnectionResetError as e:
33 print(e)
34 break
35 conn.close()
二.异常处理
什么是异常处理&＃xff1a;
程序在运行过程中出现了不可预知的错误&＃xff0c;并且该程序没有对应的处理机制’&＃xff0c;
那么就会以异常的形式表示出来&＃xff0c;造成的影响就是整个程序无法在正常运行了&＃xff0c;
那么我们一般不建议使用异常处理&＃xff0c;一般的异常都是可以通过修改代码可以防止
出现异常的&＃xff0c;只有那么你知道会报错&＃xff0c;而不能解决的&＃xff0c;
举例&＃xff1a;比如说你和别人在打电话&＃xff0c;那么可能会出现一些意外&＃xff0c;可能手机关机了&＃xff0c;或者没信号了
所以说在无法解决的时候在使用异常处理
异常的结构&＃xff1a;
1.异常的类型:NAMEERROR
2.异常的信息:name &＃39;fdsdfsdf&＃39; is not defined
3.异常的位置:Traceback (most recent call last):
File "D:/python脱产10期视频/day29/01 异常处理.py", line 1, in
fdsdfsdf
异常的种类&＃xff1a;
分为俩大类&＃xff1a;
1.语法上的错误&＃xff1a;
是你程序启动立刻就能解决的&＃xff0c;这种错误也是不能被容忍的&＃xff0c;
语法上的错误&＃xff0c;发现之后应该立即解决
2.逻辑上的错误&＃xff1a;
这种错误是可以被容忍的&＃xff0c;因为一眼看不出来&＃xff0c;
针对逻辑上的错误&＃xff0c;可以采用异常处理机制进行捕获
常见的错误类型&＃xff1a;
NAMERROR 名字错误
SyntaxError 语法错误
eyError 键不存在
ValueError 值错误
IndexError 索引错误
如何避免&＃xff1a;
异常处理&＃xff1a;
在你认为可能会出现的bug的代码上方try一下&＃xff1a;注意try内部的代码块越少越好
try:
可能出现的错误
except 出错的类型 as e: 将报错信息赋值给变量
出错之后的处理机制
三.UDP协议
udp协议简介
用户数据报协议,是OSI模型中属于传输层的协议
提供,不可靠的,不要求顺序的,数据量小的,速度快的传输服务
不可靠:
发送完成后不需要确认信息 并且立即删除缓存中的数据
不要求顺序:
当一个数据较大时 会分为多个数据报来传输,对方无法获知数据的顺序,以及是否完整
数据量较小的:
数据越大丢包的可能性越高 ,建议的数据量不要超过1472
速度快:
相对于TCP而言快很多 不需要确认信息 ,也不需要建立链接
udp协议的通讯流程&＃xff1a;
如果TCP比喻为手机打电话的过程 那么UDP可以看做是对讲机
1.买机器 创建UDP的socket
2.固定频道 bind一个ip和端口
3.收发数据 recvfrom sendto
接收
1.买机器 创建UDP的socket
2.收发数据 recvfrom sendto
注意 不能先收 要收数据 必须明确端口号 没有端口号是不可能使用网络服务的
TCP 与 UDP 的其他区别
1.没有连接
2.不会粘包 每次发送都是一个独立的数据包
TCP 对数据完整性要求较高 : 在线支付 ,文字信息
UDP: 对数据不要求完整性 但是要快 : 视频 语音 游戏
udp协议的基本使用&＃xff1a;
服务端&＃xff1a;
1 import socket
2
3 server &＃61; socket.socket(type&＃61;socket.SOCK_DGRAM)# UDP协议
4 server.bind((&＃39;127.0.0.1&＃39;,8080))
5 &＃39;&＃39;&＃39;
6 UDP不需要设置半链接池&＃xff0c;它也没有半连接池的概念
7 因为没有双向通道&＃xff0c;不需要accept 直接就是通信循环
8 &＃39;&＃39;&＃39;
9 while True:
10 data,addr &＃61; server.recvfrom(1024)
11 print(&＃39;数据&＃39;,data)# 客户端发来的信息
12 print(&＃39;地址&＃39;,addr)# 客户端发来的地址
13 server.sendto(data.upper(),addr)
14 break
客户端&＃xff1a;
1 import socket
2
3 client &＃61; socket.socket(type&＃61;socket.SOCK_DGRAM)
4 #不需要建立链接&＃xff0c;直接进入通信循环
5 server_address &＃61; (&＃39;127.0.0.1&＃39;,8080)
6
7 while True:
8 client.sendto(b&＃39;hello&＃39;,server_address)
9 data,addr &＃61; client.recvfrom(1024)
10 print(&＃39;服务端发来的数据&＃39;,data)
11 print(&＃39;服务端发来的地址&＃39;,addr)
12 break
udp通讯是不会沾包的&＃xff1a;
服务端&＃xff1a;
1 import socket
2
3 server &＃61; socket.socket(type&＃61;socket.SOCK_DGRAM)
4 server.bind((&＃39;127.0.0.1&＃39;,8080))
5
6 data,addr &＃61; server.recvfrom(1024)
7 print(data)
8 data,addr1 &＃61; server.recvfrom(1024)
9 print(data)
10 data,addr2 &＃61; server.recvfrom(1024)
11 print(data)
客户端&＃xff1a;
1 import socket
2
3
4 client &＃61; socket.socket(type&＃61;socket.SOCK_DGRAM)
5 server_address &＃61; (&＃39;127.0.0.1&＃39;,8080)
6
7 client.sendto(b&＃39;hello&＃39;,server_address)
8 client.sendto(b&＃39;hello&＃39;,server_address)
9 client.sendto(b&＃39;hello&＃39;,server_address)
小练习&＃xff1a;udp实现简易版本的qq
服务端&＃xff1a;
1 import socket
2
3 server &＃61; socket.socket(type&＃61;socket.SOCK_DGRAM)
4 server.bind((&＃39;127.0.0.1&＃39;,8080))
5
6
7 while True:
8 data,addr &＃61; server.recvfrom(1024)
9 print(data.decode(&＃39;utf-8&＃39;))
10 msg &＃61; input(&＃39;msg:>>>&＃39;).strip()
11 server.sendto(msg.encode(&＃39;utf-8&＃39;),addr)
客户端1&＃xff1a;
1 import socket
2
3 client &＃61; socket.socket(type&＃61;socket.SOCK_DGRAM)
4 server_address &＃61; (&＃39;127.0.0.1&＃39;,8080)
5
6 while True:
7 msg &＃61; input(&＃39;msg:>>>&＃39;).strip()
8 msg &＃61; &＃39;来自客户端1的信息:%s&＃39;%msg
9 client.sendto(msg.encode(&＃39;utf-8&＃39;),server_address)
10 data,server_addr &＃61; client.recvfrom(1024)
11 print(data.decode(&＃39;utf-8&＃39;))
客户端2&＃xff1a;
1 import socket
2
3 client &＃61; socket.socket(type&＃61;socket.SOCK_DGRAM)
4 server_address &＃61; (&＃39;127.0.0.1&＃39;,8080)
5
6 while True:
7 msg &＃61; input(&＃39;msg:>>>&＃39;).strip()
8 msg &＃61; &＃39;来自客户端2的信息:%s&＃39;%msg
9 client.sendto(msg.encode(&＃39;utf-8&＃39;),server_address)
10 data,server_addr &＃61; client.recvfrom(1024)
11 print(data.decode(&＃39;utf-8&＃39;))
客户端3&＃xff1a;
1 import socket
2
3 client &＃61; socket.socket(type&＃61;socket.SOCK_DGRAM)
4 server_address &＃61; (&＃39;127.0.0.1&＃39;,8080)
5
6 while True:
7 msg &＃61; input(&＃39;msg:>>>&＃39;).strip()
8 msg &＃61; &＃39;来自客户端3的信息:%s&＃39;%msg
9 client.sendto(msg.encode(&＃39;utf-8&＃39;),server_address)
10 data,server_addr &＃61; client.recvfrom(1024)
11 print(data.decode(&＃39;utf-8&＃39;))
京公网安备 11010802041100号