Python 学习笔记#

a = 10
b = a       # b 和 a 指向同一个 10
a = 20      # a 换了新标签，b 还是 10
print(b)    # 10

print(type(10))           # <class 'int'>
print(type(print))        # <class 'builtin_function_or_method'>

# 数字 10 也有方法
print((10).bit_length())  # 4（二进制 1010 有 4 位）

# int 任意精度——C++ 溢出，Python 不会
big = 2 ** 100
print(big)  # 1267650600228229401496703205376

# bool 是 int 子类
print(True + True)    # 2
print(True == 1)      # True

# 不可变类型：修改 = 创建新对象
s = "hello"
print(id(s))        # 某地址
s += " world"
print(id(s))        # 不同地址！s 指向了新对象

# 可变类型：原地修改，地址不变
lst = [1, 2, 3]
print(id(lst))
lst.append(4)
print(id(lst))      # 同一个地址！

int("42")        # 42
int(3.99)        # 3（截断，不四舍五入）
float("3.14")    # 3.14
str(42)          # "42"
bool(0)          # False
bool("")         # False
bool([])         # False
bool("false")    # True！（非空字符串都是 True）

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)    # True（值相等）
print(a is b)    # False（不是同一个对象）
print(a is c)    # True（同一个对象）

# 小整数缓存：-5 ~ 256
x = 256; y = 256
print(x is y)    # True（缓存）
x = 257; y = 257
print(x is y)    # False（不缓存）

7 / 2       # 3.5     真除法（总是返回 float）
7 // 2      # 3       整除（向下取整）
7 % 2       # 1       取余
7 ** 2      # 49      幂运算
-7 // 2     # -4      注意：向下取整，不是截断！

x = 5
print(1 < x < 10)     # True，等价于 1 < x and x < 10

# and / or / not（不是 && / || / !）
# 短路求值 + 返回操作数本身（不是 bool）
print(0 or "default")      # "default"
print(3 and 5)             # 5
print(0 and 5)             # 0

if (n := len(data)) > 10:
    print(f"数据太长：{n} 行")

while (line := input("> ")) != "quit":
    print(f"你说：{line}")

score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
else:
    grade = "F"

# 条件表达式（三元运算符）
status = "成年" if age >= 18 else "未成年"

for item in [1, 2, 3]:
    print(item)

for i in range(5):        # 0, 1, 2, 3, 4
    print(i)

# enumerate——同时取索引和值
for i, item in enumerate(["a", "b", "c"]):
    print(f"{i}: {item}")

# zip——并行遍历
for name, age in zip(["Alice", "Bob"], [25, 30]):
    print(f"{name} {age}岁")

# while-else：循环正常结束（非 break）时执行 else
n = 7
i = 2
while i < n:
    if n % i == 0:
        print(f"{n} 不是质数")
        break
    i += 1
else:
    print(f"{n} 是质数")

for i in range(10):
    if i == 5: break       # 跳出循环
    if i % 2 == 0: continue # 跳过本次
    print(i)               # 1, 3, 5(不打印), 7, 9

def todo(): pass           # pass = 空操作占位符

def handle(cmd):
    match cmd.split():
        case ["quit"]: return "退出"
        case ["hello", name]: return f"你好，{name}"
        case ["search", *kw]: return f"搜索：{' '.join(kw)}"
        case _: return "未知"

print(handle("hello Alice"))  # 你好，Alice

# 创建
fruits = ["apple", "banana", "cherry"]
mixed = [1, "hello", True, 3.14]     # 可以混合类型
from_range = list(range(5))           # [0, 1, 2, 3, 4]

# 访问（支持负索引）
fruits[0]      # "apple"
fruits[-1]     # "cherry"（倒数第一个）

# 切片 [start:stop:step]
fruits[0:2]    # ["apple", "banana"]
fruits[::-1]   # 反转
fruits[::2]    # 步长2

lst = [3, 1, 4, 1, 5]

# 添加
lst.append(5)          # 末尾添加
lst.insert(0, 0)       # 指定位置插入
lst.extend([7, 8])     # 批量添加

# 删除
lst.remove(1)          # 删除第一个值为 1 的元素
lst.pop()              # 弹出末尾并返回
del lst[0]             # 删除指定位置
lst.clear()            # 清空

# 排序
lst.sort()             # 原地排序（返回 None！）
sorted_lst = sorted(lst)  # 返回新列表，不修改原列表
lst.sort(key=abs)      # 按绝对值排序
lst.sort(reverse=True) # 降序

