Python语法概述

🚢Python知识点回顾

Date : 2023/12.11

Editor : 阮扬

🛥️数据类型

Python中有多种内置的数据类型，常用的包括：

1. 整数（int）：表示整数值，例如：x = 10

2. 浮点数（float）：表示带有小数部分的数值，例如：y = 3.14

3. 字符串（str）：表示文本数据，由一系列字符组成，可以使用单引号或双引号括起来，例如：name = "Alice"

4. 列表（list）：表示一组有序的元素集合，元素之间用逗号分隔，用方括号括起来，例如：numbers = [1, 2, 3, 4, 5]

5. 元组（tuple）：类似于列表，但是元组的元素不能修改，用圆括号括起来，例如：point = (2, 3)

6. 字典（dict）：表示键值对的集合，每个键值对之间用逗号分隔，用花括号括起来，例如：person = {"name": "Alice", "age": 25}

7. 集合（set）：表示一组唯一的元素集合，元素之间无序且不重复，用花括号括起来，例如：fruits = {"apple", "banana", "orange"}

8. 布尔值（bool）：表示真（True）或假（False）的值，用于逻辑判断和条件控制，例如：is_valid = True

除了上述基本数据类型，Python还提供了其他一些常用的数据类型，如：

• 字节串（bytes）：表示二进制数据，例如：data = b'\x00\x01\x02'

• 字节数组（bytearray）：类似于字节串，但是可变的，可以修改其中的元素

• 零碎数据类型：如空值（None）、复数（complex）、日期时间（datetime）等

此外，Python还支持动态类型，即变量的类型在运行时可以根据赋值自动推断，可以根据需要在不同的数据类型之间进行转换。

🛥️缩进

在Python中，缩进是一种表示代码块的方式，它在控制流语句（如条件语句和循环语句）以及函数和类定义中起着关键的作用。Python使用缩进来标识代码块的开始和结束，而不是使用大括号或关键字。

在Python中，通常使用四个空格作为缩进的标准，这是Python官方推荐的做法。每个缩进级别都是四个空格的倍数。例如：

if condition:
    statement1
    statement2
    # 这些语句属于 if 代码块，因为它们都缩进了四个空格

for item in iterable:
    statement3
    statement4
    # 这些语句属于 for 循环代码块，因为它们都缩进了四个空格

def my_function():
    statement5
    statement6
    # 这些语句属于 my_function 函数体，因为它们都缩进了四个空格

请注意，Python对于缩进的要求非常严格。在同一个代码块中，所有语句必须具有相同的缩进级别，通常是四个空格。如果缩进不一致，将会引发缩进错误（IndentationError）。

另外，Python还使用冒号（:）来标识代码块的开始。冒号后面的下一行必须进行缩进，以表示该代码块的内容。

if condition:
    # 这是 if 代码块的开始
    statement1
    statement2
    # 这些语句属于 if 代码块
    # 这是 if 代码块的结束
else:
    # 这是 else 代码块的开始
    statement3
    statement4
    # 这些语句属于 else 代码块
    # 这是 else 代码块的结束

在上述示例中，if 和 else 后面的冒号表示代码块的开始，而缩进则表示代码块的内容。根据条件的结果，程序将执行相应的代码块。

总的来说，Python中的缩进是一种用于表示代码块的方式，它使用四个空格作为标准缩进级别。缩进在控制流语句、函数和类定义中起着关键的作用。正确的缩进是保证代码结构清晰、可读性强的重要因素。

🛥️运算符号

Python中有多种运算符号，用于执行各种数学和逻辑运算。以下是一些常见的运算符号：

1. 算术运算符：

   • +：加法运算符，用于两个数相加。
   • -：减法运算符，用于两个数相减。
   • *：乘法运算符，用于两个数相乘。
   • /：除法运算符，用于两个数相除。
   • %：取模运算符，返回两个数相除的余数。
   • **：幂运算符，用于计算一个数的指数幂。
   • //：整除运算符，返回两个数相除的整数部分。

2. 比较运算符：

   • ==：等于运算符，用于判断两个数是否相等。
   • !=：不等于运算符，用于判断两个数是否不相等。
   • >：大于运算符，用于判断一个数是否大于另一个数。
   • <：小于运算符，用于判断一个数是否小于另一个数。
   • >=：大于等于运算符，用于判断一个数是否大于等于另一个数。
   • <=：小于等于运算符，用于判断一个数是否小于等于另一个数。

3. 逻辑运算符：

   • and：逻辑与运算符，用于判断多个条件是否同时成立。
   • or：逻辑或运算符，用于判断多个条件是否至少有一个成立。
   • not：逻辑非运算符，用于对条件取反。

4. 赋值运算符：

   • =：赋值运算符，用于将一个值赋给一个变量。
   • +=：加法赋值运算符，将右侧的值加到左侧的变量上，并将结果赋给左侧的变量。
   • -=、*=、/=、%=、**=、//=：类似地，还有减法赋值、乘法赋值、除法赋值、取模赋值、幂赋值和整除赋值运算符。

5. 位运算符：

   • &：按位与运算符，对两个数的每个位执行与操作。
   • |：按位或运算符，对两个数的每个位执行或操作。
   • ^：按位异或运算符，对两个数的每个位执行异或操作。
   • ~：按位取反运算符，对一个数的每个位执行取反操作。
   • <<：左移运算符，将一个数的二进制表示向左移动指定的位数。
   • >>：右移运算符，将一个数的二进制表示向右移动指定的位数。

6. 成员运算符：

   • in：用于判断一个值是否存在于一个容器（如列表、元组、集合、字典）中。
   • not in：用于判断一个值是否不存在于一个容器中。

7. 身份运算符：

   • is：用于判断两个对象是否是同一个对象。
   • is not：用于判断两个对象是否不是同一个对象。

这只是一些常见的运算符号，Python还提供了其他一些运算符号和特殊的运算符号，如三元条件运算符（a if condition else b）、索引运算符（[]）、切片运算符（[:]）等。

注意：不同的运算符具有不同的优先级和结合性，可以使用括号来改变运算的顺序。在复杂的表达式中，正确使用括号可以避免歧义并确保运算的顺序符合预期。

