­

python网络编程-异常处理-异常捕获-抛出异常-断言-自定义异常-UDP通信-socketserver模块应用-03

  • 2019 年 10 月 7 日
  • 筆記

异常捕获

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

影响:整个程序无法再正常运行

异常的结构

异常的类型

NameError

异常的信息

name 'safaf' is not defined

异常的位置

'''  Traceback (most recent call last):    File "E:/PyCharm 2019.1.3/ProjectFile/day010/day029/01 异常处理.py", line 1, in <module>      safaf  '''

异常的种类

语法错误

程序错误编译成一般都会直接有提示,提示就应该直接解决的,出现语法错误一般是基础太差

逻辑错误

这种错误是可以被容忍的,逻辑错误无法一眼看出来

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

常见的错误类型

常见的出错类型

原因

NameError

名字错误

SyntaxError

语法错误

keyError

键不存在

ValueError

值错误

IndexError

索引错误

如何避免

异常处理

使用:在你认为可能会出现问题的代码上方用 try 包起来

注意:try 内部的代码块越少越好 异常处理能少用就少用,不然该报错的不报错哪里错了你都不知道 像服务端、客户端断开链接就需要用到异常处理,你不知道他什么时候会断开

异常处理使用模板(try.. except.. else.. finally..)

try:      可能出错的代码  except 出错类型 as e:  # 将报错信息赋值给e      错误的处理代码  except 出错类型2 as e:  # 将报错信息赋值给e      错误的处理代码  except 出错类型3 as e:  # 将报错信息赋值给e      错误的处理代码    # 或者 Exception直接捕获所有的  except Exception as e:  # 可以匹配所有的错误类型      BaseException 是 Exception 的父类,也可以捕获所有类型      错误的处理代码  else:      当被检测的代码没有任何异常发生,才会执行这里面的语句  finally:      无论被检测的代码有没有异常发生,都会在代码执行完后执行这里面的代码

案例

try:      safaf  except NameError as e:      print(e)  else:      print("没有报错才会执行我哦~")  finally:      print("管你报不报错,我都会执行的!")    # name 'safaf' is not defined  # 管你报不报错,我都会执行的!    try:      print("我没错哦~")  except Exception as e:  # 捕捉所有异常      print("管你啥错,我都抓了!")  else:      print("没有报错才会执行我哦~")  finally:      print("管你报不报错,我都会执行的!")  # 我没错哦~  # 没有报错才会执行我哦~  # 管你报不报错,我都会执行的!

补充

出错后会立即停止代码运行,去与except中的错误类型一个个比较,匹配上了就执行里面的代码,没匹配上就直接报错

主动抛出异常raise

if 'egon' == 'DSB':      pass  else:      raise TypeError('尽说大实话')  # 这一行就是报错的位置      # raise 关键字就是用来主动抛出异常的

断言assert

断言不成立直接报错

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

自定义异常(继承异常类)

报错类型,其实对应的就是一个个类(可以自定义拼接异常的格式)

class MyError(BaseException):      def __init__(self, msg):          super().__init__()          self.msg = msg        def __str__(self):          return f'----<{self.msg}>----'    raise MyError('自定义的异常')  # Traceback (most recent call last):  #   File "E:/PyCharm 2019.1.3/ProjectFile/day010/day029/test.py", line 15, in <module>  #     raise MyError('自定义的异常')  # __main__.MyError: ----<自定义的异常>----

UDP通信

UDP协议又叫用户数据报协议

它没有双向通道,类似于发短信(只管发,不管对方有没有收到,不需要对方立即回应)

UDP的程序可以先启动客户端再启动服务端(客户端发数据给服务端之前都没问题)

UDP类似于发短信

TCP类似于打电话,你一句我一句的

普通使用

服务端

import socket    server = socket.socket(type=socket.SOCK_DGRAM)  # type=socket.SOCK_DGRAM 指定成 UDP 协议  type=socket.SOCK_STREAM TCP协议(默认就是,不用指定)  server.bind(('127.0.0.1', 8080))    # UDP 不需要设置半连接池(server.listen(5)),也没有半连接池的概念  # UDP 没有双向通道,所以也不需要建立连接(conn, addr = server.accept())    # 直接就是通信循环    while True:  # 这里只需要直接通信(交互)即可      data, addr = server.recvfrom(1024)      print("数据:", data.decode('utf-8'))  # 客户端发来的消息      print("地址:", addr)  # 客户端的地址        re_msg = input("Please input your response msg:").strip()  # 会阻塞在这里,这里过了,才能发出信息,看到下一条信息      server.sendto(re_msg.encode('utf-8'), addr)  # 向客户端发送消息      # 数据: hi  # 地址: ('127.0.0.1', 64821)  # Please input your response msg:o  hi  # 数据: hihihi  # 地址: ('127.0.0.1', 64823)  # Please input your response msg:xxixixi  # 数据: aha e  # 地址: ('127.0.0.1', 64828)  # Please input your response msg:emmm?  # 数据:  # 地址: ('127.0.0.1', 64828)  # Please input your response msg:adsa

