Python-基础

  第一章:python语言基础

11python语言概述

Python是一种多功能、高级的编程语言,广泛应用于多个领域。

应用范围

  • 科学计算:利用NumPy、SciPy等库进行高效计算。
  • 大数据:通过Pandas、PySpark等处理大量数据。
  • GUI开发:使用Tkinter、PyQt等库创建图形用户界面。
  • WEB服务端和大型网站后端:如Django、Flask等框架。
  • 云计算:适用于AWS、Azure等平台的自动化和管理。
  • 系统运维:用于自动化脚本和DevOps工具。
  • 嵌入式设备:如Raspberry Pi等。
  • 移动设备:通过Kivy等库开发移动应用。
  • 游戏开发:使用Pygame等库。
  • 人工智能:TensorFlow、PyTorch等库用于机器学习和深度学习。

Python不适用的场景

Python由于是解释型语言,其运行效率在某些性能驱动的应用中不如编译型语言(如C/C++/Java/Go)。在这些场景下,考虑使用这些替代语言可能更合适。特别是Go,它运行效率类似C,但语法简洁,接近Python。

版本兼容问题

Python 2.x已停止支持,建议使用Python 3.x。对于遗留的2.x代码,可以使用2to3工具进行迁移。

解释器

  • CPython:官方解释器,用C语言编写。
  • Jython:运行在Java平台,可调用Java类库。
  • IronPython:适用于.NET平台,可调用.NET类库。
  • PyPy:用Python编写的解释器,注重提高执行速度。

开发环境

IDE(集成开发环境)提供了更便捷的编程体验。常见的有:

  • IDLE:Python官方IDE。
  • PyCharm:功能强大的专业IDE。
  • WingIDE:另一个专业的Python IDE。
  • Eclipse + PyDev:适用于多种语言的IDE。
  • IPython:一个更加强大的交互式解释器。

交互模式

  1. 打开命令行,输入python并回车。
  2. 出现>>>提示,表示已进入交互模式。
  3. 退出交互模式:Ctrl+Z后回车、输入quit()后回车、Ctrl+C或点击窗口关闭按钮。

IDLE使用介绍

IDLE是Python自带的IDE,提供了一些实用的快捷键:

  • Alt+N/P:浏览历史命令。
  • Ctrl+F6:重启IDLE。
  • F1:打开帮助文档。
  • Alt+/:自动补全。
  • Ctrl+[/]:代码缩进。
  • Alt+M:查看模块源码。
  • Alt+C:类浏览器。
  • F5:运行程序。

12人机交互

121 概述

Python中的人机交互主要体现为两种形式:

  • 键盘交互(标准输入输出):通过键盘输入数据到程序,程序处理后将结果显示在屏幕上。
  • 文件交互:程序从文件中读取数据,运行后可以将结果写入文件。

在标准输入中,程序将键盘输入的文本数据转换为相应的数据类型。标准输出则将程序结果转换为字符型,显示在屏幕上。

122 输入输出函数

  • input(): 用于接收用户输入。
  • print(): 用于输出信息到控制台。

print() 函数的格式

print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
  • value输出对象,多个对象以逗号隔开。
  • sep输出对象之间的分隔符,默认为空格。
  • end输出语句的结束字符,默认为换行符。
  • file设置输出目的地,默认为显示器。
  • flush是否立即输出,默认为否。

123 格式控制串

使用格式化字符串,可以按照特定的格式输出变量。格式化字符串的基本形式为 '格式控制串' % (值序列)

常见格式控制符号

  • %f浮点数
  • %o八进制整数
  • %d十进制整数
  • %x十六进制整数
  • %s字符串
  • %e科学计数法
  • %%输出百分号%
a = 1.234
b = 10
c = 10000
d = 'hello'
print('The float is %f and the 10 int is %d, the ten is %e and the string is %s' % (a, b, c, d))

对于浮点数 %f,还可以指定字段宽度和精度,如 %x.yf,其中 x 是字段宽度,y 是小数点后的精度。

124 输入/输出重定向

在Python中,可以使用系统模块 sys 来重定向标准输入和输出。

  • sys.stdin:标准输入
  • sys.stdout:标准输出

控制台中的重定向

  • '<':输入重定向
  • '>':输出重定向

13对象与变量

131 对象

在Python中,对象具有三个主要特征:

  • 标识(Identity):对象在内存中的地址。使用 id(对象) 查询。
  • 类型(Type):对象存储数据的类型。使用 type(对象) 查询。
  • 值(Value):对象存储的数据信息。使用 print(对象) 查看。

132 变量

变量是存储在内存中的数据的表示。它具有以下特征:

  • 声明变量的方式变量名 = 表达式
  • 变量赋值:使用变量前必须先赋值。

变量的使用方法

  • 删除变量del 变量名
  • 链式赋值变量名1 = 变量名2 = ... = 变量名n = 表达式
  • 系列解包赋值变量名1, 变量名2, ..., 变量名n = 1, 2, ..., n
  • 变量交换:使用元组解包来实现变量交换,例如:
    变量名1, 变量名2 = 变量名2, 变量名1
    print(变量名1, 变量名2)  # 输出: b a
    

133 Python动态类型

Python是一种动态类型语言,这意味着变量的类型在运行时根据引用的对象自动确定。

134 Python常量

Python本身没有内置的常量类型。通常,通过约定俗成的命名规范来表示常量,例如使用全大写字母。虽然技术上可以修改这些“常量”,但通常应避免这样做。

135 引用

在Python中,变量本质上是对象的引用。变量存储的是对象的内存地址。变量本身存储在栈内存中,而对象存储在堆内存中。

14编码规范与注释

141 程序和模块

  • Python程序:由模块组成,每个模块对应一个源文件(.py格式)。
  • Python模块:由语句组成,语句按照在模块中的顺序执行。
  • Python语句:是程序的构造单元,用于创建对象、变量赋值、创建函数、控制语句等。

142 文件的创建和执行

在IDLE环境中:

  • 通过 File > New File 创建新文件。
  • 通过 File > Save/Save As 保存文件(保存为 .py 格式)。
  • 执行文件,可以按 F5 或选择 Run > Run Module

143 代码的组织和缩进

Python使用缩进来定义代码块。通常,一个缩进等于四个空格。

