Python简要入门#

1
integer = 10_000                 # int；下划线只提高可读性
2
hexadecimal = 0xff               # 255
3
big = 10 ** 100                  # 任意精度整数，受内存限制
4
decimal = 1.25                   # float
5
scientific = 2.5e-3              # 0.0025
6
text = "hello"                  # str，单引号也可以
7
enabled = True                   # bool：True / False
8
missing = None                   # 表示没有值
9
print(missing is None)           # True
10
print(None == 0, None == "")    # False False
11

12
item_2 = 2                      # 字母、数字、下划线；不能数字开头
13
数量 = 3                         # 合规的 Unicode 标识符也可以
14
PI = 3.14                       # 全大写只是常量约定，仍可重新赋值
15
# 2item = 2                     # SyntaxError
16
# class = 1                     # 不能使用关键字

1
print(7 + 3, 7 - 3, 7 * 3)      # 10 4 21
2
print(9 / 3, 7 // 3, 7 % 3)     # 3.0 2 1
3
print(2 ** 3)                   # 8，乘方
4
print(-7 // 3, -7 % 3)          # -3 2：地板除向负无穷取整
5
print(7.0 // 3)                 # 2.0：结果不一定为 int
6
print(int(-1.9))                # -1：int 转换向零截断
7

8
import math
9
print(0.1 + 0.2 == 0.3)         # False，浮点运算有舍入误差
10
print(math.isclose(0.1 + 0.2, 0.3))  # True
11
print(float("inf"))            # inf；有限浮点值的范围有限

1
print("I'm OK")
2
print('He said "OK"')
3
print("a\nb\tc\\d")         # \n 换行，\t 制表，\\ 反斜杠
4
raw = r"C:\notes\new"          # 原始字符串保留反斜杠
5
multiline = """line 1
6
line 2"""
7
# raw = r"C:\"                 # 错误：不能以奇数个反斜杠结束

1
a = "old"
2
b = a
3
a = "new"
4
print(b)                        # old：重新绑定 a 不影响 b
5

6
a = [1]
7
b = a                           # 不复制列表
8
a.append(2)
9
print(b)                        # [1, 2]：修改的是共享对象
10
a = [9]
11
print(b)                        # [1, 2]

1
print(bool(0), bool(""), bool([]), bool(None))  # 全为 False
2
print(bool("0"), bool("False"), bool([0]))    # 全为 True
3
print(True and False, True or False, not True)  # False True False
4
print("" or "default")         # default
5
print("hello" and 7)            # 7；and/or 返回操作数，不一定是 bool
6
print(False and (1 / 0))         # False；右侧不会执行
7
print(True or (1 / 0))           # True；右侧不会执行

1
print(ord("A"), chr(65))        # 65 A；ASCII 定义 128 个字符
2
print(ord("中"), "\u4e2d")    # 20013 中；Unicode 为字符分配码点
3
print(type("abc"), type(b"abc"))  # str 与 bytes
4

5
text = "中文"
6
data = text.encode("utf-8")     # str -> bytes
7
print(data.decode("utf-8"))     # 中文；bytes -> str
8
print(len(text), len(data))      # 2 6：码点数与字节数
9
print(len("e\u0301"))          # 2：一个视觉字符可包含多个码点
10
print(b"ABC"[0])                # 65：bytes 索引取得整数
11

12
# UTF-8 每个 Unicode 标量值占 1–4 字节；ASCII 内容编码兼容
13
print([len(c.encode("utf-8")) for c in ["A", "é", "中", "😀"]])
14
# [1, 2, 3, 4]

1
data = "中文".encode("gbk")
2
print(data.decode("gbk"))       # 中文；按数据的真实编码解码
3
# data.decode("utf-8")          # UnicodeDecodeError
4
# "中文".encode("ascii")        # UnicodeEncodeError
5
print(b"A\xffB".decode("utf-8", errors="ignore"))   # AB，丢弃错误字节
6
print(b"A\xffB".decode("utf-8", errors="replace"))  # A�B

1
#!/usr/bin/env python3
2
# -*- coding: utf-8 -*-
3
# Python 3 源码默认 UTF-8；编码声明不会转换文件实际编码
4
# 第一行用于 Unix 类系统直接执行脚本时选择解释器
5
print("你好")

1
# 将上面的代码保存为 hello.py；Unix 类系统还需执行权限
2
chmod +x hello.py
3
./hello.py
4
# 显式指定解释器运行，不依赖脚本执行权限
5
python3 hello.py

1
print("%s: %d, %.2f, %x" % ("item", 7, 2.718, 255))  # item: 7, 2.72, ff
2
print("[%2d] [%02d]" % (3, 3))   # [ 3] [03]：最小宽度与补零
3
print("%d%%" % 80)              # 80%
4
print("{0}: {1:.2f}".format("value", 2.718))  # value: 2.72
5
name, value = "value", 2.718
6
print(f"{name}: {value:.2f}")    # value: 2.72
7
print(f"{{result}}={2 + 3}")    # {result}=5；表达式与字面花括号

1
items = ["a", "b", "a"]        # 有序、可重复、可修改
2
print(items[0], items[-1], len(items))  # a a 3
3
items[1] = "B"
4
items.append("c")
5
items.insert(1, "x")
6
print(items)                    # ['a', 'x', 'B', 'a', 'c']
7
print(items.pop())               # c，删除并返回末项
8
print(items.pop(1))              # x，删除并返回索引 1 的项
9
# items[99]                     # IndexError；负索引也可能越界
10

11
nested = [1, "two", [3, 4]]      # 允许混合类型与嵌套
12
print(len(nested), nested[2][1]) # 3 4；len 只数最外层
13
print(len([]))                  # 0

1
empty = ()
2
single = (1,)                   # 单元素元组必须有逗号
3
number = (1)                    # 整数 1
4
t = (1, 2, 2)
5
print(t[0], t[-1], len(t))       # 1 2 3
6
# t[0] = 9                      # TypeError
7
# t.append(3)                   # AttributeError
8

9
t = (1, [2])
10
t[1].append(3)                  # 内部列表仍能修改
11
print(t)                        # (1, [2, 3])
12
# hash(t)                       # TypeError：含不可哈希元素

1
score = 85
2
if score >= 90:                 # 严格条件在前，只执行首个成立分支
3
    grade = "A"
4
elif score >= 60:
5
    grade = "B"
6
else:
7
    grade = "C"
8
print(grade, 0 <= score <= 100)  # B True；支持连续比较
9

10
if "0":                        # 非空字符串为真
11
    print("nonempty")
12

13
# text = input("年龄：")         # input 返回 str，实际交互时取消注释
14
text = "18"
15
age = int(text)                 # 计算前转换
16
print(age >= 18)                # True
17
# int("eighteen")               # ValueError
18
# "18" >= 18                    # TypeError

1
# Python 3.10+；首个模式与守卫均匹配时执行，不会贯穿后续分支
2
def classify(value):
3
    match value:
4
        case x if x < 0:        # 捕获 x，再检查守卫
5
            return "negative"
6
        case 0:
7
            return "zero"
8
        case 1 | 2:
9
            return "small"
10
        case _:                 # 无条件兜底必须放最后
11
            return "other"
12

13
print(classify(-1), classify(2), classify(8))  # negative small other
14

15
value = 7
16
match value:
17
    case captured:              # 裸名称是绑定变量，不是与旧值比较
18
        print(captured)         # 7
19

20
command = ["run", "main.py", "extra.py"]
21
match command:
22
    case ["run", first, *rest]: # 至少两个元素；rest 是列表
23
        print(first, rest)      # main.py ['extra.py']
24
    case ["stop"]:
25
        print("stopped")
26
    case _:
27
        print("unknown")
28

29
match "unknown":
30
    case "known":
31
        print("不会执行")       # 没有匹配且没有兜底：什么也不做

1
total = 0                       # 累加初值 0，不用 sum 作变量名
2
product = 1                     # 累乘初值 1
3
for n in range(1, 5):            # 包含起点、不含终点
4
    total += n
5
    product *= n
6
print(total, product)           # 10 24
7
print(list(range(3)))            # [0, 1, 2]
8
print(list(range(5, 0, -2)))      # [5, 3, 1]；步长可负，不能为 0
9

10
n = 3
11
while n > 0:
12
    print(n)                    # 3、2、1
13
    n -= 1                      # 推进状态，避免死循环；Ctrl+C 可中断

1
n = 0
2
while n < 10:
3
    n += 1                      # 放在 continue 前，保证每轮都更新
4
    if n % 2 == 0:
5
        continue                # 跳过本轮剩余代码
6
    if n > 5:
7
        break                   # 退出当前循环
8
    print(n)                    # 1、3、5
9

10
for row in range(2):
11
    for col in range(3):
12
        break                   # 仅退出内层
13
    print(row)                  # 0、1
14

15
def first_positive(values):
16
    for value in values:
17
        if value > 0:
18
            return value        # 退出整个函数
19
    return None
20

21
def unfinished():
22
    pass                        # 占位，什么也不做
23

24
print(first_positive([-1, 3, 4]), unfinished())  # 3 None

1
d = {"a": 1, "b": 2}
2
d["a"] = 9                     # 同键覆盖，不移动位置
3
d["c"] = 3
4
print(d["a"], "b" in d)        # 9 True；in 检查键
5
print(d.get("x"), d.get("x", -1))  # None -1，不插入 x
6
# d["x"]                       # KeyError
7
print(d.pop("b"))               # 2，删除并返回值
8
d["b"] = 20                    # 删除后重插排在末尾
9
print(list(d))                  # ['a', 'c', 'b']；Python 3.7+ 保证插入顺序
10

11
# 按位置取值用 list；按键频繁查询用 dict
12
values = [10, 20, 30]
13
print(values[1], values.index(20))  # 20 1；按值查找通常需遍历
14
print({"item": 20}["item"])    # 20；哈希表平均查找高效，但有空间开销

1
print(type({}), type(set()))     # dict、set；空集合必须 set()
2
s = set([1, 1, 2])
3
s.add(3)
4
s.add(3)                        # 重复添加无效果
5
print(s == {1, 2, 3}, 2 in s)    # True True；不依赖集合显示顺序
6
s.remove(3)
7
s.discard(99)                   # 不存在也不报错
8
# s.remove(99)                  # KeyError
9
# s[0]                          # TypeError：集合无位置索引
10
print(s & {2, 3})               # {2}，交集
11
print(s | {2, 3})               # {1, 2, 3}，并集
12
print(s - {2, 3})               # {1}，差集
13

14
# 字典键、集合元素必须可哈希；相等对象须有相等哈希值
15
mapping = {"name": 1, 2: "two", (3, 4): "pair"}
16
print(hash((3, 4)) == hash((3, 4)))  # True
17
# mapping[[1, 2]] = 3           # TypeError：list 不可哈希
18
# {(1, [2])}                    # TypeError：tuple 中含 list
19
# {set(), {}}                   # TypeError：set、dict 不可哈希

1
items = [3, 1, 2]
2
result = items.sort()
3
print(items, result)            # [1, 2, 3] None
4
s = "abc"
5
t = s.replace("a", "A")
6
print(s, t)                     # abc Abc；原字符串不变

1
f = abs                         # 保存函数对象
2
value = f(-4)                   # 调用并保存结果
3
print(value)                    # 4
4
# help(abs)                     # 查看函数签名与文档
5
# abs(1, 2)                     # TypeError：参数数量错误
6
# abs("a")                     # TypeError：类型不支持
7

8
print(min(3, 1), max([3, 1]), sum([3, 1]))  # 1 3 4
9
print(hex(255))                 # 0xff，返回字符串
10
print(int("12"), float("1.2"), str(12), bool([]))  # 12 1.2 12 False
11
print(int(1.9), int(-1.9))       # 1 -1

1
def absolute(x):
2
    """返回数字的绝对值。"""     # 首个字符串为 docstring
3
    if not isinstance(x, (int, float)):
4
        raise TypeError("需要数字")
5
    return x if x >= 0 else -x  # return 后不再执行函数体
6

7
print(absolute(-3), absolute.__doc__)
8
print(isinstance(True, int))    # True；若不接受 bool，需要单独排除
9
# absolute("3")                # TypeError
10

11
def pair():
12
    return 1, 2                 # 实际返回一个 tuple
13

14
x, y = pair()                   # 按位置拆包，数量须匹配
15
print((x, y))                   # (1, 2)
16

17
def display():
18
    print("hello")              # print 输出不等于返回值
19

20
def stop():
21
    return                      # 裸 return 返回 None
22

23
print(display(), stop())        # 先 hello，再 None None
24

25
import math
26
print(math.sqrt(9), math.sin(math.pi / 2), math.cos(0))  # 3.0 1.0 1.0
27
# 三角函数使用弧度；自定义函数的模块导入见第 5 节

1
def power(x, n=2):
2
    return x ** n
3

4
print(power(3), power(3, 3), power(n=3, x=2))  # 9 27 8
5

6
def describe(a, b=2, *args, mode, flag=True, **kwargs):
7
    return a, b, args, mode, flag, kwargs
8

9
print(describe(1, 3, 5, 7, mode="fast", debug=True))
10
# (1, 3, (5, 7), 'fast', True, {'debug': True})
11
# args 收集多余位置参数 -> tuple；kwargs 收集多余关键字参数 -> dict
12

13
def connect(host, *, port=80, timeout):
14
    return host, port, timeout
15

16
print(connect("localhost", timeout=3))  # ('localhost', 80, 3)
17
# 裸 * 或 *args 后的参数只能按名称传入，必填项可排在默认项后
18
# connect("localhost", 80, 3)           # TypeError
19
# def bad(a=1, b): pass                 # SyntaxError：普通必填参数不能放此处

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

4
values = [2, 3]
5
options = {"a": 2, "b": 3}
6
print(add(*values), add(**options))      # 5 5
7
# 定义时 * / ** 收集；调用时 * / ** 拆包，之后仍须符合签名
8
# add(1, a=2, b=3)                     # TypeError：a 被赋值两次
9
# add(**{"a": 1, "b": 2, "c": 3})      # TypeError：不接受 c
10
# add(1)                               # TypeError：缺少 b

1
def bad_append(x, items=[]):
2
    items.append(x)
3
    return items
4

5
print(bad_append(1))             # [1]
6
print(bad_append(2))             # [1, 2]：共享定义时创建的默认列表
7

8
def append_new(x, items=None):
9
    if items is None:
10
        items = []              # 每次省略参数时创建新列表
11
    items.append(x)
12
    return items
13

14
print(append_new(1), append_new(2))  # [1] [2]

1
def modify(items):
2
    items.append(2)              # 修改调用方共享对象
3
    items = [9]                 # 只重新绑定局部变量
4

5
items = [1]
6
modify(items)
7
print(items)                    # [1, 2]
8

9
def edit(**kwargs):
10
    kwargs["new"] = 1           # 仅修改新字典
11
    kwargs["items"].append(2)   # 嵌套列表仍共享
12

13
options = {"items": [1]}
14
edit(**options)
15
print(options)                  # {'items': [1, 2]}

1
def factorial(n):
2
    if type(n) is not int:
3
        raise TypeError("需要整数")
4
    if n < 0:
5
        raise ValueError("需要非负数")
6
    if n <= 1:
7
        return 1                # 0! = 1! = 1，终止条件
8
    return n * factorial(n - 1) # 问题规模减小
9

10
def factorial_loop(n):
11
    result = 1
12
    for value in range(2, n + 1):  # 此处约定 n 为非负整数
13
        result *= value
14
    return result
15

16
print(factorial(5), factorial_loop(5))  # 120 120
17
# factorial(-1)                 # ValueError
18
# factorial(10000)              # 通常 RecursionError；每层调用保存状态

1
def factorial_tail(n, result=1): # 约定 n 为非负整数
2
    if n <= 1:
3
        return result
4
    return factorial_tail(n - 1, result * n)
5
    # 直接返回递归结果；CPython 不消除尾调用，仍可能超出递归深度
6

7
def hanoi(n, source, helper, target):  # 约定 n >= 1
8
    if n == 1:
9
        print(source, "->", target)
10
        return
11
    hanoi(n - 1, source, target, helper)
12
    print(source, "->", target)
13
    hanoi(n - 1, helper, source, target)
14

15
print(factorial_tail(5))         # 120
16
hanoi(2, "A", "B", "C")       # A -> B；A -> C；B -> C

1
a = [0, 1, 2, 3, 4]
2
# seq[start:stop:step]：含起点、不含终点
3
print(a[:3], a[-3:], a[1:4])     # [0, 1, 2] [2, 3, 4] [1, 2, 3]
4
print(a[::2], a[::-1])           # [0, 2, 4] [4, 3, 2, 1, 0]
5
print(a[:99], a[99:])            # [0, 1, 2, 3, 4] []：边界自动裁剪
6
print(a[:-1:-1])                 # []：显式 -1 与省略反向终点不同
7
# a[::0]                        # ValueError：步长不能为 0
8
print((1, 2, 3)[:2], "hello"[::2])  # (1, 2) hlo
9

10
a = [[1], [2]]
11
b = a[:]                        # list 浅拷贝，内部对象仍共享
12
print(a is b, a[0] is b[0])      # False True
13
b[0].append(9)
14
print(a)                        # [[1, 9], [2]]

1
d = {"a": 1, "b": 2}
2
print(list(d), list(d.values()), list(d.items()))
3
# ['a', 'b'] [1, 2] [('a', 1), ('b', 2)]
4
for key, value in d.items():
5
    print(key, value)
6
for index, value in enumerate(["x", "y"], start=1):
7
    print(index, value)         # 1 x；2 y
8
for x, y in [(1, 2), (3, 4)]:
9
    print(x + y)               # 3；7
10
print(list("abc"))             # ['a', 'b', 'c']；可迭代不要求整数下标
11

12
from collections.abc import Iterable
13
print(isinstance([], Iterable), isinstance(3, Iterable))  # True False
14
# iter(3)                       # TypeError；实际是否可迭代以 iter 为准
15

16
# 筛选时建立新容器，避免遍历时直接增删原容器
17
positive = {k: v for k, v in d.items() if v > 1}
18
print(positive)                 # {'b': 2}
19

20
def extremes(values):
21
    if not values:
22
        return None, None
23
    low = high = values[0]      # 用真实元素初始化，不假定全为正数
24
    for value in values[1:]:
25
        low, high = min(low, value), max(high, value)
26
    return low, high
27

28
print(extremes([-3, -1]), extremes([]))  # (-3, -1) (None, None)

1
print([x * x for x in range(4)])                  # [0, 1, 4, 9]
2
print([x * x for x in range(6) if x % 2 == 0])    # [0, 4, 16]
3
print([x if x >= 0 else -x for x in [-2, 3]])     # [2, 3]
4
# for 后的 if 是筛选，不带 else；for 前的 if...else 必须两种结果齐全
5

6
print([(x, y) for x in [1, 2] for y in [3, 4]])
7
# [(1, 3), (1, 4), (2, 3), (2, 4)]；前一个 for 是外层
8

9
values = ["Hi", 3, None, "PYTHON"]
10
print([s.lower() for s in values if isinstance(s, str)])  # ['hi', 'python']
11
print([f"{k}={v}" for k, v in {"a": 1, "b": 2}.items()])
12
# ['a=1', 'b=2']；推导式立即创建整个 list

1
g = (x * x for x in range(3))
2
print(next(g), list(g), list(g)) # 0 [1, 4] []：只能向前消费
3

4
def steps():
5
    print("start")
6
    yield 1                     # 交出值并保存当前位置和局部状态
7
    yield 2
8
    return "done"
9

10
g = steps()                     # 此时不执行函数体，不输出 start
11
print(next(g))                  # 输出 start，再输出 1
12
print(next(g))                  # 2，从上次 yield 后继续
13
try:
14
    next(g)
15
except StopIteration as exc:
16
    print(exc.value)            # done；return 值存在异常中
17

18
print(list(steps()))            # 输出 start 与 [1, 2]；for/list 自动处理结束
19
print(next(steps()), next(steps()))  # 两个新生成器，均从第一项开始

1
def fibonacci(count):
2
    a, b = 0, 1
3
    for _ in range(count):
4
        yield b
5
        a, b = b, a + b         # 先计算整个右侧，再分别赋值
6

7
print(list(fibonacci(5)))        # [1, 1, 2, 3, 5]
8

9
def naturals():
10
    n = 0
11
    while True:
12
        yield n
13
        n += 1
14

15
for n in naturals():
16
    if n == 3:
17
        break                   # 无限生成器由消费端限制
18
    print(n)                    # 0、1、2
19
# 只保存当前递推状态，不保存完整序列；局部状态本身仍占内存

1
from collections.abc import Iterable, Iterator
2

3
a = [10, 20]
4
it = iter(a)                    # 不复制整个列表
5
g = (x for x in a)
6
print(isinstance(a, Iterable), isinstance(a, Iterator))  # True False
7
print(isinstance(it, Iterator), isinstance(g, Iterator)) # True True
8
print(iter(it) is it)            # True：迭代器的 __iter__ 返回自身
9
print(next(it), next(it))        # 10 20
10
print(next(it, "END"))           # END；默认值避免抛 StopIteration
11

12
# for 的核心流程：取得迭代器，反复取下一项，遇到结束异常退出
13
it = iter([1, 2])
14
while True:
15
    try:
16
        value = next(it)
17
    except StopIteration:
18
        break
19
    print(value)
20

21
# 生成器属于迭代器，迭代器属于可迭代对象；协议不承诺索引或长度
22
# it[0]                         # TypeError
23
# len(it)                       # TypeError
24
# 迭代器也不保证省内存，例如 iter(巨大的列表) 仍引用原列表

1
# 接受函数或返回函数的函数是高阶函数
2
def combine(x, y, func):
3
    return func(x) + func(y)
4

5
f = abs
6
print(combine(-2, 3, f))         # 5；传 f 是传规则，f(x) 才执行
7

8
def make_adder(offset):
9
    return lambda x: x + offset
10

11
add_two = make_adder(2)
12
print(add_two(5))                # 7
13

14
# 不用 abs、list、sum 等内置名称命名普通变量
15
# abs = 3
16
# abs(-2)                       # TypeError：名称已不再指向函数

1
from functools import reduce
2

3
mapped = map(str, [2, 4])        # 惰性变换，返回迭代器
4
print(list(mapped), list(mapped))  # ['2', '4'] []
5
print(list(map(lambda a, b: a + b, [1, 2, 3], [10, 20])))
6
# [11, 22]；多输入默认到最短输入结束
7

8
print(reduce(lambda a, b: a - b, [10, 3, 2]))  # 5，即 (10 - 3) - 2
9
print(reduce(lambda a, b: a * b, [2, 3, 4], 1))  # 24，初值为 1
10
print(reduce(lambda a, b: a * b, [], 1))         # 1，空输入返回初值
11
# reduce(lambda a, b: a + b, [])                # TypeError：空输入无初值
12
print(sum([1, 2, 3]))            # 求和直接用 sum，结果 6
13

14
digits = map(int, "246")
15
number = reduce(lambda acc, digit: acc * 10 + digit, digits, 0)
16
print(number)                   # 246：逐项转换，再从左向右累积

1
print(list(filter(lambda x: x % 2, range(6))))  # [1, 3, 5]
2
print(list(filter(None, [0, 1, "", "hi", None])))  # [1, 'hi']
3
# 谓词按真值筛选，不必严格返回 bool；结果是惰性迭代器
4

5
texts = ["", "  ", " A ", None, "B"]
6
print(list(filter(lambda s: s and s.strip(), texts)))  # [' A ', 'B']
7
# 保留的是原元素，不是 strip() 的返回值
8

9
def palindrome(n):
10
    return str(n) == str(n)[::-1]
11

12
print(list(filter(palindrome, [12, 121, 1331])))  # [121, 1331]

1
# 素数筛：每次取最小候选，再过滤它的倍数
2
def odd_numbers():
3
    n = 3
4
    while True:
5
        yield n
6
        n += 2
7

8
def not_divisible(divisor):
9
    return lambda x: x % divisor != 0
10

11
def primes():
12
    yield 2
13
    candidates = odd_numbers()
14
    while True:
15
        prime = next(candidates)
16
        yield prime
17
        candidates = filter(not_divisible(prime), candidates)
18

19
result = []
20
for prime in primes():
21
    if prime >= 15:
22
        break                   # 不把无限流整体转成 list
23
    result.append(prime)
24
print(result)                   # [2, 3, 5, 7, 11, 13]

1
values = [-3, 1, -2]
2
print(sorted(values))           # [-3, -2, 1]
3
print(sorted(values, key=abs))  # [1, -2, -3]；比较键，返回原元素
4
print(values)                   # [-3, 1, -2]；不改原列表
5
print(sorted(values, reverse=True))  # [1, -2, -3]
6

7
print(sorted(["b", "A", "Z"]))  # ['A', 'Z', 'b']；按 Unicode 码点字典序
8
print(sorted(["b", "A", "Z"], key=str.lower))  # ['A', 'b', 'Z']
9
# 默认排序不是汉语拼音排序
10

11
rows = [("A", 80), ("B", 90), ("C", 80)]
12
print(sorted(rows, key=lambda row: row[1], reverse=True))
13
# [('B', 90), ('A', 80), ('C', 80)]；同键保持原相对顺序，排序稳定
14

15
print(values.sort())            # None；list.sort 原地修改并返回 None
16
print(values)                   # [-3, -2, 1]

1
def lazy_total(*values):
2
    def calculate():
3
        return sum(values)      # 引用外层变量，形成闭包
4
    return calculate            # 返回函数；calculate() 才是返回计算结果
5

6
f = lazy_total(1, 2, 3)
7
print(f())                      # 6；此时才求和
8
print(f is lazy_total(1, 2, 3)) # False；不同函数对象
9

10
def bad_functions():
11
    return [lambda: i * i for i in range(3)]
12

13
print([f() for f in bad_functions()])  # [4, 4, 4]；调用时读取共享 i
14
good = [lambda i=i: i * i for i in range(3)]
15
print([f() for f in good])       # [0, 1, 4]；默认值绑定本轮引用
16

17
def bind_square(value):         # 也可用工厂参数形成独立绑定
18
    return lambda: value * value
19

20
print([bind_square(i)() for i in range(3)])  # [0, 1, 4]
21

22
items = [1]
23
read = lambda items=items: items
24
items.append(2)
25
print(read())                   # [1, 2]；固定引用不是深拷贝

1
def make_counter():
2
    count = 0
3
    def increment():
4
        nonlocal count          # 重新赋值外层函数变量前声明
5
        count += 1
6
        return count
7
    return increment
8

9
a, b = make_counter(), make_counter()
10
print(a(), a(), b())            # 1 2 1；两个闭包各有状态
11

12
def make_reader():
13
    value = 10
14
    def read():
15
        return value + 1        # 仅读取，不需要 nonlocal
16
    return read
17

18
print(make_reader()())          # 11
19
# 若在 read 中写 value += 1 而未声明 nonlocal，会触发 UnboundLocalError

1
square = lambda x: x * x        # 单个表达式，自动返回结果
2
print(square(4))                # 16
3
print(list(map(lambda x: x + 1, [1, 2])))  # [2, 3]
4
print(sorted(["pear", "a"], key=lambda s: len(s)))  # ['a', 'pear']
5
choose = lambda x: "yes" if x else "no"
6
print(choose(0))                # no
7
# lambda x: return x            # SyntaxError，不写 return
8

9
def explainable(x):             # 多步骤、需文档或复杂分支时用 def
10
    """将输入加一后平方。"""
11
    adjusted = x + 1
12
    return adjusted * adjusted
13

14
print(explainable(2))           # 9

1
from functools import wraps
2

3
def logged(func):
4
    @wraps(func)                # 保留 __name__、__doc__，设置 __wrapped__
5
    def wrapper(*args, **kwargs):
6
        print("calling", func.__name__)
7
        return func(*args, **kwargs)  # 转发参数，保留原返回值
8
    return wrapper
9

10
@logged                         # 等价于定义后 multiply = logged(multiply)
11
def multiply(x, y=2):
12
    """Return the product."""
13
    return x * y
14

15
print(multiply(3, y=4))         # calling multiply；12
16
print(multiply.__name__)        # multiply
17
print(multiply.__doc__)         # Return the product.
18
print(multiply.__wrapped__(3))  # 6，直接调用原函数

1
from functools import wraps
2
from time import perf_counter
3

4
def timed(label):               # 第一层：装饰器配置
5
    def decorate(func):         # 第二层：接收原函数
6
        @wraps(func)
7
        def wrapper(*args, **kwargs):  # 第三层：每次调用执行
8
            start = perf_counter()
9
            try:
10
                return func(*args, **kwargs)
11
            finally:            # 原函数抛异常也记录结束时间
12
                elapsed_ms = (perf_counter() - start) * 1000
13
                print(f"{label}: {elapsed_ms:.3f} ms")
14
        return wrapper
15
    return decorate
16

17
@timed("sum")                  # 等价于 total = timed("sum")(total)
18
def total(values):
19
    return sum(values)
20

21
print(total([1, 2, 3]))          # 先输出实际耗时，再输出 6

1
events = []
2
def tag(name):
3
    events.append("configure " + name)
4
    def decorate(func):
5
        events.append("decorate " + name)
6
        def wrapper():
7
            return name + func()
8
        return wrapper
9
    return decorate
10

11
@tag("A")
12
@tag("B")                      # greet = tag("A")(tag("B")(greet))
13
def greet():
14
    return "!"
15

16
print(events)  # ['configure A', 'configure B', 'decorate B', 'decorate A']
17
print(greet())                  # AB!；包装器在调用时才运行

1
from functools import partial
2

3
parse_binary = partial(int, base=2)  # 预绑定参数，不修改 int
4
print(parse_binary("101"))          # 5
5
print(parse_binary("101", base=10)) # 101；调用时可覆盖预绑定关键字
6
print(int("101"))                   # 101；原函数不变
7

8
at_least_ten = partial(max, 10)      # 普通预绑定位置参数放最前面
9
print(at_least_ten(3, 7))            # 10，等价于 max(10, 3, 7)
10
# 此处“偏函数”表示固定部分实参以简化调用，并非数学中的同名概念

1
import math
2
import math as m
3
from math import sqrt
4

5
print(math.sqrt(9), m.sqrt(9), sqrt(9))  # 3.0 3.0 3.0
6
print(math.__name__)                    # math
7
print(math.__doc__ is not None)         # True

1
python app.py hello 3
2
# sys.argv 为 ['app.py', 'hello', '3']；数字参数也是字符串
3
python helpers.py
4
# 输出 helpers loaded，再输出 7

1
# 使用目标解释器对应的 pip；下面是终端命令，不是 Python 语句
2
python -m pip install Pillow
3
python -m pip --version
4
python -c "from PIL import Image; print(Image.__name__)"
5
# 安装名 Pillow，导入名 PIL；两者未必相同
6

7
# Anaconda 是集成 Python 与数据科学工具的发行版，可用 conda 管理环境
8
# 安装 Anaconda 后，可在其提供的终端检查解释器与包
9
conda info --envs
10
python -c "import sys; print(sys.executable)"