• day08

    异常处理
    报错格式及顺序

    1. try:
    2. print("try报错 就匹配执行except类型,没有则报错,Exception指定所有报错")
    3.  
    4. except Exception as e:
    5. print(e)
    6.  
    7. else:
    8. print("如果try没报错,执行else")
    9.  
    10. finally:
    11. print("无论执行try或else 最后都执行finally")

    简单实例

    1. #输入1或0
    2. try:
    3. s = 1
    4. if s is 0:
    5. #print("%s 是错误的"%s)
    6. raise NameError("%s 是错误的"%s) #如果引发NameError异常，后面的代码将不能执行
    7. print(len(s))
    8. except TypeError:
    9. print("%s 是错误的" % s)

    实例

    1. #捕获出错后,提示异常信息,且不退出,捕获错误可多个
    2. #Exception捕获所有错误,写其他错误类型就是捕获具体错误类型,写一种类型加一个except
    3. #输入字符串 提示报错并继续
    5. while True:
    6. num1 = input("请输入第一位数字:")
    7. num2 = input("请输入第二位数字:")
    8. try:
    9. num1 = int(num1)
    10. num2 = int(num2)
    11. result = num1 + num2
    12. exit("%s + %s = %s"%(num1,num1,result))
    13.     
    14. except NameError as e:            #捕获具体错误,后操作如下,报错重要性可写入log,也可忽略,
    15. print("出现异常,信息如下:")
    16. print(e)
    17. except Exception as e:            #捕获所有错误
    18. print("出现异常,信息如下:")
    19. print(e)
    20.  
    21. #invalid literal for int() with base 10: 'asfd' 这是说第10行输入不是int类型
    22.   
     

    主动错误模式

    1. try:
    2. raise Exception('错误了。。。')
    3. except Exception as e:
    4. print(e)
    5. #错误了。。。
     

    自定义异常模式

    1. class guolm(Exception): #创建类 传参是Exception(所有报错)
    2. def __init__(self,msg):
    3. self.message = msg
    4. def __str__(self):
    5. return self.message
    6. try:
    7. raise guolm("我的异常") #主动异常
    8. except guolm as e:
    9. print(e)
    11. #我的异常
     

    断言

    2. assert 1 == 1    #条件满足则继续
    3. assert 1 == 2    #条件不满足则报错
     

    错误类型

    1. python2.x捕获异常语法：
    3. try:
    4. ...some functions...
    5. except Exception, e:
    6. print(e)
    8.  
    10. python3.x捕获异常语法：
    12. try:
    13. ...some functions...
    14. except Exception as e:
    15. print(e)
    17. 注意这里 Exception, e 变成了 Exception as e
    18. python常见的异常类型
    20. 0. Exception             捕获所有错误
    21.  
    22. 1. NameError：            尝试访问一个未申明的变量
    24. >>> v
    25. NameError: name 'v' is not defined
    27.  
    29. 2. ZeroDivisionError：    除数为0
    31. >>> v = 1/0
    32. ZeroDivisionError: int division or modulo by zero
    34.  
    36. 3. SyntaxError：         语法错误
    38. int int
    39. SyntaxError: invalid syntax (<pyshell#14>, line 1)
    41.  
    43. 4. IndexError：         索引超出范围
    45. List = [2]
    46. >>> List[3]
    47. Traceback (most recent call last):
    48. File "<pyshell#18>", line 1, in <module>
    49. List[3]
    50. IndexError: list index out of range
    52.  
    54. 5. KeyError：            字典关键字不存在,试图访问字典里不存在的键
    56. Dic = {'1':'yes', '2':'no'}
    57. >>> Dic['3']
    58. Traceback (most recent call last):
    59. File "<pyshell#20>", line 1, in <module>
    60. Dic['3']
    61. KeyError: '3'
    63.  
    65. 6. IOError：             输入输出错误:基本上是无法打开文件
    67. >>> f = open('abc')
    68. IOError: [Errno 2] No such file or directory: 'abc'
    70.  
    72. 7. AttributeError：        访问未知对象属性
    74. >>> class Worker:
    75. def Work():
    76. print("I am working")
    78. >>> w = Worker()
    79. >>> w.a
    80. Traceback (most recent call last):
    81. File "<pyshell#51>", line 1, in <module>
    82. w.a
    83. AttributeError: 'Worker' object has no attribute 'a'
    85.  
    87. 8.ValueError：            数值错误
    89. >>> int('d')
    90. Traceback (most recent call last):
    91. File "<pyshell#54>", line 1, in <module>
    92. int('d')
    93. ValueError: invalid literal for int() with base 10: 'd'
    95.  
    97. 9. TypeError：            类型错误
    99. >>> iStr = '22'
    100. >>> iVal = 22
    101. >>> obj = iStr + iVal;
    102. Traceback (most recent call last):
    103. File "<pyshell#68>", line 1, in <module>
    104. obj = iStr + iVal;
    105. TypeError: Can't convert 'int' object to str implicitly
    107.  
    108. 10. AssertionError：        断言错误
    110. >>> assert 1 != 1
    111. Traceback (most recent call last):
    112. File "<pyshell#70>", line 1, in <module>
    113. assert 1 != 1
    114. AssertionError
    116.  
    118. 11. MemoryError:            内存耗尽异常
    119. 12.ImportError 无法引入模块或包；基本上是路径问题或名称错误
      13.IndentationError 语法错误（的子类） ；代码没有正确对齐
      14.KeyboardInterrupt Ctrl+C被按下
15.UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，
导致你以为正在访问它
    120.  
    121.  
    122. 16. NotImplementedError：    方法没实现引起的异常
    124. class Base(object):
    125. def __init__(self):
    126. pass
    128. def action(self):
    129. #抛出异常，说明该接口方法未实现
    130. raise NotImplementedError
    132.  
    133. 17. LookupError：            键、值不存在引发的异常
    135. LookupError异常是IndexError、KeyError的基类， 如果你不确定数据类型是字典还是列表时，可以用LookupError捕获此异常
    136.  
    137.  
    138. 18. StandardError           标准异常
    140. 除StopIteration, GeneratorExit, KeyboardInterrupt 和SystemExit外，其他异常都是StandarError的子类。
    142. 错误检测与异常处理区别在于：错误检测是在正常的程序流中，处理不可预见问题的代码，例如一个调用操作未能成功结束
     
    更多错误
    1. ArithmeticError
    2. AssertionError
    3. AttributeError
    4. BaseException
    5. BufferError
    6. BytesWarning
    7. DeprecationWarning
    8. EnvironmentError
    9. EOFError
    10. Exception
    11. FloatingPointError
    12. FutureWarning
    13. GeneratorExit
    14. ImportError
    15. ImportWarning
    16. IndentationError
    17. IndexError
    18. IOError
    19. KeyboardInterrupt
    20. KeyError
    21. LookupError
    22. MemoryError
    23. NameError
    24. NotImplementedError
    25. OSError
    26. OverflowError
    27. PendingDeprecationWarning
    28. ReferenceError
    29. RuntimeError
    30. RuntimeWarning
    31. StandardError
    32. StopIteration
    33. SyntaxError
    34. SyntaxWarning
    35. SystemError
    36. SystemExit
    37. TabError
    38. TypeError
    39. UnboundLocalError
    40. UnicodeDecodeError
    41. UnicodeEncodeError
    42. UnicodeError
    43. UnicodeTranslateError
    44. UnicodeWarning
    45. UserWarning
    46. ValueError
    47. Warning
    48. ZeroDivisionError
    50. 更多异常
     
    





    socket
    

      

    1. #socket 讲解 http://www.cnblogs.com/alex3714/articles/5227251.html
      2. 

    2. # 武老师 http://www.cnblogs.com/wupeiqi/articles/5040823.html
      3. 

    3. import socket
      4. 

    4. phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)     #获取tcp/ip套接字
      5. 

    5. #phone = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) #获取udp/ip套接字
      6. 

    6. phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #防止端口结束不释放
      7. 

    7. phone.bind(('127.0.0.1',8010)) #绑定服务端ip+端口
      8. 

    8. phone.listen(5) #监听最大连接数为5
      9. 

    9.  
      10. 

    10. phone.setblocking(bool) #是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错
      11. 

      12. 

    12. phone.accept()
      13. 

    13. #conn,client_addr=phone.accept() #conn是建立连接(具体跟某个用户的连接通信),client_addr是客户端访问的ip+port
      14. 

    14. #接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。
      15. 

    15. #接收TCP 客户的连接（阻塞式）等待连接的到来
      16. 

      17. 

    17. phone.connect(('127.0.0.1',8080)) #连接server服务的ip+port 连接请求
      18. 

    18. phone.close() #关闭连接
      19. 

    19. phone.recv(1024) #一次接受数据大小
      20. 

    20. sk.recvfrom(bufsize[.flag]) #和recv一样,只是多了从哪里接受的数据地址
      21. 

      22. 

    22. sk.send(string[,flag]) #发送数据 所有通信(整个手机的通信)
      23. 

    23. sk.sendall(string[,flag]) #发送所有数据
      24. 

    24. sk.sendto(string[,flag],address) #和send功能一样 但需要指定远程地址,一半不用
      25. 

    25. sk.settimeout(timeout) #超时时间 连接远程机器 多长时间超时
      26. 

    26. sk.getpeername() #返回远程地址 返回值通常是元组（ipaddr,port）
      27. 

    27. sk.getsockname() #返回本机地址。通常是一个元组(ipaddr,port)
      28. 

      29. 

    29. sk.fileno() #套接字的文件描述符
      30. 

    30. socket.sendfile(file, offset=0, count=None) #发送文件 ，但目前多数情况下并无什么卵用
      31. 

    

     
    


    


    socket实现简单通信 
    

    运行方式先启动server在启动client
    

    server端
    

      

    1. import socket
      2. 

    2. server=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #获取tcp/ip套接字 socket.AF_INET家庭模式 socket.SOCK_STREAM通讯方式是tcp
      3. 

    3. #phone = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 获取udp/ip套接字
      4. 

    4.  
      5. 

    5. server.bind(("127.0.0.1",8000)) #绑定服务端ip+port
      6. 

    6.  
      7. 

    7. server.listen(5) #最大监听连接数为5
      8. 

    8. conn,client_addr=server.accept() #接受用户连接并返回数据
      9. 

    9.  
      10. 

    10. #conn是建立连接(具体跟某个用户的连接通信,当前连接的用户),client_addr是客户端访问的ip+port
      11. 

    11. print(conn,client_addr)
      12. 

      13. 

    13. while True:
      14. 

    14.  data=conn.recv(1024) #1024是字节 #一次接收数据最大值
      15. 

    15.  print("rece",data)
      16. 

    16.  conn.send(b"got your msg") #发送数据,conn.send()发送数据给正在连接的conn用户
      17. 

    

    client端
    

    

      

    1. import socket
      2. 

    2. client=socket.socket() #固定连接
      3. 

    3. client.connect(("127.0.0.1",8000)) #指定服务端ip+port
      4. 

    4.  
      5. 

    5. while True: #指定循环发送数据
      6. 

    6.  msg= input(">>>").strip()
      7. 

    7.  if len(msg)==0:continue #用户输入不为空
      8. 

    8.  client.send(msg.encode()) #发送byte类型数据
      9. 

    9.  #client.send(b"hello") #python只能发bite数据,encode()默认是byte类型
      10. 

    10.  
      11. 

    11.  print("send",msg)
      12. 

    12.  data=client.recv(1024) #接受单次数据最大值1024字节
      13. 

    13.  print("receive from server:",data)
      14. 

    

    




    socket实现简单通信 ,多个用户交互连接不中断
    

     
    

    server端
    

      

    1. import socket
      2. 

    2. server=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
      3. 

    3. #获取tcp/ip套接字 socket.AF_INET家庭模式 socket.SOCK_STREAM通讯方式是tcp
      4. 

    4. #phone = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)获取udp/ip套接字
      5. 

      6. 

    6. server.bind(("127.0.0.1",8000)) #绑定服务端ip+port
      7. 

    7. server.listen(5) #最大监听连接数为5
      8. 

      9. 

    9. while True: #当前用户断开,下一个用户连接正常接入
      10. 

    10.  conn,client_addr=server.accept() #接受用户连接并返回数据
      11. 

    11.  #conn是建立连接(具体跟某个用户的连接通信,当前连接的用户),client_addr是客户端访问的ip+port
      12. 

    12.  print(conn,client_addr)
      13. 

      14. 

    14.  while True: #用于用户多次交互
      15. 

    15.  try:
      16. 

    16.  data=conn.recv(1024) #1024是字节 #一次接收数据最大值
      17. 

    17.  print("rece",data)
      18. 

    18.  conn.send(b"got your msg") #发送数据,conn.send()发送数据给正在连接的conn用户
      19. 

    19.  except Exception: #因为client断开会影响server端 特加异常处理
      20. 

    20.  #conn.close() #这个不需要加 会自动释放
      21. 

    21.  break
      22. 

    

    client
    

    看第一次client配置 (这次配置2个用户,)
    

     
    

    执行方式 先开启服务器 在开启client端(2个)
    


    

    粘包
    socket 模拟ssh登录
    

    执行方式 先启动server 再启动client
    

    server端
    

      

    1. import  socket
      2. 

    2. import subprocess
      3. 

    3. server=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
      4. 

    4. server.bind(("127.0.0.1",8300))                              #绑定服务端ip+port
      5. 

    5. server.listen(5)                                             #最大监听连接数为5
      6. 

      7. 

    7. while True:                                                  #当前用户断开,下一个用户连接正常接入
      8. 

    8.     conn,client_addr=server.accept()                         #接受用户连接并返回数据
      9. 

    9.     print(conn,client_addr)
      10. 

      11. 

    11.     while True:                                              #用于用户多次交互
      12. 

    12.             data=conn.recv(1024)    #1024是字节               #一次接收数据最大值
      13. 

    13.             print("rece",data)
      14. 

      15. 

    15.             res_obj= subprocess.Popen(data, shell=True, stdout=subprocess.PIPE,stderr=subprocess.PIPE)
      16. 

    16.             res= res_obj.stdout.read()                      #读取成功日志
      17. 

    17.             conn.send(str(len(res)).encode())                 #len转成str并变成byte格式
      18. 

    18.             print("---res len---",len(res),str(len(res)).encode())
      19. 

    19.             conn.send(res)                                    #发送数据
      20. 


    


    

    client端
    

    

    

      

    1. import socket
      2. 

    2. client=socket.socket()                 #固定连接
      3. 

    3. client.connect(("127.0.0.1",8300))     #指定服务端ip+port
      4. 

    4. while True:                            #指定循环发送数据
      5. 

    5.     msg= input(">>>").strip()
      6. 

    6.     if len(msg)==0:continue            #用户输入不为空
      7. 

    7.     client.send(msg.encode())          #发送byte类型数据
      8. 

      9. 

    9.     data=client.recv(1024)             #接受单次数据最大值1024字节
      10. 

    10.     total_size = int(data.decode())
      11. 

    11.     received_size = 0
      12. 

    12.     res = b''                               #定义byte格式
      13. 

    13.     while  received_size < total_size:  #total_size是server端发送的数据,如果不为执行如下
      14. 

    14.         d = client.recv(1024)           #每次接受1024,
      15. 

    15.         res += d
      16. 

    16.         received_size += len(d)         #received_size == total_size后,说明接受完毕,结束循环
      17. 

    17.     print("--------end----------------------------")
      18. 

    18.     print(res.decode())                 #解密显示数据
      19. 


    

     
    


    


    

     
    



    




    


    




    服务器端
    

      

    1. import socket
      2. 

    2. #获取tcp/ip套接字
      3. 

    3. phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #获取tcp/ip套接字
      4. 

    4. #phone = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 获取udp/ip套接字
      5. 

    5. phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #防止端口结束不释放
      6. 

    6. phone.bind(('127.0.0.1',8010))                            #绑定服务端ip+端口
      7. 

    7. phone.listen(5)                                           #最大连接数
      8. 

    8. print('server start...')
      9. 

    9. while True: #链接循环
      10. 

    10.     conn,client_addr=phone.accept()
      11. 

    11.     print(conn,client_addr)
      12. 

      13. 

    13.     while True: #通讯循环
      14. 

    14.         try:
      15. 

    15.             client_data=conn.recv(1024)                    #接受数据
      16. 

    16.             if not client_data:break #针对linux系统
      17. 

    17.             conn.send(client_data.upper())                #发送数据 #sedall 发送所有数据
      18. 

    18.                                                           #
      19. 

    19.         except Exception: #针对windwos
      20. 

    20.             break
      21. 

    21.     conn.close()                                          #这是客户端链接断开
      22. 

      23. 

    23. phone.close()                                             #这是服务端断开
      24. 

      25. 

    25. #socket.SOCK_STREAM #流式协议,基于tcp协议
      26. 

    26. #socket.SOCK_DGRAM #udp协议 数据报协议
      27. 

      28. 

    28. #bind内写元祖 ,内学本机ip+port
      29. 

    29. #phone.listen(5) 最大挂起连接数为5
      30. 

    30. #conn.recv(1024) 收发消息 最大接受限制1024
      31. 

      32. 

    32. #conn 是socket记录信息
      33. 

    33. #<socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8080), raddr=('127.0.0.1', 60617)>
      34. 

    34. #client_addr 是客户端访问的ip+port,('127.0.0.1', 60617)
      35. 


    

     
    

    client端 可以多个
    

    

      

    1. import socket
      2. 

    2. phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
      3. 

    3. phone.connect(('127.0.0.1',8080))
      4. 

      5. 

    5. while True:
      6. 

    6.     msg=input('>>: ').strip()
      7. 

    7.     if not msg:continue
      8. 

    8.     phone.send(msg.encode('utf-8'))
      9. 

    9.     # print('====>has send')
      10. 

    10.     server_data=phone.recv(1024)
      11. 

    11.     # print('====>has recv')
      12. 

    12.     print(server_data.decode('utf-8'))
      13. 

      14. 

    14. phone.close()
      15. 


    

     
    


    





    

    python解决办法
    

    

      

    1. phone=socket(AF_INET,SOCK_STREAM)
      2. 

    2. phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
      3. 

    3. phone.bind(('127.0.0.1',8080))
      4. 


    

     
    


    

    linux解决办法
    

    

      

    1. 发现系统存在大量TIME_WAIT状态的连接，通过调整linux内核参数解决，
      2. 

    2. vi /etc/sysctl.conf
      3. 

      4. 

    4. 编辑文件，加入以下内容：
      5. 

    5. net.ipv4.tcp_syncookies = 1
      6. 

    6. net.ipv4.tcp_tw_reuse = 1
      7. 

    7. net.ipv4.tcp_tw_recycle = 1
      8. 

    8. net.ipv4.tcp_fin_timeout = 30
      9. 

      10. 

    10. 然后执行 /sbin/sysctl -p 让参数生效。
      11. 

      12. 

    12. net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭；
      13. 

      14. 

    14. net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭；
      15. 

      16. 

    16. net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。
      17. 

      18. 

    18. net.ipv4.tcp_fin_timeout 修改系統默认的 TIMEOUT 时间
      19. 


    


    


    


    


    
    
          
    • 

          
  • 

            相关阅读:
    
            
              php 删除指定文件夹
                
    php 批量进行复制文件
                
    php 导入/导出 csv 文件
                
    Java8 Nashorn JavaScript引擎
                
    Java8 Optional类
                
    Java8数据流
                
    Java8默认方法
                
    异常的其他问题
                
    package和import语句_5
                
    继承和权限控制_1
                
                    
          
    • 
          
  • 
            原文地址：https://www.cnblogs.com/Gavinkwok/p/7426923.html
          
    • 

        

      



      
      

        

        

      

    

  


  

  
Copyright © 2020-2023 
  润新知