python网络编程

一:进程间的通信

  1.本地进程间的通信

  •   消息传递(管道,FIFO,消息队列)
  •   同步(互斥量,条件变量,读写锁,文件和写记录锁,信号量)
  •   共享内存(匿名的和具名的)
  •        远程过程调用     

  2.网络进程间的通信

  网络上的进程对得唯一区分,这样才能进行网络间的通信,比如QQ,微信聊天等等。而可以唯一区分的是进程的ip地址(互联网协议地址),协议,端口(设备与外界通讯的出口)。Python进行网络编程,就是在Python程序本身这个进程内,连接别的服务器进程的通信端口进行通信。

二:软件开发的架构

  1.B/S架构(浏览器端、服务器端)

 

  2.C/S架构(客户端、服务器端)

  2.1 socket套接字就是,应用程序通过套接字向网络发出请求或者应答网络请求,使主机间或者计算机间的程序可以相互通信。应用层与TCP/IP协议族通信的中间软件抽象层,它是一组接口。在设计模式中,Socket其实就是一个门面模式,它把复杂的TCP/IP协议族隐藏在Socket接口后面,对用户来说,一组简单的接口就是全部,让Socket去组织数据,以符合指定的协议。所以,我们无需深入理解tcp/udp协议,socket已经为我们封装好了,我们只需要遵循socket的规定去编程,写出的程序自然就是遵循tcp/udp标准的。

python网络编程

 python网络编程

 

 

 

  2.2 socket()函数

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

  • family: 套接字家族可以用AF_UNIX(基于文件类型的套接字家族)或者AF_INET(基于网络类型的套接字家族)
  • type: 套接字类型可以根据是面向连接的还是非连接分为SOCK_STREAMSOCK_DGRAM
  • protocol: 一般不填默认为0.

  

 1 import socket
 2 socket.socket(socket_family,socket_type,protocal=0)
 3 socket_family 可以是 AF_UNIX 或 AF_INET。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默认值为 0。
 4 
 5 获取tcp/ip套接字
 6 tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 7 
 8 获取udp/ip套接字
 9 udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
10 
11 由于 socket 模块中有太多的属性。我们在这里破例使用了'from module import *'语句。使用 'from socket import *',我们就把 socket 模块里的所有属性都带到我们的命名空间里了,这样能 大幅减短我们的代码。
12 例如tcpSock = socket(AF_INET, SOCK_STREAM)

 

  2.3 我们学习socket(套接字)就是为了完成C/S架构

  2.4 套接字工作流程

python网络编程

 

 

   2.5 socket对象(内建)方法

函数 描述
服务器端套接字
s.bind() 绑定地址(host,port)到套接字, 在AF_INET下,以元组(host,port)的形式表示地址。****
s.listen() 开始TCP监听。backlog指定在拒绝连接之前,操作系统可以挂起的最大连接数量。该值至少为1,大部分应用程序设为5就可以了。
s.accept() 被动接受TCP客户端连接,(阻塞式)等待连接的到来
客户端套接字
s.connect() 主动初始化TCP服务器连接,。一般address的格式为元组(hostname,port),如果连接出错,返回socket.error错误。
s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
公共用途的套接字函数
s.recv() 接收TCP数据,数据以字符串形式返回,bufsize指定要接收的最大数据量。flag提供有关消息的其他信息,通常可以忽略。
s.send() 发送TCP数据,将string中的数据发送到连接的套接字。返回值是要发送的字节数量,该数量可能小于string的字节大小。
s.sendall() 完整发送TCP数据,完整发送TCP数据。将string中的数据发送到连接的套接字,但在返回之前会尝试发送所有数据。成功返回None,失败则抛出异常。
s.recvform() 接收UDP数据,与recv()类似,但返回值是(data,address)。其中data是包含接收数据的字符串,address是发送数据的套接字地址。
s.sendto() 发送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() 创建一个与该套接字相关连的文件

 

三:OSI七层模型

python网络编程

 

 

 每层运行常见的物理设备

应用层   python应用
传输层 udp/tcp
网络层 ip 路由器属于网络层
数据链路层 arp(地址解析协议) arp通过ID找地址(map)
交换机:广播 单播 组播
物理层 网卡 双绞线

python网络编程

 

 

 

四:TCP协议和UDP协议

