Python环境搭建

网上有许多关于Python环境搭建的详细教程，这里就不花大篇幅描述，简单带过。需要的推荐阅读：Python安装与环境配置全程详细教学（包含Windows版和Mac版）

Python环境安装

1、下载Python：

Python下载地址：Download Python | Python.org

2、安装Python

3、环境配置

开发工具安装

• PyCharm

• Anaconda

• VS Code

• ……

工具的选择有许多，建议哪个顺手用哪个，重要的是在于多动手练习。

变量

变量的定义

1. 变量赋值：变量是存放数据值的容器。在Python中，变量的定义是通过赋值来实现的。例如：

   my_var = 10

   这里，my_var 是变量名，10 是赋给变量的值。

2. 变量名规则：

   • 变量名必须以字母或下划线开头。

   • 变量名只能包含字母、数字和下划线（A-z, 0-9, 和 _ ）。

   • 变量名是区分大小写的。

3. 多个变量赋值：

   Python 允许您在一行中为多个变量赋值:

   x, y, z = "Orange", "Banana", "Cherry"
   print(x) # Orange
   print(y) # Banana
   print(z) # Cherry
   
   
   x = y = z = "Orange"
   print(x) # Orange
   print(y) # Orange
   print(z) # Orange

4. 动态类型：Python是动态类型语言，这意味着变量的类型在运行时根据赋值自动确定，并且可以在程序执行过程中改变。

变量的类型

Python中有一些基本数据类型，包括：

1. 整数（int）：用于存储整数，例如 123 或 -456。

2. 浮点数（float）：用于存储小数，例如 3.14 或 -1.59。

3. 字符串（str）：用于存储文本，例如 "Hello, World!" 或 'Python'。字符串可以包含字母、数字、符号和空格。

4. 布尔值（bool）：只有两个值，True 和 False。

5. 列表（list）：有序的元素集合，可以包含不同类型的元素，例如 [1, 'a', 3.14]。

6. 元组（tuple）：类似于列表，但是元组是不可变的，例如 (1, 'a', 3.14)。

7. 字典（dict）：无序的键值对集合，例如 {'name': 'Alice', 'age': 25}。

8. 集合（set）：无序的唯一元素集合，例如 {1, 2, 3}。

9. 复数（complex）：用于存储复数，复数用 "j" 作为虚部编写，例如 3+4j 或 -2-5j。

10. NoneType：None 是一个特殊的类型，表示没有值。

获取数据类型：可以使用 type() 函数获取任何对象的数据类型

数据类型转换

Python允许在不同数据类型之间进行转换，使用内置函数如 int(), float(), str() ,bool( )等。

my_int = 7
my_float = float(my_int)  # 将整数转换为浮点数
my_str = str(my_int)     # 将整数转换为字符串

标识符和关键字

标识符

在Python中，标识符是用来标识变量、函数、类、模块和其他对象的名称。以下是关于Python标识符的一些规则和最佳实践：

基本规则：

1. 首字符：标识符的第一个字符必须是字母（A-Z，a-z）或下划线（_）。

2. 后续字符：第一个字符之后，标识符可以包含字母、数字（0-9）和下划线。

3. 大小写敏感：Python是大小写敏感的语言，这意味着MyVariable和myvariable是两个不同的标识符。

4. 不能使用关键字：不能使用Python的保留关键字作为标识符，例如if、for、while等。

5. 不能包含特殊字符：标识符不能包含空格、标点符号或其他特殊字符。

最佳实践：

1. 可读性：选择有意义的、描述性的名称，以提高代码的可读性。

2. 简洁性：尽量保持标识符名称简洁，但同时要确保它们足够描述性。

3. 一致性：在同一个项目中，保持命名风格的一致性。

4. 避免缩写：除非缩写是广泛认可的，否则避免使用缩写，以减少混淆。

5. 下划线命名：

   • 单下划线（_）：在某些情况下，单下划线用于表示一个受保护的实例变量。

   • 双下划线（__）：双下划线用于名称重整，Python会将这样的标识符名称修改为_ClassName__privateName的形式，以避免子类中的名称冲突。

6. 函数和变量：通常使用小写字母和下划线（snake_case）来命名函数和变量。

7. 类：通常使用首字母大写的驼峰式命名（CamelCase）来命名类。

8. 常量：常量通常使用全大写字母和下划线来命名，例如MAX_VALUE。

示例

# 正确的标识符
my_variable = 10
_my_variable = 20
MY_VARIABLE = 30
myVariable1 = 40

# 错误的标识符
2my_variable = 50  # 不能以数字开头
my-variable = 60  # 不能包含减号
my variable = 70  # 不能包含空格
my$variable = 80  # 不能包含特殊字符

关键词

Python的关键词是具有特殊意义的单词，它们用于表示特定的语言结构。以下是一些Python 3.9版本中的关键词列表：

False               def                  lambda              return
None                del                  pass                raise
True                elif                 class               try
and                 else                 finally             while
as                  except               for                 with
assert              exec                 from                yield
break               finally              global              as

这些关键词不能用作标识符，因为它们在Python中具有特定的用途。例如，if用于条件语句，for用于循环，class用于定义类等。

示例

# 正确的标识符
my_variable = 10
_my_variable = 20
MY_VARIABLE = 30
variable1 = 40

# 错误的标识符（尝试使用关键词）
if = 50  # 错误：'if' 是关键词

输入和输出

Python中的输入和输出是程序与用户之间进行交互的基本方式。以下是Python中进行输入和输出操作的基本方法：

输入（Input）

在Python中，可以使用input()函数从用户那里获取输入。input()函数会暂停程序的执行，等待用户输入一些文本，然后按下回车键。输入的文本将作为字符串返回。

# 获取用户输入
user_input = input("请输入一些内容: ")
print("您输入的内容是: ", user_input)

输出（Output）

Python中输出最常见的方式是使用print()函数。print()函数可以将信息打印到控制台。

# 输出字符串
print("Hello, World!")

# 输出多个值
print("Hello", "World", "!")

# 输出表达式结果
print(1 + 2)

# 格式化输出
name = "Kimi"
print("你好，我的名字是 %s" % name)
print(f"你好，我的名字是 {name}")

格式化字符串

Python提供了多种方式来格式化字符串，包括使用百分号（%）操作符、str.format()方法和f-string（Python 3.6+）。

• 百分号（%）操作符：

name = "Kimi"
age = 30
print("我的名字是 %s，我的年龄是 %d" % (name, age))

• str.format()方法：

name = "Kimi"
age = 30
print("我的名字是 {0}，我的年龄是 {1}".format(name, age))

• f-string：

name = "Kimi"
age = 30
print(f"我的名字是 {name}，我的年龄是 {age}")

运算符

Python语言支持以下类型的运算符：

• 算术运算符

• 比较（关系）运算符

• 赋值运算符

• 逻辑运算符

• 位运算符

• 成员运算符

• 身份运算符

Python算术运算符

比较（关系）运算符

赋值运算符

逻辑运算符

位运算符

成员运算符

身份运算符

