1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# Python 1.x / Python 2.1 之前的古典类
class Animal:
    """古典类：没有显式继承任何类"""
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        return "..."

class Dog(Animal):
    """古典类：显式继承 Animal"""
    def speak(self):
        return self.name + " says Woof!"

# 问题：古典类的 type 是什么？
d = Dog("Buddy")
print(type(d))              # <type 'instance'>
print(d.__class__)          # __main__.Dog
print(isinstance(d, object))  # False！！！古典类不是 object 的实例！！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 在 Python 2 古典类模式下
class A:
    pass

class B:
    pass

a = A()
print(type(a))  # <type 'instance'> —— 没错，你没看错！
print(type(a) == A)  # False —— 这简直是哲学问题！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Python 2.2+ 新式类
class NewAnimal(object):  # 显式继承 object
    def __init__(self, name):
        self.name = name

# 现在 type() 终于正常了
a = NewAnimal("Cat")
print(type(a))                # <class '__main__.NewAnimal'>
print(isinstance(a, object))  # True —— 终于，你是对象了！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# Python 2 时代的 Unicode
# -*- coding: utf-8 -*-

# 普通字符串（实际上是字节串）
s = "你好"           # 在 Python 2 中，这其实是字节串
print(type(s))       # <type 'str'>

# Unicode 字符串（显式用 u 前缀）
u = u"你好"
print(type(u))       # <type 'unicode'>

# 编码转换：Unicode -> UTF-8 bytes
utf8_bytes = u.encode('utf-8')
print(repr(utf8_bytes))  # '\xe4\xb8\xad\xe6\x96\x87'

# 解码：bytes -> Unicode
back = utf8_bytes.decode('utf-8')
print(back)           # 你好

1
2
3
4
5
6
7
8
9

# -*- coding: gbk -*-
# Python 2 时代，很多人为了一行中文注释要写这样的头部
# 你以为是 utf-8，其实是 gbk，然后报错，然后心态爆炸

# 常见错误：在 console 输出 Unicode 字符串
import sys
reload(sys)
sys.setdefaultencoding('utf-8')  # 这行代码，Python 2 玩家都懂

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# Python 2 时代的字符串格式化 —— % 运算符的天下
name = "Alice"
age = 25
height = 1.68

# 基本用法：%s 字符串，%d 整数，%f 浮点数
msg = "My name is %s, I'm %d years old, and my height is %.2f m." % (name, age, height)
print(msg)
# My name is Alice, I'm 25 years old, and my height is 1.68 m.

# 字典格式化：更清晰、更安全
msg = "My name is %(name)s, I'm %(age)d years old." % {"name": name, "age": age}
print(msg)

# %的转义：%% 代表一个字面量 %
ratio = 0.75
print("完成度：%.0f%%" % (ratio * 100))
# 完成度：75%

# 格式化整数：%06d（补零）
order_id = 42
print("订单号：%06d" % order_id)
# 订单号：000042

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# Python 1.x 异常处理 —— try/except 已经有了，但 finally 还没有
try:
    x = 1 / 0
except ZeroDivisionError:
    print("除数不能为零！")

# 捕获多种异常
try:
    import non_existent_module
except (ImportError, SyntaxError) as e:
    print("模块导入失败：%s" % e)

# 早期写法：不用 as，用逗号（Python 1.x 风格）
try:
    x = 1 / 0
except ZeroDivisionError, msg:  # 这是 Python 2.1 及之前的语法！
    print(msg)

# Python 2.2+ 才改为 except Exception as e:
try:
    x = 1 / 0
except ZeroDivisionError as msg:  # 这才像话
    print(msg)

# 早期没有 finally，但可以这样做：
try:
    f = open("test.txt", "r")
    content = f.read()
except IOError as e:
    print("文件操作失败：%s" % e)
