python网络编程

时间  2019-12-09
标签 python 网络 编程 栏目 Python 繁體版
原文   原文链接

socket

Socket是应用层与TCP/IP协议族通讯的中间软件抽象层，它是一组接口。因此，咱们无需深刻理解tcp/udp协议，socket已经为咱们封装好了，咱们只须要遵循socket的规定去编程，写出的程序天然就是遵循tcp/udp标准的。python

套接字分类

  • 基于文件类型的套接字家族：AF_UNIX
  • 基于网络类型的套接字家族：AF_INET

套接字工做流程

套接字函数

1、服务端套接字函数

  • s.bind() 绑定(主机,端口号)到套接字
  • s.listen() 开始TCP监听
  • s.accept() 被动接受TCP客户的链接,(阻塞式)等待链接的到来

2、客户端套接字函数

  • s.connect() 主动初始化TCP服务器链接
  • s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

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() 关闭套接字

4、面向锁的套接字方法

tcp是基于连接的，必须先启动服务端，而后再启动客户端去连接服务端linux

5、面向文件的套接字的函数

  • s.fileno() 套接字的文件描述符
  • s.makefile() 建立一个与该套接字相关的文件

基于TCP的套接字

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
"""
服务端：
"""
import socket
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #建立服务器套接字
s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR, 1 ) #重启服务端时赶上Address already in use 时加上，在bind前加
s.bind(( '127.0.0.1' , 8083 )) #把地址绑定到套接字
s.listen( 5 ) #监听连接
 
print ( 'starting...' )
while True : # 连接循环
     conn,client_addr = s.accept() #接受客户端连接
     print (client_addr)
     while True : #通讯循环
         try :
             data = conn.recv( 1024 )
             if not data: break #适用于linux操做系统 正在连接的客户端忽然断开,recv便再也不阻塞,死循环发生
             print ( '客户端的数据' ,data)
             conn.send(data.upper())
         except ConnectionResetError: #适用于windows操做系统
             break
     conn.close() #关闭客户端套接字
s.close() #关闭服务器套接字(可选)
 
 
"""
客户端
"""
import socket
c = socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 建立客户套接字
c.connect(( '127.0.0.1' , 8083 )) # 尝试链接服务器
while True :  # 通信循环
     msg = input ( '>>: ' ).strip() #msg=''
     if not msg: continue
     c.send(msg.encode( 'utf-8' )) #c.send(b'')
     data = c.recv( 1024 )
     print (data.decode( 'utf-8' ))
c.close() # 关闭客户套接字

基于UDP的套接字

udp是无连接的，先启动哪一端都不会报错shell

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
"""
服务端：
"""
from socket import *
server = socket(AF_INET,SOCK_DGRAM)
server.bind(( '127.0.0.1' , 8080 ))
 
while True :
     data,client_addr = server.recvfrom( 1024 )
     print (data)
     server.sendto(data.upper(),client_addr)
server.close()
 
"""
客户端
"""
from socket import *
client = socket(AF_INET, SOCK_DGRAM)
while True :
     msg = input ( '>>: ' ).strip()
     client.sendto(msg.encode( 'utf-8' ),( '127.0.0.1' , 8080 ))
 
     data,server_addr = client.recvfrom( 1024 )
     print (data,server_addr)
client.close()

粘包现象

1、产生缘由

粘包问题主要是由于接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所形成的。编程

  • 发送端须要等缓冲区满才发送出去，形成粘包（发送数据时间间隔很短，数据量很小，会合到一块儿，产生粘包）
  • 接收方不及时接收缓冲区的包，形成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候仍是从缓冲区拿上次遗留的数据，产生粘包）

2、补充说明

  • TCP（transport control protocol，传输控制协议）是面向链接的，面向流的，提供高可靠性服务。
  • UDP（user datagram protocol，用户数据报协议）是无链接的，面向消息的，提供高效率服务。
  • 只有TCP有粘包现象，UDP永远不会粘包

3、解决粘包的方法

把报头作成字典，字典里包含将要发送的真实数据的详细信息，而后json序列化，而后用struck将序列化后的数据长度打包成4个字节json

1.发送时：

  • 先发报头长度
  • 再编码报头内容而后发送
  • 最后发真实内容

