1
print(5 == 5)       # True  （等于）
2
print(5 != 5)       # False （不等于）
3
print(5 > 5)        # False （大于）
4
print(5 < 5)        # False （小于）
5
print(5 >= 5)       # True  （大于等于）
6
print(5 <= 5)       # True  （小于等于）

1
# ❌ 错误理解：判断 x 是否在 1 和 10 之间
2
# 正确写法：
3
if 1 < x < 10:      # Python 支持这种写法！
4
    pass
5

6
# 等价于：
7
if x > 1 and x < 10:
8
    pass

1
print(True and False)    # False （逻辑与：两边都为 True 才为 True）
2
print(True or False)     # True  （逻辑或：只要一边为 True 就为 True）
3
print(not True)          # False （逻辑非：取反）

1
# and：左边为 False，右边不会执行
2
False and print("不会执行")    # 直接返回 False
3

4
# or：左边为 True，右边不会执行
5
True or print("不会执行")      # 直接返回 True

1
fruits = ["apple", "banana", "cherry"]
2

3
if "apple" in fruits:           # 判断元素是否在列表中
4
    print("apple is in the list")
5

6
if "orange" not in fruits:      # 判断元素是否不在列表中
7
    print("orange is not in the list")

1
person = {"name": "Alice", "age": 18}
2

3
print("name" in person)         # True（检查键）
4
print("Alice" in person)        # False（不检查值）
5
print("Alice" in person.values())  # True（检查值）

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

6
# 输出:
7
# 0
8
# 1
9
# 2

1
count = 0
2
├─ count < 3?  0 < 3?  True → 打印 0，count 变为 1
3
├─ count < 3?  1 < 3?  True → 打印 1，count 变为 2
4
├─ count < 3?  2 < 3?  True → 打印 2，count 变为 3
5
└─ count < 3?  3 < 3?  False → 结束循环

1
# ❌ 死循环示例
2
while True:
3
    print("永远执行")
4
    # 没有 break 或改变条件的代码

1
for i in range(5):
2
    if i == 2:
3
        continue        # 跳过当前循环，继续下一次
4
    if i == 4:
5
        break           # 立即终止整个循环
6
    print(i)
7

8
# 输出: 0, 1, 3

1
i=0:  不满足 if → 打印 0
2
i=1:  不满足 if → 打印 1
3
i=2:  i==2 为 True → continue → 跳过打印，进入 i=3
4
i=3:  不满足 if → 打印 3
5
i=4:  i==4 为 True → break → 循环结束

1
text = "Hello, Python!"
2

3
print(text[0:5])        # "Hello"（索引 0 到 4，不包括 5）
4
print(text[:5])         # "Hello"（从开头到 4）
5
print(text[7:])         # "Python!"（从 7 到末尾）
6
print(text[:])          # "Hello, Python!"（整个字符串）
7
print(text[::2])        # "Hlo yhn"（每隔一个字符）
8
print(text[::-1])       # "!nohtyP ,olleH"（反转字符串）

1
字符串: H  e  l  l  o  ,     P  y  t  h  o  n  !
2
索引:   0  1  2  3  4  5  6  7  8  9  10 11 12 13
3

4
[0:5]  → 取索引 0,1,2,3,4 → "Hello"
5
[7:13] → 取索引 7,8,9,10,11,12 → "Python"

1
# 字符串切片
2
doc = "Hello World Python Programming"
3
print(doc[:15])             # "Hello World Py"（前15个字符）
4

5
# 列表切片
6
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]
7
print(nums[:15])            # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
8

9
# 元组切片
10
data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)
11
print(data[:15])            # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
12

13
# 安全特性：长度不足时不会报错，直接返回全部
14
short = "Short"
15
print(short[:15])           # "Short"（原样返回，不会越界）

1
text = "Hello, Python!"
2

3
# 大小写转换
4
print(text.lower())                 # "hello, python!"
5
print(text.upper())                 # "HELLO, PYTHON!"
6

7
# 替换
8
print(text.replace("Python", "World"))  # "Hello, World!"
9

10
# 分割
11
words = "apple, banana, orange"
12
print(words.split(","))             # ['apple', ' banana', ' orange']
13
print(words.split(", "))            # ['apple', 'banana', 'orange']
14

