python网络通信编程_python之网络编程

1.OSI协议与TCP/IP协议

OSI是Open System Interconnection的缩写，意为开放式系统互联。国际标准化组织（ISO）制定了OSI模型，该模型定义了不同计算机互联的标准，是设计和描述计算机网络通信的基本框架。OSI模型把网络通信的工作分为7层，分别是物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。

这是一种事实上被TCP/IP 4层模型淘汰的协议。在当今世界上没有大规模使用。

业界广泛使用的是TCP/IP协议，将网络通信分为四层，分别是网络接口层，网络层，传输层，应用层。

2.socket层

那么用于网络通信的socket位于那一层呢？

3.socket是什么

Socket本质上就是在2台网络互通的电脑之间，架设一个通道，两台电脑通过这个通道来实现数据的互相传。它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

Socket=（IP地址：端口号）

4.套接字发展及分类

套接字Socket起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。

基于文件类型的套接字家族

套接字家族的名字：AF_UNIX

unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信

基于网络类型的套接字家族

套接字家族的名字：AF_INET

(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个。

6.socket底层工作原理解释

建立一个socket必须至少有2端， 一个服务端，一个客户端， 服务端被动等待并接收请求，客户端主动发起请求， 连接建立之后，双方可以互发数据。

基本流程

服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束。

importsocket

server= socket.socket(socket.AF_INET,socket.SOCK_STREAM) #声明socket类型同时生成socket链接对象

server.bind(('127.0.0.1',8000)) #绑定要监听的端口

server.listen(5)#监听

conn,addr=server.accept() #等待

whileTrue:

msg= conn.recv(1024) #收消息

print('客户端发来的消息是：',msg)

conn.send(msg.upper())#发消息

conn.close()

server.close()

server端

mport socket

client= socket.socket(socket.AF_INET,socket.SOCK_STREAM) #声明socket类型同时生成socket链接对象

client.connect(('127.0.0.1',8000)) #链接

whileTrue:

msg= input('>>').strip()

client.send(msg.encode('utf-8')) #向服务端发送消息

data = client.recv(1024) #接收来自服务端的消息

print('收到服务端发来的消息：',data)

client端

7.tcp三次握手与四次挥手

8.基于tcp实现远程执行命令

实现client端向server发送命令，server执行命令，并将结果返回给client端

from socket import *

importsubprocess

tcp_socket_server=socket(AF_INET,SOCK_STREAM)

tcp_socket_server.bind(('127.0.0.1',8080))

tcp_socket_server.listen(5)whileTrue:

conn,addr=tcp_socket_server.accept()print('客户端',addr)whileTrue:

cmd=conn.recv(1024) #接收来自client发送的命令

if len(cmd) == 0:break

#执行命令

act_res=subprocess.Popen(cmd.decode('utf-8'),shell=True,

stdout=subprocess.PIPE,

stdin=subprocess.PIPE,

stderr=subprocess.PIPE)

stderr=act_res.stderr.read() #标准错误

stdout=act_res.stdout.read() #标准输出

conn.send(stderr) #向client端返回执行结果

conn.send(stdout) #向client端返回错误信息

server端

importsocket

tcp_socket_client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

res=tcp_socket_client.connect(('127.0.0.1',8080))whileTrue:

msg=input('>>:').strip()if len(msg) == 0:continue

if msg == 'quit':breaktcp_socket_client.send(msg.encode('utf-8')) #向server端发送执行命令

act_res=tcp_socket_client.recv(1024) #接收执行完命令返回的结果

print(act_res.decode('utf-8'),end='')

client端

在客户端输入命令ls，错误的命令ll，以及ifconfig

返回结果

可以看到返回结果有正确stdout结果，也有错误stderr结果。

9.粘包现象

在系统终端输入ifconfig命令，结果如下

咿？从最后的结果看怎么和上面client端展示的不一样啦？

让我们再次输入命令ls

发现输出依然是ifconfig未完的结果，并且ls执行结果也在最后返回了。

这就是因为发生了粘包

为什么会发生粘包现象呢？我们可以看看代码，其中conn.recv(1024) 代表一次接收的数据字节为1024K，但是我们并不知道发送方一次发送的数据大小呀，如果发送的内容超过1024K，意味着我们一次并不能接收到所有的内容。

此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方也会收到粘包数据。

我们知道tcp的协议的优点是数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是这种模式会产生粘包现象。

让我们从发送和接收两端来分析

发送端：

需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据很小，会合到一起，产生粘包）

接受端：

不及时接收缓冲区的包，造成多个包接收（发送端发送了一段数据，接收端只收了一小部分，接受端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

扩展一 ：拆包的发生情况

当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。

扩展二：UDP协议与TCP协议比较

UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。

udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠。

10.粘包解决方法

问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据。

简单的解决方法

importsocket,subprocess

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)

