Python网络编程与并发编程_02

已于 2024-05-06 10:02:49 修改
阅读量339 收藏 4
点赞数 7
文章标签： python
于 2024-05-05 22:18:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84524453/article/details/138475532
版权

文章目录

套接字编程实战

socket对象的内置函数和属性

UDP服务器最简化案例

from socket import *

# 最简化的UDP服务器代码
# AF_INET指定使用IPv4地址
# SOCK_DGRAM指定使用UDP协议
s = socket(AF_INET, SOCK_DGRAM)  # 创建UDP类型的套接字

# 这里绑定的是本地回环地址的8888端口，表示服务器将在本地的8888端口上监听
# 如果IP地址留空或设置为None，服务器将监听所有可用的网络接口上的指定端口
s.bind(("127.0.0.1", 8888))  # 绑定端口，ip可以不写

print("等待接受数据！")

# recv()方法用于接收数据，它将阻塞直到有数据到达
# 返回值是一个包含两部分的元组：数据内容和发送方的地址信息
recv_data = s.recv(1024)  # 1024代表本次接受的最大字节数

print(f"收到远程信息：{recv_data[0].decode('gbk')}, from {recv_data[1]}")

# 关闭套接字
s.close()

这段代码的逻辑如下:

  1. 导入socket库。
  2. 创建一个UDP套接字。
  3. 将套接字绑定到本地的8888端口上，准备接收数据。
  4. 打印一条消息，通知服务器正在等待接收数据。
  5. 使用recv方法接收数据。这里设置的1024是缓冲区的大小，即服务器一次能够接收的最大数据量。
  6. 打印出接收到的数据以及发送方的地址信息。
  7. 最后关闭套接字，释放资源。

UDP客户端最简化案例

from socket import *

# 创建UDP类型的套接字
# AF_INET指定使用IPv4地址
# SOCK_DGRAM指定使用UDP协议
s = socket(AF_INET, SOCK_DGRAM)

# 定义服务器的地址和端口，这里使用的是本地回环地址和端口号8888
address = ("127.0.0.1", 8888)

# 提示用户输入数据，input函数会读取用户输入的字符串
data = input("请输入: ")

# sendto方法用于发送数据到指定的地址
# data.encode("gbk")将字符串数据转换为GBK编码的字节流，因为socket发送的是字节数据
# 第二个参数address是元组，包含服务器的IP地址和端口号
s.sendto(data.encode("gbk"), address)

# 关闭套接字，释放系统资源
s.close()

这段代码的逻辑是：

  1. 导入socket库。
  2. 创建一个UDP套接字。
  3. 定义服务器的IP地址和端口号。
  4. 提示用户输入要发送的数据。
  5. 使用sendto方法将用户输入的数据发送到服务器。这里，data.encode("gbk")是将输入的字符串转换为字节流，因为UDP协议发送的是字节数据。
  6. 关闭套接字。

UDP服务端持续接收信息

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客户端持续发送信息

from socket import *


s = socket(AF_INET, SOCK_DGRAM)
address = ("127.0.0.1", 8888)

while True:
    data = input("请输入: ")
    s.sendto(data.encode("gbk"), address)
    if data == "88":
        print("结束聊天！")
        break

# 关闭套接字，释放系统资源
s.close()

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

客户端

from socket import *
from threading import Thread


def receive_data():
    while True:
        receive_data = s.recvfrom(1024)
        receive_content = receive_data[0].decode("gbk")
        print(f"收到远程信息: {receive_content}, from {receive_data[1]}")
        if receive_content == "88":
            print("结束聊天")
            break


def send_data():
    address = ("127.0.0.1", 8888)
    while True:
        data = input("请输入: ")
        s.sendto(data.encode("gbk"), address)
        if data == "88":
            print("结束聊天")
            break


if __name__ == '__main__':
    s = socket(AF_INET, SOCK_DGRAM)
    s.bind(("127.0.0.1", 9999))
    t1 = Thread(target=receive_data)
    t2 = Thread(target=send_data)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

服务端

from socket import *
from threading import Thread


def receive_data():
    while True:
        receive_data = s.recvfrom(1024)  # 表示本次接受的最大字节数为1024
        receive_content = receive_data[0].decode("gbk")
        print(f"收到远程消息:{receive_content}, from {receive_data[1]}")
        if receive_content == "88":
            print("结束聊天")
            break