🚤成员运算符

成员运算符用于判断一个值是否存在于一个容器（如列表、元组、集合、字典）中。Python提供了两个成员运算符：

1. in 运算符：用于判断一个值是否存在于容器中。如果值存在于容器中，返回 True；否则返回 False。

2. not in 运算符：用于判断一个值是否不存在于容器中。如果值不存在于容器中，返回 True；否则返回 False。

# 列表示例
fruits = ['apple', 'banana', 'orange']
print('apple' in fruits)  # True，'apple' 存在于 fruits 列表中
print('grape' in fruits)  # False，'grape' 不存在于 fruits 列表中

# 元组示例
numbers = (1, 2, 3, 4, 5)
print(3 in numbers)  # True，3 存在于 numbers 元组中
print(6 in numbers)  # False，6 不存在于 numbers 元组中

# 集合示例
colors = {'red', 'green', 'blue'}
print('red' in colors)  # True，'red' 存在于 colors 集合中
print('yellow' in colors)  # False，'yellow' 不存在于 colors 集合中

# 字典示例
student = {'name': 'Alice', 'age': 20, 'grade': 'A'}
print('name' in student)  # True，'name' 是 student 字典的一个键
print('score' in student)  # False，'score' 不是 student 字典的一个键

注意:成员运算符适用于各种容器类型，包括列表、元组、集合和字典。在字典中，成员运算符判断的是键是否存在于字典中。

🚤身份运算符

身份运算符用于比较两个对象的内存地址，判断它们是否引用同一个对象。Python提供了两个身份运算符：

1. is 运算符：用于判断两个对象是否是同一个对象。如果两个对象具有相同的内存地址，返回 True；否则返回 False。

2. is not 运算符：用于判断两个对象是否不是同一个对象。如果两个对象具有不同的内存地址，返回 True；否则返回 False。

x = [1, 2, 3]
y = x  # y 引用了 x 所引用的对象

print(x is y)  # True，x 和 y 引用同一个对象
print(x is not y)  # False，x 和 y 引用同一个对象

z = [1, 2, 3]

print(x is z)  # False，x 和 z 引用不同的对象
print(x is not z)  # True，x 和 z 引用不同的对象

• 身份运算符比较的是对象的内存地址，而不是对象的值。即使两个对象的值相同，但如果它们的内存地址不同，身份运算符仍然会返回 False。

• 身份运算符在判断两个对象是否相等时非常有用。在某些情况下，我们可能需要判断两个变量是否引用同一个对象，而不仅仅是比较它们的值。例如，在函数调用中传递可变对象时，判断是否修改了原始对象可以使用身份运算符。

🛥️输入函数

在Python中，可以使用内置的 input() 函数从用户那里获取输入。input() 函数会等待用户输入，并将用户输入的内容作为字符串返回。

name = input("请输入您的姓名：")
print("您好，" + name + "！")

age = input("请输入您的年龄：")
print("您的年龄是：" + age)

在上面的示例中，input() 函数用于获取用户输入。函数的参数是一个字符串，作为提示信息显示给用户。用户输入的内容被返回并赋值给相应的变量。然后，可以使用这些变量进行后续的操作。

需要注意的是，input() 函数返回的是一个字符串。如果需要将输入解释为其他类型（如整数、浮点数等），需要进行相应的类型转换。例如，可以使用 int() 函数将输入转换为整数：

age = int(input("请输入您的年龄："))

在这种情况下，用户输入的内容将被解释为整数，并赋值给 age 变量。

注意:input() 函数会将用户输入的内容作为字符串返回，因此需要根据需要进行适当的类型转换。

🛥️range函数

range() 函数是Python中的一个内置函数，用于生成一个整数序列。它可以接受一个或多个参数，用于指定生成序列的起始值、结束值和步长。

range() 函数的基本语法如下：

range(start, stop, step)

参数说明：

• start（可选）：序列的起始值，默认为0。
• stop：序列的结束值，生成的序列不包含该值。
• step（可选）：序列中相邻两个值的差，默认为1。

# 生成一个从0到4的整数序列
for i in range(5):
    print(i)

# 生成一个从2到8的整数序列，步长为2
for i in range(2, 10, 2):
    print(i)

# 生成一个从10到1的整数序列，步长为-1
for i in range(10, 0, -1):
    print(i)

在上面的示例中，range() 函数用于生成整数序列，并通过 for 循环遍历序列中的每个值。可以根据需要指定起始值、结束值和步长来生成不同的序列。

注意：range() 函数生成的是一个可迭代对象，而不是一个实际的列表。如果需要将其转换为列表，可以使用 list() 函数进行转换，例如：list(range(5))。

🛥️条件判断语句

在Python中，条件判断语句用于根据条件的真假来执行不同的代码块。Python提供了 if、elif（可选）和 else（可选）关键字来构建条件判断语句。

条件判断语句的基本语法如下：

if condition1:
    # 当 condition1 为真时执行的代码块
elif condition2:
    # 当 condition1 为假，且 condition2 为真时执行的代码块
else:
    # 当 condition1 和 condition2 都为假时执行的代码块

其中，if 后面的 condition1 是一个条件表达式，用于判断条件是否为真。如果 condition1 为真，则执行紧接着的代码块。如果 condition1 为假，则继续判断下一个条件。可以使用 elif 关键字添加额外的条件，可以有多个 elif 条件。最后，可以使用 else 关键字指定当所有条件都为假时执行的代码块。

下面是一个简单的示例，演示了如何使用条件判断语句：

x = 10

if x > 0:
    print("x 是正数")
elif x < 0:
    print("x 是负数")
else:
    print("x 是零")

在上面的示例中，根据变量 x 的值，通过条件判断语句判断 x 是正数、负数还是零，并打印相应的结果。

注意：条件表达式的结果应该是一个布尔值（True 或 False）。可以使用比较运算符（如 <、>、== 等）和逻辑运算符（如 and、or、not）来构建条件表达式。

此外，条件判断语句还可以嵌套使用，即在一个条件块中包含另一个条件块。这样可以根据不同的条件组合来执行不同的代码块。

🛥️while循环语句

