1
2
3
4

# None 就是 None，它自己
x = None
print(x)          # None
print(type(x))    # <class 'NoneType'>

1
2
3
4
5
6
7
8
9

# 让我们来验证一下
print(None == "")      # False —— 物种都不一样！
print(None == [])      # False —— 一个是虚无，一个是空list
print(None == {})      # False —— 完全不同

# 空值不是 None
print(bool(None))      # False —— None 是 falsy 的
print(bool(""))        # False —— 空字符串也是 falsy 的
print(bool([]))        # False —— 空列表还是 falsy 的

1
2
3
4
5
6
7
8

def greet(name=None):
    # 如果用户没传 name，我们就给他一个默认的
    if name is None:
        name = "神秘游客"
    print(f"你好，{name}！欢迎光临！")

greet()               # 你好，神秘游客！欢迎光临！
greet("小明")         # 你好，小明！欢迎光临！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

def say_hello():
    print("Hello!")

result = say_hello()
print(result)         # None —— 没有 return 语句的函数都返回 None

# 常见的场景：查找操作，没找到就返回 None
def find_user(users, user_id):
    for user in users:
        if user["id"] == user_id:
            return user
    return None  # 找不到就返回 None，而不是抛异常

users = [{"id": 1, "name": "张三"}, {"id": 2, "name": "李四"}]
print(find_user(users, 99))   # None —— 没找到
print(find_user(users, 1))    # {'id': 1, 'name': '张三'}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 比如一个用户的"最后一次登录时间"——新用户可能还没登录过
user = {"name": "小明", "last_login": None}
# 这里 None 表示"还没有登录记录"，而不是"登录时间是0"或者"忘记记录了"

# Optional 类型提示（Python 3.5+）
from typing import Optional

def get_user_age(user: Optional[dict]) -> Optional[int]:
    """获取用户年龄，可能用户不存在（返回 None）或者用户没设置年龄（也是 None）"""
    if user is None:
        return None
    return user.get("age")

1
2
3
4
5
6
7
8

# 在 Python 中，你可以计算这个
big_number = 10 ** 1000  # 1 后面跟 1000 个零！
print(big_number)  # 这在 C 语言里早就溢出了，但 Python 表示：就这？

# 再来个大一点的
really_big = 2 ** 10000
print(f"2的10000次方有 {really_big.bit_length()} 位")
# 2的10000次方有 10001 位 —— 这数字比宇宙中的原子数还多！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 字面量表示
print(42)           # 十进制: 42
print(0b101010)     # 二进制（binary）: 42 —— 前缀 0b
print(0o52)         # 八进制（octal）: 42 —— 前缀 0o
print(0x2a)         # 十六进制（hex）: 42 —— 前缀 0x

# 十进制转其他进制
print(bin(42))      # '0b101010'
print(oct(42))      # '0o52'
print(hex(42))      # '0x2a'

# 字符串转整数（指定进制）
print(int("101010", 2))   # 42 —— 把二进制字符串转成十进制int
print(int("0x2a", 16))   # 42 —— 把十六进制字符串转成十进制int
print(int("52", 8))       # 42 —— 把八进制字符串转成十进制int

# 格式化输出不同进制
print(f"{42:b}")  # 101010 —— 二进制
print(f"{42:o}")  # 52 —— 八进制
print(f"{42:x}")  # 2a —— 十六进制

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# 与（&）：两个位都是1才得1
a = 0b1100  # 12
b = 0b1010  # 10
print(bin(a & b))   # 0b1000 —— 结果是 8

# 或（|）：只要有一个是1就得1
print(bin(a | b))   # 0b1110 —— 结果是 14

# 异或（^）：不同得1，相同得0
print(bin(a ^ b))   # 0b0110 —— 结果是 6

# 取反（~）：按位取反，等于 -(n+1)
print(~5)    # -6 —— 这是因为 Python 使用补码表示负数

# 左移（<<）：二进制位左移，相当于乘以2的n次方
print(1 << 3)   # 8 —— 1 左移 3 位，等于 1 * 2^3 = 8
print(5 << 2)   # 20 —— 5 * 4 = 20

# 右移（>>）：二进制位右移，相当于除以2的n次方（向下取整）
print(16 >> 2)   # 4 —— 16 / 4 = 4
print(15 >> 2)   # 3 —— 15 / 4 = 3.75，向下取整得 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# bit_length()：返回整数的二进制表示的位数
x = 15
print(x.bit_length())   # 4 —— 15 的二进制是 1111，有4位
print((2 ** 100).bit_length())  # 101 —— 2的100次方有101位

