Python学习笔记-socket编程

已于 2024-08-22 09:44:42 修改
阅读量740 收藏 18
点赞数 23
分类专栏： Python 文章标签： 学习 笔记 python
于 2024-08-21 11:04:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44067856/article/details/141264151
版权

目录

一、OSI七层参考模型和TCP/IP四层参考模型

二、网络通信三要素

三、socket通信

socket通信流程

一次数据传输

多次传输数据

多个客户端单独交互

多个客户端一起交互 

1. 多线程

2. socketserver

文件的上传与下载

一、OSI七层参考模型和TCP/IP四层参考模型

TCP/IP(Transmission Control Protocol/Internet Protocol-传输控制协议/网间协议)

定义了主机如何接入因特网及如何在它们之间传输的标准，从字面来看，是TCP和IP的合称，但实际上是指因特网整个TCP/IP协议簇

二、网络通信三要素

1. IP地址：标识网络上一台独立的主机

2. 端口号：标识进程（应用程序）的逻辑地址，不同的进程有不同的端口号

3. 传输协议：通信的规则，如TCP，UDP协议

以上三点可以唯一标识网络中的一个进程，标识后，就可以利用socket进行通信了。

简单介绍一下TCP和UDP

1. TCP：Transmission Control Protocol 传输控制协议

1）面向连接，传输数据之前需要建立连接，即要确保目的端能够应答后才能进行数据传输

2）可传输大量数据

3）通过三次握手完成连接，是安全可靠的传输协议

4）传输速度慢，效率低

2. UDP：User Datagram Protocol 用户数据报协议

1）面向无连接，传输数据之前源端和目的端不需要建立连接，即不管目的端是什么情况，直接进行数据传输

2）每个数据报的大小都限制在64K以内

3）面向报文的不可靠的传输协议，即发送出去的数据不一定会被接收到

4）传输速度快，效率高

三、socket通信

socket(套接字)，是在应用层和传输层之间的一个抽象层，是一组接口，把复杂的操作抽象为几个简单的接口供应用层调用以实现进程在网络中通信，应用程序两端通过socket向网络发出请求或应答网络请求，就相当于通信的把手

socket通信流程

以TCP为例

服务端流程：

