python--网络编程

　　在python中，提供了两个级别访问网络，一是低级别的网络服务支持基本的 Socket，提供了标准的Sockets API，可以访问底层操作系统Socket接口；二是高级别的网络服务模块 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发

套接字socket

　　套接字socket是源IP地址和目的IP地址以及源端口号和目的端口号的组合，是支持TCP/IP的网络通信的基本操作单元，应用程序既可以通过socket来访问网络中的主机，又可以通过socket进程主机进程间的通讯

套接字socket相关函数函数

  • socket.socket([family[, type[, proto]]])

　　用来创建一个套接字对象

　  参数：

    • family：地址簇
      • IPv4(socket.AF_INET)
      • IPv6(socket.AF_INET6)
      • socket.AF_UNIX 只能够用于单一的Unix系统进程间通信
    • type:根据传输层的类型分为
      • SOCK_STREAM(TCP协议)
      • SOCK_DGRAM(UDP协议)
    • proto:一般不填默认为0.　　
  • s.bind(address)

　　绑定地址（host,port）到套接字， 在AF_INET下,以元组（host,port）的形式表示地址。

  • s.listen([num])

　　TCP连接开始监听，监听个数为num

  • s.accept()

　　等待客户端的连接，accept会阻塞

  • s.connect(address)

　　连接TCP服务器，address以元祖(hostname,port)格式，如果连接出错，返回socket.error错误

  • s.connect_ex()

　　connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

  • s.recv(buffersize, flags=None)

　　接收TCP数据，bufsize指定要接收的最大数据量。flag提供有关消息的其他信息，通常可以忽略，该函数阻塞

  • s.send()

　　发送TCP数据，返回值是要发送的字节数量，该数量可能小于string的字节大小。

  • s.sendall()

　　完整发送TCP数据。成功返回None，失败则抛出异常。

  • s.recvfrom()

　　接收UDP数据，与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址(hostname,port)

  • s.sendto()

　　发送UDP数据，将数据发送到套接字，address是形式为（(hostname,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表示没有超时期

  • s.gettimeout()

　　返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。

  • s.fileno()

　　返回套接字的文件描述符

  • s.setblocking(flag)

　　如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）

  • s.makefile()

　　创建一个与该套接字相关连的文件

 1 import socket
 2 
 3 #创建一个socket对象,协议为IPV4（AF_INET），TCP（SOCK_STREAM）
 4 sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
 5 
 6 #绑定IP地址和端口号
 7 addr=("127.0.0.1",9999)
 8 sock.bind(addr)
 9 
10 #监听该socket,
11 sock.listen()
12 
13 #等待客户端连接
14 while True:
15     #accept会阻塞
16     connSocket,address=sock.accept()
17     #向客户端发送数据，用于发送和接收用字节，所以需要转换一下
18     connSocket.sendall(bytes("welcome to my service~",encoding="utf-8"))
19     clientData=connSocket.recv(1024)
20     #将接收到的字节转化为字符串输出
21     clientData=str(clientData,encoding="utf-8")
22     print(clientData)
TCP服务端
 1 import socket
 2 
 3 sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
 4 addr=("127.0.0.1",9999)
 5 #连接服务器
 6 sock.connect(addr)
 7 
 8 rec=sock.recv(1024)
 9 
10 #将接收到的字节转化为字符串输出
11 rec=str(rec,encoding="utf-8")
12 print(rec)
13 
14 sock.sendall(bytes("你好，服务器，我来找你了~",encoding="utf-8"))
15 
16 sock.close()
TCP客户端
 1 import socket
 2 
 3 #创建一个IPv4，UDP的套接字socket
 4 sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)
 5 
 6 #绑定
 7 addr=("127.0.0.1",9999)
 8 sock.bind(addr)
 9 
10 while True:
11     #接受一个UDP数据，数据格式为(data,(IP,port))
12     clientData=sock.recvfrom(1024)
13     #取出客户端反过来的数据
14     print(str(clientData[0],encoding="utf-8"),type(clientData))
15     #取出客户端的IP和端口号
16     print("clientip[%s],clientPort[%s]" %(clientData[1][0],clientData[1][1]))
17     #根据客户端的IP和端口号向客户端发送数据
18     sock.sendto(bytes("你好，我是服务器~",encoding="utf-8"),clientData[1])
UDP服务端
 1 import socket
 2 
 3 #创建一个IPv4，UDP的套接字socket
 4 sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)
 5 addr=("127.0.0.1",9999)
 6 #向UDP服务器为addr的发送数据
 7 sock.sendto(bytes("服务器,我来了",encoding="utf-8"),addr)
 8 #接受服务器的数据，数据格式为(data,(IP,port))
 9 serviceData=sock.recvfrom(1024)
