Python Asyncio 所有异步协程库用法详解

最新推荐文章于 2024-06-08 11:14:25 发布
置顶 最新推荐文章于 2024-06-08 11:14:25 发布
阅读量2.1k 收藏 31
点赞数 4
分类专栏： Python 文章标签： python异步 asynctask asyncio python高并发 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzy98/article/details/114002465
版权
本文详细介绍了Python的Asyncio框架，包括事件循环、取消协程任务、协程嵌套、定时启动任务、线程池结合、多进程与同步通信等内容，并探讨了aiohttp库的基础用法，如基本请求、响应内容处理、自定义请求头等，以及如何与其他异步库如aio_mysql、aioredis等配合使用，深入展示了Python异步编程的强大功能。
摘要由CSDN通过智能技术生成

title: Asyncio并发编程
copyright: true
top: 0
date: 2019-04-03 14:09:24
tags: Asyncio
categories: Python高阶笔记
permalink:
password:
keywords:
description: Python高并发框架，进一步解读asyncio的语法与功能，同时对支持异步的web网络请求包aiohttp功能做介绍。

我喜欢铁路，你沿着铁路走，在尽头肯定会找到一座城市，或者其他什么有人的地方。不像鸟飞在空中，甚至不知道前面会不会有目的地。

在此之后可以尝试阅读Python 异步协程概念，协程是一个很大的框架，需要从基础原理慢慢学习。

Asyncio

在python3.5之前，都是使用生成器的一些技巧完成协程任务，他们的调度方式依然是 事件循环+协程模式。这样设计结构和维护虽然相对于回调函数简单一些，但是代码还是有一些混乱，并且又当作生成器又当作协程，都是还是一些技巧性的东西，为了将语义变得更加明确，于是在python3.5使用了async和await(功能与yield from类似)关键词正式定义原生协程，asyncio是python解决异步io编程的一个完整框架。

它具有如下定义：

  1. 包含各种特定系统实现的模块化事件循环
  2. 传输与协议抽象
  3. 对TCP,UDP,SSL,子进程，延时调用以及其他的具体支持
  4. 模仿futures模块适用于事件循环使用到Future类
  5. 基于yield from的协议和任务，可以使用顺序执行的方式编写并发代码
  6. 必须使用一个将产生阻塞IO的调用时，有接口可以把这个事件转移到线程池
  7. 模仿threading模块中的同步语法，可以用在单线程内实现协程同步

协程编程离不开的三大要点：

  1. 事件循环
  2. 回调(驱动生成器)
  3. epoll/select(IO多路复用)

Asyncio是一个异步编程的框架，可以解决异步编程，协程调度问题，线程问题，是整个异步IO的解决方案。

事件循环

简单案例(访问一个网站)

async def get_url_title(url):
# 使用关键词async定义一个协程
    print('开始访问网站:{}'.format(url))
    await asyncio.sleep(2)
    # 这一步至关重要
    # asyncio.sleep(2) 功能:异步非阻塞等待2s，作用是模拟访问网站消耗的时间
    # await 的作用类似 yield，即这个时候把线程资源控制权交出去,监听这个描述符直到这个任务完成
    # await 后面只能接三种类型
    '''
    1. 协程:Python 协程属于 可等待 对象，因此可以在其他协程中被等待:
    2. 任务:任务 被用来设置日程以便 并发 执行协程。(当一个协程通过 asyncio.create_task() 等函数被打包为一个 任务，该协程将自动排入日程准备立即运行)
    3. Future 对象:Future 是一种特殊的 低层级 可等待对象，表示一个异步操作的 最终结果。(当一个 Future 对象 被等待，这意味着协程将保持等待直到该 Future 对象在其他地方操作完毕。)
    
    如果await time.sleep(2) 是会报错的
    '''
    print('网站访问成功')

if __name__ == '__main__':
    start_time = time.time()
    loop = asyncio.get_event_loop()
    # 一行代码创造事件循环
    loop.run_until_complete(get_url_title('http://www.langzi.fun'))
    # 这是一个阻塞的方法,可以理解成多线程中的join方法
    # 直到get_url_title('http://www.langzi.fun')完成后，才会继续执行下面的代码
    end_time = time.time()
    print('消耗时间:{}'.format(end_time-start_time))

返回结果：

开始访问网站:http://www.langzi.fun
网站访问成功
消耗时间:2.0018768310546875

简单案例(访问多个网站)

