1
# 整数缓存机制（-5 到 256）
2
a = 256
3
b = 256
4
print(a is b)  # True - 缓存范围内
5

6
a = 257
7
b = 257
8
print(a is b)  # False - 超出缓存范围
9

10
# 进制表示
11
hex_val = 0xFF     # 十六进制 -> 255
12
bin_val = 0b1010   # 二进制 -> 10
13
oct_val = 0o17     # 八进制 -> 15
14

15
# 下划线分隔符（Python 3.6+）
16
million = 1_000_000
17
version = 3_.11_._version
18

19
# 复数
20
c = 3 + 4j
21
print(c.real)  # 3.0
22
print(c.imag)  # 4.0
23
print(abs(c))  # 5.0 (模)

1
# 字符串驻留
2
s1 = "hello"
3
s2 = "hello"
4
print(s1 is s2)  # True - 字符串驻留
5

6
# 使用格式化或拼接时可能不同
7
s1 = "hello world"
8
s2 = "hello " "world"  # 编译时确定
9
print(s1 is s2)  # True
10

11
s1 = "hello"
12
s2 = "".join(["hel", "lo"])
13
print(s1 is s2)  # False - 运行时拼接
14

15
# 原始字符串
16
path = r"C:\Users\newfolder"  # 不转义
17

18
# f-string (Python 3.6+)
19
name = "Alice"
20
age = 30
21
print(f"Name: {name}, Age: {age}")
22
print(f"Age in 5 years: {age + 5}")
23
print(f"Math: {2 * 3 = }")  # Python 3.8+: 2 * 3 = 6

1
# 列表值相等但身份不同
2
a = [1, 2, 3]
3
b = [1, 2, 3]
4
print(a == b)  # True - 值相等
5
print(a is b)  # False - 对象不同
6

7
# 单例对象
8
a = None
9
b = None
10
print(a is b)  # True - None 是单例

1
# Python 整数缓存范围：-5 到 256
2
# 这是 CPython 的实现细节，其他实现可能不同
3

4
# 缓存范围内的整数
5
x = 256
6
y = 256
7
print(x is y)  # True
8

9
# 超出缓存范围
10
x = 257
11
y = 257
12
print(x is y)  # False
13

14
# 编译时常量
15
x = 1000
16
y = 500 + 500  # 编译时计算结果
17
print(x is y)  # 可能为 True（Python 优化）
18

19
x = 1000
20
y = 500
21
z = x + 0
22
print(x is z)  # 可能为 False

1
# 简单字符串（字母、数字、下划线）会被驻留
2
s1 = "hello"
3
s2 = "hello"
4
print(s1 is s2)  # True
5

6
# 字符串拼接
7
s1 = "hello world"
8
s2 = "hello " "world"  # 编译时合并
9
print(s1 is s2)  # True
10

11
s1 = "hello"
12
s2 = "hel" + "lo"
13
print(s1 is s2)  # 可能为 True
14

15
# 运行时拼接不驻留
16
s1 = "hello"
17
s2 = "".join(["hel", "lo"])
18
print(s1 is s2)  # False

1
import copy
2

3
original = [[1, 2, 3], [4, 5, 6]]
4

5
# 1. 赋值：共享引用
6
assign = original
7
print(assign is original)  # True
8

9
# 2. 浅拷贝：只拷贝第一层
10
shallow = copy.copy(original)
11
print(shallow is original)  # False
12
print(shallow[0] is original[0])  # True - 内部对象共享
13

14
# 3. 深拷贝：递归拷贝所有层级
15
deep = copy.deepcopy(original)
16
print(deep is original)  # False
17
print(deep[0] is original[0])  # False - 完全独立

1
# 列表拷贝的几种方式
2
lst = [1, 2, 3]
3

4
# 切片拷贝
5
lst_copy1 = lst[:]
6

7
# list() 拷贝
8
lst_copy2 = list(lst)
9

10
# copy() 方法
11
lst_copy3 = lst.copy()
12

