异常处理和UDP协议

一、什么是异常？

　　程序在运行过程中出现了不可预知的错误，并且该错误没对应的处理机制，那么就会以异常的形式表示出来，

造成的影响就是整个程序无法再正常的运行，抛出异常。

二、异常的结构：

　　1：异常的类型：NameError

　　2：异常的信息：name 'sys' is not defined

　　3：异常的位置：File "E:/PY/异常处理机制.py", line 1, in <module>

三、异常的两类：

　　1：语法错误：

　　　　　　是程序就显示提示的错误，应该立即解决，这种错误是不能容忍的

　　2：逻辑错误：

　　　　这种错误一般是一眼看不出来的，是可以被容忍的，针对逻辑上的错误，是可以采用异常处理机制进行捕获的

四、常见的错误类型：

　　　　名字错误：NAMERROR

　　　　键不存在：KeyError

　　　　值错误：ValueError

　　　　索引错误：IndexError

　　　　语法错误：SyntaxError

　　　　......

五、如何避免？

　　异常处理：在认为可能会出现bug的代码块上方用 try一下，要注意的是try 里的内容越少越好：

　　异常处理机制的固定语法：

　　　　try:

　　　　　　可能出错的代码

　　　　　　.......

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

　　　　>>出错后的处理机制

　　　　

六、python常用的内置异常：

　　所有异常的超类：BaseException

　　　　BaseException是所有内置异常的基类，但用户定义的类不能直接继承BaseExpxeption,所有的异常类都是从Exception继承，且都在exceptions模块中定义.

class MyError(Exception):
    def __init__(self,msg):
        self.msg= msg
    def __str__(self):
        return  self.msg
try:
    raise MyError("类型的错误！")
except MyError as e:
    print("my exception occurred",e.msg)

>>>
    my exception occurred 类型的错误！

七、异常的捕获：

　　　　python的异常捕获常用try...except...结构，把可能发生错误的语句放在try模块里，用except来处理异常，每一个try，都必须至少对应一个except。此外，与python异常相关的关键字主要有：

　　try/except   捕获异常并处理

　　pass          忽略异常

　　as              定义异常实列（except MyError as e）

　　else         如果Try 中的语句没有引发异常，则会执行else中的语句

　　finally       无论是否出现异常，都执行的代码

　　raise        主动抛出/引发异常

try:
    l = [1,2,3,4]
    l[1221544] # 语法错误
except Exception:
    print("看你还能怎么玩!")  # 有错就执行这一行
else:
    print("无所谓的啦") # 没错就执行这一行代码
finally:
    print("无论被检测的代码有没有异常发生  都会在代码运行完毕后执行我")  # 无论有没有错都执行这一行代码

raise        主动抛出/引发异常

class MyError(BaseException):
    def __init__(self,msg):
        super().__init__()
        self.msg= msg
    def __str__(self):
        return '<苏喂苏喂>' %self.msg
raise MyError("我自己定义的异常：") # 主动抛出异常

万能异常：所有的异常类型都被捕获

try:

     <语句>

except Exception:

      print('异常说明')

raise主动触发异常:

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

八、基于UDP协议的socket

　　udp协议是无连接的，启动服务后可以直接接受消息，不需要提前建立连接

UDP的特点：

　　数据报协议（自带报头），所以客户端发送的内容可为空，报头里自带一部分的内容

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

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

2：udp协议不会黏包

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

4:usp 协议支持并发

可以用代码来验证以上四点特点

UDP基本功能的使用:

服务端server:

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)

客户端:clienct

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)

简单的实现了以上的而几个功能特点,

并发,多个客户端同时进行访问,

不报错: 断开服务器是客户端也能进入待输入的界面,类似于发短信,我发了,不管你收不收得到看不看

允许发空,因为它有一个特点就是自带报头,即使什么也不输入,内容也不为空,报头里自带有一小部分内容,

不像TCP协议,它没有双向通道,不需要先建立三次握手,四次握手手动断开那么复杂,直接就交互

并发概念：看起来像同时运行（客户端看似在同时访问，其实是有时间的间隔，只是比较短）

并行概念：真正意义上的同时运行

UDP协议类似于发短信

TCP协议类似于打电话

总结

黏包现象只发生在tcp协议中：

1.从表面上看，黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。

2.实际上，主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的

九、socketserver  模块

　　利用socketserver模块，可以解决TCP协议实现看起来像UDP一样并发，就是客户端同时访问

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

服务端

重点;

　　用tcp实现

　　　　　　上传文件下载文件的操作