15
# 去除空白
16
name = "  enkidu  "
17
print(name.strip())                 # "enkidu"（去除两端空格）
18
print(name.lstrip())                # "enkidu  "（去除左边空格）
19
print(name.rstrip())                # "  enkidu"（去除右边空格）
20

21
# strip() 还能去除指定的特定字符
22
text = "***Hello World***"
23
print(text.strip('*'))              # "Hello World"（去除两端的*号）
24

25
text = "##--Hello World--##"
26
print(text.strip('#-'))             # "Hello World"（去除两端所有#和-）
27

28
# strip() 能去除的空白字符包括：空格、\t、\n、\r 等
29
doc = "\t\n  Python Programming  \n\t "
30
print(repr(doc.strip()))            # "'Python Programming'"
31

32
# ⚠️ 注意：字符串不可变，strip() 返回新字符串，原字符串不变
33
text = "  hello  "
34
text.strip()                        # 返回 "hello"，但 text 还是 "  hello  "
35
text = text.strip()                 # 必须重新赋值才能改变 text

1
# 普通赋值
2
point = (3, 5)
3
x = point[0]                # 手动取出
4
y = point[1]
5
print(x, y)                 # 3 5
6

7
# 元组解包（一行搞定）
8
x, y = (3, 5)
9
print(x, y)                 # 3 5

1
data = [
2
    ("我喜欢吃苹果", "都关于苹果"),
3
    ("香蕉也很好吃", "不同水果"),
4
    ("Python 编程语言", "完全不相关")
5
]
6
#       ↑ 这是一个列表，里面装着 3 个元组
7

8
# 元组解包写法
9
for text, expected in data:
10
    print(f"文本：{text}，分类：{expected}")
11
    # 每次循环 Python 自动把元组拆成两个变量

1
第1次循环: text, expected = ("我喜欢吃苹果", "都关于苹果")
2
           text = "我喜欢吃苹果", expected = "都关于苹果"
3
           → 打印 "文本：我喜欢吃苹果，分类：都关于苹果"
4

5
第2次循环: text, expected = ("香蕉也很好吃", "不同水果")
6
           text = "香蕉也很好吃", expected = "不同水果"
7

8
第3次循环: text, expected = ("Python 编程语言", "完全不相关")
9
           text = "Python 编程语言", expected = "完全不相关"

1
# 不用解包的写法（更繁琐）
2
for item in data:                    # item 是一个元组
3
    text = item[0]                   # 手动提取第一个元素
4
    expected = item[1]               # 手动提取第二个元素
5
    print(f"文本：{text}，分类：{expected}")

1
# 遍历字典（还记得 01_Python基础 中学到的 .items() 吗？）
2
person = {"name": "Alice", "age": 18}
3

4
for key, value in person.items():
5
    print(f"{key}: {value}")
6
# 输出:
7
# name: Alice
8
# age: 18
9
# 每次循环 key, value = 一个元组

1
# 创建集合
2
nums = {1, 2, 3, 4, 5}
3

4
# 最常见用途：给列表去重
5
nums_list = [1, 2, 2, 3, 4, 4, 5]
6
unique_nums = set(nums_list)
7
print(unique_nums)          # {1, 2, 3, 4, 5}

1
a = {1, 2, 3, 4}
2
b = {3, 4, 5, 6}
3

4
# 并集
5
print(a | b)            # {1, 2, 3, 4, 5, 6}
6
print(a.union(b))
7

8
# 交集
9
print(a & b)            # {3, 4}
10
print(a.intersection(b))
11

12
# 差集
13
print(a - b)            # {1, 2}（在 a 中但不在 b 中）
14
print(a.difference(b))
15

16
# 对称差集
17
print(a ^ b)            # {1, 2, 5, 6}（只在其中一个集合中）
18
print(a.symmetric_difference(b))

1
fruits = ["apple", "banana", "cherry"]
2

3
# remove()：删除指定值的第一个匹配项
4
fruits.remove("banana")
5
print(fruits)           # ['apple', 'cherry']
6

7
# pop()：删除并返回指定位置的元素（默认最后一个）
8
last_fruit = fruits.pop()
9
print(last_fruit)       # "cherry"
10
print(fruits)           # ['apple']
11