在Python中，while 循环语句用于重复执行一段代码块，直到给定的条件不再满足。它的基本语法如下：

while condition:
    # 循环体代码块

condition 是一个条件表达式，用于判断循环是否继续执行。只要 condition 的值为真，循环体中的代码就会被执行。当 condition 的值为假时，循环终止，程序将继续执行循环后面的代码。

以下是一个简单的示例，演示了如何使用 while 循环：

count = 0
while count < 5:
    print(count)
    count += 1

在上面的示例中，count 的初始值为0。while 循环的条件是 count < 5，只要 count 的值小于5，循环体中的代码就会被执行。在每次循环迭代时，会打印 count 的值，并将 count 的值递增1。当 count 的值达到5时，循环终止。

需要注意的是，如果条件始终为真，循环将变成无限循环，可能导致程序陷入死循环。为了避免这种情况，应确保在循环体中的代码执行过程中，能够改变循环条件的值，使其最终为假，从而终止循环。

在循环中，还可以使用 break 语句提前终止循环，或使用 continue 语句跳过当前迭代，直接进入下一次循环迭代。

🛥️for循环语句

在Python中，for 循环语句用于遍历可迭代对象（如列表、元组、字符串等）的元素，执行相应的代码块。它的基本语法如下：

for item in iterable:
    # 循环体代码块

item 是一个变量，用于依次存储可迭代对象中的元素。iterable 是一个可迭代对象，可以是列表、元组、字符串等。

for 循环会依次将 iterable 中的每个元素赋值给 item，然后执行循环体中的代码块。当所有元素都被遍历完毕后，循环终止，程序将继续执行循环后面的代码。

以下是一个简单的示例，演示了如何使用 for 循环：

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

在上面的示例中，fruits 是一个列表，for 循环会依次将列表中的每个元素赋值给 fruit，然后打印出来。

除了列表，for 循环还可以用于遍历其他可迭代对象，比如字符串：

for char in "Hello":
    print(char)

上述代码将逐个打印字符串中的字符。

注意：range() 函数常用于生成一系列连续的整数，可以和 for 循环结合使用，如下所示：

for i in range(5):
    print(i)

上述代码将打印出 0 到 4 的整数。

🛥️序列

在Python中，序列是一种数据类型，用于存储一系列有序的元素。常见的序列类型包括列表（list）、字符串（str）、元组（tuple）等。序列具有以下特点：

1. 有序性：序列中的元素按照特定的顺序排列，可以通过索引访问和操作元素。

2. 可迭代性：序列可以被迭代，即可以使用循环遍历序列中的每个元素。

3. 可变性：某些序列类型是可变的，即可以修改序列中的元素；而另一些序列类型是不可变的，元素不可修改。

下面是几种常见的序列类型及其特点：

1. 列表（list）：列表是可变的序列，用方括号[]表示。列表可以包含不同类型的元素，并且可以动态地添加、删除和修改元素。

2. 字符串（str）：字符串是不可变的序列，用引号（单引号或双引号）括起来表示。字符串是一系列字符的有序集合，可以通过索引访问和切片操作。

3. 元组（tuple）：元组是不可变的序列，用圆括号()表示。元组可以包含不同类型的元素，一旦创建后就不能修改。

除了这些常见的序列类型，还有其他一些序列类型，如字节串（bytes）、字节数组（bytearray）、范围（range）等。

序列类型在Python中提供了许多常用的方法，用于对序列进行操作和处理。常见的序列方法：

1. len(): 返回序列的长度（元素个数）。

   my_list = [1, 2, 3, 4, 5]
   length = len(my_list)  # 返回5
   

2. index(): 返回指定元素在序列中首次出现的索引。

   my_string = "Hello, World!"
   index = my_string.index("o")  # 返回4
   

3. count(): 返回指定元素在序列中出现的次数。

   my_list = [1, 2, 2, 3, 2, 4, 2, 5]
   count = my_list.count(2)  # 返回4
   

4. append(): 在列表的末尾添加一个元素。

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

5. extend(): 将一个序列的元素添加到列表的末尾。

   my_list = [1, 2, 3]
   my_list.extend([4, 5])  # [1, 2, 3, 4, 5]
   

6. insert(): 在指定索引位置插入一个元素。

   my_list = [1, 2, 3]
   my_list.insert(1, 4)  # [1, 4, 2, 3]
   

7. remove(): 移除列表中首次出现的指定元素。

   my_list = [1, 2, 3, 2, 4]
   my_list.remove(2)  # [1, 3, 2, 4]
   

8. pop(): 移除并返回指定索引位置的元素。

   my_list = [1, 2, 3, 4, 5]
   popped_element = my_list.pop(2)  # 返回3，my_list变为[1, 2, 4, 5]
   

9. reverse(): 反转列表中的元素顺序。

   my_list = [1, 2, 3, 4, 5]
   my_list.reverse()  # [5, 4, 3, 2, 1]
   

10. join(): 将序列中的元素以指定的分隔符连接成一个字符串。

    my_list = ['Hello', 'World', '!']
    my_string = ' '.join(my_list)  # 'Hello World !'
    

这些是序列类型常用的方法，每种序列类型可能会有一些特定的方法。你可以根据具体需求选择合适的方法来操作和处理序列。

🛥️元组

在Python中，for 循环语句用于遍历可迭代对象（如列表、元组、字符串等）的元素，执行相应的代码块。它的基本语法如下：

for item in iterable:
    # 循环体代码块

item 是一个变量，用于依次存储可迭代对象中的元素。iterable 是一个可迭代对象，可以是列表、元组、字符串等。

for 循环会依次将 iterable 中的每个元素赋值给 item，然后执行循环体中的代码块。当所有元素都被遍历完毕后，循环终止，程序将继续执行循环后面的代码。

以下是一个简单的示例，演示了如何使用 for 循环：

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

在上面的示例中，fruits 是一个列表，for 循环会依次将列表中的每个元素赋值给 fruit，然后打印出来。

除了列表，for 循环还可以用于遍历其他可迭代对象，比如字符串：

for char in "Hello":
    print(char)

上述代码将逐个打印字符串中的字符。

