Python Socket编程

已于 2023-12-14 16:47:04 修改
阅读量1k 收藏 23
点赞数 25
分类专栏： Python 文章标签： python socket编程 Python socket编程 urllib socket I/O多路复用 select多路复用
于 2023-12-14 12:22:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JENREY/article/details/134992470
版权

Python Socket编程

文章目录

1. 弄懂HTTP、Socket、TCP这几个概念

  • 整个计算机网络都是有协议组成的
  • 每一个应用程序只能占用1个端口

五层网络模型

  • OSI的标准网络模型是有7层的。应用层和传输层下面还有个表示层、还有个会话层。
  • 应用层中最常用的库就是requests这个第三方的包，走的就是HTTP协议；浏览器也是实现了HTTP协议。
  • HTTP协议是构建与TCP/IP协议之上的。
  • 例如我们要写一个聊天工具，这就不属于这里的应用层任何协议，那么我们如何与TCP/UDP这些底层协议打交道呢？如果我们要手动实现协议与TCP/UDP打交道是非常繁琐的，所以我们不会去实现协议与TCP/UDP打交道，这些与TCP/UDP协议打交道的活都是操作系统帮我们提供的。
  • 操作系统会提供给我们Socket，Socket我们可以理解为是一个API，Socket不属于任何协议，我们通过Socket就可以直接和TCP/UDP传输层打交道，因为聊天工具属于新的应用，而这里的应用层协议都无法满足我们的需求，所以我们就只需要使用操作系统提供的Socket编程即可，Windows、Linux、macOS等操作系统都给我们提供了Socket接口。
  • 所以我们只需要通过Socket就可以和底层的这些传输层、网络层、数据链路层、物理层进行打交道。
  • Socket在整个网络模型中，可以让我们直接脱离应用层而自动帮我们与底层协议打交道，这样我们就可以完成很多的功能哦。
  • Socket本身不属于计算机网络模型。Socket是用来连接我们的应用和TCP层，Socket使得我们自己的应用可以直接和TCP打交道，这样我们就可以实现自己的应用层协议。而这个我们自己定义的应用层协议就是使用Socket与TCP打交道，我们自己定义的应用层协议是和HTTP协议是同一层级的应用层协议。

在这里插入图片描述

2. client和server实现通信

Socket编程模式指南

  • 左侧就是server端：
    • 特点就是随时处于监听的状态，也就是服务的状态，因为不知道客户端什么时候会发送连接过来，所以server必须时刻处于等待状态。
    • accept()：阻塞等待连接请求
    • recv()：获取数据
    • send()：服务端可以发送数据给客户端，这里就与HTTP有很大的区别了，即只要连接不断开，就可以一直向客户端发送数据。而HTTP请求一般就是发送请求等待响应返回数据后就停止了。
    • close()：断开连接
  • 右侧就是client端

在这里插入图片描述

代码实现

# socket_server.py
import socket

# 新建server
# 参数1:是指明使用的类型,AF_INET就是指明使用IPv4,常用还有AF_INET6就是IPv6,AF_IPX是做linux系统上的进程间通信的
# 参数2:指明这个类型对应的协议,SOCK_STREAM就是TCP,SOCK_DGRAM就是UDP
# socket.AF_INET: 基于网络的socket通信,使用IPv4
# socket.SOCK_STREAM: 基于TCP的流式socket通信
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 绑定IP地址和端口，必须传入一个tuple
# 如果你写127.0.0.1那么你通过局域网就访问不到了
server.bind(("0.0.0.0", 8000))

# 监听
server.listen()

# 等待连接
# 返回表示连接的新套接字以及客户端的地址,sock是一个新的套接字对象,addr是客户端的地址
sock, addr = server.accept()

# 接收数据,即获取从客户端发送的数据,指定最大的接收长度为1024字节(即一次获取1KB的数据),recv方法是一个阻塞方法,如果没有数据接收就会阻塞程序执行
data = sock.recv(1024)  # data是一个bytes对象
print(data.decode("utf8"))  # 把bytes对象转换成字符串

# 发送数据给客户端
sock.send("Hello client".encode("utf8"))

# 关闭连接
# server.close()是关闭服务器套接字，停止接受新的客户端连接，sock.close()是关闭一个已经建立的客户端连接。
# server.close() # 关闭连接,真正的server一般是不会close的
# sock.close() # 关闭套接字,表示和客户端的连接也中断了