客户端

import socket    client = socket.socket(type=socket.SOCK_DGRAM)    # UDP 不需要建立连接(client.connect(('127.0.0.1', 8080)))    server_addr = ('127.0.0.1', 8080)  # UDP sendto发消息时需要一个服务器的地址及端口号    while True:      msg = input("Please input your msg:").strip()      client.sendto(msg.encode('utf-8'), server_addr)  # 向服务器发送数据,要附带服务器端地址及端口(基于网络传输的数据都必须是二进制的)      data, msg_from_server_addr = client.recvfrom(1024)  # 收到消息,且得到地址        print("服务端发来的数据:", data.decode('utf-8'))      print("服务器端的ip及端口", msg_from_server_addr)    # 窗口1  # Please input your msg:hi  # 服务端发来的数据: o  hi  # 服务器端的ip及端口 ('127.0.0.1', 8080)  # Please input your msg:    # 窗口2  # Please input your msg:hihihi  # 服务端发来的数据: xxixixi  # 服务器端的ip及端口 ('127.0.0.1', 8080)  # Please input your msg:    # 窗口3  # Please input your msg:aha e  #  # 服务端发来的数据: emmm?  # 服务器端的ip及端口 ('127.0.0.1', 8080)  # Please input your msg:服务端发来的数据: adsa  # 服务器端的ip及端口 ('127.0.0.1', 8080)  # Please input your msg:

TCP与UDP之间的区别

  1. UDP 允许发空数据,不会有影响
  2. UDP 直接启动客户端未启动服务端不会报错
  3. UDP 不会有粘包问题(自带报头)
  4. UDP 支持并发

服务端

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'))        server.sendto(data.upper(), addr)

客户端

import socket      client = socket.socket(type=socket.SOCK_DGRAM)    while True:        msg = input(">>>:")      # -------------------------------------------      # 1.UDP 允许发空数据,不会有影响      # -------------------------------------------      # UDP自带报头,就算数据为空,另一端也能处理      client.sendto(msg.encode('utf-8'), ('127.0.0.1', 8080))  # 第二参数,目标服务器地址        # -------------------------------------------      # 2.UDP 直接启动客户端未启动服务端不会报错      #   发数据找不到服务端也还是会报错      # -------------------------------------------      # 下面两行代码直接注释掉,服务端没启动,都不会报错,只管给服务器发(收没收到不管)      # data, server_addr = client.recvfrom(1024)      # print(data)        # -------------------------------------------      # 3.UDP 不会有粘包问题(自带报头)      # -------------------------------------------      # client.sendto(msg.encode('utf-8'), ('127.0.0.1', 8080))      # client.sendto(msg.encode('utf-8'), ('127.0.0.1', 8080))      # client.sendto(msg.encode('utf-8'), ('127.0.0.1', 8080))      #      # server.sendto(data.upper(), addr)      # server.sendto(data.upper(), addr)      # server.sendto(data.upper(), addr)        # -------------------------------------------      # 4.UDP 支持并发      #   TCP是保持连接,而UDP不需要保持连接      #       与一个客户端断开连接才会和下一个客户端建立连接      # -------------------------------------------

简易版的QQ

服务器端

import socket    server = socket.socket(type=socket.SOCK_DGRAM)  server.bind(('127.0.0.1', 8080))    while True:      data, client_addr = server.recvfrom(1024)      print(data.decode('utf-8'))        msg = input(">>>:").strip()      server.sendto(msg.encode('utf-8'), client_addr)    # 来自star3的消息:helo  # >>>:hi  # 来自star2的消息:aha  # >>>:haa  # 来自star的消息:hello world  # >>>:ha  # 来自star2的消息:jason nnn  # >>>:jj

客户端1、2、3共用同一份代码