12
# 删除指定位置
13
fruits = ["apple", "banana", "cherry"]
14
fruits.pop(0)           # 删除索引 0 的元素 → "apple"

1
fruits = ["apple"]
2
other_fruits = ["dog", "cat"]
3

4
# 使用 + 合并（创建新列表）
5
all_things = fruits + other_fruits
6
print(all_things)       # ['apple', 'dog', 'cat']
7

8
# 使用 extend() 原地扩展
9
fruits.extend(other_fruits)
10
print(fruits)           # ['apple', 'dog', 'cat']
11

12
# 使用 append() 添加整个列表（作为单个元素）
13
fruits = ["apple"]
14
fruits.append(other_fruits)
15
print(fruits)           # ['apple', ['dog', 'cat']]  ← 注意这是嵌套列表！

1
def say_hello(name="匿名"):
2
    print(f"hello {name}")
3

4
say_hello()                 # "hello 匿名"（使用默认值）
5
say_hello("Alice")          # "hello Alice"（传入参数覆盖默认值）

1
# ❌ 错误示例
2
def add_item(item, items=[]):
3
    items.append(item)
4
    return items
5

6
print(add_item(1))          # [1]
7
print(add_item(2))          # [1, 2]  ← 意外！使用了同一个列表
8

9
# ✅ 正确写法
10
def add_item(item, items=None):
11
    if items is None:
12
        items = []
13
    items.append(item)
14
    return items

1
def calc_sum(*args):
2
    """
3
    *args 接收任意数量的位置参数，打包成元组
4
    """
5
    total = 0
6
    for n in args:
7
        total += n
8
    print(total)
9

10
# 调用时可以传任意个数
11
calc_sum(1, 2, 3, 4, 5)     # 15
12
calc_sum(10, 20)            # 30
13
calc_sum()                  # 0

1
def func(*args):
2
    print(args)             # 是一个元组
3
    print(type(args))       # <class 'tuple'>
4

5
func(1, 2, 3)               # (1, 2, 3)

1
# 普通函数
2
def multiply(x, y):
3
    return x * y
4

5
# 等价的 lambda 函数
6
multiply = lambda x, y: x * y
7

8
print(multiply(3, 4))       # 12

1
# 排序时指定 key
2
students = [("Alice", 20), ("Bob", 18), ("Charlie", 22)]
3
students.sort(key=lambda x: x[1])   # 按年龄排序
4

5
# 配合 map()
6
nums = [1, 2, 3, 4]
7
squares = list(map(lambda x: x**2, nums))  # [1, 4, 9, 16]
8

9
# 配合 filter()
10
evens = list(filter(lambda x: x % 2 == 0, nums))  # [2, 4]

1
# ❌ 没有异常处理
2
num = int(input("请输入数字："))    # 输入 "abc" → 程序崩溃！
3
result = 10 / num                    # 输入 0 → 程序崩溃！

1
try:
2
    num = int(input("请输入一个数字："))
3
    result = 10 / num
4
    print(f"结果是{result}")
5
except ValueError as e:
6
    # 当 int() 转换失败时触发
7
    print("error 你输入的不是数字")
8
except ZeroDivisionError as e:
9
    # 当除以 0 时触发
10
    print("error 除以0错误")
11
finally:
12
    # 无论是否出错，都会执行
13
    print("程序结束")

1
情况1：输入 "5"
2
    try 块正常执行 → 打印 "结果是2.0" → 执行 finally
3

4
情况2：输入 "abc"
5
    int("abc") 报错 → 跳到 ValueError → 打印错误信息 → 执行 finally
6

7
情况3：输入 "0"
8
    10/0 报错 → 跳到 ZeroDivisionError → 打印错误信息 → 执行 finally

1
try:
2
    # 可能出错的代码
3
    pass
4
except Exception as e:
5
    # 捕获所有异常（不推荐，会隐藏 bug）
6
    print(f"出错了：{e}")

1
# 使用 with 语句（推荐，自动关闭文件）
2
with open("test.txt", "w", encoding="utf-8") as file:
3
    file.write("第一行文字\n")
4
    file.write("第二行文字\n")

