【编程语言】Python基础知识整理

一、Python基础语法

  • 版本:Python 3.7

1. 注释方法

  • 单行注释:# 注释内容(快捷键:Ctrl+ /)
  • 多行注释:''' 注释内容 '''"""注释内容"""

2. 关键字

  • 关键字一共33个,FalseNoneTrue的首字母大写,其他全部是小写
    在这里插入图片描述

3. 标识符

1、标识符的命名规则(必须遵守)

  • 由数字、字⺟、下划线_组成
  • 不能数字开头
  • 不能使⽤内置关键字
  • 严格区分⼤⼩写

2、标识符的命名规范(建议遵守)

  • ⻅名知意
  • ⼤驼峰:即每个单词⾸字⺟都⼤写,例如: XxxYyyy
  • ⼩驼峰:第⼆个(含)以后的单词⾸字⺟⼤写,例如: xxxYyy
  • 下划线:例如: xxx_yyy

4. 变量

1、 单个变量赋值
变量名 = 值

2、 多个变量赋值
变量名1,变量名2,变量名3 = 值1,值2,值3

3.、多变量赋相同值
变量名1 = 变量名2 = 变量名3 = 值

5. 数据类型

(1)整型

1、整型int

2、创建整型变量名 = 整数

创建空整型: 变量名 = int()

(2)浮点型

1、浮点型float

2、创建浮点型变量名 = 浮点数

创建空浮点型: 变量名 = float()

(3)布尔型

1、布尔型bool

2、创建布尔型变量名 = True变量名 = False

创建空布尔型: 变量名 = bool()

(4)字符串

1、字符串str

2、创建字符串

  • 单引号'字符串'"字符串"
  • 三引号(支持换行):'''字符串'''"""字符串"""

创建空字符串:''str()

3、常用操作

  • 查找

下标(计算机为数据序列中每个元素分配的从0开始的编号):字符串序列[下标位置]

切片字符串序列[开始位置下标:结束位置下标:步长]

  • 结束位置下标:-1代表倒数第一个数据
  • 步长:选取间隔,默认为1,正负数均可,-1代表从结束位置开始往前取
  • 最多取到结束位置下标的前一个数据

方法

  • find()
    功能:检测某个⼦串是否包含在这个字符串中,如果在,则返回这个⼦串开始的位置下标,否则返回-1
    语法字符串序列.find(⼦串, 开始位置下标, 结束位置下标)
  • index()
    功能:检测某个⼦串是否包含在这个字符串中,如果在,则返回这个⼦串开始的位置下标,否则抛出异常
    语法字符串序列.index(⼦串, 开始位置下标, 结束位置下标)
  • rfind()
    功能:和find()功能相同,但查找⽅向为右侧开始
    语法字符串序列.rfind(⼦串, 开始位置下标, 结束位置下标)
  • rindex()
    功能:和index()功能相同,但查找⽅向为右侧开始
    法:字符串序列.rindex(⼦串, 开始位置下标, 结束位置下标)
  • count()
    功能:返回某个⼦串在字符串中出现的次数
    语法字符串序列.count(⼦串, 开始位置下标, 结束位置下标)
  • 若省略开始和结束位置下标,表示在整个字符串序列中查找
  • 修改(不能直接修改原字符串,需要赋值到变量)

方法

  • replace()
    功能:替换
    语法字符串序列.replace(旧⼦串, 新⼦串, 替换次数)
  • split()
    功能:按照指定字符分割字符串
    语法字符串序列.split(分割字符, 分割字符出现的次数)
  • join()
    功能:⽤⼀个字符或⼦串合并字符串
    语法字符或⼦串.join(多字符串序列组成的列表序列)
  • capitalize()
    功能:将字符串的第⼀个字符转换成⼤写
    语法字符串序列.capitalize()
  • title()
    功能:将字符串每个单词⾸字⺟转换成⼤写
    语法字符串序列.title()
  • lower()
    功能:将字符串中的⼤写全部转成⼩写
    语法字符串序列.lower()
  • upper()
    功能:将字符串中的⼩写全部转成⼤写
    语法字符串序列.upper()
  • lstrip()
    功能:删除字符串左侧空⽩字符
    语法字符串序列.lstrip()
  • rstrip()
    功能:删除字符串右侧空⽩字符
    语法字符串序列.rstrip()
  • strip()
    功能:删除字符串两侧空⽩字符
    语法字符串序列.strip()
  • ljust()
    功能:使⽤指定字符(默认空格)填充⾄对应⻓度的新字符串,且字符串左对⻬
    语法字符串序列.ljust()
  • rjust()
    功能:使⽤指定字符(默认空格)填充⾄对应⻓度的新字符串,且字符串右对⻬
    语法字符串序列.rjust()
  • center()
    功能:使⽤指定字符(默认空格)填充⾄对应⻓度的新字符串,且字符串居中对⻬
    语法字符串序列.center()
  • 判断