# to_bytes()：将整数转为字节串（用于文件写入、网络传输等）
# to_bytes(length, byteorder='big')
num = 1024
print(num.to_bytes(2, 'big'))    # b'\x04\x00' —— 大端序
print(num.to_bytes(2, 'little')) # b'\x00\x04' —— 小端序

# from_bytes()：从字节串恢复整数
b = b'\x04\x00'
print(int.from_bytes(b, 'big'))     # 1024
print(int.from_bytes(b, 'little'))  # 4

1
2
3
4

import sys
print(sys.float_info)
# sys.float_info(max=1.7976931348623157e+308, max_exp=1024, ...)
# 这告诉我们：float 能表示的最大值约为 1.8 × 10^308

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 经典问题
print(0.1 + 0.2)   # 0.30000000000000004 —— 为什么会这样？！

# 比较浮点数不能直接用 ==
print(0.1 + 0.2 == 0.3)   # False —— 令人崩溃的 False！

# 正确的方法：使用 math.isclose() 或 round()
import math
print(math.isclose(0.1 + 0.2, 0.3))   # True —— 这才对嘛

# 或者用 decimal 模块（后面会详细介绍）
from decimal import Decimal
print(Decimal('0.1') + Decimal('0.2') == Decimal('0.3'))  # True —— 精确计算

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 无穷大
print(float('inf'))           # inf
print(float('-inf'))          # -inf
print(10 ** 1000)             # inf —— 超过 float 能表示的最大值

# 无穷大的运算
print(float('inf') + 1)       # inf
print(float('inf') + float('-inf'))  # nan —— 无穷加负无穷 = 不知道是啥
print(float('inf') - float('inf'))   # nan

# NaN（Not a Number）
print(float('nan'))           # nan
print(0.0 / 0.0)               # nan —— 0除以0
print(float('inf') - float('inf'))   # nan

# 判断是否是 nan —— 不能用 ==，要用 math.isnan()
import math
print(math.isnan(float('nan')))   # True
print(math.isnan(0.0 / 0.0))      # True

# 判断是否是有限或无穷
print(math.isfinite(1.0))         # True
print(math.isfinite(float('inf')))  # False
print(math.isfinite(float('nan'))) # False

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 复数的创建：使用 j（不是 i！）
z = 3 + 4j
print(z)            # (3+4j)
print(type(z))      # <class 'complex'>

# 也可以用 complex() 函数
z2 = complex(3, 4)  # 等价于 3 + 4j
print(z2)           # (3+4j)

# 纯虚数
pure_img = 5j
print(pure_img)     # 5j

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

z = 3 + 4j

# 实部和虚部
print(z.real)      # 3.0 —— 实部
print(z.imag)      # 4.0 —— 虚部

# 共轭复数：实部不变，虚部取反
print(z.conjugate())   # (3-4j)

# 复数的模（绝对值）
print(abs(z))          # 5.0 —— sqrt(3^2 + 4^2) = 5

# 复数运算
z1 = 1 + 2j
z2 = 3 + 4j
print(z1 + z2)     # (4+6j)
print(z1 * z2)     # (-5+10j)
print(z1 / z2)     # (0.44+0.08j)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

from decimal import Decimal

# 金融计算：发工资！
salary = Decimal('10000.00')
tax = Decimal('0.15')
bonus = Decimal('5000.00')

total = salary * (1 - tax) + bonus
print(total)   # 13000.00 —— 精确！

# 如果用 float 呢？
salary_f = 10000.00
tax_f = 0.15
bonus_f = 5000.00
total_f = salary_f * (1 - tax_f) + bonus_f
print(total_f)  # 12999.999999999998 —— 精度问题！

# 计算商品总价（复用上面的 Decimal）
price1 = Decimal('0.10')
price2 = Decimal('0.20')
print(price1 + price2)   # 0.30 —— 精确！
print(float(price1) + float(price2))  # 0.30000000000000004

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

from decimal import Decimal, getcontext

# 设置精度（默认28位）
getcontext().prec = 10

a = Decimal('1') / Decimal('3')
print(a)   # 0.3333333333 —— 只有10位精度

