Python基础+数据科学入门（三）组合数据类型

最新推荐文章于 2022-11-25 10:32:01 发布
最新推荐文章于 2022-11-25 10:32:01 发布
阅读量283 收藏
点赞数 1
分类专栏： python基础（数据学科入门） 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38425288/article/details/103956674
版权

声明：该博客参考深度之眼的视频课程，如有侵权请联系小编删除博文，谢谢！ 若总结有所失误，还请见谅，并欢迎及时指出。

组合数据类型

在这里插入图片描述

1.1 列表

1.1.1 列表的表达

列表类型：内部元素有位置关系，能通过位置序号访问其中元素
列表是一个可以使用多种类型元素，支持元素的增、删、查、改操作的序列类型

ls = ["Python",1989,True,{"version":3.7}]
ls   #结果：['Python', 1989, True, {'version': 3.7}]

另一种产生方式：list（可迭代对象）
可迭代对象包括：字符串、元组、集合、rang()等

#字符串转列表
list("人工智能是未来的趋势")  #运行结果 ['人', '工', '智', '能', '是', '未', '来', '的', '趋', '势']

#元组转列表
list(("我","们","很","像"))  #运行结果 ['我', '们', '很', '像']

#集合转列表
list({"李雷","韩梅梅","Jim","Green"}) #运行结果 ['李雷', 'Jim', 'Green', '韩梅梅']

#特殊的range()
for i in [0,1,2]:
    print(i)         #输出 0 1 2
for i in range(3):
    print(i)        #输出 0 1 2
# range(起始数字，终止数字，数字间隔)  如果起始数字缺省，默认为0    数字间隔缺省。默认为1

#range()转列表
list(range(1,6,2))  #输出结果 [1, 3, 5]
1.1.2 列表的性质

列表的长度——len(列表)

ls = [1,2,3,4,5]
len(ls)   #输出结果 5

列表的索引——与同为序列类型的字符串完全相同

#变量名[位置编号]
#正向索引从0开始  反向索引从-1开始
cars = ["BYD","BWM","AUDI","TOTOTA"]
print(cars[0])  #输出结果 BYD
print(cars[1])  #输出结果 BWM

#列表的切片
#变量名[开始位置：结束位置：切片间隔]
print(cars[:3])  #开始位置缺省，默认为0；切片间隔缺省，默认为1  结果 ['BYD', 'BWM', 'AUDI']
print(cars[1:4:2])  #第二个到第四个元素 前后索引差为2   结果 ['BWM', 'TOTOTA']
print(cars[:])      #获取整个列表，结束位置缺省，默认取到最后   结果 ['BYD', 'BWM', 'AUDI', 'TOTOTA']
print(cars[-4:-2])  #获取前两个元素   结果 ['BYD', 'BWM']

#反向切片
print(cars[:-4:-1])  #开始位置缺省，默认为-1   结果 ['TOTOTA', 'AUDI', 'BWM']
print(cars[::-1])    #获得反向列表   结果 ['TOTOTA', 'AUDI', 'BWM', 'BYD']
1.1.3 列表的操作符
# 用list1+list2的形式实现列表的拼接
a = [1,2]
b = [2,3]
a+b      #该用法用的不多 结果 [1, 2, 2, 3]

#用n*list 或 list*n 实现列表的成倍复制 是初始化列表的一种方式
[0]*10    #结果 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
1.1.4 列表的操作方法
  1. 增加元素
#在末尾增加元素——列表.append(待增元素)
languages = ["Python","C++","R"]
languages.append("Java")
languages          #结果 ['Python', 'C++', 'R', 'Java']

#在任意位置插入元素——列表.insert(位置编号，待增元素)    插入该位置的前面
languages.insert(1,"C")
languages      #结果 ['Python', 'C', 'C++', 'R', 'Java']

#在末尾整体并入另一列表——列表1.extend(列表2)
languages.append(["Rudy","PHP"])           #append将列表2整体作为一个元素添加到列表1中
languages      #结果 ['Python', 'C', 'C++', 'R', 'Java', ['Rudy', 'PHP']]
languages.extend(["Rudy","PHP"])           #extend将列表2内的元素逐个添加到列表1中
languages      #结果 ['Python', 'C', 'C++', 'R', 'Java', ['Rudy', 'PHP'], 'Rudy', 'PHP']
  1. 删除元素