else:  # else 在没有 finally 时用来表示"没有异常时执行"
    print("文件读取成功")
    f.close()  # 但如果这里出错，文件就没关！所以 finally 很重要

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 传统 for 循环：创建一个 0-9 的平方列表
squares = []
for i in range(10):
    squares.append(i ** 2)
print(squares)

# 列表推导式：一行搞定！
squares = [i ** 2 for i in range(10)]
print(squares)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 字符串操作
words = ["Hello", "World", "Python"]
upper_words = [w.upper() for w in words]
print(upper_words)
# ['HELLO', 'WORLD', 'PYTHON']

# 数字运算
nums = [1, 2, 3, 4, 5]
doubled = [n * 2 for n in nums]
print(doubled)
# [2, 4, 6, 8, 10]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 只保留偶数
nums = range(10)
evens = [n for n in nums if n % 2 == 0]
print(evens)
# [0, 2, 4, 6, 8]

# 过滤掉负数
data = [1, -3, 2, -5, 4, -1]
positive = [x for x in data if x > 0]
print(positive)
# [1, 2, 4]

# 多重条件
nums = range(20)
result = [n for n in nums if n % 2 == 0 if n % 3 == 0]
print(result)
# [0, 6, 12, 18] —— 能被2整除且能被3整除的数（也就是6的倍数）

# if-else 表达式（注意：这是表达式，不是过滤）
labels = ["正数" if x > 0 else "非正数" for x in [-1, 0, 1, 2]]
print(labels)
# ['非正数', '非正数', '正数', '正数']

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 二维矩阵展平
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [num for row in matrix for num in row]
print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 等价于：
flat = []
for row in matrix:
    for num in row:
        flat.append(num)

# 嵌套推导式生成乘法表
multiplication_table = [[i * j for j in range(1, 10)] for i in range(1, 10)]
# multiplication_table[i-1][j-1] = i * j

# 条件+嵌套：找出两个列表中相等的元素
list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]
common = [x for x in list1 for y in list2 if x == y]
print(common)
# [3, 4, 5] —— 找到了共同的元素

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# 生成器函数：用 yield 返回值
def count_up_to(max_val):
    """计数器，模拟 Python 2 的 range 行为"""
    count = 1
    while count <= max_val:
        yield count  # yield 就像暂停键
        count += 1

# 调用生成器函数，返回一个生成器对象
counter = count_up_to(5)
print(type(counter))  # <type 'generator'>

# 用 next() 一个个取值
print(next(counter))  # 1
print(next(counter))  # 2
print(next(counter))  # 3
print(next(counter))  # 4
print(next(counter))  # 5

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

def fibonacci():
    """生成斐波那契数列"""
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# 遍历生成器
fib = fibonacci()
for i in range(10):
    print(next(fib), end=" ")
# 0 1 1 2 3 5 8 13 21 34

# 生成器也可以用 for 循环
fib = fibonacci()
for num in fib:
    if num > 100:
        break
    print(num, end=" ")
# 0 1 1 2 3 5 8 13 21 34 55 89

# 用 list() 一次性消费完（谨慎！大数据集会爆内存）
gen = (x ** 2 for x in range(5))
print(list(gen))
# [0, 1, 4, 9, 16]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

def three_numbers():
    yield 1
    yield 2
    yield 3

gen = three_numbers()
print(next(gen))  # 1
print(next(gen))  # 2
print(next(gen))  # 3

try:
    print(next(gen))  # 没有更多值了！
except StopIteration:
    print("生成器已经榨干了！")
# 生成器已经榨干了！

# for 循环自动处理 StopIteration
for num in three_numbers():
    print(num)
# 1
# 2
# 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# 自定义上下文管理器
class ManagedResource:
    """一个支持 with 语句的资源管理类"""
    
    def __enter__(self):
        """进入 with 块时调用，返回值绑定到 as 后的变量"""
        print("📖 打开资源")
        return self  # 返回的对象会绑定到 as 后的变量
    
    def __exit__(self, exc_type_arg, exc_value, traceback):
        """退出 with 块时调用，无论是否发生异常"""
        print("📕 关闭资源")
        if exc_type_arg is not None:
            print("  异常类型: %s" % exc_type_arg.__name__)
            print("  异常信息: %s" % exc_value)
        # 返回 False 不抑制异常，异常会继续传播
        return False
    
    def read(self):
        return "数据内容..."