# socket_client.py
import socket

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 建立连接
# 参数是一个tuple,包含地址和端口号,这里是本机的地址,所以是127.0.0.1,端口号是8000
client.connect(("127.0.0.1", 8000))

# 发送数据,要求发送的数据必须是bytes格式
client.send("Hello Server".encode("utf8"))

# 接收数据
data = client.recv(1024)
print(data.decode("utf8"))

# 关闭连接,一般是先关闭发送数据的一方,然后再关闭接收数据的一方,这是一个好习惯
client.close()

先启动server端，再启动client端，发现server端打印了“Hello Server”，而后client端打印了“Hello client”，最后两者程序都退出了。

3. socket实现聊天和多用户连接

# socket_server.py
import socket

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("0.0.0.0", 8000))
server.listen()
sock, addr = server.accept()

while True:
    data = sock.recv(1024)
    print(data.decode("utf8"))
    re_data = input() # 使用终端进行发送数据的输入
    sock.send(re_data.encode("utf8"))

# socket_client.py
import socket

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(("127.0.0.1", 8000))
while True:
    re_data = input()
    client.send(re_data.encode("utf8"))
    data = client.recv(1024)
    print(data.decode("utf8"))

这样的代码有个问题：

  • server只能连接一个client，因为当客户端连接后就在while循环中出不来了。可以使用线程，每一个socket都做一个线程，在线程里面去循环，那么我们主线程就可以不停的接收其他client的连接请求
# socket_server.py
import socket
import threading

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("0.0.0.0", 8000))
server.listen()


def handle_sock(sock, addr):
    while True:
        data = sock.recv(1024)
        print(data.decode("utf8"))
        re_data = input()
        sock.send(re_data.encode("utf8"))


while True:
    sock, addr = server.accept()
    # 用线程去处理新接收的连接（用户）
    client_thread = threading.Thread(target=handle_sock, args=(sock, addr))
    client_thread.start()

4. socket模拟http请求

  • requests包是基于urllib完成的，而urllib是基于socket完成的。所以说最底层就是socket的。
  • 凡事在网络相关的连接中，比如数据库连接、进程之间的通信等，这些网络请求最底层都是用socket完成的
  • 再次强调socket是操作系统所提供的接口，只是说不同的开发语言会根据不同的操作系统所提供的socket，再次封装成接口而已。
  • 下面我们将实现通过socket 去完成urllib当中的去获取请求的实现。
import socket

# 用来解析URL, 会将URL解析为下面6个部分
# <scheme>://<netloc>/<path>;<params>?<query>#<fragment>
from urllib.parse import urlparse


def get_url(url):
    """通过socket请求html"""
    url = urlparse(url)  # 解析url
    host = url.netloc  # 获取域名
    path = url.path  # 获取域名后的子路径
    if path == "":
        path = "/"  # 如果直接请求的域名则把子路径改成/

    # 建立socket连接
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client.connect((host, 80))  # HTTP是80端口

    # 发送数据,注意这里的数据的格式是要按照HTTP协议的规范来写
    client.send(f"GET {path} HTTP/1.1\r\nHost:{host}\r\nConnection:close\r\n\r\n".encode("utf8"))

    # 接收数据
    data = b""
    while True:
        d = client.recv(1024)
        if d:
            data += d
        else:
            break
    data = data.decode("utf8")
    html_data = data.split("\r\n\r\n")[1]  # 丢弃响应头，只取HTML
    print(html_data)
    client.close()


if __name__ == "__main__":
    get_url("http://www.baidu.com")
  • 注意，这里每次发送请求都会先去建立socket连接，然后close。下次如果我们再发生请求的时候还要这样，这就比较耗时。这里只是体验socket编程的代码示例。而正常我们是应该保持长连接的。
  • socket编程是理解异步IO、协程的基础。是必须要掌握的。
  • socket编程过于底层，所以需要手动完成的功能比较多。