想要学会socket编程就得明白一些网络协议 ,所谓协议就是一些固定的标准,开发基于网络通信的软件必须遵守网络协议。

IP协议规定了IP地址的格式

  •             IP地址是一台机器在一个网络内唯一的标识
  •             子网掩码也是IP
  •             IP地址与子网掩码做按位与运算,得到的结果是网段
  •             网关IP 两个局域网之间的两台机器访问公网IP是通过网关访问的

TCP/IP协议族包括运输层、网络层、链路层。
tcp:面向字节流的 面向连接的协议 可靠的  效率低 全双工 三次握手 四次挥手*
udp:面向数据包的 不可靠的  不需要连接就可以发消息 单第一个消息一定是客户端发的

python网络编程

 

 

 tcp三次握手和四次挥手

python网络编程

 

总结:

  • 客户端的connect在三次握手的第二个次返回,而服务器端的accept在三次握手的第三次返回。

 

  • 主动断开连接 :FIN_WAIT_1
  • 被动断开连接: FIN_WAIT_2
  • 马上断开连接: TIME_WAIT
  • 四次挥手断开连接原则:
  • 记住一条原则:谁先发起客户端请求,谁先断开连接
  • 但是在大并发情况下,大部分都是服务端先断开连接,不会保留连接。因为每一分钟都有很多人在访问

五:套接字(socket)的使用

       1.基于TCP协议的套接字

    TCP服务器端

import socket
ss=socket() #创建出服务器端的套接字
ss.bind()  #把地址绑定到套接字上
ss.listen()  #监听链接
inf_loop:   #服务器无限循环
    cs=ss.accept() #接受客户端连接
    comm_loop:
        cs.recv()/cs.send()#接受发送对话
    cs.close() #关闭客户端套接字
ss.close()  #关闭服务器端套接字(可选)

    TCP客户端

cs=sorted() #创建客户端套接字
cs.connect()  #尝试连接服务器
conmm_loop:  #通讯无限循环
    cs.send/cs.recv()   #接受发送

cs.close()

          实验过程中遇到的问题:

python网络编程

 

     解决方法:

    加入一条socket配置,重用ip和端口

import socket
from socket import SOL_SOCKET,SO_REUSEADDR
sk=socket.socket()
sk.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)  #就是他,在bind前加 *********
sk.listen()
conn,addr=sk.accept()  #接受客户端链接
ret=conn.recv(1024)  #接收客户端发来的信息
print(ret)  #把信息打印出来
conn.send(b'ninuihih')
conn.close()#关闭客户端套接字
sk.close()  #关闭服务器套接字(可选)

 

  2.基于UDP协议的套接字(无链接的,不需要提前建立连接)

  UDP的服务器端

ss.socket()
ss.bind()#绑定服务器套接字
inf_loop:
    cs=ss.recvfrom()/ss.sendto()

ss.close()

 

  UDP的客户端

cs.socket()
comm_loop:
    cs.sendto()/cs.recvfrom()
cs.close

六:黏包现象

1.只有tcp有,udp没有

2.黏包问题:同时执行多条命令之后,得到的结果很可能只有一部分,再执行其他命令的时候又接收到之前执行的另一部分结果,

3.黏包问题的原因:

python网络编程

黏包问题的成因:因为应用程序所看到的数据是一个整体,或者是一个流(stream),一条消息有多少字节对应用程序是不可见的,因此tcp协议是面向流的协议,更容易发生黏包现象。TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。
                而udp是面向消息的协议,每个udp段都是一条消息,应用程序必须以消息为单位提取数据,不能一次提取任意字节的数据。

4.解决黏包问题:

  1.   在发送消息之前就告诉对方消息有多大
  2.   自定义协议的概念
  3.   struct模块将要发送的数据大小固定化,无论如何就发四个字节

 5.会发生黏包问题的两种情况

情况一:发送端需要等缓冲区满才能发送出去,造成黏包
server端
from socket import *
ip_port=('127.0.0.1',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)

conn,addr=tcp_socket_server.accept()

data1=conn.recv(10)
data2=conn.recv(10)

print('------->>',data1.decode('utf-8'))
print('----->>',data2.decode('utf-8'))

conn.close()
client端
import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)

s.send('hello'.encode('utf-8'))
s.send('eggo2'.encode('utf-8')) 
情况二:接收方不及时接受缓冲区的包,造成多个包接受。
server:
from socket import *
ip_port=('127.0.0.1',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)