需要注意的是，range() 函数常用于生成一系列连续的整数，可以和 for 循环结合使用，如下所示：

for i in range(5):
    print(i)

上述代码将打印出 0 到 4 的整数。

🛥️字典

字典（Dictionary）是Python中的一种无序、可变的数据结构，用于存储键值对（key-value）的集合。字典使用大括号 {} 来创建，键值对之间用冒号 : 分隔，键值对之间用逗号 , 分隔。

字典中的键必须是唯一的，而值可以是任意类型的对象。可以通过键来访问对应的值，这使得字典成为一种非常灵活和高效的数据结构。

以下是一些关于字典的重要特性和操作：

1. 创建字典：

my_dict = {"name": "John", "age": 30, "city": "New York"}  # 创建一个包含三个键值对的字典

2. 访问字典中的值：

print(my_dict["name"])  # 输出 'John'
print(my_dict.get("age"))  # 输出 30

3. 修改字典中的值：

my_dict["age"] = 31  # 修改键为 'age' 的值为 31

4. 添加新的键值对：

my_dict["gender"] = "Male"  # 添加一个新的键值对 'gender': 'Male'

5. 删除键值对：

del my_dict["city"]  # 删除键为 'city' 的键值对

6. 检查键是否存在：

if "name" in my_dict:
    print("Key 'name' exists in the dictionary.")

7. 遍历字典：

for key in my_dict:
    value = my_dict[key]
    print(key, value)

字典提供了一种方便的方式来存储和访问数据，尤其适用于需要根据键来查找和操作值的情况。

🛥️集合

集合（Set）是Python中的一种无序、不重复的数据结构，用于存储唯一的元素。集合使用大括号 {} 或 set() 函数进行创建，元素之间用逗号分隔。

以下是一些关于集合的重要特性和操作：

1. 创建集合：

my_set = {1, 2, 3}  # 创建一个包含三个整数的集合
my_set = {"apple", "banana", "cherry"}  # 创建一个包含三个字符串的集合
my_set = set([1, 2, 3])  # 使用set()函数创建集合

2. 添加元素：

my_set.add(4)  # 向集合中添加元素4

3. 移除元素：

my_set.remove(2)  # 从集合中移除元素2，如果元素不存在会引发KeyError异常
my_set.discard(3)  # 从集合中移除元素3，如果元素不存在不会引发异常

4. 集合操作：

• 并集：使用 union() 方法或 | 运算符
• 交集：使用 intersection() 方法或 & 运算符
• 差集：使用 difference() 方法或 - 运算符
• 对称差集：使用 symmetric_difference() 方法或 ^ 运算符

set1 = {1, 2, 3}
set2 = {3, 4, 5}

union_set = set1.union(set2)  # 并集
intersection_set = set1.intersection(set2)  # 交集
difference_set = set1.difference(set2)  # 差集
symmetric_difference_set = set1.symmetric_difference(set2)  # 对称差集

5. 判断元素是否存在：

if 3 in my_set:
    print("3 exists in the set")

集合是一种非常有用的数据结构，它提供了高效的元素查找和去重功能。

🛥️字符串

字符串（String）是由字符组成的不可变序列，可以使用引号（单引号或双引号）括起来表示。在Python中，字符串是一种常见的数据类型，用于表示文本数据。

以下是一些关于字符串的重要特性和操作：

1. 创建字符串：

my_string = "Hello, World!"  # 使用双引号创建字符串
my_string = 'Hello, World!'  # 使用单引号创建字符串

2. 访问字符串中的字符：

print(my_string[0])  # 输出 'H'，通过索引访问字符串的字符
print(my_string[7:12])  # 输出 'World'，使用切片操作获取子字符串

3. 字符串的拼接：

string1 = "Hello"
string2 = "World"
concatenated_string = string1 + ", " + string2  # 使用加号拼接字符串

4. 字符串的格式化：

name = "Alice"
age = 25
formatted_string = "My name is {} and I'm {} years old.".format(name, age)  # 使用format()方法进行字符串格式化

5. 字符串的常用方法：

• len()：获取字符串的长度
• lower()：将字符串转换为小写
• upper()：将字符串转换为大写
• split()：将字符串拆分成列表
• strip()：去除字符串两端的空格或指定的字符
• replace()：替换字符串中的子字符串

my_string = "Hello, World!"
print(len(my_string))  # 输出 13
print(my_string.lower())  # 输出 'hello, world!'
print(my_string.split(", "))  # 输出 ['Hello', 'World!']
print(my_string.strip("!"))  # 输出 'Hello, World'
print(my_string.replace("Hello", "Hi"))  # 输出 'Hi, World!'

字符串在Python中广泛应用于文本处理、数据处理和字符串操作等场景，具有丰富的内置方法和功能。

🛥️定义函数

在Python中，函数是一段可重复使用的代码块，用于执行特定的任务或操作。函数可以接受输入参数（也称为参数或参数）并返回结果。

以下是定义函数的一般语法：

def function_name(parameter1, parameter2, ...):
    # 函数体
    # 执行特定的任务或操作
    # 可以使用参数进行计算或处理
    # 可以使用 return 语句返回结果（可选）

# 调用函数
function_name(argument1, argument2, ...)

解释一下上述语法的各个部分：

• def 关键字用于定义函数。
• function_name 是函数的名称，应遵循命名规则。
• parameter1, parameter2, ... 是函数的参数列表，用于接收传递给函数的值。参数是可选的，可以没有参数。
• 函数体是函数的实际代码块，用于执行特定的任务或操作。
• return 语句可选，用于指定函数的返回值。如果没有 return 语句，函数将不返回任何值。

在调用函数时，提供的值称为实际参数（也称为参数或参数），它们将传递给函数的参数。

def greet(name):
    # 打印问候语
    print("Hello, " + name + "!")

# 调用函数
greet("Alice")  # 输出 "Hello, Alice!"
greet("Bob")  # 输出 "Hello, Bob!"

在上面的示例中，我们定义了一个名为 greet 的函数，它接受一个参数 name，并在函数体内打印问候语。然后，我们调用函数两次，分别传递不同的参数值。