5. socket使用I/O多路复用模式模拟http请求

  • 这里的代码了解即可。采用了 “select或者epoll + 回调 + 事件循环” 的编程模式
  • 这样写的好处就是并发行高，而且这里没有线程的切换，都在一个线程里面执行。而且省内存，因为1个线程消耗的内存是远远高于回调函数的模式的。
  • 回调函数其实就是一个指向函数的句柄而已。
  • 这里的代码就很好的展示了协程的核心原理（事件循环 + I/O多路复用）。
  • 这种方式其实就是当我们代码进行下一步操作的时候是让 事件循环loop 去驱动我们的回调函数
  • 缺点会让代码割裂的四分五裂。
# socket_select_http.py
"""
通过I/O多路复用模型中的select模式或者epoll模式实现http请求
"""

import socket

# selectors包的作用是根据不同的操作系统自动选择最佳的I/O多路复用模型
# 我们不要使用select包，而是要使用基于select包再次封装的selectors包
# DefaultSelector会自动帮我们根据代码运行的操作系统去选择使用poll或者epoll
# 在Windows下就是select，在Linux下就是epoll
# 而且DefaultSelector还为我们提供了注册机制
from selectors import EVENT_READ, EVENT_WRITE, DefaultSelector
from urllib.parse import urlparse

selector = DefaultSelector()  # 创建一个selector对象(选择器)


class Fetcher:
    def __init__(self):
        self.host = ""  # 域名
        self.path = ""  # 路径
        self.data = b""  # 存储返回的数据
        self.client = None  # socket对象

    def get_url(self, url):
        """
        通过socket请求html
        """
        url = urlparse(url)  # 解析url
        self.host = url.netloc  # 获取域名
        self.path = url.path  # 获取域名后的子路径
        self.data = b""  # 存储返回的数据
        if self.path == "":
            self.path = "/"  # 如果直接请求的域名则把子路径改成/

        # 创建socket对象<class 'socket.socket'>, socket.AF_INET表示ipv4, socket.SOCK_STREAM表示TCP
        self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # 将socket设置为阻塞(true)或非阻塞(false), 默认为阻塞
        self.client.setblocking(False)  # 使用非阻塞
        try:
            # 连接
            self.client.connect((self.host, 80))  # 注意这里是非阻塞的,所以不会等待连接成功,而是会立刻返回并继续执行后续代码,所以会抛出BlockingIOError异常
        except BlockingIOError as e:
            pass  # 抛出BlockingIOError异常是合理的，虽然抛出了异常，但是与host的建立连接请求已经发出去了。

        # 将socket注册到selector中，监听socket是否是可写的状态
        # 参数1: socket的文件描述符
        # 参数2: 事件，有EVENT_WRITE和EVENT_READ
        # 参数3: 回调函数，即当socket的状态变为可写的时候，就会调用此回调函数
        selector.register(self.client.fileno(), EVENT_WRITE, self.connected)  # 使用事件监听, 等待连接成功, 然后再执行后面的代码
        # 注意这后面不能再写代码了，如果写了代码就是阻塞式IO了，所以我们才要使用事件监听，采用回调的方式来处理

    def connected(self, key):
        """连接成功的回调函数，当socket的状态变为可写的时候，就会调用此回调函数，进行发送数据(发送HTTP请求)"""
        # 注销掉监控的事件,即取消注册,因为我们已经连接成功了,所以就不需要再监听socket是否是可写的状态了，所以要注销掉，否则会一直监听下去
        selector.unregister(key.fd)  # fd是file descriptor文件描述符
        # 发送数据，这里不用try...except...，是因为我们使用事件监听，当回调此方法的时候连接的状态一定是就绪的状态
        self.client.send(f"GET {self.path} HTTP/1.1\r\nHost:{self.host}\r\nConnection:close\r\n\r\n".encode("utf8"))
        # 注册,即使用事件监听,因为我们要接收服务器返回的响应数据，所以要再次监听socket是否是可读的状态,当socket的状态变为可读的时候，就会调用此回调readable方法接收数据，然后打印出来
        selector.register(self.client.fileno(), EVENT_READ, self.readable)

    def readable(self, key):
        """接收数据(接收HTTP响应)，当socket的状态变为可读的时候，就会调用此回调函数，进行接收数据(接收HTTP响应)，然后打印出来"""
        d = self.client.recv(1024)  # 接收数据
        if d:  # 当数据没有读完的时候，继续读取
            self.data += d
        else:  # 当数据读完的时候，就注销掉监控的事件，即取消注册，因为我们已经接收完了，所以就不需要再监听socket是否是可读的状态了，所以要注销掉，否则会一直监听下去
            selector.unregister(key.fd)
            data = self.data.decode("utf8")
            html_data = data.split("\r\n\r\n")[1]
            print(html_data)
            self.client.close()


