【Python】3.组合数据类型

最新推荐文章于 2023-02-28 10:18:59 发布
最新推荐文章于 2023-02-28 10:18:59 发布
阅读量325 收藏
点赞数
分类专栏： Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40633696/article/details/114691694
版权

目录

一、概述

二、列表

1. 列表的表达

2. 列表的性质

3. 列表的操作符

4. 列表的操作方法

三、元组

1. 元组的表达

2. 元组的操作

3. 元组的常见用处

四、字典

1. 字典的表达

2. 字典的性质

3. 字典的操作方法

五、集合 

1. 集合的表达

2. 集合的运算

3. 集合的操作方法

六、重难点回顾

1. 列表

2. 元组

3. 字典

4. 集合

一、概述

二、列表

1. 列表的表达

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

输入：

ls = ["Python", 1989, True, {"version": 3.7}]
ls

输出：

['Python', 1989, True, {'version': 3.7}]
  • 另一种产生方式：list(可迭代对象)
  • 可迭代对象包括：字符串、元组、集合、range()等

字符串转列表

输入：

list("人工智能是未来的趋势")

输出：

['人', '工', '智', '能', '是', '未', '来', '的', '趋', '势']

元组转列表

输入：

list(("我", "们", "很", "像"))

 输出：

['我', '们', '很', '像']

 集合转列表

输入：

list({"李雷", "韩梅梅", "Jim", "Green"})

输出：

['Green', 'Jim', '李雷', '韩梅梅']

特殊的range()

输入：

for i in [0, 1, 2, 3, 4, 5]:
    print(i)

 输出：

0
1
2
3
4
5

 输入：

for i in range(6):
    print(i)

输出：

0
1
2
3
4
5
  •  range(起始数字,中止数字,数字间隔)

如果起始数字缺省，默认为0

必须包含中止数字，中止数字取不到。

数字间隔缺省，默认为1

 输入：

for i in range(1, 11, 2):
    print(i)

输出：

1
3
5
7
9
  • range()转列表

 输入：

list(range(1, 11, 2))

输出：

[1, 3, 5, 7, 9]

2. 列表的性质

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

输入：

ls = [1, 2, 3, 4, 5]
len(ls)

输出：

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

变量名[位置编号]

正向索引从0开始
反向索引从-1开始

输入：

cars = ["BYD", "BMW", "AUDI", "TOYOTA"]
print(cars[0])
print(cars[-1])

输出：

BYD
TOYOTA
  • 列表的切片

变量名[开始位置：结束位置：切片间隔]

cars = ["BYD", "BMW", "AUDI", "TOYOTA"]
  • 正向切片

输入：

print(cars[:3])     # 前三个元素，开始位置缺省，默认为0；切片间隔缺省，默认为1

输出：

['BYD', 'BMW', 'AUDI']

输入：

print(cars[1:4:2])  # 第二个到第四个元素 前后索引差为2

输出：

['BMW', 'TOYOTA']

输入：

print(cars[:])      # 获取整个列表，结束位置缺省，默认取值到最后

输出：

['BYD', 'BMW', 'AUDI', 'TOYOTA']

输入：

print(cars[-4:-2])  # 获取前两个元素

输出：

['BYD', 'BMW']
  • 反向切片

输入：

cars = ["BYD", "BMW", "AUDI", "TOYOTA"]
print(cars[:-4:-1])      # 开始位置缺省，默认为-1
print(cars[::-1])        # 获得反向列表

输出：

['TOYOTA', 'AUDI', 'BMW']
['TOYOTA', 'AUDI', 'BMW', 'BYD']

3. 列表的操作符

  • 用 list1+lis2 的形式实现列表的拼接

输入：

a = [1, 2]
b = [3, 4]
a+b            # 该用法用的不多

输出：

[1, 2, 3, 4]
  • 用 n*list 或 list*n 实现列表的成倍复制

初始化列表的一种方式

输入：

[0]*10

输出：

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

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)

append 将列表2整体作为一个元素添加到列表1中