1
with open("test.txt", "r", encoding="utf-8") as file:
2
    content = file.read()           # 读取全部内容
3
    print(content)

1
# 逐行读取
2
with open("test.txt", "r", encoding="utf-8") as file:
3
    for line in file:
4
        print(line.strip())         # strip() 去除换行符
5

6
# 读取为列表
7
with open("test.txt", "r", encoding="utf-8") as file:
8
    lines = file.readlines()        # ['第一行\n', '第二行\n']

1
# ❌ 传统写法（容易忘记关闭）
2
file = open("test.txt", "r")
3
content = file.read()
4
file.close()                        # 如果上面报错，这行不会执行！
5

6
# ✅ with 写法（自动关闭，即使出错也会关闭）
7
with open("test.txt", "r") as file:
8
    content = file.read()
9
# 到这里 file 已经自动关闭了

1
import math
2
print(math.sqrt(16))        # 4.0（开平方）
3
print(math.pi)              # 3.141592653589793
4

5
import random
6
print(random.randint(1, 10))  # 1到10的随机整数

1
from time import sleep
2

3
print("开始等待")
4
sleep(2)                    # 暂停2秒
5
print("继续运行")

1
# 方式1：导入整个模块（推荐，避免命名冲突）
2
import math
3
math.sqrt(16)
4

5
# 方式2：从模块导入特定函数
6
from math import sqrt
7
sqrt(16)
8

9
# 方式3：导入所有（不推荐，可能覆盖已有函数）
10
from math import *
11
sqrt(16)
12

13
# 方式4：使用别名
14
import numpy as np
15
import pandas as pd

1
class Animal:
2
    """动物基类"""
3

4
    def __init__(self, name):
5
        self.name = name
6

7
    def speak(self):
8
        print(f"{self.name} 发出了声音")
9

10
class Dog(Animal):
11
    """狗类，继承自 Animal"""
12

13
    def speak(self):
14
        # 重写父类方法
15
        print(f"{self.name} 说汪汪汪")
16

17
class Cat(Animal):
18
    """猫类，继承自 Animal"""
19

20
    def speak(self):
21
        # 重写父类方法
22
        print(f"{self.name} 说喵喵喵")

1
        Animal (父类/基类)
2
       /      \
3
    Dog        Cat (子类/派生类)

1
dog = Dog("旺财")
2
dog.speak()                 # "旺财 说汪汪汪"
3

4
cat = Cat("咪咪")
5
cat.speak()                 # "咪咪 说喵喵喵"

1
创建 Dog("旺财")
2
    ↓
3
调用 Dog.__init__("旺财") → 但 Dog 没有定义 __init__
4
    ↓
5
向上查找，调用 Animal.__init__("旺财")
6
    ↓
7
self.name = "旺财"
8
    ↓
9
调用 dog.speak()
10
    ↓
11
Dog 类有 speak 方法 → 执行 Dog.speak()

1
class Dog(Animal):
2
    def __init__(self, name, breed):
3
        super().__init__(name)      # 调用父类的 __init__
4
        self.breed = breed          # 添加自己的属性
5

6
    def speak(self):
7
        super().speak()             # 先调用父类的方法
8
        print(f"{self.name} 说汪汪汪")
9

10
dog = Dog("旺财", "金毛")
11
# 输出:
12
# 旺财 发出了声音
13
# 旺财 说汪汪汪

1
# 比较：== != > < >= <=
2
# 逻辑：and or not
3
# 成员：in not in

1
while 条件:
2
    if 条件:
3
        continue    # 跳过本次
4
    if 条件:
5
        break       # 终止循环

1
text[start:end:step]        # 切片
2
text.lower() / upper()      # 大小写
3
text.strip()                # 去空白
4
text.replace(a, b)          # 替换
5
text.split(",")             # 分割
6
",".join(list)              # 连接

1
try:
2
    # 可能出错的代码
3
except 具体异常 as e:
4
    # 处理错误
5
finally:
6
    # 无论是否出错都执行

1
with open("file.txt", "r", encoding="utf-8") as f:
2
    content = f.read()

1
class 子类(父类):
2
    def __init__(self, ...):
3
        super().__init__(...)
4

5
    def 方法(self):
6
        super().方法()
7
        # 自己的逻辑