10 #取出服务器发来的数据
11 print(str(serviceData[0],encoding="utf-8"),type(serviceData))
12 #取出服务器的IP和端口
13 print("serviceIp[%s],servicePort[%s]"%(serviceData[1][0],serviceData[1][1]))
UDP客户端

 C++编写的TCP连接：http://www.cnblogs.com/chaguang/p/7115562.html

 C++编写的UDP连接：http://www.cnblogs.com/chaguang/p/7118476.html

 1 import socket
 2 import os
 3 #创建一个socket对象,协议为IPV4（AF_INET），TCP（SOCK_STREAM）
 4 sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
 5 
 6 #绑定IP地址和端口号
 7 addr=("127.0.0.1",9999)
 8 sock.bind(addr)
 9 
10 #监听该socket,
11 sock.listen()
12 
13 #等待客户端连接
14 while True:
15     #accept会阻塞
16     connSocket,address=sock.accept()
17     fileSize=str(connSocket.recv(1024),encoding="utf-8")
18     totalSize=int(fileSize)
19     startSzie=0
20     connSocket.sendall(bytes("已收到",encoding="utf-8"))
21     with open("recv1.jpg","wb") as file:
22         while startSzie<totalSize:
23             #接收文件的数据，并将它写入指定文件中
24             recvDate=connSocket.recv(1024)
25             file.write(recvDate)
26             startSzie+=len(recvDate)
上传文件服务端
 1 import socket
 2 import os
 3 sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
 4 addr=("127.0.0.1",9999)
 5 #连接服务器
 6 sock.connect(addr)
 7 #上传文件
 8 #获取文件的大小
 9 fileSize=os.stat("windows编程模型.jpg").st_size
10 #先发送文件的大小
11 sock.send(bytes(str(fileSize),encoding="utf-8"))
12 sucess=sock.recv(1024)
13 #打开文件，准备上传
14 with open("windows编程模型.jpg",'rb') as file:
15     for line in file:
16         sock.sendall(line)
17 sock.close()
上传文件客户端

 

 socketserver模块

　　socketserver是标准库中一个高级的模块，用来简化网络服务器的开发。内部使用 IO多路复用 以及 “多线程” 和 “多进程” ，从而实现并发处理多个客户端请求的Socket服务端。也就是在服务器中让一个线程作为代表去接受客户端的请求，当有客户端请求来了，就创建一个线程去处理该用户的请求，然后那个负责监听的线程继续回去监听客户的请求。

socketserver模块类

BaseServer 包含核心服务器功能和mix-in类的钩子，仅用于推导，这样不会创建这个类的实例；可以用TCPServer或者UDPServer创建类的实例
TCPServer/UDPServer 基础的网络同步TCP/UDP服务器
UnixStreamServer/UnixDatagramServer 基于文件的基础同步TCP/UDP服务器
ForkingMixIn/ThreadingMixIn 核心派出或线程功能；只用做mix-in类与一个服务器类配合实现一些异步性，不能直接实例化这个类
ForkingTCPServer/ForkingUDPServer ForkingMixIn和TCPServer/UDPServer的组合
ThreadingTCPServer/ThreadingUDPServer ThreadingMixIn和TCPServer/UDPServer的组合
BaseRequestHandler 包含处理服务请求的核心功能；仅仅用于推导，这样无法创建这个类的实例，可以使用StreamRequestHandler或DatagramRequestHandler创建类实例
StreamRequestHandler/DatagramRequestHandler 实现TCP/UDP服务器的服务处理器

 

 socketserver的实现

　　想要实现socketserver这个模块，必须定义一个继承基类BaseRequestHandle的一个类，在类中重写handle()方法，当有请求操作的话，就会调用handle方法，类中有几个实例变量包含有用的值：

  • h.request：对TCP，h.request属性是套接字对象。对于UDP，它是包含收到数据的字节字符串。
  • h.client_address：包含客户端地址
  • h.server：包含调用处理程序的实例