# 使用 with 语句
with ManagedResource() as res:
    print("正在读取:", res.read())
    # 故意抛个异常看看 __exit__ 的行为
    # raise ValueError("故意的错误")

print("with 块外的代码继续执行...")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 不用 with：文件可能没有正确关闭
f = open("example.txt", "w")
f.write("Hello")
# 如果这中间抛出异常，f.close() 就不会被调用！
f.close()

# 用 try...finally：啰嗦
f = open("example.txt", "w")
try:
    f.write("Hello")
finally:
    f.close()  # 终于关了

# 用 with：优雅、安全、简洁
with open("example.txt", "w") as f:
    f.write("Hello")
# 自动关闭，即使 write 时出错也会关闭

# Python 2.7+ 支持同时打开多个文件（用逗号分隔）
with open("input.txt") as fin, open("output.txt", "w") as fout:
    content = fin.read()
    fout.write(content.upper())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 定义一个简单的装饰器
def log_calls(func):
    """记录函数调用次数的装饰器"""
    def wrapper(*args, **kwargs):
        print("🔔 调用函数: %s" % func.__name__)
        result = func(*args, **kwargs)
        print("✅ 函数执行完毕")
        return result
    return wrapper

# 使用 @decorator 语法糖
@log_calls
def say_hello(name):
    print("你好，%s！" % name)

# 等价于：say_hello = log_calls(say_hello)

say_hello("小明")
# 🔔 调用函数: say_hello
# 你好，小明！
# ✅ 函数执行完毕

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

def bold(func):
    """加粗装饰器"""
    def wrapper(*args, **kwargs):
        return "**" + func(*args, **kwargs) + "**"
    return wrapper

def italic(func):
    """斜体装饰器"""
    def wrapper(*args, **kwargs):
        return "*" + func(*args, **kwargs) + "*"
    return wrapper

@bold
@italic
def greet(name):
    return "Hello, " + name

print(greet("World"))
# ** *Hello, World* ** —— 先 italic，再 bold

# 等价于：greet = bold(italic(greet))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

