Python-Level2-day11:TCP客户端/服务端传输(循环模型之短连接与长连接形态)；TCP粘包问题；与UDP对比；数据传输过程原理；

原创 已于 2022-08-25 13:38:51 修改 · 953 阅读 · 7 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#python
于 2022-05-27 16:48:30 首次发布
本文深入讲解TCP与UDP两种网络协议的特点及应用场景，包括TCP的三次握手、四次挥手过程，以及UDP的数据报传输方式。同时介绍了套接字编程的具体实现，并通过实例演示了如何使用这两种协议进行数据传输。 
前情回顾
​
1. 网络概念
​
  什么是网络 : 数据传输
​
  OSI七层模型 : 网络通信标准化流程模型
​
  tcp/ip模型 : 实际工作模型
​
  网络协议 : 网络通信过程中都遵循的规定
​
  网络地址 : IP(公网,内网)   端口
​
  服务端客户端:  C/S结构    B/S
​
​
 cookie:
  面试理论问题
  这是什么->具体描述->特点(优点,缺点)->话题引申->我用它干什么
​
2. 套接字编程  (写功能,确定地址,选择服务)
​
  UDP套接字 (也叫数据报套接字)  (udp协议)
​
  服务端: socket()->bind()->recvfrom/sendto->close()
   客户端: socket()--------->sendto/recvfrom->close()
​
​
 训练1:
 改写代码,让客户端可以循环收发消息,
 直到输入##两边都退出
​
注意：1.address error  当非法中断服务端端口，而不是##程序中断时候，系统认为网络断开
 与服务连接不上，此时重新运行服务端会报端口地址重复错误，过几分钟就好了。
 操作系统自动将这个地址丢弃。
   2.broken pipe ereror --在客户端不通知服务端的情况下退出（自己非法结束终端），
 那么服务端的recv不在阻塞了，他会返回一个空字节串，然后打印空，发送thanks,
 再循环一遍，再返回空，再打印空，然后就不发thanks了，开始报错。
   3.连接就意味责任，一方退出必须告诉对方，否者报错。
 解决方法：服务端写上if not data or data == b"##"，python的客户端是
 无法发送空字节串。
​
​
 训练2:
 改写代码,让客户端退出但是服务端不退出,
 服务端可以继续处理下一个客户端连接
​
练习01:
 完成一个图片上传练习,将一个图片从客户端
 上传到服务端,在服务端以 20210409.jpg为
 名字保存
 图片自选 注意,图片可能比较大,不建议一次性read读取
​
​
 练习02: 模拟一个问答机器人
 从客户端输入问题发送给服务端,
 服务端根据问题中是否有关键字返回对应的回答
​
​
 你多大了 : 我今年2岁了
 男生女生 : 我是机器人
 叫什么 : 我叫小美
     人家还小不知道啦
​
​
 作业 : 1. 今天的重点代码 自己独立完成
    \2. 两天的练习自己没写出来的 独立完成

1.3 TCP 传输方法

1.3.1 TCP传输特点

  • 面向连接的传输服务：即传输之前必须建立连接关系

    • 传输特征 ： 提供了可靠的数据传输，可靠性指数据传输过程中无丢失，无失序，无差错，无重复。

    • 可靠性保障机制（都是操作系统网络服务自动帮应用完成的）：

      • 在通信前需要建立数据连接

      • 确认应答机制

      • 通信结束要正常断开连接

  • 三次握手（建立连接）

    • 客户端向服务器发送消息报文请求连接

    • 服务器收到请求后，回复报文确定可以连接

    • 客户端收到回复，发送最终报文连接建立

img编辑

  • 四次挥手（断开连接）

    • 主动方发送报文请求断开连接（谁先发起都可以）

    • 被动方收到请求后，立即回复报文，表示准备断开

    • 被动方准备就绪，再次发送报文表示可以断开

    • 主动方收到确定，发送最终报文完成断开

img编辑

1.3.2 TCP服务端处理

img编辑