常用方法和变量：

  1. s.socket:：用于传入请求的套接字对象
  2. s.server_address：监听服务器地址
  3. s.RequestHandleClass：传递给服务器构造函数并由用户提供的请求处理程序类
  4. s.server_forever()：处理请求
  5. s.shutdown()：停止server_forever()循环
  6. s.fileno()：返回服务器套接字的整数文件描述符
 1 import socketserver
 2 
 3 #必须继承socketserver.BaseRequestHandler,而且在类中实现handle方法
 4 class MySocket(socketserver.BaseRequestHandler):
 5     #用来处理客户端请求
 6     def handle(self):
 7         #self.request是与客户端连接的套接字对象
 8         data=self.request.recv(1024)
 9         print(str(data,encoding="utf-8"))
10         self.request.sendall(bytes("这里是socketserver，你好",encoding="utf-8"))
11 
12 if __name__=="__main__":
13     #为每个client创建一个 线程，用来和客户端进行交互。
14     service=socketserver.ThreadingTCPServer(("127.0.0.1",6000),MySocket)
15     #开始处理请求
16     service.serve_forever()
socketserver服务器
 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 import socket
 5 
 6 
 7 ip_port = ('127.0.0.1',6000)
 8 sk = socket.socket()
 9 sk.connect(ip_port)
10 sk.sendall(bytes("hello",encoding="utf-8"))
11 data=sk.recv(1024)
12 print(str(data,encoding="utf-8"))
13 sk.close()
socketserver客户端

 

 I/O多路复用

　I/O多路复用是通过select，poll，epoll来监听多个对象，当对象有变化的时候就会去通知用户，然后用户就可以去处理这些变化了的对象。也就是通过一种机制一个进程能同时等待多个文件描述符，而这些文件描述符其中的任意一个进入读就绪状态，函数就可以返回。在windows和Mac中只提供了select，在linux中提供了select，poll，epoll

select函数

　　def select(rlist, wlist, xlist, timeout=None)

　　用法：

　　rList,wList,eList=select.select(句柄序列, 句柄序列, 句柄序列, 超时时间)

　　

　　参数： 可接受四个参数（前三个必须）

　　返回值：三个列表
    • 有状态变化的socket放到第一个返回值中，
    • select的第二个参数放到第二个返回值中
    • 当列表中socket出现错误的时候，将会放到第三个返回值中
    • 最后一个参数为超时时间
      • 当没有设置返回值的时候，select会一直阻塞，直到监听的句柄发生变化
      • 当 超时时间 ＝n时，如果监听的句柄均无任何变化，则select会阻塞n秒，之后返回三个空列表，如果监听的句柄有变化，则直接执行。　　
 1 import select
 2 import socket
 3 
 4 #用来保存监听列表
 5 clientList=[]
 6 
 7 #创建监听的socket对象
 8 sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
 9 addr=("127.0.0.1",6000)
10 sock.bind(addr)
11 sock.listen()
12 #将负责监听的服务器socket加入到列表中
13 clientList.append(sock)
14 
15 while True:
16     #监控clientList中的变量状态
17     #有状态变化的socket放到rList中，select的第二个参数放到wList中，当列表中socket
18     #出现错误的时候，将会放到eList中,最后一个参数为超时时间
19     rList,wList,eList=select.select(clientList,[],clientList,1)
20     for obj in rList:
21         if obj==sock:
22             #接受客户端的请求
23             clientSock,clientInfo=sock.accept()
24             print("accpet,ip[%s],port[%s]"%(clientInfo[0],clientInfo[1]))
25             #将客户端的socket添加到列表中，让select去监控变化
26             clientList.append(clientSock)
27         else:
28             Data=obj.recv(1024)
29             if Data:
30                 sendData="%s好" % str(Data,encoding="utf-8")
31                 obj.sendall(bytes(sendData,encoding="utf-8"))
32                 print(str(Data,encoding="utf-8"))
33             else:
34                 #将退出的客户端socket从监听列表中去除
35                 print("exit,ip[%s],port[%s]" % (clientInfo[0], clientInfo[1]))
36                 clientList.remove(obj)
select服务器
 1 import socket
 2 import os
 3 sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
 4 addr=("127.0.0.1",6000)
 5 #连接服务器
 6 sock.connect(addr)
 7 
 8 sock.sendall(bytes("你",encoding="utf-8"))
 9 serviceData=sock.recv(1024)
10 print(str(serviceData,encoding="utf-8"))
select客户端

 

 

posted @ 2018-03-10 16:11  菜鸟也有高飞的时候  阅读(286)  评论(0)  编辑  收藏  举报