def send_data():
    address = ("127.0.0.1", 9999)
    while True:
        data = input("请输入: ")
        s.sendto(data.encode("gbk"), address)
        if data == "88":
            print("结束聊天")
            break


if __name__ == '__main__':
    s = socket(AF_INET, SOCK_DGRAM)  # 创建UDP类型的套接字
    # 示服务器将在本地的8888端口上监听
    s.bind(('127.0.0.1', 8888))  # 绑定端口，ip可以不写

    t1 = Thread(target=receive_data)
    t2 = Thread(target=send_data)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

TCP服务端简化案例

from socket import *

# 建立TCP类型的套接字
server_socket = socket(AF_INET, SOCK_STREAM)

# 本机监听8899端口
# bind方法将套接字绑定到特定的地址和端口上，以便开始监听
server_socket.bind(("127.0.0.1", 8899))

# 开始监听传入连接，最多可以有5个客户连接同时等待接入
server_socket.listen(5)
print("等待接受连接!")

# accept方法用于接受一个新连接，它将阻塞直到一个连接到达
# 返回值是一个元组，包含两个元素：客户端套接字和客户端地址信息
client_socket, client_info = server_socket.accept()

# 使用recv方法从客户端套接字接收数据，缓冲区大小为1024字节
# recv方法将阻塞直到有数据到达
receive_data = client_socket.recv(1024)

# 将接收到的字节数据解码为GBK格式的字符串，并打印出来
# 同时打印出客户端的地址信息
print(f"收到信息: {receive_data.decode('gbk')}, 来自: {client_info}")

# 关闭与客户端的连接套接字
client_socket.close()

# 关闭监听套接字，释放资源
server_socket.close()

这段代码逻辑：

  1. 导入socket库。
  2. 创建一个TCP类型的套接字。
  3. 将套接字绑定到本机的8899端口上。
  4. 调用listen方法开始监听传入连接，最多可以有5个连接同时等待接入。
  5. 打印一条消息，通知服务器正在等待接受连接。
  6. 使用accept方法接受一个新连接。accept方法将阻塞直到一个连接到达，返回一个包含客户端套接字和客户端地址信息的元组。
  7. 使用recv方法从客户端套接字接收数据，缓冲区大小为1024字节。
  8. 将接收到的字节数据解码为GBK格式的字符串，并打印出来。同时打印出客户端的地址信息。
  9. 关闭与客户端的连接套接字。
  10. 关闭监听套接字。

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"))
client_socket.close()

TCP服务端持续交互

from socket import *

server_socket = socket(AF_INET, SOCK_STREAM)  # 建立TCP套接字
server_socket.bind(("127.0.0.1", 8899))  # 本机监听8899端口
server_socket.listen(5)
print("等待接受连接!")

client_socket, client_info = server_socket.accept()
print("一个客户端建立连接成功！")
while True:
    receive_data = client_socket.recv(1024)
    receive_content = receive_data.decode("gbk")
    print(f"客户端说: {receive_content}, 来自: {client_info}")
    if receive_content == "end":
        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 == "end":
        break

    # 接受服务器端数据
    receive_data = client_socket.recv(1024)
    print(f"服务器端说: {receive_data.decode('gbk')}")

client_socket.close()

TCP服务端增加多线程

from socket import *
from threading import Thread


def receive_data():
    while True:
        receive_data = client_socket.recv(1024)
        receive_content = receive_data.decode("gbk")
        print(f"客户端说: {receive_content}, 来自: {client_info}")
        if receive_content == "end":
            print("结束连接!")
            break


def send_data():
    while True:
        msg = input(">")
        client_socket.send(msg.encode("gbk"))
        if msg == "end":
            print("结束连接!")
            break