方法

  • startswith()
    功能:检查字符串是否是以指定⼦串开头,是则返回 True,否则返回 False
    语法字符串序列.startswith(⼦串, 开始位置下标, 结束位置下标)
  • endswith()
    功能:检查字符串是否是以指定⼦串结尾,是则返回 True,否则返回 False
    语法字符串序列.endswith(⼦串, 开始位置下标, 结束位置下标)
  • isalpha()
    功能:如果字符串⾄少有⼀个字符,且所有字符都是字⺟,则返回 True, 否则返回 False
    语法字符串序列.isalpha()
  • isdigit()
    功能:如果字符串只包含数字,则返回 True,否则返回 False
    语法字符串序列.isdigit()
  • isalnum()
    功能:如果字符串⾄少有⼀个字符,且所有字符都是字⺟或数字,则返回 True,否则返回 False
    语法字符串序列.isalnum()
  • isspace()
    功能:如果字符串中只包含空⽩,则返回 True,否则返回 False
    语法字符串序列.isspace()

(5)列表

1、列表list,用来存储多个数据

2、创建列表[数据1,数据2,数据3,数据4...]

创建空列表:[]list()

3、常用操作

  • 查找

下标列表序列[下标位置]

切片列表序列[开始位置下标:结束位置下标:步长]

  • 结束位置下标:-1代表倒数第一个数据
  • 步长:选取间隔,默认为1,正负数均可,-1代表从结束位置开始往前取
  • 最多取到结束位置下标的前一个数据

方法

  • index()
    功能:返回指定数据所在位置的下标,如果查找的数据不存在则报错
    语法列表序列.index(数据, 开始位置下标, 结束位置下标)
  • count()
    功能:统计指定数据在当前列表中出现的次数
    语法列表序列.count(数据)
  • len()
    功能:返回列表⻓度,即列表中数据的个数
    语法len(列表序列)
  • 增加(直接在原列表⾥加指定数据,即修改原列表)

方法

  • append()
    功能:在列表结尾追加数据,如果追加的数据是⼀个序列,则追加整个序列到列表
    语法列表序列.append(数据)
  • extend()
    功能:在列表结尾追加数据,如果追加的数据是⼀个序列,则将此序列的数据逐⼀添加到列表
    语法列表序列.extend(数据)
  • insert()
    功能:在指定位置新增数据
    语法列表序列.insert(位置下标, 数据)
  • 删除

方法

  • del / del()
    功能:删除列表或列表指定数据
    语法del 列表序列 / del(列表序列[下标])
  • pop()
    功能:删除指定下标的数据(默认为最后⼀个),并返回该数据
    语法列表序列.pop(下标)
  • remove()
    功能:移除列表中某个数据的第⼀个匹配项
    语法列表序列.remove(数据)
  • clear()
    功能:清空列表
    语法列表序列.clear()
  • 修改

下标列表序列[下标] = 新值

方法

  • reverse()
    功能:逆置
    语法列表序列.reverse()
  • sort()
    功能:排序
    语法列表序列.sort(key = 方法,reverse = 布尔值)
    参数key代表对列表内每个数据应用的方法(默认为None) ;reverse代表排序规则,True为降序,False为升序(默认)

(6)元组

1、元组tuple,用来存储多个数据,但数据不能直接修改

若存储的数据为可修改数据类型:如列表,则可以修改列表中的数据,但不能直接修改整个列表

