【Python网络】网络通信

互联网时代，现在基本上所有的程序都是网络程序，很少有单机版的程序了。

网络编程就是如何在程序中实现两台计算机的通信。

Python语言中，提供了大量的内置模块和第三方模块用于支持各种网络访问，而且Python语言在网络通信方面的优点特别突出，远远领先其他语言。

IP地址

IP是Internet Protocol Address，即“互联网协议地址”。

用来标识网络中的一个通信实体的地址。通信实体可以是计算机、路由器等。 比如互联网的每个服务器都要有自己的IP地址，而每个局域网的计算机要通信也要配置IP地址。

路由器是连接两个或多个网络的网络设备。

IP地址就像是我们的家庭住址一样，如果你要写信给一个人，你就要知道他（她）的地址，这样邮递员才能把信送到。计算机发送信息就好比是邮递员，它必须知道唯一的“家庭地址”才能不至于把信送错人家。只不过我们的地址是用文字来表示的，计算机的地址用二进制数字表示。 IP地址被用来给Internet上的电脑一个编号。大家日常见到的情况是每台联网的PC上都需要有IP地址，才能正常通信。我们可以把“个人电脑”比作“一台电话”，那么“IP地址”就相当于“电话号码”，而Internet中的路由器，就相当于电信局的“程控式交换机”。

类别	最大网络数	IP地址范围	单个网段最大主机数	私有IP地址范围
A	126(2^7-2)	1.0.0.1-127.255.255.254	16777214	10.0.0.0-10.255.255.255
B	16384(2^14)	128.0.0.1-191.255.255.254	65534	172.16.0.0-172.31.255.255
C	2097152(2^21)	192.0.0.1-223.255.255.254	254	192.168.0.0-192.168.255.255

目前主流使用的IP地址是IPV4，但是随着网络规模的不断扩大，IPV4面临着枯竭的危险，所以推出了IPV6。

IPV4，采用32位地址长度，只有大约43亿个地址，它只有4段数字，每一段最大不超过255。随着互联网的发展，IP地址不够用了，在2019年11月25日IPv4位地址分配完毕。

IPv6,   采用128位地址长度，几乎可以不受限制地提供地址。按保守方法估算IPv6实际可分配的地址，整个地球的每平方米面积上仍可分配1000多个地址。

IP地址实际上是一个32位整数（称为IPv4），以字符串表示的IP地址如192.168.0.1实际上是把32位整数按8位分组后的数字表示，目的是便于阅读。

IPv6地址实际上是一个128位整数，它是目前使用的IPv4的升级版，以字符串表示类似于                                                ​​​​​​​        2001:0db8:85a3:0042:1000:8a2e:0370:7334

公有地址 由Inter NIC（Internet Network Information Center互联网信息中心）负责。这些IP地址分配给注册并向Inter NIC提出申请的组织机构。通过它直接访问互联网。

私有地址 属于非注册地址，专门为组织机构内部使用。

以下列出留用的内部私有地址:
        A类 10.0.0.0--10.255.255.255
        B类 172.16.0.0--172.31.255.255
        C类 192.168.0.0--192.168.255.255

注意事项

• 127.0.0.1 本机地址
• 192.168.0.0--192.168.255.255为私有地址，属于非注册地址，专门为组织机构内部使用

windows下，我们可以通过命令ipconfig获取网卡信息。（Linux和Mac，是ifconfig）通过ping查看网络连接：

ping www.baidu.com 查看是否能上公网
ping 192.168.1.100 查看是否和该计算机在同一个局域网
ping 127.0.0.1 查看本机网卡是否可用

端口

端口（port）号用来识别计算机中进行通信的应用程序。因此，它也被称为程序地址。

一台计算机上同时可以运行多个程序。传输层协议正是利用这些端口号识别本机中正在进行通信的应用程序，并准确地进行数据传输。

• IP地址好比每个人的地址（门牌号），端口好比是房间号。必须同时指定IP地址和端口号才能够正确的发送数据。
• IP地址好比为电话号码，而端口号就好比为分机号。

端口分配

端口是虚拟的概念，并不是说在主机上真的有若干个端口。通过端口，可以在一个主机上运行多个网络应用程序。 端口的表示是一个16位的二进制整数，对应十进制的0-65535。

操作系统中一共提供了0~65535可用端口范围。

按端口号分类：有公认端口和注册端口

公认端口（Well Known Ports）：从0到1023，它们紧密绑定（binding）于一些服务。通常这些端口的通讯明确表明了某种服务的协议。例如：80端口实际上总是HTTP通讯。

