python：字典

已于 2023-01-09 12:15:32 修改
阅读量1.2k 收藏 2
点赞数
分类专栏： python 文章标签： c++ c语言 开发语言
于 2021-05-08 10:41:02 首次发布
原文链接：https://www.jb51.net/books/134093.html
版权

字典即映射

  • 字典包含了一个索引的集合，被称为键 (keys) ，和一个值 (values) 的集合。
    • 一个键对应一个值。这种一一对应的关联被称为键值对 (key-value pair) ，有时也被称为项 (item) 。
    • 字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
      • k 的取值一般是字符、数字等，像元组其实也是可以的，基本没有使用场景
      • v 的取值可以是字符、数字、元组、列表、字典等所有类型
    • 通常来说，字典中项的顺序是不可预知的。
    • 字典使用哈希表实现，键(key)必须是可散列的：
      • 如果一个对象是可散列的，那么在这个对象的生命周期中，它的散列值是不变的，而且这个对象需要实现 __hash__() 方法。
      • 可散列对象还要有 __eq__()方法，这样才能跟其他键做比较。如果两个可散列对象是相等的，那么它们的散列值一定是一样的
      • 原子不可变数据类型（str、bytes 和数值类型）都是可散列类型，frozenset 也是可散列的，因为根据其定义，frozenset 里只能容纳可散列类型。元组的话，只有当一个元组包含的所有元素都是可散列类型的情况下，它才是可散列的。

方法

构造

#--------------------
## 花括号 {} 表示一个空字典
b = {}  
b = {'one': 1, 'two': 2, 'three': 3}


#--------------------
# dict 函数生成一个不含任何项的新字典
a = dict ()  
d = dict(name='孙悟空',age=18,gender='男') 

# 也可以将一个包含有双值子序列的序列转换为字典
# 双值序列，序列中只有两个值，[1,2] ('a',3) 'ab'
# 子序列，如果序列中的元素也是序列，那么我们就称这个元素为子序列
# [(1,2),(3,5)]
d = dict([('name','孙悟饭'),('age',18)])
# print(d , type(d))
d = dict(name='孙悟空',age=18,gender='男') 
 e = dict({'three': 3, 'one': 1, 'two': 2})
  d = dict([('two', 2), ('one', 1), ('three', 3)])
 c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
  • copy()
    • 该方法用于对字典进行浅复制
    • 复制以后的对象，和原对象是独立，修改一个不会影响另一个
    • 注意，浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制
d = {'a':1,'b':2,'c':3}
d2 = d.copy()
# d['a'] = 100

d = {'a':{'name':'孙悟空','age':18},'b':2,'c':3}
d2 = d.copy()
d2['a']['name'] = '猪八戒'


print('d = ',d , id(d))
print('d2 = ',d2 , id(d2))

字典推导式

字典推导式：可以从任何以键值对作为元素的可迭代对象中构建出字典。

字典推导式，也是创建字典的一种途径。他的语法结构：
　　　　用大括号包围，第一部分为所需要提取和赋值的键值对，再就是循环语句，再就是逻辑分支语句（没有可不写）

例子:

d = {i: i*10 for i in range(1,5)}
# {1: 10, 2: 20, 3: 30, 4: 40}

# 键值互换
d = {'name': 'Tom', 'age': 18, 'height': 180}
{v:k for k,v in d.items()}
# {'Tom': 'name', 18: 'age', 180: 'height'}

例子：给定一个字典对象{‘a’: 1, ‘b’: 2, ‘c’: 3}，找出其中所有大于 1 的键值对，同时 value 值进行平方运算

# # 未使用字典推导式的写法
dc = {'a': 1, 'b': 2, 'c': 3}
d_old = dict()
for k, v in dc.items():
    if v > 1:
        d_old[k] = v ** 2
print(d_old)

# 使用字典推导式
d_new = {k : v ** 2 for k,v in dc.items() if v > 1 }
print(d_new)

遍历

print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

#遍历 key
d = {'a': 1, 'b': 2, 'c': 3}
for i in d:
    print(i)
# a
# b
# c



# 遍历 key
for i in d.keys():
    print(i)
# 结果同上

# 遍历值
for i in d.values():
    print(i)
# 1
# 2
# 3

# 遍历键值组成元组
for i in d.items():
    print(i)
