TCP与UDP协议

一、文件的上传与下载

　　服务端

　　　　1.先接受4个长度的报头

　　　　2.解析报头获取字典长度

　　　　3.接收字典数据，从字典中获取真实数据的详细信息

　　　　4.接收真实数据

import socket
import os
import json
import struct


server = socket.socket()
server.bind(('127.0.0.1',8080))
server.listen(5)

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

　　客户端

　　　　（1）制作字典的报头（固定4个长度）

　　　　（2）发送报头

　　　　（3）发送字典

　　　　（4）最后再发真实数据

import socket
import json
import os
import struct


client = socket.socket()
client.connect(('127.0.0.1',8080))

while True:
    # 获取电影列表 循环展示
    MOVIE_DIR = r'D:python脱产10期视频day25视频'
    movie_list = os.listdir(MOVIE_DIR)
    # print(movie_list)
    for i,movie in enumerate(movie_list,1):
        print(i,movie)
    # 用户选择
    choice = input('please choice movie to upload>>>:')
    # 判断是否是数字
    if choice.isdigit():
        # 将字符串数字转为int
        choice = int(choice) - 1
        # 判断用户选择在不在列表范围内
        if choice in range(0,len(movie_list)):
            # 获取到用户想上传的文件路径
            path = movie_list[choice]
            # 拼接文件的绝对路径
            file_path = os.path.join(MOVIE_DIR,path)
            # 获取文件大小
            file_size = os.path.getsize(file_path)
            # 定义一个字典
            res_d = {
                'file_name':'性感荷官在线发牌.mp4',
                'file_size':file_size,
                'msg':'注意身体,多喝营养快线'
            }
            # 序列化字典
            json_d = json.dumps(res_d)
            json_bytes = json_d.encode('utf-8')

            # 1.先制作字典格式的报头
            header = struct.pack('i',len(json_bytes))
            # 2.发送字典的报头
            client.send(header)
            # 3.再发字典
            client.send(json_bytes)
            # 4.再发文件数据(打开文件循环发送)
            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')

二、异常处理

　　1.什么是异常

　　　　程序在运行过程中出现了不可预知的错误，并且该错误没有对应的处理机制，那么就会以异常的形式表现出来，造成的影响就是整个程序无法再正常运行

　　2.异常的结构

　　　　（1）异常的类型：NAMEERROR

　　　　（2）异常的信息：name 'fdsfdsajkd' is not defined

　　　　（3）异常的位置：Traceback (most recent call last):

File "D:/python脱产10期视频/day29/01 异常处理.py", line 1, in <module>
fdsfdsajkd

　　3.异常的种类

　　　　分为两大类

　　　　　　（1）语法错误

　　　　　　　　是你程序立刻就能解决的，这种错误是不能容忍的

　　　　　　　　语法上的错误发现之后就应该立刻解决

　　　　　　（2）逻辑错误

　　　　　　　　这种错误是可以被容忍的，因为一眼看不出来

　　　　　　　　针对逻辑上的错误，可以采用异常处理机制来进行捕获

　　　　常见的错误类型

　　　　　　NameError　　名字错误　　

　　　　　　SyntaxError　  语法错误

　　　　　　KeyError　　　键不存在

　　　　　　ValueError　　 值错误　　

　　　　　　IndexError　　 索引错误

　　　　如何避免

　　　　　　异常处理

　　　　　　　　在你认为可能会出现bug的代码块上方try一下：注意try内部的代码块越少越好

　　　　　　格式

　　　　　　try:

　　　　　　　　可能出错的代码

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

　　　　　　　　出错之后的处理机制

　　　　　　万能异常（Exception和BaseException）:所有类型异常都被捕获

　　4.主动抛异常

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

　　5.断言

　　　　猜某个数据的状态，猜对了不影响代码执行正常走

　　　　猜错了，直接报错

l = [1,2,3]
assert len(l) < 0  # 断言  预言

　　6.自定义异常

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

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

三、UDP基本使用

　　1.UDP协议

　　　　数据报协议（自带报头）

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

　　2.UDP特点

　　　　（1）udp协议客户端允许发空

　　　　（2）udp协议不会粘包

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

　　　　（4）udp协议支持并发

　　　　ps:并发：看起来像同时运行的，并行：真正意义上的同时运行

　　3.代码

　　　　服务端

import socket


server = socket.socket(type=socket.SOCK_DGRAM)  # UDP协议
server.bind(('127.0.0.1',8080))
# UDP不需要设置半连接池 它也没有半连接池的概念

# 因为没有双向通道  不需要accept  直接就是通信循环
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)

　　4.验证udp协议有无粘包问题

import socket
server = socket.socket(type=socket.SOCK_DGRAM)
server.bind(('127.0.0.1',8080))
print(server.recvfrom(1024))
print(server.recvfrom(1024))
print(server.recvfrom(1024))

import socket
client = socket.socket(type=socket.SOCK_DGRAM)
server_addr = ('127.0.0.1',8080)
client.sendto(b'hello',server_addr)
client.sendto(b'hello',server_addr)
client.sendto(b'hello',server_addr)

四、TCP与UDP的区别

　　1.基于连接与无连接

　　2.对系统资源的要求（TCP较多，UDP少）

　　3.UDP程序结构较简单

　　4.流模式与数据报模式

　　5.TCP保证数据正确性，UDP可能丢包，TCP保证数据顺序，UDP不保证

五、socketserver模块

　　服务端

import socketserver


class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        # print('来啦 老弟')
        while True:
            data = self.request.recv(1024)
            print(self.client_address)  # 客户端地址
            print(data.decode('utf-8'))
            self.request.send(data.upper())


if __name__ == '__main__':
    """只要有客户端连接  会自动交给自定义类中的handle方法去处理"""
    server = socketserver.ThreadingTCPServer(('127.0.0.1',8080),MyServer)  # 创建一个基于TCP的对象
    server.serve_forever()  # 启动该服务对象

　　客户端

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'))

　　服务端1

import socketserver


class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        # print('来啦 老弟')
        while True:
            data,sock = self.request
            print(self.client_address)  # 客户端地址
            print(data.decode('utf-8'))
            sock.sendto(data.upper(),self.client_address)


if __name__ == '__main__':
    """只要有客户端连接  会自动交给自定义类中的handle方法去处理"""
    server = socketserver.ThreadingUDPServer(('127.0.0.1',8080),MyServer)  # 创建一个基于TCP的对象
    server.serve_forever()  # 启动该服务对象

　　客户端1

import socket
import time

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.decode('utf-8'),addr)
    time.sleep(1)

六、一个简易版本的QQ

　　服务端

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'))
    msg = input('>>>:')
    server.sendto(msg.encode('utf-8'),addr)

　　多个客户端

import socket


client = socket.socket(type=socket.SOCK_DGRAM)
server_address = ('127.0.0.1',8080)

while True:
    msg = input('>>>:')
    msg = '来自客户端1的消息:%s'%msg
    client.sendto(msg.encode('utf-8'),server_address)
    data, server_addr = client.recvfrom(1024)
    print(data.decode('utf-8'))