144 使用注释

  • 单行注释:使用 # 后跟注释内容。
  • 多行注释:使用三个单引号 ''' 或三个双引号 """ 包围注释内容。

145 使用行连接符

当一行代码太长时,可以使用反斜杠 \ 作为行连接符,将代码分成多行。

146 标识符

标识符是变量、函数、类、模块等的名称。它们遵循以下规则:

  • 区分大小写。
  • 第一个字符必须是字母或下划线。
  • 不能使用Python关键字,如 iforwhile 等。
  • 避免使用双下划线。

命名约定:

  • 模块和包名:全小写,多个单词用下划线连接。
  • 函数名:全小写,多个单词用下划线连接。
  • 类名:首字母大写,多个单词用下划线连接。
  • 常量名:全大写,多个单词用下划线连接。

若要查找Python关键字,可以在Python解释器中使用 help(),然后输入 keywords

第二章:数值类型

21数值类型

211数值类型

Python支持多种数值类型,包括:

  • 简单数据类型

    • 整型(int):正整数、零和负整数,如 1, 2, 3, -1, -2。
    • 浮点型(float):带有小数点的数,如 3.14, -0.001。
    • 复数(complex):由实部和虚部组成的数,如 3 + 4j。
    • 布尔类型(bool):表示真(True)或假(False)。
  • 序列对象

    • 字符串(str):一串字符,如 ‘hello’。
    • 元组(tuple):不可变的序列,如 (1, 2, 3)。
    • 列表(list):可变的序列,如 [1, 2, 3]。
  • 其它类型

    • 集合(set):无序且元素唯一的集合,如 {1, 2, 3}。
    • 字典(dict):键值对的集合,如 {‘name’: ‘John’, ‘age’: 30}。

整数进制表示

  • 二进制:以 0b 或 0B 开头,如 0b110 表示二进制数 110。
  • 八进制:以 0o 或 0O 开头,如 0o24 表示八进制数 24。
  • 十六进制:以 0x 或 0X 开头,如 0xff 表示十六进制数 FF。

使用范例

  • 二进制转十进制:0b110 = 6(二进制 110 转换为十进制)。
  • 八进制转十进制:0o24 = 20(八进制 24 转换为十进制)。
  • 十六进制转十进制:0xff = 255(十六进制 FF 转换为十进制)。

浮点数的科学计数法

  • 例如,3.14 可以写作 314e-2,表示 3.14 = 314 × 10^-2。

212时间的表示

计算机中时间的默认起点是1970年1月1日00:00:00 UTC(协调世界时),这个起点被称为“Unix时间戳”。时间以秒为单位进行计算,但在Python中,time.time() 函数返回的时间是以毫秒为精度的浮点数。

使用time模块获取当前时间

在Python中,您可以使用内置的time模块来获取当前时间。以下是获取当前Unix时间戳的示例:

import time

current_time = time.time()

current_time变量将包含一个浮点数,表示从Unix纪元开始到当前时刻的秒数。

从时间戳提取具体时间

您可以通过数值运算从这个时间戳中提取出当前的秒、分钟、小时、天等具体时间单位。例如,将时间戳除以3600可以得到小时数,除以60可以得到分钟数。但这种方法不适用于提取月份和年份,因为这些单位不是固定长度的。

注意

直接从时间戳提取月份和年份较为复杂,因为月份和年份的长度不是固定的。通常,我们会使用Python的datetime模块来处理具体的时间日期运算,例如提取当前日期的年、月、日等信息。

213布尔值

在Python中,布尔值主要用于逻辑运算,表示真(True)或假(False)。虽然它们在Python中以TrueFalse表示,但在底层,它们实际上被当作1和0来处理。

布尔值在计算中的应用

您可以将布尔值当作整数1和0来使用,在计算中直接替换。例如:

result = True + 5  # 结果为6,因为True被视为1
is_valid = False * 10  # 结果为0,因为False被视为0

这种特性使得布尔值在条件表达式中非常有用,尤其是在进行数学运算或逻辑判断时。

注意事项

虽然布尔值可以用于数值计算,但建议在逻辑上下文中使用它们,以保持代码的可读性和清晰性。在需要进行数值运算的情况下,显式地使用整数0和1通常是一个更好的选择。

214复数类型数据complex

在Python中,复数由实部和虚部组成,通常表示为 a + bj,其中 a 和 b 是数值,j 是虚数单位。例如,3 + 4j 就是一个复数。

访问复数的实部和虚部

您可以分别使用 .real 和 .imag 属性来获取复数的实部和虚部。例如:

aComplex = 3 + 4j
real_part = aComplex.real  # 结果是 3.0
imaginary_part = aComplex.imag  # 结果是 4.0

复数的共轭

复数的共轭是将虚部的符号反转。在Python中,您可以使用 .conjugate() 方法来获取复数的共轭。例如:

conjugate_complex = aComplex.conjugate()  # 结果是 3 - 4j

复数的使用场景

复数在数学、工程和科学计算中非常重要,特别是在信号处理、流体动力学和其他需要复数表示的领域。

22数值类型转换

221自动转换

在Python中,运算时,如果操作数类型相同,则运算结果的类型也相同。然而,当操作数类型不同时,Python会自动进行类型转换,以使它们成为同类型,然后进行运算。

自动转换的规则

  • 数值范围小的类型转换为数值范围大的类型

    • 当整数与浮点数运算时,系统会自动将整数转换为浮点数。
    • 例如,3 + 2.5 的结果是 5.5,因为整数 3 被转换为浮点数 3.0
  • 布尔类型转换

    • 布尔值 True 和 False 可以与任何数值类型进行运算,通常被视为 1 和 0
  • 字符串与数字运算

    • 当字符串与数字运算时,字符串会被转换为数字。
    • 例如,'3' + 2 的结果是 5,因为字符串 '3' 被转换为整数 3
  • 复数与实数运算

    • 当复数与实数(整数或浮点数)运算时,实数会被转换为复数。
    • 例如,(3 + 4j) + 2 的结果是 5 + 4j,因为实数 2 被转换为复数 2 + 0j

自动转换的优点

自动转换简化了编程,减少了类型错误,使得代码更易于编写和维护。然而,这也可能导致性能问题,特别是在处理大量数据时。

222强制转换

Python提供了多种方法来进行强制类型转换。这些方法可以用于将不同类型的数据转换为所需的类型。

int(x, base)

  • 功能:将x转换为整数。
  • 参数base 可以是 2, 8, 16。如果 base 不提供,默认将x视为十进制数。
  • 示例int('1010', 2) 返回 10int('17', 8) 返回 15
  • 注意int(9.9) 返回 9,没有四舍五入。

float(x)

  • 功能:将x转换为浮点数。
  • 示例float('3.14') 返回 3.14

complex(real, imag)

  • 功能:创建一个复数。
  • 参数real 是实系数,imag 是虚系数。
  • 示例complex(3, 4) 返回 3 + 4j

str(x) / repr(x)

  • 功能:将对象转换为字符串。
  • 区别str(x) 返回可打印的字符串,repr(x) 返回等效的字符串表示。
  • 示例str(3.14) 返回 '3.14'repr('hello') 返回 "'hello'"

ord(x)

  • 功能:将字符转换为其ASCII码。
  • 示例ord('A') 返回 65ord('a') 返回 97

chr(x)

  • 功能:将ASCII码转换为字符。
  • 示例chr(65) 返回 'A'chr(97) 返回 'a'

hex(x)

  • 功能:将整数转换为十六进制字符串。
  • 示例hex(255) 返回 '0xff'

oct(x)

  • 功能:将整数转换为八进制字符串。
  • 示例oct(255) 返回 '0o377'

eval(str)

  • 功能:计算字符串中的有效Python表达式。
  • 注意:此方法存在安全风险,因为它可以执行任意代码。
  • 示例eval('2 + 3') 返回 5

round(value)

  • 功能:返回四舍五入后的值。
  • 示例round(3.14159, 2) 返回 3.14

23数值运算

231运算符

Python中的运算符分为多个类别,用于执行不同的操作。以下是部分常见运算符的概述:

逻辑运算符

  • and:逻辑与。
  • or:逻辑或。
  • not:逻辑非。

同一性测试

  • is:比较两个对象是否是同一个对象。
  • is not:比较两个对象是否不是同一个对象。

比较运算符

  • <:小于。
  • >:大于。
  • <=:小于等于。
  • >=:大于等于。
  • !=:不等于。
  • ==:等于。

位运算符

  • |:按位或。
  • ^:按位异或。
  • &:按位与。

移位运算符

  • <<:左移。
  • >>:右移。

取反运算符

  • ~:按位取反。

整除和取余运算符

  • //:整除。
  • %:取余。

幂运算符

  • ****:幂运算。

增量赋值运算符

  • +=:增量赋值,例如 x += 1 相当于 x = x + 1

注意事项

  • is 和 == 的区别is 用于比较对象的同一性,而 == 用于比较对象的值。当比较变量和 None 时,is 通常比 == 更高效。
  • 浮点数比较:由于计算机中浮点数的表示方式,直接比较浮点数可能不准确。例如,2.1 - 2.0 不等于 0.1,因为存在舍入误差。为了准确比较,可以使用一个很小的数(如 esp)来判断浮点数的差值是否在可接受的误差范围内。例如:
    esp = 0.000000001
    abs((2.1 - 2.0) - 0.1) < esp
    
    这将正确地返回 True

24常用数值运算函数

Python提供了一系列内置函数来执行各种数值运算。以下是几个常用函数的概述:

divmod(被除, 除)

  • 功能:同时返回除法的商和余数。
  • 返回值:一个包含商和余数的元组。
  • 示例divmod(10, 3) 返回 (3, 1)

abs(值)

  • 功能:返回一个数的绝对值。
  • 示例abs(-5) 返回 5

pow(数, 幂)

  • 功能:计算数的幂。
  • 示例pow(2, 3) 返回 8

round(值, 精准度范围)

  • 功能:返回四舍五入后的值。
  • 参数精准度范围 指定了四舍五入到小数点后的位数。
  • 示例round(3.14, 0) 返回 3.0round(3.14) 默认四舍五入到整数,返回 3

25math模块及其应用

Python的 math 模块提供了一系列数学函数,这些函数可以用于执行各种数学运算。以下是 math 模块中的一些主要函数:

pi

  • 功能:返回圆周率 π

e

  • 功能:返回自然对数的底数 e

fabs(值)

  • 功能:返回一个数的绝对值。

trunc(x)

  • 功能:返回 x 的整数部分。

factorial(x)

  • 功能:返回 x 的阶乘。

pow(x, y)

  • 功能:返回 x 的 y 次幂。

sqrt(x)

  • 功能:返回 x 的平方根。

sin(x)cos(x)tan(x)

  • 功能:返回 x 的正弦、余弦和正切值。

ceil(x)

  • 功能:返回大于或等于 x 的最小整数。

floor(x)

  • 功能:返回小于或等于 x 的最大整数。

exp(x)

  • 功能:返回 e 的 x 次幂。

fmod(x, y)

  • 功能:返回 x 除以 y 的余数,结果为浮点数。

fsum(iterable)

  • 功能:对可迭代对象中的每个元素进行求和操作。

gcd(x, y)

  • 功能:返回 x 和 y 的最大公约数。

hypot(x, y)

  • 功能:返回 x^2 + y^2 的平方根,即欧几里得范数。

isinf(x)

  • 功能:如果 x 是无穷大,则返回 True,否则返回 False

isnan(x)

  • 功能:如果 x 不是数字,则返回 True

ldexp(x, i)

  • 功能:返回 x * 2^i

log(x, a)

  • 功能:返回 x 以 a 为底的对数。

modf(x)

  • 功能:返回 x 的分数部分和整数部分。

radians(x)

  • 功能:将角度转换为弧度。

使用方法

要使用 math 模块中的函数,您需要首先导入它:

from math import *

这样,您就可以直接使用 math 模块中的所有函数。

第三章:流程控制

31顺序结构

顺序结构是程序设计中最基本的结构,它指的是程序按照代码的编写顺序依次执行。在这种结构中,程序从上到下、按顺序执行每一条指令。

输入

  • 定义:输入是程序接收外部数据的过程。
  • 示例:用户通过键盘输入数据,程序接收并处理这些数据。

程式

  • 定义:程式是指程序中的代码段,用于执行特定的任务。
  • 示例:一个计算圆面积的程序,包含定义变量、计算公式、输出结果等代码段。

输出

  • 定义:输出是程序将结果呈现给用户的过程。
  • 示例:程序计算出结果后,显示在屏幕上或写入文件。

顺序结构的实现

在Python中,顺序结构通过编写代码实现。程序首先接收输入,然后执行程序代码(即程式部分),最后输出结果。这种结构简单直接,适用于大多数程序。

顺序结构的优点

  • 易于理解:代码按照逻辑顺序执行,易于理解和维护。

32分支结构

321 单分支结构

单分支结构是指程序根据一个条件执行不同的代码块。它通常由一个 if 语句组成。

  • 语法
    if XXX:
        结果输出
    
  • 示例
    if 条件:
        print("条件为真")
    

322 双分支结构

双分支结构允许程序根据条件选择执行两个不同的代码块之一。它由一个 if 语句和一个 else 语句组成。

  • 语法
    if XXX:
        结果输出
    else:
        结果输出
    
  • 示例
    if 条件:
        print("条件为真")
    else:
        print("条件为假")
    

分支嵌套

分支结构可以进行嵌套,即一个 if 语句内可以包含另一个 if 语句。这样可以实现更复杂的逻辑判断。

  • 示例
    if 条件A:
        if 条件B:
            结果输出
    

323 多分支结构

多分支结构使用多个 elif 语句来根据多个条件执行不同的代码块。

  • 语法
    if 条件1:
        结果输出1
    elif 条件2:
        结果输出2
    elif 条件3:
        结果输出3
    ...
    else:
        结果输出(其他情况)
    
  • 示例
    if 分数 >= 90:
        print("A")
    elif 分数 >= 80:
        print("B")
    elif 分数 >= 70:
        print("C")
    else:
        print("D")
    

逻辑表示

这些分支结构可以用思维导图或流程图直观地表示,以帮助理解程序的执行流程。

33循环结构

循环结构的机理是当某个条件返回 True 时,执行循环体内的代码,然后再次检查条件,直到条件变为 False

331 while 循环

while 循环根据一个条件重复执行代码块,直到条件变为 False

  • 注意事项:如果 while 循环的条件不会改变,可能会导致死循环。

  • 示例

    while 条件:
        执行语句
    

332 for 循环

for 循环用于遍历一个序列(如列表、元组、字符串)或一个范围。

  • range() 函数range(x, y, z) 生成一个从 x 到 y-1 的整数序列,步长为 z

  • 示例

    for 变量 in 范围:
        执行语句
    

循环控制语句

  • break:跳出当前循环。
  • continue:结束当前循环,直接进入下一次循环。
  • pass:不执行任何操作,通常用作占位符。

推倒式创建序列

Python支持使用列表推导式、字典推导式和集合推导式来快速创建序列。

  • 列表推导式[表达式 for 对象 in 迭代范围 if 条件判断]
  • 字典推导式{keyexpression: valueexpression for 表达式 in 可迭代对象}
  • 集合推导式{item for 对象 in 可迭代对象 if 条件判断}

第四章:函数

41函数的基本使用

411函数的定义

函数是执行特定任务的可重用代码块。在Python中,函数可以独立存在,也可以相互依赖。它们之间的关系可以是:

  • 独立函数:没有直接依赖关系的函数。
  • 依赖函数:一个函数的输出可以作为另一个函数的输入。
  • 嵌套函数:一个函数内部可以调用另一个函数。

函数的定义和调用

  • 定义:首先定义函数,包括函数名、参数(如果有)和函数体。
  • 调用:通过函数名来调用函数,并传递必要的参数。
  • 执行:调用函数时,执行函数体内的代码。
  • 返回值:函数执行完毕后,可能返回一个值。

412 使用函数的原因

使用函数有以下好处:

  • 代码复用:避免重复编写相同的代码。
  • 提高可维护性:将功能模块化,便于维护和修改。
  • 增强可读性:使代码逻辑更清晰。
  • 实现递归算法:递归算法需要函数内部调用自身。

413 函数的类型

Python中的函数可以分为几种类型:

  • 自定义函数:用户自己编写的函数,如 main()
  • 内建函数:Python语言内置的函数,如 abs()
  • 标准库函数:位于Python标准库中的函数,如 math.sqrt()string.split()
  • 对象方法:属于某个对象的函数,如 win.close()p.draw()

414 函数的定义格式

函数的定义格式如下:

def 函数名(<形参表>):
    函数语句块
    <return 返回值>
  • 函数名:标识函数的名称。
  • 形参表:函数的参数列表,用于传递数据给函数。

42函数的参数传递

421 函数调用的形式

函数可以以不同的方式调用:

  • 语句形式:直接调用函数执行。
  • 表达式形式:函数调用可以作为表达式的一部分。
  • 作为其他函数调用的参数:函数可以作为另一个函数的参数。

422 函数调用的过程

  • 暂停执行:调用函数时,程序暂停执行,转而执行函数体。
  • 参数赋值:函数的形参被赋予实参的值。
  • 执行函数体:执行函数体内的代码。
  • 返回控制:函数执行完毕后,返回调用点,继续执行下一条语句。

423 函数定义与调用中参数的关系

  • 形式参数:在函数定义时使用的参数。
  • 实际参数:在函数调用时传递的参数。
  • 参数一致性:实际参数的个数应与形式参数的个数一致。

424 程序的两个顺序

  • 执行顺序:程序从入口点开始执行,遇到函数调用时执行函数,完成后返回继续执行。
  • 书写顺序:函数的书写顺序与调用顺序无关,但建议不要在函数内部定义另一个函数。

425 传值和传地址

  • 传值:将变量的值传递给函数,函数内部对该变量的操作不会影响原始变量。
  • 传地址:将变量的内存地址传递给函数,函数内部对该变量的操作会永久改变原始变量的值。

426 “*”和“**”的妙用

  • 星号(*)
    • 在函数形参中:表示将多余的实参作为一个元组传递。
    • 在实参中:表示将元组解包为多个单独的值传递。
  • 双星号()**:
    • 在函数形参中:表示将多余的实参作为一个字典传递。

43变量的作用域

局部变量和全局变量

  • 局部变量:在函数内部定义的变量,只能在函数内部使用。
  • 全局变量:在函数外部定义的变量,可以在整个程序中使用。

同名变量的处理

  • 同名全局变量和局部变量:如果函数内部有与全局变量同名的局部变量,则局部变量会覆盖全局变量,仅在函数内部有效。

函数与调用者之间的数据沟通

  • 输入:通过参数从调用者接收值。
  • 输出:通过返回值向调用者提供值。

全局变量的访问

  • 访问全局变量:在函数内部访问全局变量时,需要使用 global 关键字声明该变量是全局变量。
    global 变量名
    

外部嵌套函数的变量访问

  • 访问外部嵌套函数的变量:在嵌套函数中访问外部函数的变量时,需要使用 nonlocal 关键字声明该变量是外部函数的局部变量。
    nonlocal 变量名

44推导式创建序列

441 列表推导式

列表推导式是创建列表的快速方式。它使用一个表达式和一个可选的循环条件。

  • 语法[表达式 for 元素 in 可迭代对象] 或 [表达式 for 元素 in 可迭代对象 if 条件]
  • 示例:创建一个列表,包含从0到9的平方。
    squares = [x**2 for x in range(10)]
    

442 字典推导式

字典推导式用于创建字典。

  • 语法{keyexpression: valueexpression for 元素 in 可迭代对象}
  • 示例:创建一个字典,其中键是字符串,值是字符串的长度。
    string_lengths = {s: len(s) for s in ['apple', 'banana', 'cherry']}
    

443 集合推导式

集合推导式用于创建集合。

  • 语法{表达式 for 元素 in 可迭代对象 if 条件}
  • 示例:创建一个集合,包含列表中的唯一元素。
    unique_elements = {x for x in [1, 2, 2, 3, 4, 3, 5]}
    

444 生成器推导式

生成器推导式用于创建生成器对象,而不是列表、字典或集合。

  • 示例:生成一个包含从0到9的平方的生成器。
    squares_gen = (x**2 for x in range(10))
    
    生成器只能使用一次,即只能迭代一次。

第五章:字符串

51字符串基本特点

511 字符串的本质

字符串是字符序列的集合,它们是不可变的。字符串通常包含字母、数字和特殊字符。

512 字符串的转换

  • ord(字符):将单个字符转换为其Unicode编码。
  • chr(十进制数字):将十进制数字转换为其对应的字符。

513 可打印字符

可打印字符是指那些可以直接在屏幕上显示的字符,如字母(a-zA-Z)、数字(0-9)、标点符号和键盘常见符号。

514 不可打印字符

不可打印字符是指那些在屏幕上不能直接显示的字符。它们通常用于表示控制信息或特殊字符。例如:

  • \a响铃字符。
  • \b退格字符。
  • \n换行符。
  • \r回车符。
  • \t制表符。
  • \f换页符。
  • \v垂直制表符。

52创建字符串

在Python中,字符串可以用单引号或双引号表示。

  • 单引号和双引号
    • 单引号和双引号都可以用来表示字符串。
    • 如果在字符串中包含单引号或双引号,需要在前面加上反斜杠(\)作为转义字符。

多行字符串

  • 多行字符串
    • 使用三个单引号(''')或三个双引号(""")来创建多行字符串。
    • 这种方法允许字符串跨越多行,而不需要在每个换行处加上反斜杠。

空字符串

  • 空字符串
    • 空字符串是允许的,它包含空格的字符串也是有效的。

53字符串的拼接

在Python中,字符串可以通过几种方式进行拼接:

  1. 相互粘连

    • 两个字符串直接相加,如 'aa' + 'bb' 得到 'aabb'
    • 这种方法适用于简单的字符串拼接。
  2. 复制字符串

    • 使用乘法操作符 * 来复制字符串,如 'a' * 3 得到 'aaa'
    • 这种方法适用于重复字符串。

不换行打印

  • 不换行打印
    • 使用 print() 函数并设置 end 参数来控制打印后的行为。
    • 例如,print('内容', end='末尾内容') 可以在一行内打印字符串,末尾不换行。

54索引

索引是用来表示字符串中字符位置的数字,用于指定取出字符串中的某个字符。

  • 索引格式<字符串>[<数值表达式>]
  • 示例
    s = 'hellopython'
    print(s[0])  # 输出 'h'
    

字符串的“替换”

  • 不可变字符串
    • 字符串是不可变的,这意味着不能直接修改字符串中的字符。
  • 替换方法
    • 虽然字符串不可变,但可以通过创建新字符串来实现“替换”。
    • 使用 replace() 方法可以替换字符串中的特定字符。
    • 示例
      a = 'ccdabcd'
      a = a.replace('c', 'T')
      print(a)  # 输出 'TTdabTd'

55字符串切片

字符串切片是用于获取字符串中指定部分的一种方法。切片格式如下:

  • 切片格式<字符串>[起始偏移量:终止偏移量:步长]
  • 默认值
    • 起始偏移量默认是 0
    • 终止偏移量默认是字符串的长度减一。
    • 步长默认是 1

切片操作

  • 示例
    • a[0:2] 获取从索引 0 到 2 的子串,不包括 2
    • a[0:2] 获取从索引 0 到 2 的子串,不包括 2
    • a[:2] 获取从开始到索引 2 的子串。
    • a[::2] 获取从开始到结束,步长为 2 的子串。
    • a[::-1] 获取字符串的反转。

切片异常处理

  • 切片异常:如果起始或终止偏移量超出字符串的范围,它们会被自动调整到合法范围。
  • 示例
    • 如果尝试获取一个超出字符串末尾的切片,起始偏移量会被调整为字符串末尾的位置。
    • 如果尝试获取一个超出字符串开头的切片,终止偏移量会被调整为字符串开头的位置。

56子串测试操作

子串测试操作用于检查一个子串是否存在于另一个字符串中。

  • 子串测试
    • 使用 in 关键字可以检查一个子串是否存在于字符串中。
    • 示例
      • 'cc' in a:如果字符串 a 中包含子串 'cc',则结果为 True
      • 'kk' in a:如果字符串 a 中不包含子串 'kk',则结果为 False

57分割

571 split() 函数

split() 函数用于根据指定的分隔符将字符串分割成多个子字符串,并将这些子字符串存储在一个列表中。

  • 默认分隔符:如果不指定分隔符,split() 函数默认使用空白字符(如空格、制表符、换行符等)进行分割。

572 split() 函数的参数

  • 分隔符:指定用于分割字符串的字符或字符串。
  • 最大分割次数:可选参数,指定分割的最大次数。
  • 选取子字符串:可选参数,指定选取列表中的第几个子字符串。

573 分割的赋值

  • 分割赋值:使用 split() 函数分割字符串后,可以将结果赋值给多个变量。
    • 示例a, b, c = s.split('.', 2):如果 s 被分割成三个子字符串,则 abc 将分别存储这三个子字符串。

分割的注意事项

  • 字符串不可变性:分割字符串不会改变原始字符串。
  • 空字符串的产生:在字符串的开始和结束位置,以及连续多个分隔符之间,可能会产生空字符串。

58合并

581join()

join() 函数用于将一个字符串列表中的所有元素合并成一个字符串。合并时,使用第一个参数(拼接符)作为各个元素之间的分隔符。

  • 拼接符:指定用于连接字符串列表中元素的字符串。
  • 字符串列表:需要合并的字符串列表。

使用示例

  • 示例
    str_list = ['hello', 'world']
    result = ' '.join(str_list)
    print(result)  # 输出 'hello world'

59字符串常用方法汇总

591 字符串方法汇总

  • 查找方法

    • find(‘字符’):返回字符在字符串中首次出现的位置。
    • rfind(‘字符’):返回字符在字符串中最后一次出现的位置。
    • count(‘字符’):返回字符在字符串中出现的次数。
  • 判断方法

    • startswith(‘字符串’):判断字符串是否以指定字符串开头。
    • endswith(‘字符串’):判断字符串是否以指定字符串结尾。
    • isalnum():判断字符串是否只包含字母和数字。
    • isdigit():判断字符串是否只包含数字。
    • isspace():判断字符串是否只包含空白字符。
    • isupper():判断字符串是否全为大写字母。
    • islower():判断字符串是否全为小写字母。
  • 大小写转换

    • capitalize():将字符串的首字母大写。
    • title():将字符串的每个单词的首字母大写。
    • upper():将字符串中的所有字母转换为大写。
    • lower():将字符串中的所有字母转换为小写。
    • swapcase():将字符串中的所有字母大小写转换。
  • 格式化

    • strip(‘指定’):去除字符串首尾指定的字符。
    • lstrip(‘指定’):去除字符串左边的指定字符。
    • rstrip(‘指定’):去除字符串右边的指定字符。
    • center(宽度, ‘填充字符’):在字符串周围填充指定字符,使其宽度达到指定宽度。
    • ljust(宽度, ‘填充字符’):在字符串左边填充指定字符,使其宽度达到指定宽度。
    • rjust(宽度, ‘填充字符’):在字符串右边填充指定字符,使其宽度达到指定宽度。

592 format() 方法

  • 基本用法

    • format() 方法用于将格式化字符串中的占位符替换为实际的值。
    • 示例
      a = '名字是:{0},年龄是{1}'.format('eric', 18)
      print(a)  # 输出 '名字是:eric,年龄是18'
      
  • 填充与对齐

    • format() 方法允许指定字符串的填充和对齐方式。
    • 示例
      print(':*>8'.format('256'))  # 输出 '*****256'
      
  • 数字格式化

    • format() 方法也可以用于数字的格式化。
    • 示例
      print('{:>8}'.format(256))  # 输出 '*****256'
      

第六章:序列类型

数据类型

Python支持多种序列类型,这些类型可以用于存储和操作批量数据。

  • 有序序列

    • 字符串(str):由字符组成的序列。
    • 列表(list):可变序列,可以修改。
    • 元组(tuple):不可变序列,一旦创建不能修改。
  • 无序序列

    • 字典(dict):键值对的无序集合。
    • 集合(set):无序且不重复元素的集合。

 序列对象

序列对象是有序的数据集合体,其成员之间存在排列次序。

  • 常见操作
    • 联接x1 + x2,将两个序列连接起来。
    • 复制x * n,复制序列 x n 次。
    • 索引x[i],访问序列中下标为 i 的元素。
    • 切片x[i:j] 或 x[i:j:k],获取序列中从 i 到 j-1 的子序列,或者每隔 k 取一个元素。
    • 长度len(x),返回序列中元素的数量。
    • 最大值和最小值max(x) 和 min(x),分别返回序列中的最大和最小值。
    • 成员检测v in x 和 v not in x,检测 v 是否为序列 x 的成员。

类型构造器

类型构造器是与数据类型同名的函数,用于创建特定类型的对象。

  • 示例
    • str():将对象转换为字符串。
    • int():将对象转换为整数。
    • float():将对象转换为浮点数。
    • list():将对象转换为列表。

61列表

611 列表简介

列表是Python中的一种可变序列类型,可以存储任意数目和类型的数据。与字符串不同,列表可以修改。

612 列表的创建

  • 基本语法:使用方括号 [] 创建列表,例如 a = [内容]
  • 嵌套列表:可以在列表中包含其他列表,例如 a = [[内容1], [内容2], [内容3]]
  • 使用 list() 函数:将其他数据结构(如元组)转换为列表,例如 a = list((‘he’, ‘she’, ‘we’))
  • 使用 range() 函数:创建一个整数列表,例如 list(range(3, 15, 2)) 创建从3到15(不包括15)的偶数列表。

613 列表元素的增加和删除

  • append() 方法:在列表末尾添加一个元素。
  • extend() 方法:将一个列表的所有元素添加到另一个列表的末尾。
  • insert() 方法:在列表的指定位置插入一个元素。
  • remove() 方法:删除列表中首次出现的指定元素。
  • pop() 方法:删除并返回列表中指定位置的元素。
  • 列表乘法:将一个列表重复多次,例如 b = a * 3
  • clear() 方法:删除列表中的所有元素。
  • del 语句:删除列表中指定位置的元素。

614 列表元素的访问和计数

  • 索引访问:使用 a[指定位置] 访问列表中的元素。
  • 修改元素:使用 a[指定位置] = b 修改列表中指定位置的元素。
  • index() 方法:返回指定元素在列表中首次出现的位置。
  • count() 方法:返回指定元素在列表中出现的次数。
  • len() 函数:返回列表中包含元素的个数。
  • 切片:使用 [起始:终止:步长] 访问列表的子序列。

615 列表的复制

  • 假复制list2 = list1,这种复制实际上只是复制了引用,而不是复制了列表本身。
  • 真复制list2 = [] + list1,这种复制创建了一个新的列表,其中包含了原始列表的内容。

616 列表排序

  • sort() 方法:对列表进行排序,默认升序排列。
  • reverse=True:使用 sort() 方法时,指定 reverse=True 可以进行降序排列。
  • random.shuffle():打乱列表中的元素顺序。
  • 新列表排序:使用 sorted() 函数可以创建一个排序后的新列表。

617 列表相关的其他内置函数

  • max() 和 min():返回列表中的最大值和最小值。
  • sum():返回列表中所有数值元素的总和。

618 多维列表

  • 多维列表格式a = [[A, B, C], [D, E, F], [G, H, I]]
  • 索引方法a[2][2] 表示访问第四行第三列的元素,即 I

62元组

元组是Python中的一种不可变序列类型,与列表和字符串类似,但与列表不同,元组一旦创建就不能修改。

621 元组的创建

  • 基本语法:使用圆括号 () 创建元组,例如 t = (1, 2, 3)
  • 包含不同类型元素:元组可以包含不同类型的元素。
  • 只有一个元素时的特殊处理:如果元组只有一个元素,需要在元素后面加上逗号以区别于其他数据类型。
  • 使用 tuple() 函数:直接调用 tuple() 函数来创建元组,例如 tuple('python')

622 元组的元素访问和计数

  • 不可变性:元组中的元素不能修改。
  • 访问格式:元组的访问格式与列表相同,使用 a[start:end:step] 或 a[指定位置]
  • 排列与计数:使用 sorted() 函数可以对元组进行排序,但返回的是一个列表。
  • count() 方法:返回指定元素在元组中出现的次数。
  • index() 方法:返回指定元素在元组中首次出现的位置。

623 Zip组合元组

  • zip() 函数:可以将多个列表的对应位置元素组合成元组,例如 zip(a, b, c)
  • 示例
    a = [10, 20, 30]
    b = [40, 50, 60]
    c = [70, 80, 90]
    d = zip(a, b, c)
    print(list(d))  # 输出 [(10, 40, 70), (20, 50, 80), (30, 60, 90)]
    

624 生成器推导式创建元组

  • 生成器推导式:类似于列表推导式,生成器推导式也可以用于创建元组。

第七章:集合与映射类型

71字典

711字典介绍

字典是Python中的一种无序序列类型,用于存储键值对。每个键(key)都是唯一的,而值(value)可以是任意类型,且可以重复。

  • 键值对:字典由键值对组成,键用于查找对应的值。
  • 无序性:字典中的元素没有固定的顺序。
  • 可变性:可以添加、删除或修改字典中的键值对。

示例

dict_example = {'name': 'Tom', 'age': '18', 'job': 'programmer'}

在这个例子中,'name' 是键,'Tom' 是与之对应的值。

712字典创建

字典创建方法

  • 基本语法:使用花括号 {} 创建字典,例如 a = {'a': 'b'}
  • 使用 dict() 函数:通过 dict() 函数创建字典,例如 a = dict(a='b')

使用 zip() 函数转换列表为字典

  • 示例
    • 创建两个列表,k = ['a', 'b', 'c'] 和 v = ['d', 'e', 'f']
    • 使用 zip(k, v) 将两个列表的元素组合成元组,并创建一个字典,例如 d = dict(zip(k, v))

使用 dict.fromkeys() 创建字典

  • 示例
    • 使用 dict.fromkeys() 方法创建一个所有键都具有相同值的字典,例如 a = dict.fromkeys(['内容为键'])

713字典元素的访问

访问字典中的元素

  • 通过键访问值:使用 a[‘键’] 访问字典 a 中对应的值。
  • 避免错误:如果键不存在,访问将引发错误。可以使用 get() 方法来避免这种情况。
    • a.get(‘键’):返回键对应的值,如果键不存在则返回 None
    • a.get(‘不存在键’,’返回对象’):返回键对应的值,如果键不存在则返回指定的 '返回对象'

列出所有键值对

  • items() 方法:使用 items() 方法列出所有键值对。
    • a.items():返回一个包含字典中所有键值对的列表。

列出所有键和值

  • keys() 方法:使用 keys() 方法列出所有键。
    • a.keys():返回一个包含字典中所有键的列表。
  • values() 方法:使用 values() 方法列出所有值。
    • a.values():返回一个包含字典中所有值的列表。

计算键值对数量

  • len() 函数:使用 len() 函数计算字典中键值对的数量。

判断键是否存在于字典中

  • 键 in 字典名:使用此表达式可以判断键是否存在于字典中。

714字典元素添加,修改,删除

改变字典中键对的值

  • 修改值:使用 a[‘键’] = ‘值’ 来修改字典中键对应的值。

添加新的键值对

  • 添加键值对:使用 a[‘新键’] = ‘新值’ 来添加新的键值对。
更新字典
  • update() 方法:使用 a.update(b) 来更新字典,其中 b 中的键值对将覆盖 a 中已有的键值对,并添加 b 中没有的键值对。

删除键值对

  • del 语句:使用 del a[‘键’] 来删除字典中指定的键值对。
  • clear() 方法:使用 a.clear() 方法来删除字典中的所有键值对。
  • pop() 方法:使用 a.pop(‘键’) 来删除指定的键值对,并将删除的值返回。
  • popitem() 方法:使用 a.popitem() 来随机删除字典中的一个键值对,并返回该键值对(以元组形式)。

715序列解包

解包字典中的键

  • 解包键:当使用元组赋值 a, b, c = {...} 时,默认情况下,a, b, c 分别赋值为字典中的键,按照字典中键的顺序。

解包键值对

  • 解包键值对:当使用 a, b, c = {...}.items() 时,a, b, c 将分别赋值为字典中的键值对。

解包值

  • 解包值:当使用 a, b, c = {...}.values() 时,a, b, c 将分别赋值为字典中的值。

716表格数据使用字典和列表存储并实现访问

表格数据的存储

  • 创建字典行:使用字典来创建表格的行,例如 r1 = {}r2 = {}r3 = {}
  • 创建表格:使用列表来存储这些字典行,例如 tb = [r1, r2, r3]

访问表格数据

  • 使用循环访问:使用 for 循环遍历表格中的每一行。
  • 使用 get() 方法访问键值:在循环中,使用 tb[i].get('键') 来访问特定行的特定键的值。
  • 示例
    tb = [r1, r2, r3]
    for i in range(len(tb)):
        print(tb[i].get('键'))
    
    在这个例子中,i 将遍历 0, 1, 2,对应于 r1r2r3

717字典核心底层原理

544e2ee69b284b9a93f381263e852304.png

72集合

721 集合的创建和删除

集合的创建

  • 基本语法:使用花括号 {} 创建集合,例如 a = {...}
  • 添加元素:使用 add() 方法添加元素,例如 a.add(元素)
  • 转换列表或元组为集合:使用 set() 函数将列表或元组转换为集合,例如 a = set([...]) 或 a = set((...))

集合的删除操作

  • 删除元素:使用 remove() 方法删除指定元素,例如 a.remove(元素)
  • 清空集合:使用 clear() 方法清空整个集合,例如 a.clear()

722 集合相关操作

集合运算

  • 并集:使用 union() 方法获取两个集合的并集,例如 a.union(b)
  • 交集:使用 intersection() 方法获取两个集合的交集,例如 a.intersection(b)
  • 差集:使用 difference() 方法获取两个集合的差集,例如 a.difference(b)

第八章:文件操作

程序的交互性

程序的交互性可以体现为两种形式:

  • 键盘交互:通过键盘输入数据,并在显示屏上显示,称为“标准输入输出”。
  • 文件交互:从文件读取数据,或运行后将结果写入一个文件。

81 文件的打开与关闭

811 文件和文件目录

  • 文件定义:文件是永久存储的有序集合,由特定顺序的字节组成,并具有名称。
  • 路径类型:路径分为绝对路径和相对路径。
  • 文件类型:文件分为文本文件和二进制文件。
    • 文本文件:存储普通字符文本,可以使用记事本打开。
    • 二进制文件:使用“字节”存储数据,需要专用软件解码。

812 访问文件的流程

  • 文件交互优势:可以处理大批量数据,可以长久保存。
  • 访问流程:打开文件 → 访问文件 → 关闭文件。

打开文件

  • 语法:使用 open() 函数打开文件。
  • 参数
    • 文件名:可以是全路径或相对路径。
    • 打开方式:包括读(r)、写(w)、追加(a)、二进制(b)、读写(+)等。

写入数据

  • 写入方法:使用 write() 方法写入数据,或者使用 writelines() 方法写入字符串列表(不添加换行符)。

关闭文件

  • 关闭文件流:使用 close() 方法关闭文件。

82文件的读写操作

821 文本文件的写入

  • 追加内容:使用 open(r"文件位置,文件名","a") 以追加模式打开文件,然后使用 write() 或 writelines() 方法写入数据。
  • 示例
    f = open(r"文件位置,文件名", "a")
    s = "追加内容\n"  # 追加内容中,是更换一行的部分后直接加'\\n'
    f.write(s)
    f.close()
    

使用 with 语句确保文件关闭

  • with 语句:使用 with 语句可以确保文件在使用完毕后自动关闭。
    s = ["追加内容\n", "追加内容\n"]
    with open(r"文件位置", "a") as f:
        f.writelines(s)
    

822 文本文件的读取

  • 读取方法
    • read([size]):读取文件中的 size 个字符。
    • readline():读取文件的一行内容。
    • readlines():读取整个文件,并将每一行作为一个字符串存入列表。

按行读取文件

  • 示例
    with open(r"文件位置", "r") as f:
        while True:
            fragment = f.readline()
            if not fragment:
                break
            else:
                print(fragment, end="")
    

迭代器读取文件

  • 示例
    with open(r"文件位置", "r") as f:
        for line in f:
            print(line, end="")
    

增加行号

  • 示例
    with open("e.txt", "r", encoding="ISO-8859-1") as f:
        lines = f.readlines()
        lines = [line.rstrip() + " #" + str(index + 1) + "\n" for index, line in enumerate(lines)]
    with open("e.txt", "w", encoding="GBK") as f:
        f.writelines(lines)
    

823 二进制文件的读取与写入

  • 二进制文件模式:使用 wbabrb 等模式打开二进制文件。

824 常用编码介绍

  • 编码类型:包括 ASCII、ISO-8859-1、GB2312、GBK、GB18030、Unicode、UTF-8 等。
  • 编码特点
    • ASCII:8位字符集,包含控制字符和可见字符。
    • ISO-8859-1:Latin-1,兼容ASCII,包含西欧字符。
    • GB2312:汉字编码字符集,主要收录汉字和符号。
    • GBK:扩展GB2312,包含更多汉字。
    • GB18030:包含GBK,并扩展到7万多个汉字。
    • Unicode:固定两个字节,表示所有字符。
    • UTF-8:变长编码,兼容ASCII,包含多语言字符。

83文件的应用

831 文件对象的常用属性和方法

  • 属性

    • name:返回文件的名字。
    • mode:返回文件的打开模式。
    • closed:若文件被关闭则返回 True
  • 方法

    • read([size]):从文件中读取 size 个字节或字符的内容返回。
    • readline():从文本文件中读取一行内容。
    • readlines():把文本文件中每一行都作为独立的字符串对象,并将这些对象放入列表返回。
    • write(str):将字符串 str 内容写入文件。
    • writelines(s):将字符串列表 s 写入文件,不添加换行符。
    • seek(offset, [,whence]):把文件指针移动到新的位置,offset 表示相对于 whence 的多少个字节。
    • tell():返回文件指针的当前位置。
    • truncate([size]):从文件的首行首字节开始截断,截断文件为 size 个字节。
    • flush():把缓冲区的内容写入文件,但不关闭文件。
    • close():把缓冲区内容写入文件,同时关闭文件,释放文件对象相关资源。

832 文件任意位置操作

  • seek() 方法:用于移动文件指针到指定位置。
    • offset:表示移动的偏移量。
    • whence:可选参数,表示相对位置。0:从文件头开始计算,1:从当前位置开始计算,2:从文件尾开始计算。

833 CSV文件的读写操作

  • CSV文件:逗号分隔值文件,常用于存储表格数据。
  • 示例操作
    • 使用 csv.writer 对象写入CSV文件。
    • import csv
    • 创建 headers 和 rows 列表。
    • 使用 with 语句打开文件,并创建 csv.writer 对象。
    • 写入标题行。
    • 写入多行数据。

  • 14
    点赞
  • 36
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值