#删除列表i位置的元素 列表.pop(位置)
languages = ['Python', 'C', 'C++', 'R', 'Java']
languages.pop(1)
languages       #结果 ['Python', 'C++', 'R', 'Java']
#不写位置信息，默认删除最后一个元素
languages.pop()
languages           #结果 ['Python', 'C++', 'R'] 

#删除列表中的第一次出现的待删除元素 列表.remove(待删除元素)
languages = ['Python', 'C', 'C++','C', 'R', 'Java']
languages.remove("C")
languages     #结果 ['Python', 'C++', 'C', 'R', 'Java']    注意只删除第一次出现的待删元素
#如何将列表中重复出现的待删除元素删除
languages = ['Python', 'C', 'C++','C', 'R', 'Java']
while "C" in languages:
    languages.remove("C")
languages               #结果 ['Python', 'C++', 'R', 'Java']
  1. 查找元素
#列表中第一次出现待查元素的位置 列表.index(待查元素)
languages = ['Python', 'C', 'R', 'Java']
index = languages.index("R")
index               #结果  2
  1. 修改元素
#通过“先索引后赋值”的方式，对元素进行修改  列表名{位置}=新值
languages = ['Python', 'C', 'R', 'Java']
languages[1] = "C++"
languages    #结果  ['Python', 'C++', 'R', 'Java']
  1. 列表的复制
#错误的复制方式
languages = ['Python', 'C', 'R', 'Java']
languages_2 = languages
languages.pop()
print(languages)     #结果  ['Python', 'C', 'R']
print(languages_2)   #结果  ['Python', 'C', 'R']   这样操作时，会发现对原来的列表进行修改，同时也对复制的列表进行了修改，相当于同一个列表有两个名字

#正确的方式——浅拷贝
#方法1：列表.copy()
languages = ['Python', 'C', 'R', 'Java']
languages_3 = languages.copy()
languages.pop()
print(languages)     #结果  ['Python', 'C', 'R']
print(languages_3)   #结果  ['Python', 'C', 'R', 'Java']
#方法2：列表[:]
languages = ['Python', 'C', 'R', 'Java']
languages_4 = languages[:]
languages.pop()
print(languages)     #结果  ['Python', 'C', 'R']
print(languages_3)   #结果  ['Python', 'C', 'R', 'Java']
  1. 列表的排序
#使用列表.sort()对列表进行永久排序
#直接在列表上进行操作，无返回值
ls = [2,5,2,8,19,3,7]
ls.sort()
ls        #结果  [2, 2, 3, 5, 7, 8, 19]
#递减排列
ls.sort(reverse = True)
ls        #结果  [19, 8, 7, 5, 3, 2, 2]

#使用sorted(列表)对列表进行临时排序
#原列表保持不变，返回排序后的列表
ls = [2,5,2,8,19,3,7]
ls_2 = sorted(ls)
print(ls)     #结果  [2, 5, 2, 8, 19, 3, 7]
print(ls_2)   #结果  [2, 2, 3, 5, 7, 8, 19]
sorted(ls,reverse = True)     #结果  [19, 8, 7, 5, 3, 2, 2]   递减排序
  1. 列表的翻转
#使用列表.reverse()对列表进行永久翻转
#直接在列表上进行操作，无返回值
ls = [1,2,3,4,5] 
print(ls[::-1])         #结果 [5, 4, 3, 2, 1]
ls                     #结果 [1, 2, 3, 4, 5]

ls.reverse()    
ls                     #结果 [5, 4, 3, 2, 1]
  1. 使用for循环对列表进行遍历
ls = [1,2,3,4,5] 
for i in ls:
    print(i)    #结果 1 2 3 4 5

1.2 元组

1.2.1 元组的表达

元组是一个可以使用多种类型元素，一旦定义，内部元素不支持增、删和修改操作的序列类型
通俗来说，可以将元组视作“不可变的列表”

