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. 













 






            

            
posted @ 
2017-08-25 10:50 
Gavinkwok 
阅读(193) 
评论(0) 
 
收藏 
举报