def repeat(times):
    """带参数的装饰器"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            result = []
            for _ in range(times):
                result.append(func(*args, **kwargs))
            return result
        return wrapper
    return decorator

@repeat(times=3)
def greet(name):
    return "Hello, %s!" % name

print(greet("Alice"))
# ['Hello, Alice!', 'Hello, Alice!', 'Hello, Alice!']

# 使用场景：日志记录、重试机制、性能计时
import time

def timer(func):
    """计时装饰器"""
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print("⏱️ %s 执行耗时: %.4f 秒" % (func.__name__, end - start))
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)
    return "Done"

slow_function()
# ⏱️ slow_function 执行耗时: 1.0023 秒

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# Python 2 风格的元类
class LowerCaseMeta(type):
    """将所有属性名转换为小写的元类"""
    def __new__(mcs, name, bases, dict):
        # 将所有属性名转为小写
        new_dict = {}
        for key, value in dict.items():
            if not key.startswith('_'):
                new_dict[key.lower()] = value
            else:
                new_dict[key] = value
        return super(LowerCaseMeta, mcs).__new__(mcs, name, bases, new_dict)

class MyClass(object):
    __metaclass__ = LowerCaseMeta
    
    Name = "Alice"    # 自动变成 name
    Age = 25           # 自动变成 age
    
print(MyClass.name)   # Alice
print(MyClass.age)    # 25

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# type() 的三种用法：查看类型
print(type(123))        # <class 'int'>
print(type("hello"))    # <class 'str'>

# type() 的第四种用法：动态创建类
# type(name, bases, dict)
# name: 类名，bases: 父类元组，dict: 属性字典

DogClass = type('Dog', (), {
    'species': 'Canis familiaris',
    'speak': lambda self: "Woof!",
    '__init__': lambda self, name: setattr(self, 'name', name)
})

dog = DogClass("Buddy")
print(dog.name)           # Buddy
print(dog.species)        # Canis familiaris
print(dog.speak())        # Woof!

# 更复杂的动态类创建
def add_method(cls, method_name, func):
    """动态给类添加方法"""
    setattr(cls, method_name, func)
    return cls

Dog = type('Dog', (), {'species': 'dog'})
Dog = add_method(Dog, 'bark', lambda self: "Woof!")
print(Dog().bark())  # Woof!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# Python 2 print 语句
print "Hello, World!"                    # 基本用法
print "Hello,", name                     # 逗号分隔，自动加空格
print "Hello,", "Python", "!"            # 多个参数
print                                   # 打印空行

# 重定向到文件
print >> file_handle, "写入文件的内容"

# 禁止换行（Python 2 的技巧）
print "内容",
print "不换行",
print "继续"    # Hello World

# 条件打印
if True:
    print "条件成立时才打印"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# Python 3 print 函数
print("Hello, World!")                    # 基本用法
print("Hello", "Python", "!")             # 逗号分隔自动加空格
print("不换行", end="")                   # 自定义 end 参数
print(" 接着打")                          # 不会换行

# sep 参数控制分隔符
print("a", "b", "c", sep=" | ")           # a | b | c

# 输出到文件
with open("output.txt", "w") as f:
    print("写入文件", file=f)

# flush 参数：立即刷新输出
print("正在加载...", end="", flush=True)
import time
time.sleep(1)
print("完成!")

# 格式化输出（结合字符串方法）
name = "小明"
score = 98.5
print("{} 的分数是 {:.1f}".format(name, score))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# Python 2 —— 危险！
# 假设用户输入：__import__('os').system('ls')
name = input("请输入你的名字：")  # 用户输入 __import__('os').system('dir')
# 结果：你的电脑执行了 dir 命令！！！

# 另一个例子：输入 1 + 1
result = input("请输入一个表达式：")  # 用户输入 1 + 1
print(result)  # 2 —— 因为 eval("1 + 1") == 2

# 危险操作：输入 os.remove('/etc/passwd') 试试？
# （请不要真的尝试）

1
2
3
4
5
6
7
8

# Python 2 raw_input() —— 安全
name = raw_input("请输入你的名字：")  # 用户的输入被当作纯字符串
print(name)                            # 打印输入的内容，不会执行

# 想要数字？自己转换
age = int(raw_input("请输入你的年龄："))  # 转换为整数
print(age + 10)                         # 数学运算

1
2
3
4
5
6
7

# print() 函数签名（Python 3）
# print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

# *objects: 任意多个对象，会被转换为字符串并打印
print("a", "b", "c", 1, 2, 3)
# a b c 1 2 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# sep: 分隔符，默认是一个空格
print("apple", "banana", "cherry", sep=", ")
# apple, banana, cherry

# end: 结尾字符，默认是换行符
print("第一行", end=" ")
print("同一行")          # 第一行 同一行

# file: 输出目标，默认是标准输出
with open("log.txt", "w") as f:
    print("日志条目", file=f)  # 写入文件

# flush: 是否立即刷新
import time
print("正在连接...", end="", flush=True)
time.sleep(2)
print("连接成功!")

# 组合使用：打印进度条风格
for i in range(101):
    print("\r进度: %d%%" % i, end="", flush=True)
    time.sleep(0.02)
print("\n下载完成！")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# Python 3: / 永远是真除法（返回 float）
print(5 / 2)      # 2.5 —— 不是 2！
print(10 / 2)     # 5.0 —— float，不是 int

# Python 3: // 永远是地板除法（返回 int 对 int，结果向下取整）
print(5 // 2)     # 2 —— 向下去整
print(-5 // 2)    # -3 —— 地板除法：向负无穷取整

# Python 2 的行为（如果你非要去回忆）
# 5 / 2 == 2（整数除法，向下取整）
# 5.0 / 2 == 2.5（浮点除法）

# 所以 Python 3 的代码更可预测
print(7 // 3)     # 2
print(7 / 3)      # 2.3333333333333335

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 地板除法（向负无穷取整）vs 截断除法（向零取整）
print(-7 // 3)    # -3 —— 地板除法：-2.333... 向下取整
print(-7 / 3)     # -2.333... —— 真除法

print(7 // -3)    # -3 —— 地板除法：-2.333... 向下取整
print(7 / -3)     # -2.333...

print(-7 // -3)   # 2 —— 2.333... 向下取整还是 2

# math.floor() 和 // 的关系
import math
print(math.floor(-2.5))    # -3
print(-7 // 3)             # -3 —— 相当于 floor(7/3)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Python 3: str 是 Unicode 字符串
text = "你好，Python 3！"
print(type(text))         # <class 'str'>
print(len(text))          # 12（字符数，不是字节数！）

# Python 3: bytes 是原始字节
data = b"Hello"           # b 前缀表示 bytes
print(type(data))        # <class 'bytes'>
print(data[0])            # 72（第一个字符的 ASCII 码）

# 字符串和字节是两种完全不同的类型，不能直接拼接
try:
    "Hello" + b"World"
except TypeError as e:
    print("错误：不能混合 str 和 bytes！")
# 错误：不能混合 str 和 bytes！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 编码：str -> bytes
text = "你好"
utf8_bytes = text.encode('utf-8')
print(utf8_bytes)                    # b'\xe4\xb8\xad\xe5\xa5\xbd'
print(len(utf8_bytes))               # 6（UTF-8 编码的中文每个字 3 字节）

# 其他编码
gbk_bytes = text.encode('gbk')
print(gbk_bytes)                    # b'\xc4\xe3\xba\xc3'
print(len(gbk_bytes))               # 4（GBK 编码的中文每个字 2 字节）

# 解码：bytes -> str
decoded = utf8_bytes.decode('utf-8')
print(decoded)                       # 你好

# 解码错误示例：UTF-8 编码的字节用 GBK 解码会出错
try:
    gbk_bytes.decode('utf-8')
except UnicodeDecodeError as e:
    print("解码错误！%s" % e)
# 解码错误！'charmap' codec can't decode byte...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# Python 3 range() —— 惰性序列
r = range(10)
print(type(r))         # <class 'range'>
print(r)               # range(0, 10)
print(len(r))          # 10
print(5 in r)           # True —— range 支持 in 操作符

# range 不存储所有值，只存储起始、结束、步长
import sys
print(sys.getsizeof(range(1000000)))  # 48 字节 —— 很小！
print(sys.getsizeof(list(range(1000000))))  # 8MB —— 很大！

# Python 2 的教训
# r = range(1000000)  # 创建了 0-999999 的列表，内存爆炸
# xrange(1000000)     # 惰性的，内存友好

1
2
3
4
5
6
7
8
9

# range 的切片
r = range(0, 20, 2)
print(list(r))            # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
print(list(r[2:6]))        # [4, 6, 8, 10] —— 切片
print(list(r[::3]))       # [0, 6, 12, 18] —— 步长切片

# 负数索引
print(r[-2])              # 16 —— 支持负数索引

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# raise...from... 语法：显式异常链
try:
    int("not a number")
except ValueError as e:
    raise RuntimeError("转换失败") from e
# RuntimeError: 转换失败
# The above exception was the direct cause of the following exception:
# ValueError: invalid literal for int() with base 10: 'not a number'

# 使用 `from None` 抑制异常链
try:
    int("not a number")
except ValueError as e:
    raise RuntimeError("转换失败") from None
# RuntimeError: 转换失败
# （不再显示原始异常）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

try:
    int("not a number")
except ValueError as original:
    try:
        raise RuntimeError("转换失败") from original
    except RuntimeError as new_exc:
        print("新异常:", new_exc)
        print("原始异常（__cause__）:", new_exc.__cause__)
        print("是否显式链接:", new_exc.__suppress_context__)

# 新异常: 转换失败
# 原始异常（__cause__）: invalid literal for int() with base 10: 'not a number'
# 是否显式链接: False —— False 表示用了 `from cause`，True 表示隐式链接

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 扩展解包：用 * 捕获中间或开头的多个元素
data = [1, 2, 3, 4, 5]

# 头部 + 尾部
first, *middle, last = data
print(first)   # 1
print(middle)  # [2, 3, 4] —— 剩余元素打包成列表
print(last)    # 5

# 只取头部
head, *tail = data
print(head)    # 1
print(tail)    # [2, 3, 4, 5]

# 只取尾部
*head, tail = data
print(head)    # [1, 2, 3, 4]
print(tail)    # 5

# 在函数调用中解包
def func(a, b, c, d, e):
    return (a, b, c, d, e)

result = func(*[1, 2, 3, 4, 5])  # 解包列表作为位置参数
print(result)  # (1, 2, 3, 4, 5)

# 解包字符串（字符串是可迭代的）
a, *b, c = "Hello"
print(a, b, c)  # H ['e', 'l', 'l'] o

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

def func(a, b, *args, **kwargs):
    """*args 收集额外位置参数，**kwargs 收集额外关键字参数"""
    print("必需参数: a=%s, b=%s" % (a, b))
    print("额外位置参数: %s" % (args,))
    print("额外关键字参数: %s" % kwargs)

func(1, 2, 3, 4, 5, name="Alice", age=25)
# 必需参数: a=1, b=2
# 额外位置参数: (3, 4, 5)
# 额外关键字参数: {'name': 'Alice', 'age': 25}

# 用 * 解包元组传参
args = (1, 2, 3)
kwargs = {"name": "Bob", "city": "Beijing"}
func(*args, **kwargs)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

def func(a, b, *, c, d):
    """星号 * 之后，c 和 d 必须用关键字传参"""
    print(a, b, c, d)

func(1, 2, c=3, d=4)   # OK: 1 2 3 4
func(1, 2, 3, 4)       # TypeError: func() takes 2 positional arguments but 4 were given

# 更复杂的例子：*args 之后都是 keyword-only
def make_dish(dish_name, *ingredients, spicy=False, vegetarian=True):
    print("菜品: %s" % dish_name)
    print("配料: %s" % list(ingredients))
    print("辣: %s, 素食: %s" % (spicy, vegetarian))

make_dish("宫保鸡丁", "鸡肉", "花生", "干辣椒", spicy=True)
# 菜品: 宫保鸡丁
# 配料: ['鸡肉', '花生', '干辣椒']
# 辣: True, 素食: True

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# async def 定义协程函数
async def fetch_data():
    """一个协程函数（不是普通函数）"""
    print("开始获取数据...")
    await asyncio.sleep(1)  # 模拟异步 I/O
    return {"id": 1, "name": "Alice"}

# 调用协程函数返回一个协程对象
coro = fetch_data()
print(type(coro))  # <class 'coroutine'>

# 用 asyncio.run() 运行协程（Python 3.7+）
import asyncio

async def main():
    result = await fetch_data()
    print("获取到数据:", result)

asyncio.run(main())
# 开始获取数据...
# 获取到数据: {'id': 1, 'name': 'Alice'}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import asyncio

async def get_user():
    await asyncio.sleep(0.5)
    return {"id": 1, "name": "Alice"}

async def get_permissions(user_id):
    await asyncio.sleep(0.3)
    return ["read", "write", "delete"]

async def main():
    # 顺序执行：总耗时 0.5 + 0.3 = 0.8 秒
    user = await get_user()
    perms = await get_permissions(user["id"])
    print(user, perms)
    
    # 如果想并发执行，用 asyncio.gather
    user2, perms2 = await asyncio.gather(
        get_user(),
        get_permissions(2)
    )
    print(user2, perms2)

asyncio.run(main())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

import asyncio

async def async_generator():
    """异步生成器：yield 值而不是返回"""
    for i in range(3):
        await asyncio.sleep(0.5)
        yield i

async def main():
    # async for 遍历异步生成器
    async for value in async_generator():
        print("获取到:", value)

asyncio.run(main())
# 获取到: 0
# 获取到: 1
# 获取到: 2

# 普通 for 循环在异步上下文中也可以用，但不推荐
# 因为普通循环不会让出控制权给事件循环

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import asyncio

class AsyncDatabase:
    """模拟异步上下文管理器"""
    async def __aenter__(self):
        print("建立异步数据库连接...")
        await asyncio.sleep(0.1)
        return self
    
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        print("关闭异步数据库连接...")
        await asyncio.sleep(0.1)
        return False
    
    async def query(self, sql):
        await asyncio.sleep(0.2)
        return f"执行: {sql}"

async def main():
    async with AsyncDatabase() as db:
        result = await db.query("SELECT * FROM users")
        print(result)

asyncio.run(main())
# 建立异步数据库连接...
# 执行: SELECT * FROM users
# 关闭异步数据库连接...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# f-string 基本用法
name = "Alice"
age = 25
print(f"Hello, {name}! You are {age} years old.")
# Hello, Alice! You are 25 years old.

# 变量名和字面量混合
x = 10
y = 20
print(f"{x} + {y} = {x + y}")
# 10 + 20 = 30

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 在 f-string 中使用任意表达式
print(f"{2 ** 10}")           # 1024
print(f"{'hello'.upper()}")   # HELLO
print(f"{len('Python')}")     # 6

# 三元表达式
status = "success"
print(f"Result: {'✅' if status == 'success' else '❌'}")
# Result: ✅

# 调用函数
def greet(name):
    return f"Hello, {name}!"

print(f"{greet('Bob')}")
# Hello, Bob!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

x = 42
y = "hello"

# Python 3.8+ 调试格式
print(f"{x=}")
# x=42

print(f"{x + 5=}")
# x + 5=47

print(f"{y.upper()=}")
# y.upper()='HELLO'

# 更实用的调试场景
a = [1, 2, 3]
print(f"{a=}")
# a=[1, 2, 3]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

from datetime import datetime

# 浮点数格式化
pi = 3.1415926
print(f"{pi:.2f}")    # 3.14
print(f"{pi:.4f}")    # 3.1416

# 整数格式化
num = 42
print(f"{num:05d}")   # 00042 —— 补零
print(f"{num:+d}")   # +42 —— 显示正号

# 百分比
ratio = 0.758
print(f"{ratio:.1%}")   # 75.8%

# 千分位分隔符
big_num = 1234567
print(f"{big_num:,}")   # 1,234,567

# 日期格式化
now = datetime(2024, 7, 15, 10, 30)
print(f"{now:%Y年%m月%d日 %H:%M}")
# 2024年07月15日 10:30

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

class Person:
    def __init__(self, name):
        self.name = name
    
    def __repr__(self):
        return f"Person(name={self.name!r})"
    
    def __str__(self):
        return self.name

p = Person("Alice")

print(f"{p!s}")   # Alice —— str()
print(f"{p!r}")   # Person(name='Alice') —— repr()
print(f"{p!a}")   # Person(name='Alice') —— ascii()

# 组合使用：格式规格 + 转换标志
value = 3.14159
print(f"{value:.2f!r}")  # 3.14 —— 先格式化，再 repr

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# Python 3.11 及之前的问题
name = "Alice"
# print(f"{name:30}\t age: {age}")  # \t 在 f-string 中不能有！

# Python 3.12：解除了一些限制
# 可以在 f-string 中使用反斜杠（3.11 不行）
print(f"\u4e2d\u6587")  # Python 3.12 OK，3.11 Error

# Python 3.12：可以写多行 f-string
message = f"""
    姓名: {name}
    年龄: {age}