流程控制语句

条件语句

if

if语句用于在满足特定条件时执行代码块。

x = 10
if x > 5:
    print("x is greater than 5")

if-else

if-else语句用于在条件为真时执行一段代码，条件为假时执行另一段代码。

x = 5
if x > 5:
    print("x is greater than 5")
else:
    print("x is not greater than 5")

if-elif-else

if-elif-else结构允许你检查多个条件。

x = 3
if x > 5:
    print("x is greater than 5")
elif x > 2:
    print("x is greater than 2")
else:
    print("x is 2 or less")

简写

a = 330
b = 330

# 单行 if 语句
if a > b: print("a is greater than b")

# 单行 if else 语句
print("A") if a > b else print("B")

# 单行 if else 语句，有三个条件
print("A") if a > b else print("=") if a == b else print("B")

嵌套 If

可以在 if 语句中包含 if 语句，这称为嵌套 if 语句。

x = 41

if x > 10:
 print("Above ten,")
  if x > 20:
    print("and also above 20!")
  else:
    print("but not above 20.")

循环语句

For循环

for循环用于遍历序列（如列表、元组、字典、集合）或任何可迭代对象。

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

For 循环中的 Else

for 循环中的 else 关键字指定循环结束时要执行的代码块:

# 打印 0 到 5 的所有数字，并在循环结束时打印一条消息
for x in range(6):
  print(x)
else:
  print("Finally finished!")

'''
0
1
2
3
4
5
Finally finished!
'''

While循环

while循环用于在某个条件为真时重复执行代码块，只要条件为真，就可以执行一组语句。

x = 1
while x <= 5:
    print(x)
    x += 1

While 循环中的 Else

通过使用 else 语句，当条件不再成立时，我们可以运行一次代码块:

# 条件为假时打印一条消息
i = 1
while i < 6:
  print(i)
  i += 1
else:
  print("i is no longer less than 6")

'''
1
2
3
4
5
i is no longer less than 6
'''

循环控制语句break、contiune和pass

break

break语句用于立即终止循环。

for i in range(1, 10):
    if i == 6:  # 当n = 6时，条件满足，执行break语句
        break  # break语句会结束当前循环
    print(i)

continue

continue语句用于跳过当前循环的剩余部分，并继续下一次迭代。

# 只打印奇数
for i in range(1, 10):
    if i % 2 == 0:  # 如果n是偶数，执行continue语句
        continue  # continue语句会直接继续下一轮循环，后续的print()语句不会执行
    print(i)

pass

pass语句是一个空操作，可以用来作为循环或条件语句的占位符。

for i in range(3):
    if i == 2:
        pass  # 这里什么也不做
    print(i)

range语句

range(num) #获取一个从0开始，到num的序列（不包含num本身）

range(num1,num2) #获得一个从 num1 开始，到 num2 结束的数字序列（不含 num2 本身）
 #如， range(5, 10) 取得的数据是： [5, 6, 7, 8, 9]

range(num1,num2,step) #获得一个从 num1 开始，到 num2 结束的数字序列（不含 num2 本身）
 #数字之间的步长，以 step 为准（ step 默认为 1 ）
 #如， range(5, 10, 2) 取得的数据是： [5, 7, 9]

字符串

字符串概念

