python中的多任务编程

最新推荐文章于 2024-07-19 11:51:01 发布
最新推荐文章于 2024-07-19 11:51:01 发布
阅读量841 收藏 3
点赞数 1
分类专栏： # python基础 文章标签： python 多线程 多进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaotai1234/article/details/109547701
版权

python中的多任务编程

一、多任务的介绍

1.多任务的概念

在这里插入图片描述

2.多任务的执行方式

在这里插入图片描述

3.小结

在这里插入图片描述

二、进程

1.进程的介绍

在Python程序中，想要实现多任务可以使用进程来完成，进程是实现多任务的一种方式。

2.进程的概念

在这里插入图片描述

3.进程的作用

在这里插入图片描述
在这里插入图片描述

4.小结

在这里插入图片描述

三、多进程的使用

1.导入进程包

在这里插入图片描述

2.Process进程类的说明

在这里插入图片描述

3.多进程完成多任务的代码

import multiprocessing
import time


# 跳舞任务
def dance():
    for i in range(5):
        print("跳舞中...")
        time.sleep(0.2)


# 唱歌任务
def sing():
    for i in range(5):
        print("唱歌中...")
        time.sleep(0.2)

if __name__ == '__main__':
    # 创建跳舞的子进程
    # group: 表示进程组，目前只能使用None
    # target: 表示执行的目标任务名(函数名、方法名)
    # name: 进程名称, 默认是Process-1, .....
    dance_process = multiprocessing.Process(target=dance, name="myprocess1")
    sing_process = multiprocessing.Process(target=sing)

    # 启动子进程执行对应的任务
    dance_process.start()
    sing_process.start()

在这里插入图片描述

4.小结

在这里插入图片描述

四、获取进程编号

1.获取进程编号的目的

在这里插入图片描述

2.获取当前进程编号

在这里插入图片描述

import multiprocessing
import time
import os


# 跳舞任务
def dance():
    # 获取当前进程的编号
    print("dance:", os.getpid())
    # 获取当前进程
    print("dance:", multiprocessing.current_process())
    for i in range(5):
        print("跳舞中...")
        time.sleep(0.2)
        # 扩展:根据进程编号杀死指定进程
        os.kill(os.getpid(), 9)


# 唱歌任务
def sing():
    # 获取当前进程的编号
    print("sing:", os.getpid())
    # 获取当前进程
    print("sing:", multiprocessing.current_process())
    for i in range(5):
        print("唱歌中...")
        time.sleep(0.2)


if __name__ == '__main__':

    # 获取当前进程的编号
    print("main:", os.getpid())
    # 获取当前进程
    print("main:", multiprocessing.current_process())
    # 创建跳舞的子进程
    # group: 表示进程组，目前只能使用None
    # target: 表示执行的目标任务名(函数名、方法名)
    # name: 进程名称, 默认是Process-1, .....
    dance_process = multiprocessing.Process(target=dance, name="myprocess1")
    sing_process = multiprocessing.Process(target=sing)

    # 启动子进程执行对应的任务
    dance_process.start()
    sing_process.start()

在这里插入图片描述

3.获取当前父进程编号

在这里插入图片描述

import multiprocessing
import time
import os


# 跳舞任务
def dance():
    # 获取当前进程的编号
    print("dance:", os.getpid())
    # 获取当前进程
    print("dance:", multiprocessing.current_process())
    # 获取父进程的编号
    print("dance的父进程编号:", os.getppid())
    for i in range(5):
        print("跳舞中...")
        time.sleep(0.2)
        # 扩展:根据进程编号杀死指定进程
        os.kill(os.getpid(), 9)


# 唱歌任务
def sing():
    # 获取当前进程的编号
    print("sing:", os.getpid())
    # 获取当前进程
    print("sing:", multiprocessing.current_process())
    # 获取父进程的编号
    print("sing的父进程编号:", os.getppid())
    for i in range(5):
        print("唱歌中...")
        time.sleep(0.2)