服务端通信流程：创建TCP套接字->绑定自己服务端地址->具备监听功能，可以被客户端连接listen->阻塞等待客户端连接accept->收发消息->关闭套接字。因此对比于udp，多了listen与accept是处理连接三次握手用的。

  • 创建套接字

    sockfd=socket.socket(family,type)
    功能：创建套接字
    参数：family  网络地址类型 AF_INET表示ipv4
         type  套接字类型 SOCK_STREAM默认,表示tcp套接字 （也叫流式套接字） 
    返回值： 套接字对象

  • 绑定地址 （与udp套接字相同）

  • 设置监听（使得具备被客户端连接的功能）

    sockfd.listen(n)
    功能 ： 将套接字设置为监听套接字，确定监听队列大小,即具备被客户端连接能力。实现缓冲效果。
    参数 ： 监听队列大小（只能一个一个处理客户端，给他一个队列排队等待）
    在Linux下这个参数就是摆设，操作系统自动帮你设置监听队列缓冲区大小，设置越大占内存越大，并且三次握手几乎在瞬间完成。

img编辑

  • 处理客户端连接请求

    connfd,addr = sockfd.accept()
    功能： 阻塞等待处理客户端请求
    返回值： connfd  客户端连接套接字
            addr    连接的客户端地址

img

服务端accept阻塞等待客户端发送数据建立连接关系后，为每一个客户端单独创建一个connfd套接字，应对每一个客户端的数据传输功能，而socket专门用于建立连接，连接完成一个客户端创建一个connfd，他是客户端的专属服务管家。如果客户端退出了，对应的connfd随之销毁。

  • 消息收发

  data = connfd.recv(buffersize)
    功能 : 接受客户端消息
    参数 ：每次最多接收消息的大小
    返回值： 接收到的内容
​
    n = connfd.send(data)
    功能 : 发送消息
    参数 ：要发送的内容  bytes格式
    返回值： 发送的字节数

  • 关闭套接字 (与udp套接字相同)

"""
   tcp服务端数据传输案例：重点代码
"""
from socket import *
​
# 1.创建tcp套接字
tcp_socket = socket(AF_INET, SOCK_STREAM)  # 默认选择也是TCP协议
​
# 2.绑定地址：只有服务端才需要固定地址
tcp_socket.bind(("0.0.0.0", 8888))
​
# 3.设置为监听功能：同一时刻允许5个客户端发起连接给他一个缓冲队列等待
tcp_socket.listen(5)
​
# 4.阻塞等待客户端处理连接
print("wait for connect...")
connfd, addr = tcp_socket.accept()
print("Connect from ", addr) #发现客户端需要与我建立连接完成
​
# 5.先收后发消息
data = connfd.recv(1024)  # 阻塞等待接收数据：一次连接接收数据后就断开，tcp不循环接收数据照样丢失
print("服务端收到数据为：", data.decode())
connfd.send(b"Thinks")
​
# 6.关闭
connfd.close()  # 关闭与某个客户端连接：完成四次挥手
tcp_socket.close()  # 关闭套接字，断开所有客户端
​

1.3.3 TCP客户端处理

img

创建与服务端相同类型的套接字->客户端发起连接->数据的发送与接受->关闭套接字

  • 创建TCP套接字

  • 请求连接

    sockfd.connect(server_addr)
    功能：连接服务器
    参数：元组  服务器地址

  • 收发消息

注意： 防止两端都阻塞，recv send要配合用

  • 关闭套接字

"""
    tcp客户端数据传输案例
"""
from socket import *
​
# 1.创建与服务端相同tcp套接字
tcp_socket = socket(AF_INET, SOCK_STREAM)  # 默认选择也是TCP协议
​
# 2.请求连接，三次握手，与服务端accept对应：写服务器地址
tcp_socket.connect(("127.0.0.1", 8888))
​
# 3.先发后收消息
tcp_socket.send(b"hello")
data = tcp_socket.recv(1024)  # 阻塞等待接收数据
print("客户端收到数据为：", data.decode())
​
# 4.关闭tcp套接字
tcp_socket.close()
​

img编辑

"""
     改写代码,让客户端可以循环收发消息,
     直到输入##两边都退出
"""
from socket import *
from time import sleep
​
tcp_socket = socket(AF_INET, SOCK_STREAM)
tcp_socket.bind(("0.0.0.0", 8888))
tcp_socket.listen(5)
print("wait for connect...")
connfd, addr = tcp_socket.accept()
print("Connect from ", addr)
​
while True:
    data = connfd.recv(1024)  # 阻塞等待接收数据
    # 当连接的两端有一端(通常是客户端)突然退出的时候
    # 另外一端的recv就不再阻塞，会得到一个空字节串
    if data.decode() == "##" or not data:
        break
    print("服务端收到数据为：", data.decode())
    connfd.send(b"Thinks")
    # sleep(0.1)
