Python3学习笔记

1- Python基础内容

1. 基本概念

解释型语言：Python 是一种解释型语言，代码运行时逐行解释执行。
动态类型：变量在运行时决定类型，无需声明。

2. 编码

定义：编码是将字符集转换为字节的方式。Python 3 默认使用 UTF-8 编码，能够支持多种语言的字符。
文件编码声明

：在文件顶部可以声明编码格式，尽管在Python 3中通常不需要，因为它默认是UTF-8，但为了兼容性，可以添加：
```
python


Copy code
# -*- coding: utf-8 -*-
```

示例

：在字符串中使用中文字符。

pythonCopy codemessage = "你好，世界"
print(message)

3. 标识符

定义：标识符用于命名变量、函数、类、模块等。
规则：
- 只能使用字母（A-Z、a-z）、数字（0-9）和下划线（_）。
- 不能以数字开头。
- 区分大小写（例如，myVar 和 myvar 是不同的）。
- 不能使用Python保留字（如 if, else, for, class 等）。

示例：

pythonCopy codemy_variable = 10  # 合法
myVariable = 20    # 合法
1st_variable = 30  # 不合法，不能以数字开头

4. 变量命名

规则：遵循标识符的规则。
命名规范：
- 使用有意义的名称，以便代码可读。
- 对于变量名使用小写字母，多个单词用下划线分隔（如 total_sum）。
- 类名通常使用驼峰命名法（如 MyClass）。
- 常量（不变的值）通常使用全大写字母（如 MAX_SIZE）。

示例：

pythonCopy codeage = 25                # 合法变量
max_students = 30      # 合法变量名
class Student:         # 合法类名
    pass

5. 缩进

重要性：在Python中，缩进用于表示代码块，这意味着代码的结构依赖于缩进而非符号。
规则：
- 通常使用4个空格作为缩进，不建议混用空格和制表符。
- 在同一个代码块中，缩进量必须保持一致。

示例：

pythonCopy codeif condition:
    # 这个代码块缩进
    do_something()
    if another_condition:
        do_something_else()  # 进一步缩进

6. 注释

单行注释：使用 # 开头。
```
# 这是一个单行注释
```

多行注释：使用三个引号（''' 或 """）。

'''
这是一个多行注释
可以用于注释多行代码
'''

7. 数据类型

基本数据类型：
- 整数（int）
- 浮点数（float）
- 字符串（str）
- 布尔值（bool）
复合数据类型：
- 列表（list）
- 元组（tuple）
- 字典（dict）
- 集合（set）

8. 变量

赋值操作：
```
x = 5
name = "Alice"
```

9. 运算符

算术运算符：
- 加（+），减（-），乘（*），除（/），整除（//），取余（%），幂（**）
比较运算符：
- 等于（==），不等于（!=），大于（>），小于（<），大于等于（>=），小于等于（<=）
逻辑运算符：
- 与（and），或（or），非（not）

10. 控制结构

条件语句：

if condition:
    # 执行代码块
elif another_condition:
    # 执行其他代码块
else:
    # 执行备用代码块

循环语句：

for 循环：
```
for i in range(5):
    print(i)
```
while 循环：
```
while condition:
    # 执行代码块
```

11. 函数

定义函数：

def function_name(parameters):
    # 函数体
    return value

调用函数：
```
result = function_name(arguments)
```

12. 模块与包

导入模块：

import module_name
from module_name import function_name

13. 异常处理

使用 try 和 except 处理异常：

try:
    # 可能会出错的代码
except SomeException:
    # 处理错误的代码

14. 文件操作

打开文件：

with open('filename.txt', 'r') as file:
    content = file.read()

15. 列表、元组、字典、集合的基本操作

列表：

my_list = [1, 2, 3]
my_list.append(4)  # 添加元素

元组：
```
my_tuple = (1, 2, 3)  # 不可变
```

字典：

my_dict = {'key': 'value'}
my_dict['new_key'] = 'new_value'  # 添加键值对

集合：

my_set = {1, 2, 3}
my_set.add(4)  # 添加元素

16. 列表推导式

简洁的创建列表：
```
squares = [x**2 for x in range(10)]
```

17. Lambda 函数

匿名函数：
```
add = lambda x, y: x + y
```

18. 类与对象

定义类：

class MyClass:
    def __init__(self, value):
        self.value = value
    
    def display(self):
        print(self.value)

创建对象：
```
obj = MyClass(10)
obj.display()
```

19. 常用内置函数

len()：获取长度
type()：获取类型
print()：输出
input()：输入

2- 标识符

1. 标识符的定义

1.1 定义

标识符是用于命名变量、函数、类、模块、包等的名称。它们在程序中用于唯一标识这些元素，方便程序员进行引用和操作。

2. 标识符的规则

2.1 字符组成

标识符可以包含字母（A-Z、a-z）、数字（0-9）和下划线（_）。
标识符的第一个字符不能是数字。

2.2 长度限制

标识符的长度没有固定限制，但应该保持简短且有意义。

2.3 大小写敏感

Python 区分大小写，因此 myVariable 和 myvariable 是两个不同的标识符。

2.4 不能使用保留字

Python 有一组保留字（关键字），这些词在语言中有特定的含义，不能用作标识符。常见的保留字包括 if, for, while, class, def, return 等。

3. 标识符的命名规范

3.1 意义明确

选择能够反映变量用途的名称，例如 count、user_name 等。

3.2 使用小写字母

常规变量使用小写字母，多个单词之间用下划线分隔（如 total_price）。

3.3 类名使用驼峰命名法

类名通常采用首字母大写的驼峰命名法（如 StudentRecord）。

3.4 常量全大写

常量（不变的值）通常使用全大写字母，单词之间用下划线分隔（如 MAX_SIZE）。

3.5 避免使用单字符命名

除非在循环或临时变量中，尽量避免使用单字符名称（如 x, y），应尽量使用更具描述性的名称。

4. 示例

好的，下面为 4.1 合法标识符 和 4.2 非法标识符 添加更多示例。

4.1 合法标识符

user_name = "Alice"         # 小写字母和下划线
age = 30                     # 字母和数字
MAX_SIZE = 100               # 常量，使用全大写
MyClass = "class_name"       # 类名，使用驼峰命名法
total_price = 250.75         # 有意义的名称，描述了变量用途
is_valid = True              # 布尔值变量，以 is 开头
student_count = 45           # 有描述性的变量名，使用下划线分隔
_user = "hidden"             # 以下划线开头的变量名，常用于内部变量
PI = 3.14159                 # 常量，用全大写字母表示
EmployeeID = "E12345"        # 类名或特定变量的驼峰命名法
first_name = "John"          # 多个单词用下划线分隔
x = 10                       # 虽然单字符命名，但在某些情况下合法，例如循环变量

4.2 非法标识符

1st_variable = 10            # 不合法，不能以数字开头
my-variable = 20             # 不合法，使用了非法字符（-）
class = "test"               # 不合法，使用了保留字
@username = "admin"          # 不合法，使用了非法字符（@）
def = "function"             # 不合法，使用了保留字
first name = "Alice"         # 不合法，包含空格
$salary = 5000               # 不合法，使用了非法字符（$）
3d_model = "model1"          # 不合法，数字不能在开头
global = "global_var"        # 不合法，使用了保留字
if_ = "condition"            # 不建议使用，虽然 `if_` 合法，但容易混淆

5. 常见错误

5.1 使用保留字

确保没有使用Python的保留字作为标识符。

5.2 字符限制

确保标识符不以数字开头，并且不使用特殊字符（如 @, #, -, !）。

5.3 大小写问题

注意标识符的大小写，确保在引用时保持一致。

3- 变量命名

1. 变量命名的基本规则

在 Python 中，变量名必须遵循以下规则：

只能包含字母、数字和下划线，并且不能以数字开头。
- 示例：合法的变量名有 name, age23, school_name 等。
- 不合法的变量名有 1name, school-name 等。
区分大小写。
- age 和 Age 是两个不同的变量。
不能使用 Python 的保留字，如 if, for, while, class 等。
- 示例：for 不能作为变量名，但可以用 for_ 代替。
变量名应简洁且具有描述性，使代码更易读和维护。

2. 常用命名规范

2.1 使用下划线分隔单词（snake_case）

在 Python 中，通常采用小写字母和下划线分隔的方式（snake_case），这是一种广泛使用的变量命名方式。

示例：

user_name = "aini"       # 使用小写字母和下划线分隔单词
age = 23                 # 简单的变量名
university = "东华大学"  # 简洁的描述性名称
city = "上海"            # 描述性强的变量

2.2 使用全大写表示常量

通常在代码中，我们用全大写字母表示常量（不变的值）。常量名称中间用下划线分隔，这样的命名便于一眼看出该变量不应被修改。

示例：

MAX_AGE = 100            # 假设这是某个最大年龄限制
BIRTH_YEAR = 2000        # 假设你的出生年份

3. 一些举例

根据你的个人信息，以下是一些合理的变量命名示例：

# 基本个人信息
name = "aini"                  # 存储名字
age = 23                       # 存储年龄
university_name = "东华大学"   # 存储大学名称
city_of_residence = "上海"     # 存储居住城市

# 更详细的信息（扩展为描述性变量）
birth_year = 2000              # 假设你的出生年份
hobby_list = ["阅读", "运动"]   # 兴趣爱好，可以用列表形式
is_student = True              # 布尔变量，表示是否为学生
graduation_year = 2025         # 假设毕业年份

4. 常见变量命名的类别与规范

4.1 布尔值命名

布尔值（True 或 False）的变量通常用 is_ 或 has_ 开头，表示状态或特性。

示例：

is_student = True              # 表示是否是学生
has_scholarship = False        # 表示是否有奖学金
is_graduated = False           # 表示是否已毕业

4.2 列表和集合的命名

如果一个变量存储多个值（如兴趣爱好、已修课程等），可以用复数形式或 _list 结尾。

示例：

hobbies = ["阅读", "运动"]       # 兴趣爱好
completed_courses = ["数学", "物理"]  # 已修课程
friend_names = ["李明", "王芳"]    # 朋友的名字

4.3 使用描述性强的名字

变量命名时，尽量选择能够反映变量内容的名字，不要过于简短或模糊。比如，name 可以更明确为 user_name 或 student_name。

示例：

user_name = "aini"             # 用户名
current_city = "上海"          # 当前居住城市
enrolled_university = "东华大学" # 所在大学

5. 不推荐的命名方式

使用无意义的单字符变量名（除非在循环中，通常我们避免使用单字符变量名）。
- 如 a = 23，n = "东华大学"，这种命名方式信息不明确。
混用大小写（除非明确需要区分大小写），过多的大小写会影响可读性。
- 如 MyName = "aini"，AGE23 = 23，不推荐在普通变量中使用驼峰或全大写，容易误解。
模糊的缩写，除非缩写很常用，否则避免使用不直观的缩写。
- 如 usr = "aini" 可能代表用户（user），但最好用 user_name 这样更清晰。

6. 结合示例的完整代码

综合以上命名规则，以下是一段 Python 代码示例：

# 基本信息
user_name = "aini"                     # 用户名
age = 23                                # 年龄
university_name = "东华大学"            # 大学名称
city_of_residence = "上海"              # 居住城市
birth_year = 2000                       # 出生年份
is_student = True                       # 是否为学生
graduation_year = 2025                  # 预计毕业年份

# 扩展信息
hobby_list = ["阅读", "运动"]            # 兴趣爱好
has_scholarship = False                 # 是否有奖学金
completed_courses = ["数学", "物理"]    # 已修课程
friend_names = ["李明", "王芳"]         # 朋友名字列表

4- 缩进和注释

1. 缩进

1.1 缩进的定义和作用

在 Python 中，缩进用于标识代码块。与许多编程语言不同，Python 没有用 {} 来包裹代码块，而是依靠缩进来确定层次结构。因此，缩进在 Python 中是强制的，它不仅用于代码的可读性，还决定了代码的执行结构。

1.2 缩进的基本规则

缩进一致性：在同一个代码块中，所有缩进必须保持一致。Python 的默认缩进规范是 4 个空格，也可以用一个 Tab 键，但不能混合使用。
代码块结构：Python 通过缩进来识别不同的代码块。例如，在 if、for、while 等语句后面缩进的部分被认为是属于这些语句的代码块。

1.3 缩进示例

以 if 语句为例，来看一下如何使用缩进来定义代码块：

age = 23

if age >= 18:
    print("你已成年")         # 这个缩进属于 if 语句的代码块
    print("可以参与投票")     # 这个也是 if 语句的代码块
else:
    print("你未成年")         # 这个属于 else 语句的代码块

在上面的代码中，if 和 else 语句下面的代码都缩进了 4 个空格，这表示这些缩进的代码是属于各自条件的代码块。

1.4 缩进错误示例

如果缩进不一致或不符合 Python 规范，就会导致 IndentationError 错误。

if age >= 18:
    print("你已成年")
     print("可以参与投票")  # 不一致的缩进，将导致 IndentationError

在这个例子中，第二行和第三行的缩进不一致（一个是 4 个空格，另一个是 5 个空格），Python 会报错。

1.5 嵌套缩进

当代码块有多层嵌套时，每一层嵌套都需要再缩进一次，通常每一层使用 4 个空格。

age = 23
is_student = True

if age >= 18:
    print("你已成年")
    if is_student:
        print("你是成年学生")   # 进一步嵌套的代码块，每层缩进 4 个空格
    else:
        print("你不是学生")
else:
    print("你未成年")

在这个例子中，if 语句中的嵌套 if 和 else 语句都进一步缩进了 4 个空格。

2. 注释

注释是对代码的解释说明，用于帮助开发者理解代码的作用和逻辑。Python 支持单行注释和多行注释。

2.1 单行注释

在 Python 中，单行注释使用 # 符号。# 后的内容不会被 Python 解释器执行，通常用于解释代码行的功能。

用法：# 后面可以跟任何注释内容。通常单行注释会放在代码上方或者旁边。

示例：

age = 23  # 定义年龄变量，值为23

多行单行注释：如果需要多行注释，但每行只有简单的注释内容，可以在每行前面加 #。
```
# 这是一个多行注释
# 说明这段代码的作用
# 以及每行的功能
```

2.2 多行注释

多行注释在 Python 中通常使用三个单引号 ''' 或三个双引号 """ 括起来的内容。这种方式的注释主要用于函数或类的文档字符串（docstring），也可以用于多行注释，但在一般代码中单行注释更为常见。

用法：在代码块前或后使用 '''注释内容''' 或 """注释内容""" 包裹多行注释。

示例：

'''
这是一个多行注释
可以用来描述整个函数的作用
或者解释代码逻辑
'''

2.3 函数和类的文档字符串（docstring）

当编写函数、类或模块时，建议在定义的第一行使用多行注释来描述它的功能。这样可以为函数或类提供文档说明，方便其他人了解它的用途。

函数文档字符串示例：

def greet_user(name):
    """打印问候用户的消息"""
    print(f"你好, {name}")

类文档字符串示例：

class Student:
    """这是一个学生类，用于存储学生的基本信息"""

    def __init__(self, name, age):
        """初始化学生的名字和年龄"""
        self.name = name
        self.age = age

2.4 注释的规范与最佳实践

注释要简洁明了：注释应该清楚明白地解释代码的意图，而不是重复代码本身。例如，以下注释是多余的：
```
count = 0  # 将计数变量设置为0
```
可以改为：
```
count = 0  # 记录用户的数量
```
注释重要逻辑或复杂代码：对于重要的代码逻辑和复杂的部分，应提供详细的解释。
避免过多注释：不要在每一行都添加注释，过多的注释会影响可读性。只在关键地方添加注释即可。

3. 结合缩进和注释的代码示例

结合缩进和注释，以下是一个示例代码，展示了如何使用合理的缩进和注释来编写清晰、易读的 Python 代码：

def check_eligibility(age, city):
    """
    检查用户的资格，根据年龄和所在城市决定是否符合条件
    参数:
    age (int): 用户的年龄
    city (str): 用户所在的城市
    返回:
    bool: 如果符合资格返回 True，否则返回 False
    """
    
    # 判断年龄是否大于等于18
    if age >= 18:
        # 如果年龄合格，继续检查城市
        if city == "上海":
            return True  # 满足条件，返回 True
        else:
            return False  # 城市不符合条件，返回 False
    else:
        return False  # 年龄不符合条件，返回 False


# 调用函数并打印结果
user_age = 23
user_city = "上海"
is_eligible = check_eligibility(user_age, user_city)  # 检查用户是否符合资格
print(is_eligible)  # 打印结果

在这个示例中：

缩进：代码中使用 4 个空格来缩进每个代码块，保持一致性。
注释：代码中的每个逻辑步骤都配有简洁明了的注释，文档字符串则详细说明了函数的用途和参数。

5- 数据类型

1. 基本数据类型

Python 的基本数据类型包括整数（int）、浮点数（float）、布尔值（bool）、字符串（str）等。

1.1 整数（int）

定义：整数是没有小数部分的数，可以是正数、负数或零。
表示：Python 中的整数可以表示任意大小，因为 Python 会根据需要自动扩展整数的存储空间。

示例：

age = 23             # 整数
temperature = -5     # 负整数
big_number = 1000000 # 大整数

常用操作：
- 加法：a + b
- 减法：a - b
- 乘法：a * b
- 整除：a // b（返回商的整数部分）
- 取余：a % b（返回除法的余数）
- 幂运算：a ** b（a 的 b 次幂）

1.2 浮点数（float）

定义：浮点数是带小数部分的数字，通常用于表示小数或科学计数法形式的数。
精度问题：由于计算机内部的存储机制，浮点数的精度有限，可能出现误差。

示例：

price = 19.99          # 小数
pi = 3.14159           # 常见的浮点数
scientific_notation = 1.23e4 # 科学计数法表示，等价于 1.23 * 10^4

常用操作：与整数的操作相同，不过浮点数除法结果为浮点数。

1.3 布尔值（bool）

定义：布尔值只有 True 和 False 两个值，通常用于逻辑判断。
表达式：布尔值通常通过条件表达式得到，如 a > b、a == b 等。

示例：

is_student = True          # 表示是否为学生
has_scholarship = False     # 表示是否有奖学金

常用操作：
- 与（and）：True and False 返回 False
- 或（or）：True or False 返回 True
- 非（not）：not True 返回 False

1.4 字符串（str）

定义：字符串是由字符组成的序列，通常用于表示文本信息。
表示：可以使用单引号（'）、双引号（"）或三重引号（''' 或 """）定义。