2、创建元组(数据1,数据2,数据3,数据4...)

创建空元组:()tuple()
创建单个数据元组:(数据1,)

3、常用操作(查找)

下标元组序列[下标]

方法

  • index()
    功能:查找某个数据,如果数据存在返回对应的下标,否则报错
    语法元组序列.index(数据)
  • count()
    功能:统计某个数据在当前元组出现的次数
    语法元组序列.count(数据)
  • count()
    功能:统计元组中数据的个数
    语法len(元组序列)

(7)字典

1、字典dict,字典⾥⾯的数据以键值对(key:value)形式出现,但不⽀持下标

2、创建字典{key1:value1,key1:value2...}

创建空字典:{}dict()

3、常用操作

  • 修改/增加(直接在原字典⾥修改/增加数据,即修改原字典)

方法

  • append()
    功能:如果字典中存在此key,则修改对应的值;如果不存在,则新增此键值对
    语法字典[key] = 值
  • 删除

方法

  • del / del()
    功能:删除字典或删除字典中指定键值对
    语法del 字典 / del(字典[key])
  • clear()
    功能:清空字典
    语法字典.clear()
  • 查找

索引字典[key值],如果当前查找的key存在,则返回对应的值,否则则报错

方法

  • get()
    功能:如果当前查找的key不存在,则返回第⼆个参数(默认值),如果省略第⼆个参数,则返回
    None
    语法字典.get(key, 默认值)
  • keys()
    功能:返回字典中的所有key
    语法字典.keys()
  • values()
    功能:返回字典中的所有value
    语法字典.values()
  • items()
    功能:返回字典中的所有键值对
    语法字典.items()

(8)集合

1、集合set,可以去掉重复数据,但不⽀持下标

2、创建集合{数据1,数据2,数据3...}

创建空集合:set()

3、常用操作

  • 增加

方法

  • add()
    功能:追加数据,但若追加的数据为当前集合已有数据,则不进⾏任何操作
    语法集合.add()
  • update()
    功能:追加序列数据,将此序列的数据逐⼀添加到集合
    语法集合.update()
  • 删除

方法

  • remove()
    功能:删除集合中的指定数据,如果数据不存在则报错
    语法集合.remove(数据)
  • discard()
    功能:删除集合中的指定数据,如果数据不存在也不会报错
    语法集合.discard(数据)
  • pop()
    功能:随机删除集合中的某个数据,并返回这个数据
    语法集合.pop()

6. 转换数据常用方法

方法说明
int(x [,base])将x转换为⼀个整数
float(x)将x转换为⼀个浮点数
str(x)将对象 x 转换为字符串
list(s)将序列 s 转换为⼀个列表
tuple(s)将序列 s 转换为⼀个元组
set(s)将序列 s 转换为⼀个集合
complex(real [,imag])创建⼀个复数,real为实部,imag为虚部
repr(x)将对象 x 转换为表达式字符串
eval(str)将str转换为str表达式原本的数据类型
chr(x)将⼀个整数转换为⼀个Unicode字符
ord(x)将⼀个字符转换为它的ASCII整数值
hex(x)将⼀个整数转换为⼀个⼗六进制字符串
oct(x)将⼀个整数转换为⼀个⼋进制字符串
bin(x)将⼀个整数转换为⼀个⼆进制字符

7. 数据容器的通用操作

1、运算符

运算符描述⽀持的容器类型
+合并字符串、列表、元组
*复制字符串、列表、元组
in元素是否存在字符串、列表、元组、字典
not in元素是否不存在字符串、列表、元组、字典

2、常用方法

方法描述支持的容器类型
len()计算容器中元素个数字符串、列表、元组、字典、集合
max()返回容器中元素最⼤值字符串、列表、元组、字典、集合
min()返回容器中元素最⼩值字符串、列表、元组、字典、集合
range(start,end,step)⽣成从start到end,步⻓为 step的数字列表,在for循环使⽤,做为数据对象的下标索引字符串、列表、元组
enumerate(数据对象,start = )将⼀个可遍历的数据对象组合为⼀个索引序列,同时列出数据和数据下标,start为索引起始值参数字符串、列表、元组、字典、集合

