socket 上传 -- 异常处理--UDP协议 --自定义socket #29

 1 ‘‘‘‘‘‘
 2 """
 3 异常处理
 4 """
 5 """
 6 1.什么是异常?
 7     程序在运行过程中出现了不可预知的错误,并且该错误没有对应的处理机制,就会以异常的形式表现出来
 8     造成的影响就是整个程序无法再正常运行
 9 """
10 """
11 2.异常的结构:类型+信息+位置
12     1.异常的类型:NAMEERROR
13     2.异常的信息:name ‘fdsdfsdf‘ is not defined
14     3.异常的位置:Traceback (most recent call last):
15               File "D:/python脱产10期视频/day29/01 异常处理.py", line 1, in <module>
16                 fdsdfsdf
17 """
18 """
19 3.异常的种类
20     1.分类
21         1.语法错误
22             是你程序立刻就能解决的,这种错误是不能被容忍的
23                 语法上的错误 发现之后应该立刻解决
24         2.逻辑错误
25             这种错是可以被容忍的 因为一眼看不出来
26                 针对逻辑上的错误  可以采用异常处理机制进行捕获
27     
28     2.常见的错误类型 
29         NAMERROR     名字错误
30         SyntaxError  语法错误
31         KeyError     键不存在
32         ValueError   值错误
33         IndexError   索引错误
34         
35 """
36 """
37 4.如何避免?
38     1.异常处理:
39         在你认为可能出现bug的代码上方try 一下:注try内部的代码越少越好
40     
41     2.语法一:
42         try:
43             可能出错的代码
44         except 出错的类型 as e:# 将报错信息赋值给变量e
45             出错以后的处理机制
46         except... # :ps:except可叠加
47     3.语法二:主动报错
48     a = 2
49     b = 3
50     if a > b:
51         print(a+b)
52     else:
53         raise TypeError(a<b)
54         
55         
56 """
57 # a = 2
58 # b = 3
59 # if a > b:
60 #     print(a+b)
61 # else:
62 #     raise TypeError(a<b)
63 """
64 Traceback (most recent call last):
65   File "E:/Python课堂内容整理/知识点框架/函数--装饰器--迭代器--生成器--常用模块--ATM/day29异常处理,,上传视频/1.异常处理/1.异常处理.py", line 57, in <module>
66     raise TypeError(a<b)
67 TypeError: True
68 """
69 """
70 5.万能异常:finally(最终)
71 """
72 a = 2
73 b = 3
74 try:
75     if a > b:
76         print(a+b)
77 except Exception:  # 万能异常 所有的异常类型都被捕获
78     print(a<b)
79 else:
80     print(‘无异常‘)
81     print(‘被检测的代码没有任何的异常发生 才会走else‘)
82 finally:
83     print(123)
84     print(‘无论被检测的代码有没有异常发生 都会在代码运行完毕之后执行我‘)
85 """
86 无异常
87 被检测的代码没有任何的异常发生 才会走else
88 123
89 无论被检测的代码有没有异常发生 都会在代码运行完毕之后执行我
90 """

 1 """"""
 2 """
 3 自定义异常
 4 """
 5 # 我的错误类型--继承自基类错误类型
 6 class MyError(BaseException):
 7     def __init__(self,msg):
 8         super().__init__()
 9         self.msg = msg
10     # 自定义打印类型
11     def __str__(self):
12         return "<fsghggdf%sdfgdffgfdgdfgfggd>"%self.msg
13 raise MyError(‘我自定义的异常‘)
14 # 主动抛出异常其实就是将异常类的对象打印出来,会走__str__方法
15 ‘‘‘
16 ‘‘‘
17 """
18 Traceback (most recent call last):
19   File "E:/Python课堂内容整理/知识点框架/函数--装饰器--迭代器--生成器--常用模块--ATM/day29异常处理,,上传视频/1.异常处理/2.自定义异常.py", line 14, in <module>
20     raise MyError(‘我自定义的异常‘)
21 __main__.MyError: <fsghggdf我自定义的异常dfgdffgfdgdfgfggd>
22 """

 1 import socket
 2 import os
 3 import json
 4 import struct
 5 client = socket.socket()
 6 client.connect((‘127.0.0.1‘,9177))
 7 while True:
 8     BAST_PATH = os.path.dirname(os.path.dirname(__file__))
 9     DB_PATH = os.path.join(BAST_PATH,‘movie‘)