"""
print(message)

# Python 3.12：支持更复杂的引号嵌套
print(f"{'单引号\'s'}")  # 更灵活的引号处理

1
2
3
4
5
6

# 海象表情： := 
#   := 
# /  \  （两只眼睛 + 嘴巴）
# 
# 哈哈哈，真的很像！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 场景1：避免重复计算
data = [1, 2, 3, 4, 5]

# Python 3.8 之前：要么先赋值，要么重复计算
result = [x ** 2 for x in data if x ** 2 > 10]
# x ** 2 被计算了两次，效率低下！

# 海象运算符：一次计算，两次使用
result = [square for x in data if (square := x ** 2) > 10]
print(result)  # [16, 25]

# 场景2：在 while 循环中边读边判断
import sys

# Python 3.8 之前：笨拙
# line = sys.stdin.readline()
# while line:
#     print(line.strip())
#     line = sys.stdin.readline()

# 海象运算符：优雅
while (line := sys.stdin.readline().strip()):
    print(line)

# 场景3：在条件表达式中赋值
if (n := len(data)) > 10:
    print(f"数据量{n}太大！")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 滥用示例：可读性灾难
result = [(a := 1, b := 2, c := 3) for a in range(10) if (b := a * 2) > (c := a + 10)]

# 滥用示例：作用域混淆
a = 10
if (a := 20) > 15:
    print(a)  # 打印的是哪个 a？—— 是内部的 20，不是外部的 10
print(a)      # 还是 20！—— 变量被修改了！

# 最佳实践：
# 1. 只在确实能提高可读性时使用
# 2. 不要在一个表达式中嵌套多个 :=
# 3. 谨慎使用，因为它会修改变量作用域

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

def f(pos_only, /, pos_or_kw, *, kw_only):
    """混合参数类型的函数"""
    print(f"pos_only={pos_only}, pos_or_kw={pos_or_kw}, kw_only={kw_only}")

# 位置参数-only：只能通过位置传参
# f(pos_only=1)  # TypeError! 不能用关键字
f(1, 2, kw_only=3)  # OK

# 普通参数：位置或关键字都行
f(1, pos_or_kw=2, kw_only=3)  # OK

# keyword-only 参数：必须用关键字
# f(1, 2, 3)  # TypeError! kw_only 必须用关键字
f(1, 2, kw_only=3)  # OK

# 总结：
# / 左边的：必须位置传参
# / 和 * 之间的：位置或关键字都行
# * 右边的：必须关键字传参

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 场景1：强制 API 的某些参数必须位置传参
def create_user(username, /, *, age, email):
    """username 必须位置传参，age 和 email 必须关键字传参"""
    print(f"创建用户: {username}, {age}, {email}")

create_user("alice", age=25, email="alice@example.com")  # OK
# create_user("alice", 25, "alice@example.com")  # TypeError

# 场景2：避免参数名冲突
def process(data, *, filter=None):
    """filter 是关键字参数，不会和 data 中的 key 冲突"""
    print(data, filter)

# 场景3：提高性能
# 位置参数比关键字参数更快（不需要解析参数名），对性能敏感的 API 很有用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 字典合并：d1 | d2 —— 返回一个新字典
d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}

merged = d1 | d2
print(merged)
# {'a': 1, 'b': 3, 'c': 4}
# 注意：d2 的值会覆盖 d1 的值（b: 2 变成了 b: 3）

# 链式合并
d3 = {"x": 100}
chained = d1 | d2 | d3
print(chained)
# {'a': 1, 'b': 3, 'c': 4, 'x': 100}