函数的定义允许我们将代码模块化，使其更易于理解、重用和维护。函数在Python中是非常重要和常用的概念。

🛥️全局变量

全局变量是在整个程序中都可以访问的变量，即在函数内外都可以使用。在Python中，可以在函数外部定义全局变量，并在函数内部进行访问和修改。

以下是一个示例：

global_variable = 10  # 在函数外部定义全局变量

def my_function():
    print(global_variable)  # 在函数内部访问全局变量

my_function()  # 输出 10

在上面的示例中，我们在函数外部定义了一个名为 global_variable 的全局变量，并在函数 my_function 内部访问了它。函数内部可以直接引用全局变量，而无需传递它作为参数。

注意：如果在函数内部修改全局变量的值，需要使用 global 关键字声明变量是全局的，否则 Python 将会创建一个新的局部变量。

global_variable = 10  # 在函数外部定义全局变量

def my_function():
    global global_variable  # 声明变量为全局变量
    global_variable = 20  # 修改全局变量的值
    print(global_variable)  # 在函数内部访问全局变量

my_function()  # 输出 20
print(global_variable)  # 输出 20

在上面的示例中，我们使用 global 关键字在函数内部声明 global_variable 是全局变量，并修改了它的值。在函数外部再次访问全局变量时，可以看到它的值已经被修改。

尽管全局变量可以在函数内外使用，但过多地使用全局变量可能会导致代码难以理解和维护。因此，应该谨慎使用全局变量，并优先考虑将数据作为参数传递给函数，以避免不必要的依赖关系和副作用。

🛥️python的异常处理机制

Python提供了异常处理机制，可以用于捕获和处理程序运行时的异常情况。异常是在程序执行期间发生的错误或异常情况，例如除以零、索引错误等。

异常处理机制可以让我们优雅地处理异常，避免程序崩溃，并提供适当的错误处理和恢复机制。在Python中，我们使用 try-except 语句来实现异常处理。

try-except 语句的基本语法：

try:
    # 可能引发异常的代码块
    # 可能会发生异常的操作
except ExceptionType1:
    # 处理 ExceptionType1 类型的异常
except ExceptionType2:
    # 处理 ExceptionType2 类型的异常
...
except:
    # 处理其他类型的异常（可选）
else:
    # 如果没有发生异常，执行的代码块（可选）
finally:
    # 无论是否发生异常，都会执行的代码块（可选）

解释一下上述语法的各个部分：

• try 块包含可能引发异常的代码。
• except 块用于捕获特定类型的异常。可以有多个 except 块，每个块处理不同类型的异常。也可以省略异常类型，以捕获所有类型的异常。
• else 块是可选的，用于在没有发生异常时执行的代码块。
• finally 块是可选的，无论是否发生异常，都会执行的代码块。通常用于清理资源或执行必要的收尾操作。

以下是一个示例，演示如何使用 try-except 来处理异常：

try:
    x = 10 / 0  # 可能引发 ZeroDivisionError 异常
    print(x)  # 不会执行，因为异常已被捕获
except ZeroDivisionError:
    print("除以零错误发生")

在上面的示例中，我们尝试将 10 除以 0，这会引发 ZeroDivisionError 异常。在 except 块中，我们捕获并处理了该异常，并打印出相应的错误消息。

除了捕获特定类型的异常，我们还可以使用 except 块来捕获多个异常类型，或者使用 except 块来捕获所有类型的异常。例如：

try:
    # 可能引发异常的代码
except (ExceptionType1, ExceptionType2):
    # 处理 ExceptionType1 或 ExceptionType2 类型的异常
except:
    # 处理其他类型的异常

在实际的异常处理中，我们可以根据具体的需求选择合适的异常类型进行捕获和处理，以提供更精确的错误处理和恢复逻辑。

🛥️self

当定义一个类时，需要在类的方法中使用 self 参数来引用对象实例自身。这样可以在方法内部访问和操作对象的属性和方法。

在类的方法中，self 是一个约定俗成的名称，但实际上可以使用任何合法的变量名。不过，为了遵循通用的编码规范和提高代码可读性，强烈建议使用 self。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hello(self):
        print(f"Hello, my name is {self.name} and I'm {self.age} years old.")

    def increase_age(self, years):
        self.age += years

# 创建一个 Person 实例
person = Person("Alice", 25)

# 调用对象的方法
person.say_hello()  # 输出：Hello, my name is Alice and I'm 25 years old.

# 调用对象的方法来修改属性
person.increase_age(5)
person.say_hello()  # 输出：Hello, my name is Alice and I'm 30 years old.

在上面的示例中，self 在类的方法中被使用。在 __init__ 方法中，我们使用 self.name 和 self.age 来访问并设置对象的属性。在 say_hello 方法中，我们使用 self.name 和 self.age 来访问对象的属性，并打印出相应的信息。在 increase_age 方法中，我们使用 self.age 来增加对象的年龄属性。

🛥️类和对象

在面向对象编程（Object-Oriented Programming，简称OOP）中，类（Class）和对象（Object）是两个重要的概念。

类是一种抽象的数据类型，用于描述对象的属性（属性是对象的特征）和行为（行为是对象的操作）。类是对象的模板或蓝图，定义了对象的结构和行为。

在Python中，可以使用关键字 class 来定义类。类的定义包括类名、属性和方法。属性是类的特征，用于存储数据。方法是类的行为，用于执行操作。

以下是一个简单的类的示例：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hello(self):
        print(f"Hello, my name is {self.name} and I'm {self.age} years old.")

# 创建对象
person1 = Person("Alice", 25)
person2 = Person("Bob", 30)

# 调用对象的方法
person1.say_hello()  # 输出 "Hello, my name is Alice and I'm 25 years old."
person2.say_hello()  # 输出 "Hello, my name is Bob and I'm 30 years old."

在上面的示例中，我们定义了一个名为 Person 的类，它具有 name 和 age 两个属性，以及 say_hello 方法。通过 __init__ 方法（构造函数），我们可以在创建对象时为属性赋值。然后，我们创建了两个 Person 对象，并调用它们的 say_hello 方法。

