《利用python进行数据分析》第二版 第12章-高阶pandas 学习笔记

于 2021-06-26 18:42:55 发布
阅读量255 收藏
点赞数
文章标签： python 数据分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KikuWong/article/details/118253036
版权

文章目录

一、分类数据

  • 本节学习 pandas 的 Categorical 类型，学习在使用 pandas 进行某些操作时如何获取更好的性能和内存使用，及一些在统计和机器学习中使用分类数据的工具。

背景和目标

  • 一个列经常会包含重复值，这些重复值是一个小型的不同值的集合，unique 和 value_counts 函数可从一个数组中提取不同值并分别计算这些不同值的频率
  • 为了提高性能，用分类的方法（或者称为字典编码）来呈现数据，即用编码的方法将数据以整数的方式呈现；同时，存在一个类别（或字典）保存了数值所代表的含义
import numpy as np
import pandas as pd

values = pd.Series(['apple', 'orange', 'apple', 'apple'] * 2)
values
'''
0     apple
1    orange
2     apple
3     apple
4     apple
5    orange
6     apple
7     apple
dtype: object
'''

# 查看values列有哪些不同的值
pd.unique(values)
'''array(['apple', 'orange'], dtype=object)'''

# 为values列不同的值计数
pd.value_counts(values)

'''
apple     6
orange    2
dtype: int64
'''

# 用重复的值表示数据
# 将主要观测值存储为引用维度表的整数键
values = pd.Series([0, 1, 0, 0] * 2)
values
# 数据的类别、字典/层级
'''
0    0
1    1
2    0
3    0
4    0
5    1
6    0
7    0
dtype: int64
'''

dim = pd.Series(['apple', 'orange'])
dim
'''
0     apple
1    orange
dtype: object
'''

# 分类数据和类别均为Series，在类别上用take方法，传入分类数据，即可还原原始数据
# 用take方法恢复原来的字符串Series
dim.take(values)
'''
0     apple
1    orange
0     apple
0     apple
0     apple
1    orange
0     apple
0     apple
dtype: object
'''

pandas 中的 Categorical 类型

pandas 拥有特殊的 Categorical 类型，用于承载基于整数的类别展示或编码的数据，

astype()方法将Series的值转换为Categorical对象

fruits = ['apple', 'orange', 'apple', 'apple'] * 2
N = len(fruits)
df = pd.DataFrame({'fruit': fruits,
                   'basket_id': np.arange(N),
                   'count': np.random.randint(3, 15, size=N),
                   'weight': np.random.uniform(0, 4, size=N)},
                  columns=['basket_id', 'fruit', 'count', 'weight'])
df
basket_idfruitcountweight
00apple53.858058
11orange82.612708
22apple42.995627
33apple72.614279
44apple122.990859
55orange83.845227
66apple50.033553
77apple40.425778
# 用astype('category')将fruit水果列数据类型dtype设置为category，原来为object
fruit_cat = df['fruit'].astype('category')
fruit_cat
'''
0     apple
1    orange
2     apple
3     apple
4     apple
5    orange
6     apple
7     apple
Name: fruit, dtype: category
Categories (2, object): ['apple', 'orange']
'''

# 得到的为pandas.Categorical实例
c = fruit_cat.values
type(c)
'''pandas.core.arrays.categorical.Categorical'''

# 参看Categorical对象的类别Categorical.categories
c.categories
'''Index(['apple', 'orange'], dtype='object')'''

c.codes
'''array([0, 1, 0, 0, 0, 1, 0, 0], dtype=int8)'''

# 更改原DataFrmae中fruit列的类别为Categorical
df['fruit'] = df['fruit'].astype('category')
df.fruit
'''
0     apple
1    orange
2     apple
3     apple
4     apple
5    orange
6     apple
7     apple
Name: fruit, dtype: category
Categories (2, object): ['apple', 'orange']
'''

用pd.Categorical()直接从其他python序列生成Categorical对象

# 用pd.Categorical()直接从其他python序列生成Categorical对象
my_categories = pd.Categorical(['foo', 'bar', 'baz', 'foo', 'bar'])
my_categories
'''
['foo', 'bar', 'baz', 'foo', 'bar']
Categories (3, object): ['bar', 'baz', 'foo']
'''