def loop():
    """回调+事件循环+select(poll/epoll)
    驱动整个程序运行，可以理解为心脏，这样不会去阻塞建立连接、等待请求等IO操作
    """
    # 事件循环，不停的请求socket的状态并调用对应的回调函数
    # 所以这是个主循环
    # 1.select本身是不支持register模式
    # 2.socket状态变化以后的回调是由程序员完成的
    while True:
        # 注意在Windows下使用的是select模式，而select(r,w,w,timeout)的参数如果为空列表会抛出OSError异常
        # 而在Linux或者macOS下会使用epoll模式，就不会抛出OSError异常，会一直阻塞在这里
        # 不停的向操作系统请求有哪些socket已经准备好了
        ready = selector.select()  # 返回的是SelectorKey数据类型，是namedtuple类型
        for key, mask in ready:
            # key是一个SelectorKey类型的对象，包含了文件描述符fd、事件event、回调函数data等属性
            # mask是一个事件的遮罩，表示事件是可读的还是可写的,EVENT_READ或EVENT_WRITE,取决于我们注册的时候监听的是可读还是可写,即key.events
            call_back = key.data  # 获取回调函数,<bound method Fetcher.connected of <__main__.Fetcher object at 0x1025d55b0>>
            call_back(key)  # 执行回调函数,即调用connected方法


if __name__ == "__main__":
    fetcher = Fetcher()
    fetcher.get_url("http://www.baidu.com")
    loop()

下面是解决Windows下使用的是select模式抛出OSError异常的问题

import socket

from selectors import EVENT_READ, EVENT_WRITE, DefaultSelector
from urllib.parse import urlparse

selector = DefaultSelector()

urls = ["http://www.baidu.com"]
stop = False


class Fetcher:
    def get_url(self, url):
        self.spider_url = url
        url = urlparse(url)
        self.host = url.netloc
        self.path = url.path
        self.data = b""
        if self.path == "":
            self.path = "/"

        self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.client.setblocking(False)
        try:
            self.client.connect((self.host, 80))
        except BlockingIOError as e:
            pass

        selector.register(self.client.fileno(), EVENT_WRITE, self.connected)

    def connected(self, key):
        selector.unregister(key.fd)
        self.client.send(f"GET {self.path} HTTP/1.1\r\nHost:{self.host}\r\nConnection:close\r\n\r\n".encode("utf8"))
        selector.register(self.client.fileno(), EVENT_READ, self.readable)

    def readable(self, key):
        d = self.client.recv(1024)
        if d:
            self.data += d
        else:
            selector.unregister(key.fd)
            data = self.data.decode("utf8")
            html_data = data.split("\r\n\r\n")[1]
            print(html_data)
            self.client.close()
            urls.remove(self.spider_url)
            if not urls:
                global stop
                stop = True


def loop():
    while not stop:
        ready = selector.select()
        for key, mask in ready:
            call_back = key.data
            call_back(key)


if __name__ == "__main__":
    fetcher = Fetcher()
    fetcher.get_url("http://www.baidu.com")
    loop()