10     # 打印电影列表目录
11     movie_list = os.listdir(DB_PATH)
12     for movie in enumerate(movie_list,start=1):
13         print(movie)
14     # 选择下载目录
15     choose = input(‘choose>>>:‘).strip()
16     if choose.isdigit():
17         choose = int(choose)
18         if choose in range(1,len(movie_list)+1):
19 
20             file_name = movie_list[choose-1]
21             file_path = os.path.join(DB_PATH,file_name)
22             file_size = os.path.getsize(file_path)
23             user_dic = {
24                 ‘file_name‘:file_name,
25                 ‘file_size‘:file_size,
26                 ‘file_path‘:file_path,
27                 ‘music‘:‘后嘿嘿‘
28             }
29             json_d = json.dumps(user_dic)
30             header = struct.pack(‘i‘,len(json_d))
31             client.send(header)
32             client.send(json_d.encode(‘utf-8‘))
33             with open(file_path,‘rb‘)as f:
34                 for line in f:
35                     client.send(line)
36         else:
37             print(‘choose必须在范围内‘)
38     else:
39         print(‘choose必须为数字‘)

 1 import socket
 2 import struct
 3 import json
 4 server = socket.socket()
 5 server.bind((‘127.0.0.1‘,9177))
 6 server.listen(5)
 7 while True:
 8     conn,addr = server.accept()
 9     while True:
10         try:
11             header_dict = conn.recv(4)
12             dict_size = struct.unpack(‘i‘,header_dict)[0]
13             dict_bytes = conn.recv(dict_size)
14             dict_json = json.loads(dict_bytes.decode(‘utf-8‘))
15             print(dict_json,‘上传视频大小‘)
16             recv_size = 0
17             file_name = dict_json.get(‘file_name‘)
18             file_size = dict_json.get(‘file_size‘)
19             with open(file_name,‘wb‘)as f:
20                 while recv_size < file_size:
21                     date = conn.recv(1024)
22                     f.write(date)
23                     recv_size += len(date)
24                 print(recv_size,‘接收文件大小‘)
25                 print(f‘{recv_size}文件上传成功‘)
26 
27         except ConnectionResetError:
28             break
29     conn.close()

 1 import socket
 2 # 1.不需要建立连接 直接进入通信循环
 3 client = socket.socket(type=socket.SOCK_DGRAM)
 4 # 1.不需要建立连接 直接进入通信循环
 5 server_addr = (‘127.0.0.1‘,9177)
 6 while True:
 7         client.sendto(b‘hello‘,server_addr)
 8         date,addr = client.recvfrom(1024)
 9         print(date.decode(‘utf-8‘),‘数据‘)
10         print(addr,‘地址‘)

 1 import socket
 2 # 1.UDP协议
 3 server = socket.socket(type=socket.SOCK_DGRAM)
 4 # 2.插卡
 5 server.bind((‘127.0.0.1‘,9177))
 6 # ps:
 7 # 1.UDP 协议不需要办连接池 ,它也没有半连接词这个概念
 8 # 2.因为没有双向通道,不需要accpet,直接就是循环通信
 9 while True:
10 
11     conn,addr = server.recvfrom(1024)
12     # 1.客户端发来消息
13     print(conn.decode(‘utf-8‘),‘数据‘)
14     # 2.客户端的地址
15     print(addr,‘地址‘)
16     server.sendto(conn.upper(),addr)