对象是类的实例，是类的具体化。通过实例化类，我们可以创建对象，并访问对象的属性和方法。每个对象都是独立的，具有自己的属性值。

在上面的示例中，person1 和 person2 就是 Person 类的两个对象。我们可以通过对象名称后跟点号来访问对象的属性和方法，例如 person1.name 和 person2.say_hello()。

类和对象是面向对象编程的核心概念，它们使代码更具模块化、可扩展性和可维护性。通过定义类和创建对象，我们可以将相关的数据和操作封装在一起，提高代码的可重用性和可读性。

🛥️类成员函数定义

在Python中，类的成员函数（也称为方法）是在类中定义的函数，用于操作类的属性和执行特定的功能。类的成员函数可以访问类的属性，并且可以通过实例化类的对象来调用。

下面是在类中定义成员函数的一般语法：

class MyClass:
    def my_function(self, arg1, arg2, ...):
        # 函数体

在这个语法中，my_function是成员函数的名称，self是一个特殊的参数，用于表示类的实例对象。在成员函数内部，可以使用self来访问类的属性和其他成员函数。

成员函数可以接受任意数量的参数，包括self参数。你可以根据需要在成员函数中定义其他参数，用于接受外部传入的值。

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

    def circumference(self):
        return 2 * 3.14 * self.radius

# 创建Circle类的实例
my_circle = Circle(5)

# 调用成员函数
print("Area:", my_circle.area())
print("Circumference:", my_circle.circumference())

在这个示例中，Circle类有两个成员函数：area()和circumference()。area()函数计算圆的面积，circumference()函数计算圆的周长。通过实例化Circle类的对象my_circle，我们可以调用这两个成员函数来计算圆的面积和周长。

注意，在成员函数内部访问类的属性时，需要使用self前缀，例如self.radius表示类的属性radius。

🛥️类的继承

类的继承是面向对象编程中的一个重要概念，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。通过继承，子类可以重用父类的代码，并可以在其基础上添加新的属性和方法，或者修改已有的属性和方法。

在Python中，使用以下语法定义一个子类并指定其父类：

class ChildClass(ParentClass):
    # 子类的定义

子类继承父类后，子类将自动获得父类中的所有属性和方法。子类可以直接使用父类中的属性和方法，也可以根据需要进行修改或扩展。

下面是一个简单的示例，演示了类的继承：

class Animal:
    def __init__(self, name):
        self.name = name

    def make_sound(self):
        print("The animal makes a sound.")

class Dog(Animal):
    def make_sound(self):
        print("The dog barks.")

animal = Animal("Animal")
print(animal.name)  # 输出 "Animal"
animal.make_sound()  # 输出 "The animal makes a sound."

dog = Dog("Dog")
print(dog.name)  # 输出 "Dog"
dog.make_sound()  # 输出 "The dog barks."

在上述示例中，我们定义了一个父类 Animal 和一个子类 Dog。父类 Animal 有一个构造函数 __init__ 和一个方法 make_sound。子类 Dog 继承了父类 Animal，并重写了 make_sound 方法。

当我们创建 Animal 对象时，可以访问父类的属性 name 和调用父类的方法 make_sound。当我们创建 Dog 对象时，可以访问子类的属性 name（继承自父类）和调用子类重写的方法 make_sound。

通过类的继承，我们可以构建出更复杂的类层次结构，实现代码的重用和扩展。子类可以继承父类的属性和方法，并可以根据需要添加新的属性和方法，以满足特定的需求。

🛥️方法重写

方法重写（Method Overriding）是面向对象编程中的一种特性，它允许子类重新定义从父类继承的方法，以适应子类的特定需求。

当子类继承一个父类时，它可以使用相同的方法名来覆盖（重写）父类的方法。这样，在调用该方法时，将执行子类中的方法而不是父类中的方法。

在Python中，方法重写是通过在子类中定义与父类方法同名的方法来实现的。子类方法的定义与父类方法的定义必须具有相同的名称和参数列表。

以下是一个示例，演示了方法重写的概念：

class Animal:
    def make_sound(self):
        print("The animal makes a sound.")

class Dog(Animal):
    def make_sound(self):
        print("The dog barks.")

animal = Animal()
animal.make_sound()  # 输出 "The animal makes a sound."

dog = Dog()
dog.make_sound()  # 输出 "The dog barks."

在上面的示例中，我们定义了一个 Animal 类和一个 Dog 类。Animal 类有一个名为 make_sound 的方法，它打印出动物发出的声音。Dog 类继承自 Animal 类，并重写了 make_sound 方法，使其打印出狗的叫声。

当我们创建 Animal 对象并调用 make_sound 方法时，输出的是动物的声音。而当我们创建 Dog 对象并调用 make_sound 方法时，输出的是狗的叫声。这是因为在子类中重写了父类的方法。

通过方法重写，我们可以根据需要修改继承自父类的方法的实现，使其适应子类的特定行为。这是面向对象编程中实现多态性的一种方式。

🛥️模块导入

模块导入是在Python中使用模块的一种方式，它允许我们在一个Python程序中使用其他模块中定义的函数、类和变量。

在Python中，我们可以使用import语句导入整个模块，也可以使用from-import语句导入模块中的特定函数、类或变量。

下面是几种常见的模块导入方式：

1. 导入整个模块：
   使用import语句导入整个模块，并使用模块名来访问其中的函数、类和变量。示例如下：

   import math
   
   result = math.sqrt(16)
   print(result)  # 输出 4.0
   

   在上述示例中，我们使用import math导入了Python的内置math模块，然后使用math.sqrt()函数计算了16的平方根。

2. 从模块中导入特定的函数、类或变量：
   使用from-import语句导入模块中的特定函数、类或变量，并直接使用它们，无需使用模块名作为前缀。示例如下：

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

   在上述示例中，我们使用from math import sqrt导入了math模块中的sqrt函数，并直接使用sqrt()函数计算了16的平方根。

3. 给导入的模块指定别名：
   使用import-as语句导入模块，并为模块指定一个别名，以便在代码中使用更简短的名称。示例如下：

   import math as m
   
   result = m.sqrt(16)
   print(result)  # 输出 4.0
   

   在上述示例中，我们使用import math as m将math模块导入，并将其别名设置为m，然后使用m.sqrt()函数计算了16的平方根。

