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标准的。

　　2.2 socket（）函数

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

family: 套接字家族可以用AF_UNIX（基于文件类型的套接字家族）或者AF_INET（基于网络类型的套接字家族）
type: 套接字类型可以根据是面向连接的还是非连接分为SOCK_STREAM或SOCK_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 套接字工作流程

　　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应用传输层   udp/tcp网络层   ip   路由器属于网络层数据链路层  arp（地址解析协议）  arp通过ID找地址（map）            交换机：广播 单播 组播物理层  网卡 双绞线

四：TCP协议和UDP协议

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

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

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

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

tcp三次握手和四次挥手

总结：

客户端的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()

　　实验过程中遇到的问题：

　　　　解决方法：

　　　　加入一条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.黏包问题的原因：

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

4.解决黏包问题：

　　在发送消息之前就告诉对方消息有多大
　　自定义协议的概念
　　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.黏包问题的总结：

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

7.黏包问题的解决方案

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

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

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模块的用处：

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

struct模块中的函数

关于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模块，长度数字转化为标准大小的四字节数字。

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编码

来源：https://www.cnblogs.com/lxx99/p/12242746.html

标签

套接字

socket

tcp四次挥手

网络编程