if __name__ == '__main__':

    # 获取当前进程的编号
    print("main:", os.getpid())
    # 获取当前进程
    print("main:", multiprocessing.current_process())
    # 创建跳舞的子进程
    # group: 表示进程组，目前只能使用None
    # target: 表示执行的目标任务名(函数名、方法名)
    # name: 进程名称, 默认是Process-1, .....
    dance_process = multiprocessing.Process(target=dance, name="myprocess1")
    sing_process = multiprocessing.Process(target=sing)

    # 启动子进程执行对应的任务
    dance_process.start()
    sing_process.start()

在这里插入图片描述

4.小结

在这里插入图片描述

五、进程执行带有参数的任务

1.进程执行带有参数的任务的介绍

在这里插入图片描述

2.args参数的使用

示例代码:

import multiprocessing
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子进程
    # args: 以元组的方式给任务传入参数
    sub_process = multiprocessing.Process(target=task, args=(5,))
    sub_process.start()

在这里插入图片描述

3.kwargs参数的使用

示例代码:

import multiprocessing
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子进程

    # kwargs: 表示以字典方式传入参数
    sub_process = multiprocessing.Process(target=task, kwargs={"count": 3})
    sub_process.start()

在这里插入图片描述

4.小结

在这里插入图片描述

六、进程的注意点

1.进程的注意点介绍

在这里插入图片描述

2.进程之间不共享全局变量

import multiprocessing
import time

# 定义全局变量
g_list = list()


# 添加数据的任务
def add_data():
    for i in range(5):
        g_list.append(i)
        print("add:", i)
        time.sleep(0.2)

    # 代码执行到此，说明数据添加完成
    print("add_data:", g_list)


def read_data():
    print("read_data", g_list)


if __name__ == '__main__':
    # 创建添加数据的子进程
    add_data_process = multiprocessing.Process(target=add_data)
    # 创建读取数据的子进程
    read_data_process = multiprocessing.Process(target=read_data)

    # 启动子进程执行对应的任务
    add_data_process.start()
    # 主进程等待添加数据的子进程执行完成以后程序再继续往下执行，读取数据
    add_data_process.join()
    read_data_process.start()

    print("main:", g_list)

    # 总结: 多进程之间不共享全局变量

在这里插入图片描述
在这里插入图片描述

3.进程之间不共享全局变量的小结

在这里插入图片描述

4.主进程会等待所有的子进程执行结束再结束

在这里插入图片描述

import multiprocessing
import time


# 定义进程所需要执行的任务
def task():
    for i in range(10):
        print("任务执行中...")
        time.sleep(0.2)

if __name__ == '__main__':
    # 创建子进程
    sub_process = multiprocessing.Process(target=task)
    sub_process.start()

    # 主进程延时0.5秒钟
    time.sleep(0.5)
    print("over")
    exit()

    # 总结： 主进程会等待所有的子进程执行完成以后程序再退出

在这里插入图片描述
在这里插入图片描述
保证主进程正常退出的示例代码:

import multiprocessing
import time


# 定义进程所需要执行的任务
def task():
    for i in range(10):
        print("任务执行中...")
        time.sleep(0.2)

if __name__ == '__main__':
    # 创建子进程
    sub_process = multiprocessing.Process(target=task)
    # 设置守护主进程，主进程退出子进程直接销毁，子进程的生命周期依赖与主进程
    # sub_process.daemon = True
    sub_process.start()

    time.sleep(0.5)
    print("over")
    # 让子进程销毁
    sub_process.terminate()
    exit()

    # 总结： 主进程会等待所有的子进程执行完成以后程序再退出
    # 如果想要主进程退出子进程销毁，可以设置守护主进程或者在主进程退出之前让子进程销毁

在这里插入图片描述

5.主进程会等待所有的子进程执行结束再结束的小结

在这里插入图片描述

七、线程

1.线程的介绍

在Python中，想要实现多任务除了使用进程，还可以使用线程来完成，线程是实现多任务的另外一种方式。

2.线程的概念

在这里插入图片描述

3.线程的作用

在这里插入图片描述

4.小结

在这里插入图片描述