1. 服务端创建socket：socket.socket(地址类型，socket类型，协议）

地址类型：有socket.AF_INET(IPv4，默认), socket.AF_INET6(IPv6)等

socket类型：有socket.SOCK_STREAM(TCP，默认), socket.SOCK_DGRAM(UDP)等

协议：默认为0，表示适用于所有socket类型

所以如果是IPv4，TCP，可以不加任何参数

2. 服务器为socket绑定IP地址和端口号: bind((ip地址, 端口号))，注意参数是以元组的形式传递的

3. 服务器socket监听端口号请求，随时准备接收客户端发来的连接，这时候服务器的socket并没有被打开: listen(最大连接数)-参数可以省略，代表没有限制

4. 服务器socket进入阻塞状态，所谓阻塞即accept()方法一直等到客户端返回连接信息后才返回一个新的socket，最初建立的socket开始接收下一个客户端连接请求

5. 服务器accept方法返回，连接成功，可以开始与客户端通信

6. 服务端读取信息: recv()

7. 服务器向socket写入信息: send()/sendall()

8. 服务器关闭（在现实中，服务器一般不会关闭）: close()

客户端流程：

1. 客户端创建socket: socket.socket()

2. 客户端打开socket，根据服务器IP地址和端口号试图连接服务器socket: connect((ip地址, 端口号))，与服务端的一致

3. 客户端连接成功，向服务器发送连接状态信息:

4. 客户端向socket写入信息: send()/sendall()

5. 客户端读取信息: recv()

6. 客户端关闭: close()

以银行和客户为例，服务端相当于银行(socket.socket())，客户端相当于来银行办理业务的客户(socket.socket())，ip和端口号相当于银行地址(bind())，大堂经理一直等待客户到来(listen())，客户来办理业务(connect())，柜台等到了客户(accept())，办理业务(send(),recv())，业务结束，客户离开(close())，柜台完成业务(close())，银行关门(close())

一次数据传输

服务端代码：

import socket    #加载socket模块
#创建socket对象
sk = socket.socket()
#绑定IP地址和端口号
sk.bind(("127.0.0.1", 13000))  #用元组进行传参 127.0.0.1 环回地址，指访问本地服务；端口号自行设置，只要是空闲的端口号就可以
#监听有没有请求
sk.listen()
print('服务端已经启动。。。')

#等待传入客户端连接，在连接成功之前，保持阻塞状态
#连接成功之后，会返回一个新的套接字和客户端的IP地址与端口号
conn, addr = sk.accept()    #conn 套接字  addr IP地址与端口号
print('客户端的IP地址和端口号是：', addr)

#接收客户端发来的数据
server_recv = conn.recv(1024)
print('客户端说：', server_recv.decode('utf8'))   #将byte转成字符串

server_input = input('服务端输入：')   #字符串不能在网络上传输
#服务端发送数据
conn.sendall(server_input.encode('utf8'))   #将字符串转成byte

#关闭socket连接
conn.close()
sk.close()

客户端代码：

import socket
#创建socket对象
sk = socket.socket()

#发起连接
sk.connect(('127.0.0.1', 13000))    #服务端的地址和端口号是定义好的，实际中集中在配置文件里

#客户端发送请求给服务端
client_input = input('客户端输入：')
sk.sendall(client_input.encode('utf8'))

#客户端接收服务端发送的数据
client_recv = sk.recv(1024)  #一次接收1024个字节
print('服务端说：', client_recv.decode('utf8'))

#关闭socket连接
sk.close()

分别运行服务端和客户端代码，结果如下：

1. 运行服务端代码
2. 服务端显示：服务端已经启动。。。
3. 运行客户端代码
4. 服务端显示：客户端的IP地址和端口号是： ('127.0.0.1', 53702)
4. 客户端显示：客户端输入：你好，我想取钱
5. 服务端显示：客户端说：你好，我想取钱
6. 服务端显示：服务端输入：不好意思，你的余额不足
7. 客户端显示：服务端说：不好意思，你的余额不足

多次传输数据

上例服务端和客户端只进行了一轮对话，如果要多次对话需要加一个循环

服务端代码：

import socket    #加载socket模块
#创建socket对象
sk = socket.socket()
#绑定IP地址和端口号
sk.bind(("127.0.0.1", 13000))  #用元组进行传参 127.0.0.1 环回地址，指访问本地服务；端口号自行设置，只要是空闲的端口号就可以
#监听有没有请求
sk.listen()
print('服务端已经启动。。。')

#等待传入客户端连接，在连接成功之前，保持阻塞状态
#连接成功之后，会返回一个新的套接字和客户端的IP地址与端口号
conn, addr = sk.accept()    #conn 套接字  addr IP地址与端口号

##循环发送和接收数据
while True:
    #接收数据
    server_recv = conn.recv(1024).decode('utf8')
    if server_recv == 'exit':  #当输入exit时，退出循环，即终止与客户端的交互
        break
    print('客户端说：', server_recv)   #将byte转成字符串

    server_input = input('服务端输入：')   #字符串不能在网络上传输
    #服务端发送数据
    conn.sendall(server_input.encode('utf8'))   #将字符串转成byte

#关闭socket连接
conn.close()
sk.close()

客户端代码：

import socket
#创建socket对象
sk = socket.socket()

#发起连接
sk.connect(('127.0.0.1', 13000))    #服务端的地址和端口号是定义好的，实际中集中在配置文件里

#循环发送和接收数据
while True:
    #客户端发送请求给服务端
    client_input = input('客户端输入：')
    sk.sendall(client_input.encode('utf8'))
    if client_input == 'exit':    #当输入exit时，退出循环，即终止与服务端的交互
        break

    #客户端接收服务端发送的数据
    client_recv = sk.recv(1024).decode('utf8')  #一次接收1024个字节
    print('服务端说：', client_recv)

#关闭socket连接
sk.close()

 运行结果如下：

多个客户端单独交互

如果服务端想要跟多个客户端交互，还需要在服务端再加一个循环，客户端与之前的代码类似（只是改了提示文字从“客户端”分别改成了“客户1”，“客户2”），但我们copy成两个py文件代表两个客户端

服务端代码：

import socket    #加载socket模块
#创建socket对象
sk = socket.socket()
#绑定IP地址和端口号
sk.bind(("127.0.0.1", 13000))  #用元组进行传参 127.0.0.1 环回地址，指访问本地服务；端口号自行设置，只要是空闲的端口号就可以
#监听有没有请求
sk.listen()
print('服务端已经启动。。。')

#第一层循环，接收多个客户端请求
while True:   #这里没有写跳出循环的条件，会一直等待客户端
    conn, addr = sk.accept()    #conn 套接字  addr IP地址与端口号

    ##循环发送和接收数据
    while True:  #第二层循环，与一个客户端进行多次数据收发
    #接收数据
        server_recv = conn.recv(1024).decode('utf8')
        if server_recv == 'exit':  #当输入exit时，退出循环，即终止与客户端的交互
            break
        print('客户端说：', server_recv)   #将byte转成字符串

        server_input = input('服务端输入：')   #字符串不能在网络上传输
        #服务端发送数据
        conn.sendall(server_input.encode('utf8'))   #将字符串转成byte

    #关闭socket连接
    conn.close()
sk.close()

运行结果如下：

服务端在两个客户退出之后一直等待：

 

客户1：                                                             客户2：

多个客户端一起交互 

 因为上述是单线程，所以只有客户一退出后，客户二的输入才会给到服务端，如果两个客户端同时跟服务端交互，应该如何做？

1. 多线程

可以把服务端第二层循环代码写在函数里，然后用线程去调用，这样一个线程对应一个客户端，就可以多个客户端同时通信，客户端保持不变

import socket    #加载socket模块
import threading  #加载threading模块
def handle_client(client_socket):
    while True:
        # 接收数据
        server_recv = client_socket.recv(1024).decode('utf8')
        if server_recv == 'exit':  # 当输入exit时，退出循环，即终止与客户端的交互
            break
        print('客户端说：', server_recv)  # 将byte转成字符串

        server_input = input('服务端输入：')  # 字符串不能在网络上传输
        # 服务端发送数据
        client_socket.sendall(server_input.encode('utf8'))  # 将字符串转成byte

    # 关闭socket连接
    client_socket.close()

#创建socket对象
sk = socket.socket()
#绑定IP地址和端口号
sk.bind(("127.0.0.1", 13000))  #用元组进行传参 127.0.0.1 环回地址，指访问本地服务；端口号自行设置，只要是空闲的端口号就可以
#监听有没有请求
sk.listen()
print('服务端已经启动。。。')

while True:
    conn, addr = sk.accept()    #conn 套接字  addr IP地址与端口号

    thread = threading.Thread(target=handle_client, args=(conn,))
    thread.start()

sk.close()

 运行结果如下，可以看出在客户1没有exit时，服务端也可以与客户2进行通信：

服务端结果：

 客户1：                                                         客户2：

   

 由于现在没有写前端的代码，所以服务端看起来无法区分客户，要加入前端代码又是比较大的工作量，这里不做说明，只是实现功能

2. socketserver

还有一种更简单的方法，加载一个新的模块socketserver

import socketserver

class MyServer(socketserver.BaseRequestHandler):
    def handle(self): #重写handle方法
        while True: #跟一个客户端进行多次通信
            #接收数据
            server_recv = self.request.recv(1024).decode('utf8')
            if server_recv == 'exit':
                break
            print(server_recv)
            #发送数据
            server_input = input('服务端输入：')
            self.request.sendall(server_input).encode('utf8')
        self.request.close()

server = socketserver.ThreadingTCPServer(('127.0.0.1', 13000), MyServer)  #完成线程和socket通信，MyServer不需要实例化，作为参数传递
server.serve_forever()  #启动服务器

文件的上传与下载

 例：客户端有一个名为image.PNG的图片，需要将它上传到服务端

服务端代码：

import socket
import os
def get_file(sk):
    '''
    接收文件
    :param sk: socket对象
    :return:
    '''
    #接收文件大小   与post_file中file_size位置对应，确保客户端的file_size是被服务端的file_size接收
    file_size = int(sk.recv(1024).decode('utf8'))  #decode将byte转成string，int将string转成int
    sk.sendall(b'OK')    #当接收到文件大小后，给客户端发送一个提示ok，与客户端post_file中的recv对应，避免粘包
    #接收文件名字
    file_name = sk.recv(1024).decode('utf8')
    #file_size和file_name在逻辑上是不一样的，但在传输时，如果客户端发送多次的数据大小<1024，对于服务端来说会认为时一个数据，这就叫粘包
    sk.sendall(b'OK')    #当接收到文件大小后，给客户端发送一个提示ok，与客户端post_file中的recv对应，避免粘包
    #接收文件
    with open('./%s' %file_name, 'wb') as f: #打开文件，并以byte写入
        while file_size > 0:   #当文件大小>0，即接收到的文件还没有写入完成
            f.write(sk.recv(1024))   #写入一次接收到的数据
            file_size -= 1024    #完成写入一次后，需要写入的文件大小就会减少1024

#创建socket对象
sk = socket.socket()
#绑定IP地址和端口号
sk.bind(("127.0.0.1", 13002))

#监听有没有请求
sk.listen()
print('服务端已经启动。。。')

#等待传入客户端连接，在连接成功之前，保持阻塞状态
#连接成功之后，会返回一个新的套接字和客户端的IP地址与端口号
conn, addr = sk.accept()

#接收客户端发来的数据
get_file(conn)

#关闭socket连接
conn.close()
sk.close()

客户端代码：

import socket
import os

def post_file(sk, file_path):
    '''
    发送文件
    :param sk: socket对象
    :param file_path: 文件路径
    :return:
    '''
    #发送文件大小
    file_size = os.stat(file_path).st_size   #获取到文件大小
    sk.sendall(str(file_size).encode('utf8'))   #str将int转成str类型，encode将str转成byte
    sk.recv(1024)  #发送完之后，加一个recv，等待服务端返回，阻塞下面的发送，避免粘包
    #发送文件名字
    file_name = os.path.split(file_path)[1]  #将文件路径中的路径和文件名称分开，split返回一个列表，取第二个元素即文件名称
    sk.sendall(file_name.encode('utf8'))
    sk.recv(1024)  #发送完之后，加一个recv，等待服务端返回，阻塞下面的发送，避免粘包
    #发送文件内容
    with open(file_path, 'rb') as f:   #以二进制格式打开需要发送的文件
        while file_size > 0:    #当文件大小>0,即文件还没有发送完成
            sk.sendall(f.read(1024))   #每次发送1024个字节
            file_size -= 1024   #每次发送完成，待发送的文件大小就要减小1024

#创建socket对象
sk = socket.socket()

#发起连接
sk.connect(('127.0.0.1', 13002))    #服务端的地址和端口号是定义好的，实际中集中在配置文件里

#客户端发送请求给服务端
path = './image.PNG'
post_file(sk, path)

#关闭socket连接
sk.close()

运行结果：

运行之前的结构：                                           运行之后的结构：

   

虞花花
关注
专栏目录
Python之socket编程
m0_59485658的博客
12-05 1386
socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，对于文件用【打开】【读写】【关闭】模式来操作。socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）
python之socket编程
weixin_33690367的博客
03-15 283
From :http://www.cnblogs.com/aylin/p/5572104.html 1、socket socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，对于文件用【打开】【读写】【关闭】模式来操作。socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数...
python之网络编程（socket）
最新发布
往日情怀酿作酒
08-15 1366
今天我们就讲完这么多了，本来想和大家讲一个文件的上传和下载的，但是发现讲不完根本讲不完，大家可以自己练习试试。
Python 中的Socket编程
欢迎光临 我的心
10-27 476
文章目录Python 中的Socket编程一、数据传输方式1.1 同步与异步1.2 阻塞非阻塞1.3 IO模型1.3.1 同步阻塞1.3.2 同步非阻塞1.3.3 IO多路复用1.3.4 异步1.3.5 对比二、Socket API三、实验代码3.1 同步阻塞3.1.1 服务端3.1.2 客户端3.1.3 测试3.2 非阻塞3.2.1 服务端3.2.2 用户端3.2.3 测试3.3 多路复用IO3.3.1 服务端3.3.2 客户端3.3.3 测试3.4 异步3.4.1 服务端与客户端3.4.2 测试3.5
python-socket 编程
西部壮仔的博客
03-20 213
介绍 要进行socket编程，发送网络消息，我们可以使用 Python 内置的 socket 库 。 目前的socket编程，使用的最多的就是通过tcp协议进行网络通讯的。 tcp进行通讯的程序双方，分为服务端和客户端。 tcp 协议进行通讯的双方，是需要先建立一个虚拟连接的。然后双方程序才能发送业务数据信息。 建立tcp虚拟连接是通过著名的 三次握手 进行的。 具体三次握手的细节大家可以参考这篇...
Python学习笔记-基于socket基础的http服务端程序
07-09
在Python编程领域，网络通信是不可或缺的一部分，而`socket`模块是Python提供的一个核心功能，用于实现低级别的网络通信。本篇文章将深入探讨如何利用`socket`基础来构建一个简单的HTTP服务端程序。HTTP（超文本传输...
学习笔记(04):Python网络编程&并发编程-什么是socket
01-06
答：网络编程也叫做socket编程即套接字编程，基于遵循socket套接字的规定进行的编程 2.什么是socket？ 答：socket就是一组简单的接口！socket抽象层位于TCP运输层和应用层之间，socket抽象层将TCP协议以及其他的协议...
自我学习笔记--LUA;python:网络编程等
06-10
【标题】中的“自我学习笔记--LUA;python:网络编程等”表明这是一份包含LUA和Python语言，特别是关于网络编程的学习资料。LUA和Python都是编程语言，广泛应用于游戏开发、脚本编写、自动化任务以及网络服务等领域。 ...
Python学习笔记-基础篇
cy2lyf的博客
09-07 2886
python学习笔记-基础篇
python网络编程学习笔记(五)：socket的一些补充
12-24
总结，本篇学习笔记主要介绍了Python网络编程中的两个关键概念：如何通过`shutdown()`函数实现半开放socket，以及如何利用`settimeout()`函数进行超时控制。此外，还探讨了网络字节顺序的概念及其在`struct`模块中的...
Python中Socket编程
weixin_45794666的博客
01-08 3231
目录 Python中Socket编程 1 一、Socket概述 1 二、python中socket模块使用 1 三、socket之聊天室 3 四、socket之端口探测 7 五、scapy之tcp端口探测 11 Python中Socket编程 一、Socket概述 socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。 socket即是一种特殊的文件，socket函数就是对其进行的操作（读/写IO、打
Python中的Socket编程
这家伙很懒，什么都没有留下
11-10 968
Socket编程是网络编程的基础，它提供了两个主要的功能：数据传输和进程间通信。在Python中，Socket编程同样扮演着重要的角色。通过使用Socket，我们可以实现不同计算机之间的通信，甚至可以实现同一台计算机不同进程之间的通信。本文介绍了Python中的Socket编程，包括Socket的基本概念、Socket编程的步骤、Socket的高级功能以及Socket编程的常见问题及解决方案。通过使用Socket编程，我们可以实现不同计算机之间的通信，甚至可以实现同一台计算机不同进程之间的通信。
python——socket编程
m0_53891399的博客
07-02 4120
使用python中的socket模块进行socket网络编程，先熟悉一些socket模块中的函数。例如：socket(),bind(),listen(),accpet(),clase(),recv(),sendall()
Python学习笔记：从基础到进阶
“这是一份详尽的Python学习资料，涵盖了从基础操作到进阶主题的广泛内容，适合初学者逐步学习。笔记记录了每个操作步骤，包括简单的数学运算、序列类型如列表和元组、字符串操作与格式化、字典的使用、控制流语句、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值