python基础（8）
一、动态导入模块和断言
动态导入模块有两种方式：
第一种：导入对方目录，如果想调用对面个目录下的模块，需要在继续往下调用
mod = __import__('lib.aa') obj = mod.aa.C() print (obj.name)
第二种为官网推荐的方式，直接对方模块，如果想要模块里面的方法，直接调用
import importlib aa=importlib.import_module("lib.aa") print(aa.C().name)
断言：
关键字是assert，作用与if继续判断类似，在操作后面代码前进行判断
user_input = input('>>>:') try: assert type(user_input) is int except Exception as e: print('is not int')
输出结果：
>>>:dada
is not int
二、Socket
python提供了两个级别访问的网络服务：
低级别的网络服务支持节本的socket，它提供了标准的BSD sockets API,可以访问底层操作系统socket接口的全部方法。
高级别的网络服务模块socketserver，它提供了服务器中心类，可以简化网络服务器的开发。
socket介绍
socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。
socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，对于文件用【打开】【读写】【关闭】模式来操作。socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）。
socket示意图：
连接原理：
根据连接启动的方式以及本地套接字要连接的目标，套接字之间的连接过程可以分为三个步骤：服务器监听，客户端请求，连接确认。
（1）服务器监听：是服务器端套接字并不定位具体的客户端套接字，而是出于等待连接的状态，实时监控网络状态。
（2）客户端请求：指由客户端的套接字剔除连接请求，要连接的目标是服务器端的套接字，为此，客户端的套接字必须首先描述它要连接的服务器的套接字，
指出服务器端套接字的地址和端口号，然后就向服务器端套接字提出连接请求。
（3）连接确认：指当服务器端套接字监听到或者说接收到客户端套接字的连接请求，它就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的描述
发给客户端，一旦客户端确认了此描述，连接就建立好了。而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。
sock参数介绍：
sk.bind(address) 必会
s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。
sk.listen(backlog) 必会
开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。
backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
这个值不能无限大，因为要在内核中维护连接队列
sk.setblocking(bool) 必会
是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。
sk.accept() 必会
接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。
接收TCP 客户的连接（阻塞式）等待连接的到来
sk.connect(address) 必会
连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。
sk.connect_ex(address)
同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061
sk.close() 必会
关闭套接字
sk.recv(bufsize[,flag]) 必会
接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。
sk.recvfrom(bufsize[.flag])
与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
sk.send(string[,flag]) 必会
将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。
sk.sendall(string[,flag]) 必会
将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
内部通过递归调用send，将所有内容发送出去。
sk.sendto(string[,flag],address)
将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。
sk.settimeout(timeout) 必会
设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）
sk.getpeername() 必会
返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
sk.getsockname()
返回套接字自己的地址。通常是一个元组(ipaddr,port)
sk.fileno()
套接字的文件描述符
sock套接字格式：
socket(family,type[,protocal]) 使用给定的地址族、套接字类型、协议编号（默认为0）来创建套接字。
|
socket类型 |
描述 |
|
socket.AF_UNIX |
只能够用于单一的Unix系统进程间通信 |
|
socket.AF_INET |
服务器之间网络通信 |
|
socket.AF_INET6 |
IPv6 |
|
socket.SOCK_STREAM |
流式socket , for TCP |
|
socket.SOCK_DGRAM |
数据报式socket , for UDP |
|
socket.SOCK_RAW |
原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。 |
|
socket.SOCK_SEQPACKET |
可靠的连续数据包服务 |
|
创建TCP Socket： |
|
|
创建UDP Socket： |
s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) |
sock函数：
注意点:
1）TCP发送数据时，已建立好TCP连接，所以不需要指定地址。UDP是面向无连接的，每次发送要指定是发给谁。
2）服务端与客户端不能直接发送列表，元组，字典。需要字符串化repr(data)。
|
socket函数 |
描述 |
|
|
服务端socket函数 |
||
|
s.bind(address) |
将套接字绑定到地址, 在AF_INET下,以元组（host,port）的形式表示地址. |
|
|
s.listen(backlog) |
开始监听TCP传入连接。backlog指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了。 |
|
|
s.accept() |
接受TCP连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。 |
|
|
客户端socket函数 |
||
|
s.connect(address) |
连接到address处的套接字。一般address的格式为元组（hostname,port），如果连接出错，返回socket.error错误。 |
|
|
s.connect_ex(adddress) |
功能与connect(address)相同，但是成功返回0，失败返回errno的值。 |
|
|
公共socket函数 |
||
|
s.recv(bufsize[,flag]) |
接受TCP套接字的数据。数据以字符串形式返回，bufsize指定要接收的最大数据量。flag提供有关消息的其他信息，通常可以忽略。 |
|
|
s.send(string[,flag]) |
发送TCP数据。将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。 |
|
|
s.sendall(string[,flag]) |
完整发送TCP数据。将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。 |
|
|
s.recvfrom(bufsize[.flag]) |
接受UDP套接字的数据。与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。 |
|
|
s.sendto(string[,flag],address) |
发送UDP数据。将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。 |
|
|
s.close() |
关闭套接字。 |
|
|
s.getpeername() |
返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。 |
|
|
s.getsockname() |
返回套接字自己的地址。通常是一个元组(ipaddr,port) |
|
|
s.setsockopt(level,optname,value) |
设置给定套接字选项的值。 |
|
|
s.getsockopt(level,optname[.buflen]) |
返回套接字选项的值。 |
|
|
s.settimeout(timeout) |
设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()） |
|
|
s.gettimeout() |
返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。 |
|
|
s.fileno() |
返回套接字的文件描述符。 |
|
|
s.setblocking(flag) |
如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。 |
|
|
s.makefile() |
创建一个与该套接字相关连的文件 |
|
功能介绍：
① server = socket.socket()
参数一：地址簇 socket.AF_INET IPv4（默认） socket.AF_INET6 IPv6 socket.AF_UNIX 只能够用于单一的Unix系统进程间通信 参数二：类型 socket.SOCK_STREAM 流式socket , for TCP （默认） socket.SOCK_DGRAM 数据报式socket , for UDP socket.SOCK_RAW 原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。 socket.SOCK_RDM 是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。 socket.SOCK_SEQPACKET 可靠的连续数据包服务 参数三：协议 0 （默认）与特定的地址家族相关的协议,如果是 0 ，则系统就会根据地址格式和套接类别,自动选择一个合适的协议
# 服务端
import socket
ip_port = ('127.0.0.1',9999)
sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)
sk.bind(ip_port)
while True:
data,(host,port) = sk.recvfrom(1024)
print(data,host,port)
sk.sendto(bytes('ok', encoding='utf-8'), (host,port))
#客户端
import socket
ip_port = ('127.0.0.1',9999)
sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)
while True:
inp = input('数据：').strip()
if inp == 'exit':
break
sk.sendto(bytes(inp, encoding='utf-8'),ip_port)
data = sk.recvfrom(1024)
print(data)
sk.close()
② server.bind(address)
server.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址
③ server.listen(backlog)
开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5,这个值不能无限大，因为要在内核中维护连接队列
④ server.setblocking(bool)
是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错
⑤ conn,addr = server.accept()
接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。接收TCP 客户的连接（阻塞式）等待连接的到来
⑥ client.connect(address)
连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。
⑦ client.connect_ex(address)
同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061
⑧ client.close()
关闭套接字
⑨ client.recv(bufsize[,flag])
接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略
⑩ client.recvfrom(bufsize[.flag])
与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址
⑪ server.send(string[,flag])
将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送
⑫ server.sendall(string[,flag])
将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常；
内部通过递归调用send，将所有内容发送出去
⑬ server.sendto(string[,flag],address)
将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议
⑭ sk.settimeout(timeout)
设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）
⑮ sk.getpeername()
返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）
⑯ sk.getsockname()
返回套接字自己的地址。通常是一个元组(ipaddr,port)
⑰ sk.fileno()
套接字的文件描述符
三、代码演示
1.第一个代码为将发送过来的字母转换成大写的简单示例：
服务端：
# -*- coding:utf-8 -*- #导入socke模块 import socket #开启ip和port ip_port=('127.0.0.1',9999) #生成句柄 server = socket.socket() #绑定IP端口，必须是元组 server.bind(ip_port) #最多连接数 server.listen(5) #开启信息处理死循环 while True: #阻塞，等待连接 conn,addr = server.accept() #连接成功之后循环的进行数据传输 while True: try: #获取客户端的请求信息 recv_data = conn.recv(1024) #一般是1024 #在server端输出获取的客户端信息 print('sip:%s recvdata:[%s]'%(addr,recv_data.decode())) #向客户端发送数据 send_data = recv_data.upper() conn.send(send_data) except Exception: break conn.close()
客户端：
# -*- coding:utf-8 -*- #导入socket模块 import socket #连接服务器的IP和端口 ip_port=('127.0.0.1',9999) #生成句柄 client=socket.socket() #连接服务器 client.connect(ip_port) #循环发送数据到服务端 while True: #发送数据到服务端 send_data = input(">>:").strip() if len(send_data) == 0:continue client.send(send_data.encode('utf-8')) #接收服务端发送过来的数据 recv_data = client.recv(1024) print(str(recv_data,'utf-8')) #关闭连接 client.close()
测试结果：
服务端显示：
sip:('127.0.0.1', 60539) recvdata:[c]
sip:('127.0.0.1', 60540) recvdata:[c]
sip:('127.0.0.1', 60540) recvdata:[d] #这一条是第一个客户端断开之后，第二个客户端连接获得
客户端显示：
>>:c
C
>>:d
D
>>:
注：这套代码可以实现简单的通信功能，但是存在问题：
1.在linux上面客户端断开服务后，服务端会一直死在循环空值。
2.粘包，如果服务端返回一个超过1024内容，客户端将无法一次获取所有信息。服务端首先会将要返回的内容存在内存里，当存储到一定的值才会返回数据，除非有个触发条件来使其主动的返回数据，我们服务器端的conn.send(send_data)就是主动的将数据发回回去，但是我们设置的市接收1024字节的内容，当超过这个值得话，服务器端会将剩下的数据留待下次再发送1024以此类推直到发送完毕为止。
3.单进程。
2. 写一个ftp工具
服务器端：
import socket,os,hashlib server = socket.socket() server.bind(("localhost",9998)) server.listen() while True: print('等待新的客户端连接') conn,add = server.accept() while True: print('等待新指令：') data = conn.recv(1024) if not len(data): print('客户端已断开......') break cmd,filename = data.decode().split() if os.path.isfile(filename): f = open(filename,'rb') m = hashlib.md5() file_size = os.stat(filename).st_size conn.send(str(file_size).encode('utf-8')) ack_info = conn.recv(1024) for line in f: conn.send(line) f.close() server.close()
客户端：
import socket client = socket.socket() client.connect(("localhost",9998)) while True: user_input = input('>>>:').strip() if not len(user_input):continue if user_input.startswith('get'): client.send(user_input.encode('utf-8')) server_response = client.recv(1024) print('Server response:',server_response) client.send(b'ready to recv file!') file_total_size = int(server_response.decode()) received_size = 0 filename = user_input.split()[1] f = open(filename+'_new','wb') while received_size < file_total_size: data = client.recv(1024) received_size += len(data) f.write(data) print(received_size,file_total_size) else: print('file recv done') f.close() client.close()
优化上面的ftp，给上面的ftp传输后的文件md5下，查看下两个文件md5是否一致，最后发送md5的时候，可能会出现粘包的问题，在客户端我们稍微做了处理，当接受的剩余文件小于1024时候的，最后只收文件总大小减去接受到的文件大小的字节数。
服务器端：
import socket,os,hashlib server = socket.socket() server.bind(("localhost",9998)) server.listen() while True: print('等待新的客户端连接') conn,add = server.accept() while True: print('等待新指令：') data = conn.recv(1024) if not len(data): print('客户端已断开......') break cmd,filename = data.decode().split() if os.path.isfile(filename): f = open(filename,'rb') m = hashlib.md5() file_size = os.stat(filename).st_size conn.send(str(file_size).encode('utf-8')) ack_info = conn.recv(1024) for line in f: m.update(line) #哈希这一行文件 conn.send(line) f.close() conn.send(m.hexdigest().encode('utf-8')) server.close()
客户端：
import socket,hashlib client = socket.socket() client.connect(("localhost",9998)) while True: user_input = input('>>>:').strip() if not len(user_input):continue if user_input.startswith('get'): client.send(user_input.encode('utf-8')) server_response = client.recv(1024) print('Server response:',server_response) client.send(b'ready to recv file!') file_total_size = int(server_response.decode()) received_size = 0 filename = user_input.split()[1] f = open(filename+'_new','wb') m = hashlib.md5() while received_size < file_total_size: if file_total_size - received_size < 1024: size = file_total_size -received_size else: size = 1024 data = client.recv(size) m.update(data) received_size += len(data) f.write(data) print(received_size,file_total_size) else: print('file recv done') f.close() server_file_md5 = client.recv(1024) if server_file_md5.decode() == m.hexdigest(): print("经过Md5验证，两个文件相同") client.close()
结果输出：
>>>:get big_server.py
Server response: b'1815'
1024 1815
1243 1815
1313 1815
1801 1815
1815 1815
file recv done
经过Md5验证，两个文件相同
四、 SocketServer
创建一个SocketServer大概分如下几步：
第一步：创建一个一个请求处理类，并且这个类要集成BaseRequestHandler，并且还要重写父类的handle()方法。
第二步：你必须实例化一个类，我们常用（TCPServer），并且传递server IP和你上面穿件的请求处理类给这个TCPServer
第三步：可以是用handle_request()或server_forever()进行处理请求，前者只处理一个请求，后者可以处理多个请求，永久执行
第四步：调用server_close()关闭socket
代码演示，写一个将小写替换为大写得程序：
服务器端：
import socketserver class MyTCPHandler(socketserver.BaseRequestHandler): def handle(self): while True: self.data = self.request.recv(1024).strip() if not self.data: print('主机断开！') break print("{} wrote:".format(self.client_address[0])) print(self.data) self.request.sendall(self.data.upper()) if __name__ == "__main__": HOST,PORT = '127.0.0.1',8888 server = socketserver.TCPServer((HOST,PORT),MyTCPHandler) server.serve_forever()
客户端：
import socket client = socket.socket() client.connect(('127.0.0.1',8888)) while True: user_input = input('>>>:').strip() if not len(user_input): continue client.send(user_input.encode('utf-8')) data = client.recv(1024) print(data.decode()) client.close()
结果显示：
>>>:adb
ADB
>>>:ddsa
DDSA
>>>:
#上面的例子并非多线程，如何开启多线程呢？
我们只需要把
server = socketserver.TCPServer((HOST, PORT), MyTCPHandler)
换成
server = socketserver.ThreadingTCPServer((HOST, PORT), MyTCPHandler)
浙公网安备 33010602011771号