conn,addr=tcp_socket_server.accept()

data1=conn.recv(2)  #一次没有收完整
data2=conn.recv(10)  #下次收的时候,会先收取旧的数据,再接收新的数据。

print('=======>',data1.decode('utf-8'))
print('=======>',data2.decode('utf-8'))

conn.close()
client:
import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)

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

6.黏包问题的总结:

  1. 黏包问题只会发生在tcp
  2. 从表面上看,黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。
  3. 实际上,主要还是因为接收方不知道消息之间的界限,不知道一次性提取多少字节的数据所造成的

 7.黏包问题的解决方案

因为接收端不知道发送端将要发送的数据的字节流的长度,所以才会产生黏包问题。所以我们需要在发送信息之前就确定一个机制(将自己发送的数据的自己留让接收端提前知晓)。

python网络编程

 

 此方法还存在一些问题,需要进阶

server

import socket,subprocess
ip_port=('127.0.0.1',8080)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

s.bind(ip_port)
s.listen(5)

while True:
    conn,addr=s.accept()
    print('客户端',addr)
    while True:
        msg=conn.recv(1024)
        if not msg:break
        res=subprocess.Popen(msg.decode('utf-8'),shell=True,\
                            stdin=subprocess.PIPE,\
                         stderr=subprocess.PIPE,\
                         stdout=subprocess.PIPE)
        err=res.stderr.read()
        if err:
            ret=err
        else:
            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()

 

client

import socket,time
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(('127.0.0.1',8080))

while True:
    msg=input('>>: ').strip()
    if len(msg) == 0:continue
    if msg == 'quit':break

    s.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 < length:
        data+=s.recv(1024)
        recv_size+=len(data)


    print(data.decode('utf-8'))

使用struct解决黏包

借助struct模块,我们知道长度数字可以被转换成一个标准大小的4字节数字。因此可以利用这个特点来预先发送数据长度。

struct模块的用处:

  1. 按照指定格式将Python数据转换为字符串,该字符串为字节流,如网络传输时,不能传输int,此时先将int转化为字节流,然后再发送;
  2. 按照指定格式将字节流转换为Python指定的数据类型;
  3. 处理二进制数据,如果用struct来处理文件的话,需要用’wb’,’rb’以二进制(字节流)写,读的方式来处理文件;
  4. 处理c语言中的结构体;

struct模块中的函数

python网络编程

 

 关于struct的用法:

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
header_bytes=bytes(json.dump(header),encoding='utf-8')   #序列化并转为bytes,用yu传输
#为了让客户知道报头的长度,用struct将报头长度这个数字转为固定长度:四字节
header_len_bytes=struct.pack('i',len(header_bytes))  #这四个字节里只包含了一个数字,该数字是报头的长度

#客户端开始发送
conn.send(header_len_bytes)  #先发报头的长度
conn.send(header_bytes)  #再发报头的字节格式
conn.sendall('文件内容')  #然后发真实内容的字节格式

#服务器端开始接收
header_len_bytes=s.recv(4)  #先收报头四个bytes ,得到报头长的的字节格式
x=struct.unpack('i',header_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)

 使用struct解决黏包问题

原理:发送消息之前我们利用struct模块,长度数字转化为标准大小的四字节数字。

python网络编程

 

server端:

#自定制报头
import socket,struct,json
import subprocess
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)  #在bind前加入 防止出错

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

phone.listen(5)

while True:
    conn,addr=phone.accept()
    while True:
        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)
        if err:
            back_msg = err
        else:
            back_msg = res.stdout.read()

        conn.send(struct.pack('i', len(back_msg)))  # 先发back_msg的长度
        conn.sendall(back_msg)  # 在发真实的内容

        conn.close()
        

 

client端:

 

import socket,time,struct

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(('127.0.0.1',8080))

while True:
    msg=input('>>: ').strip()
    if len(msg) == 0:continue
    if msg == 'quit':break

    s.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 < x:
        r_d=s.recv(1024)
        data+=r_d
        r_s+=len(r_d)

    # print(data.decode('utf-8'))
    print(data.decode('gbk')) #windows默认gbk编码

 

上一篇:深层次详解同步IO、异步IO、阻塞IO、非阻塞IO


下一篇:python网络编程-粘包问题的解决