names = ("Peter","Pual","Mary")
1.2.2 元组的操作

不支持元素的增加、元素删除、元素修改操作
其他操作与列表的操作完全一致

1.2.3 元组的常见用处
#打包与解包
#eg1
def f(x):                     #返回x的平方和立方
    return x**2, x**3        #实现打包返回

print(f(3))         #结果  (9, 27)
print(type(f(3)))   #结果  <class 'tuple'>    元组类型
a, b = f(3)         #实现解包赋值
print(a)            #结果 9
print(b)            #结果 27

#eg2
numbers = [201901, 201902, 201903]
name = ["小明","小红","小强"]
list(zip(numbers, name))      #结果  [(201901, '小明'), (201902, '小红'), (201903, '小强')]
for number,name in zip(numbers, name):      #每次取到一个元组，立刻进行解包赋值
    print(number, name)    #结果  201901 小明    201902 小红    201903 小强

1.3 字典

1.3.1 字典的表达

映射规则：通过“键”-“值”的映射实现数据存储和查找
映射的字典是无序的

students = {201901: '小明', 201902: '小红', 201903: '小强'}
students         #结果   {201901: '小明', 201902: '小红', 201903: '小强'}

字典键的要求

  1. 字典的键不能重复
  2. 字典的键必须是不可变类型，如果键可变，就找不到对应存储的值了
    不可变类型：数字、字符串、元组。一旦确定，他自己就是他自己，变了就不是他了
    可变类型：列表、字典、集合。一旦确定，还可以随意增删改
d1 = {1: 3}         #数字
d2 = {"s": 3}       #字符串
d3 = {(1,2,3): 3}   #元组

d = {[1,2]: 3}      #列表
d = {{1:2}: 3}      #字典
d = {{1,2}: 3}      #集合
1.3.2 字典的性质
#字典的长度——键值对的个数
students = {201901: '小明', 201902: '小红', 201903: '小强'}
len(students)    #结果 3

#字典的索引
#通过 字典[键] 的形式来获取对应的值
students[201901]    #结果  '小明'
1.3.3 字典的操作方法
  1. 增加键值对
#变量名[新建] = 新值
students = {201901: '小明', 201902: '小红', 201903: '小强'}
students[201904] = "小雪"
students       #结果 {201901: '小明', 201902: '小红', 201903: '小强', 201904: '小雪'}
  1. 删除键值对
# 通过del 变量名[待删除键]
students = {201901: '小明', 201902: '小红', 201903: '小强'}
del students[201903]
students    #结果  {201901: '小明', 201902: '小红'}

# 通过变量名.pop(待删除)
value = students.pop(201902)
print(value)      #结果  小红
print(students)   #结果  {201901: '小明'} 

# 变量名.popitem() 随机删除一个键值对，并以元组返回删除键值对
students = {201901: '小明', 201902: '小红', 201903: '小强'}
key, value = students.popitem()
print(value)      #结果  小强
print(students)   #结果  {201901: '小明', 201902: '小红'}
  1. 修改值
#通过先索引后赋值的方式对相应的值进行修改
students = {201901: '小明', 201902: '小红', 201903: '小强'}
students[201902] = "小雪"
students       #结果 {201901: '小明', 201902: '小雪', 201903: '小强'}
  1. d.get( )方法
#d.get(key,default)  从字典d中获取键key对应的值，如果没有这个键，则返回default
# eg：统计“牛奶奶找刘奶奶买牛奶”中字符出现频率
s = "牛奶奶找刘奶奶买牛奶"
d = {}
for i in s:
    d[i] = d.get(i, 0)+1
print(d)      #结果 {'牛': 2, '奶': 5, '找': 1, '刘': 1, '买': 1}
  1. d.key( ) d.value( )方法
students = {201901: '小明', 201902: '小红', 201903: '小强'}
print(list(students.keys()))    #结果 [201901, 201902, 201903]
print(list(students.values()))  #结果 ['小明', '小红', '小强']
  1. d.items( )方法及字典的遍历
print(list(students.items()))
for k, v in students.items():
    print(k, v)  