3、推导式

  • 列表:列表 = [xx for .. in 数据序列]
 # 举例:返回0-9的偶数列表
 list1 = [i for i in range(10) if i % 2 == 0]
 print(list1)
 # [0,2,4,6,8]
  • 字典:字典 = {xx1:xx2 for .. in 数据序列}
 # 举例:将两个列表内元素打包为字典
list1 = ['name', 'age']
list2 = ['Jack', 18]
dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)
# {'name': Jack, 'age': 18}
  • 集合:集合 = {xx for .. in 数据序列}
 # 举例:用集合形式打印列表内元素的2次方
list1 = [1, 1, 2]
set1 = {i ** 2 for i in list1}
print(set1 )
# {1,4}

8. 运算符

分类运算符
算数运算符+-*///%**()
赋值运算符=
复合赋值运算符+=-=*=/=//=%=**=
⽐较运算符=!=><>=<=
逻辑运算符andornot

1、算数运算符

运算符描述
+
-
*
/
//整除
%取余
**指数
()⼩括号

优先级() ⾼于 ** ⾼于 * / // % ⾼于 + -

2、赋值运算符

运算符描述
=赋值

3、复合赋值运算符

运算符描述
+=加法赋值运算符
-=减法赋值运算符
*=乘法赋值运算符
/=除法赋值运算符
//=整除赋值运算符
%=取余赋值运算符
**=幂赋值运算符

优先级

  1. 先算复合赋值运算符右侧的表达式
  2. 再算复合赋值运算的算数运算
  3. 最后算赋值运算

4、⽐较运算符

  • 返回 True 或 False
运算符描述]=
==等于
!=不等于
>大于
<小于
>=大于等于
<=小于等于

5、逻辑运算符

  • 返回 True 或 False
运算符描述
and
or
not

数字之间的逻辑运算

  • and运算符,只要有⼀个值为0,则结果为0,否则结果为最后⼀个⾮0数字
  • or运算符,只有所有值为0结果才为0,否则结果为第⼀个⾮0数字

9. 输入输出

1、输⼊

  • 语法:input('提示⽂字')
  • input()会把接收到的任意数据都当做字符串处理

2、输出

  • 语法:print('输出的字符串')

  • 转义字符

  • \n :换⾏
  • \t :制表符,⼀个tab键(4个空格)的距离
  • 结束符
  • end="\n" :默认结束符(默认换行),可修改
  • 格式化输出
  • 单个格式化输出:print('格式化符号' % 表达式)
  • 多个格式化输出:print('格式化符号1,格式化符号2' % (表达式1, 表达式2))
  • Python3.6中新增的格式化⽅法:print(f'{表达式}')
  • 常用格式符号
格式符号转换
%s字符串
%d有符号的⼗进制整数
%f浮点数
%c字符
%u⽆符号⼗进制整数
%o⼋进制整数
%x⼗六进制整数(⼩写ox)
%X⼗六进制整数(⼤写OX)
%e科学计数法(⼩写e)
%E科学计数法(⼤写E)
%g%f和%e的简写
%G%f和%E的简写
  • %06d:表示输出的整数显示6位数,不⾜以0补全,超出当前位数则原样输出
  • %.2f:表示⼩数点后显示2位小数

10. 条件语句

  • if…
if 条件语句:
	条件成⽴执⾏的代码
  • if…else…
if 条件语句:
	条件成⽴执⾏的代码
else:
	条件不成⽴执⾏的代码
  • 多重判断
if 条件1:
	条件1成⽴执⾏的代码
elif 条件2:
	条件2成⽴执⾏的代码
else:
	以上条件都不成⽴执⾏的代码
  • if嵌套
if 条件1:
	条件1成⽴执⾏的代码
	if 条件2:
		条件2成⽴执⾏的代码
		...
  • 三⽬运算符:条件成⽴执⾏的表达式 if 条件 else 条件不成⽴执⾏的表达式

11. 循环语句

1、while 循环

  • while…
while 条件:
	条件成⽴重复执⾏的代码
  • while…else…
while 条件:
   条件成⽴重复执⾏的代码