示例：

name = "aini"            # 使用双引号
greeting = 'Hello'       # 使用单引号
long_text = """这是一个多行字符串
可以换行显示"""

常用操作：
- 字符串拼接："Hello" + " World" -> "Hello World"
- 重复："Hi" * 3 -> "HiHiHi"
- 取子串："Hello"[1:4] -> "ell"
- 常用方法：len("Hello")、"hello".upper()、"WORLD".lower()、"Hello World".split()。

2. 复合数据类型

复合数据类型包括列表（list）、元组（tuple）、字典（dict）和集合（set）。它们可以用来存储多个值，方便处理复杂的数据结构。

2.1 列表（list）

定义：列表是一个有序的可变序列，可以存储多个元素，元素之间用逗号分隔。
表示：列表使用方括号 [] 表示。

示例：

hobbies = ["阅读", "运动", "音乐"]     # 定义一个包含多个元素的列表
numbers = [1, 2, 3, 4, 5]             # 定义一个数字列表
mixed_list = ["aini", 23, True]       # 可以包含不同类型的元素

常用操作：
- 访问元素：hobbies[0] -> "阅读"
- 修改元素：hobbies[1] = "跑步"
- 添加元素：hobbies.append("电影")
- 删除元素：hobbies.remove("运动")
- 列表切片：numbers[1:3] -> [2, 3]

2.2 元组（tuple）

定义：元组是一个有序的不可变序列，一旦定义无法修改，通常用于存储不会改变的数据。
表示：元组使用小括号 () 表示。

示例：

coordinates = (30.0, 50.0)          # 定义一个坐标元组
personal_info = ("aini", 23, "上海") # 存储不可变的个人信息
single_item_tuple = (42,)           # 包含一个元素的元组，后面需加逗号

常用操作：
- 访问元素：coordinates[0] -> 30.0
- 元组解包：x, y = coordinates -> x = 30.0, y = 50.0

2.3 字典（dict）

定义：字典是一个无序的键值对集合，使用键（key）来访问对应的值（value），键必须是唯一的。
表示：字典使用大括号 {} 表示，每个键值对用冒号 : 分隔。

示例：

student_info = {
    "name": "aini",
    "age": 23,
    "city": "上海",
    "university": "东华大学"
}

常用操作：
- 访问值：student_info["name"] -> "aini"
- 修改值：student_info["age"] = 24
- 添加键值对：student_info["major"] = "计算机科学"
- 删除键值对：del student_info["city"]
- 获取键集合：student_info.keys()
- 获取值集合：student_info.values()

2.4 集合（set）

定义：集合是一个无序、唯一的元素集合，主要用于去重和集合运算。
表示：集合使用大括号 {} 表示，元素之间用逗号分隔，或使用 set() 函数创建空集合。

示例：

unique_numbers = {1, 2, 3, 4, 5, 5}  # 集合会自动去重
empty_set = set()                    # 使用 set() 创建空集合

常用操作：
- 添加元素：unique_numbers.add(6)
- 删除元素：unique_numbers.remove(2)
- 并集：set1 | set2
- 交集：set1 & set2
- 差集：set1 - set2
- 对称差集：set1 ^ set2

3. 特殊数据类型：NoneType

定义：NoneType 是一个特殊的空值类型，只有一个值 None，用于表示“什么都没有”。
用途：None 常用于表示缺失值、空返回值等。

示例：

result = None  # 初始值为 None，表示还没有结果

6- 运算符

6.1 算术运算符（掌握）

算术运算符用于进行数学计算，包括加、减、乘、除等基本操作。它们是编程中最常用的运算符。

常见的算术运算符：

运算符描述示例结果
+ 加法 3 + 2 5
- 减法 3 - 2 1
* 乘法 3 * 2 6
/ 除法 3 / 2 1.5
// 整除 3 // 2 1
% 取余 3 % 2 1
** 幂运算 3 ** 2 9

运算符	描述	示例	结果
`+`	加法	`3 + 2`	`5`
`-`	减法	`3 - 2`	`1`
`*`	乘法	`3 * 2`	`6`
`/`	除法	`3 / 2`	`1.5`
`//`	整除	`3 // 2`	`1`
`%`	取余	`3 % 2`	`1`
`**`	幂运算	`3 ** 2`	`9`

示例代码：

