多进程/多线程/协程爬虫的性能比较

最新推荐文章于 2023-09-21 09:37:43 发布
最新推荐文章于 2023-09-21 09:37:43 发布
阅读量516 收藏 3
点赞数
分类专栏： python 文章标签： 爬虫 多任务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z1360408752/article/details/113028761
版权

进程、线程、协程

首先我们先来了解一下python中的进程、线程和协程。

进程和线程

从计算机硬件角度：

计算机的核心是CPU，承担了所有的计算任务。
一个CPU，在一个时间切片里只能运行一个程序。

从操作系统的角度：
进程和线程，都是一种CPU的执行单元。

进程： 表示一个程序的上下文执行活动（打开、执行、保存）

线程： 进程执行程序时的最小调度单位（执行a，执行b…）
一个程序至少有一个进程，一个进程至少有一个线程。

打个比方，我们打开QQ，这就创建了一个进程，而在QQ里打开多个聊天窗口和别人聊天，这就创建了多个线程。

并行和并发

并行： 多个CPU核心，不同的程序就分配给不同的CPU来运行，多以让多个程序同时执行。
cpu1 -------------
cpu2 -------------
cpu3 -------------
cpu4 -------------

并发： 单个CPU核心，在一个时间切片里以此只能运行多个程序，如果需要运行多个程序，则串行执行。
cpu1　　----　　----

cpu1 　　　----　　----

多进程和多线程

表示可以同时执行多个任务，进程和线程的调度是由操作系统自动完成。

进程：每个进程都有自己独立的内存空间，不同进程之间的内存空间不共享。
进程之间的同信由由操作系统传递，导致通讯效率低，切换开销大。

线程：一个进程可以有多个线程，所有线程共享进程的内存空间，通讯效率高，切换开销小。
共享意味着竞争，导致数据不安全，为了保护内存空间的数据安全，引入"互斥锁"。

一个线程在访问内存空间的时候，其他线程不允许访问，必须等待之前的线程访问结束，才能使用这个内存空间。

互斥锁：一种安全有序的让多个线程访问内存空间的机制。

Python的多线程

GIL 全局解释器锁：线程的执行权限，在Python的进程里只有一个GIL。

一个线程需要执行任务，必须获取GIL。

好处：直接杜绝了多个线程访问内存空间的安全问题。
坏处：Python的多线程不是真正多线程，不能充分利用多核CPU的资源。

但是，在I/O阻塞的时候，解释器会释放GIL。

所以：

多进程：密集CPU任务，需要充分使用多核CPU资源（服务器，大量的并行计算）的时候，用多进程。 multiprocessing
缺陷：多个进程之间通信成本高，切换开销大。

多线程：密集I/O任务（网络I/O，磁盘I/O，数据库I/O）使用多线程合适。
threading.Thread、multiprocessing.dummy
缺陷：同一个时间切片只能运行一个线程，不能做到高并行，但是可以做到高并发。

协程

协程：又称微线程，在单线程上执行多个任务，用函数切换，开销极小。不通过操作系统调度，没有进程、线程的切换开销。genvent，monkey.patchall

多线程请求返回是无序的，那个线程有数据返回就处理那个线程，而协程返回的数据是有序的。

缺陷：单线程执行，处理密集CPU和本地磁盘IO的时候，性能较低。处理网络I/O性能还是比较高.

对于多进程、多线程、协程的通俗解释

进程、线程、协程对比

请仔细理解如下的通俗描述

有一个老板想要开个工厂进行生产某件商品（例如剪子）

他需要花一些财力物力制作一条生产线，这个生产线上有很多的器件以及材料这些所有的 为了能够生产剪子而准备的资源称之为：进程

只有生产线是不能够进行生产的，所以老板的找个工人来进行生产，这个工人能够利用这些材料最终一步步的将剪子做出来，这个来做事情的工人称之为：线程

这个老板为了提高生产率，想到3种办法：

1、在这条生产线上多招些工人，一起来做剪子，这样效率是成倍増长，即单进程 多线程方式（一条生产线多个工人）