else:
   循环正常结束后执⾏的代码

2、for 循环

  • for…in…
for 临时变量 in 序列:
	重复执⾏的代码
  • for…in…else…
for 临时变量 in 序列:
	重复执⾏的代码
else:
	循环正常结束后执⾏的代码

3、跳出循环

  • continue:跳出本次循环,继续执⾏下⼀次重复执⾏的代码
  • break:跳出整个循环,且不执⾏else里的代码

二、函数

1. 定义函数

  • 函数的作⽤:封装代码,⾼效的代码复用
  • 定义方法(函数必须先定义后使⽤)
def 函数名(参数):
	# 也可以不带参数
	代码

2. 调用函数

  • 调用方法:函数名(参数)

1、嵌套:⼀个函数⾥⾯⼜调⽤了另外⼀个函数

# 举例:
def testB():
	print('这⾥是testB函数执⾏的代码')

def testA():
	print('---- testA start----')
	testB()
	print('---- testA end----')
	
testA()
# ---- testA start----
# 这⾥是testB函数执⾏的代码
# ---- testA end----

2、递归:函数内部⾃⼰调⽤⾃⼰

# 举例:计算 1 + 2 + 3
def sum_numbers(num):

	# 如果是1,则直接返回1
	if num == 1:
		return 1
		
	# 如果不是1,则重复调用自己
	return num + sum_numbers(num-1)

sum_result = sum_numbers(3)
print(sum_result)
# 6

3. 函数参数

  • 作用:函数调⽤的时候可以传⼊真实数据,增⼤函数的使⽤的灵活性
  • 形参:函数定义时的参数
  • 实参:函数调⽤时的参数

1、位置参数

  • 调⽤函数时,根据函数定义的参数位置来传递参,形参和实参的个数和顺序必须⼀致
# 举例:
def user_info(name, age):
	print(f'您的名字是{name}, 年龄是{age}')

user_info('Jack', 18)
# 您的名字是Jack, 年龄是18

2、关键字参数

  • 调⽤函数时,通过key=value形式加以指定,关键字参数之间不存在先后顺序
  • 如果有位置参数,位置参数必须在关键字参数的前⾯
# 举例:
def user_info(name, age, gender):
	print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')

user_info('Jack', gender='男', age=18)
# 您的名字是Jack, 年龄是18, 性别是男

3、 默认参数

  • 定义函数时,通过key=value形式为参数提供默认值
  • 调⽤函数时,可以修改默认参数值
  • 如果有位置参数,位置参数必须出现在默认参数前面
# 举例:
def user_info(name, age, gender='男'):
	print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')

user_info('Jack', 20)
# 您的名字是Jack, 年龄是20, 性别是男
user_info('Rose', 18, '⼥')
# 您的名字是Rose, 年龄是18, 性别是女

4、可变位置参数

  • 收集所有位置参数,返回⼀个元组
# 举例:
def user_info(*args):
	print(args)
	
user_info('Jack') 
# ('Jack',)
user_info('Jack', 18) 
# ('Jack', 18)

5、可变关键字参数

  • 收集所有关键字参数,返回⼀个字典
# 举例:
def user_info(**kwargs):
	print(kwargs)

user_info(name='Jack', age=18, gender='男')
# {'name': 'Jack', 'age': 18, 'gender': '男'}

4. 函数返回值

1、返回值语法

  • 返回单个数据:return 表达式
  • 返回多个数据:
  • 返回元组:return 表达式1, 表达式2..return (表达式1, 表达式2..)
  • 返回列表:return [表达式1, 表达式2..]
  • 返回字典/集合:return {表达式1, 表达式2..}

2、返回值拆包

  • 列表/元组/集合拆包
# 举例:
def return_num():
	return [100, 200]
	# 也适用于以下表达式
	# return 100,200
	# return (100,200)
	# return {100,200}
	
num1, num2 = return_num()
print(num1) # 100
print(num2) # 20
  • 字典拆包:取出来的是字典的key
# 举例:
dict1 = {'name': 'TOM', 'age': 18}
a, b = dict1

print(a) # name
print(b) # age
  • 交换变量值
  • 方法一:借助第三变量存储数据
  • 方法二:变量对调