这些是常见的模块导入方式，可以根据具体的需求选择适合的方式。需要注意的是，模块导入后，可以使用导入的函数、类或变量，但也要避免命名冲突，以免引起不必要的错误。

🛥️Python常用内容模块

Python中有许多常用的内容模块，它们提供了各种功能和工具，可以帮助我们进行各种任务和操作。以下是一些常用的内容模块：

1. math模块： 提供了数学运算相关的函数和常量，例如三角函数、指数函数、对数函数、常用数学常量等。

2. random模块： 提供了生成随机数和随机选择的函数，用于模拟随机事件、生成随机样本等。

3. datetime模块： 提供了处理日期和时间的函数和类，用于获取当前日期时间、格式化日期时间、进行日期时间计算等。

4. os模块： 提供了与操作系统交互的函数，用于执行文件和目录操作，例如创建、删除、重命名文件或目录，获取文件属性等。

5. sys模块： 提供了与Python解释器和系统相关的函数和变量，例如获取命令行参数、退出程序、修改模块搜索路径等。

6. re模块： 提供了正则表达式相关的函数，用于在文本中进行模式匹配和搜索。

7. json模块： 提供了处理JSON（JavaScript Object Notation）数据的函数和类，用于解析JSON数据、序列化Python对象为JSON格式等。

8. csv模块： 提供了读写CSV（Comma-Separated Values）文件的函数和类，用于处理以逗号分隔的数据。

9. requests模块： 提供了发送HTTP请求的函数和类，用于与Web服务器进行交互，例如获取网页内容、发送POST请求等。

10. numpy模块： 提供了高性能的数值计算和数组操作功能，用于处理大规模数据和进行科学计算。

11. pandas模块： 提供了数据分析和处理的函数和数据结构，用于处理和分析结构化数据。

12. matplotlib模块： 提供了绘制图表和可视化数据的函数和类，用于创建各种类型的图表和图形。

这只是一小部分常用的内容模块，Python还有许多其他模块可以满足不同的需求。根据具体的任务和应用场景，我们可以选择合适的模块来提供所需的功能。

🛥️编码格式

编码格式是用于表示和存储文本数据的规则和约定。在计算机中，所有的文本都以二进制形式存储，而编码格式定义了如何将字符映射为二进制数据。

在Python中，常见的编码格式包括：

1. ASCII编码： ASCII（American Standard Code for Information Interchange）是最早的字符编码标准，使用7位二进制数表示128个字符，包括英文字母、数字和一些常用符号。ASCII编码只适用于英文字符，无法表示其他语言的字符。

2. Unicode编码： Unicode是一种字符编码标准，它定义了全球范围内所有字符的唯一编码，包括各种语言的字符、符号、标点符号等。Unicode编码可以使用不同的存储方式，如UTF-8、UTF-16等。

3. UTF-8编码： UTF-8（Unicode Transformation Format-8）是一种变长编码，它可以表示Unicode中的所有字符。UTF-8编码使用1到4个字节来表示不同的字符，对于ASCII字符，使用1个字节表示，兼容ASCII编码。

在Python中，默认使用UTF-8编码来处理文本数据。当我们读取或写入文件时，可以指定所使用的编码格式。例如，使用open()函数打开文件时，可以指定encoding参数来指定编码格式：

# 以UTF-8编码方式打开文件
file = open("file.txt", "r", encoding="utf-8")

在处理字符串时，我们可以使用encode()和decode()方法进行编码和解码操作：

# 编码为UTF-8
encoded_data = "文本".encode("utf-8")

# 解码为Unicode字符串
decoded_data = encoded_data.decode("utf-8")

需要注意的是，不同的编码格式在存储和表示字符时使用的字节数不同，因此在处理文本数据时，要确保使用相同的编码格式进行读取和写入，以避免乱码和数据损坏的问题。

🛥️常用文件打开方式

在Python中，打开文件时可以使用不同的模式来指定文件的打开方式。以下是一些常用的文件打开方式：

1. “r”： 以只读方式打开文件。如果文件不存在，会引发FileNotFoundError错误。

2. “w”： 以写入方式打开文件。如果文件存在，会先清空文件内容；如果文件不存在，会创建新文件。

3. “a”： 以追加方式打开文件。如果文件存在，写入的内容会追加到文件末尾；如果文件不存在，会创建新文件。

4. “x”： 以独占方式创建新文件并打开。如果文件已存在，会引发FileExistsError错误。

5. “b”： 以二进制模式打开文件。可以与上述模式组合使用，例如："rb"表示以二进制只读方式打开文件。

6. “t”： 以文本模式打开文件（默认模式）。可以与上述模式组合使用，例如："wt"表示以文本写入方式打开文件。

7. “+”： 以更新模式打开文件，可读写。可以与上述模式组合使用，例如："r+"表示以读写方式打开文件。

在使用open()函数打开文件时，可以指定文件名和打开方式。例如：

# 以只读方式打开文件
file = open("file.txt", "r")

# 以写入方式打开文件
file = open("file.txt", "w")

# 以追加方式打开文件
file = open("file.txt", "a")

需要注意的是，在操作完文件后，应该使用close()方法关闭文件，以释放资源。另一种更好的方式是使用with语句，它可以自动管理文件的打开和关闭，确保文件在使用完后被正确关闭：

with open("file.txt", "r") as file:
    # 对文件进行操作
    # 文件会在这个代码块执行完后自动关闭

使用with语句可以避免忘记关闭文件的问题，并提供更清晰的代码结构。

🛥️文件对象常用方法

文件对象在Python中具有许多常用的方法，用于读取、写入和操作文件。下面是一些常见的文件对象方法：

1. read(size=-1)： 从文件中读取指定大小的数据。如果没有指定大小，则读取整个文件。返回一个字符串（文本模式）或字节对象（二进制模式）。

2. readline(size=-1)： 从文件中读取一行数据。如果没有指定大小，则读取整行。返回一个字符串（文本模式）或字节对象（二进制模式）。