注册端口（Registered Ports）：从1024到65535。它们松散地绑定于一些服务。也就是说有许多服务绑定于这些端口，这些端口同样用于许多其它目的。例如：许多系统处理动态端口从1024左右开始。

网络协议ISO分层

        国际标准化组织(ISO，即International Organization for Standardization)定义了网络通信协议的基本框架，被称为OSI（Open System Interconnect，即开放系统互联）模型。要制定通讯规则，内容会很多，比如要考虑A电脑如何找到B电脑，A电脑在发送信息给B电脑时是否需要B电脑进行反馈，A电脑传送给B电脑的数据格式又是怎样的？内容太多太杂，所以OSI模型将这些通讯标准进行层次划分，每一层次解决一个类别的问题，这样就使得标准的制定没那么复杂。

OSI模型制定的七层标准模型，分别是：应用层，表示层，会话层，传输层，网络层，数据链路层，物理层。

OSI七层协议模型如图所示：

网络协议的分层

虽然国际标准化组织制定了这样一个网络通信协议的模型，但是实际上互联网通讯使用最多的网络通信协议是TCP/IP网络通信协议。

TCP/IP 是一个协议族，也是按照层次划分，共四层：应用层，传输层，互连网络层，网络接口层（物理+数据链路层）。

把用户应用程序作为最高层，把物理通信线路作为最低层，将其间的协议处理分为若干层，规定每层处理的任务，也规定每层的接口标准。

TCP和UDP传输数据的区别

TCP 和 UDP 的优缺点无法简单地、绝对地去做比较：TCP 用于在传输层有必要实现可靠传输的情况；UDP 主要用于那些对高速传输和实时性有较高要求的通信或广播通信。TCP 和 UDP 应该根据应用的目的按需使用。

TCP（Transmission Control Protocol，传输控制协议）。TCP方式就类似于拨打电话，使用该种方式进行网络通讯时，需要建立专门的虚拟连接，然后进行可靠的数据传输，如果数据发送失败，则客户端会自动重发该数据。

UDP（User Data Protocol，用户数据报协议）

UDP是一个非连接的协议，传输数据之前源端和终端不建立连接， 当它想传送时就简单地去抓取来自应用程序的数据，并尽可能快地把它扔到网络上。 在发送端，UDP传送数据的速度仅仅是受应用程序生成数据的速度、 计算机的能力和传输带宽的限制； 在接收端，UDP把每个消息段放在队列中，应用程序每次从队列中读一个消息段。

UDP方式就类似于发送短信，使用这种方式进行网络通讯时，不需要建立专门的虚拟连接，传输也不是很可靠，如果发送失败则客户端无法获得。

UDP 因为没有拥塞控制，一直会以恒定的速度发送数据。即使网络条件不好，也不会对发送速率进行调整。这样实现的弊端就是在网络条件不好的情况下可能会导致丢包，但是优点也很明显，在某些实时性要求高的场景（比如电话会议）就需要使用 UDP 而不是 TCP

TCP和UDP区别

这两种传输方式都在实际的网络编程中使用，重要的数据一般使用TCP方式进行数据传输，而大量的非核心数据则可以通过UDP方式进行传递，在一些程序中甚至结合使用这两种方式进行数据传递。

由于TCP需要建立专用的虚拟连接以及确认传输是否正确，所以使用TCP方式的速度稍微慢一些，而且传输时产生的数据量要比UDP稍微大一些。

	UDP	TCP
是否连接	无连接	面向连接
是否可靠	不可靠传输，不使用流量控制和拥塞控制	可靠传输，使用流量控制和拥塞控制
连接对象个数	支持一对一，一对多，多对一和多对多交互通信	只能是一对一通信
传输方式	面向报文	面向字节流
首部开销	首部开销小，仅8字节	首部最小20字节，最大60字节
适用场景	适用于实时应用（IP电话、视频会议、直播等）	适用于要求可靠传输的应用，例如文件传输

总结而言 TCP是面向连接的，传输数据安全，稳定，效率相对较低。而UDP是面向无连接的，传输数据不安全，效率较高。

TCP的三次握手和四次挥手_数据包的概念

TCP建立连接的三次握手

