python基础—socket与协程

已于 2022-02-12 17:49:19 修改
阅读量1.4k 收藏
点赞数 1
分类专栏： python基础 python数据分析与数据处理 文章标签： 网络 网络协议
于 2022-02-12 16:53:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55196097/article/details/122886276
版权

目录

1.socket通信：

    1.1 osi模型：       

2. 协程：

2.1 利用yield实现协程：

 2.2 greenlet:可实现单线程内切换多个任务

  2. 3 gevent： 可实现协程也是由C扩展而来的            a.阻塞式协程           

                b. 非阻塞, 上述例子中gevent识别io阻塞。如果想实现非阻塞模型需要导入， #167和#168两行代码       

1.socket通信：

 
   1.1 osi模型：       

实现通信
            
            物理层----数据链路层---网络层----传输层----应用---表示----回话
            
            传输层--socket（网络套接字，可实现两个主要通信架构c/s---UDP/TCP）
            
            mysql---tcp
        

2. 协程：


    提升通信效率的手段，单线程下实现并发。
    优点：
        1）无需线程可以切换上下文，避免无意义的调度，可提升代码性能
        2）无需原子操作可以锁定及同步开销
        3）简化编程
        4) 高并发 高扩展 低成本
    缺点：
        1）无法利用多核资源
        2）阻塞会导致程序崩溃

        进程
        线程
        协程

2.1 利用yield实现协程：

 import time
        
        def func1():
            while True:
                yield
        
        def func2():
            g = func1()
            for i in range(10000):
                i+=1
                next(g)
        
        def main():
            start = time.time()
            func2()
            print(time.time()-start)
        
        if __name__ == '__main__':
            main()

 2.2 greenlet:可实现单线程内切换多个任务


        import greenlet
        
        # 返回greenlet数据类型
        greenlet.greenlet
        
        # 创建greenlet对象，不执行，run是greenlet执行的回调函数
        greenlet(run=None,parent=None)
        
        # 返回当前greenlet，谁调用返回谁
        greenlet.getcurrent()
        
        # 用于清除掉一个greenlet对象而不影响父辈greenlet
        greenlet.GreenletExit  
        
        
     'dead',            greenlet执行结束的标志
     'error',
     'getcurrent',      获取当前执行的greenlet
     'gettrace',        获取链路追踪
     'gr_frame',
     'parent',          每个greenlet都有一个parent
     'run',             当greenlet启动时调用run方法
     'settrace',        设置链路追踪，可查看协程切换过程
     'switch',          协程之间切换
     'throw'            协程抛出异常

  实例1：
     

   import greenlet
        
        def FunA():
            print('FunA')
            g2.switch()
            print('FunB')
            g2.switch()
        
        def FunB():
            print('FunB')
            g1.switch()
            print('FunA')
        
        if __name__ == '__main__':
            g1 = greenlet.greenlet(FunA)
            g2 = greenlet.greenlet(FunB)
            g1.switch()

  2. 3 gevent： 可实现协程也是由C扩展而来的
    
        a.阻塞式协程
           

 import gevent,time
            
            def eat(name):
                print('%s eat 1'%name)
                time.sleep(2)
                print('%s eat 2' % name)
            
            def study(name):
                print('%s study 1'%name)
                time.sleep(3)
                print('%s study 2' % name)
            
            def main():
                g1 = gevent.spawn(eat,'Alex')
                g2 = gevent.spawn(study,'Jill')
                g1.join()
                g2.join()
                print('main')
            
            if __name__ == '__main__':
                main()


        
        b. 非阻塞, 上述例子中gevent识别io阻塞。如果想实现非阻塞模型需要导入， #167和#168两行代码
       

     import gevent,time
            from gevent import monkey
            monkey.patch_all()
            
            def eat(name):
                print('%s eat 1'%name)
                time.sleep(2)
                print('%s eat 2' % name)
            
            def study(name):
                print('%s study 1'%name)
                time.sleep(3)
                print('%s study 2' % name)
            
            def main():
                g1 = gevent.spawn(eat,'Alex')
                g2 = gevent.spawn(study,'Jill')
                g1.join()
                g2.join()
                print('main')
            
            if __name__ == '__main__':
                main()  