a = 10
b = 3
print(a + b)    # 输出 13
print(a - b)    # 输出 7
print(a * b)    # 输出 30
print(a / b)    # 输出 3.3333333333333335
print(a // b)   # 输出 3
print(a % b)    # 输出 1
print(a ** b)   # 输出 1000

6.2 比较运算符（掌握）

比较运算符用于比较两个值，结果返回布尔值 True 或 False，在条件判断中非常常用。

常见的比较运算符：

运算符描述示例结果
== 等于 3 == 2 False
!= 不等于 3 != 2 True
> 大于 3 > 2 True
< 小于 3 < 2 False
>= 大于等于 3 >= 2 True
<= 小于等于 3 <= 2 False

运算符	描述	示例	结果
`==`	等于	`3 == 2`	`False`
`!=`	不等于	`3 != 2`	`True`
`>`	大于	`3 > 2`	`True`
`<`	小于	`3 < 2`	`False`
`>=`	大于等于	`3 >= 2`	`True`
`<=`	小于等于	`3 <= 2`	`False`

示例代码：

x = 5
y = 10
print(x == y)   # 输出 False
print(x != y)   # 输出 True
print(x > y)    # 输出 False
print(x < y)    # 输出 True
print(x >= y)   # 输出 False
print(x <= y)   # 输出 True

6.3 赋值运算符（掌握）

赋值运算符用于将值赋给变量，并支持自加、自减、自乘等简便操作。是编程中非常基础且常用的运算符。

常见的赋值运算符：

运算符	描述	示例	等价于
`=`	赋值	`x = 5`	`x = 5`
`+=`	加赋值	`x += 3`	`x = x + 3`
`-=`	减赋值	`x -= 3`	`x = x - 3`
`*=`	乘赋值	`x *= 3`	`x = x * 3`
`/=`	除赋值	`x /= 3`	`x = x / 3`
`//=`	整除赋值	`x //= 3`	`x = x // 3`
`%=`	取余赋值	`x %= 3`	`x = x % 3`
`**=`	幂赋值	`x **= 3`	`x = x ** 3`

示例代码：

x = 10
x += 5      # 等价于 x = x + 5，结果为 15
x -= 3      # 等价于 x = x - 3，结果为 12
x *= 2      # 等价于 x = x * 2，结果为 24
x /= 4      # 等价于 x = x / 4，结果为 6.0

6.4 逻辑运算符（掌握）

逻辑运算符用于组合多个条件，返回布尔值 True 或 False，在条件判断和控制结构中十分常用。

常见的逻辑运算符：

运算符描述示例结果
and 逻辑与 True and False False
or 逻辑或 True or False True
not 逻辑非 not True False

运算符	描述	示例	结果
`and`	逻辑与	`True and False`	`False`
`or`	逻辑或	`True or False`	`True`
`not`	逻辑非	`not True`	`False`

示例代码：

a = True
b = False
print(a and b)   # 输出 False
print(a or b)    # 输出 True
print(not a)     # 输出 False

6.5 位运算符（了解）

位运算符用于直接操作二进制位，主要用于底层编程或硬件控制，对一般的应用程序开发不常用。

常见的位运算符：

运算符描述示例结果
& 按位与 5 & 3 1
` ` 按位或 `5
^ 按位异或 5 ^ 3 6
~ 按位取反 ~5 -6
<< 左移 5 << 1 10
>> 右移 5 >> 1 2

运算符	描述	示例	结果
`&`	按位与	`5 & 3`	`1`
`	`	按位或	`5
`^`	按位异或	`5 ^ 3`	`6`
`~`	按位取反	`~5`	`-6`
`<<`	左移	`5 << 1`	`10`
`>>`	右移	`5 >> 1`	`2`

示例代码：

a = 5        # 二进制为 0101
b = 3        # 二进制为 0011
print(a & b)  # 输出 1（二进制为 0001）
print(a | b)  # 输出 7（二进制为 0111）
print(a ^ b)  # 输出 6（二进制为 0110）
print(~a)     # 输出 -6（二进制为 -0110，补码表示）
print(a << 1) # 输出 10（二进制为 1010）
print(a >> 1) # 输出 2（二进制为 0010）

6.6 成员运算符（掌握）

成员运算符用于检查某个值是否存在于序列（如列表、元组、字符串）中，返回布尔值 True 或 False，在数据结构操作中非常常用。

常见的成员运算符：

运算符描述示例结果
in 在序列中 'a' in 'apple' True
not in 不在序列中 'b' not in 'apple' True

运算符	描述	示例	结果
`in`	在序列中	`'a' in 'apple'`	`True`
`not in`	不在序列中	`'b' not in 'apple'`	`True`

示例代码：

fruits = ["apple", "banana", "cherry"]
print("apple" in fruits)     # 输出 True
print("grape" not in fruits) # 输出 True

6.7 身份运算符（了解）

身份运算符用于比较两个对象的内存地址，判断它们是否是同一个对象。适合在需要比较对象身份的场景中使用，常

用于对象的内存管理。

常见的身份运算符：

运算符描述示例结果
is 是同一个对象 a is b True 或 False
is not 不是同一个对象 a is not b True 或 False

运算符	描述	示例	结果
`is`	是同一个对象	`a is b`	`True` 或 `False`
`is not`	不是同一个对象	`a is not b`	`True` 或 `False`

示例代码：

x = [1, 2, 3]
y = x
z = [1, 2, 3]

print(x is y)      # 输出 True，因为 y 和 x 是同一个对象
print(x is z)      # 输出 False，因为 z 是另一个列表，虽然内容相同
print(x == z)      # 输出 True，因为 x 和 z 的内容相同

6.8 运算符优先级（掌握）

运算符优先级决定了运算符的执行顺序，优先级高的运算符会先执行。在复合运算中，理解运算符优先级可以帮助我们正确书写表达式。

运算符优先级（从高到低）：
1. 指数运算符：**
2. 按位取反、逻辑非：~, not
3. 乘除、取余、整除：*, /, //, %
4. 加减：+, -
5. 移位运算符：<<, >>
6. 比较运算符：<, <=, >, >=
7. 等于运算符：==, !=
8. 位运算符：&, ^, |
9. 逻辑运算符：and, or
10. 赋值运算符：=, +=, -=, *=, /=, %= 等

万能方法：实在搞不清优先级，那就用()，希望先计算的用() 括起来

7- 字符串

7.1 字符串的定义（掌握）

字符串是一种由字符组成的不可变序列，用于表示文本数据。在 Python 中，字符串可以使用单引号 '、双引号 " 或三引号 '''/""" 来定义。

单引号和双引号：用于定义单行字符串，二者功能一致。
```
name = 'aini'
greeting = "Hello"
```
三引号：用于定义多行字符串，适合长文本或多行注释。
```
long_text = """这是一个
多行字符串"""
```

7.2 字符串的基本操作（掌握）

7.2.1 字符串拼接

使用 + 运算符将多个字符串拼接在一起。

first_name = "aini"
last_name = "Zhang"
full_name = first_name + " " + last_name  # 输出 'aini Zhang'

7.2.2 字符串重复

使用 * 运算符将字符串重复多次。

repeated = "Hello" * 3  # 输出 'HelloHelloHello'

7.2.3 字符串长度

使用 len() 函数获取字符串的字符数。

message = "Hello, World!"
print(len(message))  # 输出 13

7.2.4 字符串索引与切片

索引：使用索引访问字符串中的单个字符，索引从 0 开始，支持负索引。
```
text = "Python"
print(text[0])   # 输出 'P'
print(text[-1])  # 输出 'n'
```

切片：使用切片获取字符串中的部分内容，格式为 字符串[起始:结束:步长]。

text = "Python"
print(text[1:4])     # 输出 'yth'
print(text[:3])      # 输出 'Pyt'
print(text[::2])     # 输出 'Pto'
print(text[::-1])    # 输出 'nohtyP'（字符串反转）

7.3 字符串的常用方法（掌握）

Python 提供了丰富的字符串方法，以下是常用的字符串方法，主要用于字符串的处理和格式化。

7.3.1 `upper()` 和 `lower()`：转换大小写

upper()：将字符串全部转换为大写。

lower()：将字符串全部转换为小写。

text = "Hello World"
print(text.upper())  # 输出 'HELLO WORLD'
print(text.lower())  # 输出 'hello world'

7.3.2 `strip()`：去除空白字符

strip()：去除字符串两端的空白字符（包括空格、换行符等）。
lstrip()：去除左侧空白字符。

rstrip()：去除右侧空白字符。

text = "   Hello World   "
print(text.strip())   # 输出 'Hello World'
print(text.lstrip())  # 输出 'Hello World   '
print(text.rstrip())  # 输出 '   Hello World'

7.3.3 `replace()`：替换子字符串

replace(old, new)：将字符串中的 old 替换为 new。

text = "Hello World"
print(text.replace("World", "Python"))  # 输出 'Hello Python'

7.3.4 `split()` 和 `join()`：拆分与合并字符串

split(separator)：根据指定的分隔符将字符串拆分成列表。如果不指定分隔符，默认按空白字符拆分。

text = "Hello World"
print(text.split())         # 输出 ['Hello', 'World']
print(text.split('o'))      # 输出 ['Hell', ' W', 'rld']

join(iterable)：将可迭代对象中的元素连接成一个字符串，以调用者作为分隔符。

words = ["Hello", "Python", "World"]
print(" ".join(words))      # 输出 'Hello Python World'

7.3.5 `find()` 和 `index()`：查找子字符串

find(sub)：查找子字符串 sub 的位置，找到则返回索引，否则返回 -1。

index(sub)：与 find 类似，但如果找不到会引发 ValueError。

text = "Hello World"
print(text.find("World"))   # 输出 6
print(text.index("World"))  # 输出 6

7.4 字符串格式化（掌握）

Python 提供了多种格式化字符串的方法，便于拼接变量和字符串。

7.4.1 `f-string` 格式化（Python 3.6 及以上）

使用 f"{变量}" 的方式嵌入变量，非常直观且易读。

name = "aini"
age = 23
message = f"Hello, my name is {name} and I am {age} years old."
print(message)  # 输出 'Hello, my name is aini and I am 23 years old.'

7.4.2 `str.format()` 方法

使用 {} 占位符，并在字符串末尾调用 .format() 方法填充变量。

name = "aini"
age = 23
message = "Hello, my name is {} and I am {} years old.".format(name, age)
print(message)  # 输出 'Hello, my name is aini and I am 23 years old.'

7.4.3 百分号 `%` 格式化（旧方法）

使用 % 运算符来进行格式化，在旧代码中仍然常见。

name = "aini"
age = 23
message = "Hello, my name is %s and I am %d years old." % (name, age)
print(message)  # 输出 'Hello, my name is aini and I am 23 years old.'

7.5 字符串的编码与解码（了解）

编码与解码用于将字符串转换为字节或将字节转换为字符串。通常用于处理文件、网络传输和多语言文本处理。

7.5.1 `encode()`：编码字符串

encode(encoding)：将字符串转换为指定编码格式的字节对象（bytes）。

text = "Hello"
byte_text = text.encode("utf-8")
print(byte_text)  # 输出 b'Hello'

7.5.2 `decode()`：解码字节

decode(encoding)：将字节对象转换回指定编码格式的字符串。

byte_text = b'Hello'
text = byte_text.decode("utf-8")
print(text)  # 输出 'Hello'

7.6 字符串的常见检查方法（掌握）

用于判断字符串是否符合特定格式或内容。

7.6.1 `isalpha()`：检查是否全为字母

返回 True 如果字符串只包含字母且非空，否则返回 False。
```
text = "Hello"
print(text.isalpha())  # 输出 True
```

7.6.2 `isdigit()`：检查是否全为数字

返回 True 如果字符串只包含数字且非空，否则返回 False。
```
text = "12345"
print(text.isdigit())  # 输出 True
```

7.6.3 `isalnum()`：检查是否全为字母和数字

返回 True 如果字符串只包含字母和数字且非空，否则返回 False。
```
text = "Hello123"
print(text.isalnum())  # 输出 True
```

7.6.4 `isspace()`：检查是否全为空白字符

返回 True 如果字符串只包含空白字符（如空格、制表符）且非空，否则返回 False。
```
text = "   "
print(text.isspace())  # 输出 True
```

8- 列表

8.1 列表的定义（掌握）

列表是一个有序的、可变的序列，可以包含任意类型的元素。列表是 Python 中最常用的数据结构之一，适合存储一系列数据。列表用方括号 [] 表示，元素之间用逗号分隔。

定义列表：

empty_list = []                # 空列表
numbers = [1, 2, 3, 4, 5]      # 包含整数的列表
mixed_list = [1, "hello", 3.14, True]  # 混合数据类型的列表

8.2 列表的基本操作（掌握）

列表支持多种基本操作，如访问、修改、添加和删除元素。

8.2.1 访问元素

使用索引访问列表中的元素，索引从 0 开始，支持负索引。

numbers = [1, 2, 3, 4, 5]
print(numbers[0])    # 输出 1
print(numbers[-1])   # 输出 5（最后一个元素）

8.2.2 修改元素

使用索引修改列表中的元素。

numbers = [1, 2, 3, 4, 5]
numbers[0] = 10
print(numbers)       # 输出 [10, 2, 3, 4, 5]

8.2.3 列表切片

使用切片获取列表中的一部分，格式为 列表[起始:结束:步长]。

numbers = [1, 2, 3, 4, 5]
print(numbers[1:4])      # 输出 [2, 3, 4]
print(numbers[:3])       # 输出 [1, 2, 3]
print(numbers[::2])      # 输出 [1, 3, 5]
print(numbers[::-1])     # 输出 [5, 4, 3, 2, 1]（列表反转）

8.2.4 列表长度

使用 len() 函数获取列表的长度。

numbers = [1, 2, 3, 4, 5]
print(len(numbers))      # 输出 5

8.3 列表的常用方法（掌握）

Python 提供了多种方法来操作列表，这些方法可以帮助我们对列表进行添加、删除、查找等操作。

8.3.1 `append()`：添加元素到列表末尾

使用 append() 方法将元素添加到列表的末尾。

numbers = [1, 2, 3]
numbers.append(4)
print(numbers)           # 输出 [1, 2, 3, 4]

8.3.2 `insert()`：在指定位置插入元素

使用 insert(index, element) 方法在指定位置插入元素。

numbers = [1, 2, 3]
numbers.insert(1, "hello")
print(numbers)           # 输出 [1, 'hello', 2, 3]

8.3.3 `extend()`：扩展列表

使用 extend() 方法将一个列表的所有元素添加到另一个列表末尾。

numbers = [1, 2, 3]
more_numbers = [4, 5, 6]
numbers.extend(more_numbers)
print(numbers)           # 输出 [1, 2, 3, 4, 5, 6]

8.3.4 `remove()`：删除指定元素

使用 remove(element) 方法删除列表中的第一个匹配的元素。如果元素不存在，会引发 ValueError。
```
numbers = [1, 2, 3, 2, 4]
numbers.remove(2)
print(numbers)           # 输出 [1, 3, 2, 4]
```

8.3.5 `pop()`：弹出指定位置的元素

使用 pop(index) 方法删除并返回指定位置的元素。如果不指定索引，默认删除并返回最后一个元素。

numbers = [1, 2, 3, 4]
last_element = numbers.pop()
print(numbers)           # 输出 [1, 2, 3]
print(last_element)      # 输出 4

8.3.6 `clear()`：清空列表

使用 clear() 方法删除列表中的所有元素。

numbers = [1, 2, 3, 4]
numbers.clear()
print(numbers)           # 输出 []

8.3.7 `index()`：查找元素的索引

使用 index(element) 方法返回元素在列表中的第一个匹配索引。如果元素不存在，会引发 ValueError。
```
numbers = [1, 2, 3, 4]
print(numbers.index(3))  # 输出 2
```

8.3.8 `count()`：统计元素出现次数

使用 count(element) 方法统计指定元素在列表中出现的次数。
```
numbers = [1, 2, 2, 3, 4]
print(numbers.count(2))  # 输出 2
```

8.3.9 `sort()` 和 `sorted()`：排序

使用 sort() 方法对列表进行原地排序，改变原列表。可以传入 reverse=True 参数降序排序。

使用 sorted() 函数返回一个排序后的新列表，不改变原列表。

numbers = [3, 1, 4, 2]
numbers.sort()
print(numbers)           # 输出 [1, 2, 3, 4]

numbers = [3, 1, 4, 2]
sorted_numbers = sorted(numbers, reverse=True)
print(sorted_numbers)    # 输出 [4, 3, 2, 1]

8.3.10 `reverse()`：反转列表

使用 reverse() 方法将列表中的元素顺序反转，改变原列表。

numbers = [1, 2, 3, 4]
numbers.reverse()
print(numbers)           # 输出 [4, 3, 2, 1]

8.4 列表的生成式（掌握）

列表生成式（List Comprehension）是一种简洁的生成列表的方法，可以用一行代码创建一个新的列表，常用于数据处理和过滤。

基本语法：

[表达式 for 变量 in 可迭代对象 if 条件]

示例：

squares = [x**2 for x in range(1, 6)]
print(squares)           # 输出 [1, 4, 9, 16, 25]

even_numbers = [x for x in range(10) if x % 2 == 0]
print(even_numbers)      # 输出 [0, 2, 4, 6, 8]

8.5 列表的嵌套（掌握）

列表可以包含其他列表，形成嵌套结构，用于表示二维或多维数据。

示例：

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print(matrix[1][2])      # 输出 6，访问第2行第3列

8.6 列表的拷贝（了解）

列表的拷贝分为浅拷贝和深拷贝。

8.6.1 浅拷贝

浅拷贝只复制列表的第一层元素，嵌套的列表仍然是引用。

original = [1, [2, 3], 4]
shallow_copy = original.copy()
shallow_copy[1][0] = 99
print(original)          # 输出 [1, [99, 3], 4]

8.6.2 深拷贝

深拷贝递归地复制所有层级的元素，使用 copy 模块中的 deepcopy() 实现。
```
import copy
original =
```

[1, [2, 3], 4]
deep_copy = copy.deepcopy(original)
deep_copy[1][0] = 99
print(original) # 输出 [1, [2, 3], 4]


---

### 8.7 列表和其他数据类型的转换（了解）

Python 提供了多种内置函数，可以将其他数据类型转换为列表。

- **字符串转列表**：使用 `list()` 将字符串的每个字符转为列表元素。
```python
text = "hello"
text_list = list(text)
print(text_list)         # 输出 ['h', 'e', 'l', 'l', 'o']

元组转列表：使用 list() 将元组转换为列表。

tuple_data = (1, 2, 3)
list_data = list(tuple_data)
print(list_data)         # 输出 [1, 2, 3]

集合转列表：使用 list() 将集合转换为列表。

set_data = {1, 2, 3}
list_data = list(set_data)
print(list_data)         # 输出 [1, 2, 3]

9- 元祖

9.1 元组的定义（掌握）

元组是一种有序的、不可变的数据结构，可以存储多个元素。与列表类似，元组可以包含任意数据类型，但元组一旦创建，不能修改。元组使用小括号 () 表示，元素之间用逗号分隔。

定义元组：

empty_tuple = ()                    # 空元组
single_element_tuple = (42,)        # 单个元素的元组，需在元素后加逗号
numbers = (1, 2, 3, 4, 5)           # 包含多个元素的元组
mixed_tuple = (1, "hello", 3.14)    # 包含不同数据类型的元组

9.2 元组的基本操作（掌握）

虽然元组是不可变的，但我们可以通过索引和切片访问其中的元素。

9.2.1 访问元组元素

使用索引访问元组中的单个元素，索引从 0 开始，支持负索引。

numbers = (1, 2, 3, 4, 5)
print(numbers[0])       # 输出 1
print(numbers[-1])      # 输出 5（最后一个元素）

9.2.2 元组切片

使用切片获取元组中的一部分，格式为 元组[起始:结束:步长]。

numbers = (1, 2, 3, 4, 5)
print(numbers[1:4])     # 输出 (2, 3, 4)
print(numbers[:3])      # 输出 (1, 2, 3)
print(numbers[::2])     # 输出 (1, 3, 5)
print(numbers[::-1])    # 输出 (5, 4, 3, 2, 1)（元组反转）

9.2.3 元组长度

使用 len() 函数获取元组的长度。

numbers = (1, 2, 3, 4, 5)
print(len(numbers))      # 输出 5

9.3 元组的常用方法（掌握）

元组提供的内置方法不多，主要用于基本操作，如统计元素出现次数和查找元素索引。

9.3.1 `count()`：统计元素出现次数

使用 count(element) 方法统计指定元素在元组中出现的次数。
```
numbers = (1, 2, 2, 3, 4)
print(numbers.count(2))  # 输出 2
```

9.3.2 `index()`：查找元素的索引

使用 index(element) 方法返回指定元素在元组中的第一个匹配索引。如果元素不存在，会引发 ValueError。
```
numbers = (1, 2, 3, 4)
print(numbers.index(3))  # 输出 2
```

9.4 元组的不可变性（掌握）

元组的不可变性是其最重要的特性。元组一旦创建，元素就不能被修改、添加或删除。这一特性使元组在需要不可变数据时特别有用，例如作为函数返回多个值或将元组作为字典的键。

示例：

numbers = (1, 2, 3)
# numbers[0] = 10  # 会引发 TypeError，因为元组不可变

9.5 元组解包（掌握）

元组解包是一种将元组中的元素直接赋值给多个变量的方式，非常方便。

示例：

coordinates = (10, 20)
x, y = coordinates
print(x)  # 输出 10
print(y)  # 输出 20

应用场景：当一个函数返回多个值时，可以直接解包到多个变量中。

def get_point():
    return (5, 10)

x, y = get_point()
print(x, y)  # 输出 5 10

9.6 元组的嵌套（掌握）

元组可以包含其他元组，形成嵌套结构，适合表示多维数据或层级结构的数据。

示例：

nested_tuple = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
print(nested_tuple[1][2])   # 输出 6，访问第2行第3列

9.7 元组与列表的转换（掌握）

在 Python 中可以使用 tuple() 和 list() 进行元组与列表的相互转换，方便在需要可变或不可变数据时灵活切换。

列表转换为元组：

numbers_list = [1, 2, 3]
numbers_tuple = tuple(numbers_list)
print(numbers_tuple)        # 输出 (1, 2, 3)

元组转换为列表：

numbers_tuple = (1, 2, 3)
numbers_list = list(numbers_tuple)
print(numbers_list)         # 输出 [1, 2, 3]

9.8 元组的使用场景（掌握）

由于元组不可变，且比列表更高效，因此在以下场景中更适合使用元组：

多值返回：函数返回多个值时，可以将它们放在一个元组中。
字典键：元组可以作为字典的键（因为元组是不可变类型），而列表不行。
不需要修改的数据：当数据不需要修改时，用元组可以避免数据被意外改变，提高代码的安全性和可读性。

示例：函数返回多个值：

def get_person_info():
    name = "aini"
    age = 23
    return name, age  # 返回一个包含多个值的元组

info = get_person_info()
print(info)            # 输出 ('aini', 23)

9.9 元组的拷贝（了解）

元组的拷贝通常不需要特别处理，因为元组是不可变的，直接赋值就是拷贝。拷贝只是创建了新的引用，指向相同的内存地址。

示例：

original_tuple = (1, 2, 3)
copy_tuple = original_tuple
print(copy_tuple is original_tuple)   # 输出 True，两个变量指向相同对象

9.10 元组的优点和局限性（了解）

9.10.1 优点

不可变性：确保数据的安全性，不会被意外修改。
高效：因为不可变，元组的性能比列表略高，尤其是在迭代和存储方面。
适合作为键：可以作为字典的键，而列表不能。

9.10.2 局限性

不可变：无法修改、添加或删除元素。
方法少：元组只提供了 count() 和 index() 两个方法，功能相对有限。

10- 字典

10.1 字典的定义（掌握）

字典是一种无序的键值对集合，用于存储和查找数据。字典通过键（key）来访问值（value），键必须是唯一的且不可变的（通常为字符串或数字），而值可以是任意数据类型。字典使用大括号 {} 表示，键值对之间用逗号分隔，键和值之间用冒号分隔。

定义字典：

empty_dict = {}                                # 空字典
person = {"name": "aini", "age": 23, "city": "Shanghai"}  # 包含多个键值对的字典

10.2 字典的基本操作（掌握）

字典支持多种基本操作，如添加、修改、删除和访问键值对。

10.2.1 访问字典的值

使用键来访问字典中的值。如果键不存在会引发 KeyError，可以使用 get() 方法避免异常。

person = {"name": "aini", "age": 23}
print(person["name"])             # 输出 'aini'
print(person.get("age"))          # 输出 23
print(person.get("gender", "N/A"))  # 输出 'N/A'，若键不存在返回默认值

10.2.2 添加和修改键值对

如果键已存在，则修改该键的值；如果键不存在，则添加新的键值对。

person = {"name": "aini", "age": 23}
person["city"] = "Shanghai"       # 添加新的键值对
person["age"] = 24                # 修改已有键的值
print(person)                     # 输出 {'name': 'aini', 'age': 24, 'city': 'Shanghai'}

10.2.3 删除键值对

使用 del 语句或 pop() 方法删除指定的键值对。popitem() 方法可以随机删除字典中的最后一对键值。

person = {"name": "aini", "age": 23, "city": "Shanghai"}
del person["city"]                # 删除指定键
age = person.pop("age")           # 使用 pop() 获取并删除指定键
print(person)                     # 输出 {'name': 'aini'}
print(age)                        # 输出 23

10.2.4 检查键是否存在

使用 in 关键字检查键是否存在于字典中。

person = {"name": "aini", "age": 23}
print("name" in person)           # 输出 True
print("city" in person)           # 输出 False

10.3 字典的常用方法（掌握）

Python 提供了多种方法来操作字典，这些方法可以帮助我们进行遍历、更新和获取键值对等操作。

10.3.1 `keys()`：获取所有键

使用 keys() 方法返回字典中所有键的视图。

person = {"name": "aini", "age": 23}
print(person.keys())              # 输出 dict_keys(['name', 'age'])

10.3.2 `values()`：获取所有值

使用 values() 方法返回字典中所有值的视图。

person = {"name": "aini", "age": 23}
print(person.values())            # 输出 dict_values(['aini', 23])

10.3.3 `items()`：获取所有键值对

使用 items() 方法返回字典中所有键值对的视图，每个键值对以元组形式表示。

person = {"name": "aini", "age": 23}
print(person.items())             # 输出 dict_items([('name', 'aini'), ('age', 23)])

10.3.4 `update()`：更新字典

使用 update() 方法将另一个字典或键值对序列合并到当前字典中，若有重复键则更新值。

person = {"name": "aini", "age": 23}
additional_info = {"city": "Shanghai", "age": 24}
person.update(additional_info)
print(person)                     # 输出 {'name': 'aini', 'age': 24, 'city': 'Shanghai'}

10.3.5 `pop()` 和 `popitem()`：删除键值对

pop(key)：删除并返回指定键的值。

popitem()：随机删除并返回字典中的最后一个键值对（Python 3.7 以后为删除最后一对）。

person = {"name": "aini", "age": 23, "city": "Shanghai"}
age = person.pop("age")           # 删除并返回 'age' 的值
last_item = person.popitem()      # 随机删除并返回最后一个键值对
print(age)                        # 输出 23
print(last_item)                  # 输出 ('city', 'Shanghai')

10.3.6 `clear()`：清空字典

使用 clear() 方法删除字典中的所有键值对，将字典清空。

person = {"name": "aini", "age": 23}
person.clear()
print(person)                     # 输出 {}

10.4 字典的遍历（掌握）

字典遍历是字典操作中非常常见的一部分，通常用于处理每一个键值对。

遍历键：

person = {"name": "aini", "age": 23}
for key in person.keys():
    print(key)

遍历值：

for value in person.values():
    print(value)

遍历键值对：

for key, value in person.items():
    print(f"{key}: {value}")

10.5 字典的嵌套（掌握）

字典可以包含其他字典，形成嵌套结构，用于表示更复杂的数据关系。

示例：

student = {
    "name": "aini",
    "age": 23,
    "courses": {
        "math": 90,
        "science": 85
    }
}
print(student["courses"]["math"])  # 输出 90

10.6 字典生成式（掌握）

字典生成式（Dictionary Comprehension）是一种简洁的生成字典的方式，可以用一行代码创建一个新的字典，常用于数据处理和过滤。

基本语法：

{key_expr: value_expr for item in iterable if condition}

示例：

squares = {x: x**2 for x in range(1, 6)}
print(squares)                     # 输出 {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

10.7 字典的拷贝（了解）

字典的拷贝分为浅拷贝和深拷贝。

10.7.1 浅拷贝

浅拷贝只复制字典的第一层元素，嵌套的字典仍然是引用。

original = {"name": "aini", "courses": {"math": 90}}
shallow_copy = original.copy()
shallow_copy["courses"]["math"] = 100
print(original)                    # 输出 {'name': 'aini', 'courses': {'math': 100}}

10.7.2 深拷贝

深拷贝递归地复制所有层级的元素，使用 copy 模块中的 deepcopy() 实现。

import copy
original = {"name": "aini", "courses": {"math": 90}}
deep_copy = copy.deepcopy(original)
deep_copy["courses"]["math"] = 100
print(original)                    # 输出 {'name': 'aini', 'courses': {'math': 90}}

10.8 字典的使用场景（了解）

字典适合用于存储和查找数据的场景，尤其是在以下情况中：

数据映射：存储键值对关系，如用户信息、配置数据等。
计数：可以用字典来统计元素出现的频率。
多层数据结构：当需要存储多层数据时，字典嵌套是常用方式。

示例：计数应用：

words = ["apple", "banana", "apple", "cherry"]
word_count = {}
for word in words:
    word_count[word] = word_count.get(word, 0) + 1
print(word_count)                  # 输出 {'apple': 2, 'banana': 1, 'cherry': 1}

11- 集合

11.1 集合的定义（掌握）

集合是一个无序且不重复的元素集合。它通常用于去重、集合运算（交集、并集、差集等）等场景。集合使用大括号 {} 表示，或者通过 set() 函数创建（适用于空集合）。

定义集合：

empty_set = set()                    # 空集合，不能用 {} 创建空集合
fruits = {"apple", "banana", "cherry"}  # 包含多个元素的集合

11.2 集合的基本操作（掌握）

集合支持添加、删除和检查元素是否存在等基本操作。

11.2.1 添加元素

使用 add() 方法将元素添加到集合中，如果元素已存在则不会重复添加。

fruits = {"apple", "banana"}
fruits.add("cherry")
print(fruits)                      # 输出 {'apple', 'banana', 'cherry'}

11.2.2 删除元素

使用 remove() 方法删除指定元素，如果元素不存在会引发 KeyError。

使用 discard() 方法删除指定元素，如果元素不存在不会报错。

fruits = {"apple", "banana", "cherry"}
fruits.remove("banana")
fruits.discard("grape")            # 不会报错
print(fruits)                      # 输出 {'apple', 'cherry'}

11.2.3 检查元素是否存在

使用 in 关键字检查元素是否存在于集合中。

fruits = {"apple", "banana", "cherry"}
print("apple" in fruits)           # 输出 True
print("grape" in fruits)           # 输出 False

11.3 集合的常用方法（掌握）

集合提供了丰富的方法来进行集合运算，如交集、并集、差集等。

11.3.1 `union()` 和 `|`：并集

使用 union() 方法或 | 运算符获取两个集合的并集，返回一个新集合。

set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1.union(set2))            # 输出 {1, 2, 3, 4, 5}
print(set1 | set2)                 # 输出 {1, 2, 3, 4, 5}

11.3.2 `intersection()` 和 `&`：交集

使用 intersection() 方法或 & 运算符获取两个集合的交集，返回一个新集合。

set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1.intersection(set2))     # 输出 {3}
print(set1 & set2)                 # 输出 {3}

11.3.3 `difference()` 和 `-`：差集

使用 difference() 方法或 - 运算符获取集合的差集，返回一个新集合。

set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1.difference(set2))       # 输出 {1, 2}
print(set1 - set2)                 # 输出 {1, 2}

11.3.4 `symmetric_difference()` 和 `^`：对称差集

使用 symmetric_difference() 方法或 ^ 运算符获取集合的对称差集，即在任一集合中但不在两个集合中的元素。

set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1.symmetric_difference(set2))  # 输出 {1, 2, 4, 5}
print(set1 ^ set2)                     # 输出 {1, 2, 4, 5}

11.4 集合的更新操作（掌握）

集合的更新操作会将另一个集合中的元素添加到当前集合中，通常会直接改变原集合。

11.4.1 `update()` 和 `|=`：并集更新

使用 update() 方法或 |= 运算符将另一个集合的元素并入当前集合，直接修改原集合。

set1 = {1, 2, 3}
set2 = {3, 4, 5}
set1.update(set2)
print(set1)                         # 输出 {1, 2, 3, 4, 5}

11.4.2 `intersection_update()` 和 `&=`：交集更新

使用 intersection_update() 方法或 &= 运算符保留当前集合和另一个集合的交集，直接修改原集合。

set1 = {1, 2, 3}
set2 = {3, 4, 5}
set1.intersection_update(set2)
print(set1)                         # 输出 {3}

11.4.3 `difference_update()` 和 `-=`：差集更新

使用 difference_update() 方法或 -= 运算符从当前集合中删除与另一个集合的交集元素，直接修改原集合。

set1 = {1, 2, 3}
set2 = {3, 4, 5}
set1.difference_update(set2)
print(set1)                         # 输出 {1, 2}

11.4.4 `symmetric_difference_update()` 和 `^=`：对称差集更新

使用 symmetric_difference_update() 方法或 ^= 运算符保留当前集合和另一个集合的对称差集，直接修改原集合。

set1 = {1, 2, 3}
set2 = {3, 4, 5}
set1.symmetric_difference_update(set2)
print(set1)                         # 输出 {1, 2, 4, 5}

11.5 集合的遍历（掌握）

可以使用 for 循环遍历集合中的每一个元素。

示例：

fruits = {"apple", "banana", "cherry"}
for fruit in fruits:
    print(fruit)

11.6 集合生成式（掌握）

集合生成式（Set Comprehension）是一种简洁的生成集合的方式，可以用一行代码创建一个新的集合，常用于数据处理和过滤。

基本语法：

{表达式 for 变量 in 可迭代对象 if 条件}

示例：

squares = {x**2 for x in range(1, 6)}
print(squares)                      # 输出 {1, 4, 9, 16, 25}

11.7 集合的使用场景（了解）

集合主要用于去重和集合运算的场景，在以下情况中非常有用：

数据去重：可以快速删除重复元素。
集合运算：交集、并集、差集和对称差集等集合操作。
快速查找：集合中的查找操作的时间复杂度为 O(1)，比列表更快。

示例：去重应用：

numbers = [1, 2, 2, 3, 4, 4, 5]
unique_numbers = set(numbers)
print(unique_numbers)               # 输出 {1, 2, 3, 4, 5}

11.8 冻结集合（了解）

冻结集合（frozenset）是一种不可变集合，一旦创建就无法修改，类似于不可变的元组。冻结集合常用于需要不可变集合的场景，例如字典的键。

创建冻结集合：

frozen_fruits = frozenset(["apple", "banana", "cherry"])
# frozen_fruits.add("grape")  # 会引发 AttributeError，因为冻结集合不可修改
print(frozen_fruits)               # 输出 frozenset({'apple', 'banana', 'cherry'})

好的，下面将详细讲解 Python 中的 if 判断语句。if 语句用于根据条件执行不同的代码块，是编写控制流的重要工具。从基本语法、分支结构到嵌套和简写形式，将详细解释 if 判断的使用。知识点分为“掌握”和“了解”两类，序号从 12.1 开始。

12- if判断

12.1 `if` 语句的基本语法（掌握）

if 语句用于根据条件执行代码块，如果条件为 True，则执行 if 语句块中的代码；否则，跳过该代码块。if 语句的基本语法如下：

语法：
```
if 条件:
    代码块
```

示例：

age = 20
if age >= 18:
    print("成年人")  # 输出 "成年人"

在上面的代码中，当 age >= 18 条件为 True 时，打印 "成年人"。

12.2 `if-else` 语句（掌握）

if-else 语句用于根据条件执行两个代码块之一。如果条件为 True，执行 if 代码块；否则，执行 else 代码块。

语法：

if 条件:
    代码块1
else:
    代码块2

示例：

age = 16
if age >= 18:
    print("成年人")
else:
    print("未成年人")  # 输出 "未成年人"

在上面的代码中，当 age < 18 时，else 代码块中的内容会被执行。

12.3 `if-elif-else` 语句（掌握）

if-elif-else 语句用于处理多重条件判断。如果第一个条件为 False，则检查下一个条件，以此类推。可以包含多个 elif，但 else 语句只能有一个，并且是可选的。

语法：

if 条件1:
    代码块1
elif 条件2:
    代码块2
elif 条件3:
    代码块3
else:
    代码块4

示例：

score = 85
if score >= 90:
    print("优秀")
elif score >= 75:
    print("良好")  # 输出 "良好"
elif score >= 60:
    print("及格")
else:
    print("不及格")

在上面的代码中，程序会从上到下依次判断条件，直到找到第一个满足条件的代码块。

12.4 嵌套的 `if` 语句（掌握）

if 语句可以嵌套在另一个 if 语句中，用于处理更复杂的逻辑。但嵌套层次不宜过深，以避免代码难以阅读。

语法：

if 条件1:
    if 条件2:
        代码块1
    else:
        代码块2
else:
    代码块3

示例：

age = 20
has_id = True
if age >= 18:
    if has_id:
        print("允许进入")  # 输出 "允许进入"
    else:
        print("需要身份证")
else:
    print("未成年人禁止进入")

在上面的代码中，当 age >= 18 且 has_id 为 True 时，执行 "允许进入"。

12.5 单行 `if` 表达式（掌握）

在一些简单的条件判断中，可以使用单行 if 表达式，将 if 和 else 的执行代码写在同一行。

语法：
```
代码块1 if 条件 else 代码块2
```

示例：

age = 20
result = "成年人" if age >= 18 else "未成年人"
print(result)  # 输出 "成年人"

在上面的代码中，if 表达式用于根据 age 的值返回不同的结果。

12.6 多条件判断（掌握）

在 if 语句中，可以使用逻辑运算符 and 和 or 实现多条件判断。

12.6.1 `and` 运算符

and 运算符：当所有条件为 True 时，返回 True，否则返回 False。

age = 20
has_id = True
if age >= 18 and has_id:
    print("允许进入")  # 输出 "允许进入"

12.6.2 `or` 运算符

or 运算符：当至少一个条件为 True 时，返回 True，否则返回 False。

age = 16
has_permission = True
if age >= 18 or has_permission:
    print("允许进入")  # 输出 "允许进入"

在多条件判断中，合理使用 and 和 or 可以更精确地控制代码逻辑。

12.7 `if` 判断的注意事项（了解）

在编写 if 判断时，有一些常见的注意事项，以避免代码错误或逻辑漏洞。

12.7.1 比较运算符的使用

确保使用正确的比较运算符（如 ==、!=、<、> 等）进行条件判断。错误的运算符可能导致逻辑错误。

12.7.2 避免过深的嵌套

尽量避免过深的 if 嵌套，层级过多会影响代码的可读性和维护性。可以使用 elif 或提前返回等方式优化嵌套结构。

12.7.3 注意缩进

Python 使用缩进来标识代码块，因此 if 判断中的代码块需要保持一致的缩进。缩进错误会导致 IndentationError。

12.7.4 判断值的布尔性

在 if 判断中，可以直接使用变量名或表达式来检查其布尔性。例如，if my_list: 检查列表是否为空。
```
my_list = [1, 2, 3]
if my_list:
    print("列表不为空")
else:
    print("列表为空")
```

12.8 综合示例（掌握）

通过一个综合示例来展示 if 判断在实际代码中的应用。

示例：根据用户输入的年龄，判断他们的分类：

age = int(input("请输入你的年龄: "))

if age < 12:
    print("儿童")
elif 12 <= age < 18:
    print("青少年")
elif 18 <= age < 65:
    print("成年人")
else:
    print("老年人")

在这个示例中，用户输入年龄，程序会根据不同的条件打印相应的分类。

13- for循环

13.1 `for` 循环的基本语法（掌握）

for 循环用于从一个可迭代对象中逐一提取元素，并在循环体中对每个元素执行操作。基本语法如下：

语法：

for 变量 in 可迭代对象:
    代码块

示例：
```
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)
```
在上面的示例中，for 循环依次提取 fruits 列表中的每一个元素，并打印出来。

13.2 使用 `range()` 函数进行数值循环（掌握）

range() 函数用于生成一系列数字，常用于指定循环的次数，生成的数字序列为左闭右开区间 [start, stop)。

13.2.1 基本用法

语法：

range(stop)
range(start, stop)
range(start, stop, step)

示例：

# 从0到4的序列
for i in range(5):
    print(i)  # 输出 0, 1, 2, 3, 4

# 从2到6的序列
for i in range(2, 7):
    print(i)  # 输出 2, 3, 4, 5, 6

# 从1到9，每隔2步
for i in range(1, 10, 2):
    print(i)  # 输出 1, 3, 5, 7, 9

13.3 遍历字符串（掌握）

字符串是一个字符序列，可以直接使用 for 循环逐个访问其中的字符。

示例：
```
text = "Python"
for char in text:
    print(char)
```
在上面的代码中，for 循环逐个访问字符串 text 中的每一个字符并打印。

13.4 遍历列表和元组（掌握）

列表和元组都是可迭代对象，可以使用 for 循环逐个访问它们的元素。

示例：

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    print(num)

元组遍历示例：

items = (10, 20, 30)
for item in items:
    print(item)

13.5 遍历字典（掌握）

字典是键值对的集合，可以使用 for 循环来遍历键、值或键值对。

13.5.1 遍历键

示例：

person = {"name": "aini", "age": 23}
for key in person:
    print(key)  # 输出 "name" 和 "age"

13.5.2 遍历值

示例：

for value in person.values():
    print(value)  # 输出 "aini" 和 23

13.5.3 遍历键值对

示例：

for key, value in person.items():
    print(f"{key}: {value}")  # 输出 "name: aini" 和 "age: 23"

13.6 嵌套的 `for` 循环（掌握）

在 for 循环内部可以嵌套另一个 for 循环，通常用于处理二维数据结构（如列表嵌套列表）。

示例：

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
for row in matrix:
    for element in row:
        print(element, end=" ")  # 输出 1 2 3 4 5 6 7 8 9
    print()  # 换行

在上面的代码中，外层循环遍历每一行，内层循环遍历每行中的每一个元素。

13.7 使用 `enumerate()` 函数获取索引和元素（掌握）

enumerate() 函数用于在 for 循环中同时获取元素的索引和元素本身，适合在遍历时需要索引的场景。

示例：

fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

输出：

0: apple
1: banana
2: cherry

13.8 使用 `zip()` 函数并行遍历多个列表（掌握）

zip() 函数用于将多个可迭代对象组合成一个迭代器，以便在 for 循环中并行遍历多个序列。

示例：

names = ["aini", "zhang", "li"]
ages = [23, 25, 30]
for name, age in zip(names, ages):
    print(f"{name} is {age} years old.")

输出：

aini is 23 years old.
zhang is 25 years old.
li is 30 years old.

13.9 列表生成式中的 `for` 循环（掌握）

列表生成式（List Comprehension）是一种简洁的生成列表的方法，通常用来将 for 循环和条件判断结合起来生成新的列表。

基本语法：

[表达式 for 变量 in 可迭代对象 if 条件]

示例：

squares = [x**2 for x in range(1, 6)]
print(squares)  # 输出 [1, 4, 9, 16, 25]

13.10 `for-else` 语句（了解）

for-else 语句中的 else 块会在 for 循环正常完成后执行，如果循环被 break 语句提前终止，则不执行 else 块。该语句结构相对少用。

示例：

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num == 3:
        print("Found 3!")
        break
else:
    print("3 not found.")

在上面的代码中，for 循环因 break 终止，else 块不会执行。

13.11 `for` 循环的注意事项（了解）

在编写 for 循环时，有一些常见的注意事项，以避免逻辑错误或效率低下：

避免修改可迭代对象：在 for 循环中修改正在迭代的对象（如添加或删除元素）可能导致循环行为异常。
合理使用 range() 和 enumerate()：当需要索引时使用 enumerate()，避免手动维护索引。
避免嵌套过深：多层嵌套会导致代码复杂且难以维护，尽量优化循环结构。

14- while循环

14.1 `while` 循环的基本语法（掌握）

while 循环在指定条件为 True 时不断重复执行代码块，直到条件为 False 时结束循环。while 循环的语法结构如下：

语法：
```
while 条件:
    代码块
```
示例：
```
count = 1
while count <= 5:
    print(count)
    count += 1
```
输出：
```
1
2
3
4
5
```
在上面的代码中，while 循环会在 count <= 5 为 True 时执行，直到 count 增加到 6，条件变为 False 时终止循环。

14.2 无限循环（掌握）

如果 while 循环的条件一直为 True，则会形成无限循环。在某些情况下，程序需要一直运行直到满足特定的退出条件。

示例：

while True:
    user_input = input("请输入 'exit' 退出: ")
    if user_input == "exit":
        break

在上面的代码中，程序会一直运行，直到用户输入 "exit" 时，通过 break 退出循环。

14.3 使用 `break` 和 `continue` 控制循环（掌握）

break 和 continue 是控制循环的两个关键字，可以用来在特定条件下中断或跳过循环的执行。

14.3.1 `break`：中断循环

break 用于立即退出循环，不再执行循环体的剩余部分。
```
count = 1
while count <= 5:
    if count == 3:
        break
    print(count)
    count += 1
```
输出：
```
1
2
```
在上面的代码中，当 count 为 3 时，break 语句会中断循环。

14.3.2 `continue`：跳过本次循环

continue 用于跳过当前循环的剩余部分，立即开始下一次循环。
```
count = 0
while count < 5:
    count += 1
    if count == 3:
        continue
    print(count)
```
输出：
```
1
2
4
5
```
在上面的代码中，当 count 为 3 时，continue 会跳过本次循环的剩余部分。

14.4 `while-else` 语句（了解）

while-else 语句中的 else 块会在 while 循环正常完成后执行，如果循环被 break 语句提前终止，则不会执行 else 块。

示例：

count = 1
while count <= 3:
    print(count)
    count += 1
else:
    print("循环结束")

输出：

1
2
3
循环结束

在上面的代码中，当 while 循环正常结束时，else 块会被执行。

14.5 使用 `while` 循环处理用户输入（掌握）

while 循环常用于处理用户输入，直到用户输入有效的内容为止。

示例：

while True:
    user_input = input("请输入一个数字 (输入 'exit' 退出): ")
    if user_input == "exit":
        print("退出程序")
        break
    elif user_input.isdigit():
        print(f"您输入的数字是 {user_input}")
    else:
        print("无效输入，请输入数字")

在上面的代码中，while 循环不断询问用户输入数字，直到用户输入 "exit" 时退出程序。

14.6 `while` 循环中的计数器（掌握）

使用 while 循环时，经常需要设置计数器来控制循环次数，计数器通常会在每次循环结束后递增或递减。

示例：

count = 0
while count < 5:
    print("当前计数:", count)
    count += 1

输出：

当前计数: 0
当前计数: 1
当前计数: 2
当前计数: 3
当前计数: 4

在上面的代码中，count 是计数器，控制 while 循环的次数。

14.7 嵌套的 `while` 循环（了解）

while 循环可以嵌套在另一个 while 循环中，用于处理多层循环结构。

示例：

outer = 1
while outer <= 3:
    inner = 1
    while inner <= 2:
        print(f"外层: {outer}, 内层: {inner}")
        inner += 1
    outer += 1

输出：

外层: 1, 内层: 1
外层: 1, 内层: 2
外层: 2, 内层: 1
外层: 2, 内层: 2
外层: 3, 内层: 1
外层: 3, 内层: 2

在上面的代码中，外层 while 控制 outer 计数，内层 while 控制 inner 计数。

14.8 `while` 循环的注意事项（了解）

在编写 while 循环时，有一些常见的注意事项，以避免代码运行出错或陷入死循环。

避免死循环：确保循环条件最终会变为 False，否则可能导致死循环，程序无法退出。
计数器控制：使用计数器时，记得在每次循环中更新计数器的值，否则可能造成无限循环。
合理使用 break 和 continue：break 和 continue 能提高循环的灵活性，但要避免滥用，以免影响代码的可读性。

15- for循环和while循环比较

15.1 基本区别（掌握）

for 循环：用于遍历可迭代对象（如列表、元组、字符串、字典、集合等）中的每一个元素，通常适用于明确知道迭代次数的场景。
while 循环：在条件为 True 时不断执行代码块，适用于不确定迭代次数的场景，直到某一条件满足才结束循环。

15.2 语法结构对比（掌握）

`for` 循环的基本语法

for 变量 in 可迭代对象:
    代码块

`while` 循环的基本语法

while 条件:
    代码块

15.3 使用场景（掌握）

`for` 循环的适用场景

遍历已知长度的可迭代对象：如列表、字符串、元组等，直接遍历元素。
需要计数的循环：可以与 range() 配合，执行固定次数的循环。
生成列表：列表生成式通常使用 for 循环生成。

`while` 循环的适用场景

条件控制的循环：在满足条件时重复执行代码，而不是固定次数。
用户输入验证：不断检查输入，直到符合要求为止。
无限循环：在服务器或实时监控中常见，通过 while True 持续执行，直到满足某个终止条件。

15.4 优缺点比较（掌握）

特性	`for` 循环	`while` 循环
适用情况	明确的迭代次数或固定的序列	不确定的迭代次数，基于条件的循环
可读性	代码简洁明了，适合处理序列	适合动态条件的循环，但逻辑略复杂
灵活性	依赖可迭代对象或 `range` 控制次数	可处理任意复杂的条件
效率	更适合于遍历对象，代码效率高	适合条件控制，可能会陷入死循环

15.5 `for` 和 `while` 循环的替换（掌握）

在某些情况下，for 和 while 循环可以相互替换：

15.5.1 使用 `while` 循环模拟 `for` 循环

示例：用 while 模拟一个固定次数的循环。

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

等价于：

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

15.5.2 使用 `for` 循环模拟简单的条件控制

虽然 for 循环并不直接适用于条件控制，但可以通过遍历 itertools.cycle 实现无限循环，并在循环体中条件判断以 break 退出。

from itertools import cycle

for _ in cycle([None]):
    user_input = input("请输入 'exit' 退出: ")
    if user_input == "exit":
        break

15.6 示例对比（掌握）

示例 1：遍历列表

for 循环：

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

while 循环：

fruits = ["apple", "banana", "cherry"]
i = 0
while i < len(fruits):
    print(fruits[i])
    i += 1

示例 2：条件控制的循环

for 循环（通过 break 终止）：

for _ in range(100):  # 实际上是人为限定了次数
    user_input = input("请输入 'exit' 退出: ")
    if user_input == "exit":
        break

while 循环：

while True:
    user_input = input("请输入 'exit' 退出: ")
    if user_input == "exit":
        break

15.7 循环的嵌套使用（了解）

for 和 while 循环可以嵌套使用，适合处理多层数据结构或条件复杂的情况。

示例：遍历二维列表中的元素，并根据条件判断是否打印

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
for row in matrix:
    for element in row:
        if element % 2 == 0:
            print(element)

在这个示例中，for 循环用于遍历列表，而条件判断和打印操作可以在嵌套循环中控制。

15.8 优先选择哪种循环（掌握）

选择 for 循环：当明确知道迭代次数或需要遍历可迭代对象时，优先选择 for 循环。它的结构清晰、代码简洁。
选择 while 循环：当循环次数不确定或需要条件控制时，选择 while 循环。它在处理需要灵活控制结束条件的场景中更合适。

16- 循环综合练习题

1. 输出 1 到 10 的所有数字

思路：使用 for 循环遍历从 1 到 10 的范围，逐个输出数字。

for i in range(1, 11):
    print(i)  # 输出 1 到 10 的数字

2. 计算 1 到 100 的和

思路：使用 for 循环遍历 1 到 100，将每个数累加到一个变量中。

total = 0
for i in range(1, 101):
    total += i  # 每次循环累加当前数到总和中
print("1到100的和为:", total)

3. 输出列表中的所有元素

思路：使用 for 循环遍历列表，并打印每个元素。

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)  # 输出每个水果的名字

4. 打印 1 到 50 中所有的偶数

思路：使用 for 循环遍历 1 到 50，检查每个数是否为偶数，是偶数则输出。

for i in range(1, 51):
    if i % 2 == 0:  # 如果数是偶数
        print(i)  # 输出偶数

5. 计算一个列表中所有数字的和

思路：遍历列表中的每个数字，并累加到一个变量中。

numbers = [10, 20, 30, 40]
total = 0
for num in numbers:
    total += num  # 累加每个数到总和
print("列表中所有数字的和为:", total)

6. 找到列表中最大值

思路：初始化最大值为第一个元素，然后遍历列表，逐个比较并更新最大值。

numbers = [3, 5, 7, 2, 8]
max_num = numbers[0]  # 假设第一个数为最大值
for num in numbers:
    if num > max_num:
        max_num = num  # 更新最大值
print("列表中的最大值是:", max_num)

7. 打印九九乘法表

思路：使用嵌套的 for 循环，外层循环控制乘数 1 到 9，内层循环控制被乘数 1 到 9。

for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j} * {i} = {i * j}", end="  ")  # 打印乘法表
    print()  # 换行

8. 反转一个字符串

思路：使用 for 循环从字符串末尾开始逐个字符提取，并累加到新字符串中。

text = "hello"
reversed_text = ""
for char in text[::-1]:  # 从末尾到开头遍历字符
    reversed_text += char
print("反转后的字符串为:", reversed_text)

9. 统计列表中正数的个数

思路：遍历列表，检查每个数字是否为正数，是则计数加一。

numbers = [-5, 3, 8, -2, 6]
count = 0
for num in numbers:
    if num > 0:
        count += 1  # 计数加一
print("列表中正数的个数为:", count)

10. 找到两个列表的交集

思路：使用 for 循环遍历第一个列表，检查是否在第二个列表中。

list1 = [1, 2, 3, 4]
list2 = [3, 4, 5, 6]
intersection = []
for item in list1:
    if item in list2:
        intersection.append(item)
print("两个列表的交集为:", intersection)

11. 输出一个列表中所有非零元素

思路：遍历列表，检查每个元素是否不为零，不为零则输出。

numbers = [0, 5, 3, 0, 8]
for num in numbers:
    if num != 0:
        print(num)  # 输出非零元素

12. 打印一个字符串中所有的字母

思路：遍历字符串，检查每个字符是否为字母，如果是则打印。

text = "Hello123"
for char in text:
    if char.isalpha():  # 检查是否是字母
        print(char)

13. 计算一个数的阶乘

思路：使用 for 循环从 1 到 n，逐个相乘计算阶乘。

n = 5
factorial = 1
for i in range(1, n + 1):
    factorial *= i
print(f"{n} 的阶乘是:", factorial)

14. 打印一个列表中的奇数位置元素

思路：使用 for 循环结合 range()，遍历奇数位置索引的元素。

numbers = [10, 20, 30, 40, 50]
for i in range(1, len(numbers), 2):
    print(numbers[i])  # 输出奇数位置的元素

15. 求出 1 到 50 的所有数的平方和

思路：使用 for 循环遍历 1 到 50，将每个数的平方累加到总和中。

total = 0
for i in range(1, 51):
    total += i ** 2  # 累加平方
print("1到50的平方和为:", total)

16. 输出一个字符串中所有的数字

思路：使用 for 循环遍历字符串，检查每个字符是否为数字，是则输出。

text = "abc123def456"
for char in text:
    if char.isdigit():  # 检查是否是数字
        print(char)

17. 打印出所有质数（2 到 50）

思路：使用嵌套循环，外层遍历 2 到 50，内层检查每个数是否有除 1 和自身之外的因数。

for num in range(2, 51):
    is_prime = True
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            is_prime = False
            break
    if is_prime:
        print(num)

18. 找到列表中最小值

思路：假设第一个元素为最小值，遍历比较更新。

numbers = [4, 2, 9, 1, 5]
min_num = numbers[0]
for num in numbers:
    if num < min_num:
        min_num = num
print("列表中的最小值为:", min_num)

19. 判断一个字符串是否是回文

思路：检查字符串是否与反转后的字符串相同。

text = "level"
is_palindrome = text == text[::-1]
print(f"{text} 是回文" if is_palindrome else f"{text} 不是回文")

20. 计算一个字符串中每个字符的出现次数

思路：使用字典存储字符和对应出现次数。

text = "hello world"
count_dict = {}
for char in text:
    count_dict[char] = count_dict.get(char, 0) + 1
print("每个字符的出现次数为:", count_dict)

17- 循环判断练习题（较难）

10.1 判断素数

题目描述

编写一个程序，判断用户输入的一个正整数是否为素数。

解题思路

输入一个正整数。
使用循环判断从2到该数的平方根是否有整除的数。

代码详解

num = int(input("请输入一个正整数: "))
is_prime = True
if num < 2:
    is_prime = False
else:
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            is_prime = False
            break

if is_prime:
    print(f"{num} 是素数")
else:
    print(f"{num} 不是素数")

10.2 打印斐波那契数列

题目描述

编写一个程序，输出斐波那契数列的前n项，n由用户输入。

解题思路

使用循环生成斐波那契数列。

代码详解

n = int(input("请输入要输出的斐波那契数列项数: "))
a, b = 0, 1
fib_seq = []
for _ in range(n):
    fib_seq.append(a)
    a, b = b, a + b
print(fib_seq)

10.3 冒泡排序

题目描述

实现一个冒泡排序算法，要求用户输入一组整数，然后输出排序后的结果。

解题思路

使用嵌套循环比较相邻元素。

代码详解

arr = list(map(int, input("请输入一组整数，用空格分隔: ").split()))
n = len(arr)
for i in range(n):
    for j in range(0, n - i - 1):
        if arr[j] > arr[j + 1]:
            arr[j], arr[j + 1] = arr[j + 1], arr[j]
print("排序后的数组:", arr)

10.4 统计字符频率

题目描述

编写程序，统计输入字符串中每个字符出现的频率，并输出结果。

解题思路

使用字典存储字符和其频率。

代码详解

input_string = input("请输入字符串: ")
freq = {}
for char in input_string:
    freq[char] = freq.get(char, 0) + 1
print("字符频率:", freq)

10.5 查找最大子序列和

题目描述

给定一个整数数组，编写程序找出具有最大和的连续子序列。

解题思路

使用动态规划维护当前的子序列和和最大子序列和。

代码详解

array = list(map(int, input("请输入整数数组，用空格分隔: ").split()))
max_sum = float('-inf')
current_sum = 0
for num in array:
    current_sum += num
    if current_sum > max_sum:
        max_sum = current_sum
    if current_sum < 0:
        current_sum = 0
print("最大子序列和:", max_sum)

10.6 查找重复元素

题目描述

编写程序，找出输入列表中所有重复的元素。

解题思路

使用集合存储已见过的元素。

代码详解

input_list = list(map(int, input("请输入整数列表，用空格分隔: ").split()))
seen = set()
duplicates = set()
for num in input_list:
    if num in seen:
        duplicates.add(num)
    else:
        seen.add(num)
print("重复的元素:", duplicates)

10.7 计算阶乘

题目描述

编写程序，计算一个正整数的阶乘。

解题思路

使用循环从1乘到n。

代码详解

num = int(input("请输入一个正整数: "))
result = 1
for i in range(1, num + 1):
    result *= i
print("阶乘是:", result)

10.8 查找数组中第K大的元素

题目描述

编写程序，找出数组中第K大的元素。

解题思路

使用排序的方法，先对数组进行排序。

代码详解

array = list(map(int, input("请输入整数数组，用空格分隔: ").split()))
k = int(input("请输入K值: "))
unique_elements = list(set(array))
unique_elements.sort(reverse=True)
print(f"数组中第{k}大的元素是: {unique_elements[k - 1]}")

10.9 验证回文数

题目描述

编写程序，判断一个字符串是否为回文。

解题思路

比较字符串的前后字符。

代码详解

input_string = input("请输入字符串: ")
is_palindrome = True
length = len(input_string)
for i in range(length // 2):
    if input_string[i] != input_string[length - 1 - i]:
        is_palindrome = False
        break

if is_palindrome:
    print(f"{input_string} 是回文")
else:
    print(f"{input_string} 不是回文")

10.10 爬楼梯问题

题目描述

假设每次可以爬1阶或2阶，编写程序计算爬到n阶的不同方式数。

解题思路

使用动态规划的思想。

代码详解

n = int(input("请输入楼梯的阶数: "))
if n == 1:
    print("不同的爬楼梯方式数: 1")
elif n == 2:
    print("不同的爬楼梯方式数: 2")
else:
    dp = [0] * (n + 1)
    dp[1], dp[2] = 1, 2
    for i in range(3, n + 1):
        dp[i] = dp[i - 1] + dp[i - 2]
    print("不同的爬楼梯方式数:", dp[n])

18- 函数

18.1 函数的定义（掌握）

函数是一个可重用的代码块，用于执行特定的任务。函数可以接收输入参数并返回结果，帮助我们组织代码并提高可读性和可维护性。

定义函数的基本语法：

def function_name(parameters):
    """可选的文档字符串"""
    # 函数体
    return result  # 可选的返回值

示例：

def greet(name):
    """打印问候信息"""
    print(f"Hello, {name}!")

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

18.2 函数的调用（掌握）

函数定义后可以通过调用来执行。函数调用可以传递参数，调用函数时参数的顺序要与定义时一致。

示例：

def add(a, b):
    """返回两个数的和"""
    return a + b

result = add(5, 3)  # 调用函数，传递参数
print(result)       # 输出: 8

18.3 函数的参数（掌握）

函数可以接收参数，参数是函数外部传入的值，函数内部可以使用这些值。

18.3.1 位置参数

定义和调用：

def multiply(x, y):
    return x * y

print(multiply(2, 3))  # 输出: 6

18.3.2 默认参数

定义默认参数：在定义函数时，可以为参数指定默认值，调用时可以选择性传入参数。

def power(base, exponent=2):
    return base ** exponent

print(power(3))        # 输出: 9 (使用默认 exponent)
print(power(3, 3))     # 输出: 27 (覆盖默认 exponent)

18.3.3 可变参数

使用 *args 和 **kwargs：*args 用于传入任意数量的位置参数，**kwargs 用于传入任意数量的关键字参数。

def sum_all(*args):
    return sum(args)

print(sum_all(1, 2, 3, 4))  # 输出: 10

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

print_info(name="Alice", age=30)  # 输出: name: Alice, age: 30

18.4 函数的返回值（掌握）

函数可以返回结果，使用 return 语句指定返回值。如果没有 return，函数将返回 None。

示例：

def square(n):
    return n * n

result = square(4)
print(result)  # 输出: 16

18.4.1 多个返回值

返回多个值：可以使用逗号分隔多个值。

def divide(a, b):
    return a // b, a % b  # 返回商和余数

quotient, remainder = divide(10, 3)
print(quotient, remainder)  # 输出: 3 1

18.5 函数的文档字符串（掌握）

文档字符串（docstring）是函数定义中的字符串，用于描述函数的功能。文档字符串通常是函数的第一行，可以通过 help() 函数查看。

示例：

def subtract(a, b):
    """返回 a 和 b 的差值"""
    return a - b

print(help(subtract))  # 查看文档字符串

18.6 函数的作用域（掌握）

变量的作用域决定了其可见性和生命周期。在 Python 中，变量有局部作用域和全局作用域。

18.6.1 局部变量

在函数内定义的变量：只在函数内有效，外部无法访问。

def func():
    local_var = 10  # 局部变量
    print(local_var)

func()
# print(local_var)  # 会引发 NameError

18.6.2 全局变量

在函数外定义的变量：可以在整个程序中访问。

global_var = 20  # 全局变量

def func():
    print(global_var)  # 可以访问全局变量

func()  # 输出: 20

18.6.3 使用 `global` 关键字

在函数内部修改全局变量：可以使用 global 关键字声明。

global_var = 30

def modify_global():
    global global_var  # 声明使用全局变量
    global_var += 10

modify_global()
print(global_var)  # 输出: 40

18.7 高阶函数（掌握）

高阶函数是指接受函数作为参数或返回一个函数的函数。在 Python 中，函数是第一类对象，可以作为参数传递。

18.7.1 函数作为参数

示例：

def apply_function(func, value):
    return func(value)

def square(n):
    return n * n

result = apply_function(square, 5)
print(result)  # 输出: 25

18.7.2 返回函数

示例：

def outer_function(msg):
    def inner_function():
        print(msg)
    return inner_function  # 返回内嵌函数

my_func = outer_function("Hello, World!")
my_func()  # 输出: Hello, World!

18.8 匿名函数（了解）

匿名函数（lambda 函数）是一种没有名字的函数，通常用于需要小型函数的场景，如在 map()、filter() 和 sorted() 等函数中使用。

示例：

square = lambda x: x * x
print(square(5))  # 输出: 25

# 使用 map() 函数
numbers = [1, 2, 3, 4]
squares = list(map(lambda x: x ** 2, numbers))
print(squares)  # 输出: [1, 4, 9, 16]

19- 全局变量和局部变量

19.1 变量的作用域（掌握）

在编程中，作用域指的是变量可以被访问的范围。在 Python 中，变量的作用域分为局部作用域和全局作用域。

局部作用域（Local Scope）：在函数内部定义的变量，只能在该函数内部使用，函数外部无法访问这些变量。
全局作用域（Global Scope）：在整个程序中定义的变量，通常位于函数外部，可以在程序的任何位置访问。

19.2 局部变量（掌握）

局部变量是在函数内部定义的变量。它的作用范围仅限于该函数，函数外部无法访问这个变量。局部变量的生命周期在函数执行期间，当函数执行完毕，局部变量也随之销毁。

19.2.1 局部变量的定义和访问

定义：在函数内部直接赋值给变量即定义了局部变量。
访问：只能在定义它的函数内部访问。

示例：

def my_function():
    local_var = 10  # 局部变量
    print("局部变量:", local_var)

my_function()  # 输出: 局部变量: 10

# print(local_var)  # 会引发 NameError，因为函数外无法访问 local_var

在上面的示例中，local_var 是 my_function() 函数内部的局部变量，它只能在该函数内部使用。函数外部无法访问 local_var，否则会引发 NameError。

19.2.2 局部变量的优先级

在函数内部，如果局部变量和全局变量同名，局部变量会优先被使用。局部变量的优先级高于同名的全局变量。

示例：

x = 5  # 全局变量

def my_function():
    x = 10  # 局部变量
    print("函数内部的 x:", x)  # 输出: 函数内部的 x: 10

my_function()
print("函数外部的 x:", x)      # 输出: 函数外部的 x: 5

在这个示例中，虽然 x 在函数外部被定义为全局变量，但在 my_function() 中重新定义了一个同名的局部变量 x，因此在函数内部会使用局部变量，而不会影响函数外部的全局变量。

19.3 全局变量（掌握）

全局变量是在函数外部定义的变量。全局变量可以在整个程序的任何地方访问，包括函数内部和外部。全局变量的生命周期贯穿程序的执行过程。

19.3.1 全局变量的定义和访问

定义：在函数外部直接赋值给变量。
访问：可以在函数内部和外部访问。

示例：

global_var = 20  # 全局变量

def my_function():
    print("函数内部的全局变量:", global_var)

my_function()  # 输出: 函数内部的全局变量: 20
print("函数外部的全局变量:", global_var)  # 输出: 函数外部的全局变量: 20

在这个示例中，global_var 是一个全局变量，既可以在 my_function() 函数内访问，也可以在函数外部访问。

19.3.2 使用 `global` 关键字修改全局变量

在函数内部，可以通过 global 关键字声明一个变量为全局变量，从而修改该全局变量的值。

示例：

count = 0  # 全局变量

def increment():
    global count  # 声明使用全局变量
    count += 1    # 修改全局变量

increment()
print("全局变量 count 的值:", count)  # 输出: 全局变量 count 的值: 1

在这个示例中，通过 global count 声明 count 为全局变量，从而可以在 increment() 函数中修改 count 的值。

19.3.3 不使用 `global` 的情况下

如果没有使用 global 关键字直接在函数内部赋值同名变量，Python 会将该变量视为局部变量，不会影响同名的全局变量。

示例：

total = 100  # 全局变量

def reset_total():
    total = 0  # 局部变量，不会影响全局的 total
    print("函数内部的 total:", total)  # 输出: 函数内部的 total: 0

reset_total()
print("全局的 total:", total)  # 输出: 全局的 total: 100

在这个示例中，函数 reset_total() 中定义的 total 是一个局部变量，并不会影响函数外部的全局变量 total。

19.4 全局变量和局部变量的注意事项（掌握）

避免过度使用全局变量：全局变量在程序的任何地方都可以被修改，可能会导致意外错误。通常建议使用局部变量，除非确有必要才使用全局变量。
global 的使用：如果需要在函数内部修改全局变量，必须使用 global 关键字，否则 Python 会默认将其视为局部变量。
变量的生命周期：全局变量在程序运行期间始终存在，而局部变量只在函数执行期间有效，函数执行结束后局部变量会被销毁。
命名冲突：避免在局部作用域中定义与全局变量同名的变量，以免造成混淆。
可读性问题：过多的全局变量会降低代码的可读性和可维护性，增加调试难度。

19.5 全局变量和局部变量的综合示例（掌握）

以下是一个综合示例，展示全局变量、局部变量和 global 关键字的使用场景。

示例：

balance = 1000  # 全局变量，初始余额

def deposit(amount):
    """存款操作"""
    global balance  # 声明 balance 为全局变量
    balance += amount  # 修改全局变量
    print(f"存款 {amount} 元，当前余额：{balance}")

def withdraw(amount):
    """取款操作"""
    if amount > balance:
        print("余额不足")
    else:
        global balance
        balance -= amount
        print(f"取款 {amount} 元，当前余额：{balance}")

def check_balance():
    """查询余额"""
    print(f"当前余额为：{balance}")

# 操作示例
deposit(500)      # 存款 500 元
withdraw(200)     # 取款 200 元
check_balance()   # 查询余额

在这个示例中，balance 是一个全局变量，用于记录账户余额。deposit()、withdraw() 和 check_balance() 是三个函数，分别用于存款、取款和查询余额。deposit() 和 withdraw() 函数通过 global 关键字来声明 balance 为全局变量，从而可以在函数内部修改全局变量 balance 的值。

20- 综合案例

1. 寻找满足条件的数字“自反数”

题目：定义自反数：一个整数 n 满足以下条件时称为自反数：

n 是一个四位数。
n 可以被 4 整除。
n 的数位的平方和等于 n 自身。

请编写一个函数 is_autoreflective(num) 来判断一个数是否为自反数，并找出 1000 到 9999 之间的所有自反数。

思路分析：

使用嵌套循环提取各位数字。
检查是否为四位数、可被 4 整除、并且数位平方和等于数本身。
使用 is_autoreflective 函数检查数字条件，在主程序中遍历范围并输出。

代码详解：

def is_autoreflective(num):
    """判断一个数是否为自反数"""
    if num % 4 != 0:
        return False
    thousands = num // 1000
    hundreds = (num // 100) % 10
    tens = (num // 10) % 10
    units = num % 10
    return (thousands**2 + hundreds**2 + tens**2 + units**2) == num

# 找出所有自反数
autoreflective_numbers = []
for i in range(1000, 10000):
    if is_autoreflective(i):
        autoreflective_numbers.append(i)

print("所有自反数为：", autoreflective_numbers)

2. 判断“亲密素数对”

题目：定义亲密素数对：如果两个素数之差等于 2，则称它们为亲密素数对。例如 (3, 5) 和 (11, 13) 是亲密素数对。编写函数 is_prime(num) 判断一个数是否为素数，找到 1 到 100 之间的所有亲密素数对。

思路分析：

编写 is_prime(num) 函数判断一个数是否为素数。
遍历 1 到 100 的素数，检查每对素数之间的差是否等于 2。
如果差值满足条件，则将素数对存储在列表中并输出。

代码详解：

def is_prime(num):
    """判断一个数是否为素数"""
    if num < 2:
        return False
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            return False
    return True

# 找到 1 到 100 之间的所有亲密素数对
prime_pairs = []
previous_prime = None
for num in range(2, 101):
    if is_prime(num):
        if previous_prime and num - previous_prime == 2:
            prime_pairs.append((previous_prime, num))
        previous_prime = num

print("亲密素数对为：", prime_pairs)

3. 生成和验证“循环素数”

题目：循环素数是指通过循环排列数位生成的新数字也都是素数。例如，197 是循环素数，因为 197、971 和 719 都是素数。编写函数 is_circular_prime(num) 判断一个数是否为循环素数，找出 1 到 100 之间的所有循环素数。

思路分析：

编写 is_prime(num) 判断素数。
编写 generate_rotations(num) 生成数的所有循环排列。
使用 is_circular_prime(num) 判断每个循环排列是否为素数。

代码详解：

def is_prime(num):
    if num < 2:
        return False
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            return False
    return True

def generate_rotations(num):
    """生成所有循环排列"""
    rotations = []
    s = str(num)
    for i in range(len(s)):
        rotated = int(s[i:] + s[:i])
        rotations.append(rotated)
    return rotations

def is_circular_prime(num):
    """判断是否为循环素数"""
    for rotation in generate_rotations(num):
        if not is_prime(rotation):
            return False
    return True

# 找出 1 到 100 之间的循环素数
circular_primes = [num for num in range(1, 101) if is_circular_prime(num)]
print("循环素数有：", circular_primes)

4. 计算“最小公倍数数列”

题目：编写函数 gcd(a, b) 计算两个数的最大公约数，编写函数 lcm(a, b) 计算两个数的最小公倍数，再编写 lcm_list(numbers) 计算一个整数列表的最小公倍数。测试 lcm_list 函数求 [4, 5, 12, 15] 的最小公倍数。

思路分析：

使用欧几里得算法在 gcd 中计算最大公约数。
使用公式 lcm(a, b) = a * b / gcd(a, b) 在 lcm 中计算最小公倍数。
使用 reduce 和 lcm 计算列表的最小公倍数。

代码详解：

from functools import reduce

def gcd(a, b):
    """计算最大公约数"""
    while b:
        a, b = b, a % b
    return a

def lcm(a, b):
    """计算最小公倍数"""
    return a * b // gcd(a, b)

def lcm_list(numbers):
    """计算列表中所有数字的最小公倍数"""
    return reduce(lcm, numbers)

# 测试列表的最小公倍数
numbers = [4, 5, 12, 15]
result = lcm_list(numbers)
print("列表 [4, 5, 12, 15] 的最小公倍数是：", result)

5. 判断“完全平方回文数”

题目：完全平方回文数是指一个数字的平方是回文数。例如，11 是完全平方回文数，因为 (11^2 = 121)，而 121 是回文数。编写函数 is_palindrome(num) 判断一个数是否为回文数，编写函数 is_square_palindrome(num) 判断一个数是否为完全平方回文数，输出 1 到 100 之间的所有完全平方回文数。

思路分析：

使用字符串反转在 is_palindrome(num) 中判断回文数。
使用 is_square_palindrome(num) 判断一个数的平方是否为回文数。
遍历 1 到 100，找出所有完全平方回文数。

代码详解：

def is_palindrome(num):
    """判断一个数是否是回文数"""
    return str(num) == str(num)[::-1]

def is_square_palindrome(num):
    """判断一个数的平方是否是回文数"""
    square = num ** 2
    return is_palindrome(square)

# 找出 1 到 100 之间的完全平方回文数
square_palindromes = [num for num in range(1, 101) if is_square_palindrome(num)]
print("完全平方回文数有：", square_palindromes)

6. 查找“素数回文三角数”

题目：素数回文三角数是指同时满足以下条件的数字：

该数字是素数。
该数字是回文数（正向和反向相同）。
该数字是三角数，三角数的公式为 n * (n + 1) / 2。

请编写函数 is_prime(num)、is_palindrome(num) 和 is_triangle_number(num) 来判断一个数是否满足这三个条件，并找出 1 到 10000 之间的所有素数回文三角数。

思路分析：

使用 is_prime(num) 判断是否为素数。
使用 is_palindrome(num) 判断是否为回文数。
使用 is_triangle_number(num) 判断是否为三角数，检查是否符合三角数公式。
遍历 1 到 10000 的数，筛选出符合所有条件的数字。

代码详解：

def is_prime(num):
    """判断是否为素数"""
    if num < 2:
        return False
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            return False
    return True

def is_palindrome(num):
    """判断是否为回文数"""
    return str(num) == str(num)[::-1]

def is_triangle_number(num):
    """判断是否为三角数"""
    n = (-1 + (1 + 8 * num) ** 0.5) / 2
    return n.is_integer()

# 找出 1 到 10000 之间的素数回文三角数
result = []
for i in range(1, 10001):
    if is_prime(i) and is_palindrome(i) and is_triangle_number(i):
        result.append(i)

print("素数回文三角数有：", result)

7. 查找满足特定“数字和”的数字

题目：找出 100 到 999 之间所有的三位数，使得：

各个位数字之和等于 15。
各个位数字之积等于 36。

请编写函数 digit_sum(num) 和 digit_product(num) 来分别计算一个数字的位数之和与位数之积，并找出符合条件的三位数。

思路分析：

定义 digit_sum(num) 和 digit_product(num)，分别计算一个数的位数和与位数积。
遍历 100 到 999，检查位数和为 15 且位数积为 36 的数。

代码详解：

def digit_sum(num):
    """返回数字的位数和"""
    return sum(int(d) for d in str(num))

def digit_product(num):
    """返回数字的位数积"""
    product = 1
    for d in str(num):
        product *= int(d)
    return product

# 找出满足条件的三位数
result = []
for num in range(100, 1000):
    if digit_sum(num) == 15 and digit_product(num) == 36:
        result.append(num)

print("满足条件的三位数有：", result)

8. 寻找满足条件的“质数方差对”

题目：找出 1 到 1000 之间所有的质数对 (p, q)，使得 |p - q| 的平方等于 p + q。即满足条件 |p - q|^2 = p + q。

思路分析：

使用 is_prime(num) 判断质数。
遍历 1 到 1000 中的质数对，检查是否满足 |p - q|^2 = p + q。
使用条件判断进行筛选，确保每对只输出一次。

代码详解：

def is_prime(num):
    """判断是否为素数"""
    if num < 2:
        return False
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            return False
    return True

# 找出 1 到 1000 之间的所有质数方差对
prime_pairs = []
primes = [i for i in range(1, 1001) if is_prime(i)]

for i in range(len(primes)):
    for j in range(i + 1, len(primes)):
        p, q = primes[i], primes[j]
        if (abs(p - q) ** 2) == (p + q):
            prime_pairs.append((p, q))

print("满足条件的质数方差对有：", prime_pairs)

9. 查找“数位奇偶相反”的数字

题目：找出 1000 到 9999 之间所有四位数，使得：

数字的奇数位（从左到右的第 1 位和第 3 位）为偶数。
数字的偶数位（第 2 位和第 4 位）为奇数。

思路分析：

使用整除和取余操作提取各个数位。
检查奇数位是否为偶数，偶数位是否为奇数。
遍历四位数范围，筛选符合条件的数字。

代码详解：

# 找出满足条件的四位数
result = []
for num in range(1000, 10000):
    thousands = num // 1000          # 第一位（奇数位）
    hundreds = (num // 100) % 10     # 第二位（偶数位）
    tens = (num // 10) % 10          # 第三位（奇数位）
    units = num % 10                 # 第四位（偶数位）

    if thousands % 2 == 0 and tens % 2 == 0 and hundreds % 2 == 1 and units % 2 == 1:
        result.append(num)

print("满足条件的四位数有：", result)

10. 检查“等差质数序列”

题目：找出 1 到 100 之间所有长度为 3 的等差质数序列 (p, q, r)，其中 p < q < r。即满足 q - p = r - q，且 p、q、r 均为素数。

思路分析：

使用 is_prime(num) 函数判断质数。
使用嵌套循环枚举质数序列 (p, q, r)。
检查是否满足等差条件 q - p = r - q。

代码详解：

def is_prime(num):
    """判断是否为素数"""
    if num < 2:
        return False
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            return False
    return True

# 找出满足条件的等差质数序列
result = []
primes = [i for i in range(1, 101) if is_prime(i)]

for i in range(len(primes) - 2):
    for j in range(i + 1, len(primes) - 1):
        for k in range(j + 1, len(primes)):
            p, q, r = primes[i], primes[j], primes[k]
            if q - p == r - q:
                result.append((p, q, r))

print("满足条件的等差质数序列有：", result)

11. 检查“连续回文质数对”

题目：找出 1 到 1000 之间的所有回文质数对 (p, q)，使得 p < q 且 q 是 p 的下一个回文质数。

思路分析：

使用 is_prime(num) 和 is_palindrome(num) 判断质数和回文数。
找到 1 到 1000 的所有回文质数，并检查是否连续。
将符合条件的回文质数对存储在列表中。

代码详解：

def is_prime(num):
    """判断是否为素数"""
    if num < 2:
        return False
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            return False
    return True

def is_palindrome(num):
    """判断是否为回文数"""
    return str(num) == str(num)[::-1]

# 找出 1 到 1000 之间所有连续回文质数对
result

 = []
palindromic_primes = [num for num in range(1, 1001) if is_prime(num) and is_palindrome(num)]

for i in range(len(palindromic_primes) - 1):
    p, q = palindromic_primes[i], palindromic_primes[i + 1]
    result.append((p, q))

print("连续回文质数对有：", result)

21- 生成式

21.1 列表生成式（List Comprehension） - 掌握

列表生成式是一种简洁的语法，用于基于已有的可迭代对象（如列表、元组、字符串等）快速生成新的列表。它可以替代传统的 for 循环来创建列表，使代码更简洁易读。

基本语法

[表达式 for 变量 in 可迭代对象 if 条件]

表达式：指定每个元素在列表中的值，通常是一个运算、函数或变量。
变量：用于接收每次迭代的元素。
条件（可选）：为列表生成式添加一个过滤条件，只有满足条件的元素才会包含在新列表中。

示例 1：生成平方数列表

生成 1 到 10 的平方数列表。

squares = [x ** 2 for x in range(1, 11)]
print(squares)  # 输出: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

示例 2：带条件的列表生成式

生成 1 到 20 中的偶数列表。

evens = [x for x in range(1, 21) if x % 2 == 0]
print(evens)  # 输出: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

示例 3：嵌套循环的列表生成式

生成一个乘法表的列表。

multiplication_table = [i * j for i in range(1, 4) for j in range(1, 4)]
print(multiplication_table)  # 输出: [1, 2, 3, 2, 4, 6, 3, 6, 9]

21.2 字典生成式（Dictionary Comprehension） - 掌握

字典生成式用于基于可迭代对象生成一个新的字典。它的语法与列表生成式类似，但生成的是键值对的字典，而不是列表。

基本语法

{键表达式: 值表达式 for 变量 in 可迭代对象 if 条件}

键表达式：生成字典中每个键的值。
值表达式：生成字典中每个键对应的值。
条件（可选）：用于过滤键值对，只有满足条件的元素才会包含在字典中。

示例 1：生成数字平方的字典

生成一个字典，键为 1 到 5 的数字，值为它们的平方。

squares_dict = {x: x ** 2 for x in range(1, 6)}
print(squares_dict)  # 输出: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

示例 2：使用条件的字典生成式

生成一个字典，键为 1 到 10 的数字，值为 "偶数" 或 "奇数"。

parity_dict = {x: "偶数" if x % 2 == 0 else "奇数" for x in range(1, 11)}
print(parity_dict)  
# 输出: {1: '奇数', 2: '偶数', 3: '奇数', 4: '偶数', 5: '奇数', 6: '偶数', 7: '奇数', 8: '偶数', 9: '奇数', 10: '偶数'}

示例 3：字典生成式处理两个列表

使用两个列表生成字典，其中一个列表提供键，另一个提供值。

keys = ["a", "b", "c"]
values = [1, 2, 3]
combined_dict = {k: v for k, v in zip(keys, values)}
print(combined_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

21.3 元组生成式（Tuple Comprehension） - 掌握

严格来说，Python 并没有元组生成式，因为括号 () 被优先解释为生成器表达式。但我们可以通过将生成器表达式转换为 tuple() 来实现类似元组生成式的效果。生成器表达式用于生成一个惰性求值的生成器对象，可以减少内存占用。

基本语法

(表达式 for 变量 in 可迭代对象 if 条件)

表达式：指定每个元素在生成器中的值。
变量：用于接收每次迭代的元素。
条件（可选）：用于过滤元素，只有满足条件的元素才会包含在生成器中。

示例 1：生成平方数的元组

生成 1 到 10 的平方数元组。

squares_tuple = tuple(x ** 2 for x in range(1, 11))
print(squares_tuple)  # 输出: (1, 4, 9, 16, 25, 36, 49, 64, 81, 100)

示例 2：带条件的生成器表达式转换为元组

生成 1 到 20 的偶数元组。

evens_tuple = tuple(x for x in range(1, 21) if x % 2 == 0)
print(evens_tuple)  # 输出: (2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

示例 3：生成嵌套元组

生成乘法表的嵌套元组。

multiplication_table = tuple((i, j, i * j) for i in range(1, 4) for j in range(1, 4))
print(multiplication_table)  
# 输出: ((1, 1, 1), (1, 2, 2), (1, 3, 3), (2, 1, 2), (2, 2, 4), (2, 3, 6), (3, 1, 3), (3, 2, 6), (3, 3, 9))

21.4 生成式的优缺点（了解）

优点

简洁高效：生成式使用一行代码创建数据结构，比传统的循环和条件判断更简洁。
可读性高：生成式语法直观清晰，减少代码行数，提升代码的可读性。
节省内存：生成器表达式使用惰性求值，不会立即生成所有元素，适合处理大数据量。

缺点

复杂性限制：生成式适合简单的逻辑，过于复杂的表达式会降低可读性。
调试难度：生成式中嵌套条件判断或多重循环时，调试较为困难。
生成器的单次迭代：生成器表达式只能被迭代一次，需注意使用场景。

22- 文件读写

22.1 文件的打开（掌握）

在 Python 中，文件可以通过内置的 open() 函数来打开。open() 函数接受两个主要参数：文件路径和文件模式。

基本语法

file = open("文件路径", "模式")

文件模式

常用的文件模式如下：

模式	含义
`'r'`	读取模式（默认值），文件必须存在，读取内容。
`'w'`	写入模式，若文件已存在则清空文件，若不存在则创建新文件。
`'a'`	追加模式，在文件末尾添加内容。若文件不存在则创建新文件。
`'b'`	以二进制模式读写文件，用 `'rb'`、`'wb'` 等组合形式。
`'r+'`	读写模式，可以同时读取和写入。
`'w+'`	读写模式，文件存在则清空，不存在则创建。
`'a+'`	读写模式，在文件末尾追加内容，不存在则创建。

示例：打开文件进行读取

file = open("example.txt", "r")
# 执行文件读取或其他操作
file.close()  # 关闭文件

22.2 文件的读取（掌握）

Python 提供多种方法来读取文件内容。常用的读取方法有 read()、readline() 和 readlines()。

22.2.1 `read()` 读取整个文件内容

示例：

file = open("example.txt", "r")
content = file.read()
print(content)  # 输出整个文件内容
file.close()

22.2.2 `readline()` 逐行读取

示例：

file = open("example.txt", "r")
line = file.readline()  # 读取文件的第一行
while line:
    print(line, end="")  # 打印每行内容
    line = file.readline()  # 继续读取下一行
file.close()

22.2.3 `readlines()` 读取所有行，返回列表

示例：

file = open("example.txt", "r")
lines = file.readlines()  # 读取所有行，返回列表
for line in lines:
    print(line, end="")  # 打印每行内容
file.close()

22.3 文件的写入（掌握）

使用 'w' 模式或 'w+' 模式可以将内容写入文件，注意 'w' 模式会清空文件内容。写入可以通过 write() 或 writelines() 方法实现。

21.3.1 `write()` 写入字符串

示例：

file = open("example.txt", "w")
file.write("Hello, world!\n")  # 写入字符串
file.write("Python 文件写入示例。\n")
file.close()

22.3.2 `writelines()` 写入多行

示例：

file = open("example.txt", "w")
lines = ["第一行\n", "第二行\n", "第三行\n"]
file.writelines(lines)  # 写入多行内容
file.close()

22.4 文件的追加（掌握）

使用 'a' 模式可以在文件末尾追加内容。追加写入不会清空文件内容，而是在已有内容的末尾追加。

示例：

file = open("example.txt", "a")
file.write("这是追加的一行。\n")  # 在文件末尾追加
file.close()

22.5 使用 `with` 语句自动管理文件（掌握）

在文件操作中，手动关闭文件是必须的，但有时可能会忘记使用 close()。使用 with 语句可以确保文件操作完成后自动关闭文件，即使在执行过程中发生错误。

示例：使用 `with` 语句读取文件

with open("example.txt", "r") as file:
    content = file.read()
    print(content)
# 此时文件已自动关闭

示例：使用 `with` 语句写入文件

with open("example.txt", "w") as file:
    file.write("使用 with 语句写入内容。\n")
# 文件已自动关闭

22.6 文件指针的移动（了解）

文件指针用于指示当前读写的位置。使用 seek() 和 tell() 可以控制和获取指针的位置。

22.6.1 `seek(offset, whence)` 移动指针

参数：
- offset：指针移动的偏移量。
- whence：移动的起始位置（0 表示文件开头，1 表示当前位置，2 表示文件末尾）。

示例：

with open("example.txt", "r") as file:
    file.seek(5)  # 将指针移动到文件的第 5 个字节
    print(file.read())  # 从第 5 个字节开始读取

22.6.2 `tell()` 获取当前指针位置

示例：

with open("example.txt", "r") as file:
    print(file.tell())  # 输出指针当前位置
    file.read(5)  # 读取 5 个字节
    print(file.tell())  # 输出新的指针位置

22.7 文件的其他操作（了解）

Python 提供了一些内置的文件操作方法，如 os 模块中的 remove()、rename()、exists() 等，用于对文件进行删除、重命名、检查是否存在等操作。

删除文件

使用 os.remove() 删除指定文件。

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

重命名文件

使用 os.rename() 重命名文件。

os.rename("old_name.txt", "new_name.txt")  # 重命名文件

检查文件是否存在

使用 os.path.exists() 检查文件是否存在。

if os.path.exists("example.txt"):
    print("文件存在")
else:
    print("文件不存在")

22.8 二进制文件的读写（了解）

对于非文本文件（如图片、视频、音频等），需要使用二进制模式读写，以避免编码问题。使用模式 'rb' 读取二进制文件，使用 'wb' 写入二进制文件。

示例：读取二进制文件

with open("example.jpg", "rb") as file:
    content = file.read()
    print(content)  # 输出二进制内容

示例：写入二进制文件

with open("example_copy.jpg", "wb") as file:
    file.write(content)  # 将读取的二进制内容写入新文件

22.9 文件读写的常见问题（掌握）

忘记关闭文件：在文件操作结束后要记得关闭文件，或使用 with 语句自动管理文件。
文件路径错误：检查文件路径是否正确，可以使用绝对路径或相对路径。
文件编码问题：如果文件包含非 ASCII 字符，建议在打开文件时指定编码，如 open("example.txt", "r", encoding="utf-8")。
文件不存在：在打开文件之前检查文件是否存在，避免 FileNotFoundError 错误。
文件权限错误：确保对文件具有相应的读写权限，否则可能会遇到 PermissionError 错误。

23- 面向对象

23.1 面向对象编程的基本概念（掌握）

面向对象编程（OOP）是一种编程范式，它将数据和操作数据的方法封装在一起，称之为对象。Python 是一门面向对象语言，OOP 中的关键概念有以下几个：

类（Class）：类是创建对象的模板或蓝图，它定义了对象的属性和方法。
对象（Object）：对象是类的实例，通过类来创建。
属性（Attribute）：属性是对象的特征或数据，通常是类中定义的变量。
方法（Method）：方法是对象的行为或操作，通常是类中定义的函数。

示例：定义一个简单的类

class Dog:
    # 类属性
    species = "Canis lupus"

    # 初始化方法（构造函数）
    def __init__(self, name, age):
        self.name = name  # 实例属性
        self.age = age    # 实例属性

    # 实例方法
    def bark(self):
        print(f"{self.name} says Woof!")

# 创建对象
my_dog = Dog("Buddy", 3)
print(my_dog.name)  # 输出: Buddy
my_dog.bark()       # 输出: Buddy says Woof!

23.2 类的定义和实例化（掌握）

在 Python 中，使用 class 关键字定义类，类名通常遵循首字母大写的命名约定。定义完类后，通过调用类名并传入必要的参数来创建类的实例（即对象）。

定义类：

class ClassName:
    # 类的内容（属性和方法）

实例化对象：
```
object_name = ClassName(parameters)
```

示例

class Car:
    def __init__(self, make, model):
        self.make = make  # 实例属性
        self.model = model

my_car = Car("Toyota", "Corolla")
print(my_car.make)  # 输出: Toyota
print(my_car.model) # 输出: Corolla

23.3 `init` 方法（构造函数）（掌握）

__init__ 方法是类的构造函数，在创建对象时自动调用，用于初始化对象的属性。它通常接收参数来为属性赋初始值。

定义 __init__ 方法：

def __init__(self, 参数1, 参数2):
    self.属性1 = 参数1
    self.属性2 = 参数2

示例

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

my_book = Book("1984", "George Orwell")
print(my_book.title)  # 输出: 1984
print(my_book.author) # 输出: George Orwell

23.4 实例属性和类属性（掌握）

实例属性：每个对象独立拥有的属性，由 self 关键字定义。实例属性在不同的对象中可以拥有不同的值。
类属性：类本身的属性，不属于任何一个特定的对象，由类名直接访问。类属性在所有对象中共享。

示例

class Animal:
    species = "Mammal"  # 类属性

    def __init__(self, name):
        self.name = name  # 实例属性

a1 = Animal("Lion")
a2 = Animal("Tiger")

print(a1.species)  # 输出: Mammal
print(a2.species)  # 输出: Mammal
print(a1.name)     # 输出: Lion
print(a2.name)     # 输出: Tiger

23.5 实例方法和类方法（掌握）

实例方法：实例方法是作用于对象的方法，第一个参数为 self，表示该方法属于对象，可以访问对象的属性。
类方法：类方法由 @classmethod 装饰器定义，第一个参数为 cls，表示该方法属于类，可以访问类属性。类方法通常用于创建或操作类级别的数据。

示例

class Circle:
    pi = 3.14  # 类属性

    def __init__(self, radius):
        self.radius = radius  # 实例属性

    def area(self):  # 实例方法
        return Circle.pi * (self.radius ** 2)

    @classmethod
    def set_pi(cls, new_pi):  # 类方法
        cls.pi = new_pi

c1 = Circle(5)
print(c1.area())  # 输出: 78.5

Circle.set_pi(3.1416)
print(c1.area())  # 输出: 78.54（使用新值 3.1416）

23.6 静态方法（掌握）

静态方法不需要传入 self 或 cls 参数，通常不与类或对象的属性进行交互，常用于工具方法。使用 @staticmethod 装饰器定义静态方法。

示例

class Math:
    @staticmethod
    def add(x, y):
        return x + y

result = Math.add(5, 3)
print(result)  # 输出: 8

23.7 封装与私有属性（掌握）

封装是 OOP 的核心思想之一，通过将对象的内部数据隐藏起来，只允许通过特定方法访问。Python 使用双下划线前缀 __ 将属性定义为私有属性，限制外部直接访问。

示例

class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance  # 私有属性

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def get_balance(self):
        return self.__balance

account = Account("Alice", 1000)
account.deposit(500)
print(account.get_balance())  # 输出: 1500
# print(account.__balance)  # 访问报错，私有属性

23.8 继承（掌握）

继承允许我们创建一个新的类，并从现有类中继承属性和方法。继承使代码重用更高效，新类称为子类，继承的类称为父类或超类。

示例

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):  # Dog 类继承 Animal 类
    def bark(self):
        print("Dog barks")

dog = Dog()
dog.speak()  # 调用父类方法，输出: Animal speaks
dog.bark()   # 调用子类方法，输出: Dog barks

23.9 方法重写（掌握）

方法重写（Override）允许子类重写父类的方法。子类重写的方法可以覆盖父类的方法，实现不同的功能。

示例

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):  # 重写父类方法
        print("Dog barks")

dog = Dog()
dog.speak()  # 输出: Dog barks

23.10 多态（掌握）

多态是指对象在不同的场景中表现出不同的行为。Python 的多态性允许使用相同的方法名调用不同类的实例，而不关心实例的具体类型。

示例

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        print("Dog barks")

class Cat(Animal):
    def speak(self):
        print("Cat meows")

animals = [Dog(), Cat()]

for animal in animals:
    animal.speak()  # 输出 Dog barks 和 Cat meows

23.11 面向对象的优势（了解）

封装：将数据和行为封装在一起，提高代码安全性。
继承：实现代码重用，减少重复代码。
多态：同一方法在不同对象中表现出不同的行为，提高代码的灵活性。
抽象：隐藏复杂实现，暴露简单接口，提高代码的可维护性。

24- 面向对象综合案例

案例 1：银行账户系统

需求：

创建一个 BankAccount 类，用于管理银行账户。
该类需要包含以下功能：
- 开户：初始化账户名、账户余额和账户类型（如储蓄、支票）。
- 存款：向账户中添加指定金额。
- 取款：从账户中取出指定金额，余额不足时给出警告。
- 查询余额：显示当前余额。

思路分析：

BankAccount 类包含初始化方法 __init__ 来设置账户名称、余额和账户类型。
定义 deposit 和 withdraw 方法分别用于存款和取款，确保取款时余额足够。
定义 get_balance 方法用于查询余额。

代码实现：

class BankAccount:
    def __init__(self, account_name, initial_balance=0, account_type="Savings"):
        self.account_name = account_name
        self.balance = initial_balance
        self.account_type = account_type

    def deposit(self, amount):
        if amount > 0:
            self.balance += amount
            print(f"存入 {amount} 元。当前余额：{self.balance} 元")
        else:
            print("存款金额必须为正数。")

    def withdraw(self, amount):
        if amount > self.balance:
            print("余额不足，无法取款。")
        elif amount > 0:
            self.balance -= amount
            print(f"取出 {amount} 元。当前余额：{self.balance} 元")
        else:
            print("取款金额必须为正数。")

    def get_balance(self):
        print(f"{self.account_name} 的当前余额：{self.balance} 元")

# 测试
account = BankAccount("Alice", 1000)
account.deposit(500)
account.withdraw(300)
account.get_balance()
account.withdraw(1500)  # 余额不足

案例 2：图书馆系统

需求：

创建一个 Book 类，包含书籍的基本信息（如标题、作者、ISBN 编号）。
创建一个 Library 类，用于管理图书馆的藏书和借阅记录。
Library 类需要包含以下功能：
- 添加书籍：将书籍添加到藏书列表。
- 借书：用户可以借阅指定书籍，若该书已被借出则提示不可用。
- 归还书籍：将书籍归还到图书馆。

思路分析：

Book 类包含书籍的基本信息，如标题、作者和 ISBN 编号。
Library 类包含一个 books 字典，用于记录图书馆的藏书信息，书籍的可用状态（True 表示可用，False 表示已借出）。
在 Library 类中定义 add_book、borrow_book 和 return_book 方法来管理书籍的借阅和归还。

代码实现：

class Book:
    def __init__(self, title, author, isbn):
        self.title = title
        self.author = author
        self.isbn = isbn

class Library:
    def __init__(self):
        self.books = {}

    def add_book(self, book):
        if book.isbn not in self.books:
            self.books[book.isbn] = {"book": book, "available": True}
            print(f"添加书籍：《{book.title}》")
        else:
            print(f"书籍《{book.title}》已存在于图书馆。")

    def borrow_book(self, isbn):
        if isbn in self.books:
            if self.books[isbn]["available"]:
                self.books[isbn]["available"] = False
                print(f"成功借出书籍：《{self.books[isbn]['book'].title}》")
            else:
                print("该书籍已被借出。")
        else:
            print("该书籍不存在于图书馆。")

    def return_book(self, isbn):
        if isbn in self.books:
            if not self.books[isbn]["available"]:
                self.books[isbn]["available"] = True
                print(f"成功归还书籍：《{self.books[isbn]['book'].title}》")
            else:
                print("该书籍已经在馆。")
        else:
            print("该书籍不存在于图书馆。")

# 测试
library = Library()
book1 = Book("Python Basics", "Author A", "ISBN001")
book2 = Book("Data Science", "Author B", "ISBN002")

library.add_book(book1)
library.add_book(book2)
library.borrow_book("ISBN001")
library.borrow_book("ISBN001")  # 已被借出
library.return_book("ISBN001")
library.borrow_book("ISBN003")  # 不存在的书籍

案例 3：员工管理系统

需求：

创建一个基类 Employee，包含员工的基本信息（如姓名和薪资）。
创建两个子类 Manager 和 Developer，继承 Employee，并在子类中实现特定的方法和属性。
需要提供以下功能：
- Manager 类可以管理一个员工列表。
- Developer 类可以记录其特定的编程语言。
- 打印每个员工的信息，区分不同员工类型。

思路分析：

Employee 类作为基类，包含基本信息属性和显示信息的方法。
Manager 类继承自 Employee，包含一个员工列表，并可添加管理的员工。
Developer 类继承自 Employee，包含一个记录编程语言的属性。

代码实现：

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    def display_info(self):
        print(f"员工姓名: {self.name}, 薪资: {self.salary}")

class Manager(Employee):
    def __init__(self, name, salary):
        super().__init__(name, salary)
        self.employees = []

    def add_employee(self, employee):
        if isinstance(employee, Employee) and employee not in self.employees:
            self.employees.append(employee)
            print(f"{self.name} 现在管理员工 {employee.name}")

    def display_info(self):
        super().display_info()
        print("管理的员工:")
        for emp in self.employees:
            print(f"- {emp.name}")

class Developer(Employee):
    def __init__(self, name, salary, language):
        super().__init__(name, salary)
        self.language = language

    def display_info(self):
        super().display_info()
        print(f"编程语言: {self.language}")

# 测试
manager = Manager("Alice", 100000)
dev1 = Developer("Bob", 80000, "Python")
dev2 = Developer("Charlie", 85000, "JavaScript")

manager.add_employee(dev1)
manager.add_employee(dev2)

manager.display_info()
dev1.display_info()
dev2.display_info()

25- 数据类型转换

25.1 数据类型转换概述（掌握）

数据类型转换指的是将一个数据类型转换为另一个数据类型。例如，将整数转换为浮点数，将字符串转换为列表等。Python 提供了多种内置函数来实现不同的数据类型转换。

25.2 常见的数据类型转换方法（掌握）

Python 提供的基本数据类型转换函数如下：

函数	描述
`int(x)`	将 `x` 转换为整数
`float(x)`	将 `x` 转换为浮点数
`str(x)`	将 `x` 转换为字符串
`list(x)`	将 `x` 转换为列表
`tuple(x)`	将 `x` 转换为元组
`set(x)`	将 `x` 转换为集合
`dict(x)`	将 `x` 转换为字典（需满足特定结构）

25.3 数字类型转换（掌握）

Python 中支持整数和浮点数的转换，可以通过 int() 和 float() 函数实现。

25.3.1 整数和浮点数转换

示例：

# 将浮点数转换为整数
num1 = 3.14
int_num1 = int(num1)  # 输出: 3

# 将整数转换为浮点数
num2 = 5
float_num2 = float(num2)  # 输出: 5.0

25.3.2 字符串和数字的转换

字符串转整数：

str_num = "123"
int_num = int(str_num)  # 输出: 123

字符串转浮点数：

str_float = "3.14"
float_num = float(str_float)  # 输出: 3.14

数字转字符串：

num = 456
str_num = str(num)  # 输出: "456"

25.4 字符串与列表/元组的转换（掌握）

字符串、列表和元组之间的转换方法主要依靠 list()、tuple() 和 join() 函数。

25.4.1 字符串转列表和元组

字符串转列表：每个字符将成为列表的一个元素。

text = "hello"
text_list = list(text)  # 输出: ['h', 'e', 'l', 'l', 'o']

字符串转元组：使用 tuple() 将字符串转换为元组。

text_tuple = tuple(text)  # 输出: ('h', 'e', 'l', 'l', 'o')

25.4.2 列表/元组转字符串

列表转字符串：使用 join() 方法将列表中的元素合并为字符串。

words = ['Python', 'is', 'fun']
sentence = ' '.join(words)  # 输出: "Python is fun"

元组转字符串：同样使用 join() 方法。

chars = ('P', 'y', 't', 'h', 'o', 'n')
word = ''.join(chars)  # 输出: "Python"

25.5 列表、元组、集合的互相转换（掌握）

可以使用 list()、tuple() 和 set() 函数在列表、元组和集合之间进行转换。

24.5.1 列表、元组、集合的转换

列表转元组：

fruits = ['apple', 'banana', 'cherry']
fruits_tuple = tuple(fruits)  # 输出: ('apple', 'banana', 'cherry')

列表转集合：

fruits_set = set(fruits)  # 输出: {'apple', 'banana', 'cherry'}

元组转列表：

fruits_list = list(fruits_tuple)  # 输出: ['apple', 'banana', 'cherry']

集合转列表：

set_to_list = list(fruits_set)  # 输出: ['apple', 'banana', 'cherry']

25.6 字典的转换（掌握）

字典的键和值可以分别转换为列表、元组或集合，字典本身可以通过满足一定结构的列表或元组进行转换。

25.6.1 字典转列表/元组/集合

字典键转换为列表：

person = {'name': 'Alice', 'age': 25}
keys_list = list(person.keys())  # 输出: ['name', 'age']

字典值转换为列表：

values_list = list(person.values())  # 输出: ['Alice', 25]

字典键值对转换为元组列表：

items_list = list(person.items())  # 输出: [('name', 'Alice'), ('age', 25)]

25.6.2 列表/元组转字典

列表转字典：列表中的元素需为二元组。

items = [('name', 'Bob'), ('age', 30)]
person_dict = dict(items)  # 输出: {'name': 'Bob', 'age': 30}

元组转字典：与列表转字典相同，要求元组内元素为二元组。

items_tuple = (('name', 'Charlie'), ('age', 35))
person_dict = dict(items_tuple)  # 输出: {'name': 'Charlie', 'age': 35}

25.7 常见数据类型转换示例（掌握）

示例 1：混合数据类型列表转字符串

将包含多个不同数据类型的列表元素合并成字符串。

data = [1, 'apple', 3.14]
string_data = ' | '.join(map(str, data))
print(string_data)  # 输出: "1 | apple | 3.14"

示例 2：字符串列表转整数列表

将一个包含数字字符串的列表转换为整数列表。

str_nums = ["10", "20", "30"]
int_nums = list(map(int, str_nums))
print(int_nums)  # 输出: [10, 20, 30]

示例 3：将嵌套列表转换为字典

将嵌套列表（每个子列表包含键值对）转换为字典。

data = [["name", "Alice"], ["age", 28], ["city", "New York"]]
data_dict = dict(data)
print(data_dict)  # 输出: {'name': 'Alice', 'age': 28, 'city': 'New York'}

25.8 数据类型转换的注意事项（掌握）

转换条件：并非所有数据类型都可以互相转换，如将非数值字符串转换为数字会报错。
```
int("hello")  # ValueError: invalid literal for int()
```
精度损失：浮点数转换为整数时会丢失小数部分。
```
int(3.9)  # 输出: 3
```
可变与不可变：列表、字典和集合是可变类型，元组和字符串是不可变类型。数据转换时要注意特性变化。
数据丢失：集合的元素是唯一的，将包含重复元素的列表转换为集合会自动去重。
```
list_to_set = set([1, 2, 2, 3])  # 输出: {1, 2, 3}
```