# ('a', 1)
# ('b', 2)
# ('c', 0)

# 分别取键值遍历
for k in d:
		print (k, d[ k ])
		
for k,v in d.items():
    print(k, v)
# a 1
# b 2
# c 0

一个字典就是一个键集合与值集合的映射关系。

  • 字典的 keys() 方法返回一个展现键集合的键视图对象。
    • 键视图的一个很少被了解的特性就是它们也支持集合操作，比如集合并、交、差运算。
    • 所以，如果你想对集合的键执行一些普通的集合操作，可以直接使用键视图对象而不用先将它们转换成一个 set。
  • 字典的 items() 方法返回一个包含 (键，值) 对的元素视图对象。
    • 这个对象同样也支持集合操作，并且可以被用来查找两个字典有哪些相同的键值对。
  • 尽管字典的 values()返回一个展现value集合的键视图对象。
    • 但是它并不支持集合操作。某种程度上是因为值视图不能保证所有的值互不相同，这样会导致某些集合操作会出现问题
    • 不过，如果你硬要在值上面执行这些集合操作的话，你可以先将值集合转换成 set，然后再执行集合运算就行了。

遍历顺序

在 Python 3.6 版之前字典不会保留插入顺序，在 CPython 3.6 中插入顺序会被保留，但这在当时被当作是一个实现细节而非确定的语言特性。在 3.7 版本中，dict 对象会保持插入时的顺序这个特性 正式宣布 成为 Python 语言官方规范的一部分。

# Python 3.6字典中的键是无序的。如果要以确定的顺序遍历字典，你可以使用内建方法sorted：
for key in sorted ( d ) :
	 print ( key , d[ key ])

添加/修改元素

  • 字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改
  • 如果在使用 变量名[‘键’] = 数据 时，这个“键”在字典中，不存在，那么就会新增这个元素
# d[key] = value 如果key存在则覆盖，不存在则添加
d['name'] = 'sunwukong' # 修改字典的key-value
d['address'] = '花果山' # 向字典中添加key-value

# setdefault(key[, default]) 可以用来向字典中添加key-value
#   如果key已经存在于字典中，则返回key的值，不会对字典做任何操作
#   如果key不存在，则向字典中添加这个key，并设置value
result = d.setdefault('name','猪八戒')
result = d.setdefault('hello','猪八戒')



# update([other])
# 将其他的字典中的key-value添加到当前字典中
# 如果有重复的key，则后边的会替换到当前的
d = {'a':1,'b':2,'c':3}
d2 = {'d':4,'e':5,'f':6, 'a':7}
d.update(d2)

查找/访问元素

  • 根据k找v
info = {'name':'班长','age':18} 

# 通过[]来获取值时，如果键不存在，会抛出异常 KeyError
print(info['age']) # 获取年龄 
# print(info['sex']) # 获取不存在的key，会发生异常 KeyError


print(info.get('sex')) # 获取不存在的key，获取到空的内容，不会出现异常 
print(info.get('sex'， '男')) # 获取不存在的key, 可以提供一个默认值。


# 嵌套取值
d = {'a': {'name': 'Tom', 'age':18}, 'b': [4,5,6]}
d['b'][1] # 5
d['a']['age'] # 18
  • 逆序查找：
    • 如果你想通过 v 找到 k 呢？有两个问题：
      • 第一，可能有不止一个的键其映射到值 v。你可能可以找到唯一一个，不然就得用 list 把所有的键包起来。
      • 第二，没有简单的语法可以完成逆向查找 (reverse lookup) ；
    • 你必须搜索。
      • 逆向查找比正向查找慢得多；如果你频繁执行这个操作或是字典很大，程序性能会变差。
      • 下面这个函数接受一个值并返回映射到该值的第一个键： 如果我们到达循环结尾，这意味着字典中不存在 v 这个值，所以我们触发一个异常。
def reverse_lookup (d , v ) :
	for k in d :
		if d [ k ] == v :
			return k
raise LookupError ()  # raise 语句能触发异常
# raise LookupError ('value ␣ does ␣not ␣ appear ␣in␣the ␣ dictionary ')

删除元素

  • del：删除指定的元素
info = {'name':'monitor', 'id':100} 
print('删除前,%s'%info) 
del info['name'] # del 也可以直接删除变量 
print('删除后,%s'%info)


