网络编程三

一 .TCP上传大文件

Server端

import socket
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 = conn.recv(4)

            dict_size = struct.unpack(‘i‘,header)[0]

            dic_byte = conn.recv(dict_size)

            dic = json.loads(dic_byte.decode(‘utf-8‘))

            file_size = dic.get(‘file_size‘)
            recv_size = 0
            with open(dic.get(‘file_name‘),‘wb‘) as f :
                while recv_size <file_size :
                    data = conn.recv(1024)
                    f.write(data)
                    recv_size += len(data)
                    print(‘#####******####‘)
            print(‘上传成功‘)

        except ConnectionResetError :
            break
    conn.close()

Client端

import socket
import json
import struct
import os

client = socket.socket()

client.connect((‘127.0.0.1‘,8080))

while True :

    MOVIE_DIR = r‘D:\笔记\film‘
    movie_list = os.listdir(MOVIE_DIR)

    for index,movie in enumerate(movie_list,1) :
        print(index,movie)

    choice = input(">> : ").strip()

    if choice.isdigit():
        choice = int(choice)-1

        if choice >= 0 and choice <len(movie_list) :

            file_name = movie_list[choice]
            file_path = os.path.join(MOVIE_DIR,file_name)
            file_size = os.path.getsize(file_path)

            d = {
                ‘file_name‘ : file_name,
                ‘file_size‘ : file_size,
                ‘info‘   : ‘高清无码‘
            }

            json_d = json.dumps(d)
            dic_byte = json_d.encode(‘utf-8‘)

            header = struct.pack(‘i‘,len(dic_byte))
            client.send(header)
            client.send(dic_byte)

            with open(file_path,‘rb‘) as f :
                for line in f :
                    client.send(line)
        else:
            print(‘out of range‘)
    else:
        print(‘not is digit‘)

二.异常机制

异常 : 程序运行中出现了不可预知的错误，没有相应的处理机制来进行处理，

　　   程序就会中断，抛出异常。

异常的结构 ：

　　　　　　异常类型

　　　　　　异常的信息

　　　　　　异常的位置

异常的类型：

　　　　　　语法错误

　　　　　　逻辑错误

异常的抛出方式 ：

　　　　　　　　程序运行出错被动抛出

　　　　　　　　使用raise 异常类型 （异常信息），主动抛出

异常的处理 ：

try:

    l = [1,2,3]
    l[111]
    # Exception和BaseException都是万能异常
    #其中BaseException是Exception
except BaseException:  # 万能异常  所有的异常类型都被捕获
    print(‘6666‘)

与其他关键字的配合使用：

　　　　　　　　else ：与try  : ......except连用，程序没有抛出异常才会执行

　　　　　　　　finally：与try  : ......except连用，无论有没有异常都会执行

断言 assert：猜测某个数据的状态，猜错了抛出AssertionError异常。猜对了，代码正常执行

自定义异常：

class MyError(BaseException):
     def __init__(self,msg):
         super().__init__()
         self.msg=msg
     def __str__(self):
         return ‘<dfsdf%ssdfsdaf>‘ %self.msg

raise MyError(‘我自己定义的异常‘) 

三.TCP与UDP的区别

TCP(Transmission Control Protocol):

会粘包

不能发送空格

服务端不存在的情况下，客户端会报错

不支持并发

UDP(User Datagram Protocol):

自带报文头，不会粘包

支持发送空格

服务端不存在的情况下，客户端也不会报错

支持并发

PS :并发:看起来像同时运行的 ;并行:真正意义上的同时运行

四.UDP的基本使用

服务端

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)

五.SocketServer

TCP服务端

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()  # 启动该服务对象

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

UDP客户端

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()  # 启动该服务对象

UDP服务端

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)

原文地址：https://www.cnblogs.com/Cpsyche/p/11324541.html