因本人偶尔需要使用到Python，但又苦于不怎么熟悉Python基础知识，故学习并记录下来，这篇学习有一些内容与C/C++做了对比。

各种渠道的Python基础学习资料很多，这一篇自用。

---

1.入门

Python的广泛应用性无须多言

可以直接从Python官网下载安装Python，点此直达官网，记得勾选自动配置全局环境。

安装完成后可以通过查看Python的版本信息来判断是否安装成功，在命令行输入以下命令查看：

python --version

最基本的编写并运行Python的方法有两种：

1. 编译文件：用任意文本编写程序编写python文件，后缀是.py，然后用python编译这个文件

   C:\Users\***>python helloworld.py

2. 编译命令：直接在命令行输入python进入代码编写模式，让Python本身作为命令行运行

   C:\Users\***>python
   Python 3.12.2 (tags/v3.12.2:6abddd9, Feb  6 2024, 21:26:36) [MSC v.1937 64 bit (AMD64)] on win32
   Type "help", "copyright", "credits" or "license" for more information.
   >>> print("hello world")
   hello world
   >>>

---

2. 基础语法

2.1 行和缩进

相比于C/C++，Python不需要使用{}来标识代码块，也不需要使用;来标识语句，Python完全使用缩进和换行来标识代码块和语句，因此，Python中必须要合理的使用缩进，规范使用制表符（TAB）即四个空格缩进。

Python默认一行一语句，因此一般不用;，如果需要一行多语句，Python也支持在一行中间使用;来区分多个语句。

# 严格规范缩进
if True:
    print("hello world")
else:
    print ("world hello")

# 一行多语句，中间使用;来区分
print("hello ");print ("world")

2.2 注释

• 单行注释：以#开头。

  # 这是单行注释
  # 这是单行注释