TCP是面向连接的协议，也就是说，在收发数据前，必须和对方建立可靠的连接。 一个TCP连接必须要经过三次“对话”才能建立起来，其中的过程非常复杂， 只简单的描述下这三次对话的简单过程：

        1）主机A向主机B发出连接请求：“我想给你发数据，可以吗？”，这是第一次对话；

        2）主机B向主机A发送同意连接和要求同步 （同步就是两台主机一个在发送，一个在接收，协调工作）的数据包 ：“可以，你什么时候发？”，这是第二次对话；

        3）主机A再发出一个数据包确认主机B的要求同步：“我现在就发，你接着吧！”， 这是第三次握手。

三次“对话”的目的是使数据包的发送和接收同步， 经过三次“对话”之后，主机A才向主机B正式发送数据。

1. 第一步，客户端发送一个包含SYN即同步（Synchronize）标志的TCP报文，SYN同步报文会指明客户端使用的端口以及TCP连接的初始序号。
2. 第二步，服务器在收到客户端的SYN报文后，将返回一个SYN+ACK的报文，表示客户端的请求被接受，同时TCP序号被加一，ACK即确认（Acknowledgement）
3. 第三步，客户端也返回一个确认报文ACK给服务器端，同样TCP序列号被加一，到此一个TCP连接完成。然后才开始通信的第二步：数据处理。

这就是所说的TCP的三次握手（Three-way Handshake）。

为什么TCP协议有三次握手,而UDP协议没有？

        因为三次握手的目的是在client端和server端建立可靠的连接。保证双方发送的数据对方都能接受到，这也是TCP协议的被称为可靠的数据传输协议的原因。而UDP就不一样，UDP不提供可靠的传输模式，发送端并不需要得到接收端的状态，因此UDP协议就用不着使用三次握手。

TCP断开连接的四次挥手

TCP建立连接要进行3次握手，而断开连接要进行4次：

第一次： 当主机A完成数据传输后,将控制位FIN置1，提出停止TCP连接的请求 ；

第二次： 主机B收到FIN后对其作出响应，确认这一方向上的TCP连接将关闭,将ACK置1；

第三次： 由B 端再提出反方向的关闭请求,将FIN置1 ；

第四次： 主机A对主机B的请求进行确认，将ACK置1，双方向的关闭结束.。

由TCP的三次握手和四次断开可以看出，TCP使用面向连接的通信方式， 大大提高了数据通信的可靠性，使发送数据端和接收端在数据正式传输前就有了交互， 为数据正式传输打下了可靠的基础。

数据包与处理流程

通信传输中的数据单位，一般也称“数据包”。在数据包中包括：包、帧、数据包、段、消息。

网络中传输的数据包由两部分组成：一部分是协议所要用到的首部，另一部分是上一层传过来的数据。首部的结构由协议的具体规范详细定义。在数据包的首部，明确标明了协议应该如何读取数据。反过来说，看到首部，也就能够了解该协议必要的信息以及所要处理的数据。包首部就像协议的脸。

socket套接字编程底层原理和TCP_UDP的关系

socket编程

TCP协议和UDP协议是传输层的两种协议。Socket是传输层供给应用层的编程接口，所以Socket编程就分为TCP编程和UDP编程两类。

Socket编程封装了常见的TCP、UDP操作，可以实现非常方便的网络编程。

socket()函数介绍

在Python语言标准库中，通过使用socket模块提供的socket对象，可以在计算机网络中建立可以互相通信的服务器与客户端。在服务器端需要建立一个socket对象，并等待客户端的连接。客户端使用socket对象与服务器端进行连接，一旦连接成功，客户端和服务器端就可以进行通信了。

⚠️上图中，我们可以看出socket通讯中，发送和接收数据，都是通过操作系统控制网卡来进行。因此，我们在使用之后，必须关闭socket。

在Python 中，通常用一个Socket表示“打开了一个网络连接”，语法格式如下：

socket.socket([family[, type[, proto]]])
# family: 套接字家族可以使AF_UNIX或者AF_INET；
# AF 表示ADDRESS FAMILY 地址族
# AF_INET（又称 PF_INET）是 IPv4 网络协议的套接字类型；而 AF_UNIX 则是 Unix 系统本地通信。
# type: 套接字类型可以根据是面向连接的还是非连接分为SOCK_STREAM或SOCK_DGRAM；protocol: 一般不填，默认为0。

Socket主要分为面向连接的Socket和无连接的Socket。

无连接Socket的主要协议是用户数据报协议，也就是常说的UDP，UDP Socket的名字是SOCK_DGRAM。创建套接字UDP/IP套接字，可以调用socket.socket()。示例代码如下：