在已经获得分类编码数据时，用pd.Categorical.from_codes()构造函数

# 在已经获得分类编码数据时，用pd.Categorical.from_codes()构造函数
categories = ['foo', 'bar', 'baz']
codes = [0, 1, 2, 0, 0, 1]
my_cats_2 = pd.Categorical.from_codes(codes, categories)
my_cats_2
'''
['foo', 'bar', 'baz', 'foo', 'foo', 'bar']
Categories (3, object): ['foo', 'bar', 'baz']
'''
  • 默认情况下，分类转换没有指定类别的顺序，因此 categories 数组可能和输入的顺序不同，在使用 from_codes 或其他任意构造函数时，通过传递 ordered=True 来严格指定顺序
  • 一个未排序的分类实例可用 as_ordered() 方法进行排序
ordered_cat = pd.Categorical.from_codes(codes, categories,
                                        ordered=True)
ordered_cat
'''
['foo', 'bar', 'baz', 'foo', 'foo', 'bar']
Categories (3, object): ['foo' < 'bar' < 'baz']
'''

# 对未排序的分类实例使用as_ordered()排序
my_cats_2.as_ordered()
'''
['foo', 'bar', 'baz', 'foo', 'foo', 'bar']
Categories (3, object): ['foo' < 'bar' < 'baz']
'''

使用 Categorical 对象进行计算

np.random.seed(12345)
draws = np.random.randn(1000)
draws[:5]
'''array([-0.2047,  0.4789, -0.5194, -0.5557,  1.9658])'''

# 计算1000个随机数字的四分位分箱
bins = pd.qcut(draws, 4)
bins
'''
[(-0.684, -0.0101], (-0.0101, 0.63], (-0.684, -0.0101], (-0.684, -0.0101], (0.63, 3.928], ..., (-0.0101, 0.63], (-0.684, -0.0101], (-2.9499999999999997, -0.684], (-0.0101, 0.63], (0.63, 3.928]]
Length: 1000
Categories (4, interval[float64]): [(-2.9499999999999997, -0.684] < (-0.684, -0.0101] < (-0.0101, 0.63] < (0.63, 3.928]]
'''

# 使用label添加四分位数名称
bins = pd.qcut(draws, 4, labels=['Q1', 'Q2', 'Q3', 'Q4'])
bins
'''
['Q2', 'Q3', 'Q2', 'Q2', 'Q4', ..., 'Q3', 'Q2', 'Q1', 'Q3', 'Q4']
Length: 1000
Categories (4, object): ['Q1' < 'Q2' < 'Q3' < 'Q4']
'''

bins.codes[:10]
'''array([1, 2, 1, 1, 3, 3, 2, 2, 3, 3], dtype=int8)'''

# 用 groupby 提取汇总统计值
bins = pd.Series(bins, name='quartile')
results = (pd.Series(draws).groupby(bins).agg(['count', 'min', 'max']).reset_index())
results
quartilecountminmax
0Q1250-2.949343-0.685484
1Q2250-0.683066-0.010115
2Q3250-0.0100320.628894
3Q42500.6342383.927528
# 结果中'quartile'列保留了bins中原始的分类信息，包括顺序
results['quartile']
'''
0    Q1
1    Q2
2    Q3
3    Q4
Name: quartile, dtype: category
Categories (4, object): ['Q1' < 'Q2' < 'Q3' < 'Q4']
'''

数据量比较大时，使用分类能够获得更好的性能