​
connfd.close()  # 关闭与某个客户端连接：完成四次挥手
tcp_socket.close()  # 关闭套接字，断开所有客户端
​
​
"""客户端程序"""
from socket import *
​
tcp_socket = socket(AF_INET, SOCK_STREAM)
tcp_socket.connect(("127.0.0.1", 8888))
​
while True:
    senddata = input(">>")
    tcp_socket.send(senddata.encode())#如果发送##通知服务端要断开连接
    if senddata == "##":#不然客户端不打招呼给服务端就退出容易管道破裂
        break#客户端发不了空字节串，因为发他没有意义
    data = tcp_socket.recv(1024)  # 阻塞等待接收数据
    print("客户端收到数据为：", data.decode())
tcp_socket.close()
​

"""
    改写代码,让客户端退出但是服务端不退出,
    服务端可以继续处理下一个客户端连接
​
    这里程序是循环模型，不是并发模型，不能应对多个客户端同时发出数据做处理，只能在
    这个客户端处理完成退出后，才能等待下一个客户端连接。即tcp 长连接形态
    udp也是循环模型，虽然任何人发数据都接收，但只是处理快的让你感觉多个客户端
    可以同时处理
"""
from socket import *
​
tcp_socket = socket(AF_INET, SOCK_STREAM)
tcp_socket.bind(("0.0.0.0", 8888))
tcp_socket.listen(5)
while True:
    print("wait for connect...")
    connfd, addr = tcp_socket.accept()
    print("Connect from ", addr)
    while True:
        data = connfd.recv(1024)  # 阻塞等待接收数据
        if data.decode() == "##" or not data:
            break
        print("服务端收到数据为：", data.decode())
        connfd.send(b"Thinks")
    connfd.close()
​
"""
   客户端程序
"""
from socket import *
​
tcp_socket = socket(AF_INET, SOCK_STREAM)
tcp_socket.connect(("127.0.0.1", 8888))
​
while True:
    senddata = input(">>")
    tcp_socket.send(senddata.encode())
    if senddata == "##":
        break
    data = tcp_socket.recv(1024)  # 阻塞等待接收数据
    print("客户端收到数据为：", data.decode())
​
tcp_socket.close()
​
​
​

"""
 完成一个图片上传练习,将一个图片从客户端
上传到服务端,在服务端以 20210409.jpg为名字保存
图片自选 注意,图片可能比较大,不建议一次性read读取
"""
from socket import *
​
tcp_socket = socket(AF_INET, SOCK_STREAM)
tcp_socket.connect(("127.0.0.1", 8888))
file1 = open("caihua.jpeg", "rb")
while True:
    data = file1.read(1024)
    if not data:
        break
    tcp_socket.send(data)
tcp_socket.close()
#发送完成客户端关闭，客户端退出后服务端收到系统发的空字符串
​
​
"""
    服务端程序
"""
"""
 完成一个图片上传练习,将一个图片从客户端
上传到服务端,在服务端以 20210409.jpg为名字保存
图片自选 注意,图片可能比较大,不建议一次性read读取
"""
from socket import *
​
tcp_socket = socket(AF_INET, SOCK_STREAM)
tcp_socket.bind(("0.0.0.0", 8888))
tcp_socket.listen(5)
file2 = open("20210402.jpg", "wb")
​
while True:
    print("wait for connect...")
    connfd, addr = tcp_socket.accept()
    print("Connect from ", addr)
    while True:
        data = connfd.recv(1024)  # 阻塞等待接收数据
        file2.write(data)
        if not data:
            break
    connfd.close()
    file2.close()
​
​
​
"""
升级
    tcp服务端例子：短连接形态,看起来好像和udp一样同一时间可以应对多个客户端
    其实并不是，只是应对的客户端只接收4字节后就迅速断开，不是真正的同时
    即只处理一次数据交互就断开连接。如果下次还想进行交互就必须建立连接
    之前是一次只应对一个客户端，一次连接长久有效，效率较高
    现在是不利用并发技术下 一次应对多个客户端，由于每次需要三次挥手，效率较低
"""
from socket import *
​
def main():
    tcp_sock = socket()
    tcp_sock.bind(("0.0.0.0", 8888))
    tcp_sock.listen(5)
    while True:
        connfd, add = tcp_sock.accept()
        print("connect from:", add)
        handle(connfd)  # 只进行一次客户端交互数据就断开，不能长期占有服务器端口代码
        connfd.close()