2、老板发现这条生产线上的工人不是越多越好，因为一条生产线的资源以及材料毕竟有限，所以老板又花了些财力物力购置了另外一条生产线，然后再招些工人这样效率又再一步提高了，即多进程 多线程方式

3、老板发现，现在已经有了很多条生产线，并且每条生产线上已经有很多工人了（即程序是多进程的，每个进程中又有多个线程），为了再次提高效率，老板想了个损招，规定：如果某个员工在上班时临时没事或者再等待某些条件（比如等待另一个工人生产完谋道工序 之后他才能再次工作） ，那么这个员工就利用这个时间去做其它的事情，那么也就是说：如果一个线程等待某些条件，可以充分利用这个时间去做其它事情，其实这就是：协程方式

简单总结

l 进程是资源分配的单位

l 线程是操作系统调度的单位

l 进程切换需要的资源很最大，效率很低

l 线程切换需要的资源一般，效率一般（当然了在不考虑GIL的情况下）

l 协程切换任务资源很小，效率高

l 多进程、多线程根据cpu核数不一样可能是并行的，但是协程是在一个线程中 所以是并发

实战案例：爬取豆瓣电影TOP250

单线程

import requests
from lxml import etree
import time
start=time.time()
base_url='https://movie.douban.com/top250?start={}'
headers={

    'Host': 'movie.douban.com',
    'Referer': 'https://movie.douban.com/top250?start=0',
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.104 Safari/537.36'
}
for page in range(0,11):
    url=base_url.format(page*25)
    response=requests.get(url,headers=headers)
    html=etree.HTML(response.text)
    info_list=html.xpath('//*[@id="content"]/div/div[1]/ol/li')
    for info in info_list:
        name=info.xpath('div/div[2]/div[1]/a/span[1]/text()')[0]
        score=info.xpath('div/div[2]/div[2]/div/span[2]/text()')[0]
        print(score,name)
end=time.time()
print('耗时%s秒'%(end-start))

在这里插入图片描述

多线程

from multiprocessing import Queue
from threading import Thread
import time
from lxml import etree
import requests

# 继承进程类
class DouBanSpider(Thread):
    def __init__(self, url, q):
        # 重写写父类的__init__方法
        super(DouBanSpider, self).__init__()
        self.url = url
        self.q = q
        self.headers = {
            'Host': 'movie.douban.com',
            'Referer': 'https://movie.douban.com/top250?start=225&filter=',
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.104 Safari/537.36',
        }

    def run(self):
        self.parse_page()

    def send_request(self, url):
        '''
        用来发送请求的方法
        :return: 返回网页源码
        '''
        # 请求出错时，重复请求３次,
        i = 0
        while i <= 3:
            try:
                print(u"[INFO]请求url:" + url)
                return requests.get(url=url, headers=self.headers).content
            except Exception as e:
                print(u'[INFO] %s%s' % (e, url))
                i += 1

    def parse_page(self):
        '''
        解析网站源码，并采用ｘｐａｔｈ提取　电影名称和平分放到队列中
        :return:
        '''
        response = self.send_request(self.url)
        html = etree.HTML(response)
        # 　获取到一页的电影数据
        node_list = html.xpath("//div[@class='info']")
        for move in node_list:
            # 电影名称
            title = move.xpath('.//a/span/text()')[0]
            # 评分
            score = move.xpath('.//div[@class="bd"]//span[@class="rating_num"]/text()')[0]

            # 将每一部电影的名称跟评分加入到队列
            self.q.put(score + "\t" + title)
            print(self.q.get())


def main():
    # 创建一个队列用来保存进程获取到的数据
    q = Queue()
    base_url = 'https://movie.douban.com/top250?start='
    # 构造所有ｕｒｌ
    url_list = [base_url + str(num) for num in range(0, 225 + 1, 25)]

    # 保存线程
    Thread_list = []
    # 创建并启动线程
    for url in url_list:
        p = DouBanSpider(url,q)
        p.start()
        Thread_list.append(p)

    # 让主线程等待子线程执行完成
    for i in Thread_list:
        i.join()

    while not q.empty():
        print(q.get())