2.接收时：

  • 先收报头长度，用struct取出来
  • 根据取出的长度收取报头内容，而后解码，反序列化
  • 从反序列化的结果中取出待取数据的详细信息，而后去取真实的数据内容
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
"""
服务端
"""
import socket
import subprocess
import struct
import json
 
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR, 1 )
phone.bind(( '127.0.0.1' , 9909 ))
phone.listen( 5 )
 
print ( 'starting...' )
while True : # 连接循环
     conn,client_addr = phone.accept()
     print (client_addr)
 
     while True : #通讯循环
         try :
             #一、收命令
             cmd = conn.recv( 8096 )
             if not cmd: break #适用于linux操做系统
 
             #二、执行命令，拿到结果
             obj = subprocess.Popen(cmd.decode( 'utf-8' ), shell = True ,
                                    stdout = subprocess.PIPE,
                                    stderr = subprocess.PIPE)
 
             stdout = obj.stdout.read()
             stderr = obj.stderr.read()
 
             #三、把命令的结果返回给客户端
             #第3.1步：制做固定长度的报头
             header_dic = {
                 'filename' : 'a.txt' ,
                 'md5' : 'xxdxxx' ,
                 'total_size' : len (stdout) + len (stderr)
             }
 
             header_json = json.dumps(header_dic)
 
             header_bytes = header_json.encode( 'utf-8' )
 
             #第3.2步：先发送报头的长度
             conn.send(struct.pack( 'i' , len (header_bytes)))
 
             #第3.3步：再发报头
             conn.send(header_bytes)
 
             #第3.4步：再发送真实的数据
             conn.send(stdout)
             conn.send(stderr)
 
         except ConnectionResetError: #适用于windows操做系统
             break
     conn.close()
 
phone.close()
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
"""
客户端
"""
import socket
import struct
import json
 
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 
phone.connect(( '127.0.0.1' , 9909 ))
 
while True :
     #一、发命令
     cmd = input ( '>>: ' ).strip() #ls /etc
     if not cmd: continue
     phone.send(cmd.encode( 'utf-8' ))
 
     #二、拿命令的结果，并打印
 
     #第2.1步：先收报头的长度
     obj = phone.recv( 4 )
     header_size = struct.unpack( 'i' ,obj)[ 0 ]
 
     #第2.2步：再收报头
     header_bytes = phone.recv(header_size)
 
     #第2.3步：从报头中解析出对真实数据的描述信息
     header_json = header_bytes.decode( 'utf-8' )
     header_dic = json.loads(header_json)
     print (header_dic)
     total_size = header_dic[ 'total_size' ]
 
     #第2.4步：接收真实的数据
     recv_size = 0
     recv_data = b''
     while recv_size < total_size:
         res = phone.recv( 1024 ) #1024是一个坑
         recv_data + = res
         recv_size + = len (res)
 
     print (recv_data.decode( 'utf-8' ))
 
phone.close()

socketserver实现并发

  • 基于tcp的套接字，关键就是两个循环，一个连接循环，一个通讯循环
  • socketserver模块中分两大类：server类（解决连接问题）和request类（解决通讯问题）

 

import socketserver
class Myserver(socketserver.BaseRequestHandler):
    def handle(self):
        self.data = self.request.recv(1024).strip()
        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", 9999

    # 设置allow_reuse_address容许服务器重用地址
    socketserver.TCPServer.allow_reuse_address = True
    # 建立一个server, 将服务地址绑定到127.0.0.1:9999
    server = socketserver.TCPServer((HOST, PORT),Myserver)
    # 让server永远运行下去，除非强制中止程序
    server.serve_forever()
server端 
import socket

HOST, PORT = "127.0.0.1", 9999
data = "hello"

# 建立一个socket连接，SOCK_STREAM表明使用TCP协议
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
    sock.connect((HOST, PORT))          # 连接到客户端
    sock.sendall(bytes(data + "\n", "utf-8")) # 向服务端发送数据
    received = str(sock.recv(1024), "utf-8")# 从服务端接收数据