输入：

languages.append(["Ruby", "PHP"])
languages

输出：

['Python', 'C', 'C++', 'R', 'Java', ['Ruby', 'PHP']]

输入：

languages = ['Python', 'C', 'C++', 'R', 'Java']
languages.extend(["Ruby", "PHP"])
languages

输出：

['Python', 'C', 'C++', 'R', 'Java', 'Ruby', 'PHP']

2、删除元素

  • 删除列表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', 'R', 'C', 'Java']
languages.remove("C")    
languages

输出：

['Python', 'R', 'C', 'Java']

输入：

languages = ['Python', 'C', 'R', 'C', 'Java']
while "C" in languages:
    languages.remove("C")    
languages

输出：

['Python', 'R', 'Java']

3、查找元素

  • 列表中第一次出现待查元素的位置 列表.index(待查元素)

输入：

languages = ['Python', 'C', 'R','Java']
idx = languages.index("R") 
idx

输出：

 2

4、修改元素

  • 通过"先索引后赋值"的方式，对元素进行修改 列表名[位置]=新值

输入： 

languages = ['Python', 'C', 'R','Java']
languages[1] = "C++"
languages

输出：

['Python', 'C++', 'R', 'Java']

5、列表的复制

  • 错误的方式

输入：

languages = ['Python', 'C', 'R','Java']
languages_2 = languages
print(languages_2)

输出：

['Python', 'C', 'R', 'Java']

输入：

languages.pop()
print(languages)
print(languages_2)

输出：

['Python', 'C', 'R']
['Python', 'C', 'R']
  • 正确的方式——浅拷贝
  • 方法1：列表.copy()

输入：

languages = ['Python', 'C', 'R','Java']
languages_2 = languages.copy()
languages.pop()
print(languages)
print(languages_2)

输出：

['Python', 'C', 'R']
['Python', 'C', 'R', 'Java']
  • 方法2：列表[ : ]

输入：

languages = ['Python', 'C', 'R','Java']
languages_3 = languages[:]
languages.pop()
print(languages)
print(languages_3)

输出：

['Python', 'C', 'R']
['Python', 'C', 'R', 'Java']

6、列表的排序

  • 使用列表.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)
print(ls_2)

输出：

[2, 5, 2, 8, 19, 3, 7]
[19, 8, 7, 5, 3, 2, 2]

输入：

sorted(ls, reverse = True)

输出：

[19, 8, 7, 5, 3, 2, 2]

7、列表的翻转

  • 使用列表.reverse()对列表进行永久翻转
  • 直接在列表上进行操作，无返回值

输入：

ls = [1, 2, 3, 4, 5]
print(ls[::-1])
ls

输出：

[5, 4, 3, 2, 1]
[1, 2, 3, 4, 5]

输入：

ls.reverse()
ls

输出：

[5, 4, 3, 2, 1]

8、使用for循环对列表进行遍历

输入：

ls = [1, 2, 3, 4, 5]
for i in ls:
    print(i)

输出：

1
2
3
4
5

三、元组

1. 元组的表达

  • 元组是一个可以使用多种类型元素，一旦定义，内部元素不支持增、删和修改操作的序列类型

通俗的讲，可以将元组视作“不可变的列表”

names = ("Peter", "Pual", "Mary")

2. 元组的操作

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

3. 元组的常见用处

打包与解包

  • 例1

输入：

def f1(x):              # 返回x的平方和立方
    return x**2, x**3   # 实现打包返回

print(f1(3))
print(type(f1(3)))      # 元组类型

输出：

(9, 27)
<class 'tuple'>

输入：

a, b = f1(3)            # 实现解包赋值 
print(a)
print(b)

输出：

9
27
  • 例2

输入：

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. 字典的表达

  • 映射类型： 通过“键”-“值”的映射实现数据存储和查找
  • 常规的字典是无序的
students = {201901: '小明', 201902: '小红', 201903: '小强'}
students

字典键的要求

  • 1. 字典的键不能重复