squares = [x ** 2 for x in range(10)]
evens = [x for x in range(20) if x % 2 == 0]
labels = ["偶" if x % 2 == 0 else "奇" for x in range(5)]
pairs = [(x, y) for x in range(3) for y in range(3) if x != y]

point = (3, 4)
single = (42,)        # 单元素必须加逗号！
packed = 1, 2, 3      # 不加括号也行

# 解包
x, y = point
first, *rest = [1, 2, 3, 4]    # first=1, rest=[2, 3, 4]

# 交换变量
a, b = b, a

person = {"name": "Alice", "age": 30}

# 访问
person["name"]              # "Alice"
person.get("phone")         # None（不报错）
person.get("phone", "未填")  # 提供默认值

# 遍历
for k, v in person.items():
    print(f"{k}: {v}")

# 合并（Python 3.9+）
merged = {"a": 1} | {"b": 2}   # {"a": 1, "b": 2}

from collections import defaultdict

word_count = defaultdict(int)    # 自动初始化为 0
for word in words:
    word_count[word] += 1

groups = defaultdict(list)       # 自动初始化为空列表
for item in items:
    groups[item["category"]].append(item)

s = {1, 2, 3, 3}       # {1, 2, 3}（自动去重）

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
a | b    # 并集 {1,2,3,4,5,6}
a & b    # 交集 {3, 4}
a - b    # 差集 {1, 2}
a ^ b    # 对称差集 {1, 2, 5, 6}

# 去重
unique = list(set(duplicates_list))

# 快速成员判断（O(1) vs list 的 O(n)）
3 in a    # True

name = "Alice"
age = 30
print(f"我叫{name}，今年{age}岁")
print(f"{name:*^20}")        # 居中对齐
print(f"{3.14159:.2f}")      # 3.14
print(f"{255:#x}")           # 0xff

path = r"C:\Users\name"      # 原始字符串，不转义

s = "  Hello, World!  "
s.strip()              # "Hello, World!"
s.lower() / s.upper()
s.find("World")        # 9（找不到返回 -1）
s.replace("World", "Python")
s.split(", ")          # ["  Hello", "World!  "]
",".join(["a", "b"])   # "a,b"
"123".isdigit()        # True
"hi".startswith("h")   # True

s = "你好世界"
b = s.encode("utf-8")    # str → bytes
s2 = b.decode("utf-8")   # bytes → str

def greet(name, greeting="你好"):
    """向某人打招呼"""
    return f"{greeting}，{name}！"

greet("Alice")             # 你好，Alice！
greet("Bob", "Hi")         # Hi，Bob！
greet(name="Carol")        # 你好，Carol！

def func(*args, **kwargs):
    print(f"位置参数: {args}")    # 元组
    print(f"关键字参数: {kwargs}") # 字典

func(1, 2, 3, x=10, y=20)
# 位置参数: (1, 2, 3)
# 关键字参数: {'x': 10, 'y': 20}

# 匿名函数，适合简单的单行操作
square = lambda x: x ** 2
sorted(lst, key=lambda x: x["age"])
list(map(lambda x: x * 2, [1, 2, 3]))

# 函数可以赋值、传参、返回
def shout(text): return text.upper()
 whisper = lambda t: t.lower()

funcs = [shout, whisper]
for f in funcs:
    print(f("Hello"))

# 高阶函数
def apply_twice(func, x):
    return func(func(x))

apply_twice(lambda x: x + 3, 10)   # 16

x = "global"          # G
def outer():
    x = "enclosing"   # E
    def inner():
        x = "local"   # L
        print(x)      # → "local"
    inner()
    print(x)          # → "enclosing"
outer()
print(x)              # → "global"

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

def make_counter():
    n = 0
    def counter():
        nonlocal n    # 声明使用外层函数变量
        n += 1
        return n
    return counter

def make_multiplier(factor):
    def multiply(n):
        return n * factor    # factor 被"记住"了
    return multiply

double = make_multiplier(2)
triple = make_multiplier(3)
print(double(5))    # 10
print(triple(5))    # 15

import functools

def log_calls(func):
    @functools.wraps(func)    # 保留原函数元信息
    def wrapper(*args, **kwargs):
        print(f"调用 {func.__name__}({args}, {kwargs})")
        result = func(*args, **kwargs)
        print(f"返回 {result}")
        return result
    return wrapper

@log_calls
def add(a, b):
    return a + b

add(3, 4)
# 调用 add((3, 4), {})
# 返回 7

