【Python】常用的语法糖

1. 列表、字典、集合推导式
用简洁的语法生成新的容器，替代繁琐的循环。python
# 列表推导式：生成 0~9 的平方数列表
squares = [x**2 for x in range(10)]
print(squares)  # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]# 字典推导式：用数字作为键，平方作为值
square_dict = {x: x**2 for x in range(5)}
print(square_dict)  # 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}# 集合推导式：生成 0~9 中的偶数集合
even_set = {x for x in range(10) if x % 2 == 0}
print(even_set)  # 输出: {0, 2, 4, 6, 8}


2. 条件表达式（三元运算符）
在一行内完成简单的条件判断赋值。python
age = 20
status = "成年" if age >= 18 else "未成年"
print(status)  # 输出: 成年

age = 15
status = "成年" if age >= 18 else "未成年"
print(status)  # 输出: 未成年

3. with 语句（上下文管理器）
自动管理资源，如文件打开后自动关闭。python
# 传统写法需要手动 try-finally，with 自动处理
with open('example.txt', 'w') as f:f.write('Hello, world!')
# 文件在这里已经自动关闭，无需显式调用 f.close()
print("文件写入完成，已自动关闭")

4. 装饰器 @
使用 @ 符号简洁地扩展函数功能。

python
# 定义一个计时装饰器
import timedef timer(func):def wrapper(*args, **kwargs):start = time.time()result = func(*args, **kwargs)end = time.time()print(f"{func.__name__} 执行耗时: {end - start:.4f} 秒")return resultreturn wrapper@timer
def slow_function():time.sleep(1)  # 模拟耗时操作return "完成"result = slow_function()  # 输出类似: slow_function 执行耗时: 1.0012 秒
print(result)             # 输出: 完成


5. 切片操作
快速获取序列的子集，支持步长和反向。python
lst = [0, 1, 2, 3, 4, 5]
sub = lst[1:4]            # 索引 1 到 3（不包含 4）
print(sub)                # 输出: [1, 2, 3]

reverse = lst[::-1]        # 步长为 -1，反转列表
print(reverse)             # 输出: [5, 4, 3, 2, 1, 0]

every_second = lst[::2]    # 步长为 2，取偶数索引元素
print(every_second)        # 输出: [0, 2, 4]


6. 解包（Unpacking）
将可迭代对象拆分到多个变量，或合并多个对象。

python
# 基本解包
a, b, c = [1, 2, 3]
print(a, b, c)  # 输出: 1 2 3# 使用 * 收集剩余元素
first, *rest = range(5)   # 等价于 [0, 1, 2, 3, 4]
print(first)              # 输出: 0
print(rest)               # 输出: [1, 2, 3, 4]# 列表合并解包
combined = [1, 2, *[3, 4], 5]
print(combined)           # 输出: [1, 2, 3, 4, 5]# 字典合并解包
dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
merged = {**dict1, **dict2}
print(merged)             # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}


7. f-string 格式化字符串
在字符串中直接嵌入变量和表达式，简洁直观。python
name = "Alice"
age = 30
print(f"{name} is {age} years old.")  # 输出: Alice is 30 years old.# 支持表达式和格式化
x = 10
y = 3
print(f"{x} / {y} = {x/y:.2f}")       # 输出: 10 / 3 = 3.33# Python 3.8+ 支持调试模式（打印变量名和值）
print(f"{2 * 3 = }")                  # 输出: 2 * 3 = 6


8. 赋值表达式（海象运算符）:=
在表达式中同时赋值，避免重复计算。python
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]# 传统写法需要先计算长度再判断
# n = len(data)
# if n > 5:
#     print(f"长度 {n} 大于 5")# 使用海象运算符
if (n := len(data)) > 5:print(f"长度 {n} 大于 5")  # 输出: 长度 10 大于 5# 在循环中读取文件块
with open('example.txt', 'r') as f:while (chunk := f.read(10)):  # 每次读取 10 个字符，直到空print(chunk, end='|')
# 假设文件内容 "HelloWorld"，输出: HelloWorl|d|