课后作业：616971722@qq.com
    仿照现有代码实现greenlet协程爬虫
    import time,os,socket
    
        from urllib.parse import urlparse
        
        urls = [
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f0932b2-580x413.jpg!page-800',
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f1da6e5-580x825.jpg!page-800',
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f1e7e54-580x825.jpg!page-800',
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f1e5b2d-580x825.jpg!page-800',
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f223258-580x825.jpg!page-800',
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f227243-580x825.jpg!page-800',
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f24b9c2-580x825.jpg!page-800',
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f24c126-580x825.jpg!page-800',
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f256263-580x825.jpg!page-800',
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f297a87-580x825.jpg!page-800',
        ]
        
        class Crawler:
            def __init__(self, url):
                self.url = url
                self.receive_data = b''
        
            def fetch(self):
                # url是获取的域名和路径
                url = urlparse(self.url)
                # 创建socket实例
                self.socket = socket.socket()
                # 使用阻塞方法连接服务器,web服务器通用端口号默认80
                self.socket.connect((url.netloc,80))
                print('连接成功')
                os.system('mkdir -p pic')
                data  = 'GET {} HTTP/1.1\r\nHOST:{}\r\nConnection: close\r\n\r\n'.format(url.path, url.netloc)
                # 向服务器发送数据
                self.socket.send(data.encode())
                while True:
                        d = self.socket.recv(1024)
                        if d:
                           self.receive_data+=d
                        else:
                            break
                print('数据接收成功')
                with open('pic/{}'.format(url.path[1:]),'wb') as f:
                    f.write(self.receive_data.split(b'\r\n\r\n')[1])
                print('文件保存成功')
                self.socket.close()
        
        def main():
            start = time.time()
            for url in urls:
                crawler = Crawler(url)
                crawler.fetch()
            print('耗时：{:.2f}s'.format(time.time()-start))
        
        if __name__ == '__main__':
            main()

3. greenlet协程爬虫

    1）普通的爬虫方式：
        urllib.parse
          
        实例：耗时-1.26s
       


import time, os, socket
from urllib.parse import urlparse

urls = [
    'https://oss.mkzcdn.com/comic/page/20191005/5d9899f0932b2-580x413.jpg!page-800',
    'https://oss.mkzcdn.com/comic/page/20191005/5d9899f1da6e5-580x825.jpg!page-800',
    'https://oss.mkzcdn.com/comic/page/20191005/5d9899f1e7e54-580x825.jpg!page-800',
    'https://oss.mkzcdn.com/comic/page/20191005/5d9899f1e5b2d-580x825.jpg!page-800',
    'https://oss.mkzcdn.com/comic/page/20191005/5d9899f223258-580x825.jpg!page-800',
    'https://oss.mkzcdn.com/comic/page/20191005/5d9899f227243-580x825.jpg!page-800',
    'https://oss.mkzcdn.com/comic/page/20191005/5d9899f24b9c2-580x825.jpg!page-800',
    'https://oss.mkzcdn.com/comic/page/20191005/5d9899f24c126-580x825.jpg!page-800',
    'https://oss.mkzcdn.com/comic/page/20191005/5d9899f256263-580x825.jpg!page-800',
    'https://oss.mkzcdn.com/comic/page/20191005/5d9899f297a87-580x825.jpg!page-800',
]


# 创建的爬虫类
class Crawler:
    # 构造方法：初始化自带属性，
    #   分别为url属性-输入的数据
    #   以及receive_data属性-输出数据
    def __init__(self, url):
        self.url = url
        self.receive_data = b''

    # 实现爬虫的主要方法
    def fetch(self):
        # url是获取的域名和路径，目的是在执行爬虫代码之前先验证图片地址是否可用，截止到#111行
        url = urlparse(self.url)
        # 创建socket实例
        self.socket = socket.socket()
        # 使用阻塞方法连接服务器,web服务器通用端口号默认80
        self.socket.connect((url.netloc, 80))
        print('连接成功')
        os.system('mkdir pic')  # 当图片可用时，创建文件夹，接收数据，保存数据，截止到#126行
        data = 'GET {} HTTP/1.1\r\nHOST:{}\r\nConnection: close\r\n\r\n'.format(url.path, url.netloc)
        # 向服务器发送数据
        self.socket.send(data.encode())
        while True:
            d = self.socket.recv(1024)
            if d:
                # bytes字节码或字节流
                self.receive_data += d
            else:
                break
        print('数据接收成功')
        filename = self.url.split('/')[-1][:-9]
        with open('pic/{}'.format(filename), 'wb') as f:
            f.write(self.receive_data.split(b'\r\n\r\n')[1])
        print('文件保存成功')
        self.socket.close()