if __name__ == "__main__":
    start = time.time()
    main()
    print('[info]耗时：%s' % (time.time() - start))

在这里插入图片描述

多进程

from multiprocessing import Process, Queue

import time
from lxml import etree
import requests

# 继承进程类
class DouBanSpider(Process):
    def __init__(self, url, q):
        # 重写写父类的__init__方法
        super(DouBanSpider, self).__init__()
        self.url = url
        self.q = q
        self.headers = {
            'Host': 'movie.douban.com',
            'Referer': 'https://movie.douban.com/top250?start=225&filter=',
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.104 Safari/537.36',
        }

    def run(self):
        self.parse_page()

    def send_request(self, url):
        '''
        用来发送请求的方法
        :return: 返回网页源码
        '''
        # 请求出错时，重复请求３次,
        i = 0
        while i <= 3:
            try:
                print(u"[INFO]请求url:" + url)
                return requests.get(url=url, headers=self.headers).content
            except Exception as e:
                print(u'[INFO] %s%s' % (e, url))
                i += 1

    def parse_page(self):
        '''
        解析网站源码，并采用ｘｐａｔｈ提取　电影名称和平分放到队列中
        :return:
        '''
        response = self.send_request(self.url)
        html = etree.HTML(response)
        # 　获取到一页的电影数据
        node_list = html.xpath("//div[@class='info']")
        for move in node_list:
            # 电影名称
            title = move.xpath('.//a/span/text()')[0]
            # 评分
            score = move.xpath('.//div[@class="bd"]//span[@class="rating_num"]/text()')[0]

            # 将每一部电影的名称跟评分加入到队列
            self.q.put(score + "\t" + title)
            print(self.q.get())


def main():
    # 创建一个队列用来保存进程获取到的数据
    q = Queue()
    base_url = 'https://movie.douban.com/top250?start='
    # 构造所有ｕｒｌ
    url_list = [base_url + str(num) for num in range(0, 225 + 1, 25)]

    # 保存进程
    Process_list = []
    # 创建并启动进程
    for url in url_list:
        p = DouBanSpider(url, q)
        p.start()
        Process_list.append(p)

    # 让主进程等待子进程执行完成
    for i in Process_list:
        i.join()
    while not q.empty():
        print(q.get())

if __name__ == "__main__":
    start = time.time()
    main()
    print('[info]耗时：%s' % (time.time() - start))

在这里插入图片描述

协程

from Queue import Queue
import time
from lxml import etree
import requests
import gevent

#　打上猴子补丁
from gevent import monkey
monkey.patch_all()

class DouBanSpider(object):
    def __init__(self):
        # 创建一个队列用来保存进程获取到的数据
        self.q = Queue()
        self.headers = {
            'Cookie': 'll="118282"; bid=ctyiEarSLfw; ps=y; __yadk_uid=0Sr85yZ9d4bEeLKhv4w3695OFOPoedzC; dbcl2="155150959:OEu4dds1G1o"; as="https://sec.douban.com/b?r=https%3A%2F%2Fbook.douban.com%2F"; ck=fTrQ; _pk_id.100001.4cf6=c86baf05e448fb8d.1506160776.3.1507290432.1507283501.; _pk_ses.100001.4cf6=*; __utma=30149280.1633528206.1506160772.1507283346.1507290433.3; __utmb=30149280.0.10.1507290433; __utmc=30149280; __utmz=30149280.1506160772.1.1.utmcsr=(direct)|utmccn=(direct)|utmcmd=(none); __utma=223695111.1475767059.1506160772.1507283346.1507290433.3; __utmb=223695111.0.10.1507290433; __utmc=223695111; __utmz=223695111.1506160772.1.1.utmcsr=(direct)|utmccn=(direct)|utmcmd=(none); push_noty_num=0; push_doumail_num=0',
            'Host': 'movie.douban.com',
            'Referer': 'https://movie.douban.com/top250?start=225&filter=',
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.104 Safari/537.36',
        }

    def run(self,url):
        self.parse_page(url)

    def send_request(self,url):
        '''
        用来发送请求的方法
        :return: 返回网页源码
        '''
        # 请求出错时，重复请求３次,
        i = 0
        while i <= 3:
            try:
                print u"[INFO]请求url:"+url
                html = requests.get(url=url,headers=self.headers).content
            except Exception as e:
                print u'[INFO] %s%s'% (e,url)
                i += 1
            else:
                return html

    def parse_page(self,url):
        '''
        解析网站源码，并采用ｘｐａｔｈ提取　电影名称和平分放到队列中
        :return:
        '''
        response = self.send_request(url)
        html = etree.HTML(response)
        #　获取到一页的电影数据
        node_list = html.xpath("//div[@class='info']")
        for move in node_list:
            # 电影名称
            title = move.xpath('.//a/span/text()')[0]
            # 评分
            score = move.xpath('.//div[@class="bd"]//span[@class="rating_num"]/text()')[0]

            # 将每一部电影的名称跟评分加入到队列
            self.q.put(score + "\t" + title)


    def main(self):


        base_url = 'https://movie.douban.com/top250?start='
        # 构造所有ｕｒｌ
        url_list = [base_url+str(num) for num in range(0,225+1,25)]
        # 创建协程并执行
        job_list = [gevent.spawn(self.run,url) for url in url_list]
        # 让线程等待所有任务完成，再继续执行。
        gevent.joinall(job_list)

        while not self.q.empty():
            print self.q.get()