#  del info['z'] z不存在，报错

结果：

清空前,{'name': 'monitor', 'id': 100} 
清空后,{'id': 100}
  • del：删除整个字典
info = {'name':'monitor', 'id':100} 
print('删除前,%s'%info) 
del info # del 也可以直接删除变量 
print('删除后,%s'%info)

结果：

删除前,{'name': 'monitor', 'id': 100} 
Traceback (most recent call last): 
File "<stdin>", line 1, in <module> 
NameError: name 'info' is not defined
  • popitem：
    • 随机删除字典中的一个键值对，一般都会删除最后一个键值对
      • 删除之后，它会将删除的key-value作为返回值返回
      • 返回的是一个元组，元组中有两个元素，第一个元素是删除的key，第二个是删除的value
    • 当使用popitem()删除一个空字典时，会抛出异常 KeyError: ‘popitem(): dictionary is empty’
d.popitem()
result = d.popitem()
  • pop(key[, default])
    • 根据key删除字典中的key-value
      • 会将被删除的value返回！
      • 如果删除不存在的key，会抛出异常
      • 如果指定了默认值，再删除不存在的key时，不会报错，而是直接返回默认值
result = d.pop('d')
result = d.pop('z','这是默认值')
  • clear：清空整个字典
info = {'name':'monitor', 'id':100} 
print('清空前,%s'%info) 
info.clear() 
print('清空后,%s'%info)

结果：

清空前,{'name': 'monitor', 'id': 100} 
清空后,{}

应用

获取最大或者最小的key…


prices = { 'ACME': 45.23,
           'AAPL': 612.78,
           'IBM': 205.55,
           'HPQ': 37.20,
           'FB': 10.75
}
  • 获取最大或者最小的key
# 对key操作
print(min(prices))  # AAPL
print(max(prices))  # IBM
  • 获取最大或者最小的value
print(min(prices.values())) #10.75
print(max(prices.values())) #612.78
  • 获取最小值或最大值对应的key
print(min(prices, key=lambda k: prices[k]) ) # Returns 'FB'
print(max(prices, key=lambda k: prices[k]) )# Returns 'AAPL'
  • 获取最大或者最小对应的key和value
# 为了对字典值执行计算操作，通常需要使用 zip() 将字典”反转”为 (值，键) 元组序列。
#		当比较两个元组的时候，值会先进行比较，然后才是键
#		当多个实体拥有相同的值的时候，键会决定返回结果。
min_price = min(zip(prices.values(), prices.keys()))
# min_price is (10.75, 'FB')
max_price = max(zip(prices.values(), prices.keys()))
# max_price is (612.78, 'AAPL')


# 可以使用 zip() 和 sorted() 函数来排列字典数据
prices_sorted = sorted(zip(prices.values(), prices.keys()))
# prices_sorted is [    (10.75, 'FB'), (37.2, 'HPQ'),
#                       (45.23, 'ACME'), (205.55, 'IBM'),
#                       (612.78, 'AAPL')]
  • 执行这些计算的时候，需要注意的是 zip() 函数创建的是一个只能访问一次的迭代器。比如，下面的代码就会产生错误：
prices_and_names = zip(prices.values(), prices.keys())
print(min(prices_and_names)) # OK
print(max(prices_and_names)) # ValueError: max() arg is an empty sequence

怎样在两个字典中寻找相同点（比如相同的键、相同的值等等）

a = {'x' : 1, 'y' : 2, 'z' : 3 }
b = {'w' : 10, 'x' : 11, 'y' : 2 }
  • 可以简单的在两字典的 keys() 或者 items() 方法返回结果上执行集合操作
# Find keys in common
a.keys() & b.keys() # { 'x', 'y' }
# Find keys in a that are not in b
a.keys() - b.keys() # { 'z' }
# Find (key,value) pairs in common
a.items() & b.items() # { ('y', 2) }
  • 这些操作也可以用于修改或者过滤字典元素。比如，假如你想以现有字典构造一个排除几个指定键的新字典。
# Make a new dictionary with certain keys removed
c = {key:a[key] for key in a.keys() - {'z', 'w'}}
# c is {'x': 1, 'y': 2}

做逻辑分支

对于一些逻辑分支功能，字典可以做路由，免去编写if else语句：