s.bind(('127.0.0.1',8080))

s.listen(5)whileTrue:

conn,addr=s.accept()print('客户端',addr)whileTrue:

msg=conn.recv(1024)if not msg:breakres=subprocess.Popen(msg.decode('utf-8'),shell=True,

stdin=subprocess.PIPE,

stderr=subprocess.PIPE,

stdout=subprocess.PIPE)

err=res.stderr.read()iferr:

ret=errelse:

ret=res.stdout.read()

data_length=len(ret)

conn.send(str(data_length).encode('utf-8'))

data=conn.recv(1024).decode('utf-8')if data == 'recv_ready':

conn.sendall(ret)

conn.close()

server端

importsocket,time

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

res=s.connect(('127.0.0.1',8080))whileTrue:

msg=input('>>:').strip()if len(msg) == 0:continue

if msg == 'quit':breaks.send(msg.encode('utf-8'))

length=int(s.recv(1024).decode('utf-8'))

s.send('recv_ready'.encode('utf-8'))

send_size=0

recv_size=0

data=b''

while recv_size

data+=s.recv(1024)

recv_size+=len(data)print(data.decode('utf-8'))

复制代码

client端

这种方法的缺陷是程序的运行速度远快于网络传输速度，所以在发送一段字节前，先用send去发送该字节流长度，这种方式会放大网络延迟带来的性能损耗。

高级一点的解决方法

为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据

struct模块

该模块可以把一个类型，如数字，转成固定长度的bytes

importjson,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)

importstructimportbinasciiimportctypes

values1= (1, 'abc'.encode('utf-8'), 2.7)

values2= ('defg'.encode('utf-8'),101)

s1= struct.Struct('I3sf')

s2= struct.Struct('4sI')print(s1.size,s2.size)

prebuffer=ctypes.create_string_buffer(s1.size+s2.size)print('Before :',binascii.hexlify(prebuffer))#t=binascii.hexlify('asdfaf'.encode('utf-8'))#print(t)

s1.pack_into(prebuffer,0,*values1)

s2.pack_into(prebuffer,s1.size,*values2)print('After pack',binascii.hexlify(prebuffer))print(s1.unpack_from(prebuffer,0))print(s2.unpack_from(prebuffer,s1.size))

s3=struct.Struct('ii')

s3.pack_into(prebuffer,0,123,123)print('After pack',binascii.hexlify(prebuffer))print(s3.unpack_from(prebuffer,0))

复制代码

struct详细用法

importsocket, struct, jsonimportsubprocess

server=socket.socket(socket.AF_INET, socket.SOCK_STREAM)

server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1) #就是它，在bind前加

server.bind(('127.0.0.1', 8080))

server.listen(5)whileTrue:

conn, addr=server.accept()whileTrue:

cmd= conn.recv(1024)if not cmd: break

print('cmd: %s' %cmd)

res= subprocess.Popen(cmd.decode('utf-8'),

shell=True,

stdout=subprocess.PIPE,

stderr=subprocess.PIPE)

err=res.stderr.read()print(err)iferr:

back_msg=errelse:

back_msg=res.stdout.read()

conn.send(struct.pack('i', len(back_msg))) #先发back_msg的长度

conn.sendall(back_msg) #在发真实的内容

conn.close()

server端(自定制报头)

importsocket, time, struct

s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)

res= s.connect(('127.0.0.1', 8080))whileTrue:

msg= input('>>:').strip()if len(msg) == 0: continue

if msg == 'quit': breaks.send(msg.encode('utf-8'))

l= s.recv(4)

x= struct.unpack('i', l)[0]print(type(x), x)#print(struct.unpack('I',l))

r_s =0

data= b''

while r_s

r_d= s.recv(1024)

data+=r_d

r_s+=len(r_d)print(data.decode('utf-8'))

client端（自定制报头)

我们可以把报头做成字典，字典里包含将要发送的真实数据的详细信息，然后json序列化，然后用struck将序列化后的数据长度打包成4个字节（4个字节足够用了）

发送时：

先发报头长度

再编码报头内容然后发送

最后发真实内容

接收时：

先收报头长度，用struct取出来

根据取出的长度收取报头内容，然后解码，反序列化

从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容

importsocket, struct, jsonimportsubprocess

server=socket.socket(socket.AF_INET, socket.SOCK_STREAM)

server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1) #就是它，在bind前加

server.bind(('127.0.0.1', 8080))