if __name__=="__main__":
    start = time.time()
    douban = DouBanSpider()
    douban.main()
    print '[info]耗时：%s'%(time.time()-start)

参考链接：
1.多线程、多进程简介+代码示例
2.【多进程、多线程、协程+异步】对比测试
3.python采用 多进程/多线程/协程 写爬虫以及性能对比，牛逼的分分钟就将一个网站爬下来!..
4.进程、线程、协程对比通俗解释
5.单线程、多线程和协程的爬虫性能对比(含彩蛋)

Z_Coding
关注
专栏目录
多线程与协程爬虫
qq_45351815的博客
10-31 365
介绍 网络爬虫是一种高IO密集型任务，所以传统的进程或者多进程并不适合网络爬虫。由于CPython中全局解释器锁GIL的存在，无法真正意义上的实现多线程，但这种“不完美的多线程”依然可以大大提高爬虫效率，并且也因为这种缺陷产生了多协程网络爬虫。 ...
【爬虫】使用多线程、多进程、多协程提升爬虫速度
weixin_51656605的博客
02-05 4953
本系列为自己学习爬虫的相关笔记，如有误，欢迎大家指正 要学习提升爬虫速度用到的知识，必须先熟悉并发和并行、同步和异步的概 一、并发和并行，同步和异步 并发和并行 并发（concurrency）和并行（parallelism）是两个相似的概念。并发是指在一个时间段内发生若干事件的情况，并行是指在同一时刻发生若干事件的情况。 使用单核CPU和多核CPU来说就是：在使用单核CPU时，多个工作任务是以并发的方式运行的，因为只有一个CPU，所以各个任务会分别占用CPU的一段时间依次执行。如果在自己分得的时间段没有.
python采用 多进程/多线程/协程 写爬虫以及性能对比，牛逼的分分钟就将一个网站爬下来!...
weixin_30344131的博客
10-06 1733
首先我们来了解下python中的进程，线程以及协程！ 从计算机硬件角度： 计算机的核心是CPU，承担了所有的计算任务。一个CPU，在一个时间切片里只能运行一个程序。 从操作系统的角度： 进程和线程，都是一种CPU的执行单元。 进程：表示一个程序的上下文执行活动（打开、执行、保存...） 线程：进程执行程序时候的最小调度单位（执行a，执行b...) 一个程序至少有一个进程，...
Python 爬虫：单线程、多线程和协程的爬虫性能对比
【CSDN官方推荐】
03-02 522
前言 本文的文字及图片来源于网络,仅供学习、交流使用,不具有任何商业用途,如有问题请及时联系我们以作处理。 PS：如有需要Python学习资料的小伙伴可以点击下方链接自行获取 Python免费学习资料、代码以及交流解答点击即可加入 今天我要给大家分享的是如何爬取豆瓣上深圳近期即将上映的电影影讯，并分别用普通的单线程、多线程和协程来爬取，从而对比单线程、多线程和协程在网络爬虫中的性能。 具体要爬的网址是：https://movie.douban.com/cinema/later/shenzhen/
python爬虫之多线程、多进程、多协程对比
naer_chongya的博客
05-29 1626
Python爬虫通常需要处理大量的数据和网络请求，因此在爬虫中使用多线程、多进程和多协程可以大大提高爬虫的效率和速度。在本篇文章中，我们将详细介绍Python爬虫中的多线程、多进程和多协程的概念，优缺点以及如何选择合适的方案。
爬虫代码详解Python多线程、多进程、协程
早起Python
04-07 803
一、前言 很多时候我们写了一个爬虫，实现了需求后会发现了很多值得改进的地方，其中很重要的一点就是爬取速度。本文就通过代码讲解如何使用多进程、多线程、协程来提升爬取速度。注意：我们不深入介绍理论和原理，一切都在代码中。 二、同步 首先我们写一个简化的爬虫，对各个功能细分，有意识进行函数式编程。下面代码的目的是访问300次百度页面并返回状态码，其中parse_1函数可以设定循环次数，每次循环将当...
python爬虫之多线程、多进程爬虫
02-24
多线程对爬虫的效率提高是非凡的，当我们使用python的多线程有几点是需要我们知道的：1.Python的多线程并不如java的多线程，其差异在于当python解释器开始执行任务时，受制于GIL(全局解释所)，Python的线程被限制到...
进程/线程/协程/多进程/多线程应用场景/线程切换/进程切换/内核栈和用户栈切换/线程的工作内存
s11show_163的博客
01-20 526
为什么会有线程？ 在网络或多用户换机下，一个服务器通常需要接收大量不确定数量用户的并发请求，为每一个请求都创建一个进程显然行不通（系统开销大响应用户请求效率低），因此操作系统中线程概念被引进。 进程：是并发执行的程序在执行过程中分配和管理资源的基本单位，是一个动态概念，竞争计算机系统资源的基本单位。 线程：是进程的一个执行单元，是进程内科调度实体。比进程更小的独立运行的基本单位。线程也被称为轻量级进程。 一个程序至少一个进程，一个进程至少一个线程。 进程线程的区别： 地址空间：同一进程的线程共享本进程的地址
多进程、多线程、协程的使用如何选择？
仙路尽头谁为峰
10-17 2914
进程、线程与协程的差异总结背景基础概念1、进程2、线程3、协程各自的适用环境参考文献 背景 最近在研究如何实现高效率爬虫过程中，经常会使用多线程、多进程、以及协程来进行并发或并行操作。虽然掌握了这几个Python库的基本用法，但其实一直对这几个概念之间的区别理解不是那么明确，处在一种知其然，不知其所以然的处境，因此这几天查询了各种相关文献，总算是搞明白了进程、线程以及协程的内涵以及最佳使用场景，这篇博客可以算是学习记录与总结，记下来一遍日后有需要的时候再翻阅。 基础概念 在对比使用差别之前，首先看一下三者的
Python爬虫中多线程、多进程、多协程的介绍和对比
梁先森的博客
12-12 886
前面咱们也写了好几篇爬虫的文章，都是些数据量不是很多的例子。那如果遇到数据量比较大的时候怎么办提高速度和效率呢。今天的这篇会给你答案。 一、线程、进程、协程的简介 1.同步、异步、并行、并发 同步：各个任务不是独自运行的，任务之间有一定的运行顺序 异步：各个任务是独立运行的，一个任务的运行不收另一个任务的影响 并行：同一时刻发生若干事情的情况 并发：同一时间段发生若干事情。 这里可能并行和并发...
Python爬虫是用多线程还是多进程
Jayj1997的博客
10-12 1376
我的爬虫学习Python爬虫多线程多进程多线程多进程 Python爬虫多线程多进程 多线程 自己的爬虫一直在用多进程，以前一直没了解过多线程，只知道多线程适合IO密集型场景，感觉自己的也不太需要，所以就一直用Multiprocessing，昨天经理让我们写多线程的爬虫，我就去学习了一下，了解到了Python有一个终极黑科技：GIL锁（global interpreter lock） 任何Pyth...
python爬虫的多进程，多线程和协程1
sjp8497697的博客
06-07 396
python的多进程 1. 多线程版本 import ssl import threading import time import urllib.request from queue import Queue from lxml import etree class myThread(threading.Thread): def __init__(self,url,q): ...
爬虫--多线程-多进程-协程以及池的使用
weixin_44090435的博客
01-14 392
多线程 线程的创建和运行 import threading def task(num): pass t = threading.Thread(target=task,args=(num,)) t.start() 守护线程 一般情况下，主线程代码执行完毕后不会结束，会等待所有子线程任务结束后才结束 如果将子线程设置为守护线程，意味着：主线程代码执行完毕，主线程和子线程一起立即结...
Python爬虫案例演示：Python多线程、多进程、协程
Python学习Q群696455390
04-07 230
很多时候我们写了一个爬虫，实现了需求后会发现了很多值得改进的地方，其中很重要的一点就是爬取速度。本文就通过代码讲解如何使用 多进程、多线程、协程来提升爬取速度。注意：我们不深入介绍理论和原理，一切都在代码中。 二、同步 首先我们写一个简化的爬虫，对各个功能细分，有意识进行函数式编程。下面代码的目的是访问300次百度页面并返回状态码，其中parse_1函数可以设定循环次数，每次循环将...
多线程多进程协程的区别和不同的应用场景
someonei的博客
03-18 8825
当然既然是都是 多这个字开头，那么就是多任务，我们需要了解并发：指的是任务数多余cpu核数，通过操作系统的各种任务调度算法，        实现⽤多个任务“⼀起”执⾏（实际上总有⼀些任务不在执⾏，因为切换任            务的速度相当快，看上去⼀起执⾏⽽已）并⾏：指的是任务数⼩于等于cpu核数，即任务真的是⼀起执⾏的多线程（threading）：①在⼀个进程内的所有线程共享全局变量，很⽅便...
python:一文搞懂多线程,多进程,异步协程的使用场景
m0_72741644的博客
09-03 1034
案例一代表纯CPU计算------进程池完胜 案例二代表CPU耗时=IO耗时------协程异步完胜 案例三代表少量CPU计算, 大量IO操作(相对于CPU计算的时间是大量的)------线程池完胜 案例四代表极少量CPU计算------单线程完胜
Python实战：用多线程和多进程打造高效爬虫
最新发布
null18的博客
09-21 5073
通过使用多线程和多进程，我们可以显著提高网络爬虫的效率，更快地获取大量数据。然而，要小心线程安全问题和进程管理的开销。挑战与创造都是很痛苦的，但是很充实。
Python爬虫实战：单线程、多线程和协程性能对比
Python_cocola的博客
04-25 871
今天我要给大家分享的是如何爬取中农网产品报价数据，并分别用普通的单线程、多线程和协程来爬取，从而对比单线程、多线程和协程在网络爬虫中的性能。目标URL：爬取产品品名、最新报价、单位、报价数、报价时间等信息，保存到本地Excel。今天我演示了简单的单线程爬虫、多线程爬虫和协程异步爬虫。可以看到一般情况下异步爬虫速度最快，多线程爬虫略慢一点，单线程爬虫速度较慢，必须上一个页面爬取完成才能继续爬取。
python开发面试题进程和线程对比_Python 多线程、多进程 （三）之 线程进程对比、多进程...
weixin_31437187的博客
02-20 246
一、多线程与多进程的对比在之前简单的提过，CPython中的GIL使得同一时刻只能有一个线程运行，即并发执行。并且即使是多核CPU，GIL使得同一个进程中的多个线程也无法映射到多个CPU上运行，这么做最初是为了安全着想，慢慢的也成为了限制CPython性能的问题。 一个线程想要执行，就必须得到GIL，否则就不能拿到CPU资源。但是也不是说一个线程在拿到CPU资源后就一劳永逸，在执行的过程中GIL可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值