udpSocket=socket.socket (AF_INET,SOCK_DGRAM)

socket对象的内置函数和属性

在Python语言中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.recvfrom()	接收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()	创建一个与该套接字相关连的文件

UDP编程

UDP协议时，不需要建立连接，只需要知道对方的IP地址和端口号，就可以直接发数据包。但是，能不能到达就不知道了。虽然用UDP传输数据不可靠，但它的优点是和TCP比，速度快，对于不要求可靠到达的数据，就可以使用UDP协议。

创建Socket时，SOCK_DGRAM指定了这个Socket的类型是UDP。绑定端口和TCP一样，但是不需要调用listen()方法，而是直接接收来自任何客户端的数据。recvfrom()方法返回数据和客户端的地址与端口，这样，服务器收到数据后，直接调用sendto()就可以把数据用UDP发给客户端。

示例：UDP接受数据

#coding=utf-8
from socket import *
s = socket(AF_INET, SOCK_DGRAM) #创建套接字
#绑定接收信息端口
s.bind(('127.0.0.1', 8888)) #绑定一个端口，ip地址和端⼝号
print("等待接收数据！")
redata = s.recvfrom(1024) #1024表示本次接收的最⼤字节数
print(redata)
print(f'收到远程信息:{redata[0].decode("gbk")}, from {redata[1]}')
s.close()

示例：UDP发送数据

from socket import *
s = socket(AF_INET, SOCK_DGRAM) #创建套接字
addr = ('127.0.0.1', 8888) #准备接收方地址
data = input("请输入：")
#发送数据时，python3需要将字符串转成byte
s.sendto(data.encode('gbk'),addr) #默认的网络助手使用的编码是gbk
s.close()

示例：UDP持续接收数据
 

#coding=utf-8
from socket import *
​
s = socket(AF_INET,SOCK_DGRAM) #创建UDP类型的套接字
s.bind(("127.0.0.1",8888)) #绑定端口,ip可以不写
print("等待接收数据！")
while True:
  recv_data = s.recvfrom(1024)  #1024表示本次接收的最大字节数
  recv_content = recv_data[0].decode('gbk')
  print(f"收到远程信息:{recv_content},from {recv_data[1]}")
  if recv_content == "88":
    print("结束聊天！")
    break
​
s.close()

示例：UDP持续发送数据

#coding=utf-8
from socket import *
​
s = socket(AF_INET,SOCK_DGRAM) #创建UDP类型的套接字
addr = ("127.0.0.1",8888)
​
while True:
  data = input("请输入：")
  s.sendto(data.encode("gbk"),addr)
  if data == "88":
    print("结束聊天！")
    break
​
s.close()

示例：TCP编程服务器端

from socket import *
#建立TCP套接字
server_socket = socket(AF_INET, SOCK_STREAM)
#本机监听8899端口
server_socket.bind(("127.0.0.1", 8899))
#设置最大监听数
server_socket.listen(5)
print("等待接收连接Q")
#获得信息
client_socket, client_info = server_socket.accept() #返回是个元组哦
#最大接收1024字节
recv_data = client_socket.recv(1024)
print(f'收到消息；{recv_data.decode("gbk")}, from;{client_info}')
client_socket.close()
server_socket.close()

示例：TCP编程客户端

from socket import *

client_socket = socket(AF_INET, SOCK_STREAM)
#建立连接
client_socket.connect(('127.0.0.1', 8899))
#发送信息
client_socket.send("hello".encode('gbk'))

示例：TCP编程服务端持续接收消息

from socket import *
#建立TCP套接字
server_socket = socket(AF_INET, SOCK_STREAM)
#本机监听8899端口
server_socket.bind(("127.0.0.1", 8899))
#设置最大监听数
server_socket.listen(5)
print("等待接收连接Q")
#获得信息
client_socket, client_info = server_socket.accept() #返回是个元组哦
print("一个客户端建立成功！")
while True:
    #最大接收1024字节
    recv_data = client_socket.recv(1024)
    print(f'客户端说；{recv_data.decode("gbk")}, 来自;{client_info}')
    if recv_data == '88' or recv_data == 'and':
        break
    msg = input('>请输入：')
    client_socket.send(msg.encode('gbk'))
client_socket.close()
server_socket.close()

示例：TCP编程客户端持续发送消息

from socket import *