输入：

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

输出：

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

输入：

d = {[1, 2]: 3}

输出：

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-68-bf7f06622b3f> in <module>
----> 1 d = {[1, 2]: 3}

TypeError: unhashable type: 'list'

输入：

d = {{1:2}: 3}

输出：

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-69-188e5512b5fe> in <module>
----> 1 d = {{1:2}: 3}

TypeError: unhashable type: 'dict'

输入：

d = {{1, 2}: 3}

输出：

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-70-c2dfafc1018a> in <module>
----> 1 d = {{1, 2}: 3}

TypeError: unhashable type: 'set'

2. 字典的性质

  • 字典的长度——键值对的个数

输入：

students = {201901: '小明', 201902: '小红', 201903: '小强'}
len(students)

输出：

3
  • 字典的索引

通过 字典[键] 的形式来获取对应的值

输入：

students = {201901: '小明', 201902: '小红', 201903: '小强'}
students[201902]

输出：

'小红'

3. 字典的操作方法

1、增加键值对

  • 变量名[新键] = 新值

输入：

students = {201901: '小明', 201902: '小红', 201903: '小强'}
students[201904] = "小雪"
students

输出：

{201901: '小明', 201902: '小红', 201903: '小强', 201904: '小雪'}

2、删除键值对

  • 通过del 变量名[待删除键]

输入：

students = {201901: '小明', 201902: '小红', 201903: '小强'}
del students[201903]
students

输出：

{201901: '小明', 201902: '小红'}
  • 通过变量名.pop(待删除键) 

输入：

students = {201901: '小明', 201902: '小红', 201903: '小强'}
value = students.pop(201903)   # 删除键值对，同时获得删除键值对的值
print(value)
print(students)

输出：

小强
{201901: '小明', 201902: '小红'}
  • 变量名.popitem() 随机删除一个键值对，并以元组返回删除键值对 

输入：

students = {201901: '小明', 201902: '小红', 201903: '小强'}
key, value = students.popitem()
print(key, value)
print(students)

输出：

201903 小强
{201901: '小明', 201902: '小红'}

3、修改值

  • 通过先索引后赋值的方式对相应的值进行修改

输入：

students = {201901: '小明', 201902: '小红', 201903: '小强'}
students[201902] = "小雪"
students

输出：

{201901: '小明', 201902: '小雪', 201903: '小强'}

4、d.get( )方法

d.get(key,default) 从字典d中获取键key对应的值，如果没有这个键，则返回default

  • 小例子：统计"牛奶奶找刘奶奶买牛奶"中字符的出现频率

输入：

s = "牛奶奶找刘奶奶买牛奶"
d = {}
print(d)
for i in s:
    d[i] = d.get(i, 0)+1
    print(d)
# print(d)

输出：

{}
{'牛': 1}
{'牛': 1, '奶': 1}
{'牛': 1, '奶': 2}
{'牛': 1, '奶': 2, '找': 1}
{'牛': 1, '奶': 2, '找': 1, '刘': 1}
{'牛': 1, '奶': 3, '找': 1, '刘': 1}
{'牛': 1, '奶': 4, '找': 1, '刘': 1}
{'牛': 1, '奶': 4, '找': 1, '刘': 1, '买': 1}
{'牛': 2, '奶': 4, '找': 1, '刘': 1, '买': 1}
{'牛': 2, '奶': 5, '找': 1, '刘': 1, '买': 1}

5、d.keys( ) d.values( )方法 

输入：

students = {201901: '小明', 201902: '小红', 201903: '小强'}
print(list(students.keys()))
print(list(students.values()))

输出：

[201901, 201902, 201903]
['小明', '小红', '小强']

6、d.items( )方法及字典的遍历

输入：

print(list(students.items()))
for k, v in students.items():
    print(k, v)

输出：

[(201901, '小明'), (201902, '小红'), (201903, '小强')]
201901 小明
201902 小红
201903 小强

五、集合 

