异常处理 udp通信

上传电影

1.循环打印某个文件夹的所有文件

2.用户选取要上传的文件

3.将用户选择的文件上传到服务器

4.服务器保存你文件

客户端
import socket
import os
import json
import struct
client = socket.socket()
client.connect(('127.0.0.1',8080))
while True:
    MOVIE_DIR = 'G:\Python10期脱产视频\day01\视频'
    movie_list = os.listdir(MOVIE_DIR)
    for i, movie in enumerate(movie_list,1):  # 获取电影列表,循环展示
        print(i,movie)
    choice = input('>>>:').strip()  #用户选择
    if choice.isdigit():   # 判断是否是数字
        choice = int(choice) - 1
        if choice in range(len(movie_list)):   # 判断用户选择的是否在列表中
            path = movie_list[choice]   # 获取用户上传的文件路径
            print(path)
            file_path = os.path.join(MOVIE_DIR,path)   #获取文件路径
            file_size = os.path.getsize(file_path)  #获取文件大小
            print(file_path)
            print(file_size)
            res = {'name':'大保健','file_size':file_size}  #定义一个字典
            json_d = json.dumps(res)   # 序列化字典
            json_bytes = json_d.encode('utf-8')
            print(json_bytes)
            header = struct.pack('i',len(json_bytes))  #制作一个报头
            client.send(header)  #发送报头
            client.send(json_bytes)  # 发送字典
            with open(file_path,'rb')as f:   # 发文件数据
                for line in f:
                    client.send(line)
        else:
            print('not in range')
    else:
        print('must be a number')

服务端
import socket
import struct
import json
import os
server = socket.socket()
server.bind(('127.0.0.1',8080))
server.listen(5)
while True:
    sock,addr = server.accept()
    while True:
        try:
            header_len = sock.recv(4)   # 解析字典报头
            header_len = struct.unpack('i',header_len)[0]
            header_dic = sock.recv(header_len)  # 接收字典数据
            real_dic = json.loads(header_dic.decode('utf-8'))
            print(real_dic)
            print(real_dic.get('file_size'))
            total_size = real_dic.get('file_size')  # 获取字典长度
            print(total_size)
            recv_size = 0  #循环写入文件
            print(real_dic.get('file_size'))
            with open(real_dic.get('name'),'wb')as f:
                while recv_size < total_size:
                    data = sock.recv(1024)
                    f.write(data)
                    recv_size += len(data)
                print('上传成功')
        except ConnectionResetError as e:
            print(e)
            break
    sock.close()

 

异常处理

异常处理是在程序运行中出现不可预知的错误,并且该机制没有对应的处理机制,就会报错,使的整个程序无法正常运行

异常的结构

1.异常的位置: Traceback (most recent call last):
                  　　File "D:/python脱产10期视频/day29/01 异常处理.py", line 1, in <module>fdsdfsdf

2.异常的类型: NameError

3.异常的信息: name 'fdsdfsdf' is not defined

 

异常分两类:

1. 语法错误:能够一眼看得到,能够立马解决

2.逻辑错误:一眼看不出来.可以采用异常处理进行捕获

常见的错误类型
            NameRrror     名字错误
            SyntaxError  语法错误
            KeyError     键不存在
            ValueError   值错误
            IndexError   索引错误

 

如何避免异常处理: 在可能出现bug的代码上方try一下, try越少越好

try:

　　可能出错的代码

except 出错的类型    as  e:  #  将报错的信息赋值给变量

　　出错之后的处理机制

try:
    res = {'name':''}
    print(res['pwd'])
    print(res.get('pwd','None'))
except KeyError:   #  键值错误
    print('KeyError')
except NameError:   # 变量名错误
    print('NameError')
except IndexError:    # 索引错误
    print('IndexError')
except Exception:     # 所有异常都可以捕获
    print('Exception')
except BaseException:   # 所有异常都可以捕获
    print('BaseException')

try:
    l = [1,2,3]
    l[111]
except Exception:  # 万能异常  所有的异常类型都被捕获
    print('老子天下无敌')
else:
    print('被检测的代码没有任何的异常发生 才会走else')
finally:
    print('无论被检测的代码有没有异常发生 都会在代码运行完毕之后执行我')

#主动抛异常
if 'egon' == 'DSB':
    pass
else:
    raise TypeError('尽说大实话')
# 关键字raise就是主动抛出异常

l = [1,2,3]
assert len(l) < 0  # 断言  预言
# 猜某个数据的状态 猜对了 不影响代码执行 正常走
# 猜错了  直接报错

# 自定义异常
class MyError(BaseException):
    def __init__(self, msg):
        super().__init__()
        self.msg = msg
    def __str__(self):
        return '<dfsdf%ssdfsdaf>' % self.msg

raise MyError('我自己定义的异常')  # 主动抛出异常其实就是将异常类的对象打印出来,会走__str__方法

UDP通信

　　　数据报协议(自带报头)

　　　没有双向通道,通信类似于发短信

udp 使用

服务端
import socket
server = socket.socket(type=socket.SOCK_DGRAM)  #UDP协议
server.bind(('127.0.0.1',8080))
while True:
    data,addr = server.recvfrom(1024)
    print('数据:',data)
    print('地址:',addr)
    server.sendto(data.upper(),addr)

服务端
import socket
client = socket.socket(type=socket.SOCK_DGRAM)
server_address = ('127.0.0.1',8080)
while True:
    client.sendto(b'hello',server_address)
    data,addr = client.recvfrom(1024)
    print('服务端发来的数据',data)
    print('服务端发来的地址',addr)

 

1. udp协议客户端允许发空

2. udp协议不会粘包

3. udp协议服务端不存在的情况下,客户照样不会报错

4. udp协议支持并发

简易版qq

客户端
import socket
client = socket.socket(type=socket.SOCK_DGRAM)
server_address = ('127.0.0.1',8080)
while True:
    res = input('>>>:').strip()
    client.sendto(res.encode('utf-8'),server_address)
    data,server_address = client.recvfrom(1024)
    print(data.decode('utf-8'))

服务端
import socket
server = socket.socket(type=socket.SOCK_DGRAM)
server.bind(('127.0.0.1',8080))
while True:
    data,addr = server.recvfrom(1024)
    print(data.decode('utf-8'))
    res = input('>>>:').strip()
    server.sendto(res.encode('utf-8'),addr)

 

udp类似于发短信

tcp类似于打电话

tcp 解决粘包
客户端
import socket
client = socket.socket()
client.connect(('127.0.0.1',8080))
while True:
    client.send(b'hello')
    data = client.recv(1024)
    print(data.decode('utf-8'))

服务端
import socketserver
class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            data = self.request.recv(1024)
            print(self.client_address)  # 客户端地址
            print(data.decode('utf-8'))  #
            self.request.send(data.upper())
if __name__ == '__main__':    # 只要有客户连接,会自定义交给类中handler方法去处理
    server = socketserver.ThreadingTCPServer(('127.0.0.1',8080),MyServer)
    server.serve_forever()   #启动该服务器

 

并发: 看起来像同时运行的

并行: 真正的运行

网络编程    TCP粘包问题,上传下载文件