def repeat(times):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(times - 1):
                func(*args, **kwargs)
            return func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def say_hi(name):
    print(f"Hi {name}")

say_hi("Alice")    # 打印 3 次

# @property — 把方法变成属性
class Temperature:
    @property
    def celsius(self):
        return self._c

    @celsius.setter
    def celsius(self, value):
        self._c = value

# @staticmethod / @classmethod
class MyClass:
    @staticmethod
    def utility():
        return "不需要 self/cls"

    @classmethod
    def from_dict(cls, d):
        return cls(**d)

# @dataclass（Python 3.7+）
from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float

# 可迭代对象 Iterable：实现 __iter__()
# 迭代器 Iterator：实现 __iter__() + __next__()

class CountUp:
    def __init__(self, limit):
        self.limit = limit
        self.current = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current >= self.limit:
            raise StopIteration
        self.current += 1
        return self.current

for n in CountUp(5):
    print(n)    # 1, 2, 3, 4, 5

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fib = fibonacci()
for _ in range(10):
    print(next(fib))    # 0, 1, 1, 2, 3, 5, 8, 13, 21, 34

# 列表推导：立即创建全部元素，占 O(n) 内存
squares_list = [x ** 2 for x in range(1000000)]

# 生成器表达式：惰性求值，占 O(1) 内存
squares_gen = (x ** 2 for x in range(1000000))

print(next(squares_gen))   # 0
print(next(squares_gen))   # 1

# 求和不需要先建列表
total = sum(x ** 2 for x in range(1000000))   # 高效！

class Dog:
    species = "Canis familiaris"    # 类变量（所有实例共享）

    def __init__(self, name, age):  # 构造函数
        self.name = name            # 实例变量（每个实例独有）
        self.age = age

    def bark(self):                 # 实例方法
        return f"{self.name} says Woof!"

    @classmethod
    def from_dict(cls, d):          # 类方法（工厂模式）
        return cls(d["name"], d["age"])

    @staticmethod
    def info():                     # 静态方法（逻辑归属类）
        return "Dogs are loyal"

dog = Dog("Buddy", 3)
print(dog.bark())          # Buddy says Woof!
print(Dog.from_dict({"name": "Max", "age": 5}).bark())

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius

    @property
    def fahrenheit(self):
        return self._celsius * 9 / 5 + 32

    @fahrenheit.setter
    def fahrenheit(self, f):
        self._celsius = (f - 32) * 5 / 9

t = Temperature(100)
print(t.fahrenheit)    # 212.0（像属性一样访问）
t.fahrenheit = 32      # 像属性一样赋值
print(t._celsius)      # 0.0

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError("子类必须实现")

class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

animals = [Dog("Buddy"), Cat("Whiskers")]
for a in animals:
    print(a.speak())    # 多态：同一接口不同行为

class Robot:
    def speak(self):
        return "Beep boop"

# Robot 不继承 Animal，但有 speak() 方法
animals = [Dog("Buddy"), Cat("Whiskers"), Robot()]
for a in animals:
    print(a.speak())    # 都能调用！

class A:
    def greet(self): return "A"

class B(A):
    def greet(self): return "B"

class C(A):
    def greet(self): return "C"

class D(B, C):
    pass

print(D().greet())         # B（MRO: D → B → C → A）
print(D.__mro__)           # 查看方法解析顺序

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):       # +
        return Vector(self.x + other.x, self.y + other.y)

    def __eq__(self, other):        # ==
        return self.x == other.x and self.y == other.y

    def __repr__(self):             # repr()，面向开发者
        return f"Vector({self.x}, {self.y})"

    def __str__(self):              # str()/print()，面向用户
        return f"({self.x}, {self.y})"

v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)    # (4, 6)
print(repr(v1))   # Vector(1, 2)

class Matrix:
    def __init__(self, data):
        self.data = data

    def __getitem__(self, key):     # obj[key]
        return self.data[key]

    def __len__(self):              # len(obj)
        return len(self.data)

    def __contains__(self, item):   # item in obj
        return any(item in row for row in self.data)

    def __iter__(self):             # for x in obj
        for row in self.data:
            yield from row

class FileManager:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode

    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.file.close()
        return False    # 不吞异常

with FileManager("test.txt", "w") as f:
    f.write("Hello")    # 退出 with 块自动关闭

from dataclasses import dataclass, field

@dataclass
class Student:
    name: str
    age: int
    scores: list = field(default_factory=list)  # 可变默认值用 field

    def average(self):
        return sum(self.scores) / len(self.scores) if self.scores else 0

