Python 高级语法速览

1
def func(a, b=10, *args, **kwargs):
2
    # a        → 位置参数（必填）
3
    # b=10     → 默认参数
4
    # *args    → 接收多余位置参数，打包为 tuple
5
    # **kwargs → 接收多余关键字参数，打包为 dict
6
    print(a, b, args, kwargs)
7

8
func(1, 2, 3, 4, x=5)  # 1 2 (3, 4) {'x': 5}

1
def connect(*, host, port):   # * 后面的参数必须用关键字传入
2
    print(host, port)
3

4
connect(host="localhost", port=3306)  # ✅
5
# connect("localhost", 3306)         # ❌ TypeError

1
square = lambda x: x ** 2
2
# 常与 sorted / map / filter 搭配
3
nums = [3, 1, 4, 1, 5]
4
sorted(nums, key=lambda x: -x)       # [5, 4, 3, 1, 1]
5
list(map(lambda x: x * 2, nums))     # [6, 2, 8, 2, 10]
6
list(filter(lambda x: x > 2, nums))  # [3, 4, 5]

1
def make_counter():
2
    count = 0
3
    def counter():
4
        nonlocal count    # 声明修改外层变量
5
        count += 1
6
        return count
7
    return counter
8

9
c = make_counter()
10
print(c(), c(), c())  # 1 2 3

1
// 基本语法示例
2
a: int=597 #则a

1
// 基本语法示例
2
def A(scores: list[int])-> float/tuple[?，？，？]

1
// 代码示例

1
# 任何实现了 __iter__() 和 __next__() 的对象都是迭代器
2
it = iter([1, 2, 3])
3
next(it)  # 1
4
next(it)  # 2

1
def countdown(n):
2
    while n > 0:
3
        yield n       # 暂停并返回值，下次从这里继续
4
        n -= 1
5

6
for i in countdown(3):
7
    print(i)   # 3 2 1

1
# 列表推导 → 一次性全部存入内存
2
squares_list = [x**2 for x in range(1000000)]
3

4
# 生成器表达式 → 按需生成，几乎不占内存
5
squares_gen  = (x**2 for x in range(1000000))

1
def flatten(nested):
2
    for item in nested:
3
        if isinstance(item, list):
4
            yield from flatten(item)   # 递归委托
5
        else:
6
            yield item
7

8
list(flatten([1, [2, [3, 4], 5], 6]))  # [1, 2, 3, 4, 5, 6]

1
// 基本语法示例
2
__str__

1
class A:
2
    def greet(self): return "A"
3
class B(A):
4
    def greet(self): return "B"
5
class C(A):
6
    def greet(self): return "C"
7
class D(B, C): pass
8

9
d = D()
10
print(d.greet())            # B（按 MRO 顺序：D → B → C → A）
11
print(D.__mro__)            # 查看方法解析顺序

1
class B(A):
2
    def greet(self):
3
        return super().greet() + " + B"   # A + B

1
from abc import ABC, abstractmethod
2

3
class Shape(ABC):
4
    @abstractmethod
5
    def area(self): ...         # 子类必须实现
6

7
class Rect(Shape):
8
    def __init__(self, w, h):
9
        self.w, self.h = w, h
10
    def area(self):
11
        return self.w * self.h
12

13
# Shape()         # ❌ 不能实例化抽象类
14
r = Rect(3, 4)    # ✅

1
#基本语法
2
#多项匹配，相当于分岔路
3
try:
4
    result = 10 / 0
5
except ZeroDivisionError as e:
6
    print(f"错误: {e}")       # 捕获特定异常
7
except (TypeError, ValueError):
8
    print("类型或值错误")       # 同时捕获多种
9
except Exception as e:
10
    print(f"未知错误: {e}")    # 兜底
11
else:
12
    print("没有异常时执行")
13
finally:
14
    print("无论如何都执行")     # 清理资源

1
class AppError(Exception):
2
    def __init__(self, code, msg):
3
        self.code = code
4
        self.msg = msg
5
    def __str__(self):
6
        return f"[{self.code}] {self.msg}"
7

8
raise AppError(404, "资源未找到")

1
try:
2
    open("不存在.txt")
3
except FileNotFoundError as e:
4
    raise ValueError("配置文件缺失") from e   # 保留原始异常

1
# 读写
2
with open("data.txt", "r", encoding="utf-8") as f:
3
    content = f.read()          # 全部读取
4
    # lines = f.readlines()    # 按行读取为 list
5
    # for line in f:           # 逐行迭代（最省内存）
6
    #     print(line.strip())
7

8
with open("out.txt", "w", encoding="utf-8") as f:
9
    f.write("Hello\n")
10

11
# 常用模式: "r"读 / "w"写(覆盖) / "a"追加 / "rb"二进制读

1
class Timer:
2
    def __enter__(self):
3
        import time
4
        self.start = time.time()
5
        return self              # as 后面绑定的对象
6

7
    def __exit__(self, exc_type, exc_val, exc_tb):
8
        self.elapsed = time.time() - self.start
9
        print(f"耗时: {self.elapsed:.4f}s")
10
        return False             # True=吞掉异常, False=继续抛出
11

12
with Timer() as t:
13
    sum(range(1000000))
14
# 耗时: 0.0312s

1
from contextlib import contextmanager
2

3
@contextmanager
4
def timer():
5
    import time
6
    start = time.time()
7
    yield                        # yield 之前 = __enter__，之后 = __exit__
8
    print(f"耗时: {time.time()-start:.4f}s")
9

10
with timer():
11
    sum(range(1000000))

1
from functools import lru_cache, reduce, partial
2

3
# lru_cache — 自动缓存（记忆化）
4
@lru_cache(maxsize=128)
5
def fib(n):
6
    return n if n < 2 else fib(n-1) + fib(n-2)
7

8
# reduce — 累积运算
9
reduce(lambda a, b: a + b, [1, 2, 3, 4])  # 10
10

11
# partial — 固定部分参数
12
int2 = partial(int, base=2)
13
int2("1010")                     # 10

1
import itertools
2

3
# 排列组合
4
list(itertools.permutations("ABC", 2))   # [('A','B'),('A','C'),('B','A'),...]
5
list(itertools.combinations("ABC", 2))   # [('A','B'),('A','C'),('B','C')]
6

7
# 链接多个可迭代对象
8
list(itertools.chain([1,2], [3,4]))      # [1, 2, 3, 4]
9

10
# 分组（需先排序）
11
data = sorted(["apple","banana","avocado","blueberry"], key=lambda x: x[0])
12
for k, g in itertools.groupby(data, key=lambda x: x[0]):
13
    print(k, list(g))
14
# a ['apple', 'avocado']  b ['banana', 'blueberry']

1
from pathlib import Path
2

3
p = Path("data") / "logs" / "app.log"   # 自动拼接路径
4
p.exists()                               # 是否存在
5
p.parent                                 # 父目录
6
p.suffix                                 # .log
7
p.stem                                   # app
8
p.read_text(encoding="utf-8")            # 读取内容
9
p.write_text("hello", encoding="utf-8")  # 写入内容
10
list(Path(".").glob("**/*.py"))           # 递归查找所有 .py

1
# 赋值的同时用于表达式，减少重复计算
2
if (n := len("hello")) > 3:
3
    print(f"长度 {n} 超过 3")    # 长度 5 超过 3
4

5
# while 循环中常用
6
while (line := input("输入: ")) != "quit":
7
    print(f"你输入了: {line}")
8

9
# 列表推导中过滤并复用
10
data = [1, 5, 12, 3, 20]
11
results = [y for x in data if (y := x * 2) > 10]  # [24, 6, 40]