Jenrey
关注
  • 25
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python socket编程实例详解
09-22
主要介绍了Python socket编程,以实例形式较为详细的分析了Python中socket模块的使用技巧,非常具有实用价值,需要的朋友可以参考下
python的网络编程(socket)
myp2004的博客
07-12 565
模块提供了对套接字编程的支持，包括创建、连接、发送和接收数据等操作。使用套接字，可以实现底层的网络通信，并与其他计算机上的应用程序进行数据交互。套接字（Socket）：套接字是进行网络通信的基础，它提供了一种抽象机制，通过网络传输数据。
Python socket详解，全网最全教程
最新发布
m0_72282564的博客
08-08 5706
嗨喽，大家好呀~这里是爱看美女的茜茜呐。
Python渗透测试编程基础——Socket网络编程
PICACHU+++的博客
03-24 2052
Socket通信是基于客户端/服务器结构（C/S），可隐藏复杂的TCP/IP协议族，只要遵循Socket的规定就可以进行网络程序开发，简单且开发效率高。Python中的socket模块，提供了套接字编程的大部分功能。支持使用UDP和TCP协议进行网络通信。UDP属于无连接协议，在向接收方发送信息时不需要建立连接，而是直接发送即可。Socket又称"套接字"，是计算机间进行网络通信的一套程序接口。UDP的应用：域名系统；socket模块方法如图所示。一、socket编程简介。UDP编程流程及常用的。
python网络编程一--socket开发
谁家的喵
08-07 2000
socket是非常底层的接口库，它是一种通用的网络编程接口(意思就是java/c++/python都一样)，和网络层次没有一一对应关系，而是看你在哪一层进行编程。 cs编程：client-server，bs(browser-server)就是一种cs。只做c开发，就是前端开发，只做s后端开发............
python——socket编程
m0_53891399的博客
07-02 3501
使用python中的socket模块进行socket网络编程，先熟悉一些socket模块中的函数。例如：socket(),bind(),listen(),accpet(),clase(),recv(),sendall()
Python网络编程：Socket的简介和使用
在夜里，所有人都会失去年龄。
06-09 1022
通过使用Socket编程，我们可以构建各种网络应用程序，如客户端-服务器模型、聊天应用、文件传输等。
Python Socket编程详细介绍
09-21
主要介绍了Python Socket编程详细介绍，socket可以建立连接，传递数据，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。
python socket 网络编程
01-19
本代码主要是关于python socket 的网络编程，可以实现文件上传 文件下载 以及远程命令行的执行
【Python】Socket的简单应用
热门推荐
RexHa的博客
11-03 1万+
python socket实现客户端与服务器的通信
Python Socket
03-30
使用Python语言编写Socket通信 包括TCP和UDP协议2种 简单扼要的进行了说明和举例 代码整理 如有雷同纯属巧合
python socket client
02-06
pytnon写的tcp client，包括json和信号间通信，给有需要的参考一下
Python学习笔记——socket通信相关资源文件
07-18
Python学习笔记——socket通信相关资源文件 内部包括server1 2 3 + windows版 nc
python-websocket-socket 消息推送
12-24
消息推送：1.浏览器前台 到 socket 2.生产消息端 到 socket 再从socket 推送到前台 3.代码整理之后，可以和webpy框架合用 4.实现前台无刷新，后台多线程监听消息发送
Python socket网络编程
Simple子夜
01-21 9518
前言： 平常我们会接触到两种框架，分别是：b/s架构与c/s架构。Socket属于CS架构，它也称为：套接字，应用程序通常使用套接字通过网络，实现与另一台计算机进行通讯。。
Python Socket网络编程
m0_62063669的博客
08-05 4815
编程的时候，如果要跟某个IP建立连接，我们需要调用操作系统提供的socket API。socket在操作系统层面，可以理解为一个文件。我们可以对这个文件进行一些方法操作。用listen方法，可以让程序作为服务器监听其他客户端的连接。用connect，可以作为客户端连接服务器。用send或write可以发送数据，recv或read可以接收数据。在建立好连接之后，如果我们想给远端服务发点什么东西，那就只需要对这个文件执行写操作就行了。剩下的发送工作自然就是由操作系统内核来完成了。......
【计算机网络】python——socket编程（TCP/UDP）
Coco416的博客
11-10 2379
Socket（套接字）是一种抽象层，应用程序通过它来发送和接收数据，就像应用程序打开一个文件句柄，将数据读写到稳定的存储器上一样。一个socket允许应用程序添加到网络中，并与处于同一个网络中的其他应用程序进行通信。一台计算机上的应用程序向socket写入的信息能够被另一台计算机上的另一个应用程序读取，反之亦然。
python之socket模块
qq_38039965的博客
09-28 6074
自己学习
Python的Socket编程
Ryan
12-08 2028
python socket编程 介绍socket的来源、socket的编程和函数简介
python socket编程
05-11
Python socket 编程是在 Python 语言中使用 socket 模块来开发网络程序的方法。通过 socket 模块可以实现服务器和客户端之间的通信。常用的 socket 函数有 socket、bind、listen、accept、connect、send、recv 等。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值