Python入门【TCP建立连接的三次握手、 TCP断开连接的四次挥手、套接字编程实战、 TCP编程的实现、TCP双向持续通信】(二十七)

艾派徳

已于 2023-08-19 21:37:51 修改

阅读量1.7k

点赞数 2

分类专栏： python入门到实战文章标签：网络 Python 网络协议 tcp/ip 进程

于 2023-08-16 11:16:46 首次发布

本文链接：https://blog.csdn.net/abc19991119/article/details/132313707

版权

python入门到实战专栏收录该内容

35 篇文章 19 订阅

订阅专栏

👏作者简介：大家好，我是爱敲代码的小王，CSDN博客博主,Python小白
📕系列专栏：python入门到实战、Python爬虫开发、Python办公自动化、Python数据分析、Python前后端开发
📧如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步👀
🔥如果感觉博主的文章还不错的话，请👍三连支持👍一下博主哦
🍂博主正在努力完成2023计划中：以梦为马，扬帆起航，2023追梦人

🔥🔥🔥 python入门到实战专栏：从入门到实战

🔥🔥🔥 Python爬虫开发专栏：从入门到实战

🔥🔥🔥 Python办公自动化专栏：从入门到实战

🔥🔥🔥 Python数据分析专栏：从入门到实战

🔥🔥🔥 Python前后端开发专栏：从入门到实战

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是传输层供给应用层的编程接口，所以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对象中，提供如表所示的内置函数。

UDP编程介绍

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

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

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()

结合多线程实现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编程介绍

面向连接的Socket使用的协议是TCP协议。TCP的Socket名称是 SOCK_STREAM 。创建套接字TCP套接字，可以调用 socket.socket() 。示例代码如下：

tcpSocket=socket.socket(AF_INET,SOCK_STREAM)

TCP编程的实现

在Python语言中创建Socket服务端程序，需要使用socket模块中的 socket类。创建Socket服务器程序的步骤如下：

（1）创建Socket对象。

（2）绑定端口号。

（3）监听端口号。

（4）等待客户端Socket的连接。

（5）读取客户端发送过来的数据。

（6）向客户端发送数据。

（7）关闭客户端Socket连接。

（8）关闭服务端Socket连接。

【示例】TCP服务器端接收数据

#coding=utf-8
from socket import *
server_socket = socket(AF_INET, SOCK_STREAM)
server_socket.bind(("", 8899))
server_socket.listen(5)
client_socket, client_info =
server_socket.accept()
#clientSocket 表示这个新的客户端
#clientInfo 表示这个新的客户端的ip以及port
recv_data = client_socket.recv(1024)
print(f"收到信息:{recv_data.decode('gbk')},来自:{client_info}")
client_socket.close()
server_socket.close()

【示例】TCP客户端发送数据到服务端

#coding=utf-8
from socket import *
client_socket = socket(AF_INET, SOCK_STREAM)
client_socket.connect(("127.0.0.1", 8899))
#注意：
# 1. tcp客户端已经链接好了服务器，所以在以后的数据发
送中，不需要填写对方的ip和port----->打电话
# 2. udp在发送数据的时候，因为没有之前的链接，所以需
要在每次的发送中，都要填写接收方的ip和port－－－－－＞写信　
client_socket.send("haha".encode("gbk"))
client_socket.close()

TCP双向持续通信

【示例】TCP：双向通信Socket之服务器端

#coding=utf-8
'''
双向通信Socket之服务器端
       读取客户端发送的数据，将内容输出到控制台
       将控制台输入的信息发送给客户器端
'''
#导入socket模块
from socket import *
#创建Socket对象
tcp_server_socket=socket(AF_INET,SOCK_STREAM)
#绑定端口
tcp_server_socket.bind(('', 8888))
#监听客户端的连接
tcp_server_socket.listen()
print("服务端已经启动，等待客户端连接！")
#接收客户端连接
tcp_client_socket,
host=tcp_server_socket.accept()
print("一个客户端建立连接成功！")
while True:
    #读取客户端的消息
  