• 多行注释：前后使用三个单引号 ”’ 或三个双引号 """

  '''
  这是单引号多行注释
  这是单引号多行注释
  这是单引号多行注释
  '''
  
  """
  这是双引号多行注释
  这是双引号多行注释
  这是双引号多行注释
  """

2.3 变量

• Python中没有用于声明变量的命令，无须手动声明变量类型，编译器会自动在首次为变量分配值的时候自动创建，类似C++的auto，JS的var。而Python甚至无须这些表示自动化的命令（因为Python根本就没有声明命令）。
• 变量名的长度不受限制，其中的字符必须是 字母 、 数字或下划线，并且首字符不能是数字。
• Python的变量因为不用声明，所以类型也不固定，可以在首次设置后更改类型。
• Python能够同时给多个变量赋值，也适用于变量之间值的交换。
• 对于全局变量，一般首次出现在最外一层的默认为全局变量，而函数等局部代码块中的变量默认局部变量，当然在局部代码块中使用global也可指定为全局变量。
• Python中没有所谓常量，约定俗成的使用全大写字母命名的作为常量（如MAX_SIZE）

x = 1 # int类型
y = "John" # string类型
x = "Half" # 此时x更改为string类型
x, y, z = 1, 'China', 2.5 # 同时给多个变量赋值
x, y = y, x  # 交换变量

def test()
    global a, b = 1, 2 # 指定全局变量

具体的各种数据类型见后两章节。

2.4 保留字符

下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数，或任何其他标识符名称。

所有 Python 的关键字只包含小写字母。

保留字符	保留字符	保留字符
and	exec	not
assert	finally	or
break	for	pass
class	from	print
continue	global	raise
def	if	return
del	import	try
elif	in	while
else	is	with
except	lambda	yield

2.5 模块导入

在Python中，模块是一个包含Python代码的文件，是组织代码的基本单元，文件名以 .py 结尾。模块可以包含函数、类和变量，也可以包含可执行代码模块。有很多现成好用的模块直接下载并导入使用，对于一个大型项目，也需要自行编写代码文件作为模块导入使用。

• 使用 import 语句导入整个模块，可选地使用 as来写别名

  import math as mt
  print(mt.sqrt(16))  # 输出: 4.0  

• 使用from ... import ...语句导入模块中特定函数或变量，同样可选地使用 as来写别名

  from math import sqrt  
  print(sqrt(16))  # 输出: 4.0  

注意if __name__ == '__main__':语句

Python编译器在编译一个包含很多模块的Python项目时，会生成一个特殊变量__name__，这个变量代表最初开始执行的模块（文件）。对于就是最初执行的文件来说，__name__就等于'__main__'，而对于其他被调用的模块来说，__name__就等于最初执行文件的文件名称。

所以通过这样一个判断，可以在执行目标文件时额外执行一段代码。如果作为模块被导入其他文件使用时，if判断将失败则不会执行，因此，这种if测试可以让一个模块通过命令行运行时执行一些额外的代码，最常见的就是运行测试。

PI = 3.1415926
def paraTest(): #定义测试函数
    print("PI = ", PI)

if __name__ == '__main__': # 如果直接从执行这个文件，则会执行以下代码；如果别的文件把这个文件当作模块调用，则不会执行以下代码
    paraTest()

2.6 其他

介于我个人有着写C/C++的习惯，这里要特别提醒一下。

Python中变量名、函数名和类名等都习惯使用下划线命名法，而非驼峰命名法，这与Python内建函数和类的命名风格有关。

---

3. 基本数据类型

概括的说Python中大概有九种数据类型：数值、字符串、布尔值、字节流、空值、列表、元组、字典、集合
前五种类似C/C++中的对应类型，我放在这一节；后四种是需要特殊注意的类型，统称为序列结构类型，我放在下一节。

Python中可以通过type()方法获取任意对象的数据类型：

x = 5
print(type(x)) # 输出 int

Python中的类型转换的方法格式类似C/C++，如整数转换为int()，要注意的是，虽然Python中的类型转换没有C/C++中那么要求严格，符合逻辑思考的都能转换，而有些情况也会转换报错。

x = "1.23"
y = float(x) # 正确
z = int(y) # 正确，取浮点数的整数部分

a = int(x) # 错误，x是字符串，无法直接解析字符串的“整数部分”

3.1 数值 [int, float, complex]

• 整数（int）

  表示没有小数部分的数字，可以是正整数、负整数或零。另外，Python的整数类型没有大小限制。

  a = 5  
  b = -10  

• 浮点数（float）

  表示带小数部分的数字。浮点数的表示采用IEEE 754双精度浮点数格式，能表示范围较广的数字。另外，支持科学计数法（使用e代替指数10）表示更广的浮点数。

  pi = 3.14159  
  x = -0.001
  y = 3.14e9

• 复数（complex）

  表示具有实部和虚部的数字，用j 表示虚数单位，总体形式 a + bj 表示，其中 a 是实部，b 是虚部。

  z = 2 + 3j  

3.2 字符串 [str]

• 字符串是用于表示文本数据的序列，可以使用单引号、双引号或三重引号（用于多行字符串）来创建，支持双引号嵌套单引号。

• 字符串在 Python 中是不可变的，即一旦创建后无法修改内容，但可以通过切片操作创建新的字符串。

• []：与C/C++一样，Python中的字符串也是数组，可以使用[]来访问单个字符，也支持在[]中使用:进行切片，切片的语法也基本与C/C++一样。

• 支持使用for语句遍历字符串。

• len()：支持使用len()方法获取字符串的长度。

• in和not in：Python中使用in来检查字符串中是否含有某个指定子字符串，而使用not in来检查是否不含有。

• +：拼接字符串

• f {}：F-String即f字符串是新引入的，在基础字符串前使用f来转换为f字符串，使用{}作为占位符，可以用来在字符串中填充指定变量，对于数值类型，还能指定数值的格式化，如:.2f指定两位小数

• 转义字符：

  转义字符	代表含义
  \ （在行尾）	续行
  \'	单引号
  \"	双引号
  \\	反斜杠
  \n	换行
  \r	回车
  \t	横向制表符
  \v	纵向制表符
  \b	退格
  \f	换页
  \000（数字0）	空
  \oyy （字母o）	八进制值，yy代表字符
  \xyy	十六进制值，yy代表字符
  \other	其他字符以普通格式输出

• 其他内置方法：

  • upper()：以大写形式返回字符串。
  • lower()：以小写形式返回字符串。
  • strip()：删除空格，但删除的有效字符串前后的多余空格，不能删除有效字符串中间的空格。
  • replace()：替换字符串，将一个字符串替换为另一个字符串。
  • split()：拆分字符串，返回一个列表。

single_quote_str = 'Hello'  
double_quote_str = "World" 
# 多行要注意空格也会被计入字符串中
multi_line_str = """This is a   
multi-line string."""

a = "Hello, World!"
print(a[1]) # 输出指定序号1的字符e，也是从0数序号
print(a[:5]) # 获取从开头到序号5的字符串Hello，不包括第五个在内
print(len(a)) # 输出 13
print("Hello" in a) # 输出 True

# 使用占位符引入变量的字符串
name = "jay"
x = f"I am {name}"
print(x) # 输出 I am jay
price = 59
y = f"This is {price:.2f}"
print(y) # 输出 This is 59.00

# 其他内置方法
print(a.upper()) # 输出 HELLO, WORLD!
print(a.lower()) # 输出 hello, world!
print(a.replace("H", "J")) # 输出 Jello, World!
print(a.split(",")) # 输出 ['Hello', ' World!']
b = " ok ay   "
print(b.strip()) # 输出 "ok ay"

3.3 布尔值 [bool]

• 布尔类型用于表示逻辑真（True）和假（False），首字母大写。布尔值在条件判断和逻辑运算中不可或缺。
• 在 Python 中，布尔值是整数类型的子类，True 被视为 1，False 被视为 0。
• Python中的布尔运算符包括 and, or, not，等同于C/C++中的&&、||、!，常用于控制程序的执行流。

3.4 字节流 [bytes, bytearray, memoryview]

• 字节（bytes）：

  可以使用前缀 b 来创建字节串。字节类型是不可变的，表示原始的字节序列，适合于处理二进制数据。

  byte_data = b'hello'  

• 字节数组（bytearray）：

  字节数组是可变的字节序列，允许对内容进行修改。

  mutable_byte_data = bytearray(b'hello')  
  mutable_byte_data[0] = 72  # 修改为 'H'  

• 内存视图（memoryview）：

  内存视图提供了对字节缓冲区的切片功能，允许在不复制数据的情况下查看和操作数据。

  byte_data = b'hello'  
  mv = memoryview(byte_data)  
  print(mv[0])  # 输出 104，代表字母 'h'  

3.5 空值 [NoneType]

• None 是 Python 中一个特殊的值，表示无值或空值。它常用于初始化变量，或者表示函数未返回任何值。

• None 是唯一的 NoneType 对象类型，使用时通常与条件判断结合，用于检查一个变量是否有值。

  data = None  # 变量 data 尚未被赋任何值  
  if data is None:  
    print("No data available")  

---

4. 序列结构类型

序列结构类型在 Python 中用于存储一系列有序的数据，包括字符串、列表、元组、字典、集合等。

默认情况下，列表、元组、字符串是有序序列；字典、集合是无序序列。列表、字典、集合是可变序列；元组、字符串是不可变序列。

4.1 列表 [list, range]

• 列表（list）

  • 列表是一个可变的有序集合，可以包含不同类型的元素。

  • 使用方括号[]创建一个列表，元素之间用逗号,分隔。

  • 支持索引访问，并且支持添加或删除元素，支持切片操作。

  • 支持各种方法对列表进行操作，常用的如下。

  方法	说明
  lst.append(x)	将元素 x 添加到列表 lst 尾部
  lst.extend(L)	将列表 L 中的所有元素添加到列表 lst 尾部
  lst.insert(index, x)	在列表 lst 指定的位置 index 添加元素 x，该位置后面的所有元素将移到一个位置
  lst.remove(x)	在列表 lst 中删除第一个指定的元素 x，该元素之后的所有元素将移一个位置
  lst.pop([index])	删除并返回列表 lst 中指定 index 的元素（默认是 -1，即最后一个元素）
  lst.clear()	删除列表 lst 中所有元素，但保留列表对象
  lst.index(x)	返回列表 lst 中第一个值为 x 的元素的下标，如果不存在则抛出异常
  lst.count(x)	返回元素 x 在列表 lst 中出现的次数
  lst.reverse()	对列表 lst 所有元素进行翻转
  lst.sort(key=None, reverse=False)	对列表 lst 中的元素进行排序，key 参数指定排序依据，reverse 决定排序顺序（False 还是降序 (True)）
  lst.copy()	返回列表 lst 的浅复制（浅复制意味着新列表中的任何修改都不会反映到原始列表中）

  lst = [1, 2, 3, 'a', 'b']  
  lst.append(4)  # 添加元素  
  lst.remove('a')  # 删除元素  

• 范围（range）

  • range 是生成整数序列的内建函数，常用于循环中，具有从开始值到结束值生成不重复的整数序列的功能。
  • 可以指定步长，默认步长为 1。

  for i in range(5):  # 生成 0 到 4 的数字  
    print(i)  

4.2 元组 [tuple]

• 元组是一个不可变的有序集合，支持不同类型的元素。

• 元组的创建使用小括号 ()，元素之间用逗号,分隔，如果只包含一个元素，仍然需以逗号结尾，否则编译器分不清是否是在定义元组。

• 元组的不可变性意味着一旦创建，就不能进行修改。这使得元组常用于存储不应被更改的数据。

• 支持各种方法对元组进行操作，常用的如下。

  方法	说明
  x in tuple	若 x 是元组 tuple 中的一个元素，则返回 True，否则返回 False
  len(tuple)	元组 tuple 包含的元素数
  tuple.count(x)	元素 x 在元组 tuple 中出现的次数
  tuple.index(x)	元组 tuple 中第一个元素 x 的索引，若 x 未包含在 tuple 中，将引发 ValueError 异常
  max(tuple)/min(tuple)	返回元组中元素最大值/最小值
  tuple(seq)	将列表 seq 转换为元组

t = (1, 2, 3, 'a', 'b')  
single_element_tuple = (5,)  # 单元素元组  

4.3 字典 [dict]

• 字典是一个可变的无序集合，以键值对的形式存储数据。键必须唯一，且不可变，而值可以是任意类型。

• 使用花括号 {} 创建字典，通过键访问相应的值。键值对中间用冒号:相隔，键值对之间用逗号,相隔。

• 支持各种方法对字典进行操作，常用的如下。

  函数名	返回的值
  d.items()	返回一个由字典 d 的键—值对 (key, value) 组成的列表视图 (view)
  d.keys()	返回一个字典 d 的键组成的视图
  d.values()	返回一个字典 d 的值组成的视图
  d.get(key)	返回与 key 相关联的值
  d.pop(key)	删除键 key 并返回与之相关联的值
  d.popitem()	返回并删除字典中的最后一个键—值对
  d.clear()	删除字典 d 的所有元素
  d.copy()	复制字典 d
  d.fromkeys(s, t)	创建一个新字典，其中的键来自 s，值来自 t
  d.setdefault(key, v)	如果键 key 包含在字典 d 中，则返回其值；否则返回 v 并将 (key, v) 添加到字典中
  d.update(e)	将 e 中的键—值添加到字典 d 中；e 可以是键—值对序列

d = {'name': 'Alice', 'age': 25}  
d['age'] = 26  # 更新年龄  
d['city'] = 'Beijing'  # 新增城市键值对  

4.4 集合 [set, frozenset]

• 集合（set）

  • 集合是一个无序的可变集合，只含有唯一元素，适合用于去重或存储不重复的项目。
  • 创建时使用花括号 {} 或 set() 函数。集合不支持索引和切片操作。创建空集合一定要使用过set()函数，使用{}是创建空字典。
  • 集合和字典类似，也是一组key的集合，但不存储value。由于key 不能重复，所以在set中没有重复的key。
  • 常用方法略。

  s = {1, 2, 3, 4}  # 创建集合
  s.add(5)  # 添加元素  
  s.remove(3)  # 移除元素
  s2 = set() # 创建空集合

• 冻结集合（frozenset）

  • 冻结集合是不可变的集合，既保持了集合的特性，又可以作为字典的键或集合的元素使用。
  • 创建时使用 frozenset() 函数。

  my_frozenset = frozenset([1, 2, 3, 3])

---

5. 输入与输出

• 输入：使用input()方法获取用户输入，输入的内容会以字符串形式返回。程序会在执行到input()时停止执行，直至用户输入。

  参数只有一个，即提示的字符串，格式略。

  name = input("请输入你的名字：")  
  print("你好, " + name)  

• 输出：使用print()方法进行输出。

  格式如下：

  print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

  • *objects：序列，可以一次输出多个对象。输出多个对象时需要用 ,分隔参数。
  • sep：设定以什么来间隔多个对象，默认值是空格。
  • end：设定以什么结尾，默认值是换行符\n。
  • file：要写入的文件对象，默认值是系统输出流。
  • flush：设定输出流是否强制刷新，默认值为False，即默认不会强制刷新。

  a = "hello"
  b = "world"
  print(a, b, sep = ",", end = "!\n") # 输出 hello,world!

---

6. 运算符

Python中这一部分基本和C/C++类似，要注意注意的有 内存比较运算符、成员资格运算符、逻辑运算符。

6.1 算术运算符

基本算数运算符如下，也支持简写，如+=、*=等

• +：加法
• -：减法
• *：乘法
• /：除法（结果是浮点数）
• //：整除（只保留整数部分）
• %：取余
• **：幂运算

a = 5  
b = 2  
print(a + b)  # 输出: 7  
print(a / b)  # 输出: 2.5  
print(a // b)  # 输出: 2  
print(a % b)  # 输出: 1  
print(a ** b)  # 输出: 25  

6.2 比较运算符

• ==：等于
• !=：不等于
• >：大于
• <：小于
• >=：大于等于
• <=：小于等于

6.3 逻辑运算符

• and：与
• or：或
• not：非

x = True  
y = False  
print(x and y)  # 输出: False  
print(x or y)   # 输出: True  
print(not x)    # 输出: False  

6.4 位运算符

• &：按位与
• |：按位或
• ~：非
• <<：左移位，如：x << 2
• >>：右移位，如：x >> 2

6.5 内存比较运算符

• is：并非比较两个对象是否相等，而是比较它们在内存中是否是同一位置，即是否是一个对象。但也要注意的是Python中完全相同的值是用一个内存存储的，见下例。
• is not：比较两个对象在内存中是否不是是同一位置

a = 1  
b = 1  
c = a
d = 1.0
print(a is b)  # 输出: True
print(a is c)  # 输出: True
print(a == d)  # 输出: True
print(a is d)  # 输出: False

6.6 成员资格运算符

• in：检查对象是否在序列中
• not in：检查对象是否不在序列中

---

7. 流程控制

Python中这一部分也基本和C/C++类似，只要注意一下Python语法格式即可。

7.1 条件语句

条件语句用于根据条件的真假执行不同的代码，相比于C/C++的else if，Python使用elif。

age = 18  

if age >= 18:  
    print("你是成年人。")  
elif age >= 13:  
    print("你是青少年。")  
else:  
    print("你还是未成年人。")  

7.2 循环语句

Python提供for和while循环来处理重复操作。

• for循环

  用于遍历。

  fruits = ["apple", "banana", "cherry"]  
  for fruit in fruits:  
    print(fruit)  

• while循环

  在条件为True时，循环会持续执行。

  count = 0  
  while count < 5:  
    print(count)  
    count += 1  # 每次循环，count加1  

7.3 推导式

在Python中，推导式是一种简洁的方式来创建列表、字典、集合。其按照某种规则，以一个数据序列（如列表，字典和集合等）为基础，推导出另外一个新的数据序列。即把普通的多行for循环压缩成一行代码，适用于列表、字典、集合等可迭代数据结构。

• 列表推导式

  使用[]来表示此类型推导式，语法：

  x = [expression for item in iterable if condition]
  # 等价于
  x = []
  for item in iterable:
    if condition:
        x.append(expression)

  示例：

  # 生成一个包含1到10之间平方数的列表：
  squares = [x**2 for x in range(1, 11)]  
  print(squares)  # 输出: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]  

• 字典推导式

  使用{}来表示此类型推导式，同时注意字典的key:value格式，语法：

  x = {key_expression: value_expression for item in iterable if condition}
  # 等价于
  x = {}
  for item in iterable:
    if condition:
        x.append(key_expression : value_expression)

  示例：

  # 生成一个以数字为键，平方数为值的字典：
  squares_dict = {x: x**2 for x in range(1, 6)}  
  print(squares_dict)  # 输出: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}  

• 集合推导式

  也使用{}来表示此类型推导式，但没有键值对，语法：

  x = {expression for item in iterable if condition}  

  示例：

  # 生成一个包含1到10之间的奇数的集合：
  odd_numbers = {x for x in range(1, 11) if x % 2 != 0}  
  print(odd_numbers)  # 输出: {1, 3, 5, 7, 9}  

• 生成器推导式
  语法与列表推导式类似，但使用圆括号，而不是方括号。它在使用时按需生成值，节省内存。示例：

  # 生成一个生成1到10间平方数的生成器：
  squares_gen = (x**2 for x in range(1, 11))  
  
  for square in squares_gen:  
    print(square)  # 输出: 1, 4, 9, ..., 100  

---

8. 函数

函数是代码的封装，可以重用，使用def关键字定义。

8.1 函数的定义与调用

• 使用关键字def来定义函数，函数名命名格式与变量一样，整体格式与C/C++差不多。
• 不用指定返回值类型和参数类型，都只靠编译器自动处理。
• Python参数的传递方式是引用传递，传递的参数占用同一片内存地址。

def greet(name):  
    return f"Hello, {name}"  

print(greet("Alice"))  # 输出: Hello, Alice  

8.2 参数传递的特殊使用

• 默认参数：支持为参数设置默认值。

  def greet(name="Guest"):  
    return f"Hello, {name}"  
  
  print(greet())  # 输出: Hello, Guest  

• 可变参数：支持接收任意数量的参数。使用指定关键字，使用*args表示接收多个位置参数，使用**kwargs表示接收多个关键字参数。

  def add(*args):  
    return sum(args)  
  
  print(add(1, 2, 3))  # 输出: 6  
  pythondef print_info(**kwargs):  
    for key, value in kwargs.items():  
        print(f"{key}: {value}")  
  
  print_info(name="Alice", age=25)  

• 关键字参数：调用时根据参数名称来赋值。清晰地指定参数值，所以实参和形参的顺序不重要，可以不一致。

  def fun(name,age,score):
  print("姓名:{0},年龄:{1},分数:{2}".format(name,age,score))
  fun("Tom", 20, 100) # 普通调用
  fun(name="Tom", score=100, age=20) # 通过关键字设置参数

---

9. 类和对象

Python是面向对象的编程语言，通过类定义对象的特征和行为。

9.1 类的定义与使用

• 使用class关键字来定义类，注意最好使用大写驼峰来命名。
• 无须像C/C++那样指定类或类中成员的访问权限，使用下划线来标识访问权限。
• 以单下划线开头（如：_foo ）的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用from ... import ... 导入使用。
• 只以双下划线开头（如： __foo）代表类的私有成员。
• 以双下划线开头和结尾的（如：__init__、__str__等）代表 Python 里特殊方法专用的标识，要避免这样命名。
• __init__：构造函数，初始化对象的属性，其参数中要使用self加入当前对象。
• self：指代当前对象，类似于C/C++中的this指针，允许访问对象的属性和方法。要注意，因为Python中无须对变量进行声明，所以直接使用self来定义类中的成员变量，如下。

class Dog:  
    def __init__(self, name): 
        self.name = name  # 定义了实例变量  

    def bark(self):  
        return f"{self.name} says Woof!"  # 类的方法  

dog = Dog("Buddy")  # 创建一个Dog对象  
print(dog.bark())  # 输出: Buddy says Woof!  

9.2 类的继承

可以创建一个新类，它继承自已有的类。

class Puppy(Dog):  
    def play(self):  
        return f"{self.name} is playing!"  

puppy = Puppy("Charlie")  
print(puppy.bark())  # 输出: Charlie says Woof!  
print(puppy.play())  # 输出: Charlie is playing!  

---

10. 文件处理

Python提供内置方法来处理文件，也提供了os、os.path、shutil等模块处理文件。以下提供简便的文件操作，更复杂的文件操作可以学习对应模块。

• 打开/关闭文件

  • 使用open()方法，第一个参数指定文件路径，第二个参数指定文件打开方式。格式如下

  open(file, [mode[, buffering]])

  • 使用with语句可以自动管理文件的打开和关闭。当然也可不用，手动调用close()方法关闭文件。

  • 支持多种文件打开方式：

  模式	描述
  r	以只读的方式打开文件
  r+	以读写的方式打开文件
  w	以写入的方式打开文件。先删除文件原有的内容，再重新写入新的内容。如果文件不存在，则创建一个新的文件。
  w+	以读写的方式打开文件。先删除文件原有的内容，再重新写入新的内容。如果文件不存在，则创建一个新的文件。
  a	以写入的方式打开文件，在文件末尾追加新的内容。如果文件不存在，则创建一个新文件
  a+	以读写的方式打开文件，在文件末尾追加新的内容。如果文件不存在，则创建一个新文件
  x	只创建文件

  with open("test.txt", "r") as file:  # 读取模式  
    file.read()

• 读取文件

  使用读取模式r、r+。

  • 调用read()方法读取整个文件
  • 调用readline()方法读取文件中的一行
  • 调用readlines()方法读取文件中的多行

  with open("test.txt", "r") as file:  # 读取模式  
    content = file.read()  # 读取整个文件内容  
    print(content)  # 输出: Hello, World!  

• 写入文件

  使用写入模式w、w+、a、a+，注意写入模式的区别，直接调用write()方法就可以写入了。

  with open("test.txt", "w") as file:  # 写入模式  
    file.write("Hello, World!\n")  # 添加换行符  

---

11. 异常处理

Python使用try: ... except: ... 语句来排查需要执行的代码是否有异常。

类似C++的try{...}catch(...){...}。

try: # 如果无异常就执行以下语句
  print(x)
except: # 如果有异常就执行以下语句
  print("An exception occurred")

Python支持使用多个except ... : ...同时排查多个指定异常。

try: # 如果无异常就执行以下语句
  print(x)
except NameError: # 如果发生NameError异常就执行下面语句
  print("Variable x is not defined")
except: # 如果发生其他异常就执行下面语句
  print("Something else went wrong")

Python支持使用else: ...来执行未发生错误的语句。

try: # 如果无异常就执行以下语句
  print("Hello")
except: # 如果有异常就执行以下语句
  print("Something went wrong")
else: # 如果无异常会额外执行以下语句
  print("Nothing went wrong")

Python支持使用finally: ...来一定执行语句，无论是否存在异常。

try: # 如果无异常就执行以下语句
  print(x)
except: # 如果有异常就执行以下语句
  print("Something went wrong")
finally:  # 无论是否有异常，都会额外执行以下语句
  print("The 'try except' is finished")