def main():
    start = time.time()
    for url in urls:
        crawler = Crawler(url)
        crawler.fetch()
    print('耗时：{:.2f}s'.format(time.time() - start))


if __name__ == '__main__':
    main()

  2)使用greenlet-总耗时：0.620s

     

  #导入相应的模块：
        import socket,os,time
        from greenlet import greenlet #实现协程
        from urllib.parse import urlparse
        # 实现IO多路复用
        from selectors import DefaultSelector, EVENT_WRITE,EVENT_READ
        
        selector = DefaultSelector()
        stopped = False
        
        urls = [
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f0932b2-580x413.jpg!page-800',
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f1da6e5-580x825.jpg!page-800',
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f1e7e54-580x825.jpg!page-800',
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f1e5b2d-580x825.jpg!page-800',
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f223258-580x825.jpg!page-800',
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f227243-580x825.jpg!page-800',
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f24b9c2-580x825.jpg!page-800',
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f24c126-580x825.jpg!page-800',
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f256263-580x825.jpg!page-800',
            'https://oss.mkzcdn.com/comic/page/20191005/5d9899f297a87-580x825.jpg!page-800',
        ]
        
        # 创建协程控制类
        class Hub():
            def wait(self):
                # 创建Waiter实例
                waiter = Waiter()
                # 设置回调方法为waiter的swich方法
                self.callback = waiter.switch
                # 将waiter实例返回值通过get方法获取
                return waiter.get()
            def set_result(self,data):
                self.callback(data)
        
        class Waiter:
            def __init__(self):
                #创建主协程
                self.main_gr = main_gr
        
            def switch(self, value):
                # 切换协程，保存当前协程
                self.gr.switch(value)
        
            def get(self):
                # 将当前协程赋值给greenlet属性，当前协程就是Crawler实例的fetch方法
                self.gr = greenlet.getcurrent()
                return self.main_gr.switch()
        
        # 创建爬虫类
        class Crawler:
            # 构造方法，创建属性，并赋值
            def __init__(self, url):
                self._url = url
                self.url = urlparse(url)
                self.response = b''
        
            def fetch(self):
                global stopped
                # 创建套接字
                sock = socket.socket()
                # 设置套接字为非阻塞模式
                sock.setblocking(False)
                try:
                    sock.connect((self.url.netloc, 80))
                except BlockingIOError:
                    pass
                # 创建Hub调度实例
                h = Hub()
                # 写事件的回调，套接字的写事件就绪时运行如下函数
                def writable():
                    h.set_result(None)
                # 实例化selector，注册监听事件
                selector.register(sock.fileno(),EVENT_WRITE, writable)
                h.wait()
                # 切换回来注销套接字监听事件
                selector.unregister(sock.fileno())
                data = 'GET {} HTTP/1.1\r\nHost:{}\r\nConnection: close\r\n\r\n'.format(self.url.path,self.url.netloc)
                # 向服务器发送请求
                sock.send(data.encode())
                # 读取数据,创建读事件监听回调事件就是readable
                def readable():
                    h.set_result(sock.recv(4096))
                # 注册套接字读事件
                selector.register(sock.fileno(), EVENT_READ, readable)
                while True:
                    data = h.wait()
                    if data:
                        self.response += data
                    else:
                        # 数据接收完，注销客户端监听
                        selector.unregister(sock.fileno())
                        # 从列表中移除对应的URL
                        urls.remove(self._url)
                        if not urls:
                            stopped = True
                        # 转存图片到本地
                        filename = self.url.path.split('/')[-1][:-9]
                        with open('pic/'+filename,'wb') as f:
                            f.write(self.response.split(b'\r\n\r\n')[1])
                        print('URL:{}下在完成'.format(self.url.path))
                        break
        
        def crawler():
            # 循环创建实例
            for url in urls:
                crawler = Crawler(url)
                # 使用fetch方法爬取数据
                gr = greenlet(crawler.fetch)
                gr.switch()
        # 将crawler函数作为参数创建协程，该协程是主协程。在这个协程内部会创建子协程
        main_gr = greenlet(crawler)
        
        # 事件循环函数
        def loop():
            while not stopped:
                events = selector.select()
                for event_key,_ in events:
                    callback = event_key.data
                    callback()
        def main():
            start = time.time()
            os.system('mkdir pic')
            # 切换到父协程main_gr中运行
            main_gr.switch()
            # 执行循环事件
            loop()
            print('总耗时：{:.3f}s'.format(time.time()-start))
        
        if __name__ == '__main__':
            main()