print("Sent:     {}".format(data))
print("Received: {}".format(received))
client 
"""
1.功能类
class Myserver(socketserver.BaseRequestHandler):
    def handle(self):  #放入要并发的逻辑  self.request 就是以前的conn
        pass       
2.server=socketserver.ThreadingTCPServer(("127.0.0.1",8881),Myserver)
3.server.serve_forever()
"""
import socketserver
class Myserver(socketserver.BaseRequestHandler):
    def handle(self):  #放入要并发的逻辑  self.request 就是以前的conn
            while True:
                try:
                    client_data=self.request.recv(1024)
                    if len(client_data)==0:
                        break  # 适用于linux操做系统 正在连接的客户端忽然断开,recv便再也不阻塞,死循环发生
                    print ("客户端的数据 >>>",str(client_data,"utf8"))
                    server_data=input("服务端的数据 >>>").strip()
                    self.request.send(bytes(server_data,"utf8"))
                except ConnectionResetError:  # 适用于windows操做系统
                    break
            self.request.close()
server=socketserver.ThreadingTCPServer(("127.0.0.1",8881),Myserver)
server.serve_forever()
######################################################################
import socket
c=socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 建立客户套接字
c.connect(('127.0.0.1',8881)) # 尝试链接服务器
while True:  # 通信循环
    msg=input('>>: ').strip() #msg=''
    if not msg:continue
    c.send(msg.encode('utf-8')) #c.send(b'')
    data=c.recv(1024)
    print(data.decode('utf-8'))
c.close() # 关闭客户套接字
View Code

4、分析socketserver源码：

  • server=socketserver.ThreadingTCPServer(("127.0.0.1",8881),Myserver)
  • server.serve_forever()
  • 查找属性的顺序：ThreadingTCPServer->ThreadingMixIn->TCPServer->BaseServer
  • 实例化获得server，先找类ThreadingTCPServer的__init__,在TCPServer中找到，进而执行server_bind,server_active
  • 找server下的serve_forever,在BaseServer中找到，进而执行self._handle_request_noblock()，该方法一样是在BaseServer中 执行self._handle_request_noblock()进而执行request,client_address = self.get_request()（就是TCPServer中的self.socket.accept()），而后执行self.process_request(request, client_address)
  • 在ThreadingMixIn中找到process_request，开启多线程应对并发，进而执行process_request_thread，执行self.finish_request(request, client_address) 上述完成了连接循环.
  • 开始进入通信部分，在BaseServer中找到finish_request,触发咱们本身定义的类的实例化，去找__init__方法，而咱们本身定义的类没有该方法，则去它的父类也就是BaseRequestHandler中找__init__方法....

#_*_coding:utf-8_*_

"""
尽管Son继承了Base类，父子类中都有一样的方法，
可是因为咱们实例化了子类的对象，因此这个在初始化方法里的self.Testfunc，
self指的是子类的对象，固然也就先调用子类中的方法啦。
因此尽管初始化方法在父类执行，可是仍是改变不了它是子类对象的本质，
当使用self去调用Testfunc方法时，始终是先调用子类的方法。
"""

class Base(object):
    def __init__(self,name):
        self.name = name
        self.Testfunc()
    def Testfunc(self):
        print ('do Base Testfunc')
class Son(Base):
    def Testfunc(self):
        print ('do Son Testfunc')

sonobj = Son('sonobj')  # do Son Testfunc



"""
尽管这三个类中都有一样的Testfunc方法，可是，因为计算机在找方法的时候，
遵循的顺序是：Base2，Son，Base，因此它会先找到Base2类，
而这个类中恰好有它要找的方法，它也就拿去执行啦！
"""

class Base(object):
    def Testfunc(self):
        print ('do Base Testfunc')
class Son(Base):
    def __init__(self,name):
        self.name = name
        self.Testfunc()
    def Testfunc(self):
        print ('do Son Testfunc')
class Base2(object):
    def Testfunc(self):
        print ('do Base2 Testfunc')
class GrandSon(Base2,Son):
    pass
sonobj = Son('sonobj')       #do Son Testfunc
sonobj = GrandSon('sonobj')  #do Base2 Testfunc
继承复习

1：threadingTCPServer的相关类：windows

2：初始化相关过程：缓存

3：执行serve_forever的相关代码：服务器

 

5、源码分析总结：

一、基于tcp的socketserver咱们本身定义的类中的

  • self.server即套接字对象
  • self.request即一个连接
  • self.client_address即客户端地址

二、基于udp的socketserver咱们本身定义的类中的

  • self.request是一个元组（第一个元素是客户端发来的数据，第二部分是服务端的udp套接字对象），如(b'adsf', )
  • self.client_address即客户端地址
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程