re_data=tcp_client_socket.recv(1024).decode('gbk')
    #将消息输出到控制台
    print('客户端说：',re_data)
    if re_data=='end':
        break
    #获取控制台信息
    msg=input('>')
  
tcp_client_socket.send(msg.encode('gbk'))
tcp_client_socket.close()
tcp_server_socket.close()

【示例】TCP：双向通信Socket之客户端

#coding=utf-8
'''
双向通信Socket之客户端
       将控制台输入的信息发送给服务器端
       读取服务器端的数据，将内容输出到控制台
'''
#导入socket模块
from socket import *
#创建客户端Socket对象
tcp_client_socket=socket(AF_INET,SOCK_STREAM)
#连接服务器端
tcp_client_socket.connect(('127.0.0.1',8888))
while True:
    msg=input('>')
    #向服务器发送数据
  
 tcp_client_socket.send(msg.encode('gbk'))
    if msg=='end':
        break
    #接收服务器端数据
    re_data=tcp_client_socket.recv(1024)
    print('服务器端说：',re_data.decode('gbk'))
tcp_client_socket.close()

首先运行示例启动服务器端程序，然后运行示例客户端程序。执行结果如下图所示:

结合多线程实现TCP双向传送(自由聊天)

【示例】TCP服务端结合多线程实现自由收发信息

#coding=utf-8
'''
双向通信Socket之服务器端
       读取客户端发送的数据，将内容输出到控制台
       将控制台输入的信息发送给客户器端
'''
#导入socket模块
from socket import *
from threading import Thread
def recv_data():
    while True:
        # 读取客户端的消息
        re_data =
tcp_client_socket.recv(1024).decode('gbk')
        # 将消息输出到控制台
        print(f'客户端说:{re_data}')
        if re_data == 'end':
            break
def send_data():
    while True:
        # 获取控制台信息
        msg = input('>')
      
tcp_client_socket.send(msg.encode('gbk'))
if __name__ == '__main__':
    # 创建Socket对象
    tcp_server_socket = socket(AF_INET,SOCK_STREAM)
    # 绑定端口
    tcp_server_socket.bind(('', 8888))
    # 监听客户端的连接
    tcp_server_socket.listen()
    print("服务端已经启动，等待客户端连接！")
    # 接收客户端连接
    tcp_client_socket, host = tcp_server_socket.accept()
    print("一个客户端建立连接成功！")
    t1 = Thread(target=recv_data)
    t2 = Thread(target=send_data)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    tcp_client_socket.close()
    tcp_server_socket.close()

【示例】TCP客户端结合多线程实现自由收发信息

#coding=utf-8
'''
双向通信Socket之客户端
       将控制台输入的信息发送给服务器端
       读取服务器端的数据，将内容输出到控制台
'''
#导入socket模块
from socket import *
from threading import Thread
def recv_data():
    while True:
        # 接收服务器端数据
        re_data = tcp_client_socket.recv(1024)
        print(f'\n服务器端说: {re_data.decode("gbk")}')
def send_data():
    while True:
        msg = input('>')
        # 向服务器发送数据
      tcp_client_socket.send(msg.encode('gbk'))
        if msg == 'end':
            break
if __name__ == '__main__':
    # 创建客户端Socket对象
    tcp_client_socket = socket(AF_INET,SOCK_STREAM)
    # 连接服务器端
    tcp_client_socket.connect(('127.0.0.1',8888))
    t1 = Thread(target=recv_data)
    t2 = Thread(target=send_data)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    tcp_client_socket.close()

关于http协议和服务器的授课顺序说明

由于大家还没有学习网页内容，考虑到更好的和实战结合。所以，在讲服务器编程时，详细展开。

艾派徳

关注

2
点赞
踩
9

收藏

觉得还不错? 一键收藏
1
评论
Python入门【TCP建立连接的三次握手、 TCP断开连接的四次挥手、套接字编程实战、 TCP编程的实现、TCP双向持续通信】(二十七)

Python入门【TCP建立连接的三次握手、 TCP断开连接的四次挥手、套接字编程实战、 TCP编程的实现、TCP双向持续通信】(二十七)
复制链接

扫一扫