八、多线程的使用

1.导入线程模块

在这里插入图片描述

2.线程类Thread参数说明

在这里插入图片描述

3.启动线程

启动线程使用start方法

4.多线程完成多任务的代码

import threading
import time

# 唱歌任务
def sing():
    # 扩展： 获取当前线程
    # print("sing当前执行的线程为：", threading.current_thread())
    for i in range(3):
        print("正在唱歌...%d" % i)
        time.sleep(1)

# 跳舞任务
def dance():
    # 扩展： 获取当前线程
    # print("dance当前执行的线程为：", threading.current_thread())
    for i in range(3):
        print("正在跳舞...%d" % i)
        time.sleep(1)


if __name__ == '__main__':
    # 扩展： 获取当前线程
    # print("当前执行的线程为：", threading.current_thread())
    # 创建唱歌的线程
    # target： 线程执行的函数名
    sing_thread = threading.Thread(target=sing)

    # 创建跳舞的线程
    dance_thread = threading.Thread(target=dance)

    # 开启线程
    sing_thread.start()
    dance_thread.start()

在这里插入图片描述

5.小结

在这里插入图片描述

九、线程执行带有参数的任务

1.线程执行带有参数的任务的介绍

在这里插入图片描述

2.args参数的使用

示例代码:

import threading
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子线程
    # args: 以元组的方式给任务传入参数
    sub_thread = threading.Thread(target=task, args=(5,))
    sub_thread.start()

在这里插入图片描述

3.kwargs参数的使用

示例代码:

import threading
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子线程
    # kwargs: 表示以字典方式传入参数
    sub_thread = threading.Thread(target=task, kwargs={"count": 3})
    sub_thread.start()

在这里插入图片描述

4.小结

在这里插入图片描述

十、线程的注意点

1.线程的注意点介绍

在这里插入图片描述

2.线程之间执行是无序的

import threading
import time


def task():
    time.sleep(1)
    print("当前线程:", threading.current_thread().name)


if __name__ == '__main__':

   for _ in range(5):
       sub_thread = threading.Thread(target=task)
       sub_thread.start()

在这里插入图片描述

3.主线程会等待所有的子线程执行结束再结束

假如我们现在创建一个子线程，这个子线程执行完大概需要2.5秒钟，现在让主线程执行1秒钟就退出程序，查看一下执行结果，示例代码如下:

import threading
import time


# 测试主线程是否会等待子线程执行完成以后程序再退出
def show_info():
    for i in range(5):
        print("test:", i)
        time.sleep(0.5)


if __name__ == '__main__':
    sub_thread = threading.Thread(target=show_info)
    sub_thread.start()

    # 主线程延时1秒
    time.sleep(1)
    print("over")

在这里插入图片描述
在这里插入图片描述
设置守护主线程的示例代码:

import threading
import time


# 测试主线程是否会等待子线程执行完成以后程序再退出
def show_info():
    for i in range(5):
        print("test:", i)
        time.sleep(0.5)


if __name__ == '__main__':
    # 创建子线程守护主线程 
    # daemon=True 守护主线程
    # 守护主线程方式1
    sub_thread = threading.Thread(target=show_info, daemon=True)
    # 设置成为守护主线程，主线程退出后子线程直接销毁不再执行子线程的代码
    # 守护主线程方式2
    # sub_thread.setDaemon(True)
    sub_thread.start()

    # 主线程延时1秒
    time.sleep(1)
    print("over")

在这里插入图片描述

4.线程之间共享全局变量

在这里插入图片描述

import threading
import time


# 定义全局变量
my_list = list()

# 写入数据任务
def write_data():
    for i in range(5):
        my_list.append(i)
        time.sleep(0.1)
    print("write_data:", my_list)


# 读取数据任务
def read_data():
    print("read_data:", my_list)


if __name__ == '__main__':
    # 创建写入数据的线程
    write_thread = threading.Thread(target=write_data)
    # 创建读取数据的线程
    read_thread = threading.Thread(target=read_data)

    write_thread.start()
    # 延时
    # time.sleep(1)
    # 主线程等待写入线程执行完成以后代码在继续往下执行
    write_thread.join()
    print("开始读取数据啦")
    read_thread.start()