s = Student("Alice", 20, [90, 85, 92])
print(s)               # Student(name='Alice', age=20, scores=[90, 85, 92])
print(s.average())     # 89.0

from typing import Optional, Union, List, Dict, Callable

def greet(name: str, times: int = 1) -> str:
    return (f"Hello {name}! ") * times

def find(items: list[int], target: int) -> int | None:
    for i, item in enumerate(items):
        if item == target:
            return i
    return None

# Python 3.9+ 可以直接用 list[int], dict[str, int]
# Python 3.10+ 可以用 X | Y 代替 Union[X, Y]

try:
    result = 10 / x
except ZeroDivisionError as e:
    print(f"除零错误: {e}")
except (TypeError, ValueError) as e:
    print(f"类型/值错误: {e}")
except Exception as e:
    print(f"其他异常: {e}")
else:
    print(f"结果: {result}")    # 无异常时执行
finally:
    print("清理资源")            # 总是执行

class AppError(Exception):
    """应用基础异常"""
    pass

class ValidationError(AppError):
    def __init__(self, field, message):
        self.field = field
        super().__init__(f"{field}: {message}")

class NotFoundError(AppError):
    pass

# 使用
try:
    raise ValidationError("email", "格式不正确")
except ValidationError as e:
    print(e.field)    # email

try:
    data = json.loads(text)
except json.JSONDecodeError as e:
    raise ValueError("配置文件格式错误") from e
    # from e 保留原始异常链，traceback 会显示两者

# 推荐用 with 语句（自动关闭）
with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()          # 一次性读取
    # 或逐行
    for line in f:
        print(line.strip())

with open("output.txt", "w", encoding="utf-8") as f:
    f.write("Hello\n")
    f.writelines(["line1\n", "line2\n"])

from pathlib import Path

p = Path("docs") / "notes" / "readme.md"
p.exists()         # True/False
p.is_file()
p.parent           # Path("docs/notes")
p.suffix           # ".md"
p.stem             # "readme"
p.read_text(encoding="utf-8")     # 一行读
p.write_text("content", encoding="utf-8")

# 遍历
for f in Path(".").rglob("*.py"):
    print(f)

import json, csv, pickle

# JSON
data = {"name": "Alice", "scores": [90, 85]}
json.dumps(data)              # 序列化为字符串
json.loads(json_str)          # 反序列化
with open("d.json", "w") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

# CSV
with open("data.csv") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(row["name"], row["age"])

# pickle（仅 Python 内部，有安全风险）
with open("data.pkl", "wb") as f:
    pickle.dump(obj, f)

# mymath.py
def add(a, b): return a + b
PI = 3.14159

# main.py
import mymath
print(mymath.add(1, 2))     # 3
print(mymath.PI)

from mymath import add, PI  # 导入特定名称
from mymath import *        # 导入全部（不推荐）
import mymath as mm         # 别名

from utils.string_utils import capitalize
from utils import file_utils as fu

# module.py
def main():
    print("运行主程序")

if __name__ == "__main__":
    main()

import threading

def download(url):
    # 模拟 I/O 操作
    print(f"下载 {url}")

threads = []
for url in ["a.com", "b.com", "c.com"]:
    t = threading.Thread(target=download, args=(url,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()    # 等待所有线程完成

# GIL 保证同一时刻只有一个线程执行 Python 字节码
# 这意味着：多线程在 CPU 密集型任务中不会加速！

# CPU 密集型：多线程反而更慢（线程切换开销）
def cpu_work():
    total = sum(i * i for i in range(10**7))
    return total

# I/O 密集型：多线程有效（等待 I/O 时释放 GIL）
def io_work(url):
    response = requests.get(url)    # 等 I/O 时其他线程可以运行
    return response.text

import threading

# Lock — 互斥锁
lock = threading.Lock()
counter = 0

def safe_increment():
    global counter
    with lock:          # 自动获取/释放
        counter += 1

# 不加锁的并发写会有竞态条件！
threads = [threading.Thread(target=safe_increment) for _ in range(1000)]
for t in threads: t.start()
for t in threads: t.join()
print(counter)    # 1000（加锁后正确）

from multiprocessing import Process, Pool

def square(n):
    return n * n

if __name__ == "__main__":
    # 单进程
    p = Process(target=square, args=(5,))
    p.start()
    p.join()

    # 进程池（推荐）
    with Pool(4) as pool:
        results = pool.map(square, range(10))
        print(results)    # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]