'''
输出结果
[(201901, '小明'), (201902, '小红'), (201903, '小强')]
201901 小明
201902 小红
201903 小强
'''

1.4 集合

1.4.1 集合的表达
  • 一系列互不相等元素的无序组合
  • 元素必须是不可变类型：数字，字符串或元组，可视作字典的键
  • 可以看作是没有值，或者为None的字典
students = {"小明","小红","小强","小明"}    #可用于去重
students    #结果   {'小强', '小明', '小红'}
1.4.2 集合的运算
# eg 通过集合进行交集并集的运算
Chinese_A = {"刘德华","钟楚红","张学友","张曼玉","古天乐","林青霞"}
Math_A = {"林青霞","郭富城","王祖贤","刘德华","张曼玉","黎明"}

#语文和数学两门均为A的学员
#S&T返回一个新集合，包括同时在集合S和T中的元素
Chinese_A & Math_A    #结果   {'刘德华', '张曼玉', '林青霞'}

#语文和数学至少有一个为A的学员
#S|T返回一个新集合，包括集合S和T中的所有元素
Chinese_A | Math_A    #结果  {'刘德华', '古天乐', '张学友', '张曼玉', '林青霞', '王祖贤', '郭富城', '钟楚红', '黎明'}

#语文和数学只有一个为A的学员
#S^T返回一个新集合，包括集合S和T中的非共同元素
Chinese_A ^ Math_A    #结果  {'古天乐', '张学友', '王祖贤', '郭富城', '钟楚红', '黎明'} 

#语文为A，数学不为A的学员
#S-T返回一个新集合，包括集合S和不在集合T中的元素
Chinese_A - Math_A     #结果  {'古天乐', '张学友', '钟楚红'}

#数学为A，语文不为A的学员
Math_A -  Chinese_A    #结果  {'王祖贤', '郭富城', '黎明'}
1.4.3 集合的操作方法
#增加元素——S.add(x)
stars = {"刘德华","张学友","张曼玉"}
stars.add("王祖贤")
stars      #结果    {'刘德华', '张学友', '张曼玉', '王祖贤'}

#移除元素——S.remove(x)
stars.remove("王祖贤")
stars      #结果    {'刘德华', '张学友', '张曼玉'}

#集合的长度——len(S)
len(stars)     #结果    3

#集合的遍历——借助for循环
for star in stars:
    print(star)
'''
输出结果
张学友
刘德华
张曼玉
'''

总结

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