route = {True: 'case1', False: 'case2'} # 定义路由
route[7>6] # 'case1' 传入结果为布尔的变量、表达式、函数调用

# 定义计算方法
cal = {'+': lambda x,y: x+y, '*':lambda x,y: x*y}
cal['*'](4,9) # 36 使用

补充

zip函数

  • zip() 函数
    • zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
    • 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
# python3

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 返回一个对象
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped)  # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c))              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]

>>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]
>>>

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

len

len 函数也适用于字典；它返回键值对的个数：

>>> len ( eng2sp )
3

in

in 操作符也适用于字典；它可以用来检验字典中是否存在某个键

>>> 'one ' in eng2sp
True
>>> 'uno ' in eng2sp
False

想要知道字典中是否存在某个值，你可以使用 values 方法，它返回值的集合，然后你可以使用 in 操作符来验证：

>>> vals = eng2sp . values ()
>>> 'uno ' in vals
True

in 操作符对列表和字典采用不同的算法。对于列表，它按顺序依次查找目标，随着列表的增长，搜索时间成正比增长。

对于字典，Python 使用一种叫做哈希表(hashtable) 的算法，这种算法具备一种特性：无论字典中有多少项，in 运算符搜索所需的时间都是一样的。

get

字典类有一个 get 方法，接受一个键和一个默认值作为参数。如果字典中存在该键，则返回对应值；否则返回传入的默认值。

>>> h = histogram ('a')
>>> h
{'a': 1}
>>> h . get ('a', 0)
1
>>> h . get ('b', 0)

sort:排序

  • 现有字典 d= {‘a’:24,‘g’:52,‘i’:12,‘k’:33}请按value值进行排序?
sorted(d.items(),key=lambda x:x[1])

x[0]代表用key进行排序;x[1]代表用value进行排序