协程的优势是多任务协作，单任务访问网站没法发挥出他的功能，一次性访问多个网站或者一次性等待多个IO响应时间才能发挥它的优势。

# -*- coding:utf-8 -*-
import asyncio
import time

async def get_url_title(url):
    print('开始访问网站:{}'.format(url))
    await asyncio.sleep(2)
    print('网站访问成功')

if __name__ == '__main__':
    start_time = time.time()
    loop = asyncio.get_event_loop()
    # 创造一个事件循环
    tasks = [get_url_title('http://www.langzi.fun')for i in range(10)]
    # 这个列表代表总任务量，即执行10次get_url_title()函数
    loop.run_until_complete(asyncio.wait(tasks))
    # asyncio.wait后面接上非空可迭代对象,一般来说是功能函数列表
	# 功能是一次性提交多个任务，等待完成
	# loop.run_until_complete(asyncio.gather(*tasks))
	# 和上面代码功能一致，但是gather更加高级，如果是列表就需要加上*
    # 这里会等到全部的任务执行完后才会执行后面的代码
    end_time = time.time()
    print('消耗时间:{}'.format(end_time-start_time))

对一个网站发起10次请求，返回结果：

开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
消耗时间:2.0015649795532227

gather与wait的区别：

  • gather更擅长于将函数聚合在一起
  • wait更擅长筛选运行状况

即gather更加高级，他可以将任务分组，也可以取消任务

import asyncio

async def get_url_title(url):
    print('开始访问网站:{}'.format(url))
    await asyncio.sleep(2)
    print('网站访问成功')
    return 'success'

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    # 使用wait方法
    # tasks = [get_url_title('http://www.langzi.fun')for i in range(10)]
    # loop.run_until_complete(asyncio.wait(tasks))

    # 使用gather方法实现分组导入(方法1)
    group1 = [get_url_title('http://www.langzi.fun')for i in range(3)]
    group2 = [get_url_title('http://www.baidu.com')for i in range(5)]
    loop.run_until_complete(asyncio.gather(*group1,*group2))
    # 这种方法会把两个全部一次性导入

    # 使用gather方法实现分组导入(方法2)
    group1 = [get_url_title('http://www.langzi.fun')for i in range(3)]
    group2 = [get_url_title('http://www.baidu.com')for i in range(5)]
    group1 = asyncio.gather(*group1)
    group2 = asyncio.gather(*group2)
    #group2.cancel() 取消group2任务
    loop.run_until_complete(asyncio.gather(group1,group2))
    # 这种方法会先把group1导入，然后导入group2

返回结果：

开始访问网站:http://www.baidu.com
开始访问网站:http://www.baidu.com
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.baidu.com
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.baidu.com
开始访问网站:http://www.baidu.com
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.baidu.com
开始访问网站:http://www.baidu.com
开始访问网站:http://www.baidu.com
开始访问网站:http://www.baidu.com
开始访问网站:http://www.baidu.com
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功

另外一种使用gather获取返回结果:

import asyncio

async def get_url_title(url):
    print('开始访问网站:{}'.format(url))
    await asyncio.sleep(2)
    print('网站访问成功')
    return 'success'

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    # 使用gather方法传递任务获取结果
    group1 = asyncio.ensure_future(get_url_title('http://www.langzi.fun'))
    loop.run_until_complete(asyncio.gather(group1))
	# 如果不是列表就不需要加*
    print(group1.result())

返回结果：

开始访问网站:http://www.langzi.fun
网站访问成功
success

还有一些复杂的区别转移到python 异步协程中查看

协程的调用和组合十分灵活，尤其是对于结果的处理，如何返回，如何挂起，需要逐渐积累经验和前瞻的设计。

简单案例(获取返回值)

# -*- coding:utf-8 -*-
import asyncio
import time

async def get_url_title(url):
    print('开始访问网站:{}'.format(url))
    await asyncio.sleep(2)
    print('网站访问成功')
    return 'success'

if __name__ == '__main__':
    start_time = time.time()
    loop = asyncio.get_event_loop()
    # 创建一个事件循环

    get_future = loop.create_task(get_url_title('http://www.langzi.fun'))
    #get_future = asyncio.ensure_future(get_url_title('http://www.langzi.fun'))
    # 这两行代码功能用法一模一样

    loop.run_until_complete(get_future)
    print('获取结果:{}'.format(get_future.result()))
    # 获取结果
    
    end_time = time.time()
    print('消耗时间:{}'.format(end_time-start_time))