# 量化（quantize）到指定小数位
from decimal import ROUND_HALF_UP
price = Decimal('19.99') * Decimal('3')
print(price.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
# 59.97 —— 四舍五入到分

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

from fractions import Fraction

# 创建分数
f1 = Fraction(3, 4)     # 3/4
f2 = Fraction('5/7')   # 也可以用字符串
f3 = Fraction(0.5)     # 从浮点数创建（注意精度损失）
f4 = Fraction("0.5")   # 从字符串创建（精确）

print(f1)      # 3/4
print(f2)      # 5/7
print(f3)      # 1/2
print(f4)      # 1/2

# 分数运算 —— 结果还是分数！
result = Fraction(1, 3) + Fraction(1, 6)
print(result)  # 1/2 —— 自动约分！

# 解决数学题：1/3 + 1/6 = ?
from fractions import Fraction
print(Fraction(1, 3) + Fraction(1, 6))  # 1/2

# 浮点数转分数
import math
print(Fraction(math.pi).limit_denominator(1000))
# 355/113 —— 著名的圆周率近似分数，误差极小！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

import math

# ceil(x)：向上取整 —— 天花板
print(math.ceil(3.2))    # 4 —— 往大的取
print(math.ceil(-3.2))   # -3 —— 往大的取（-3 > -3.2）

# floor(x)：向下取整 —— 地板
print(math.floor(3.9))   # 3 —— 往小的取
print(math.floor(-3.9))  # -4 —— 往小的取（-4 < -3.9）

# sqrt(x)：平方根
print(math.sqrt(16))    # 4.0
print(math.sqrt(2))     # 1.4142135623730951

# pow(x, y)：x的y次方（等价于 x ** y）
print(math.pow(2, 3))   # 8.0 —— 注意返回的是 float
print(2 ** 3)           # 8 —— 这个是 int

# exp(x)：e的x次方
print(math.exp(1))      # 2.718281828459045 —— e ≈ 2.718

# log(x, base)：对数，默认底数为 e（自然对数）
print(math.log(math.e))      # 1.0 —— ln(e) = 1
print(math.log(100, 10))     # 2.0 —— log10(100) = 2
print(math.log2(1024))       # 10.0 —— log2(1024) = 10
print(math.log10(1000))      # 3.0 —— log10(1000) = 3

# factorial(n)：阶乘
print(math.factorial(5))   # 120 —— 5! = 5×4×3×2×1 = 120

# gcd(a, b)：最大公约数
print(math.gcd(48, 18))    # 6 —— 48和18的最大公约数是6

# fabs(x)：绝对值（返回 float）
print(math.fabs(-5))    # 5.0

# trunc(x)：截断取整（向0取整）
print(math.trunc(3.9))    # 3 —— 和 floor 不同！
print(math.trunc(-3.9))   # -3 —— 向0取整

1
2
3
4
5
6
7

import math

print(math.pi)    # 3.141592653589793 —— 圆周率 π
print(math.e)     # 2.718281828459045 —— 自然常数 e
print(math.tau)   # 6.283185307179586 —— 2π，完整圆的弧度
print(math.inf)   # inf —— 无穷大
print(math.nan)   # nan —— 不是一个数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import math

# 角度转弧度
angle_deg = 45
angle_rad = math.radians(angle_deg)
print(f"{angle_deg}° = {angle_rad} rad")  # 45° = 0.7853981633974483 rad

# 弧度转角度
rad = math.pi / 4
deg = math.degrees(rad)
print(f"{rad} rad = {deg}°")  # 0.785... rad = 45.0°

# 三角函数
print(math.sin(angle_rad))    # 0.7071067811865476 —— sin(45°) ≈ √2/2
print(math.cos(angle_rad))    # 0.7071067811865476 —— cos(45°) ≈ √2/2
print(math.tan(angle_rad))    # 0.9999999999999999 —— tan(45°) ≈ 1

# 反三角函数
print(math.asin(0.5))    # 0.5235987755982989 —— arcsin(0.5) = π/6
print(math.acos(0.5))    # 1.0471975511965979 —— arccos(0.5) = π/3
print(math.atan(1))      # 0.7853981633974483 —— arctan(1) = π/4

# 双曲函数
print(math.sinh(1))    # 1.1752011936438014
print(math.cosh(1))    # 1.5430806348152437
print(math.tanh(1))    # 0.7615941559557649

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import random

# random()：返回 [0.0, 1.0) 区间内的随机浮点数
print(random.random())       # 0.721... 每次运行都不一样！

# uniform(a, b)：返回 [a, b] 区间内的随机浮点数
print(random.uniform(1, 10)) # 5.374... 在1到10之间

# randint(a, b)：返回 [a, b] 区间内的随机整数（两端都包含）
print(random.randint(1, 6))  # 4 —— 掷骰子！

# randrange(start, stop, step)：返回随机选择的元素
print(random.randrange(0, 101, 2))  # 随机偶数，0到100之间

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

import random

# choice(seq)：从序列中随机选一个元素
fruits = ["苹果", "香蕉", "橘子", "葡萄"]
print(random.choice(fruits))  # 随机选一个水果

# sample(population, k)：从总体中随机选k个不重复的元素
deck = list(range(1, 53))  # 52张牌
hand = random.sample(deck, 5)  # 发5张
print(hand)  # [23, 45, 12, 7, 38] —— 5张不重复的牌

# shuffle(x)：原地打乱序列（会修改原列表）
cards = ["红桃A", "黑桃K", "方块Q", "梅花J"]
random.shuffle(cards)  # 洗牌！
print(cards)  # 顺序被打乱了

# choices(population, weights=None, k=1)：可重复选择
# 模拟有偏骰子：6出现的概率是其他数字的2倍
weights = [1, 1, 1, 1, 1, 2]  # 1-5各1份，6有2份
print(random.choices(range(1, 7), weights=weights, k=10))
# 可能输出类似 [3, 6, 1, 6, 4, 6, 2, 6, 5, 6]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import random

# gauss(mu, sigma)：正态分布（高斯分布）
# mu = 均值，sigma = 标准差
height = random.gauss(170, 10)  # 平均身高170，标准差10
print(f"随机身高：{height:.1f} cm")

# expovariate(lambd)：指数分布
# lambd = 1 / 平均值
arrival_time = random.expovariate(1/5)  # 平均5分钟来一辆车
print(f"随机等待时间：{arrival_time:.2f} 分钟")

# 其他分布
print(random.betavariate(2, 5))   # Beta分布
print(random.gammavariate(2, 2))  # Gamma分布
print(random.lognormvariate(0, 1)) # 对数正态分布
print(random.triangular(0, 1))    # 三角分布

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import random

# 设置种子
random.seed(42)
print(random.random())   # 0.6394267984578837
print(random.random())   # 0.02501075520032851
print(random.randint(1, 100))  # 81

# 重新设置种子，序列会重复
random.seed(42)
print(random.random())   # 0.6394267984578837 —— 和上面第一个一样！
print(random.random())   # 0.02501075520032851 —— 和上面第二个一样！
print(random.randint(1, 100))  # 81 —— 和上面第三个一样！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import statistics

data = [2, 4, 4, 4, 5, 5, 7, 9]

# 均值（mean）：所有数加起来除以个数
print(statistics.mean(data))       # 5.0 —— (2+4+4+4+5+5+7+9)/8 = 40/8 = 5

# 中位数（median）：排序后位于中间的值
print(statistics.median(data))     # 4.5 —— 排序后 [2,4,4,4,5,5,7,9]，中间是4和5，平均4.5
print(statistics.median([1, 2, 3]))  # 2 —— 奇数个直接取中间

# 众数（mode）：出现次数最多的值
print(statistics.mode(data))       # 4 —— 4出现了3次，最多

# 方差（variance）：衡量数据离散程度
print(statistics.variance(data))   # 4.0 —— 各数据与均值的差的平方的平均

# 标准差（stdev）：方差的平方根，更直观
print(statistics.stdev(data))      # 2.0 —— √4 = 2

# 其他统计量
print(statistics.harmonic_mean(data))  # 调和平均数
print(statistics.geometric_mean(data)) # 几何平均数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 方法1：直接用方括号
empty = []
numbers = [1, 2, 3, 4, 5]
mixed = ["hello", 42, 3.14, True]  # 列表可以装任意类型

# 方法2：用 list() 函数
another_list = list()           # 空列表
from_string = list("hello")     # ['h', 'e', 'l', 'l', 'o']
from_tuple = list((1, 2, 3))    # [1, 2, 3] —— 从元组创建
from_range = list(range(5))     # [0, 1, 2, 3, 4]

# 方法3：列表推导式（List Comprehension）—— Python的独门绝技！
squares = [x ** 2 for x in range(5)]    # [0, 1, 4, 9, 16]
evens = [x for x in range(10) if x % 2 == 0]  # [0, 2, 4, 6, 8]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

fruits = ["苹果", "香蕉", "橘子", "葡萄", "西瓜"]

# 正向索引：从0开始
print(fruits[0])   # 苹果 —— 第一个元素
print(fruits[1])   # 香蕉 —— 第二个元素

# 反向索引：从-1开始
print(fruits[-1])  # 西瓜 —— 最后一个
print(fruits[-2])  # 葡萄 —— 倒数第二个

# 切片：[start:stop:step]
print(fruits[1:4])     # ['香蕉', '橘子', '葡萄'] —— 索引1到3（不包括4）
print(fruits[:3])      # ['苹果', '香蕉', '橘子'] —— 从开头到索引2
print(fruits[2:])      # ['橘子', '葡萄', '西瓜'] —— 从索引2到结尾
print(fruits[::2])     # ['苹果', '橘子', '西瓜'] —— 每隔一个取一个
print(fruits[::-1])    # ['西瓜', '葡萄', '橘子', '香蕉', '苹果'] —— 反转！

# 切片是左闭右开区间 [start, stop)
print(fruits[1:2])  # ['香蕉'] —— 只取索引1，不包括索引2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

nums = [1, 2, 3]

# 增
nums.append(4)      # 末尾添加：[1, 2, 3, 4]
print(nums)

nums.insert(1, 99)  # 在索引1位置插入99：[1, 99, 2, 3, 4]
print(nums)

nums.extend([5, 6])  # 末尾追加多个：[1, 99, 2, 3, 4, 5, 6]
print(nums)

# 改
nums[0] = 100       # 修改索引0的元素：[100, 99, 2, 3, 4, 5, 6]
print(nums)

# 删
nums.pop()          # 弹出最后一个：[100, 99, 2, 3, 4, 5]，返回6
print(nums)

nums.pop(1)         # 弹出索引1的元素：[100, 2, 3, 4, 5]，返回99
print(nums)

nums.remove(100)    # 删除第一个匹配的元素：[2, 3, 4, 5]
print(nums)

del nums[0]         # 删除索引0的元素：[3, 4, 5]
print(nums)

del nums[0:2]       # 删除切片：[5]
print(nums)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

# sort()：原地排序（修改原列表）
numbers.sort()
print(numbers)  # [1, 1, 2, 3, 4, 5, 6, 9]

# sort(reverse=True)：降序排列
numbers.sort(reverse=True)
print(numbers)  # [9, 6, 5, 4, 3, 2, 1, 1]

# sort(key=)：自定义排序规则
words = ["banana", "apple", "Cherry", "date"]
words.sort(key=str.lower)  # 不区分大小写排序
print(words)  # ['apple', 'banana', 'Cherry', 'date']

# sorted()：返回排序后的新列表，不修改原列表
numbers = [3, 1, 4, 1, 5]
sorted_nums = sorted(numbers)
print(numbers)      # [3, 1, 4, 1, 5] —— 原列表不变
print(sorted_nums)  # [1, 1, 3, 4, 5] —— 新列表

# reverse()：原地反转
numbers.reverse()
print(numbers)  # [5, 4, 3, 1, 1]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 浅拷贝的问题
a = [[1, 2], [3, 4]]
b = a          # 这不是拷贝！b和a是同一个对象
b[0][0] = 99
print(a)  # [[99, 2], [3, 4]] —— a也被改了！
print(b)  # [[99, 2], [3, 4]]

# 正确的拷贝方式
a = [[1, 2], [3, 4]]
c = a.copy()    # 浅拷贝：外层列表是新的，但内层列表还是共享的！
d = a[:]        # 同上
c[0][0] = 99    # 修改内层元素——这会影响原列表 a！
print(a)  # [[99, 2], [3, 4]] —— a 也被影响了，因为浅拷贝共享内层对象！
print(c)  # [[99, 2], [3, 4]]

# 真正的深拷贝
import copy
a = [[1, 2], [3, 4]]
e = copy.deepcopy(a)  # 深拷贝：完全独立
e[0][0] = 99
print(a)  # [[1, 2], [3, 4]] —— 原列表不受影响！
print(e)  # [[99, 2], [3, 4]]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 基本格式：[表达式 for 项目 in 可迭代对象]

# 传统写法
squares = []
for x in range(10):
    squares.append(x ** 2)
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 列表推导式写法
squares = [x ** 2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 带条件过滤
evens = [x for x in range(20) if x % 2 == 0]
print(evens)  # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# 多重循环
pairs = [(x, y) for x in [1, 2] for y in [3, 4]]
print(pairs)  # [(1, 3), (1, 4), (2, 3), (2, 4)]

# 带条件的多重循环
pairs_50 = [(x, y) for x in [1, 2, 3] for y in [3, 4, 5] if x + y > 5]
print(pairs_50)  # [(1, 5), (2, 4), (2, 5), (3, 4), (3, 5)]

# 字典推导式（类似的语法）
word = "hello"
char_count = {c: word.count(c) for c in set(word)}
print(char_count)  # {'h': 1, 'e': 1, 'l': 2, 'o': 1}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 时间复杂度分析
# O(1) - 常数时间：不管数据多大，操作时间不变
lst = []
lst.append(1)      # O(1) —— 追加很快

# O(n) - 线性时间：操作时间和数据量成正比
lst.insert(0, 1)   # O(n) —— 头部插入，需要移动所有元素

lst.pop()           # O(1) —— 尾部删除
lst.pop(0)          # O(n) —— 头部删除，需要移动所有元素

# O(1) 平均：访问、修改
lst[0] = 99         # O(1) —— 直接定位
val = lst[0]        # O(1) —— 直接访问

# 查找
print(1 in lst)     # O(n) —— 线性查找，需要遍历

# 排序
lst.sort()          # O(n log n) —— 最好的比较排序算法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# 创建元组
empty = ()
single = (42,)  # 注意！单个元素的元组必须加逗号
multi = (1, 2, 3, "hello", True)

# 也可以不加括号（tuple unpacking 常见写法）
t = 1, 2, 3
print(t)  # (1, 2, 3)

# 用 tuple() 从其他序列创建
t_from_list = tuple([1, 2, 3])
t_from_str = tuple("hello")
print(t_from_str)  # ('h', 'e', 'l', 'l', 'o')

# 索引和切片（和列表一样）
t = (1, 2, 3, 4, 5)
print(t[0])      # 1 —— 正向索引
print(t[-1])     # 5 —— 反向索引
print(t[1:4])    # (2, 3, 4) —— 切片

1
2
3
4
5
6
7

t = (1, 2, 3)
# t[0] = 99  # TypeError: 'tuple' object does not support item assignment

# 但如果元组里包含可变对象，那些可变对象可以修改！
t = (1, [2, 3], 4)
t[1].append(99)  # 合法！因为 list 是可变的
print(t)  # (1, [2, 3, 99], 4)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from collections import namedtuple

# 定义一个命名元组类型
Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)

# 可以用索引访问
print(p[0])    # 10
print(p[1])    # 20

# 也可以用名字访问
print(p.x)    # 10 —— 更直观！
print(p.y)    # 20

# 可以像普通元组一样解包
x, y = p
print(x, y)   # 10 20

# 转换为字典
print(p._asdict())  # {'x': 10, 'y': 20}

# 替换某些字段（创建新实例）
p2 = p._replace(x=100)
print(p2)   # Point(x=100, y=20)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 基本解包
coordinates = (10, 20, 30)
x, y, z = coordinates
print(x, y, z)  # 10 20 30

# 交换变量（不需要临时变量！）
a, b = 1, 2
a, b = b, a  # Pythonic 的交换方式
print(a, b)  # 2 1

# 用 * 收集多余的元素
first, *rest = [1, 2, 3, 4, 5]
print(first)  # 1
print(rest)   # [2, 3, 4, 5]

# 函数返回元组
def get_min_max(numbers):
    return min(numbers), max(numbers)

low, high = get_min_max([3, 1, 4, 1, 5, 9, 2, 6])
print(f"最小值: {low}, 最大值: {high}")  # 最小值: 1, 最大值: 9

# 解包可以用于任何可迭代对象
*a, b = "hello"
print(a)  # ['h', 'e', 'l', 'l']
print(b)  # 'o'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# range(start, stop, step)
# 注意：是左闭右开区间 [start, stop)

r = range(0, 10)      # 0 到 9
r2 = range(5, 15)     # 5 到 14
r3 = range(0, 10, 2)  # 0, 2, 4, 6, 8 —— 偶数
r4 = range(10, 0, -1) # 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 —— 倒序

# 访问元素
print(r3[0])   # 0
print(r3[2])   # 4

# 判断是否在序列中
print(4 in r3)    # True
print(5 in r3)    # False

# 切片（返回新的 range）
print(r3[1:3])  # range(2, 6)

1
2
3
4

# range(0, 10**18) 在 C 层面实现，不占用大量内存
big_range = range(0, 10**18)
print(len(big_range))  # 1000000000000000000 —— 居然能算长度！
print(big_range[100])  # 100 —— 但只占用极少的内存

1
2
3
4
5
6
7
8
9

# range 转 list
r = range(5)
lst = list(r)
print(lst)  # [0, 1, 2, 3, 4]

# list 转 range —— 没那么直接，但可以用
lst = [0, 1, 2, 3, 4]
r = range(len(lst))
print(r)  # range(0, 5)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

import time

# 用 range 遍历
start = time.time()
for i in range(10000000):
    pass
end = time.time()
print(f"range 遍历: {end - start:.4f} 秒")

# 用 list 遍历
start = time.time()
for i in list(range(10000000)):
    pass
end = time.time()
print(f"list 遍历: {end - start:.4f} 秒")
# range 快得多，因为不需要预先创建大列表！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 方法1：花括号
d1 = {}
d2 = {"name": "张三", "age": 25}

# 方法2：dict() 函数
d3 = dict()  # 空字典
d4 = dict([("a", 1), ("b", 2)])  # 从键值对列表创建
d5 = dict(name="李四", age=30)   # 关键字参数

# 方法3：字典推导式
squares = {x: x**2 for x in range(5)}
print(squares)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

person = {"name": "小明", "age": 18, "city": "北京"}

# 方式1：中括号访问（键不存在会报错）
print(person["name"])   # 小明
# print(person["gender"])  # KeyError: 'gender'

# 方式2：get 方法（键不存在返回 None 或默认值）
print(person.get("name"))       # 小明
print(person.get("gender"))     # None —— 不报错！
print(person.get("gender", "未知"))  # 未知 —— 提供默认值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

d = {"name": "张三"}

# 增
d["age"] = 25       # 直接添加新键值对
d.update({"city": "北京", "job": "工程师"})  # 批量添加
print(d)  # {'name': '张三', 'age': 25, 'city': '北京', 'job': '工程师'}

# 改
d["age"] = 26       # 修改现有键的值
print(d)  # {'name': '张三', 'age': 26, 'city': '北京', 'job': '工程师'}

# 删
del d["job"]        # 删除指定键值对
print(d)  # {'name': '张三', 'age': 26, 'city': '北京'}

popped = d.pop("city")  # 弹出并返回被删除的值
print(popped)   # 北京
print(d)  # {'name': '张三', 'age': 26}

d.clear()        # 清空字典
print(d)  # {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

d = {"a": 1, "b": 2, "c": 3}

# keys()：所有键
print(d.keys())    # dict_keys(['a', 'b', 'c'])

# values()：所有值
print(d.values())  # dict_values([1, 2, 3])

# items()：所有键值对
print(d.items())   # dict_items([('a', 1), ('b', 2), ('c', 3)])

# 视图对象是动态的——字典变，它们也跟着变
d["d"] = 4
print(d.keys())    # dict_keys(['a', 'b', 'c', 'd']) —— 自动更新！

# 可以遍历
for key in d.keys():
    print(f"{key}: {d[key]}")

for key, value in d.items():
    print(f"{key}: {value}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 可哈希的类型（可以作为字典的键）
valid_keys = {
    42: "整数键",
    "hello": "字符串键",
    (1, 2): "元组键",  # 元组不可变，所以可以
    3.14: "浮点数键",
    True: "布尔键",
}

# 不可哈希的类型（不能作为字典的键）
# 列表是可变的，所以不能作为键
# d = {[1, 2]: "列表键"}  # TypeError: unhashable type: 'list'

# 但是，如果列表在元组里，就可以！
d = {([1, 2],): "嵌套列表的元组键"}
print(d)  # {([1, 2],): '嵌套列表的元组键'}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 数字平方的字典
squares = {x: x**2 for x in range(5)}
print(squares)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 字符串长度字典
words = ["apple", "banana", "cherry"]
lengths = {w: len(w) for w in words}
print(lengths)  # {'apple': 5, 'banana': 6, 'cherry': 6}

# 条件过滤
nums = [1, 2, 3, 4, 5, 6]
evens_sq = {x: x**2 for x in nums if x % 2 == 0}
print(evens_sq)  # {2: 4, 4: 16, 6: 36}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Python 3.9+ 的字典合并运算符
d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}

# | 运算符：合并成新字典
merged = d1 | d2
print(merged)  # {'a': 1, 'b': 3, 'c': 4} —— 注意：d2 的值覆盖了 d1

# |= 运算符：就地扩展
d1 |= d2
print(d1)  # {'a': 1, 'b': 3, 'c': 4}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 字典的操作复杂度
d = {}

# O(1) 操作
d["key"] = "value"    # 设置：常数时间
val = d["key"]        # 访问：常数时间
d.get("key")          # 获取：常数时间
d.pop("key")          # 删除：常数时间
"key" in d            # 成员检查：常数时间

# 遍历是 O(n)
for key in d:         # O(n)
    pass

1
2
3
4
5
6
7
8
9

# Python 3.7+，字典保持插入顺序
d = {}
d["z"] = 1
d["a"] = 2
d["m"] = 3

for key in d:
    print(key, end=" ")
print()  # 输出: z a m —— 插入顺序！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

from collections import defaultdict

# 创建一个默认值是 int（0）的字典
dd_int = defaultdict(int)
dd_int["a"] += 1  # 不需要先检查键是否存在
print(dd_int["a"])  # 1
print(dd_int["b"])  # 0 —— 自动创建，默认值是 int 的默认值（0）

# 创建一个默认值是 list 的字典
dd_list = defaultdict(list)
dd_list["fruits"].append("apple")
dd_list["fruits"].append("banana")
dd_list["colors"].append("red")
print(dd_list)  # defaultdict(<class 'list'>, {'fruits': ['apple', 'banana'], 'colors': ['red']})

# 创建一个默认值是 dict 的字典（二级字典）
dd_dict = defaultdict(dict)
dd_dict["user1"]["name"] = "张三"
print(dd_dict)  # defaultdict(<class 'dict'>, {'user1': {'name': '张三'}})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 传统 dict 的写法
d = {}
if "key" not in d:
    d["key"] = []
d["key"].append(1)

# 使用 setdefault
d = {}
d.setdefault("key", []).append(1)

# defaultdict 的写法（最简洁）
from collections import defaultdict
d = defaultdict(list)
d["key"].append(1)  # 自动创建空列表

1
2
3
4
5
6

# Python 3.7+ 的普通字典
d = {}
d["z"] = 1
d["a"] = 2
d["b"] = 3
print(list(d.keys()))  # ['z', 'a', 'b'] —— 有序！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

from collections import OrderedDict

od = OrderedDict({"a": 1, "b": 2, "c": 3})

# 移动键到末尾
od.move_to_end("a")
print(list(od.keys()))  # ['b', 'c', 'a']

# 移动键到开头
od.move_to_end("c", last=False)
print(list(od.keys()))  # ['c', 'b', 'a']

# 适用场景：需要频繁调整顺序时

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

from collections import Counter

# 统计单词出现次数
words = ["apple", "banana", "apple", "cherry", "banana", "apple"]
counter = Counter(words)
print(counter)  # Counter({'apple': 3, 'banana': 2, 'cherry': 1})

# most_common(n)：返回出现次数最多的 n 个元素
print(counter.most_common(2))  # [('apple', 3), ('banana', 2)]

# elements()：返回所有元素（重复出现次数次）
print(list(counter.elements()))
# ['apple', 'apple', 'apple', 'banana', 'banana', 'cherry']

# 计数器运算
c1 = Counter(a=3, b=1)
c2 = Counter(a=1, b=2)
print(c1 + c2)   # Counter({'a': 4, 'b': 3}) —— 加法
print(c1 - c2)   # Counter({'a': 2}) —— 减法（只保留正数）
print(c1 & c2)   # Counter({'a': 1, 'b': 1}) —— 交集（取较小值）
print(c1 | c2)   # Counter({'a': 3, 'b': 2}) —— 并集（取较大值）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from collections import ChainMap

# 把多个字典"链"在一起
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 100, "c": 3}
dict3 = {"d": 4}

# ChainMap 按顺序查找
chain = ChainMap(dict1, dict2, dict3)
print(chain["a"])   # 1 —— 只在 dict1 中找到
print(chain["b"])   # 2 —— dict1 中的 b，优先！
print(chain["c"])   # 3 —— dict2 中的 c
print(chain["d"])   # 4 —— dict3 中的 d

# 修改只影响第一个字典
chain["a"] = 999
print(dict1)  # {'a': 999, 'b': 2}

# 适用场景：合并多个配置字典（如命令行参数 + 默认配置）
defaults = {"theme": "light", "language": "zh"}
user_config = {"theme": "dark"}
config = ChainMap(user_config, defaults)
print(config["theme"])   # dark —— 用户配置优先
print(config["language"])  # zh —— 回退到默认配置