小明同学的杂货铺
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python基础数值运算、组合数据类型的基本操作
Junds0的博客
09-08 1410
说明：eval()函数可以将字符串当成有效的表达式来求值，并返回计算结果，而无论用户输入的是字符还是数字， input() 将统一按照字符串类型输出。根据提示，在右侧编辑器 Begin-End 区间补充代码，集合 S 和 T 以及元素 x 已经给出。球体体积计算公式： V=4/3πr³ ，其中 r 为球的半径， V 为球的体积；为了完成本关任务，你需要掌握：1.集合的创建，2.集合的相关操作。平台会对你编写的代码进行测试，输出结果与预期结果一致，则通关。根据提示，在右侧编辑器补充代码，计算并输出球体体积。
Python知识点汇总--Python基础（组合数据类型）
weixin_55207753的博客
12-18 1166
一、什么是组合数据类型（列表、元组、集合、字典） 1.Python中常用的序列类型有字符串、列表和元组 Python中的序列支持双向索引：正向递增索引和反向递减索引正向递增索引从左向右依次递增，第一个元素的索引为0，第二个元素的索引为1，以此类推；反向递减索引从右向左依次递减，从右数第一个元素的索引为-1，第二个元素的索引为-2，以此类推。 2.Python集合具备确定性、互异性和无序性三个特性。Python要求放入集合中的元素必须是不可变类型，Python中的整型、浮点型、字符串类型和元组属于.
Python常用数字处理基本操作汇总
菜鸟教程
11-20 763
更多编程教程请到：菜鸟教程 https://www.piaodoo.com/ 友情链接：好看站 http://www.nrso.net/ 高州阳光论坛https://www.hnthzk.com/ 一些基本的操作，在工作者遇到相关问题要有相关印象。 一、 你想对浮点数执行指定精度的舍入运算 对于简单的舍入运算，使用内置的 round(value, ndigits) 函数即可。比如： >>> round(1.23, 1) 1.2 >>> round(1.27,
python基础数据类型操作_Python基础数据类型和基本数值操作
weixin_30189603的博客
12-30 1181
一、整数类型Python的整数类型是无限范围的，也就是说，想要多大就有多大。学过C语言的朋友应该知道，C语言当中的整数类型是有范围的，如果超出一定范围就会产生溢出，这一点在Python中是不必考虑的。比如说一个好几十位的整数，9234214832583495782138091238947389543，在Python中也是可以直接使用的再比如2的100次方，2的10000000次方，都是可以的。二、...
python基本数,Python基本数据类型及其操作,基础
weixin_35806032的博客
03-26 207
1.数字 (Number)一、数字类型：①int 整数(整型)：通常被称为是整型或整数，可以是正整数或负整数，不带小数点。Python3整型是没有限制大小的，可以当做long类型使用， 但实际上由于机器内存的有限，我们使用的整数是不可能无限大的。整型的四种表现形式：2 进 制：以’0b’开头。例如：'0b11011’表示10进制的278 进 制：以’0o’开头。例如：'0o33’表示10进制的2...
Python基础（一）_基本数据类型及操作
Climb_Ma的博客
08-11 1359
一：基本数据类型及操作 （一）基本数据类型 1.整数类型 整数类型一共有4种进制表示：十进制、二进制、八进制和十六进制 默认情况，整数采用十进制，其他进制需要增加引导符号(大小写字母均可使用)。 整数类型理论上取值范围是[-∞，∞]，实际上的取值范围受限于运行Python程序的计算机内存大小。除极大数的运算外，一般认为整数类型没有取值范围限制。 2.浮点数类型 Python语言要求所有浮点数必须带有小数部分，小数部分可以是0，这种设计是为了区分浮点数和整数类型。 浮点数有两种表示方法：十进制表示法和
python基础+数据分析三大件Numpy Pandas Matplotlib
04-08
该资源为本人学习过程中的笔记，适合有一定基础的同学使用。
Python入门——组合数据类型
12-21
文章目录第一部分 列表 list1.1 列表的表达 []另一种生成方式：list(可迭代对象)range()1.2 列表的性质列表的长度——len(列表)列表的索引——与同为序列类型的字符串完全相同列表的切片——与字符串完全相同1.3 ...
hive+python数据分析入门
02-26
举个例子,当年没有数据库的时候,人们编程来操作文件系统,这相当于我们编写mapreduce...因为:python真是太好用了,脚本语言,无需编译,有强大的机器学习库,适合科学计算(这就是数据分析啊!!)hive与python的分工:使用hives
python+numpy+基础数据分析+可视化
最新发布
04-10
python数据分析与可视化 python+numpy+基础数据分析+可视化
python基本语法——组合数据类型
weixin_44606231的博客
02-12 188
列表list： 有顺序的存储多个可以重复的数据，可变数据 常见操作函数：          增加数据：                    append()末尾追加一个数据                    extends()默认追加一组数据                    insert()指定位置增加一个数据          删除数据：               ...
Python组合数据类型及其相关操作（元组、列表、字典、集合）
yanyunfei0921的博客
07-16 1231
很详细的数据类型（元组、列表、字典、集合）讲解，尤其是列表，可通过目录索引。
字符串类型
weixin_30622181的博客
11-26 94
#在python中，加了引号的字符就是字符串类型，python并没有字符类型。 定义：name='egon' #name=str('egon') 用于标识：描述性的内容，如姓名，性别，国籍，种族 #那单引号、双引号、多引号有什么区别呢？ 让我大声告诉你，单双引号木有任何区别，只有下面这种情况 你需要考虑单双的配合 msg = "My name is Egon ...
Python组合数据类型及操作
qq_46386020的博客
06-17 340
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、Python组合数据类型二、集合1.定义3.操作方法三.序列类型1.定义2.序列处理函数及方法3.元组类型4.列表类型四.字典类型1.定义2.函数及方法 一、Python组合数据类型 集合类型 （集合） 序列类型 （字符串、元组、列表） 映射类型 （字典） 二、集合 1.定义 python中集合用大括号表示{}，每个元素间用逗号分隔。 集合类型与数学中的集合概念一致。 集合元素之间无序，每个元素唯一，不存在相同元素
Python基本数据类型及基本运算
立志成为一个前端、后端、测试全方位发展的程序员
10-06 417
Python基本数据类型及基本运算 文章目录Python基本数据类型及基本运算一、注释二、基本数据类型三、不同类型的转换四、对字符串的操作五、对列表的操作六、对元组的操作七、对字典的操作八、对集合的操作九、基本运算符 一、注释 单行注释： Python中单行注释以 # 开头，例如： # 这是一个注释 多行注释： Python中多行注释用三个单引号 ''' 或者三个双引号 """ 将注释括起来，例如: ''' 这是多行注释，用三个单引号 这是多行注释，用三个单引号 这是多行注释，用三个单引号 ''' "
Python元组类型详解
永远是少年
11-25 4212
今天继续给大家介绍Python相关知识，本文主要内容是Python元组类型定义、操作及应用。 一、元组类型定义 二、元组类型操作示例 三、元组类型应用
python基本数据类型（3）— 元组
个人博客
08-04 4883
​元组（Tuple）是一种Python基本数据类型，是一种有序、不可变的数据类型。 元组使用圆括号()来表示，元素之间使用逗号,分隔。 元组中的元素是不可变的，一旦创建就不能被修改，也不能添加或删除元素。 元组支持索引和切片操作。 元组在某些情况下比列表更适合使用，例如需要保护数据不被修改或者作为字典的键等。
python元组的定义形式_Python数据类型--元组（tuple）
weixin_39611666的博客
11-24 429
元组与列表非常相似，最大区别在于:(1)元组是不可修改的，定义之后就“固定”了。(2)元组在形式上是用（）这样的圆括号括起来(3)元组不能插入或删除元素注：元素可修改与不可修改是列表与元组最大的区别，基本除了修改内部元素的操作，其他列表适用的操作都可以用于元组。一、元组中的元素值是不允许修改的，但可以对元组进行连接组合例题：tup1=(12,34.56)tup2=('abc','xyz')tup1...
组合数据类型
m0_61459140的博客
12-14 1912
一、认识组合数据类型： 1、Python中常用的序列类型有字符串、列表和元组 2、Python中的序列支持双向索引：正向递增索引和反向递减索引正向递增索引从左向右依次递增，第一个元素的索引为0，第二个元素的索引为1，以此类推；反向递减索引从右向左依次递减，从右数第一个元素的索引为-1，第二个元素的索引为-2，以此类推。 ...
python+大数据分析基础
03-15
Python是一种高级编程语言，它具简洁、易读、易学的特点，因此在分析领域得到了广泛应用。Python拥有富的第三方库和工具，使得数据分析变得更加便捷和高效。 在Python中进行大数据分析，通常会使用以下几个重要的库和工具： 1. Num：NumPy是Python科学计算的基础库，提了高性能多维数组对象和各种数学函数是进行数据分的基础。 2. Pandas：Pandas是一个强大的数据处理和分析工具，提供了灵活的数据结构和数据操作，可以轻松地处理和清洗数据3. MatplotlibMatplotlib是一个用于绘制图表和可视化数据的库，可以创建各种类型的图表，如折线图、散点图、柱状图等。 4. Seaborn：Seaborn是基于Matplotlib的统计数据可视化库，提供了更高级的图表样式和更简单的API接口。 5. Scikit-learn：Scikit-learn是一个机器学习库，提供了各种常用的机器学习算法和工具，可以用于数据挖掘和预测分析。 6. PySpark：PySpark是Python与Apache Spark的集成库，Spark是一个快速、通用、扩展的大数据处理框架，PySpark可以用于布式数据处理和分析。 以上是Python在大数据分析中常用的一些基础库和工具，通过它们可以进行数据的处理、分析、可视化和机器学习等任务。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值