​
​
def handle(connfd):
    data = connfd.recv(4)
    print(data.decode())
    connfd.send(b"ok")
​
​
if __name__ == '__main__':
    main()
​
"""
    客户端1
"""
from socket import *
​
​
def main():
    while True:
        msg = input(">>")
        if not msg:
            break
        tcp_connect(msg)
​
​
def tcp_connect(msg):
    tcp_socket = socket(AF_INET, SOCK_STREAM)
    tcp_socket.connect(("127.0.0.1", 8888))
    tcp_socket.send(msg.encode())
    data = tcp_socket.recv(1024)
    print("客户端收到数据为：", data.decode())
​
    tcp_socket.close()
​
​
if __name__ == '__main__':
    main()
​
"""
    客户端2：如果服务端1的数据传输需要占用很长时间，那么客户端2也连接不上服务端。因此这个循环模型适合处理小数据传输，传输完成后立即等待下一个客户端连接。
"""
from socket import *
​
​
def main():
    while True:
        msg = input(">>")
        if not msg:
            break
        tcp_connect(msg)
​
​
def tcp_connect(msg):
    tcp_socket = socket(AF_INET, SOCK_STREAM)
    tcp_socket.connect(("127.0.0.1", 8888))
    tcp_socket.send(msg.encode())
    data = tcp_socket.recv(1024)
    print("客户端收到数据为：", data.decode())
​
    tcp_socket.close()
​
​
if __name__ == '__main__':
    main()
"""
练习02: 模拟一个问答机器人
从客户端输入问题发送给服务端,
服务端根据问题中是否有关键字返回对应的回答
​
客户端2
你多大了 :  2ages
​
客户端3:
男生女生 :  robort
​
客户端1
叫姓名什么 : xiao yi
"""
from socket import *
​
def main():
    tcp_sock = socket()
    tcp_sock.bind(("0.0.0.0", 8888))
    tcp_sock.listen(5)
    while True:
        connfd, add = tcp_sock.accept()
        print("connect from:", add)
        handle(connfd)
        connfd.close()
​
​
def handle(connfd):
    data = connfd.recv(1024)
    if "age" in data.decode():
        connfd.send(b"2 ages")
    elif "name" in data.decode():
        connfd.send(b"xiao yi")
    elif "sex" in data.decode():
        connfd.send(b"robot")
    else:
        connfd.send(b"sorry I not know")
​
​
if __name__ == '__main__':
    main()
​
 """客户端1""" 
from socket import *
​
​
def main():
    while True:
        msg = input(">>")
        if not msg:
            break
        tcp_connect(msg)
​
​
def tcp_connect(msg):
    tcp_socket = socket(AF_INET, SOCK_STREAM)
    tcp_socket.connect(("127.0.0.1", 8888))
    tcp_socket.send(msg.encode())
    data = tcp_socket.recv(1024)
    print("客户端1收到数据为：", data.decode())
​
    tcp_socket.close()
​
​
if __name__ == '__main__':
    main()
​
 
"""
客户端2
"""
 from socket import *
​
​
def main():
    while True:
        msg = input(">>")
        if not msg:
            break
        tcp_connect(msg)
​
​
def tcp_connect(msg):
    tcp_socket = socket(AF_INET, SOCK_STREAM)
    tcp_socket.connect(("127.0.0.1", 8888))
    tcp_socket.send(msg.encode())
    data = tcp_socket.recv(1024)
    print("客户端2收到数据为：", data.decode())
    tcp_socket.close()
​
​
if __name__ == '__main__':
    main()
​

1.3.4 TCP套接字细节

  • tcp连接中当一端退出，另一端如果阻塞在recv，此时recv会收到一个空字串。

  • tcp连接中如果一端已经不存在，仍然试图通过send向其发送数据则会产生BrokenPipeError

  • 一个服务端可以同时连接多个客户端，也能够重复被连接，即循环模型的短连接形态

  • tcp粘包问题

    • 产生原因

      • 为了解决数据再传输过程中可能产生的速度不协调问题，例如发送端发10个字节，接收端按照5个字节接收。如果不是长连接模型那么另外的5个字节就丢了，但操作系统设置了缓冲区专门给tcp提供可靠不丢失传输服务，分两次发送。

      • 实际网络工作过程比较复杂，导致消息收发速度不一致

      • tcp以字节流方式进行数据传输，udp是数据报方式传输，在接收时不区分消息边界，发送端发送的数据都连接堆积在缓冲区里面，如同水流不间断。

      • img编辑

    • 带来的影响

      • 如果每次发送内容是一个独立的含义，需要接收端独立解析此时粘包会有影响。

    • 处理方法

      • 消息格式化处理，如人为的添加消息边界，用作消息之间的分割。

      • 软件sleep来控制发送的速度