Top Secret
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python手动或自动协程操作方法解析
09-16
Python中的协程是一种高级的并发处理机制，它允许在单个线程中实现多个控制流，使得程序在等待I/O操作时不会阻塞，从而提高了程序的执行效率。本文将详细解析Python中手动和自动协程的操作方法。 1. 手动协程 手动...
python async socket_python 协程之二：协程使用范围、由来及演变过程
weixin_39784774的博客
11-27 378
协程：可以在许多不同的点上进入、退出和恢复协程提高效率就是用于 IO 操作上，计算型操作上协程无法提高效率一、IO 相关的简单理解IO概念：IO 就是输入输出的简称(input/output)IO操作一般分三种，其实本质都是基于文件的文件IO：文件对象，进行文件的读写操作。比如 open() 函数读写文件网络IO：socket对象，进行网络的传输操作的基础，有 TCP、UDP 两种传输模式。终端I...
# python 携程socket链接 TCP
JiuWeiYaoHo的博客
08-24 178
前一段是研究epool进行socket链接 一方面可能是本人不精通出现一些小BUG(就使用不顺手) 另一方面则是携程没有具体使用过则最近研究python官方文档给予的携程链接 先奉上代码 等研究差不多则可提供大家使用 这里提供官方文档 感兴趣可看一下 首先是server端 import asyncio from threading import Thread # 创建一个公共方法 用来存放客户端的文件地址 或者说是连接对象 server_dic = {} # 创建一个类 并且继承asyncio的接受子
协程在Socket上的应用
weixin_30510153的博客
03-31 235
Socket内部实现用的是多线程。 服务端 # coding=utf-8 import sys import socket import time import gevent from gevent import socket, monkey monkey.patch_all() def server(port): s = socket.socke...
greenlet和gevent模块
anmi8562的博客
06-03 116
协程是用户态的线程，并非真正意义上的线程， 协程只有一个线程，看起来并发的效果是因为它利用了寄存器的上下文切换， 多线程和多进程比较消耗cpu资源，当遇到修改数据的时候，还会遇到死锁的问题。 协程是最大的发挥了cpu的单核能力，遇到io阻塞就切换，阻塞完成之后切换回来。 协程的好处： 跨平台 跨体系架构 无需线程上下文切换的开销 无需原子操作锁定及同步的开销 方便切...
socket开发遇到的问题及注意事项实战
jia12216的专栏
09-14 1821
想做长连接，要知道几个基本问题： 1.运营商网络是否稳定，他们的ip是否变化。大家知道一切TCP/IP协议都要涉及到IP地址。一个移动设备在连网使用时，运营商会给你分配一个动态IP。若运营商发现你一段时间不使用就回收你的动态IP，分配给其他人，毕竟运营商的动态IP是有限的。每个省份的运营商给你的这段时间都不相同，有的是15分钟，有的是30分钟，甚至更久。所以你的长连接要保证这个间隔至少发送一次报...
Python gevent协程切换实现详解
09-16
在Python的世界里，gevent库是一个强大的工具，它利用了协程（greenlet）的概念，实现了高效的并发执行。本文将深入解析Python gevent中的协程切换实现，帮助开发者理解其内部工作原理。 首先，我们要明白gevent的...
Python使用协程进行 IO 并发程序示例
01-21
2. 让socket 模块下的 阻塞 可以出发协程跳转 “”” import gevent from gevent import monkey monkey.patch_all() # 在导入需要阻塞 的模块 之前执行, 执行脚本，修改socket 阻塞 from socket import * 创建 ...
python线程、进程和协程详解
12-24
我们都知道python网络编程的两大必学模块socket和socketserver，其中的socketserver是一个支持IO多路复用和多线程、多进程的模块。一般我们在socketserver服务端代码中都会写这么一句： server = socketserver....
python实现socket+threading处理多连接的方法
09-19
在Python编程中，Socket库是用于网络通信的基本模块，它提供了低级别的接口，允许程序员...此外，为了提高服务端的可扩展性和可靠性，还可以考虑使用更高级的并发模型，如协程（如Python的asyncio库）或者多进程编程。
python网络通信库_python网络通信 --- socket
weixin_39845347的博客
11-20 313
socketsocket 通常被翻译为“套接字”，它是计算机之间进行通信的一种约定或一种方式。通过socket这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据。Python标准库提供了socket模块来实现这种网络通信。实例化一个socket类便能得到一个socket对象sock = socket.socket()，使用这个socket对象就可以进行通信了。常用的socke...
python 网络编程笔记-socket
waixin的专栏
05-01 699
python 提供了对底层网络编程的socket模块，也提供了诸如urllib、httplib、poplib、ftplib等针对特定功能的编程模块。 以下直接贴代码测试socket模式使用： 服务端：Server.py #-*- coding:gbk -*- ''' Created on 2013-4-30 @author: herong ''' import threadin
python 协程及socket网络编程
weixin_42635252的博客
09-26 1214
协程 什么是协程 协程，英文Coroutines，是一种比线程更加轻量级的存在。正如一个进程可以拥有多个线程一样，一个线程也可以拥有多个协程。 最重要的是，协程不是被操作系统内核所管理，而完全是由程序所控制（也就是在用户态执行）。 这样带来的好处就是性能得到了很大的提升，不会像线程切换那样消耗资源。 协程优势： 有较高的执行效率， 始终只有一个线程， 不存在创建线程和销毁线程需要的时间； 也没有...
\r,\n,\r\n的区别
zm_bingxindan的专栏
12-25 2154
\n是换行，英文是New line，表示使光标到行首 \r是回车，英文是Carriage return，表示使光标下移一格 \r\n表示回车换行 我们在平时使用电脑时，已经习惯了回车和换行一次搞定，敲一个回车键，即是回车，又是换行。   1、\n 软回车： 在Windows 中表示换行且回到下一行的最开始位置。相当于Mac OS 里的 \r 的效果。 在Linux、unix 中只
自学 python 中的异步编程 asyncio：实战（三）websocket服务
最新发布
m0_61560439的博客
05-04 492
【代码】自学 python 中的异步编程 asyncio：实战（三）websocket服务。
Python3服务器端实现Socket实时通信和持续通信
weixin_43793002的博客
07-15 5575
address里的引号内填入你的本机ip地址，如果不填留空的话默认的是你本机的ip地址，后面的6666代表的是端口号，可以自己调整修改，但是不要修改为跟已有的端口号冲突。Socket通信协议就像是快递员和收货人，在本项目中服务器端就是收货人，客户端就是快递员，快递员把快递送到收货人手上时需要知道收货人的地址，所以会有地址，快递员到了收货人家中时收货人还需要把门打开才能正常收取快递，所以还要打开相应的端口，只不过每次接收快递都需要打开一个新的端口（避免冲突）。...
python3--socket编程(tcp协议)
qq_43966957的博客
11-24 2182
python3--socket编程(tcp协议)
php 阻塞函数吗,PHPfsockopen函数问题，本脚本无阻塞触发其他脚本失败
weixin_35089515的博客
03-28 191
$host = 'www.abc.com';$port = 80;$query = "admin/mi.php?key=value";$fp = @fsockopen($host, $port, $errno, $errstr, 30);if ($fp) {$out = "GET /".$query." HTTP/1.1\r\n";$out .= "Host: ".$host."\r\n";$ou...
socketTCP协程文件+信息传递 - TCP聊天文件服务器v1.9 - 划时代的版本更新(4.6万字)
热门推荐
m0_60394896的博客
05-04 1万+
TCP聊天+传输文件服务器服务器套接字v1.9 这, 划时代的版本更新, 修复若干大bug, 文件/信息区分, 最最最重要的一点是， 程序可以传文件了!!! 类似于QQ等软件(只不过.css比不上)

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Top Secret

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

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

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

打赏作者

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

抵扣说明：

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

余额充值