if __name__ == '__main__':
    server_socket = socket(AF_INET, SOCK_STREAM)  # 建立TCP套接字
    server_socket.bind(("127.0.0.1", 8899))  # 本机监听8899端口
    server_socket.listen(5)
    print("等待接受连接!")

    client_socket, client_info = server_socket.accept()
    print("一个客户端建立连接成功！")

    t1 = Thread(target=receive_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 receive_data():
    while True:
        # 接受服务器端数据
        receive_data = client_socket.recv(1024)
        receive_content = receive_data.decode('gbk')
        print(f"服务器端说: {receive_content}")
        if receive_content == "end":
            print("结束连接")
            break


def send_data():
    while True:
        # 给服务器发消息
        msg = input(">")
        client_socket.send(msg.encode("gbk"))
        if msg == "end":
            break


if __name__ == '__main__':
    client_socket = socket(AF_INET, SOCK_STREAM)
    client_socket.connect(("127.0.0.1", 8899))

    t1 = Thread(target=receive_data)
    t2 = Thread(target=send_data)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

    client_socket.close()

碰到的问题

OSError: [WinError 10048] 通常每个套接字地址(协议/网络地址/端口)只允许使用一次。

  • 解决方法：通常是客户端和服务端的接口设置的不对，参考上面的代码UDP和多线程实现双向自由通信
牧天️白衣
关注
  • 7
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
学习笔记(10):Python网络编程&并发编程-粘包现象
12-22
 粘包现象：服务器接收到客户端的命令后，进行执行得到结果后，再发送回给客户端，在这个过程中如果服务器返回的结果的字节数会大于客户端所接收最大字节数（此处以1024为客户端接收的最大字节数），则大于1024字节...
python：并发编程（一）
weixin_43431593的博客
06-13 2043
本文将和大家一起探讨并发编程，而不限于python语言。后续文章，我们将一起学习并发编程的相关模块。为什么专门写并发编程的文章呢？一个重要原因是有趣，而且实用。写一些简单的脚本可能很少用到并发编程，但是要提高这些脚本的工作效率，并发编程是个不错的选择。
python并发编程服务_Python并发编程之协程
weixin_32236415的博客
02-04 2549
引入咱们知道一个线程同一时间内只能被操做系统分配一个CPU资源, 咱们能够基于多进程实现并发, 也能够基于多线程实现并发, CPU正在运行一个任务, 有两种状况下会被切去执行其它任务, 一种是该任务发生了阻塞, 另外一是该任务运行时间过长或者被其余优先级更高的任务夺走CPU, 对于单线程来讲, 若是一个单线程下运行了多个任务, 那么就不可避免的出现I/O操做, 一旦一个任务出现阻塞的状况, 那么整...
python的并发编程详解
sunkanghui的博客
01-05 1327
进程 multiprocessing 概念：程序运行的 实例，是系统资源分配和调度的的最小单位 任务实例拆分成更小的模块，在给线程使用，线程共享进程空间，线程再分就是协程。 多进程适合于cpu密集型 **cpu密集型：**计算密集型，特点是cpu占用率高 i/o密集型: 磁盘读写多，CPU占用率不高 注：多进程池和多进程都要放在main中声明 扩展链接： 线程 threading 概念：程序最小的执行单位，优势切换快速。 **原理：**线程运行在cpu上是，遇到i/o阻塞就切换，利用CPU和IO可以同时执
Python中的网络编程Socket与HTTP协议的实践
一键难忘的博客
03-27 3143
在当今互联网时代，网络编程是程序员不可或缺的一项技能。Python作为一种高级编程语言，提供了丰富的网络编程库，使得开发者能够轻松地实现各种网络应用。本文将介绍Python中两种主要的网络编程方式：Socket编程和基于HTTP协议的网络编程，并通过实际案例来演示它们的应用。
网络编程——python
m0_58086930的博客
07-05 4430
网络编程 python 进程 线程 开发
Python 并发编程
二哈
05-09 7102
一. 为什么需要引入并发编程呢？ 场景1：一个网络爬虫，按顺序爬取花了一小时，采用并发下载减少到20 min，场景2：一个app 应用，优化前每次打开页面需要3s，采用异步并发提升到每次200ms；引入并发，就是为了提升程序运行的速度，有哪些程序提升速度的方法呢？ ① 单线程串行：由CPU 和 IO 轮流执行；② 多线程并发（threading）③ 多CPU 并行（multiprocessing）④ 多机器并行； python 对于并发编程的支持： 多线程：threading，利用CPU 和 IO
Python中的并发编程
爱意随风起，风止意难平
12-16 2332
线程、进程、协程以及异步编程模型。从创建到使用，讨论异步过程出现例如死锁、数据同步等问题的解决策略。
Python并发编程之Queue队列
热门推荐
hubing_hust的专栏
11-21 1万+
创建一个优先级队列，其中项目按照优先级从低到高依次排列。使用这种队列时，项目应该是(priority, data)形式的元组，其中priority是一个数字。使用队列一般可以简化多线程的程序。例如，可以使用共享队列将线程连接在一起，而不必依赖于必须有锁定保护的共享状态。maxsize是队列中可以放入的项目的最大值。如果省略maxsize或将它置为0，队列大小将是无限大。queue模块实现了各种多生产者-多消费者队列，可用于在执行的多个线程之间安全地交换信息。创建一个LIFO后进先出队列，也叫做栈。
Python网络编程入门
cnds123的专栏
12-05 2796
当今的世界是一个互联的世界，绝大多数的计算机和人都在通过网络和他人传递信息、沟通互联。本讲主要介绍Python 网络编程入门知识。
Python网络编程（小白一看就懂）
南枝向暖北枝寒
06-20 1万+
Python网络编程（小白一看就懂） 一、网络编程基础概念 1. mac地址与ip地址 举个例子，在大学校园，找到名叫Lucy的男神可以用学号，脱离了校园，你要找到Lucy男神，你就要通过身份证号，这里学号是临时的编号，变化的，出了校园就不可用了；身份证号是唯一标识，不变的，在哪里都能找到。 在计算机中，也有类似的概念，不变的是mac地址，能够唯一标识你这台机器；变化的是ip地址，能够更方便的找到你的机器。（可以类比生活中运送快递） 1.1 ip地址 ipv4协议：规定ip地址是由四位点分十进制数组成，每一
Python网络编程(Linux)_网络编程_python_linux网络编程_
10-03
Python网络编程在Linux环境下是一个强大的工具，用于构建服务器端应用程序和服务。这个主题涵盖了多个关键知识点，包括基础概念、Python的网络库...同时，对于深入理解网络协议、操作系统原理和并发编程也有很大帮助。
python聊天室.zip_网络编程_Python__网络编程_Python_
08-09
在Python编程中，网络通信是一个重要的组成部分，主要涉及到网络协议、套接字（socket）编程以及网络服务的实现。Python的`socket`模块提供了低级网络I/O接口，允许我们创建自定义的网络协议，实现客户端与服务器...
网络编程_网络编程_jungleuyf_python网络编程_
10-02
在网络编程中，为了处理多个并发连接，通常会用到多线程或多进程，Python的threading和multiprocessing模块提供了相应支持。此外，Python 3.4引入了asyncio库，基于协程实现异步I/O，可以提高高并发场景下的效率。 ...
任意多边形.rar_网络编程_Python__网络编程_Python_
08-09
标题"任意多边形.rar_网络编程_Python__网络编程_Python_"表明我们将讨论如何利用Python进行网络编程，特别是与"任意多边形"相关的任务。描述提到"python 调用 CAD 随机骨料模型"，暗示我们将探讨如何将Python与...
yolov8 出现loss 为nan
最新发布
zhaoluruoyan89的博客
08-21 118
这篇博客警示读者在购买用于深度学习的显卡时要避开那些导致RuntimeWarning: All-NaN slice encountered的问题。作者强调这些Tensor核心存在严重缺陷，不适宜进行深度学习任务，建议大家在选购时务必谨慎。方法二：将混合精度训练AMP 设置为False。方法一：降低cuda和pytorch 版本号。
基于Python星载气溶胶数据处理与反演分析
lwjnlqiqi的博客
08-21 636
Python星载气溶胶数据处理与反演分析
Transformer经典模型实战：零基础训练一个面向中文的T5模型（Text to Text Transfer Transformer）
bayesian1的博客
08-20 898
Transformer经典模型实战：零基础训练一个面向中文的T5模型（Text to Text Transfer Transformer），通过构建T5模型，采用中文重写任务的数据集进行训练，模型效果非常好，貌似还涌现出了一定的创造力。
python之matplotlib （5 散点图和柱状图）
这是C.L 的博客，欢迎大家学习浏览！！
08-20 422
附：colormap对照 '%.f'%y‘是标注数据的形式设置：保留两位小数，数据来源于y数组。也可以这样写：f'{y:.2f}',在它前面的参数是标注的位置。也可以是一个数组，表示每个点的颜色不同。ax.bar()中y参数是直方图的高度，其中facecolor是条形图的颜色，而edgecolor是除了条形图内的颜色。也可以是一个数组，表示每个点的大小不同。参数来指定一个colormap，用于映射颜色数组到颜色。
Python网络编程入门与进阶
"Python网络编程书籍，英文版，由Sebastian V. Tiponut撰写，技术大学蒂米索阿拉发布，介绍了Python网络编程的基础到高级主题，包括socket使用、服务器设计、多线程与多进程处理、HTTP协议及CGI模块等。" Python...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值