from socket import *
from time import sleep
​
tcp_socket = socket(AF_INET, SOCK_STREAM)
tcp_socket.bind(("0.0.0.0", 8888))
tcp_socket.listen(5)
while True:
    print("wait for connect...")
    connfd, addr = tcp_socket.accept()
    print("Connect from ", addr)
    while True:
        data = connfd.recv(2)  # 阻塞等待接收数据
        if data.decode() == "##" or not data:
            break
        print("服务端收到数据为：", data.decode())
        connfd.send(b"Thinks#")#区分粘包边界
        sleep(0.1)#等完全发出去Thinks后再接收服务端缓冲区剩余字节
    connfd.close()
    

1.3.5 TCP与UDP对比

  • 传输特征

    • TCP提供可靠的数据传输，但是UDP则不保证传输的可靠性

    • TCP传输数据处理为字节流，而UDP处理为数据包形式

    • TCP传输需要建立连接才能进行数据传，效率相对较低，UDP比较自由，无需连接，效率较高

  • 套接字编程区别

    • 创建的套接字类型不同

    • tcp套接字会有粘包，udp套接字有消息边界不会粘包

    • tcp套接字依赖listen accept建立连接才能收发消息，udp套接字则不需要

    • tcp套接字使用send，recv收发消息，udp套接字使用sendto，recvfrom

  • 使用场景

    • tcp更适合对准确性要求高，传输数据较大的场景

      • 文件传输：如下载电影，访问网页，上传照片

      • 邮件收发

      • 点对点数据传输：如点对点聊天，登录请求，远程访问，发红包

    • udp更适合对可靠性要求没有那么高，传输方式比较自由的场景

      • 视频流的传输： 如直播，视频聊天

      • 广播：如网络广播，群发消息

      • 实时传输：如游戏画面

    • 在一个大型的项目中，可能既涉及到TCP网络又有UDP网络

1.4 数据传输过程

1.4.1 传输流程

  • 发送端由应用程序发送消息，上到下逐层添加首部信息，最终在物理层发送消息包。如果数据过大，拆分成一帧一帧发送，帧头与帧尾将这大数据按照顺序连接起来。

  • 发送的消息经过多个网络设备节点（交换机，路由器）传输，最终到达目标主机。

  • 目标主机由物理层逐层解析首部消息包，最终到应用程序呈现消息。

img编辑

1.4.2 传输层的TCP协议首部信息(了解)

img编辑

  • 源端口和目的端口 各占2个字节，分别写入源端口和目的端口。

  • 序号seq占4字节。TCP是面向字节流的。在一个TCP连接中传送的字节流中的每一个字节都按顺序编号。例如，一报文段的序号是301，而接待的数据共有100字节。这就表明本报文段的数据的第一个字节的序号是301，最后一个字节的序号是400。

  • 确认号ack占4字节，是期望收到对方下一个报文段的第一个数据字节的序号。例如，B正确收到了A发送过来的一个报文段，其序号字段值是501，而数据长度是200字节（序号501~700），这表明B正确收到了A发送的到序号700为止的数据。因此，B期望收到A的下一个数据序号是701，于是B在发送给A的确认报文段中把确认号置为701。

  • 确认ACK（ACKnowledgment） 仅当ACK = 1时确认号字段才有效，当ACK = 0时确认号无效。TCP规定，在连接建立后所有的传送的报文段都必须把ACK置为1。

  • 同步SYN（SYNchronization） 在连接建立时用来同步序号。当SYN=1而ACK=0时，表明这是一个连接请求报文段。对方若同意建立连接，则应在响应的报文段中使SYN=1和ACK=1，因此SYN置为1就表示这是一个连接请求或连接接受报文。

  • 终止FIN（FINis，意思是“完”“终”） 用来释放一个连接。当FIN=1时，表明此报文段的发送发的数据已发送完毕，并要求释放运输连接。