在这里插入图片描述

5.线程之间共享全局变量数据出现错误问题

在这里插入图片描述

import threading

# 定义全局变量
g_num = 0


# 循环一次给全局变量加1
def sum_num1():
    for i in range(1000000):
        global g_num
        g_num += 1

    print("sum1:", g_num)


# 循环一次给全局变量加1
def sum_num2():
    for i in range(1000000):
        global g_num
        g_num += 1
    print("sum2:", g_num)


if __name__ == '__main__':
    # 创建两个线程
    first_thread = threading.Thread(target=sum_num1)
    second_thread = threading.Thread(target=sum_num2)

    # 启动线程
    first_thread.start()
    # 启动线程
    second_thread.start()

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
线程等待的示例代码:

import threading

# 定义全局变量
g_num = 0


# 循环1000000次每次给全局变量加1
def sum_num1():
    for i in range(1000000):
        global g_num
        g_num += 1

    print("sum1:", g_num)


# 循环1000000次每次给全局变量加1
def sum_num2():
    for i in range(1000000):
        global g_num
        g_num += 1
    print("sum2:", g_num)


if __name__ == '__main__':
    # 创建两个线程
    first_thread = threading.Thread(target=sum_num1)
    second_thread = threading.Thread(target=sum_num2)

    # 启动线程
    first_thread.start()
    # 主线程等待第一个线程执行完成以后代码再继续执行，让其执行第二个线程
    # 线程同步： 一个任务执行完成以后另外一个任务才能执行，同一个时刻只有一个任务在执行
    first_thread.join()
    # 启动线程
    second_thread.start()

在这里插入图片描述

6.小结

在这里插入图片描述

十一、互斥锁

1.互斥锁的概念

在这里插入图片描述

2.互斥锁的使用

在这里插入图片描述

3.使用互斥锁完成2个线程对同一个全局变量各加100万次的操作

import threading


# 定义全局变量
g_num = 0

# 创建全局互斥锁
lock = threading.Lock()


# 循环一次给全局变量加1
def sum_num1():
    # 上锁
    lock.acquire()
    for i in range(1000000):
        global g_num
        g_num += 1

    print("sum1:", g_num)
    # 释放锁
    lock.release()


# 循环一次给全局变量加1
def sum_num2():
    # 上锁
    lock.acquire()
    for i in range(1000000):
        global g_num
        g_num += 1
    print("sum2:", g_num)
    # 释放锁
    lock.release()


if __name__ == '__main__':
    # 创建两个线程
    first_thread = threading.Thread(target=sum_num1)
    second_thread = threading.Thread(target=sum_num2)
    # 启动线程
    first_thread.start()
    second_thread.start()

    # 提示：加上互斥锁，那个线程抢到这个锁我们决定不了，那线程抢到锁那个线程先执行，没有抢到的线程需要等待
    # 加上互斥锁多任务瞬间变成单任务，性能会下降，也就是说同一时刻只能有一个线程去执行

在这里插入图片描述

4.小结

在这里插入图片描述

十二、死锁

1.死锁的概念

在这里插入图片描述

2.死锁示例

在这里插入图片描述

import threading
import time

# 创建互斥锁
lock = threading.Lock()


# 根据下标去取值， 保证同一时刻只能有一个线程去取值
def get_value(index):

    # 上锁
    lock.acquire()
    print(threading.current_thread())
    my_list = [3,6,8,1]
    # 判断下标释放越界
    if index >= len(my_list):
        print("下标越界:", index)
        return
    value = my_list[index]
    print(value)
    time.sleep(0.2)
    # 释放锁
    lock.release()


if __name__ == '__main__':
    # 模拟大量线程去执行取值操作
    for i in range(30):
        sub_thread = threading.Thread(target=get_value, args=(i,))
        sub_thread.start()

3.避免死锁

在合适的地方释放锁