Python中的字符串是一种用于存储文本的数据类型，它可以包含字母、数字、符号和空格。字符串可以是单引号（'）、双引号（"）或三引号（''' 或 """）括起来的字符序列。

字符串不可变：Python中的字符串是不可变的，这意味着一旦创建了字符串，你就不能改变它的值。

字符串是一种特殊的元组，因此可以执行元组的相关操作。

字符串索引

字符串可以被索引和切片。索引从0开始，负数索引从字符串末尾开始。

s = "Hello"
print(s[0])  # 输出 'H'
print(s[-1]) # 输出 'o'

字符串切片

切片允许你获取字符串的一部分（顾头不顾尾）。

s = "Hello"
print(s[1:4]) # 输出 'ell'

字符串连接

可以使用+操作符来连接字符串。

s1 = "Hello, "
s2 = "World!"
s3 = s1 + s2  # 输出 'Hello, World!'

字符串重复

可以使用*操作符来重复字符串。

s = "abc"
s_repeated = s * 3  # 输出 'abcabcabc'

字符串方法

Python字符串有许多内置的方法，例如：

• .upper()：将所有字符转换为大写。

• .lower()：将所有字符转换为小写。

• .capitalize()：将字符串的第一个字符转换为大写，其余字符转换为小写。

• .title()：将字符串的每个单词的首字母转换为大写。

• .strip()：移除字符串两端的空白字符。

• .lstrip()：去除字符串左侧的空白字符。

• .rstrip()：去除字符串右侧的空白字符。

• .split()：以指定的字符为分隔符分割字符串。

• .join()：将序列中的元素以指定的字符连接成字符串。

• .replace()：替换字符串中的某些字符。

• .find()：查找子字符串在字符串中的位置。

• .format()：格式化字符串。

• .count()：统计字符串中指定子字符串出现的次数。

s = "Hello, World!"
s_upper = s.upper()  # 输出 'HELLO, WORLD!'
s_lower = s.lower()  # 输出 'hello, world!'
s_stripped = s.strip()  # 输出 'Hello, World!'（如果字符串前后有空格，则去除它们）
s_split = s.split(", ")  # 输出 ['Hello', 'World!']
s_joined = ", ".join(["Hello", "World!"])  # 输出 'Hello, World!'
s_replaced = s.replace("World", "Python")  # 输出 'Hello, Python!'
s_find = s.find("World")  # 输出 7（因为'World'从索引7开始）

字符串格式化

Python支持多种字符串格式化方法，包括传统的%操作符、str.format()方法和f-strings（Python 3.6+）。

# 使用 % 操作符
name = "Alice"
age = 30
s = "My name is %s and I am %d years old." % (name, age)

# 使用 str.format() 方法
s = "My name is {} and I am {} years old.".format(name, age)

# 使用 f-strings
s = f"My name is {name} and I am {age} years old."

转义字符

• \n：表示换行符

• \t：表示制表符，通常用于缩进

• \b：表示退格符，用于删除前一个字符

• \r：表示回到当前行的开头（这里说明一下，\r后面的字符会覆盖当前行之前的内容）

• \：表示反斜杠字符本身

• \’：表示单引号字符

• \”：表示双引号字符

列表和元组

Python 编程语言中有四种集合数据类型:

• 列表（List） 是一种有序和可更改的集合。允许重复的成员。

• 元组（Tuple） 是一种有序且不可更改的集合。允许重复的成员。

• 集合（Set） 是一个无序和无索引的集合。没有重复的成员。

• 词典（Dictionary） 是一个无序，可变和有索引的集合。没有重复的成员。

列表（List）

列表可以包含任何种类的对象，是一种可变对象，这意味着你可以在列表创建后修改它的内容，比如添加、删除或更改元素。

列表的基本特性：

1. 有序：列表中的元素是有序的，这意味着元素的插入顺序被保留。

2. 可变：你可以更改列表的内容，比如添加、删除或替换元素。

3. 异构：列表可以包含不同类型的元素。

4. 动态：列表的大小可以动态变化。

创建列表：

list = [ ]，创建列表时，使用方括号[]，元素之间用逗号分隔。

list( ) 函数创建(转换为)列表，注意：在使用 list() 函数创建列表时，一定要注意双括号。

my_list = [1, 2, 3, 'a', 'b']

this_list = list(('apple', 'banana', 'cherry'))

访问列表元素：

你可以通过索引来访问列表中的元素，索引从0开始。

# 访问第一个元素
first_element = my_list[0]

# 访问最后一个元素
last_element = my_list[-1]

列表切片：

切片用于获取列表的一部分。

list_name[strat : end : step] ，其中，start 表示起始索引，end 表示结束索引，step 表示步长。

list_name = ['wzq', 'lgl', 'gz', 'whl', 'sj', 'hxw']
print(list_name[1:5:2])  # ['lgl', 'whl']
print(list_name[-6:-1:3])  # ['wzq', 'whl']

修改列表：

你可以更改列表中的元素，添加新元素，或从列表中删除元素。

# 更改元素
my_list[0] = 10

# 添加元素
my_list.append('c')  # 在列表末尾添加 'c'

# 插入元素
my_list.insert(1, 'new')  # 在索引1的位置插入 'new'

# 删除元素
del my_list[2]  # 删除索引2的元素
my_list.remove('a')  # 删除列表中第一个出现的 'a'
my_list.pop()  # 删除并返回列表的最后一个元素
my_list.clear() # 清空列表
thislist = my_list.copy() # 复制列表

合并列表:

list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

# 使用 + 运算符
list3 = list1 + list2

# 将 list2 中的所有项一个接一个地追加到 list1 中
for x in list2:
  list1.append(x)

# 使用 extend() 方法，其目的是将一个列表中的元素添加到另一列表中
list1.extend(list2)

列表遍历：

你可以使用for循环来遍历列表中的每个元素。

fruit_list = ['apple', 'pear', 'cherry']
for i in fruit_list:
    print(i)

'''
apple
pear
cherry
'''

嵌套列表：

使用嵌套列表即在列表里面创建其他列表。

x = [1, 2, 3]
y = ['a', 'b', 'c']
z = [x, y]
print(z)

# [[1, 2, 3], ['a', 'b', 'c']]

列表推导式：

列表推导式是一种简洁的方式来创建列表。

squared_list = [x**2 for x in range(10)]  # 创建一个包含0到9的平方的列表

列表方法：

• append(x)：在列表末尾添加一个元素x。

• extend(iterable)：在列表末尾一次性追加另一个序列中的多个值。

• insert(i, x)：在指定位置i插入一个元素x。

• remove(x)：移除列表中第一个值为x的元素。

• pop([i])：移除列表中指定位置i的元素，并返回该元素。如果不指定i，则默认移除并返回列表中的最后一个元素。

• sort(key=None, reverse=False)：对列表中的元素进行排序。

• index(x[, start[, end]])：返回列表中第一个值为x的元素的索引。

• 更多列表/数组上使用的内置方法

示例：

my_list = [1, 2, 3]
my_list.append(4)  # [1, 2, 3, 4]
my_list[0] = 'a'   # ['a', 2, 3, 4]

元组（Tuple）

元组是不可变的，这意味着一旦元组被创建，你不能更改它的元素。

创建元组：

tuple = ( )，使用括号( )创建，元素之间用逗号分隔。

如需创建仅包含一个项目的元组，您必须在该项目后添加一个逗号，否则 Python 无法将变量识别为元组。

不使用圆括号，直接用逗号分隔元素。

tuple()将其他序列转换为元组。

my_tuple = (1, 2, 3, 'a', 'b')
# 或者
my_tuple = 1, 2, 3, 'a', 'b'

访问元组

通过引用方括号内的索引号来访问元组。

# 访问第一个元素
first_element = my_tuple[0]

# 访问最后一个元素
last_element = my_tuple[-1]

更改元组值

创建元组后，您将无法更改其值。元组是不可变的，或者也称为恒定的。

但是有一种解决方法。您可以将元组转换为列表，更改列表，然后将列表转换回元组。

x = ("apple", "banana", "cherry")
y = list(x)
y[1] = "kiwi"
x = tuple(y)

print(x)

遍历元组

您可以使用 for 循环遍历元组。

thistuple = ("apple", "banana", "cherry")
for x in thistuple:
  print(x)

元组嵌套

元组可以包含其他元组，从而实现嵌套结构。

nested_tuple = (1, (2, 3), (4, (5, 6)))

print(nested_tuple[1]) # 输出 (2, 3)
print(nested_tuple[2][1]) # 输出 (5, 6)

切片操作

元组支持切片操作，可以获取元组的子集。

tuple7 = (1, 2, 3, 4, 5)

print(tuple7[1:3]) # 输出 (2, 3)
print(tuple7[:2]) # 输出 (1, 2)
print(tuple7[3:]) # 输出 (4, 5)

合并元组

如需连接两个或多个元组，您可以使用 + 运算符:

tuple1 = ("a", "b" , "c")
tuple2 = (1, 2, 3)

tuple3 = tuple1 + tuple2
print(tuple3)

元组的方法：

• count(x)：返回元素x在元组中出现的次数。

• index(x[, start[, end]])：返回列表中第一个值为x的元素的索引。

示例：

my_tuple = (1, 2, 3)
# my_tuple[0] = 'a'  # 错误：元组不支持项赋值

列表和元组对比

相同

• 都是有序集合，可以存储任意类型的元素。

• 都支持索引和切片操作。

• 都可以用len()函数获取长度。

不同

• 可变性：列表是可变的，元组是不可变的。

• 性能：由于元组的不可变性，它们通常在性能上比列表更优，特别是在创建大量小对象时。

• 用途：列表用于存储需要修改的数据，元组用于存储不应改变的数据。

• 内存使用：元组的内存开销通常比列表小。

在选择使用列表还是元组时，需要根据数据是否需要修改来决定。如果不需要修改集合中的元素，使用元组可以提高代码的安全性和性能。

字典

字典的概念

Python 字典是一种映射类型的数据结构，其中的数据以键值对（key-value pairs）的形式存储。字典的实现基于哈希表，使得键值对的查找和操作速度非常快。

• 键（Key）: 键必须是唯一的，并且是可哈希的（如整数、字符串、元组等不可变类型）。这意味着两个不同的键不能具有相同的哈希值。

• 值（Value）: 值可以是任意类型，包括数字、字符串、列表、甚至是另一个字典。

基本特点：

• 键的唯一性：字典中的每个键必须是唯一的。

• 可变性：字典是可变的，这意味着可以动态地增加、修改和删除键值对。

• 无序性：在 Python 3.7 之前，字典中的元素没有顺序。从 Python 3.7 开始，字典按插入顺序保存键值对。

创建字典

字典可以用大括号 {} 来创建，也可以使用 dict() 函数。

使用 fromkeys() 方法，用于创建包含指定键并且所有值相同的字典

# 使用大括号创建字典
my_dict = {
    'name': 'Alice',
    'age': 25,
    'city': 'New York'
}

# 使用dict()函数创建字典
my_dict = dict(name='Alice', age=25, city='New York')

# fromkeys() 方法
a = {}.fromkeys(('x', 'y'), 0)
print(a)
# 输出: {'x': 0, 'y': 0}

访问字典中的值

你可以通过键来访问字典中的值。

还有一个名为 get() 的方法会给你相同的结果

# 访问字典中的值
name = my_dict['name']
print(name)  # 输出: Alice

x = my_dict.get("name") # get()

如果键不存在，将会抛出 KeyError。

修改字典

字典中的值可以被修改或者添加新的键值对。

# 修改值
my_dict['age'] = 26

# 添加新的键值对
my_dict['email'] = 'alice@example.com'

删除字典中的元素

可以使用 del 语句或者 pop() 方法来删除字典中的元素，clear() 方法清空整个字典。

# 使用del语句
del my_dict['city']

# 使用pop()方法，这个方法还会返回被删除的值
email = my_dict.pop('email')

#clear()
a = {1: 100, 2: 200}
a.clear()
print(a)  # 输出: {}

遍历字典

可以遍历字典的键、值或键值对。

# 遍历键
for key in my_dict:
    print(key)

# 遍历值
for value in my_dict.values():
    print(value)

# 遍历键值对
for key, value in my_dict.items():
    print(f'{key}: {value}')

检查键是否存在

可以使用 in 关键字来检查某个键是否存在于字典中。

# 检查键是否存在
if 'name' in my_dict:
    print('Name exists in the dictionary')

字典的方法

字典提供了许多方法来操作字典，比如 clear()（清空字典）、copy()（复制字典）、get()（安全地访问字典中的值）、update()（更新字典）等。

# 使用get方法安全访问值，如果键不存在，可以返回一个默认值
value = my_dict.get('non_existent_key', 'Default Value')

# 使用update方法更新字典
my_dict.update({'age': 27, 'country': 'USA'})

# 使用clear方法清空字典
my_dict.clear()  # 清空后，my_dict 变为 {}

函数

在Python中，函数是一种组织代码的方式，它允许你将一段代码封装起来，并在需要时重复使用。以下是Python函数的一些基本概念和用法。

定义函数

使用def关键字来定义一个函数，后跟函数名和括号。括号内可以包含参数，用来接收传递给函数的数据。然后是冒号，冒号后面是缩进的代码块，定义了函数体。

def my_function(param1, param2):
    # 函数体
    print("Hello, World!")
    return param1 + param2

参数和返回值

• 参数：函数可以有零个或多个参数，这些参数在函数定义时声明，并在调用函数时传递值。

• 返回值：使用return关键字从函数返回值。如果函数执行到return语句，函数执行结束，并返回指定的值。

调用函数

通过函数名和一对圆括号( )来调用函数，圆括号内可以传递参数。

result = my_function(5, 3)

参数

Python 函数可以接受多种形式的参数，包括必需参数、关键字参数、默认参数等。

必需参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时一样。

def print_age(name, age):
    print(f"{name} is {age} years old.")

关键字参数

关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

print_age(age=26, name="Bob")  # 输出: Bob is 26 years old.

默认参数

可以为函数参数指定默认值，这样在调用函数时，如果没有提供该参数的值，则使用默认值。

def greet(name, message="Hello"):
    print(f"{message}, {name}!")

可变参数

可以使用*来定义可变数量的参数，这些参数将被打包成一个元组。

def print_names(*names):
    for name in names:
        print(name)

print_names("Alice", "Bob", "Charlie")  # 输出: Alice, Bob, Charlie

可变关键字参数

可以使用**来定义接受任意数量关键字参数的函数，这些参数将被打包成一个字典。

def print_key_values(**kwargs):
    for key, value in kwargs.items():
        print(f"{key} = {value}")

print_key_values(apple=1, banana=2, cherry=3)  # 输出: apple = 1, banana = 2, cherry = 3

函数注解

Python 3 允许在函数定义中使用注解，为参数和返回值提供元数据。叫 type hint， 即类型提示。

def add_numbers(a: int, b: int) -> int:
    return a + b

嵌套函数

函数内部可以定义另一个函数。

def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

递归函数

递归函数是一种调用自身的函数。递归函数需要有一个明确的结束条件。

def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)

Lambda 函数

Lambda 函数是一种简洁的定义单行函数的方式。

lambda 函数是一种小的匿名函数。

lambda 函数可接受任意数量的参数，但只能有一个表达式。

add = lambda x, y: x + y

函数装饰器

装饰器是一种特殊类型的函数，它允许你在不修改函数内容的情况下增加函数功能。

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def my_function():
    print("Hello, World!")

函数是Python编程中非常重要的一个概念，它们不仅可以帮助你重用代码，还可以提高代码的模块化和可读性。

作用域

变量的作用域决定了变量在程序中的可见性和可访问性，即变量在哪些部分可以被引用和使用。

变量的四种作用域

LEGB规则

• L：local（局部作用域），局部作用域，即函数中定义的变量；

• E：enclosing（嵌套局部作用域），嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是全局的；

• G：globa（全局作用域），全局变量，就是模块级别定义的变量；

• B：built-in（内置作用域），系统固定模块里面的变量，比如int, bytearray等

搜索变量的优先级顺序依次是：作用域局部>外层作用域>当前模块中的全局>python内置作用域，也就是LEGB。

1. 局部作用域

   局部作用域也称为函数作用域，是变量在函数内部定义时的范围。在函数内部定义的变量只在该函数内部可见，当函数执行完毕后，这些变量就会被销毁。

   def my_function():
       local_var = "我在局部作用域内"
       print(local_var)
   
   my_function()  # 输出：我在局部作用域内
   # 尝试在函数外部访问 local_var 会导致 NameError
   # print(local_var)  # NameError: name 'local_var' is not defined
   1234567'

2. 嵌套局部作用域

   嵌套局部作用域指的是在函数内部定义的另一个函数中的变量作用域。内部函数可以访问外部函数的局部变量，但外部函数无法直接访问内部函数的局部变量。

   def outer_function():
       outer_var = "我在外部函数作用域内"
       
       def inner_function():
           inner_var = "我在嵌套局部作用域内"
           print(outer_var)  # 可以访问外部函数的变量
           print(inner_var)
       
       inner_function()
   
   outer_function()  # 输出：我在外部函数作用域内，我在嵌套局部作用域内
   1234567891011'

3. 全局作用域

   全局作用域是指在整个程序中都可见的变量作用域。在函数外部定义的变量属于全局作用域，它们可以在程序的任何地方被访问和修改（除非在函数内部被重新定义为局部变量）。

   global_var = "我在全局作用域内"
   
   def another_function():
       print(global_var)  # 可以访问全局变量
   
   another_function()  # 输出：我在全局作用域内
   123456'

4. 内置作用域

   内置作用域是Python解释器自带的变量作用域，它包含了所有内置函数和异常的名字。这些名字在程序任何地方都是可见的，但通常我们不会修改它们。

   例如，len()、print()等内置函数就位于内置作用域中。

示例

下面是一个综合了以上作用域的示例代码：

# 全局作用域
global_scope_var = "全局变量"

def outer_function():
    # 嵌套局部作用域（属于outer_function）
    nested_scope_var = "嵌套局部变量"
    
    def inner_function():
        # 局部作用域（属于inner_function）
        local_scope_var = "局部变量"
        
        # 访问嵌套局部作用域变量
        print(nested_scope_var)
        
        # 访问全局作用域变量
        print(global_scope_var)
        
        # 尝试访问内置作用域变量（例如len）
        print(len([1, 2, 3]))
        
        # 尝试访问不存在的变量会导致NameError
        # print(non_existent_var)  # NameError: name 'non_existent_var' is not defined
    
    inner_function()

outer_function()

在函数内部可以使用global关键字声明变量为全局的。但应避免在函数内部修改全局变量：最好通过参数传递变量到函数中，并在函数内部返回修改后的值。

面向对象编程

推荐阅读：Python面向对象编程：合集篇（类、对象、封装、继承和多态）

类和对象

• 类（Class）：类是创建对象的蓝图或模板，它定义了一组属性（变量）和方法（函数）。类描述了它所创建的对象的行为和状态。

• 对象（Object）：对象是类的实例。每个对象可以拥有不同的属性值，但共享相同的方法。

类是抽象的概念，而对象是具体的东西。在面向对象编程的世界中，一切皆为对象，对象都有属性和行为，每个对象都是独一无二的，而且对象一定属于某个类（型）。当我们把一大堆拥有共同特征的对象的静态特征（属性）和动态特征（行为）都抽取出来后，就可以定义出一个叫做“类”的东西。

例：创建了一个"动物"（Animal）类，然后创建该类的对象，比如"狗"（Dog）和"猫"（Cat）。

三大特性

封装

封装是将数据（属性）和操作数据的方法（行为）捆绑在一起的过程。封装还意味着隐藏对象的内部状态和实现细节，仅通过对象提供的接口进行交互。

可以将封装理解为"隐藏一切可以隐藏的实现细节，只向外界暴露（提供）简单的编程接口"。我们在类中定义的方法其实就是把数据和对数据的操作封装起来了，在我们创建了对象之后，只需要给对象发送一个消息（调用方法）就可以执行方法中的代码，也就是说我们只需要知道方法的名字和传入的参数（方法的外部视图），而不需要知道方法内部的实现细节（方法的内部视图）。

继承

继承是一种创建新类的技术，新类（子类或派生类）继承另一个类（父类或基类）的属性和方法。这支持代码重用，并允许创建基于现有类的特定版本。

多态

多态性是指允许不同类的对象对同一消息做出响应的能力，即同一个接口可以被不同对象以不同方式实现。这使得代码更加灵活和可扩展。

定义类

在Python中可以使用class关键字定义类，然后在类中通过之前学习过的函数来定义方法，这样就可以将对象的动态特征描述出来，代码如下所示。

class Student(object):

    # __init__是一个特殊方法用于在创建对象时进行初始化操作
    # 通过这个方法我们可以为学生对象绑定name和age两个属性
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def study(self, course_name):
        print('%s正在学习%s.' % (self.name, course_name))

    # PEP 8要求标识符的名字用全小写多个单词用下划线连接
    # 但是部分程序员和公司更倾向于使用驼峰命名法(驼峰标识)
    def watch_movie(self):
        if self.age < 18:
            print('%s只能观看《熊出没》.' % self.name)
        else:
            print('%s正在观看岛国爱情大电影.' % self.name)

说明： 写在类中的函数，我们通常称之为（对象的）方法，这些方法就是对象可以接收的消息。

创建和使用对象

当我们定义好一个类之后，可以通过下面的方式来创建对象并给对象发消息。

def main():
    # 创建学生对象并指定姓名和年龄
    stu1 = Student('骆昊', 38)
    # 给对象发study消息
    stu1.study('Python程序设计')
    # 给对象发watch_av消息
    stu1.watch_movie()
    stu2 = Student('王大锤', 15)
    stu2.study('思想品德')
    stu2.watch_movie()


if __name__ == '__main__':
    main()

继承

基本语法

在Python中，继承可以通过在类定义时指定父类来实现。

class ParentClass:
    pass

class ChildClass(ParentClass):
    pass

在这个例子中，ChildClass 继承了 ParentClass。

访问父类的属性和方法

子类可以访问父类的公有属性和方法，就像访问自己的一样。

class ParentClass:
    def __init__(self, value):
        self.value = value

class ChildClass(ParentClass):
    pass

obj = ChildClass(10)
print(obj.value)  # 输出：10

方法覆盖

子类可以覆盖父类的方法，提供特定的实现。

class ParentClass:
    def show(self):
        print("Parent show method")

class ChildClass(ParentClass):
    def show(self):
        print("Child show method")

obj = ChildClass()
obj.show()  # 输出：Child show method

使用 super() 调用父类方法

super() 函数用于在子类中调用父类的同名方法，这在覆盖方法时非常有用。

class ParentClass:
    def show(self):
        print("Parent show method")

class ChildClass(ParentClass):
    def show(self):
        super().show()  # 调用父类的show方法
        print("Child show method")

obj = ChildClass()
obj.show()
# 输出：
# Parent show method
# Child show method

多重继承

Python支持多重继承，即一个类可以有多个父类，使用逗号分隔这些父类。

class ParentClassA:
    def show_a(self):
        print("ParentClassA show method")

class ParentClassB:
    def show_b(self):
        print("ParentClassB show method")

class ChildClass(ParentClassA, ParentClassB):
    pass

obj = ChildClass()
obj.show_a()  # 输出：ParentClassA show method
obj.show_b()  # 输出：ParentClassB show method

面向对象编程的步骤

1. 识别对象：确定问题域中的对象，它们将作为类的基础。

2. 定义类和对象：为每个对象定义属性和方法。

3. 设计接口：确定对象如何与外部世界交互。

4. 实现继承和多态性：如果适用，通过继承和多态性提高代码的复用性和灵活性。

5. 封装数据：确保对象的数据只能通过对象的方法被访问和修改。

6. 测试和调试：创建对象并测试它们的行为，确保它们按照预期工作。

示例

# 定义一个类
class Dog:
    def __init__(self, name, age):  # 构造函数
        self.name = name  # 实例变量
        self.age = age

    def bark(self):  # 方法
        print("Woof!")

    def get_details(self):  # 方法
        return f"{self.name} is {self.age} years old."

# 创建对象
my_dog = Dog("Buddy", 3)

# 调用方法
my_dog.bark()
print(my_dog.get_details())

在这个例子中，Dog 是一个类，my_dog 是 Dog 类的一个实例。__init__ 方法是一个特殊的方法，用于类的初始化。self 代表类的实例，用于访问类的属性和方法。

_init_() 函数

要理解类的含义，我们必须先了解内置的 _init_() 函数。

所有类都有一个名为 _init_() 的函数，它始终在启动类时执行。

使用 _init_() 函数将值赋给对象属性，或者在创建对象时需要执行的其他操作。

self 参数

self 参数是对类的当前实例的引用，用于访问属于该类的变量。

它不必被命名为 self，可以随意调用它，但它必须是类中任意函数的首个参数。

# 使用单词 mysillyobject 和 abc 代替 self
class Person:
  def init(mysillyobject, name, age):
    mysillyobject.name = name
    mysillyobject.age = age

  def myfunc(abc):
    print("Hello my name is " + abc.name)

p1 = Person("John", 36)
p1.myfunc()

面向对象编程是一种强大的编程范式，它通过模拟现实世界中的对象和它们之间的关系来提高代码的组织性和可维护性。

模块

Python 模块是组织代码的一种方式，它允许你将函数、类和变量组织在不同的文件中，以保持代码的整洁和可管理性。模块也可以定义可被其他程序导入和使用的函数、类和变量。

创建模块

在Python中，一个模块就是一个.py文件。例如，如果你有一个名为mymodule.py的文件，那么mymodule就是一个模块。

导入模块

你可以使用import语句来导入模块，并使用模块中定义的功能。

import mymodule

使用模块中的组件

导入模块后，你可以使用点（.）表示法来访问模块中的属性。

# 导入模块
import mymodule

# 使用模块中的函数
mymodule.my_function()

# 使用模块中的变量
print(mymodule.MY_VARIABLE)

导入特定的组件

你也可以只导入模块中的特定组件，而不是整个模块。

# 从模块中导入特定的函数
from mymodule import my_function

# 直接使用导入的函数
my_function()

导入所有组件

你可以导入模块中的所有组件，但这不是推荐的做法，因为它可能会导致命名空间的冲突。

# 导入模块中的所有组件（不推荐）
from mymodule import *

别名

你可以给导入的模块或组件一个别名，以简化代码或避免命名冲突。

# 给模块一个别名
import mymodule as mm

# 使用别名访问模块中的函数
mm.my_function()

# 给导入的函数一个别名
from mymodule import my_function as mf

# 使用别名调用函数
mf()

dir() 函数

有一个内置函数可以列出模块中的所有函数名（或变量名）。dir() 函数:

# 列出属于 mymodule 模块的所有已定义名称
import mymodule

x = dir(mymodule)
print(x)

模块搜索路径

Python解释器会在特定的路径中搜索模块，这些路径包括：

• 当前目录

• 由环境变量PYTHONPATH定义的目录

• 安装Python时的内置库目录

包

Python还支持包的概念，包是包含多个模块的容器。包允许你创建模块层次结构。要创建一个包，你需要在目录中创建一个名为__init__.py的空文件。

mypackage/
    __init__.py
    module1.py
    module2.py

在包中，你可以组织相关的模块，并使用点（.）表示法来导入它们。

# 导入包中的模块
from mypackage import module1

# 使用模块中的函数
module1.my_function()

常用模块

日期时间

在Python中处理日期和时间，可以使用标准库中的datetime模块，它提供了日期和时间的操作和计算功能。

datetime模块

datetime模块包含了以下主要类：

• date：表示一个日期。

• time：表示一个时间。

• datetime：表示一个日期和时间。

• timedelta：表示两个日期或时间之间的差。

• tzinfo：表示时区信息。

获取当前日期和时间

from datetime import datetime

now = datetime.now()
print("当前日期和时间:", now)

创建日期和时间对象

from datetime import date, time, datetime, timedelta

# 创建日期对象
today = date(2024, 12, 16)
print("日期:", today)

# 创建时间对象
noon = time(12, 0)
print("时间:", noon)

# 创建日期时间对象
specific_datetime = datetime(2024, 12, 16, 12, 0)
print("日期时间:", specific_datetime)

计算日期和时间

from datetime import datetime, timedelta

# 获取当前时间
now = datetime.now()

# 计算10天后的时间
ten_days_later = now + timedelta(days=10)
print("10天后:", ten_days_later)

# 计算10天前的时间
ten_days_ago = now - timedelta(days=10)
print("10天前:", ten_days_ago)

格式化日期和时间

from datetime import datetime

now = datetime.now()

# 格式化日期时间
formatted_now = now.strftime("%Y-%m-%d %H:%M:%S")
print("格式化日期时间:", formatted_now)

strftime方法允许你指定日期时间的格式，其中%Y、%m、%d、%H、%M、%S分别代表年、月、日、小时、分钟和秒。

解析日期字符串

from datetime import datetime

date_string = "2024-12-16 12:00:00"
parsed_date = datetime.strptime(date_string, "%Y-%m-%d %H:%M:%S")
print("解析后的日期时间:", parsed_date)

strptime方法用于将字符串解析为datetime对象，你需要提供相应的格式字符串。

strftime() 方法

datetime 对象拥有把日期对象格式化为可读字符串的方法。

该方法称为 strftime()，并使用一个 format 参数来指定返回字符串的格式。

# 显示月份的名称
import datetime

x = datetime.datetime(2018, 6, 1)

print(x.strftime("%B"))

# June

所有合法格式代码的参考：

pytz模块

pytz是一个第三方库，用于处理时区。它不是Python标准库的一部分，但可以通过包管理工具如pip安装。

pip install pytz

使用pytz处理时区：

from datetime import datetime
import pytz

# 创建一个时区对象
utc = pytz.utc

# 创建一个带时区的日期时间对象
utc_now = datetime.now(utc)
print("UTC时间:", utc_now)

# 转换时区
eastern = pytz.timezone('US/Eastern')
eastern_now = utc_now.astimezone(eastern)
print("东部时间:", eastern_now)

数学运算

Python的math模块提供了许多用于执行数学运算的函数和常量。

数学函数

• round(x)：将x四舍五入到最接近的整数。

• abs(x)：计算x的绝对值。

• max(x, y)和min(x, y)：计算x和y中的最大值和最小值。

• pow(x, y) 函数返回 x 的 y 次方 (x ^y)。

result_round = round(3.6)
result_abs = abs(-10)
result_max = max(3, 7)
result_min = min(3, 7)
result_pow = pow(4, 3)

math模块

math模块提供了许多额外的数学函数：

• math.sqrt(x)：计算x的平方根。

• math.pow(x, y)：计算x的y次幂。

• math.log(x)：计算x的自然对数。

• math.log10(x)：计算x的以10为底的对数。

• math.sin(x)、math.cos(x)、math.tan(x)：计算x的正弦、余弦和正切值。

• math.asin(x)、math.acos(x)、math.atan(x)：计算x的反正弦、反余弦和反正切值。

• math.pi：圆周率π的值。

• math.e：自然对数的底数e的值。

import math

result_sqrt = math.sqrt(16)
result_pow = math.pow(2, 3)
result_log = math.log(math.e)
result_log10 = math.log10(100)
result_sin = math.sin(math.pi / 2)
result_cos = math.cos(0)
result_tan = math.tan(0)

随机数生成

random模块提供了生成随机数的函数：

• random.random()：生成一个0到1之间的随机浮点数。

• random.randint(a, b)：生成一个a和b之间（包括a和b）的随机整数。

• random.uniform(a, b)：生成一个a和b之间的随机浮点数。

import random

result_random = random.random()
result_randint = random.randint(1, 10)
result_uniform = random.uniform(1.5, 4.5)

JSON

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。Python提供了内置的json模块，可以用来处理JSON数据。

将Python对象转换成JSON字符串

使用json.dumps()函数可以将Python对象（如字典、列表等）转换成JSON格式的字符串。

import json

data = {
    'name': 'John',
    'age': 30,
    'city': 'New York'
}

json_str = json.dumps(data)
print(json_str)  # 输出：{"name": "John", "age": 30, "city": "New York"}

将JSON字符串转换成Python对象

使用json.loads()函数可以将JSON格式的字符串转换成Python对象。

json_str = '{"name": "John", "age": 30, "city": "New York"}'
data = json.loads(json_str)
print(data)  # 输出：{'name': 'John', 'age': 30, 'city': 'New York'}
              # 结果是一个 Python 字典

读取和写入JSON文件

使用json.dump()函数可以将Python对象直接写入文件，而json.load()函数可以从文件中读取JSON数据，并转换成Python对象。

# 写入JSON到文件
with open('data.json', 'w') as f:
    json.dump(data, f)

# 从文件读取JSON
with open('data.json', 'r') as f:
    data = json.load(f)
    print(data)  # 输出：{'name': 'John', 'age': 30, 'city': 'New York'}

当 Python 转换为 JSON 时，Python 对象会被转换为 JSON（JavaScript）等效项:

美化输出

json.dumps()函数提供了一些参数来美化输出，例如indent用于美化缩进，sort_keys用于按键排序，使用 separators 来更改默认分隔符。

json_str_pretty = json.dumps(data, indent=4, sort_keys=True, separators=(". ", " = "))
print(json_str_pretty)

处理复杂的数据类型

json模块默认支持基本的数据类型（如字典、列表、字符串、整型、浮点型、布尔型和None）。对于其他类型（如日期时间），需要自定义序列化和反序列化的函数。

from datetime import datetime

# 序列化函数
def json_serial(obj):
    if isinstance(obj, datetime):
        return obj.isoformat()
    raise TypeError("Type not serializable")

# 反序列化函数
def json_deserial(json_str):
    json_str = json_str.replace('"', '')
    return datetime.strptime(json_str, '%Y-%m-%dT%H:%M:%S')

data_with_datetime = {
    'name': 'John',
    'created_at': datetime.now()
}

json_str = json.dumps(data_with_datetime, default=json_serial)
print(json_str)

data = json.loads(json_str, object_hook=json_deserial)
print(data)

正则表达式

Python的正则表达式是通过re模块提供的，它是一个强大的工具，用于匹配字符串中的模式。

基本函数

re.match()：从字符串的开始位置匹配模式，如果匹配成功，返回一个匹配对象；否则返回None。

import re

match = re.match(r'^\d{3}', '123-456-7890')
if match:
    print(match.group())  # 输出：123

re.search()：扫描整个字符串，返回第一个成功的匹配。

search = re.search(r'\d{3}', 'abc-123-def')
if search:
    print(search.group())  # 输出：123

re.findall()：找出字符串中所有匹配的模式。

matches = re.findall(r'\d{3}', '123-456-7890')
print(matches)  # 输出：['123', '456', '789']

re.finditer()：返回一个迭代器，该迭代器产生一个Match对象。

for match in re.finditer(r'\d{3}', '123-456-7890'):
    print(match.group())  # 输出：123, 456, 789

re.sub()：替换字符串中的匹配项。

new_str = re.sub(r'\d{3}', 'XXX', '123-456-7890')
print(new_str)  # 输出：XXX-XXX-XXX

re.split()：根据匹配的模式分割字符串。

parts = re.split(r'-', '123-456-7890')
print(parts)  # 输出：['123', '456', '7890']

元字符

元字符是具有特殊含义的字符:

特殊序列

特殊序列指的是 \ 后跟下表中的某个字符，拥有特殊含义:

集合（Set）

集合（Set）是一对方括号 [] 内的一组字符，具有特殊含义:

Match 对象

Match 对象是包含有关搜索和结果信息的对象。

注释: 如果没有匹配，则返回值 None，而不是 Match 对象。

实例

执行会返回 Match 对象的搜索

import re

txt = "The rain in Spain"
x = re.search("ai", txt)
print(x) #this will print an object

Match 对象提供了用于取回有关搜索及结果信息的属性和方法:

.span() 返回的元组包含了匹配的开始和结束位置
.string 返回传入函数的字符串
.group() 返回匹配的字符串部分

实例

打印首个匹配出现的位置（开始和结束位置）。

import re

txt = "The rain in Spain"
x = re.search(r"\bS\w+", txt)

# 打印首个匹配出现的位置（开始和结束位置）。正则表达式查找以大写 "S" 开头的任何单词
print(x.span()) # (12, 17)

# 打印传入函数的字符串
print(x.string) # The rain in Spain

# 打印匹配的字符串部分。正则表达式查找以大写 "S" 开头的任何单词
print(x.group()) # Spain

编译正则表达式

使用re.compile()可以编译一个正则表达式模式，之后可以使用编译后的模式对象进行匹配。

pattern = re.compile(r'\d{3}')
match = pattern.match('123-456-7890')
if match:
    print(match.group())  # 输出：123

PIP

pip（Python包管理器）是一个用于安装和管理Python包的工具。它允许你从Python包索引（PyPI）安装和管理软件包。

检查是否已安装 PIP

将命令行导航到 Python 脚本目录所在的位置，然后键入pip --version检查 PIP 版本

例：

C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\Scripts>pip --version

安装pip

大多数Python安装都会自带pip。如果你的Python环境中没有pip，你可以通过以下方式安装：

• 在Linux上：

  sudo apt-get install python3-pip  # 对于Debian/Ubuntu系统
  sudo yum install python3-pip      # 对于RedHat/CentOS系统

• 在macOS上：

  easy_install pip  # 或者使用Homebrew: brew install pip

• 在Windows上：

通常Python for Windows安装器会包含pip。如果没有，你可以从PyPI官网下载get-pip.py脚本来安装。

更新pip

为了确保pip是最新版本，你可以使用以下命令更新它：

pip install --upgrade pip

安装包

使用pip安装包非常简单。以下是一些常用的安装命令：

# 安装一个包
pip install package_name

# 安装指定版本的包
pip install package_name==package_version

# 安装多个包
pip install package1 package2 package3

# 安装包的依赖
pip install package_name[extras]

列出包

列出已安装的包：

pip list

卸载包

卸载一个已安装的包：

pip uninstall package_name

查找包

查找包的信息：

pip search package_name

检查包

检查包是否可以升级：

pip check

查看包信息

查看已安装包的信息：

pip show package_name

导出已安装包列表

导出已安装包的列表到requirements.txt文件：

pip freeze > requirements.txt

从requirements.txt安装包

从requirements.txt文件安装包：

pip install -r requirements.txt

使用虚拟环境

使用pip时，推荐在虚拟环境中安装包，以避免污染全局Python环境。你可以使用venv（Python 3.3+）或virtualenv来创建虚拟环境：

# 创建虚拟环境
python -m venv myenv

# 激活虚拟环境
# 在Windows上
myenv\Scripts\activate
# 在Unix或macOS上
source myenv/bin/activate

# 然后在虚拟环境中安装包
pip install package_name

异常处理

在Python中，异常处理是一种结构，它允许程序在发生错误时捕获并处理异常，而不是让程序崩溃。异常处理的关键语句包括try、except、else和finally。

try

try块包含了可能触发异常的代码。

except

except块指定了如何处理特定类型的异常。

else

else块中的代码只有在try块没有发生任何异常时才会执行。

finally

finally块中的代码无论是否发生异常都会执行，通常用于清理资源。

基本的异常处理结构

try:
    # 尝试执行的代码
    result = 10 / 0
except ZeroDivisionError:
    # 如果发生了ZeroDivisionError异常，执行这个块
    print("除数不能为0！")
else:
    # 如果没有异常发生，执行这个块
    print("没有发生异常，结果是：", result)
finally:
    # 无论是否有异常发生，都会执行这个块
    print("这是finally块，总会被执行。")

捕获多个异常

你可以在单个except语句中捕获多个异常。

try:
    # 可能触发不同类型的异常
    value = int(input("请输入一个数字："))
    result = 10 / value
except (ZeroDivisionError, ValueError) as e:
    print(f"发生了异常：{e}")

捕获所有异常

你可以捕获所有异常，但这通常不推荐，因为它可能会隐藏真正的程序错误。

try:
    # 可能触发任何类型的异常
    result = 1 / 0
except Exception as e:
    print(f"异常：{e}")

引发异常

你可以使用raise关键字来引发一个异常。

age = 17
if age < 18:
    raise ValueError("未成年")

自定义异常

你可以定义自己的异常类型。

class MyError(Exception):
    pass

try:
    raise MyError("我的自定义错误")
except MyError as e:
    print(f"捕获到自定义异常：{e}")

异常链

在Python 3中，你可以在raise一个异常时附加另一个异常，这称为异常链。

try:
    raise ValueError("错误的值")
except ValueError as e:
    raise RuntimeError("运行时错误") from e

文件操作

文件读写三步骤：

• 第⼀步，打开⽂件

• 第⼆步，读（写）⽂件

• 第三步，关闭⽂件

文件处理

在 Python 中使用文件的关键函数是 open() 函数。

open() 函数有两个参数:文件名和模式。

有四种打开文件的不同方法（模式）:

• "r" - 读取 - 默认值。打开文件进行读取，如果文件不存在则报错。

• "a" - 追加 - 打开供追加的文件，如果不存在则创建该文件。

• "w" - 写入 - 打开文件进行写入，如果文件不存在则创建该文件。

• "x" - 创建 - 创建指定的文件，如果文件存在则返回错误。

此外，您可以指定文件是应该作为二进制还是文本模式进行处理。

• "t" - 文本 - 默认值。文本模式。

• "b" - 二进制 - 二进制模式（例如图像）。

打开文件

• open(file, mode, encoding)

#打开⽂件

f = open('/letter.txt', 'r', 1 encoding = 'UTF-8')

• wit h open() as…

#使⽤这种⽅式打开⽂件，可以不使⽤close()关闭⽂件

with open('/letter.txt', 'r', encoding = 'UTF-8') as f:

使用open()函数打开文件，它返回一个文件对象。

# 打开文件用于读取，默认模式为'r'
with open('file.txt', 'r') as file:
    content = file.read()
    print(content)

写入文件

读写模式mode：

| 模式mode | 操作           | 若不存在   | 是否覆盖       |
|----------|----------------|------------|----------------|
| r        | 只能读不能写   | 报错       | -              |
| rb       | 二进制只读     | 报错       | -              |
| r+       | 可读可写       | 报错       | 是             |
| rb+      | 二进制读写     | 报错       | 是             |
| w        | 只能写不能读   | 创建文件   | 是             |
| wb       | 二进制只写     | 创建文件   | 是             |
| w+       | 可读可写       | 创建文件   | 是             |
| wb+      | 二进制读写     | 创建文件   | 是             |
| a        | 追加不能读     | 创建文件   | 否,追加写      |
| ab       | 二进制追加不能读 | 创建文件 | 否,追加写      |
| a+       | 可读可写       | 创建文件   | 否,追加写      |
| ab+      | 二进制追加可读可写 | 创建文件 | 否,追加写      |

写入

使用'w'模式打开文件进行写入。如果文件已存在，'w'模式会覆盖原有文件。

with open('file.txt', 'w') as file:
    file.write("Hello, World!")

追加文件

使用'a'模式打开文件进行追加。如果文件已存在，'a'模式会在文件末尾追加内容。

with open('file.txt', 'a') as file:
    file.write("\nThis is new line.")

文件读取

读取文件行

使用readlines()方法可以一次性读取文件的所有行，并返回一个列表。

with open('file.txt', 'r') as file:
    lines = file.readlines()
    for line in lines:
        print(line.strip())  # 使用strip()去除行尾的换行符

逐行读取文件

使用for循环可以逐行读取文件内容。

with open('file.txt', 'r') as file:
    for line in file:
        print(line.strip())

文件指针

文件指针默认指向文件的开头。读取文件后，文件指针会移动到读取的位置。可以使用seek()方法移动文件指针。

with open('file.txt', 'r') as file:
    file.seek(0)  # 移动到文件开头
    content = file.read()
    print(content)

文件的当前位置

使用tell()方法可以获取文件的当前位置。

with open('file.txt', 'r') as file:
    print(file.tell())  # 输出：0
    file.read(10)
    print(file.tell())  # 输出：10（假设文件内容超过10个字符）

二进制文件操作

使用'rb'和'wb'模式可以处理二进制文件。

# 以二进制写入模式打开文件
with open('image.png', 'wb') as file:
    file.write(b'\x89PNG\r\n\x1a\n')

# 以二进制读取模式打开文件
with open('image.png', 'rb') as file:
    content = file.read()

删除文件

如需删除文件，必须导入 OS 模块，并运行其 os.remove() 函数:

# 删除文件 "demofile.txt"
import os
os.remove("demofile.txt")

检查文件是否存在

为避免出现错误，可能需要在尝试删除文件之前检查该文件是否存在

# 检查文件是否存在，然后删除它
import os
if os.path.exists("demofile.txt"):
  os.remove("demofile.txt")
else:
  print("The file does not exist")

删除文件夹

如需删除整个文件夹，请使用 os.rmdir() 方法

# 删除文件夹 "myfolder"
import os
os.rmdir("myfolder")

注释: 只能删除空文件夹。