python的入门TCP编程
热门推荐
arlovekyh的博客
03-27 1万+
一、创建TCP服务器 创建TCP服务器的流程： 使用socket创建一个套接字 使用bind绑定IP和端口 使用listen让套接字变成可以被动连接 使用accept等待客户端的连接 使用recv/send接收和发送数据 例子：我们实现一个服务器向浏览器发送“Hello World”。 创建一个server.py文件 import socket #导入socket模块 host = '127.0.0.1' #主机IP port = 8080 #端口 web
TCP （传输控制协议）和 UDP
agustinymy
07-15 1022
传输控制协议（TCP，Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议。是为了在不可靠的互联网络上提供可靠的端到端字节流而专门设计的一个传输协议。 TCP是一种面向广域网的通信协议，目的是在跨越多个网络通信时，为两个通信端点之间提供一条具有下列特点的通信方式： （1）基于流的方式； （2）面向连接； （3）可靠通信方式； （4）在网络...
Python TCP网络编程入门到实战：从原理到代码，手把手教你实现客户端与服务端通信
最新发布
weixin_60925698的博客
04-03 399
Python网络编程入门：TCP通信实现指南 本文介绍了Python网络编程基础，重点讲解TCP协议的客户端-服务端通信实现。核心内容包括： 网络基础概念：IP地址（设备定位）、端口号（程序定位）、Socket（通信工具）和TCP协议（可靠传输） 编程流程： 服务端7步：创建socket→绑定地址→监听→接受连接→收发数据→关闭连接 客户端5步：创建socket→连接服务端→收发数据→关闭连接 完整代码示例：提供可直接运行的TCP双向聊天程序，包含详细注释 注意事项：必须先启动服务端再连接客户端，统一编码格
Python_socket编程
qq_36985354的博客
02-24 1787
也有人将socket说成ip+port，ip是用来标识互联网中的一台主机的位置，而port是用来标识这合机器上的一个应用程序，ip地址是配置到网卡上的，而port是应用程序开启的，ip与port的绑定就标识了互联网中独一无二的一个应用程序。有了ethernet、mac地址、广播的发送方式世界上的计算机就可以彼此通信了，问题是世界范围的互联网是由一个个彼此隔离的小的局域网组成的，那么如果所有的通信都采用以太网的广播方式，那么一台机器发送的包全世界都会收到，这就不仅仅是效率低的问题了，这会是一种灾难。
Python网络编程之TCP
AI创世纪的博客
04-21 3850
TCP协议，传输控制协议（Transmission Control Protocol，TCP）是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC793定义。TCP通信需要经过创建连接、数据传送、终止连接三个步骤。正在上传…重新上传取消TCP通信模型中，在通信开始之前，一定要先建立相关的链接，才能发送数据。
python网络编程（Tcp/Ip网络通讯协议）
m0_65995252的博客
09-23 4684
Python网络编程是指使用Python编程语言进行网络通信和网络应用开发的技术。Python提供了一系列的网络编程库和模块，可以方便地进行网络通信、创建网络服务器、编写网络应用等。Python的网络编程模块包括socket、select、asyncio等。其中，socket模块是Python最基础、最常用的网络编程模块，提供了对套接字编程的支持，可以创建TCP、UDP等类型的套接字，进行网络通信。select模块提供了对I/O多路复用的支持，可以同时监听多个套接字的I/O事件。
Python-Level2-day12:多任务概述,进程概述,多进程编程,进程处理细节(僵尸&孤儿进程,进程函数编写风格),面向对象创建进程类
dpq666dpq666
07-19 461
2022年7月19日16:51:08
Python中的TCP
weixin_45862390的博客
11-14 1284
文章目录一. 计算机网络1. 网络的概念2. IP地址3. 端口和端口号的概念4. socket套接字二. TCP三. TCP实战 一. 计算机网络 1. 网络的概念 2. IP地址 3. 端口和端口号的概念 4. socket套接字 二. TCP 三. TCP实战
TCP协议快速入门到python实战
qq_53631388的博客
08-23 2898
简单通俗地说TCP
python网络编程—TCP协议（一）
python全栈
10-17 4895
客户端发送请求,用send不用sendto，客户端知道服务器的ip和端口，服务器也知道客户端的端口和ip，因为是面向连接的。等待客户端的连接请求,当前函数是线程阻塞的函数，accept返回2个值，第一个：新的socket，第二个：客户端地址，创建目标服务器，绑定一个IP和端口 服务器里面空的字符串代表server_socket绑定这台机器下的任何ip地址。新创建的socket是server_socket中的子socket，只是和当前的客户端（一个客户端）收发数据。
Python网络编程之TCP协议
weixin_66398100的博客
02-09 879
Python网络编程之TCP协议
Python网络编程之TCP编程
精益求精，永无止境，永远在路上！
08-18 4107
Python网络编程之TCP编程，创建一个属于我们自己的聊天室吧（一起努力，咱们顶峰相见！！！）
python中TCP的使用
xuan_kong的博客
03-22 728
backlog:限制最大的连接数量 如果设置了固定值 那么客户端连接的数量不能超过这个固定值。5.accept()这个方法是等待客户端连接服务器 此方法会堵塞程序 当有客户端连接了 堵塞就会解除。# 所有针对于该客户端的任何操作 有这个一对一的socket对象来执行。# 这个值可以不写 那么连接的最大数量 根据计算机的运行内存来分配。# socket对象 , 客户端的地址 = accept()# 这个socket对象是服务当前连接的客户端的。4.创建一个连接的监听 设置指定的客户端连接数量。
TCP协议双向网络通讯---Python实现
博主关注人工智能、强化学习、嵌入式等||985高校A+学科研究生、猿龄六年||CSDN博客专家、2024年博客之星TOP33、华为云享专家、人工智能领域优质创作者。
07-11 4471
TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。它工作在OSI模型的传输层，旨在确保数据在IP网络中的可靠传输。以下是对TCP协议网络通讯的详细论述： 本文主要使用Python实现TCP协议双向网络通讯，即服务器和客户端都可以实现信息的收发，采用多线程的方式，能够实现服务器的一对多收发信息。
Python实现TCP通信
NightSky_XTC的博客
05-04 3434
TCP：由于tcp是数据流的形式接收，所有发送数据都会粘着一起，如果接收数据超过我们指定的，则会出现粘包现象，那么此时这个数据还会保存在缓冲区，这里也就是recv内，待我们下次再次recv时，取到的就会是上次没有取完的数据。问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据。定义：数据全部粘在一起，如果一次性未取完，下一次接着上一次未取完的数据部分接着取。
python网络编程---TCP协议进行
W030321的博客
07-15 2426
在这里简单实现一个TCP服务器，用于监听来自客户端的连接，接收客户端发送的消息，并向客户端发送响应消息。下面我将详细解释这个代码的工作原理和各个部分的作用。首先建立一个客户端（client），一个服务端（server），在客户端进行连接到运行在本地机器（IP地址为。然后建立一个服务端（server）监听本地机器上的8080端口，等待客户端的连接，并与连接的客户端进行双向通信。客户端通过标准输入接收用户输入的消息，将这些消息发送给服务器，并接收来自服务器的响应。）上的TCP服务器，该服务器监听。
【python学习笔记】python实现TCP
热情、奔放、快乐编程！
11-24 1147
本文简单介绍python实现TCP的简要过程，仅供参考学习。
Python--TCP/UDP通信
zhoutong2323的博客
09-17 2406
TCP三次握手：在TCP通信中，建立连接的过程涉及到三次握手。这确保了双方都能够确认对方的存在和准备接收数据。数据传输：TCP协议确保了数据的可靠传输。它通过序列号、确认应答、超时重传等机制来确保数据的顺序、完整性和无重复传输。连接管理：TCP连接是面向连接的，这意味着在数据交换之前必须先建立连接，并在数据交换完成后关闭连接。错误处理：在通信过程中，可能会遇到各种错误（如网络中断、连接超时等）。Python的socket模块提供了相应的异常处理机制，允许开发者在发生错误时采取适当的措施。
使用python实现tcp连接
bucketyoung的博客
03-23 1052
创建了一个TCP/IP套接字对象（socket.socket），然后使用connect方法连接到远程主机（在本例中，连接到本地主机的10000端口）。接着使用sendall方法发送一条消息，使用recv方法接收从服务器返回的数据。，使用close方法关闭套接字对象。
linux线程卡死在recvfrom,python：无法终止挂在socket.recvfrom（）中的线程调用
weixin_28689729的博客
05-11 962
我无法终止挂起在socket.recvfrom()调用中的线程。例如，应该触发KeyboardInterrupt异常的ctrl + c不能被捕获。以下是我用于测试的脚本：python：无法终止挂在socket.recvfrom()中的线程调用from socket import *from threading import Threadfrom sys import exitclass TestT...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

dpq666dpq666

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值