1 import socket
2 client = socket.socket(type=socket.SOCK_DGRAM)
3 server_addr = (‘127.0.0.1‘,9744)
4 while True:
5     msg = input(‘msg>>>:‘).strip()
6     msgs = ‘来自客户端1的消息:%s‘%msg
7     client.sendto(msg.encode(‘utf-8‘),server_addr)
8     date,addr = client.recvfrom(1024)
9     print(date.decode(‘utf-8‘))

 1 ‘‘‘‘‘‘
 2 """
 3 qq
 4 """
 5 import socket
 6 server = socket.socket(type=socket.SOCK_DGRAM)
 7 server.bind((‘127.0.0.1‘,9744))
 8 while True:
 9     conn,addr = server.recvfrom(1024)
10     print(conn.decode(‘utf-8‘))
11     msg = input(‘msg>>>:‘).encode(‘utf-8‘)
12     server.sendto(msg,addr)

1 6.TCP与UDP的区别:
2     1.UDP协议客户端允许发空
3     2.UDP协议不会粘包(自带报头)
4     3.UDP协议服务端不存在的情况下,照样不会报错(UDP只管发,不管收)
5 
6 ps:UDP通信
7     1.数据报协议(自带报头)
8 
9     2.没有双向通道 通信类似于发短信

1 import socket
2 import time
3 client = socket.socket()
4 client.connect((‘127.0.0.1‘,8999))
5 while True:
6     client.send(b‘hello‘)
7     date = client.recv(1024)
8     print(date.decode(‘utf-8‘))
9     time.sleep(1)

 1 ‘‘‘‘‘‘
 2 """
 3 自定义TCP协议
 4 """
 5 import socketserver
 6 
 7 class MyServer(socketserver.BaseRequestHandler):
 8     def handle(self):
 9         print(‘weclcome to you!‘)
10         while True:
11             date = self.request.recv(1024)
12             print(self.client_address)
13             print(date.decode(‘utf-8‘))
14             self.request.send(date.upper())
15 if __name__ == "__main__":
16     """
17     只要有客户端连接,会自动交给自定义类中handle方法去处理
18     """
19     server = socketserver.ThreadingTCPServer((‘127.0.0.1‘,8999),MyServer)  # 创建一个基于TCP的对象
20     server.serve_forever()  # 启动该服务对象

1 import socket
2 import time
3 client = socket.socket()
4 server_address = (‘127.0.0.1‘,8999)
5 while True:
6     client.sendto(b‘hello‘,server_address)
7     date,addr= client.recvfrom(1024)
8     print(date.decode(‘utf-8‘),addr)
9     time.sleep(1)

 1 ‘‘‘‘‘‘
 2 """
 3 自定义UDP协议
 4 """
 5 import socketserver
 6 
 7 class MyServer(socketserver.BaseRequestHandler):
 8     def handle(self):
 9         print(‘weclcome to you!‘)
10         while True:
11             date,sock = self.request
12             # 客户端地址
13             print(self.client_address)
14             print(date.decode(‘utf-8‘))
15             sock.sendto(date.upper(),self.client_address)
16 if __name__ == "__main__":
17     """
18     只要有客户端连接,会自动交给自定义类中handle方法去处理
19     """
20     server = socketserver.ThreadingUDPServer((‘127.0.0.1‘,8999),MyServer)  # 创建一个基于TCP的对象
21     server.serve_forever()  # 启动该服务对象

 1 复习
 2 socket套接字
 3 TCP协议
 4 1.最简易版本的客户端与服务端通信
 5 2.通信循环
 6 recv()  阻塞
 7 3.连接循环
 8 accept()  阻塞
 9 4.TCP粘包问题
10 struct模块 对数据进行打包处理
11 pack  unpack
12 
13 服务端:
14     1.生成一个字典
15     2.制定该字典的报头
16     json序列化
17     编码统计长度
18     3.发送字典的报头
19     4.发送字典
20     5.最后发真实数据
21 客户端:
22     1.现接受固定长度的4个字节字典报头
23     2.解析获取字典数据的长度
24     unpack(...)[0]
25     3.接受字典数据
26     解码,反序列化
27     4.接受真实数据
28 
29 ps:为什么要多加一个字典?
30     1.打包的数据大小有限
31     2.可以携带更多的信息
32 
33 并发:看起来像同时运行的
34 并行:真正意义上的同时运行