client_socket = socket(AF_INET, SOCK_STREAM)
#建立连接
client_socket.connect(('127.0.0.1', 8899))
while True:
    #给服务端发送信息
    msg = input('>请输入向服务端发送的信息：')
    client_socket.send(msg.encode('gbk'))
    if msg == '88' or msg == 'and':
        break
    #接收服务端发的信息
    recv_data = client_socket.recv(1024) #最大接收1024字节
    print(f">服务端说：{recv_data.decode('gbk')}")


client_socket.close()

结合多线程实现UDP双向自由通信

UDP 不同于 TCP，不存在请求连接和受理过程，因此在某种意义上无法明确区分服务器端和客户端，只是因为其提供服务而称为服务器端。

如下服务端、客户端代码几乎一模一样，注意接收和发送端口对应，即可。

【示例】UDP实现多线程服务端

#coding=utf-8
from socket import *
from threading import Thread
udp_socket=socket(AF_INET,SOCK_DGRAM)
#绑定接收信息端口
udp_socket.bind(('127.0.0.1',8989))
​
#不停接收
def recv_data():
  while True:
    redata = udp_socket.recvfrom(1024)
    print(f'收到信息:{redata[0].decode("gbk")}, from {redata[1]}')
​
#不停发送
def send_data():
  while True:
    data=input('输入信息：')
    addr=('127.0.0.1',8080)
    udp_socket.sendto(data.encode('gbk'),addr)
​
if __name__=='__main__':
  # 创建两个线程
  t1=Thread(target=send_data)
  t2=Thread(target=recv_data)
  t2.start()
  t1.start()
  t1.join()
  t2.join()

【示例】UDP实现多线程客户端

#coding=utf-8
from socket import *
from threading import Thread
udp_socket=socket(AF_INET,SOCK_DGRAM)
#绑定接收信息端口
udp_socket.bind(('127.0.0.1',8080))
​
#不停接收
def recv_data():
  while True:
    redata = udp_socket.recvfrom(1024)
    print(f'收到信息:{redata[0].decode("gbk")}, from {redata[1]}')
​
#不停发送
def send_data():
  while True:
    data=input('输入信息：')
    addr=('127.0.0.1',8989)
    udp_socket.sendto(data.encode('gbk'),addr)
​
if __name__=='__main__':
  # 创建两个线程
  t1=Thread(target=send_data)
  t2=Thread(target=recv_data)
  t2.start()
  t1.start()
  t1.join()
  t2.join()

【示例】TCP实现多线程服务器

from socket import *
from threading import Thread

def recv_data():
    while True:
        # 最大接收1024字节
        recv_data = client_socket.recv(1024)
        recv_content = recv_data.decode("gbk")
        print(f'客户端说；{recv_content}, 来自：{client_info}')
        if recv_content == '88' or recv_data == 'end':
            print("结束链接")
            break

def send_data():
    while True:
        msg = input('>请输入：')
        client_socket.send(msg.encode('gbk'))
        if msg == '88':
            print("结束连接")
            break


if __name__ == '__main__':
    # 建立TCP套接字
    server_socket = socket(AF_INET, SOCK_STREAM)
    # 本机监听8899端口
    server_socket.bind(("127.0.0.1", 8899))
    # 设置最大监听数
    server_socket.listen(5)
    print("等待接收连接Q")
    # 获得信息
    client_socket, client_info = server_socket.accept()  # 返回是个元组哦
    print("一个客户端建立成功！")
    #建立两个线程，一个收一个发
    t1 = Thread(target=recv_data)
    t2 = Thread(target=send_data)

    t1.start()
    t2.start()

    t1.join()
    t2.join()

    client_socket.close()
    server_socket.close()

【示例】TCP实现多线程客户端

from socket import *
from threading import Thread

def recv_data():
    while True:
        # 接收服务端发的信息
        recv_data = client_socket.recv(1024)  # 最大接收1024字节
        recv_content = recv_data.decode("gbk")
        print(f">服务端说：{recv_content}")
        if recv_content == '88':
            print("结束连接!")
            break


def send_data():
    while True:
        # 给服务端发送信息
        msg = input('>请输入向服务端发送的信息：')
        client_socket.send(msg.encode('gbk'))
        if msg == '88' or msg == 'end':
            print("结束连接")
            break

if __name__ == '__main__':
    client_socket = socket(AF_INET, SOCK_STREAM)
    # 建立连接
    client_socket.connect(('127.0.0.1', 8899))

    t1 = Thread(target=recv_data)
    t2 = Thread(target=send_data)

    t1.start()
    t2.start()

    t1.join()
    t2.join()

    client_socket.close()