1. 集合的表达

  • 一系列互不相等元素的无序集合
  • 元素必须是不可变类型：数字，字符串或元组，可视作字典的键
  • 可以看做是没有值，或者值为None的字典

输入：

students = {"小明", "小红", "小强", "小明"}   #可用于去重
students

输出：

{'小强', '小明', '小红'}

2. 集合的运算

  • 小例子 通过集合进行交集并集的运算

输入：

Chinese_A = {"刘德华", "张学友", "张曼玉", "钟楚红", "古天乐", "林青霞"}
Chinese_A

输出：

{'刘德华', '古天乐', '张学友', '张曼玉', '林青霞', '钟楚红'}

输入：

Math_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

输出：

{'王祖贤', '郭富城', '黎明'}

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. 列表

2. 元组

3. 字典

4. 集合

猎猎长风
关注
专栏目录
Python学习-5.组合数据类型
momomuabc的博客
11-29 4273
组合数据类型：集合、列表、元组、字典
python中的组合数据类型
最新发布
Luinee的博客
04-17 1776
其中，组合数据类型的数据可以包含多个值，且可以添加、删除、修改等，常常用于存储、操作数据等，是数据分析中常用的数据类型。2.数值类型的数据是不可变的，即一旦创建就不能修改，而组合类型的数据是可变的，可以添加、删除和修改其中的元素.3.数值类型的数据通常用于进行数学计算和逻辑判断，而组合类型的数据通常用于存储、组织和操作多个相关的数据。有序序列，使用索引来访问，可以使用负数，-1表示最后一个元素，-2表示倒数第二个元素。1.数值类型的数据是单一的，只包含一个值，而组合类型的数据可以包含多个值。
pytorch删除Tensor中指定位置的元素
guanyonglai的博客
09-30 2万+
想要在pytorch的tensor中删除元素，但是pytorch中貌似没有直接删除元素的方法，那么我们就简单写一个，经过测试发现这个方法居然跟np.delete速度差不多，还以为自己写的会很慢呢
盏茶python(三) 组合数据类型
盏茶AI
01-26 289
盏茶python(一) 语言特性及环境配置 盏茶python(二) 基本数据类型 盏茶python(三) 组合数据类型 本节我们将要讲解python的组合数据类型，主要包括列表，字典，元组和集合。 1.列表 列表(list)是一种序列类型，表示方式为[element1, element2…] list1 = [1, 2, 3, 4, 5] # 长度 len(list1) # 索引 list1[...
Python--第3次平时作业
风起
07-06 391
一、单项选择题 题号 1 2 3 4 5 6 7 8 9 10 答案 C A A C C D D ..
Tensor-Level替换、删除（后面元素前移）其中的元素
justBeHerHero
02-28 731
Tensor-Level替换、删除（后面元素前移）其中的元素.NLP中简单数据增强包括插入、删除、替换。 在word级别完成的替换，比如：https://github.com/tedljw/data_augment/blob/master/eda.py 但是映射到token后，在tensor级别中，我并没有找到，因此参考BERT、LevOCR的代码实现在token级别中的替换、删除。
PyTorch的Tensor模块笔记
qq_64265869的博客
09-22 614
简要收集了tensor的常见操作，适合ctrl+f
pytorch 一个tensor去除指定值的元素
weixin_44347271的博客
02-18 5262
可以用集合运行实现，但转换为set之后会删除重复值，所以接用np.isin实现。 A = torch.tensor([1, 2, 3]) B = torch.tensor([2]) A[~np.isin(A, B)] np.isin还可以用于dataframe数据的过滤中，速度很快非常好用。
实验7 Python组合数据类型.pdf
05-25
Python组合数据类型是Python编程语言中用于存储多个数据值的内置数据结构。在Python中，组合数据类型包括列表（List）、元组（Tuple）和字典（Dictionary）。这三种类型各有其特点，可以存储不同类型的数据，包括...
python组合数据类型
06-08
Python 组合数据类型 Python 中的组合数据类型主要包括集合、列表、元组和字典四种。这些数据类型都是 Python 中的内置类型，广泛应用于数据处理和存储。 集合类型 集合类型是无序、唯一性元素的组合，可以是数字...
Python组合数据类型.pptx
04-15
"Python 组合数据类型" Python 组合数据类型是 Python 编程语言中的一种基本数据类型，它包括列表、元组、字典和集合四种类型。组合数据类型可以存储多个元素，并提供了多种操作和处理方法，非常有利于数据处理和...
pytorch 实现删除tensor中的指定行列
12-23
前言 在pytorch中， 想删除tensor中的指定行列，原本以为有个函数或者直接把某一行赋值为[]就可以，结果发现没这么简单，因此用了一个曲线救国方法，希望如果有更直接的方法，请大家指出。 code 本质上是利用mask删除了指定行，然后重新指向。 a = torch.rand(4, 2) print(a) idx = 1 a = a[torch.arange(a.size(0))!=1] print(a) """ tensor([[2.7775e-01, 3.7430e-01], [9.0373e-01, 8.1220e-02], [9.8638e-01, 8.6293
网络容器------Pytorch
轻羽羽的博客
05-20 224
一、容器(在Net网络类的__init__函数中使用) 1、nn.Sequetial:按顺序包装多个网络层 class Net(nn.module): def __init__(self,classes) super(Net,self).__init__() self.network = nn.Sequetial( nn.Conv2d(3,6,5), .
pytorch: 给tensor删除或者添加维度为1的维度（squeeze和unsqueeze）
傲笑风的博客
11-19 5万+
删除tensor中维度为1的维度 在pytorch中，用torch.squeeze()函数或者tensor的自身成员函数squeeze()去除维度为1的维度。 import torch x = torch.randn(3,1,4,1,2) a = x.squeeze(dim=1) # 成员函数删除第二维度 print(a.shape) b = torch.squeeze(x, dim=1) # torch自带函数删除第二维度 print(b.shape) c = torch.squeeze(x, dim
huggingface：transformers中文文本分词
wu0310zh的博客
09-20 2154
huggingface：transformers中文文本分词
pytorch 删除tensor中的指定位置元素
lhyyhlfornew的博客
09-13 1万+
pytorch似乎并没有提供删除指定位置的元素或者删除某个值的直接方法，但是可以使用其他方法曲线达到目标。 删除指定位置元素或者具体某个值需要先用nonzero()获取到要删除的元素的索引位置，之后使用torch.cat()进行删除操作 import torch a = torch.randn(4,5).int() #生成一个随机的4,5 tensor print(a, a.size()) tensor([[ 0, 1, 0, 0, 0], [ 0, 0, 0, -1,
pytorch删除tensor中的指定行列
qq_29007291的博客
06-06 3万+
前言 在pytorch中， 想删除tensor中的指定行列，原本以为有个函数或者直接把某一行赋值为[]就可以，结果发现没这么简单，因此用了一个曲线救国方法，希望如果有更直接的方法，请大家指出。 code 本质上是利用mask删除了指定行，然后重新指向。 a = torch.rand(4, 2) print(a) idx = 1 a = a[torch.arange(a.size(0))!=1] ......
python中删除某个元素的3种方法
热门推荐
henusyb的博客
12-03 8万+
1.remove: 删除单个元素，删除首个符合条件的元素，按值删除 举例说明: >>> str=[1,2,3,4,5,2,6] >>> str.remove(2) >>> str [1, 3, 4, 5, 2, 6] 2.pop:  删除单个或多个元素，按位删除(根据索引删除) >>> str=[0,1,2,3,4,5,6] >>> str.pop(1)   #pop删除时
Python组合数据类型详解：列表、元组与字典操作
在"3Python组合数据类型.pptx"文件中，主要讲解了Python中的三种关键组合数据类型：列表（List）、元组（Tuple）以及字典（Dictionary）。这部分内容深入探讨了Python程序设计中这些数据结构的基础概念和应用。 **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值