# 举例:
a, b = 1, 2
a, b = b, a
print(a)  # 2
print(b)  # 1

5. 函数说明文档

  • 定义文档语法
def 函数名(参数):
	""" 说明⽂档的位置 """
	代码
  • 查看文档语法:help(函数名)

6. 变量作⽤域

  • 全局变量:在函数体内、外都能⽣效的变量
  • 局部变量:只在函数体内部⽣效的变量(在函数体内临时保存数据,当函数调⽤完成后,则销毁局部变量)
  • 在函数中修改全局变量:global关键字声明全局变量
# 举例:
a = 100

def test():
	global a
	a = 200
	print(a)

test() # 200

7. 变量值的引用

变量值是靠引⽤来传递的,当修改变量时,可以根据变量的内存地址变化情况,将数据分为可变类型和不可变类型

  • 可变类型(内存地址不变):列表、字典、集合
  • 不可变类型(内存地址有变化):整型、浮点型、字符串、元组
# 举例:1. 整型
a = 1
b = a

print(id(a)) # 140715006346912
print(id(b)) # 140715006346912

a = 2
print(id(a)) # 140715006346944,内存地址有变化
print(id(b)) # 140715006346912
# 举例:2. 列表
aa = [10, 20]
bb = aa
print(id(aa)) # 2011069398720
print(id(bb)) # 2011069398720

aa.append(30)
print(id(aa)) # 2011069398720,内存地址不变
print(id(bb)) # 2011069398720

可以⽤id()来判断两个变量是否为同⼀个值的引⽤,id的值代表变量内存的地址标识

8. lambda表达式

1、适用场景:函数有⼀个返回值,且只有⼀句代码

2、语法lambda 参数列表:表达式

  1. lambda表达式能接收任何数量的参数,但只能返回⼀个表达式的值
  2. 直接打印lambda表达式,输出的是此lambda的内存地址

3、lambda的参数形式

  • ⽆参数:lambda: 表达式
  • 位置/关键字参数:lambda 参数:表达式
  • 默认参数:lambda key=value:表达式
  • 可变位置参数:lambda *args:表达式
  • 可变关键词参数:lambda **kwargs:表达式
# 举例:使列表数据按字典key的值排序
students = [
	{'name': 'TOM', 'age': 20},
	{'name': 'ROSE', 'age': 19},
	{'name': 'Jack', 'age': 22}
	]

# 按name值升序排列
students.sort(key=lambda x: x['name'], reverse=False)
print(students)
# [{'name': 'Jack', 'age': 22}, {'name': 'ROSE', 'age': 19}, {'name': 'TOM', 'age': 20}]

9. 高阶函数

1、高阶函数作⽤:把函数作为参数传⼊,化简代码

# 举例:任意两个数字,按照指定函数处理后再进⾏求和计算
def sum_num(a, b, f):
	return f(a) + f(b)

result = sum_num(-1, 2, abs)
print(result) # 3

2、内置⾼阶函数

  • map()

语法:map(func, lst),将传⼊的函数变量func作⽤到序列的每个元素中,并将结果组成新的迭代器返回

# 举例:将列表内元素依次乘以2次方
list1 = [1, 2, 3, 4, 5]
def func(x):
	return x ** 2

result = map(func, list1)
print(result) # <map object at 0x000001D43D121C70>
print(list(result)) # [1, 4, 9, 16, 25]
  • filter()

语法:filter(func, lst),⽤于过滤掉序列中不符合条件的元素,返回⼀个 filter 对象

# 举例:去掉列表中的奇数
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def func(x):
	return x % 2 == 0
	
result = filter(func, list1)
print(result) # <filter object at 0x000001D43D121AC0>
print(list(result)) # [2, 4, 6, 8, 10]
  • reduce()

语法:reduce(func,lst),func每次计算的结果继续和序列的下⼀个元素做累积计算,其中func必须有两个参数

# 举例:计算列表中各个数字的累加和
import functools

list1 = [1, 2, 3, 4, 5]
def func(a, b):
	return a + b

result = functools.reduce(func, list1)
print(result) # 15
  • 7
    点赞
  • 93
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值