1
列表（list）可变，元组（tuple）不可变。
2
列表用 []，元组用 ()。
3
列表支持增删改，元组创建后不能修改。
4
性能上元组略快，因为不可变所以可作为字典的键。

1
set可变，frozenset不可变。
2
set不能作为字典的键，frozenset可以。

1
列表底层是动态数组（连续内存），插入/删除O(n)，随机访问O(1)。
2
字典底层是哈希表（hash table），查找/插入/删除平均O(1)，
3
但需要处理哈希冲突（Python用开放寻址法）。
4
字典的key必须是可哈希的（不可变类型）。

1
Python3.6开始字典底层使用紧凑的哈希表实现（结合数组+索引），
2
实际会保持插入顺序。Python3.7正式将有序作为语言特性。

1
不可变对象：int、float、str、tuple、frozenset
2
可变对象：list、dict、set、自定义类实例
3

4
Python函数传参是「对象引用传递」：
5
- 函数内部修改可变对象会影响外部
6
- 函数内部对不可变对象重新赋值不会影响外部（因为创建了新对象）

1
def append_to(element, target=[]):  # 默认参数是可变对象
2
    target.append(element)
3
    return target
4

5
print(append_to(1))  # [1]
6
print(append_to(2))  # [1, 2]  ← 默认参数被记住了！

1
import copy
2

3
a = [1, 2, [3, 4]]
4
b = copy.copy(a)      # 浅拷贝：只拷贝外层，内层list还是引用
5
c = copy.deepcopy(a)  # 深拷贝：递归拷贝所有层
6

7
a[2][0] = 99
8
print(b[2][0])  # 99（浅拷贝受影响）
9
print(c[2][0])  # 3（深拷贝不受影响）

1
迭代器：实现了__iter__和__next__方法的对象。
2
生成器：用yield关键字的函数，返回生成器对象，是迭代器的一种。
3

4
yield让函数变成生成器，每次调用next()执行到yield暂停并返回值，
5
下次调用next()从断点继续执行。
6

7
好处：惰性求值，节省内存（处理大文件、无限序列时特别有用）。

1
def read_large_file(file_path):
2
    """逐行读取大文件，不会一次性加载到内存"""
3
    with open(file_path) as f:
4
        for line in f:
5
            yield line.strip()

1
__new__：静态方法，负责创建实例（分配内存），返回实例对象
2
__init__：实例方法，负责初始化实例（设置属性），无返回值
3

4
调用顺序：__new__ → __init__
5
通常不需要重写__new__，除非要实现单例模式或不可变类型。

1
== 比较值是否相等（调用__eq__方法）
2
is 比较内存地址是否相同（是否是同一个对象）
3

4
a = [1, 2, 3]
5
b = [1, 2, 3]
6
a == b  # True（值相等）
7
a is b  # False（不同对象）
8

9
c = None
10
c is None  # True（None是单例）

1
class FileManager:
2
    def __enter__(self):
3
        print("进入with块")
4
        return self  # 返回给as变量
5
    def __exit__(self, exc_type, exc_val, exc_tb):
6
        print("退出with块，清理资源")
7
        # 返回True可抑制异常
8

9
with FileManager() as f:
10
    print("执行中")

1
from contextlib import contextmanager
2
@contextmanager
3
def file_manager(filename):
4
    print("打开文件")
5
    yield
6
    print("关闭文件")

1
GIL（Global Interpreter Lock）是CPython的全局解释器锁，
2
保证同一时刻只有一个线程执行Python字节码。
3

4
影响：
5
- CPU密集型任务：多线程无法利用多核，用多进程（multiprocessing）
6
- IO密集型任务：多线程仍然有效（IO等待时释放GIL）
7
- 可以用asyncio、C扩展（如numpy）绕过GIL
8

9
Python 3.12+改进了GIL，但尚未完全移除。

1
class Dog:
2
    species = "犬科"      # 类变量
3
    def __init__(self, name):
4
        self.name = name  # 实例变量
5

6
a = Dog("旺财")
7
b = Dog("来福")
8
print(a.species)  # 犬科
9
Dog.species = "哺乳动物"
10
print(a.species)  # 哺乳动物（类变量被改了）
11
a.species = "狗"  # 创建了实例变量，不影响类变量
12
print(b.species)  # 哺乳动物

1
class A:
2
    @staticmethod
3
    def static_method():
4
        """不依赖类和实例，就是个普通函数"""
5
        return "static"
6

7
    @classmethod
8
    def class_method(cls):
9
        """依赖类本身，可以访问类变量"""
10
        return cls.__name__
11

12
# staticmethod：通过类或实例调用，没有自动传参
13
# classmethod：自动传入类作为第一个参数

1
import asyncio
2

3
async def fetch_data(url):
4
    print(f"开始下载 {url}")
5
    await asyncio.sleep(1)  # 模拟IO等待
6
    return f"{url} 的数据"
7

8
async def main():
9
    tasks = [fetch_data(f"page{i}") for i in range(3)]
10
    results = await asyncio.gather(*tasks)
11
    print(results)
12

13
asyncio.run(main())  # 3个任务并发执行，总共约1秒

1
- 环境隔离：venv / conda / poetry
2
- 依赖管理：pip freeze > requirements.txt / poetry.lock
3
- Python版本管理：pyenv
4
- 推荐现代方案：poetry（依赖管理+打包+发布一体）

1
def add(a: int, b: int) -> int:
2
    return a + b
3

4
from typing import List, Optional, Dict
5
def process(items: List[str]) -> Optional[Dict[str, int]]:
6
    if not items:
7
        return None
8
    return {item: len(item) for item in items}