返回结果：

开始访问网站:http://www.langzi.fun
网站访问成功
获取结果:success
消耗时间:2.0019724369049072

如果是多个网址传入，访问多个网址的返回值呢？只需要把前面的知识点汇总一起即可使用：

if __name__ == '__main__':
    start_time = time.time()
    loop = asyncio.get_event_loop()
    # 创建一个事件循环

    tasks = [loop.create_task(get_url_title('http://www.langzi.fun')) for i in range(10)]
	# 把所有要返回的函数加载到一个列表

    loop.run_until_complete(asyncio.wait(tasks))
	# 这里和上面用法一样

    print('获取结果:{}'.format([x.result() for x in tasks]))
    # 因为结果都在一个列表，在列表中取值即可

    end_time = time.time()
    print('消耗时间:{}'.format(end_time-start_time))

返回结果：

开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
开始访问网站:http://www.langzi.fun
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
网站访问成功
获取结果:['success', 'success', 'success', 'success', 'success', 'success', 'success', 'success', 'success', 'success']
消耗时间:2.0016491413116455

简单案例(回调函数)

上面的例子是一个协程函数，当这个协程函数的await xxx执行完毕后，想要执行另一个函数后，然后再返回这个协程函数的返回结果该这么做：

# -*- coding:utf-8 -*-
import asyncio
from functools import partial
# partial的功能是 固定函数参数，返回一个新的函数。你可以这么理解：
'''
from functools import partial
    def go(x,y):
        return x+y
    g = partial(go,y=2)
    print(g(1))
返回结果：3

    g = partial(go,x=5,y=2)
    print(g())
返回结果：7
    
'''
async def get_url_title(url):
    print('开始访问网站:{}'.format(url))
    await asyncio.sleep(2)
    print('网站访问成功')
    # 当这个协程函数快要结束返回值的时候，会调用下面的call_back函数
    # 等待call_back函数执行完毕后，才返回这个协程函数的值
    return 'success'

def call_back(future,url):
    # 注意这里必须要传递future参数，因为这里的future即代表下面的get_future对象
    print('检测网址:{}状态正常'.format(url))

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    # 创建一个事件循环

    get_future = loop.create_task(get_url_title('http://www.langzi.fun'))
    # 将一个任务注册到loop事件循环中

    get_future.add_done_callback(partial(call_back,url = 'http://www.langzi.fun'))
    # 这里是设置，当上面的任务完成要返回结果的时候，执行call_back函数
    # 注意call_back函数不能加上()，也就意味着你只能依靠partial方法进行传递参数
    
    loop.run_until_complete(get_future)
    # 等待任务完成
    print('获取结果:{}'.format(get_future.result()))
    # 获取结果

返回结果：

开始访问网站:http://www.langzi.fun
网站访问成功
检测网址:http://www.langzi.fun状态正常
获取结果:success

梳理

  1. 协程函数必须要使用关键词async定义
  2. 如果遇到了要等待的对象，必须要使用await
  3. 使用await后面的任务，必须是可等待对象(三种主要类型: 协程, 任务 和 Future.)
  4. 运行前，必须要创建一个事件循环(loop = asyncio.get_event_loop(),一行代码即可)
  5. 然后把任务加载到该事件循环中即可
  6. 如果需要获取协程函数的返回值，需要使用loop.create_task()或asyncio.ensure_future()函数，在最后使用.result()获取返回结果。
  7. 如果想要把多个任务注册到loop中，需要使用一个列表包含他们，调用的时候使用asyncio.wait(list)

取消协程任务

存在多个任务协程，想使用ctrl c退出协程，使用例子讲解：

import asyncio
async def get_time_sleep(t):
    print('开始运行，等待:{}s'.format(t))
    await asyncio.sleep(t)
    print('运行结束')

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    # 创建一个事件循环
    task_1 = get_time_sleep(1)
    task_2 = get_time_sleep(2)
    task_3 = get_time_sleep(3)

    tasks = [task_1,task_2,task_3]
    # 三个协程任务加载到一个列表

    try:
        loop.run_until_complete(asyncio.wait(tasks))
    except KeyboardInterrupt:
        # 当检测到键盘输入 ctrl c的时候
        all_tasks = asyncio.Task.all_tasks()
        # 获取注册到loop下的所有task
        for task in all_tasks:
            print('开始取消协程')
            task.cancel()
            # 取消该协程,如果取消成功则返回True
        loop.stop()
		# 停止循环
        loop.run_forever()
		# loop事件循环一直运行
        # 这两步必须要做
    finally:
        loop.close()
		# 关闭事件循环