3. readlines()： 从文件中读取所有行，并将每行作为一个字符串存储在列表中返回。每行字符串末尾包含换行符。

4. write(string)： 将字符串（文本模式）或字节对象（二进制模式）写入文件。返回写入的字符数（文本模式）或写入的字节数（二进制模式）。

5. writelines(lines)： 将字符串列表（或可迭代对象）中的每个字符串写入文件。每个字符串末尾不会自动添加换行符。

6. seek(offset[, whence])： 将文件指针移动到指定位置。offset表示偏移量，whence表示参考位置，默认为0（文件开头）。常用的参考位置有0（文件开头）、1（当前位置）和2（文件末尾）。

7. tell()： 返回当前文件指针的位置。

8. close()： 关闭文件。在完成文件操作后，应该调用该方法以释放资源。

这些是文件对象的一些常用方法，可以根据需要使用它们来读取、写入和操作文件。需要注意的是，在使用完文件后，应该调用close()方法关闭文件，以释放资源。另一种更好的方式是使用with语句，它可以自动管理文件的打开和关闭，确保文件在使用完后被正确关闭：

with open("file.txt", "r") as file:
    # 对文件进行操作
    # 文件会在这个代码块执行完后自动关闭

使用with语句可以避免忘记关闭文件的问题，并提供更清晰的代码结构。

当然！下面是一些使用文件对象常用方法的示例代码：

1. 读取文件内容并打印：

with open("file.txt", "r") as file:
    content = file.read()
    print(content)

2. 逐行读取文件内容并打印：

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

3. 写入数据到文件：

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

4. 逐行写入数据到文件：

lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
with open("file.txt", "w") as file:
    file.writelines(lines)

5. 移动文件指针并读取部分内容：

with open("file.txt", "r") as file:
    file.seek(5)  # 将文件指针移动到第6个字节的位置
    content = file.read(10)  # 读取10个字节的内容
    print(content)

这些示例演示了如何使用文件对象的常用方法来读取和写入文件内容。根据实际需求，你可以灵活运用这些方法来处理文件操作。记得在完成文件操作后，使用close()方法或者with语句来关闭文件，以释放资源。

🛥️with语句

with语句是Python中用于处理资源管理的一种语法结构。它提供了一种简洁的方式来管理打开的文件、网络连接、数据库连接等资源，确保在使用完毕后自动关闭或释放这些资源，以避免资源泄露和错误。

with语句的一般语法形式如下：

with expression as variable:
    # 执行需要使用资源的代码块

在这个语法结构中，expression通常是一个返回资源对象的表达式，variable是一个变量名，用于引用这个资源对象。

with语句的执行流程如下：

1. expression表达式的结果会被赋值给variable变量。
2. 执行with代码块中的代码，使用variable来操作资源。
3. 无论代码块中是否发生异常，with语句会自动调用资源对象的__exit__()方法，用于释放资源。

下面是一个使用with语句打开文件并读取内容的示例：

with open("file.txt", "r") as file:
    content = file.read()
    print(content)

在这个示例中，open("file.txt", "r")返回一个文件对象，它被赋值给file变量。在with代码块中，我们可以使用file变量来读取文件内容。当代码块执行完毕后，无论是否发生异常，文件对象的__exit__()方法会被自动调用，从而关闭文件。

使用with语句可以简化资源管理的代码，同时也更加安全可靠，因为它能够自动处理资源的释放，避免忘记关闭资源而导致的问题。

🛥️os模块常用函数

os模块是Python中用于与操作系统进行交互的模块，它提供了许多常用的函数和方法来执行文件和目录操作、进程管理、环境变量访问等。下面是一些os模块的常用函数：

1. os.getcwd(): 获取当前工作目录的路径。
2. os.chdir(path): 改变当前工作目录到指定的路径。
3. os.listdir(path): 返回指定路径下的文件和目录列表。
4. os.mkdir(path): 创建一个新目录。
5. os.makedirs(path): 递归创建多层目录。
6. os.remove(path): 删除指定的文件。
7. os.rmdir(path): 删除指定的目录。
8. os.removedirs(path): 递归删除多层目录。
9. os.rename(src, dst): 将文件或目录从src重命名为dst。
10. os.path.exists(path): 判断指定路径是否存在。
11. os.path.isfile(path): 判断指定路径是否为文件。
12. os.path.isdir(path): 判断指定路径是否为目录。
13. os.path.join(path1, path2, ...): 将多个路径组合成一个路径。
14. os.path.basename(path): 获取路径中的文件名部分。
15. os.path.dirname(path): 获取路径中的目录部分。
16. os.path.abspath(path): 返回路径的绝对路径表示。
17. os.path.split(path): 将路径分割成目录和文件名两部分。

这些函数只是os模块提供的众多函数中的一部分，它们可以帮助你进行文件和目录的操作，判断路径是否存在以及获取路径的各种信息。你可以根据实际需求选择适合的函数来使用。更详细的函数列表和用法可以参考Python官方文档中的os模块文档。

🛥️os.path模块操作目录以及相关函数

os.path模块是Python中用于处理文件路径和目录的模块，它提供了一些函数和方法用于对路径进行操作和处理。下面是一些os.path模块的常用函数：

1. os.path.join(path1, path2, ...): 将多个路径组合成一个完整的路径。
2. os.path.abspath(path): 返回指定路径的绝对路径。
3. os.path.basename(path): 返回指定路径中的文件名部分。
4. os.path.dirname(path): 返回指定路径中的目录部分。
5. os.path.exists(path): 判断指定路径是否存在。
6. os.path.isfile(path): 判断指定路径是否为文件。
7. os.path.isdir(path): 判断指定路径是否为目录。
8. os.path.splitext(path): 分离文件名和扩展名，返回一个元组。
9. os.path.getsize(path): 返回指定文件的大小，单位为字节。
10. os.path.getctime(path): 返回指定文件的创建时间。
11. os.path.getmtime(path): 返回指定文件的最后修改时间。

这些函数可以帮助你对文件路径进行拼接、获取文件名、判断路径是否存在、判断路径是文件还是目录，以及获取文件的大小和时间等信息。通过使用这些函数，你可以更方便地操作和处理文件路径和目录。