import socket    client = socket.socket(type=socket.SOCK_DGRAM)    username = 'star'  # 客户端对应改成 star2 star3  server_address = ('127.0.0.1', 8080)  # 指定一个发消息的目标服务器  while True:      msg = input(">>>:").strip()        msg = f'来自{username}的消息:{msg}'  # 是哪个用户名发出的数据不应该由这里传过去,用户可以随便改,实际意义不大      '''      user_dict = {          "username1": (ip1 + port1),          "username2": (ip2 + port2),          "username3": (ip3 + port3),      }      # 可以在每个端都存这样一个对照表,根据ip与port就可以知道用户名了      '''        client.sendto(msg.encode('utf-8'), server_address)        data, server_addr = client.recvfrom(1024)  # server_addr 收到消息的服务端地址        print(data.decode('utf-8'))    # 各个窗口的控制台输入与输出  # >>>:helo  # hi  # >>>:    # >>>:aha  # haa  # >>>:jason nnn  # jj    # >>>:  # >>>:hello world  # ha  # >>>:

概念科普

  • 并发

看起来像同时运行(直接启动多个UDP客户端)(默认的UDP程序多开就是这个效果)

  • 并行

真正意义上的同时运行

socketserver模块科普

是给服务端用的(客户端还是用socket模块),能够支持服务端的并发

TCP模拟UDP实现并发

服务器端

import socketserver  # 文件名不要和模块冲突了,不然都不知道导哪个了      class MyServer(socketserver.BaseRequestHandler):      def handle(self):          # 与客户端进行通信          # print("来啦 老弟")          while True:  # 需要保持通信(后续 client.send() 可没有附带服务器地址, connect 被关闭了)              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()  # 启动该服务对象    # ('127.0.0.1', 14327)  # dAddA  # ('127.0.0.1', 14326)  # ADD  # ('127.0.0.1', 14325)  # ADsafga

客户端

# TCP 实现UDP  import socket    client = socket.socket()  client.connect(('127.0.0.1', 8080))    while True:      res = input(">>>:")      client.send(res.encode('utf-8'))        data = client.recv(1024)      print(data.decode('utf-8'))      # 窗口1 控制台数据(输入与输出)  # >>>:dAddA  # DADDA  # >>>:    # 窗口2 控制台数据(输入与输出)  # >>>:ADD  # ADD  # >>>:    # 窗口1 控制台数据(输入与输出)  # >>>:ADsafga  # ADSAFGA  # >>>:

socketserver之UDP

服务器端

import socketserver  # 文件名不要和模块冲突了,不然都不知道导哪个了      class MyServer(socketserver.BaseRequestHandler):      def handle(self):          # 与客户端进行通信          # while True:  # UDP 不需要通信循环,每次 sendto 都有服务器的地址          data, sock = self.request          print(self.client_address)  # 客户端地址          print(data.decode('utf-8'))          sock.sendto(data.lower(), self.client_address)      if __name__ == '__main__':      '''只要有客户端连接,会自动交给自定义类中的handle方法去处理'''      server = socketserver.ThreadingUDPServer(('127.0.0.1', 8080), MyServer)  # 创建一个基于UDP的对象      server.serve_forever()  # 启动该服务对象    # 控制台打印的数据  # ('127.0.0.1', 52524)  # CLient2  # ('127.0.0.1', 52529)  # clet1  # ('127.0.0.1', 52529)  # CLienT1  # ('127.0.0.1', 54485)  # CLiEnt3

客户端

import socket    client = socket.socket(type=socket.SOCK_DGRAM)    server_addr = ('127.0.0.1', 8080)    while True:      res = input(">>>:").strip()      client.sendto(res.encode('utf-8'), server_addr)        data, response_server_addr = client.recvfrom(1024)      print(data.decode('utf-8'), response_server_addr)    # 窗口1 控制台数据(输入与输出)  # >>>:clIeNt1  # clet1 ('127.0.0.1', 8080)  # >>>:CLienT1  # client1 ('127.0.0.1', 8080)  # >>>:    # 窗口2 控制台数据(输入与输出)  # >>>:CLient2  # client2 ('127.0.0.1', 8080)  # >>>:    # 窗口1 控制台数据(输入与输出)  # >>>:CLiEnt3  # client3 ('127.0.0.1', 8080)  # >>>:

为什么UDP时重写的handle方法里不用写通信循环

handle 是处理一次连接请求的,handle结束连接就断开了    UDP是不需要保持(双向)连接的,所以每次sendto 都是单个请求(都附带服务器端地址及端口),不能写通信循环(不然就拿着一个sendto 过来的数据循环打印了)    而TCP是基于双向通道通信的,handle结束后连接就断开了(再client.send() 这个连接状态就已经不存在了),所以TCP这边的服务端要写通信循环保持连接来多次通信