N = 10000000
draws = pd.Series(np.random.randn(N))
labels = pd.Series(['foo', 'bar', 'baz', 'qux'] * (N // 4))

categories = labels.astype('category')

# dtype: objects占用的内存
labels.memory_usage()
'''80000128'''

# dtype: category占用的内存
categories.memory_usage()
'''10000320'''

# 分类转换耗时
%time _ = labels.astype('category')
'''Wall time: 988 ms'''

分类方法

pandas 中 Series 的分类方法：涉及对Categorical 类型的增删改及重命名、排序

方法(Series.cat.)描述
add_categories将新的类别（未使用过的）添加到已有类别的尾部
as_ordered对类别排序
as_unordered使类别无序
remove_categories去除类别，将被移除的值置为 null
remove_unused_categories去除所有没有出现在数据中的类别
rename_categories使用新的类别名称替代现有的类别，不会改变类别的数量
reorder_categories与 rename_categories 类似，但结果是经过排序的类别
set_categories用指定的一组新类别替换现有类别，可以添加或删除类别
s = pd.Series(['a', 'b', 'c', 'd'] * 2)
cat_s = s.astype('category')
cat_s
'''
0    a
1    b
2    c
3    d
4    a
5    b
6    c
7    d
dtype: category
Categories (4, object): ['a', 'b', 'c', 'd']
'''

cat_s.cat.codes
'''
0    0
1    1
2    2
3    3
4    0
5    1
6    2
7    3
dtype: int8
'''

# 用属性categories查看有哪些分类
cat_s.cat.categories
'''
Index(['a', 'b', 'c', 'd'], dtype='object')
'''

# 用set_categories()重新设置分类
actual_categories = ['a', 'b', 'c', 'd', 'e']
cat_s2 = cat_s.cat.set_categories(actual_categories)
cat_s2
'''
0    a
1    b
2    c
3    d
4    a
5    b
6    c
7    d
dtype: category
Categories (5, object): ['a', 'b', 'c', 'd', 'e']
'''

# 以上结果看起来并未改变，雇佣value_counts()验证

cat_s.value_counts()
'''
d    2
c    2
b    2
a    2
dtype: int64
'''

cat_s2.value_counts()
'''
d    2
c    2
b    2
a    2
e    0
dtype: int64
'''

# 对于cat_s3类别c、d并没有出现在结果中
# 可用remove_unused_categories()去除未使用的类别
cat_s3 = cat_s[cat_s.isin(['a', 'b'])]
cat_s3
'''
0    a
1    b
4    a
5    b
dtype: category
Categories (4, object): ['a', 'b', 'c', 'd']
'''

cat_s3.cat.remove_unused_categories()
'''
0    a
1    b
4    a
5    b
dtype: category
Categories (2, object): ['a', 'b']
'''

创建用于建模的虚拟变量

  • 在用统计数据或机器学习工具时，通常会将分类数据转换为虚拟变量，也称为 one-hot 编码
  • pandas.get_dummies() 函数将一维的分类数据转换为一个包含虚拟变量的 DataFrame，每个不同的类别都是它的一列，这些列包含特定类别的出现次数，否则为 0
cat_s
'''
0    a
1    b
2    c
3    d
4    a
5    b
6    c
7    d
dtype: category
Categories (4, object): ['a', 'b', 'c', 'd']
'''

cat_s = pd.Series(['a', 'b', 'c', 'd'] * 2, dtype='category')
pd.get_dummies(cat_s)
abcd
01000
10100
20010
30001
41000
50100
60010
70001

二、高阶GroupBy应用

分组转换和 “展开” GroupBy

GroupBy的transform()方法，与apply 类似；但对可以使用的函数种类有更多的限制：

  • transform 可以产生一个标量值，并广播到各分组的尺寸数据中，即结果的shape与原shape相同
  • transform 可以产生一个与输入分组尺寸相同的对象
  • transform 不可改变它的输入
df = pd.DataFrame({'key': ['a', 'b', 'c'] * 4,
                   'value': np.arange(12.)})
df
keyvalue
0a0.0
1b1.0
2c2.0
3a3.0
4b4.0
5c5.0
6a6.0
7b7.0
8c8.0
9a9.0
10b10.0
11c11.0
# 按key分类后value的均值
g = df.groupby('key').value
g.mean()
'''key
a    4.5
b    5.5
c    6.5
Name: value, dtype: float64'''

# 用transform()，传入匿名函数，
# 可得到一个尺寸和df[‘value’]一样，但值都被按‘key’分组的均值替代的 Series
# 即transform()返回标量值会分别广播道对应的组
g.transform(lambda x: x.mean())
'''
0     4.5
1     5.5
2     6.5
3     4.5
4     5.5
5     6.5
6     4.5
7     5.5
8     6.5
9     4.5
10    5.5
11    6.5
Name: value, dtype: float64
'''

# 用transform()，传入字符串别名（仅针对内建的聚合函数）,
# 可得到一个尺寸和df[‘value’]一样，但值都被按‘key’分组的均值替代的 Series
g.transform('mean')
'''
0     4.5
1     5.5
2     6.5
3     4.5
4     5.5
5     6.5
6     4.5
7     5.5
8     6.5
9     4.5
10    5.5
11    6.5
Name: value, dtype: float64
'''

# 与apply类似，transform可与返回series的函数一起使用，但结果必须和输入有相同的大小
g.transform(lambda x: x * 2)
'''
0      0.0
1      2.0
2      4.0
3      6.0
4      8.0
5     10.0
6     12.0
7     14.0
8     16.0
9     18.0
10    20.0
11    22.0
Name: value, dtype: float64
'''

g.transform(lambda x: x.rank(ascending=False))
'''
0     4.0
1     4.0
2     4.0
3     3.0
4     3.0
5     3.0
6     2.0
7     2.0
8     2.0
9     1.0
10    1.0
11    1.0
Name: value, dtype: float64
'''

# 有简单聚合构成的分组转换函数传递给transform()/apply()结果等价
def normalize(x):
    return (x - x.mean()) / x.std()

g.apply(normalize)
'''
0    -1.161895
1    -1.161895
2    -1.161895
3    -0.387298
4    -0.387298
5    -0.387298
6     0.387298
7     0.387298
8     0.387298
9     1.161895
10    1.161895
11    1.161895
Name: value, dtype: float64
'''

# 但与apply()相比，transform()更快
g.transform(normalize)
'''
0    -1.161895
1    -1.161895
2    -1.161895
3    -0.387298
4    -0.387298
5    -0.387298
6     0.387298
7     0.387298
8     0.387298
9     1.161895
10    1.161895
11    1.161895
Name: value, dtype: float64
'''

normalized = (df['value'] - g.transform('mean')) / g.transform('std')
normalized
'''
0    -1.161895
1    -1.161895
2    -1.161895
3    -0.387298
4    -0.387298
5    -0.387298
6     0.387298
7     0.387298
8     0.387298
9     1.161895
10    1.161895
11    1.161895
Name: value, dtype: float64
'''

分组的时间重新采样

对时间序列数据，resample 方法在语义上是一种基于时间分段的分组操作。

N = 15
times = pd.date_range('2017-05-20 00:00', freq='1min', periods=N)
df = pd.DataFrame({'time': times,
                   'value': np.arange(N)})
df
timevalue
02017-05-20 00:00:000
12017-05-20 00:01:001
22017-05-20 00:02:002
32017-05-20 00:03:003
42017-05-20 00:04:004
52017-05-20 00:05:005
62017-05-20 00:06:006
72017-05-20 00:07:007
82017-05-20 00:08:008
92017-05-20 00:09:009
102017-05-20 00:10:0010
112017-05-20 00:11:0011
122017-05-20 00:12:0012
132017-05-20 00:13:0013
142017-05-20 00:14:0014
# 对df，按'time'进行索引，再进行5min重采样
df.set_index('time').resample('5min').count()
value
time
2017-05-20 00:00:005
2017-05-20 00:05:005
2017-05-20 00:10:005
# 同时包含'time'与分组键'key'
df2 = pd.DataFrame({'time': times.repeat(3),
                    'key': np.tile(['a', 'b', 'c'], N),
                    'value': np.arange(N * 3.)})
df2[:7]
timekeyvalue
02017-05-20 00:00:00a0.0
12017-05-20 00:00:00b1.0
22017-05-20 00:00:00c2.0
32017-05-20 00:01:00a3.0
42017-05-20 00:01:00b4.0
52017-05-20 00:01:00c5.0
62017-05-20 00:02:00a6.0
# pd.Grouper()对每个'key'值进行相同的重新采样，传递freq='5min'
# pd.Grouper()限制时间序列必须是Series或DataFrame
time_key = pd.Grouper(freq='5min')

resampled = (df2.set_index('time').groupby(['key', time_key]).sum())
resampled
value
keytime
a2017-05-20 00:00:0030.0
2017-05-20 00:05:00105.0
2017-05-20 00:10:00180.0
b2017-05-20 00:00:0035.0
2017-05-20 00:05:00110.0
2017-05-20 00:10:00185.0
c2017-05-20 00:00:0040.0
2017-05-20 00:05:00115.0
2017-05-20 00:10:00190.0
resampled.reset_index()
keytimevalue
0a2017-05-20 00:00:0030.0
1a2017-05-20 00:05:00105.0
2a2017-05-20 00:10:00180.0
3b2017-05-20 00:00:0035.0
4b2017-05-20 00:05:00110.0
5b2017-05-20 00:10:00185.0
6c2017-05-20 00:00:0040.0
7c2017-05-20 00:05:00115.0
8c2017-05-20 00:10:00190.0
KikuWong
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据分析之Pandas-详细版
m0_58468567的博客
01-23 1391
Pandas常用于爬虫之后的数据清洗，将数据处理干净，便于后续对数据进行可视化分析。
pandas里面dtype的string object
pfm685757的专栏
03-18 4096
今天写程序，遇到一个很有意思的情况 我的原始日志里，如果是下面这样的格式，第一行带字符开头。那么pandas read_csv读进来后，第一列的数据类型是object。 =>10000 E AUTO_JOB_CONTROL OK 91000 E INIT_BATCH ...
Python数据分析常用高阶函数大全
CDA数据分析师
10-09 281
作者 | CDA数据分析师 来源 | CDA数据科学研究院 map map(function,iterable,...) 第一个参数，是函数 第二个参数，是可迭代对象（列表、字符串等） map返回的是对可迭代对象里的每个元素进行函数运算的结果 例如： def fun(x): return x*3 l=[0,1,2,3,4,5] l_m=map(fun,l)...
python四大高阶函数_Python数据分析常用高阶函数大全
weixin_39913628的博客
11-20 252
作者 | CDA数据分析师来源 | CDA数据科学研究院mapmap(function,iterable,...)第一个参数，是函数第二个参数，是可迭代对象（列表、字符串等）map返回的是对可迭代对象里的每个元素进行函数运算的结果例如：def fun(x): return x*3l=[0,1,2,3,4,5]l_m=map(fun,l)print(list(l_m))原本是[0,1,2,3,...
高阶pandas : 分类数据
AI路漫漫
07-21 543
高阶pandas : 分类数据
Python学习笔记--皮大庆.pdf.zip
10-11
了解如何导入和使用标准库及第三方库，比如Numpy、Pandas用于数据分析，Matplotlib和Seaborn用于数据可视化。 8. **面向对象编程**：Python支持面向对象编程，包括类的定义、对象的创建和销毁、封装、继承、多态等...
《learning python》中文第四版的学习笔记，由纸值文档转换而来.zip
最新发布
02-21
《Learning Python》中文第四版的学习笔记是一份宝贵的资源，它为初学者和有经验的程序员提供了深入理解Python编程语言的机会。这本书由Mark Lutz撰写，是Python编程领域内的经典之作，其内容覆盖了Python的基础语法...
Python学习手册笔记.zip
09-19
14. **科学计算与数据分析**：NumPy、Pandas和Matplotlib等库，使得Python在科学计算和数据分析领域表现出色。 15. **Web开发**：Django和Flask是流行的Python Web框架，用于构建动态网站和API服务。 以上是Python...
python 学习笔记资料
01-23
13. **数据分析与科学计算**：NumPy、Pandas和Matplotlib等库使Python成为数据科学和分析的首选语言。学习如何处理和可视化数据是现代Python开发者的重要技能。 14. **自动化脚本**：Python是编写系统自动化脚本的...
Python基础学习笔记
03-13
另外，Python中的函数可以作为返回值，也可以作为其他函数的参数，这就是所谓的高阶函数特性。 模块化是Python的一大特点，通过import语句可以导入其他Python文件，实现代码的重用。每个Python文件都可以看作一个...
Categorical类型
qq_31385713的博客
06-27 8042
一 介绍 在数据中，一个列有可能会包含很多重复值，这时会对重复值进行分类。往往在使用过程中会通过unique、value_counts等函数对重复值进行唯一性的提取和重复个数的统计。而还有一类数据类型可以帮助统计对应的值和表示的键。这类数据在系统可以称为维度表，维度表包含了不同值，并将主要观测存储为引用维度的整数键。 可以通过如下例子进行展示，在例子代码中，这种按照整数展现的方式被称为分类或者字典编码展现。不同值的数组可以被称为数据的类别、字典或者层级。 import numpy as np import
pd.Categorical 用法
不死彡邪神的博客
05-29 9066
http://pandas.pydata.org/pandas-docs/stable/generated/pandas.Categorical.html    网址class pandas.Categorical（values，categories = None，ordered = None，dtype = None，fastpath = False ）[source]代表经典的R / S +时...
用python进行数据分析——第十二章.高阶pandas
逐梦er的博客
06-13 6563
文章目录一.分类数据1.1 背景和目标1.2 pandas中的Categorical类型1.3使用Categorical对象进行计算1.4分类方法二.高阶GroupBy应用2.1分组转换和'展开'GroupBy2.2分组的时间重新采样三.方法链技术3.1 pipe(管道)方法 一.分类数据 这一节介绍的是pandas的Categorical类型。我会向你展示通过使用它，提高性能和内存的使用率。我还会介绍一些在统计和机器学习中使用分类数据的工具。 1.1 背景和目标 表中的一列通常会有重复的包含不同值的小集合
pandas 中的分类数据pandas.Categorical
weixin_43213268的博客
04-06 1574
(1)pandas.Categorical（） pandas.Categorical(values, categories=None, ordered=None, dtype=None, fastpath=False) 参考文档 栗子: pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c']) 结果： [a, b, c, a, b, c] Categories...
pandas的两种数据类型：Series和DataFrame
热门推荐
进击的菜鸟
10-02 1万+
首先要明确pandas是做什么的，在确定是如何做的，通过哪些方式去做的？ pandas是做什么的？      Python Data Analysis Library 或 pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量能使我们快速便捷地处理数据的函数和...
pandas数据处理实践四（时间序列date_range、数据分箱cut、分组技术GroupBy）
进击的菜鸟
10-05 7802
时间序列： 关键函数 pandas.date_range（start = None，end = None，periods = None，freq = None，tz = None，normalize = False，name = None，closed = None，** kwargs ） 参数： start：str或datetime-like，可选 生成日期的...
pandas中的Categorical类型
liujingwei8610的专栏
06-25 1725
Categorical是python的pandas中对应分类变量的一种数据类型，与R中的因子型变量比较相似，例如性别、血型等等用于表示类别的变量都可以用其来表示。 Categorical可以进行排序操作，但不可以进行数值运算操作，其顺序 在其被定义的时候一同确定，而不是按照数字字母词法排序的顺序，其适用场景有如下： 1、具有少数几种可能取值并存在大量重复的字符串字段，利用Categorical类型对其转换后可有效节省内存 2、字段的排序规则特殊，不遵循词法顺序时，可以利用Categorical类型对其转换后
04-3 pandas 中 pd.Categorical用法
DayDayUp
11-01 6446
pandas.Categorical（values，categories = None，ordered = None，dtype = None，fastpath = False ）[source] 表示经典R / S-plus方式的分类变量 分类只能采用有限的，通常是固定数量的可能值（类别）。与统计分类变量相比，分类可能具有顺序，但数值运算（加法，除法，…）是不可能的。 分类的所有值都在类别或np...
pandas.Categorical（）函数的理解
weixin_43407190的博客
11-01 9763
pandas.Categorical（）函数的理解 pandas.Categorical（values，categories = None，ordered = None，dtype = None ） 首先看看官方的参数解释： values list-likeThe values of the categorical. If categories are given, values not ...
利用Python进行数据分析_第二版中文1: pandas数据分析实战指南
《利用Python进行数据分析_第二版》是一本关于数据分析和数据科学的书籍，作者于2008年初开始开发pandas，当时任职于AQRCapitalManagement，一家量化投资管理公司。由于许多业务需求无法用现有的工具解决，作者开始...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值