13
# 字典拷贝
14
d = {"a": 1, "b": [1, 2]}
15
d_shallow = d.copy()  # 浅拷贝
16
d_deep = copy.deepcopy(d)  # 深拷贝
17

18
# 列表推导式
19
lst_copy = [x for x in lst]
20

21
# 列表生成器
22
gen = (x for x in range(10))  # 生成器，非拷贝

1
# 陷阱1：可变默认值参数
2
def append_to(element, target=[]):  # 危险！
3
    target.append(element)
4
    return target
5

6
print(append_to(1))  # [1]
7
print(append_to(2))  # [1, 2] - 不是 [2]！
8

9
# 正确做法
10
def append_to_fixed(element, target=None):
11
    if target is None:
12
        target = []
13
    target.append(element)
14
    return target
15

16
# 陷阱2：循环引用
17
class Node:
18
    def __init__(self, value):
19
        self.value = value
20
        self.next = None
21

22
a = Node(1)
23
b = Node(2)
24
a.next = b  # a -> b
25
b.next = a  # b -> a (循环引用)
26

27
# deepcopy 可以处理循环引用
28
import copy
29
a_copy = copy.deepcopy(a)  # 正常工作

1
L - Local（局部作用域）
2
E - Enclosing（闭包作用域）
3
G - Global（全局作用域）
4
B - Built-in（内置作用域）

1
x = "global"
2

3
def outer():
4
    x = "enclosing"
5

6
    def inner():
7
        x = "local"
8
        print(x)  # "local"
9

10
    inner()
11
    print(x)  # "enclosing"
12

13
outer()
14
print(x)  # "global"

1
# global：修改全局变量
2
counter = 0
3

4
def increment():
5
    global counter
6
    counter += 1
7

8
# nonlocal：修改外层（非全局）变量
9
def outer():
10
    count = 0
11

12
    def inner():
13
        nonlocal count
14
        count += 1
15

16
    inner()
17
    print(count)  # 1
18

19
# 常见错误
20
def bad_counter():
21
    count = 0
22
    def increment():
23
        count = count + 1  # 错误！会创建新的局部变量
24
    increment()

1
# 闭包：内部函数记住外层变量
2
def make_multiplier(factor):
3
    def multiplier(number):
4
        return number * factor
5
    return multiplier
6

7
times3 = make_multiplier(3)
8
times5 = make_multiplier(5)
9
print(times3(10))  # 30
10
print(times5(10))  # 50
11

12
# 陷阱：延迟绑定
13
def create_funcs():
14
    funcs = []
15
    for i in range(3):
16
        funcs.append(lambda: i)  # 所有函数返回相同的 i
17
    return funcs
18

19
f1, f2, f3 = create_funcs()
20
print(f1())  # 2 (不是 0)
21
print(f2())  # 2 (不是 1)
22
print(f3())  # 2
23

24
# 正确做法：使用默认参数捕获值
25
def create_funcs_fixed():
26
    funcs = []
27
    for i in range(3):
28
        funcs.append(lambda i=i: i)  # i=i 捕获当前值
29
    return funcs

1
# Python 3.8: 赋值表达式
2
if (n := len(data)) > 10:
3
    print(f"List has {n} elements")
4

5
# Python 3.9: 字典合并
6
d1 = {"a": 1, "b": 2}
7
d2 = {"b": 3, "c": 4}
8
print(d1 | d2)  # {"a": 1, "b": 3, "c": 4}
9

10
# Python 3.10: match-case
11
def http_status(status):
12
    match status:
13
        case 200:
14
            return "OK"
15
        case 404:
16
            return "Not Found"
17
        case _:
18
            return "Unknown"
19

20
# Python 3.10: 结构化模式匹配
21
def get_point(point):
22
    match point:
23
        case (0, 0):
24
            return "Origin"
25
        case (x, 0):
26
            return f"X-axis at {x}"
27
        case (0, y):
28
            return f"Y-axis at {y}"
29
        case (x, y):
30
            return f"Point at ({x}, {y})"