import threading
import time

# 创建互斥锁
lock = threading.Lock()


# 根据下标去取值， 保证同一时刻只能有一个线程去取值
def get_value(index):

    # 上锁
    lock.acquire()
    print(threading.current_thread())
    my_list = [3,6,8,1]
    if index >= len(my_list):
        print("下标越界:", index)
        # 当下标越界需要释放锁，让后面的线程还可以取值
        lock.release()
        return
    value = my_list[index]
    print(value)
    time.sleep(0.2)
    # 释放锁
    lock.release()


if __name__ == '__main__':
    # 模拟大量线程去执行取值操作
    for i in range(30):
        sub_thread = threading.Thread(target=get_value, args=(i,))
        sub_thread.start()

4.小结

在这里插入图片描述

十三、进程和线程的对比

1.进程和线程的对比的三个方向

在这里插入图片描述

2.关系对比

在这里插入图片描述

3.区别对比

在这里插入图片描述

4.优缺点对比

在这里插入图片描述

5.小结

在这里插入图片描述

十四、协程

协程，又称微线程，纤程。英文名Coroutine。

1.协程是啥

在这里插入图片描述

2.协程的优点

在这里插入图片描述

3.gevent

在这里插入图片描述
在这里插入图片描述

gevent的使用

在这里插入图片描述
在这里插入图片描述

gevent切换执行

在这里插入图片描述
在这里插入图片描述

给程序打补丁

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