run_forever 会一直运行，直到 stop 被调用，但是你不能像下面这样调 stop

loop.run_forever()
loop.stop()

run_forever 不返回，stop 永远也不会被调用。所以，只能在协程中调 stop：

async def do_some_work(loop, x):
    print('Waiting ' + str(x))
    await asyncio.sleep(x)
    print('Done')
    loop.stop()

这样并非没有问题，假如有多个协程在 loop 里运行：

asyncio.ensure_future(do_some_work(loop, 1))
asyncio.ensure_future(do_some_work(loop, 3))

loop.run_forever()

第二个协程没结束，loop 就停止了——被先结束的那个协程给停掉的。
要解决这个问题，可以用 gather 把多个协程合并成一个 future，并添加回调，然后在回调里再去停止 loop。

async def do_some_work(loop, x):
    print('Waiting ' + str(x))
    await asyncio.sleep(x)
    print('Done')

def done_callback(loop, futu):
    loop.stop()

loop = asyncio.get_event_loop()

futus = asyncio.gather(do_some_work(loop, 1), do_some_work(loop,
最低0.47元/天 解锁文章
浪子燕青啦啦啦
关注
  • 4
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Python 学习之 ---asyncio 库的使用
等风来的博客
06-19 2468
asyncio 库的使用 3.4版本加入标准库asyncio 底层基于selector 实现,看似库,其实就是个框架,包含同步IO, 事件循环,协程,任务等内容 举例: def a(): for i in range(3): print('a.x',i) def b(): for i in range(3): print('b.x' ,i) a() ...
生产者—消费者模型及实现
Ricky
12-07 995
一、什么是生产者消费者模式生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。
python 异步编程：协程
最新发布
瑞瑞的博客
06-08 1072
yield关键字用于定义一个生成器（generator）函数。生成器是一种特殊的迭代器，它允许你逐个产生值，而不是一次性创建并返回一个包含所有值的列表。使用yield的函数在执行过程中可以多次yield值，每次yield都会返回一个值，并在下一次从该点继续执行。yield是 Python 中实现协程和异步编程的基础，特别是在 Python 3.3 之前，当时的asyncio库依赖于生成器来实现协程。在 Python 3.5 及以后版本中，引入了async和await语法，提供了更高级的异步编程能力，但。
Python的协程异步IO（asyncio）详解
创作不易，请多支持，将为本站提供更多「有价值的文章」。
09-19 9673
协程不是系统级线程，很多时候协程被称为“轻量级线程”、“微线程”、“纤程(fiber)”等。简单来说可以认为协程是线程里不同的函数，这些函数之间可以相互快速切换。协程和用户态线程非常接近，用户态线程之间的切换不需要陷入内核，但部分操作系统中用户态线程的切换需要内核态线程的辅助。协程是编程语言（或者 lib）提供的特性（协程之间的切换方式与过程可以由编程人员确定），是用户态操作。协程适用于 IO 密集型的任务。
Python使用Asyncio协程以及多协程爬虫
TranSad的博客
12-04 645
Python使用Asyncio协程以及多协程爬虫的使用方法。 我们都知道python有一个GIL（全局解释器锁），因此虽然有Threading库，但那只是用来模拟多线程，因此Python的多线程也不能带来真正的并行。 所以要用python达到并发的效果，要么多进程（multiprocess），要么就是——多协程。 话说进程、线程、协程的区别应该也是面试重点了，值得一背~ 直接来说这篇文章的重点，协程。它涉及到Asyncio的基本使用方法，最后再附...
python asyncio理解_深入理解asyncio(一)
weixin_39652760的博客
12-05 234
前言这几天看asyncio相关的pycon视频又重温了asyncio 的官方文档，收获很多。之前asyncio被吐槽的一点就是文档写的不好，Python 3.7 时 asyncio 的官方文档被 Andrew Svetlov 以及 Yury Selivanov 等核心开发者重写了，新的版本我觉得已经好很多了。在这里记录一下我对asyncio的一些理解。核心概念asyncio里面主要有4个需要关注的...
Python 异步协程函数原理及实例详解
09-18
本文将深入探讨Python异步协程函数的原理和实例。 首先，Python 3.4引入了asyncio标准库，这是一个内置的事件循环（message loop）系统，专门用于处理异步I/O操作。事件循环是异步编程的核心，它负责调度协程的执行...
关于Python核心框架tornado的异步协程的2种方法详解
09-18
Tornado通过集成`asyncio`库，支持使用`async/await`进行异步操作。以下是一个使用协程的例子： ```python import asyncio import tornado.ioloop import tornado.web class MainHandler(tornado.web....
Python使用asyncio包处理并发详解
09-21
`asyncio`是Python的标准库之一，专门用于处理异步I/O和并发操作，尤其适用于网络编程和事件驱动的应用。 `asyncio`的核心概念是事件循环（Event Loop）和协程（Coroutine）。事件循环是整个异步模型的驱动力，它...
python并发编程之多进程、多线程、异步和协程详解
09-21
Python的`asyncio`库提供了异步I/O框架，通过`async/await`语法糖，可以让异步代码看起来像是同步代码，极大地简化了异步编程。异步编程特别适合处理网络I/O和数据库查询等I/O密集型任务，因为它能有效地利用CPU资源...
深入浅析python 协程与go协程的区别
09-19
### 深入浅析 Python 协程与 Go 协程的区别 #### 一、基本概念 在深入了解 Python 协程与 Go 协程的区别之前，我们先回顾一下进程、线程以及协程的基本概念。 **进程**是操作系统中运行程序的实体。每个进程拥有...
Python-aiochan一个Python下的并发库
08-10
aiochan 一个 Python 下的并发库
python asyncio 高级用法_Python并发concurrent.futures和asyncio的用法
weixin_42548782的博客
03-01 346
Python并发concurrent.futures和asyncio的用法发布时间：2020-07-29 09:26:00来源：亿速云阅读：104作者：小猪这篇文章主要讲解了Python并发concurrent.futures和asyncio的用法，内容清晰明了，对此有兴趣的小伙伴可以学习一下，相信大家阅读完之后会有帮助。说明Python标准库为我们提供了threading和multiproces...
python 协程 & 异步 & asyncio
m0_54219225的博客
08-20 418
Task继承Future, Task 对象内部await结果的处理基于Future对象，在Future对象内部有一个 _state 变量 记录了 Task 对象的状态，通过_state的状态 实现await 的功能。需要注意的是，协程并不是线程，它是在单个线程中执行，并利用事件循环来切换协程的执行。在Python中，asyncio模块提供了对协程的支持，使用async/await关键字来定义协程函数，并提供了一套事件循环和相关工具来调度和管理协程的执行。这意味着可以通过共享变量来实现协程间的通信和同步。
一文看懂Python协程asyncio模块的演变及高级用法
大江狗
05-17 1243
网上很多关于Python协程asyncio模块的教程都是基于老版Python的, 本文将以对比方式展示新老Python版本下协程的写法有什么不同并总结了asyncio的一些高级用法, 包括...
asyncio：高性能异步模块使用介绍
Python之禅的专栏
07-03 1084
本文是作者「无名小妖」的第3篇原创投稿，文章重点探讨 Python3 中的 asyncio 库，这是官方推荐实现高并发的模块。如果你喜欢技术写作并且愿意分享，可投稿给我(...
python asyncio 异步协程知识点集合
weixin_58439331的博客
12-22 1378
tornado asyncio 异步协程的基本使用
Python asyncssh 万金油服务器端，万金油客户端 Demo
来啊 快活啊
11-20 1225
import asyncio, asyncssh, sys import threading import time def yesinstall(chan): time.sleep(10) chan.write("ls\n") class MySSHClientSession(asyncssh.SSHClientSession): def data_received(self, data, datatype): print(data, end='')
python asyncio 实现协程_python——asyncio模块实现协程、异步编程（三）
weixin_36163672的博客
02-09 212
【八】协程停止future对象有几个状态：PendingRunningDoneCancelled创建future的时候，task为pending，事件循环调用执行的时候当然就是running，调用完毕自然就是done，如果需要停止事件循环，就需要先把task取消。可以使用asyncio.Task获取事件循环的task例如：importasyncioimporttimenow=lambda:...
协程asyncio_Python 异步模块 asyncio 中的协程与任务
05-24
在Python异步模块asyncio中，协程和任务都是用于异步编程的重要对象。 协程是一种特殊的函数，可以通过`async def`关键字定义。协程可以通过`await`关键字暂停执行，并在稍后继续执行。协程的定义示例： ```python...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

浪子燕青啦啦啦

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

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

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

打赏作者

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

抵扣说明：

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

余额充值