server.listen(5)whileTrue:

conn, addr=server.accept()whileTrue:

cmd= conn.recv(1024)if not cmd: break

print('cmd: %s' %cmd)

res= subprocess.Popen(cmd.decode('utf-8'),

shell=True,

stdout=subprocess.PIPE,

stderr=subprocess.PIPE)

err=res.stderr.read()print(err)iferr:

back_msg=errelse:

back_msg=res.stdout.read()

headers= {'data_size':len(back_msg)} #定义报文头部

head_json =json.dumps(headers)

head_json_bytes= bytes(head_json,encoding='utf-8')

conn.send(struct.pack('i', len(head_json_bytes))) #先发报头的长度

conn.send(head_json_bytes) #再发报头

conn.sendall(back_msg) #再发真实的内容

conn.close()

server端(自定制报头改进版)

importsocket, time, struct,json

client=socket.socket(socket.AF_INET, socket.SOCK_STREAM)

res= client.connect(('127.0.0.1', 8080))whileTrue:

msg= input('>>:').strip()if len(msg) == 0: continue

if msg == 'quit': breakclient.send(msg.encode('utf-8'))

head= client.recv(4)

head_json_len= struct.unpack('i', head)[0]

head_json= json.loads(client.recv(head_json_len).decode('utf-8'))

data_len= head_json['data_size']

receive_size=0

receive_data= b''

while receive_size

receive_data= client.recv(1024)

receive_size+=len(receive_data)print(receive_data.decode('utf-8'))

client端

11.socket sever实现并发

到目前为止我们可以实现两个端的简单通信，然而实际生活中的网络通信不可能只有一个接收端，一个发送端，你不可能只和一个人聊天，你想和多人聊天怎么办呢？这就用到了socket server。我们知道基于TCP的套接字 , 关键就是两个循环 , 一个链接循环(多人) , 一个通信循环(多消息)。

server类

request类

实现一个简单的socket server有4步：

1.创建一个请求处理类，这个类继承自BaseRequestHandler，且需要重写父类的handle()方法

2.实例化TCPServer，传递server IP 和上面创建的请求处理类给这个TCPServer

3.调用 handle_request()或者serve_forever()方法来处理一个或多个请求

4.调用server_close() 关闭套接字（使用了with语句自己不需要关闭）

importsocketserverclassMyTCPHandler(socketserver.BaseRequestHandler):defhandle(self):whileTrue:try:

self.data= self.request.recv(1024).strip()print('{} wrote'.format(self.client_address[0]))print(self.data.decode())

self.request.send(self.data.upper())exceptConnectionResetError as e :print('err',e)break

if __name__ == '__main__':

HOST,PORT= '127.0.0.1',9999server=socketserver.ThreadingTCPServer((HOST,PORT),MyTCPHandler)

server.serve_forever()

server.server_close

12.认证客户端的链接合法性

实现一个简单的客户端链接认证功能，利用hmac+加盐的方式来实现，这么做的好处是限制客户端的链接，杜绝客户端通过IP+端口就对你的服务器进行访问。

from socket import *

importhmac, os

secret_key= b'anne is best'

defconn_auth(conn):'''认证客户端链接

:param conn:

:return:'''

print('开始验证新链接的合法性')

msg= os.urandom(32) #随机产生一个32位的密钥

print(msg)

conn.sendall(msg)#将这32位密码发送给client端

h = hmac.new(secret_key, msg) #hmac类似于md5,这里是加盐的方式

digest = h.digest() #生成密文

respone = conn.recv(len(digest)) #接收来自client的验证密文

return hmac.compare_digest(respone, digest) #比对是否一致

def data_handler(conn, bufsize=1024):if notconn_auth(conn):print('该链接不合法,关闭')

conn.close()return

print('链接合法,开始通信')whileTrue:

data=conn.recv(bufsize)if not data: breakconn.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)whileTrue:

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', 9998)

bufsize= 1024server_handler(ip_port, bufsize)

服务端

from socket import *

importhmac, os

secret_key= b'anne is best'

defconn_auth(conn):'''验证客户端到服务器的链接

:param conn:

:return:'''msg= conn.recv(32) #接收来自server的原始密钥

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)whileTrue:

data= input('>>:').strip()if not data: continue

if data == 'quit': breaktcp_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', 9998)

bufsize= 1024client_handler(ip_port, bufsize)

合法的客户端

13.开发一个支持多用户在线的FTP程序

最后

以上就是爱撒娇睫毛膏为你收集整理的python网络通信编程_python之网络编程的全部内容，希望文章能够帮你解决python网络通信编程_python之网络编程所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。