xiaotai1234
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
python多任务编程
qq_40102768的博客
07-22 299
一.多任务编程 1.什么是多任务编程 多任务编程简单来说就是操作系统可以同时运行多个任务。 2.单核cpu如何实现多任务编程 操作系统轮流让各个任务交替执⾏，每个任务执⾏0.01秒，这样反复执⾏下去。 表⾯上看，每个任务交替执⾏，但CPU的执⾏速度实在是太快了，感觉就像所有任务都在同时执⾏⼀样。 3.多核cpu如何实现多任务编程 真正的并⾏执⾏多任务只能在多核CPU上实现，但是，由于任务数量远...
Python多任务编程
m0_60121089的博客
11-19 664
1.进程（Process）是资源分配的最小单位。2.多进程是Python程序中实现多任务的一种方式，使用多进程可以大大提高程序的执行效率。1.多线程是Python程序中实现多任务的一种方式。2.线程是程序执行的最小单位。3.同属一个进程的多个线程共享进程所拥有的全部资源。
2024年python中的多任务编程(1)，2024年最新阿里面试 在线编程
m0_61549674的博客
05-09 755
print(“任务执行中…”)ifname== ‘mainprint(“任务执行中…”)ifname== ‘main七、线程在Python中，想要实现多任务除了使用进程，还可以使用线程来完成，线程是实现多任务的另外一种方式。print(“当前线程:”, threading.current_thread().name)ifname== ‘main’:g_num = 0。
python高级之多任务编程
11-17
python学习之多任务线程的使用，和一些基本的使用方法
python---多任务编程
Wangtuo1115的博客
02-06 443
文章目录一、多任务编程1、什么叫“多任务”？2、单核CPU如何实现“多任务”？3、多核CPU如何实现“多任务”？二、多进程编程1、进程的创建2、多进程编程3、进程池4、进程间通信三、多线程编程1、多线程编程2、什么是线程？3、线程和进程各自有什么区别和优劣呢？4、线程分类5、多线程编程6、线程的几种状态7、共享全局变量8、线程同步9、死锁四、协程gevent实现协程 一、多任务编程 1、什么叫“多...
基于Python的多进程编程
07-31
进程是自愿分配的基本单元，线程是CPU执行和调度的基本单位。进程之间的数据是独立的，同一个进程中的所有线程中的数据是共享的。...多进程编程同时运行了多个任务，并发执行的时间比单进程顺序执行要快。
python多线程编程.rar
06-10
Python多线程编程是Python系统编程中的重要组成部分，它允许程序同时执行多个任务，从而提高程序的效率和响应速度。在Python中，我们通常使用内置的`thread`库、`threading`库以及`Queue`库来实现多线程。 首先，`...
核桃编程python课程体系.docx
06-13
多线程编程则可以让程序并行执行任务，提高效率；数据库编程则可以帮助学习者存储和管理大量数据，构建复杂的数据库应用程序。例如，学习者可以设计一个带有图形界面的棋盘游戏，或者创建一个能够处理大量用户数据的...
python编程，python编程入门
03-08
Python编程是现代软件开发领域中最受欢迎的编程语言之一，尤其对于初学者来说，它具有简洁易懂的语法和丰富的库支持。"Python编程入门"旨在引导新手逐步掌握Python的基础知识和核心概念。以下是对压缩包文件中各部分...
python_多任务编程
zd_blog
02-04 257
在同一时间内执行多个任务，充分利用CPU资源，提高程序的执行效率
python-多任务编程
最新发布
是程序喵呀
07-19 845
多任务即操作系统中可以同时运行多个任务。比如我们可以同时挂着qq，听音乐，同时上网浏览网页。这是我们看得到的任务，在系统中还有很多系统任务在执行,现在的操作系统基本都是多任务操作系统，具备运行多任务的能力。计算机原理CPU：计算机硬件的核心部件，用于对任务进行执行运算。操作系统调用CPU执行任务cpu轮询机制 ： cpu都在多个任务之间快速的切换执行，切换速度在微秒级别，其实cpu同时只执行一个任务，但是因为切换太快了，从应用层看好像所有任务同时在执行。
【Python进阶】多任务编程（超详细）
风口IT猪的成长录
09-02 1150
Python 多任务编程1. 多任务的介绍2. 进程3. 多进程的使用4. 获取进程编号5. 进程执行带有参数的任务6. 进程的注意点7. 线程8. 多线程的使用9. 线程执行带有参数的任务10. 线程的注意点11. 互斥锁12. 死锁13. 进程和线程的对比 1. 多任务的介绍 1. 提问 利用现学知识能够让两个函数或者方法同时执行吗? 不能，因为之前所写的程序都是单任务的，也就是说一个函数或者方法执行完成另外一个函数或者方法才能执行，要想实现这种操作就需要使用多任务。 多任务的最大好处是充分利用CPU资
Python_多任务编程
C_teacher的博客
02-13 247
文章目录多任务编程什么是多任务编程？单核CPU如何实现“多任务”呢？多核CPU如何实现“多任务”呢？多进程编程进程的五状态模型创建子进程多进程修改全局变量多进程编程进程池的使用进程间通信多线程编程共享全局变量线程同步协程总结 多任务编程 什么是多任务编程？ 就是操作系统可以同时运⾏多个任务。打个 ⽐⽅，你⼀边在⽤浏览器上⽹，⼀边在听MP3，⼀边在⽤Word赶作业，这就是多任务，⾄少同时有3个任务正...
python多任务编程（进程与线程）
HHYZBC的博客
04-01 1102
多任务的概念 简单说就是在同一时间内执行多个任务，现在主流的操作系统都满足这个。也叫做多任务操作系统。 多任务的执行方式 一共有两种。分别是并发和并行 并发 是在一段时间内交替执行任务，因为速度过快，所以肉眼上看是在同时执行，但是这种执行方式多在单核cpu中。现在也被淘汰掉了，只需要了解即可。 并行 是真正意义上的同时执行，现在的双核及以上都是这种执行方式。简单说就是这个核执行一个任务，另一个核执行另一个任务，从而达到同时执行多个任务的效果。 进程和线程概念 进程是操作系统进行资源分配时的
python的多任务编程实现
Pinkmanabcd的博客
07-12 165
多进程编程 import os pid = os.fork() 功能：创建新的进程 参数：无 返回值：失败返回一个负数 成功：在原有进程中返回新的进程的PID号 在新的进程中返回0 fork函数演示于进程的特征 一般情况下父进程在子进程之前运行 #此程序演示多进程编程中fork函数以及进程的特征 import os from time import slee...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值