week7
7 异常处理
7.1 异常种类
AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x IOError 输入/输出异常；基本上是无法打开文件 ImportError 无法引入模块或包；基本上是路径问题或名称错误 IndentationError 语法错误（的子类） ；代码没有正确对齐 IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5] KeyError 试图访问字典里不存在的键 KeyboardInterrupt Ctrl+C被按下 NameError 使用一个还未被赋予对象的变量 SyntaxError Python代码非法，代码不能编译 TypeError 传入对象类型与要求的不符合 UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量 导致你以为正在访问它 ValueError 传入一个调用者不期望的值，即使值的类型是正确的
ArithmeticError
AssertionError
AttributeError
BaseException
BufferError
BytesWarning
DeprecationWarning
EnvironmentError
EOFError
Exception
FloatingPointError
FutureWarning
GeneratorExit
ImportError
ImportWarning
IndentationError
IndexError
IOError
KeyboardInterrupt
KeyError
LookupError
MemoryError
NameError
NotImplementedError
OSError
OverflowError
PendingDeprecationWarning
ReferenceError
RuntimeError
RuntimeWarning
StandardError
StopIteration
SyntaxError
SyntaxWarning
SystemError
SystemExit
TabError
TypeError
UnboundLocalError
UnicodeDecodeError
UnicodeEncodeError
UnicodeError
UnicodeTranslateError
UnicodeWarning
UserWarning
ValueError
Warning
ZeroDivisionError
7.2 异常基础处理
try: 被检测的代码块 except 异常类型： try中一旦检测到异常，就执行这个位置的逻辑
7.2.1 异常类只能用来处理指定的异常情况，如果非指定异常则无法处理。
s1 = 'hello' try: int(s1) except IndexError as e: # 未捕获到异常，程序直接报错 print e
7.2.2 多分支
s1 = 'hello' try: int(s1) except IndexError as e: print(e) except KeyError as e: print(e) except ValueError as e: print(e)
7.2.3 万能异常Exception
s1 = 'hello' try: int(s1) except Exception as e: print(e)
7.2.4 异常其他结构
s1 = 'hello' try: int(s1) except IndexError as e: print(e) except KeyError as e: print(e) except ValueError as e: print(e) #except Exception as e: # print(e) else: print('try内代码块没有异常则执行我') finally: print('无论异常与否,都会执行该模块,通常是进行清理工作')
7.2.5 主动触发异常
try: raise TypeError('类型错误') except Exception as e: print(e)
7.2.6 自定义异常
class LvException(BaseException): def __init__(self,msg): self.msg=msg def __str__(self): return self.msg try: raise LvException('类型错误') except LvException as e: print(e)
7.3 断言
assert type(obj.name) is str #执行前检查
8 网络编程Socket
8.1 网络通信原理
8.1.1 物理层
主要是基于电器特性发送高低电压（电信号），高电压对应数字1，低电压对应数字0
8.1.2 数据链路层
数据链路层的功能：定义了电信号的分组方式。
以太网协议ethernet规定
- 一组电信号构成一个数据包，叫做'帧’
- 每一数据帧分成：报头head和数据data两部分
| head | data |
mac地址：
head中包含的源和目标地址由来：ethernet规定接入internet的设备都必须具备网卡，发送端和接收端的地址便是指网卡的地址，即mac地址。获取目标主机的mac，就需要通过arp协议。
mac地址：每块网卡出厂时都被烧制上一个世界唯一的mac地址，长度为48位2进制，通常由12位16进制数表示。
广播：
8.1.3 网络层
网络层功能：引入一套新的地址用来区分不同的广播域／子网，这套地址即网络地址
IP协议：
- 规定网络地址的协议叫ip协议，它定义的地址称之为ip地址，广泛采用的v4版本即ipv4，它规定网络地址由32位2进制表示
- 范围0.0.0.0-255.255.255.255
- 一个ip地址通常写成四段十进制数，例：172.16.10.1
ip地址分成两部分
- 网络部分：标识子网
- 主机部分：标识主机
子网掩码
所谓”子网掩码”，就是表示子网络特征的一个参数。它在形式上等同于IP地址，也是一个32位二进制数字，它的网络部分全部为1，主机部分全部为0。
IP协议的作用主要有两个，一个是为每一台计算机分配IP地址，另一个是确定哪些地址在同一个子网络。
ip数据包
ip数据包也分为head和data部分，无须为ip包定义单独的栏位，直接放入以太网包的data部分。
| 以太网头 | ip 头 | ip数据 |
8.1.4 传输层
传输层功能：建立端口到端口的通信。
tcp协议：可靠传输
| 以太网头 | ip 头 | tcp头 | 数据 |
udp协议：不可靠传输
| 以太网头 | ip头 | udp头 | 数据 |
8.1.5 应用层
应用层功能：规定应用程序的数据格式。
例：TCP协议可以为各种各样的程序传递数据，比如Email、WWW、FTP等等。那么，必须有不同协议规定电子邮件、网页、FTP数据的格式，这些应用程序协议就构成了”应用层”。
9 socket
ip地址＋协议＋端口号唯一标示网络中的一个进程，就可以利用socket进行通信。
socket又称为套接字，socket是在应用层和传输层之间的一个抽象层，它把TCP/IP层复杂的操作抽象为几个简单的接口供应用层调用已实现进程在网络中通信。
socket模块是针对服务器端 和客户端Socket 进行【打开】【读写】【关闭】。
先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束。
import socket ip_port = ('127.0.0.1',9999) sk = socket.socket() #声明一个socket实例 sk.connect(ip_port) #sk.accept() sk.sendall('请求占领地球') server_reply = sk.recv(1024) print server_reply sk.close()
import socket ip_port = ('127.0.0.1',9999) sk = socket.socket() sk.bind(ip_port) sk.listen(5) while True: print 'server waiting...' conn,addr = sk.accept() #conn是客户端连接在服务端为其生成的一个连接实例 client_data = conn.recv(1024) print client_data conn.sendall('不要回答,不要回答,不要回答') conn.close()
9.1 socket模块函数用法
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
参数1：地址簇（Socket Families） socket.AF_INET IPv4（默认） socket.AF_INET6 IPv6 socket.AF_UNIX 只能够用于单一的Unix系统进程间通信 参数2：类型（Socket Types） socket.SOCK_STREAM 流式socket , for TCP （默认） socket.SOCK_DGRAM 数据报式socket , for UDP socket.SOCK_RAW 原始套接字 参数三：协议 0 （默认）与特定的地址家族相关的协议
9.1.1 服务端套接字函数
s.bind() 绑定(主机,端口号)到套接字
s.listen() 开始TCP监听
s.accept() 被动接受TCP客户的连接,(阻塞式)等待连接的到来
9.1.2 客户端套接字函数
s.connect() 主动初始化TCP服务器连接
s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
9.1.3 公共的套接字函数
s.recv() 接收TCP数据
s.send() 发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完)
s.sendall() 发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)
s.recvfrom() 接收UDP数据
s.sendto() 发送UDP数据
s.getpeername() 连接到当前套接字的远端的地址
s.getsockname() 当前套接字的地址
s.getsockopt() 返回指定套接字的参数
s.setsockopt() 设置指定套接字的参数
s.close() 关闭套接字
9.1.4 面向锁的套接字函数
s.setblocking() 设置套接字的阻塞与非阻塞模式
s.settimeout() 设置阻塞套接字操作的超时时间
s.gettimeout() 得到阻塞套接字操作的超时时间
9.1.5 面向文件的套接字函数
s.fileno() 套接字的文件描述符
s.makefile() 创建一个与该套接字相关的文件
import socket client = socket.socket() client.connect(('localhost',6467)) while True: cmd = input('>>:').strip() if len(cmd) ==0: continue client.send(cmd.encode('utf-8')) cmd_res_size = client.recv(1024) #接收命令结果的长度 print('命令大小',cmd_res_size) recv_size = 0 while recv_size != int(cmd_res_size.decode()): #print(recv_size) data = client.recv(1024) recv_size += len(data) #每次收到可能小于1024，所以必须用len判断 print(data.decode()) else: print('收到命令大小',recv_size) client.close()
import os import socket server = socket.socket() ##声明一个socket实例 server.bind(('localhost',6467)) server.listen() while True: conn,addr = server.accept() #conn是客户端连接在服务端为其生成的一个连接实例 print('new_conn:',conn) while True: data = conn.recv(1024) # recv默认是阻塞的 if not data: #print(data.decode()) 客户端已断开，conn.recv收到就都是空数据 print('断开连接') break # 重新接入新链接 print('执行指令',data.decode()) cmd_res = os.popen(data.decode()).read() if len(cmd_res) ==0: cmd_res='没有指令' conn.send(str(len(cmd_res.encode())).encode('utf-8')) #先发送大小给客户端 conn.send(cmd_res.encode('utf-8')) print('完成发送') server.close()
10 粘包
发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据。
解决办法：
服务端：在send中间加msg=conn.recv(1024) #wait for ack
客户端：接收命令长度后加client.sent('可以发送'.encode('utf-8'))
为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据。
struct模块：该模块可以把一个类型，如数字，转成固定长度的bytes
import json,struct #假设通过客户端上传1T:1073741824000的文件a.txt #为避免粘包,必须自定制报头 header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T数据,文件路径和md5值 #为了该报头能传送,需要序列化并且转为bytes head_bytes=bytes(json.dumps(header),encoding='utf-8') #序列化并转成bytes,用于传输 #为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节 head_len_bytes=struct.pack('i',len(head_bytes)) #这4个字节里只包含了一个数字,该数字是报头的长度 #客户端开始发送 conn.send(head_len_bytes) #先发报头的长度,4个bytes conn.send(head_bytes) #再发报头的字节格式 conn.sendall(文件内容) #然后发真实内容的字节格式 #服务端开始接收 head_len_bytes=s.recv(4) #先收报头4个bytes,得到报头长度的字节格式 x=struct.unpack('i',head_len_bytes)[0] #提取报头的长度 head_bytes=s.recv(x) #按照报头长度x,收取报头的bytes格式 header=json.loads(json.dumps(header)) #提取报头 #最后根据报头的内容提取真实的数据,比如 real_data_len=s.recv(header['file_size']) s.recv(real_data_len)
11 ftp
11.1 server
1.读取文件名
2.检测文件是否存在
3.打开文件
4.检测文件大小
5.发送文件大小给客户端
6.等客户端确认
7.开始边读边发数据
8.发送md5值
9.关闭文件
12 SocketServer实现并发
SocketServer内部使用 IO多路复用 以及 “多线程” 和 “多进程” ，从而实现并发处理多个客户端请求的Socket服务端。即：每个客户端请求连接到服务器时，Socket服务端都会在服务器是创建一个“线程”或者“进程” 专门负责处理当前客户端的所有请求。
基于TCP的套接字，关键就是两个循环，一个链接循环，一个通信循环。SocketServer模块中分两大类：server类（解决链接问题）和request类（解决通信问题）。
import socketserver class MyServer(socketserver.BaseRequestHandler): def handle(self): # print self.request,self.client_address,self.server conn = self.request conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.') Flag = True while Flag: data = conn.recv(1024) if data == 'exit': Flag = False elif data == '0': conn.sendall('通过可能会被录音.balabala一大推') else: conn.sendall('请重新输入.') if __name__ == '__main__': server = socketserver.ThreadingTCPServer(('127.0.0.1',8009),MyServer) server.serve_forever() #处理多个请求，handle_request()处理一个请求
import socket ip_port = ('127.0.0.1',8009) sk = socket.socket() sk.connect(ip_port) sk.settimeout(5) while True: data = sk.recv(1024) print('receive:',data) inp = input('please input:') sk.sendall(inp) if inp == 'exit': break sk.close()
BaseRequestHandler中有server类：处理链接，request类：处理通信
+------------+
| BaseServer |
+------------+
| v +-----------+ +------------------+ | TCPServer |------->| UnixStreamServer | +-----------+ +------------------+ | v +-----------+ +--------------------+ | UDPServer |------->| UnixDatagramServer | +-----------+ +--------------------+
12.1 ThreadingTCPServer
ThreadingTCPServer实现的Socket服务器内部会为每个client创建一个 “线程”，该线程用来和客户端进行交互。
- 创建一个继承自 SocketServer.BaseRequestHandler 的处理类
- 类中必须定义一个名称为 handle 的方法
- 启动 ThreadingTCPServer 实例化TCPServer，并且传递server IP和创建的处理类
查找属性的顺序：ThreadingTCPServer->ThreadingMixIn->TCPServer->BaseServer
内部调用流程为：
- 启动服务端程序
- 执行 TCPServer.__init__ 方法，创建服务端Socket对象并绑定 IP 和 端口
- 执行 BaseServer.__init__ 方法，将自定义的继承自SocketServer.BaseRequestHandler 的类 MyServer赋值给self.RequestHandlerClass
- 执行 BaseServer.server_forever 方法，While 循环一直监听是否有客户端请求到达 ...
- 当客户端连接到达服务器
- 执行 ThreadingMixIn.process_request 方法，创建一个 “线程” 用来处理请求
- 执行 ThreadingMixIn.process_request_thread 方法
- 执行 BaseServer.finish_request 方法，执行 self.RequestHandlerClass() 即：执行 自定义 MyServer 的构造方法（自动调用基类Base RequestHandler的构造方法，在该构造方法中又会调用 MyRequestHandler的handle方法）
SocketServer的ThreadingTCPServer之所以可以同时处理请求得益于 select 和 Threading 两个东西，其实本质上就是在服务器端为每一个客户端创建一个线程，当前线程用来处理对应客户端的请求，所以，可以支持同时n个客户端链接（长连接）。
12.2 ForkingTCPServer
ForkingTCPServer和ThreadingTCPServer的使用和执行流程基本一致，只不过在内部分别为请求者建立 “线程” 和 “进程”。
ps.重启服务端时可能会遇到Address already in use
解决方法：
#加入一条socket配置，重用ip和端口 phone=socket(AF_INET,SOCK_STREAM) phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加 phone.bind(('127.0.0.1',8080))
socket.socket()
self.allow_reuse_address
认证客户端合法性：
from socket import * import hmac,os secret_key=b'linhaifeng bang bang bang' def conn_auth(conn): ''' 认证客户端链接 :param conn: :return: ''' print('开始验证新链接的合法性') msg=os.urandom(32) conn.sendall(msg) h=hmac.new(secret_key,msg) digest=h.digest() respone=conn.recv(len(digest)) return hmac.compare_digest(respone,digest) def data_handler(conn,bufsize=1024): if not conn_auth(conn): print('该链接不合法,关闭') conn.close() return print('链接合法,开始通信') while True: data=conn.recv(bufsize) if not data:break conn.sendall(data.upper()) def server_handler(ip_port,bufsize,backlog=5): ''' 只处理链接 :param ip_port: :return: ''' tcp_socket_server=socket(AF_INET,SOCK_STREAM) tcp_socket_server.bind(ip_port) tcp_socket_server.listen(backlog) while True: conn,addr=tcp_socket_server.accept() print('新连接[%s:%s]' %(addr[0],addr[1])) data_handler(conn,bufsize) if __name__ == '__main__': ip_port=('127.0.0.1',9999) bufsize=1024 server_handler(ip_port,bufsize)
from socket import * import hmac,os secret_key=b'linhaifeng bang bang bang' def conn_auth(conn): ''' 验证客户端到服务器的链接 :param conn: :return: ''' msg=conn.recv(32) h=hmac.new(secret_key,msg) digest=h.digest() conn.sendall(digest) def client_handler(ip_port,bufsize=1024): tcp_socket_client=socket(AF_INET,SOCK_STREAM) tcp_socket_client.connect(ip_port) conn_auth(tcp_socket_client) while True: data=input('>>: ').strip() if not data:continue if data == 'quit':break tcp_socket_client.sendall(data.encode('utf-8')) respone=tcp_socket_client.recv(bufsize) print(respone.decode('utf-8')) tcp_socket_client.close() if __name__ == '__main__': ip_port=('127.0.0.1',9999) bufsize=1024 client_handler(ip_port,bufsize)
from socket import * def client_handler(ip_port,bufsize=1024): tcp_socket_client=socket(AF_INET,SOCK_STREAM) tcp_socket_client.connect(ip_port) while True: data=input('>>: ').strip() if not data:continue if data == 'quit':break tcp_socket_client.sendall(data.encode('utf-8')) respone=tcp_socket_client.recv(bufsize) print(respone.decode('utf-8')) tcp_socket_client.close() if __name__ == '__main__': ip_port=('127.0.0.1',9999) bufsize=1024 client_handler(ip_port,bufsize)
from socket import * import hmac,os secret_key=b'linhaifeng bang bang bang1111' def conn_auth(conn): ''' 验证客户端到服务器的链接 :param conn: :return: ''' msg=conn.recv(32) h=hmac.new(secret_key,msg) digest=h.digest() conn.sendall(digest) def client_handler(ip_port,bufsize=1024): tcp_socket_client=socket(AF_INET,SOCK_STREAM) tcp_socket_client.connect(ip_port) conn_auth(tcp_socket_client) while True: data=input('>>: ').strip() if not data:continue if data == 'quit':break tcp_socket_client.sendall(data.encode('utf-8')) respone=tcp_socket_client.recv(bufsize) print(respone.decode('utf-8')) tcp_socket_client.close() if __name__ == '__main__': ip_port=('127.0.0.1',9999) bufsize=1024 client_handler(ip_port,bufsize)
1524
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