9. enumerate 枚举
同时获取索引和元素，比手动维护计数器更优雅。python
fruits = ['apple', 'banana', 'cherry']for idx, fruit in enumerate(fruits):print(f"{idx}: {fruit}")
# 输出:
# 0: apple
# 1: banana
# 2: cherry# 可以指定起始索引
for idx, fruit in enumerate(fruits, start=1):print(f"{idx}: {fruit}")
# 输出:
# 1: apple
# 2: banana
# 3: cherry


10. zip 并行迭代
将多个可迭代对象按位置打包成元组。python
names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
cities = ['New York', 'London', 'Tokyo']for name, age, city in zip(names, ages, cities):print(f"{name} is {age} years old, lives in {city}.")
# 输出:
# Alice is 25 years old, lives in New York.
# Bob is 30 years old, lives in London.
# Charlie is 35 years old, lives in Tokyo.# 如果长度不一致，zip 会以最短为准
short_names = ['Alice', 'Bob']
for name, age in zip(short_names, ages):print(name, age)  # 输出: Alice 25 \n Bob 30


11. 匿名函数 lambda
快速定义简单函数，常用于函数式编程。python
# 定义一个加法 lambda
add = lambda x, y: x + y
print(add(3, 5))  # 输出: 8# 结合 map 使用
numbers = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, numbers))
print(squared)    # 输出: [1, 4, 9, 16]# 结合 filter 使用
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)      # 输出: [2, 4]


12. 生成器表达式
类似列表推导式，但返回生成器，惰性求值，节省内存。python
# 生成器表达式，不会立即计算所有值
gen = (x**2 for x in range(10))
print(gen)  # 输出: <generator object <genexpr> at 0x...># 逐个获取值
print(next(gen))  # 输出: 0
print(next(gen))  # 输出: 1# 也可用于 sum、max 等函数，无需创建完整列表
total = sum(x**2 for x in range(1000000))  # 内存友好
print(f"总和: {total}")  # 输出: 总和: 333332833333500000 (实际数值)


13. for-else 和 while-else
循环正常结束（未遇到 break）时执行 else 块，常用于查找场景。

python
# 检查一个数是否是质数
def is_prime(n):if n < 2:return Falsefor i in range(2, int(n**0.5) + 1):if n % i == 0:print(f"{n} 不是质数，能被 {i} 整除")breakelse:# 循环没有被 break 中断，说明是质数print(f"{n} 是质数")return Truereturn Falseis_prime(7)   # 输出: 7 是质数
is_prime(10)  # 输出: 10 不是质数，能被 2 整除


14. 函数参数中的 *args 和 **kwargs
接受任意数量的位置参数和关键字参数。

python
def show_info(title, *args, **kwargs):print(f"标题: {title}")print("位置参数:", args)      # args 是一个元组print("关键字参数:", kwargs)  # kwargs 是一个字典

show_info("测试", 1, 2, 3, name="Alice", age=30)
# 输出:
# 标题: 测试
# 位置参数: (1, 2, 3)
# 关键字参数: {'name': 'Alice', 'age': 30}


15. 属性装饰器 @property
将方法转换为属性调用，并可定义 setter 和 deleter。python
class Circle:def __init__(self, radius):self._radius = radius@propertydef radius(self):"""获取半径"""return self._radius@radius.setterdef radius(self, value):"""设置半径，并进行验证"""if value < 0:raise ValueError("半径不能为负数")self._radius = value@propertydef area(self):"""计算面积，通过属性访问"""return 3.14159 * self._radius ** 2c = Circle(5)
print(c.radius)  # 输出: 5
print(c.area)    # 输出: 78.53975 (像属性一样调用，无括号)

c.radius = 10    # 调用 setter
print(c.area)    # 输出: 314.159# c.radius = -1  # 会抛出 ValueError