OceanStar的学习笔记
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Python学习：字典
百锦再的博客
03-25 3万+
在字典中，键必须是唯一的，并且通常是不可变的数据类型，比如字符串、数字或元组。键的不可变性：字典的键必须是不可变（immutable）的类型，比如字符串、数字或元组，因为键作为哈希值的索引需要保持稳定性。唯一键：字典中的键必须是唯一的，不能存在重复的键。数据存储：字典使用键值对的形式存储数据，对应关系是通过键来建立的，通过键可以快速地查找和访问对应的值。动态性：字典的大小是动态的，可以根据需要随时添加或删除键值对，灵活地适应不同的需求。需要注意的是，字典是无序的，即不保证键值对的顺序与添加顺序相同。
python字典分组_Python：将字典中的列表项分组
weixin_39540834的博客
12-08 2403
我想从词典列表中生成字典，并按某些键的值将列表项分组，例如：input_list = [{'a':'tata', 'b': 'foo'},{'a':'pipo', 'b': 'titi'},{'a':'pipo', 'b': 'toto'},{'a':'tata', 'b': 'bar'}]output_dict = {'pipo': [{'a': 'pipo', 'b': 'titi'},{'a...
Python：字典翻转输出
WQ的博客
03-29 8506
【描述】 读入一个字典类型的字符串，反转其中键值对输出。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬ 即，读入字典key:value模式，输出value:key模式。 【输入格式】 用户输入的字典格式的字符串，如果输入不正确，提示：输入错误。 【输出格式】 给定字典d，按照print(d)方式输出 【输入格式】 {"a":1,"b":2} 【输出格式】 {1:'a...
Python：字典转元组
鞠勇鸿的技术专栏
02-13 8381
dict = {"Name": "JYH", "Age": 18} print(dict) print(tuple(dict)) print(tuple(dict.values())) # 输出： # {'Name': 'JYH', 'Age': 18} # ('Name', 'Age') # ('JYH', 18)
Python：字典的基本定义使用
有意栽花花不发，无心插柳柳成荫。
01-23 1802
今天，我们来学习Python字典的使用。 1.定义一个字典 定义字典格式： 字典名称 = {键1: 值1, 键2: 值3, ······, 键n: 值n} 照此格式，定义字典score： # 一个存储考试成绩的字典 score = {"语文": 93.5, "英语": 99, "数学": 100} 如上代码，我们定义字典score，按照了Python所允许的格式定义字典，这样更美观一点。 2.查找字典键所对应值 很简单，指定键名称就可以查找了： print(score["语文"]) 3.添
Python：字典嵌套字典的数据类型，如何取出字典外部以及层级嵌套字典的键值对
J_____Q的博客
10-13 2621
思路整理： 1. 循环遍历取出外层的 key 和 value 的值 2、判断遍历后的 value 数据类型是否为：字典 dict 3、if true，则再次循环遍历取出 key 和 value 的值 代码实现： # -*--*- coding: utf-8 -*--*- # @Time : 2021/10/13 21:23 # @Author : PythonKimo # @File : demo_test.py # -*-*-*-*-*-*-*-*-*-*-*-*-*- ''' .
Python:字典的查询、更新、增加（案例）
lwh_fighting的博客
10-31 5006
字典的查询、更新、增加（案例） 查询 有字典 dict1 = {‘赵广辉’:‘13299887777’,‘特朗普’:‘814666888’,‘普京’:‘522888666’,‘吴京’:‘13999887777’}，编程实现查找功能，用户输入姓名，如在字典中存在，输出“姓名：电话”，如不存在，则输出“数据不存在”。 输入格式：一个姓名‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪
Python字典添加元素
热门推荐
王员外的博客
01-05 38万+
手动推荐知识点 字典创建-> 创建字典（7种方式） 删除元素-> 字典删除元素（6种方式） 修改元素-> 字典修改元素（4种方式） 遍历元素-> 字典遍历元素（4种方式） 查找元素-> 字典查找元素（3种方式） 本文使用代码 book_dict = {"price": 500, "bookName": "Python设计", "weight": "250g"} 第一种方式：使用[] book_dict["owner"] = "tyson" 说明：中.
python系列之：字典update
zhengzaifeidelushang的博客
03-18 6267
python系列之：字典update一、字典不存在键值update二、字典已经存在键值update 一、字典不存在键值update 字典不存在键值，使用update会添加键值对到字典中 account = "optics" decrypt_passwd = "12345abc" accountDict = {} accountDict.update({account:decrypt_passwd}) print(accountDict) 输出如下所示： {‘optics’: ‘12345abc’} 二、
python：在字典中增加键值对
听海边涛声
01-11 1658
python：在字典中增加键值对
python中的序列：字典、集合
12-22
Python中的序列类型包括多种，本文主要讨论两种特殊的序列——字典和集合。它们都是Python中重要的数据结构，各自具有独特的特性和用途。 1. **字典（Dictionary）** - **字典的创建**：字典是键值对的无序可变...
Python语言基础项目案例：字典的操作.pptx
05-05
通过这些操作，我们可以深入理解Python字典的基本特性和操作。字典是一种关联数据结构，允许我们使用键来存储和访问值，而无需关心它们在字典内部的顺序。`dict1.update(dict2)`操作使得`dict1`包含了`dict2`的所有...
Python语言基础：字典概述.pptx
05-05
总结起来，Python字典提供了一种灵活且高效的方式来存储和操作键值对数据。它们在处理关联数据、快速查找和更新信息时具有很高的实用性。在实际编程中，掌握字典的使用是至关重要的，因为它们在很多场景下都是首选的...
第六章：Python字典
12-21
Python字典是编程语言中非常重要的数据结构，它以键值对的形式存储数据，不同于列表等其他序列类型，字典不依赖于元素的顺序，而是通过键来访问对应的值。在Python中，字典的创建通常使用大括号 `{}` 来实现。 一、...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1197
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
【C++】：红黑树深度剖析 --- 手撕红黑树！
最新发布
2301_77900444的博客
07-25 1691
就是太过追求绝对平衡，比如在插入时要维护其绝对平衡，旋转次数太多，在删除时甚至有可能要一直旋转到根位置，使之性能低下。本篇文章介绍的红黑树也是一种平衡树，是通过改变节点颜色以及旋转操作，使之接近平衡。红黑树比AVL树的用途更加广泛，在一些方面效率甚至要优于AVL树，并且 map/set 的底层封装用的也是红黑树。红黑树的节点结构与AVL树的大致相同，只是AVL树中有节点的颜色，没有平衡因子。//枚举颜色RED,BLACK,_kv(kv){}
C++ primer plus 第16章string 类和标准模板库, 关联容器
zhyjhacker的博客
07-25 664
C++ primer plus 第16章string 类和标准模板库, 关联容器。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 275
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值