很多 Python 开发者写了好几年代码，依然停留在「能跑就行」的阶段。但真正拉开初级和中高级差距的，往往不是什么高深框架，而是对语言本身的细节掌控：一行代码能不能替代十行、一个表达式能不能避开一整段嵌套循环、数据结构的选择会不会悄悄拖垮性能。这篇把我这些年反复打磨、真正常用到的 10 个 Python 进阶技巧整理出来，每一个都附带可运行示例，建议边读边敲。

一、列表推导式：一行干掉一个 for 循环

新手最常写的样板代码：

squares = []
for i in range(10):
    squares.append(i * i)

进阶写法只要一行，且底层用专门的字节码 LIST_APPEND，比循环里反复调用 append 更快：

squares = [i * i for i in range(10)]

带条件的版本：

even_squares = [i * i for i in range(10) if i % 2 == 0]

但有一点要警惕：列表推导式一次性把结果加载进内存。数据量上百万时，用生成器表达式替换方括号为圆括号，省内存：

gen = (i * i for i in range(10_000_000))   # 不立即计算，按需产出

二、enumerate：别再用 range(len(...)) 取下标

这是最典型的「从 C/Java 带过来的坏习惯」：

for i in range(len(data)):
    print(i, data[i])

Pythonic 的写法是 enumerate，默认从 0 开始，也可指定起始序号：

for idx, value in enumerate(data, start=1):
    print(idx, value)

三、zip：并行遍历多个序列

把两个列表按位置配对，不用下标硬拼：

names = ["Alice", "Bob", "Carol"]
scores = [90, 85, 78]

for name, score in zip(names, scores):
    print(f"{name}: {score}")

注意 zip 以最短序列为准截断。想保留全部，用 itertools.zip_longest：

from itertools import zip_longest
for name, score in zip_longest(names, scores, fillvalue="缺考"):
    print(name, score)

巧妙用法：用 zip(*matrix) 实现矩阵转置：

matrix = [[1, 2, 3], [4, 5, 6]]
transposed = list(zip(*matrix))   # [(1, 4), (2, 5), (3, 6)]

四、字典推导式：一行完成数据清洗与转换

把一个列表里的单词按长度分组统计，传统写法要好几行，用 collections.Counter 配合字典推导式：

from collections import Counter
words = ["apple", "pie", "banana", "kiwi", "apple"]

word_len = {w: len(w) for w in set(words)}
counts = Counter(words)            # Counter({'apple': 2, 'pie': 1, ...})

过滤型字典推导：

filtered = {w: len(w) for w in words if len(w) > 3}

三、解包与 *、** 的妙用

星号解包是 Python 3 最实用的语法之一：

first, *rest = [1, 2, 3, 4, 5]      # first=1, rest=[2,3,4,5]
*init, last = [1, 2, 3, 4, 5]       # init=[1,2,3,4], last=5
first, *middle, last = [1, 2, 3, 4] # first=1, middle=[2,3], last=4

合并字典也变得极简（Python 3.5+）：

d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}
merged = {**d1, **d2}   # {'a': 1, 'b': 3, 'c': 4}，后者覆盖前者

Python 3.9 之后还能用 | 运算符：merged = d1 | d2。

四、any() 与 all()：布尔聚合的瑞士军刀

判断列表里是否存在某个条件的元素，别再写循环：

numbers = [3, 7, 12, -5, 8]

has_negative = any(n < 0 for n in numbers)       # True
all_positive = all(n > 0 for n in numbers)        # False

any 有一个「短路」特性：遇到第一个 True 立刻返回，不遍历剩余元素；all 遇到第一个 False 立刻返回。处理超大序列时这是免费的性能优化。

五、海象运算符 := 把赋值塞进表达式

Python 3.8 引入的 := 让你在一个表达式里完成「赋值 + 使用」，避免重复求值：

text = f.read()
if len(text) > 100:
    process(text)

if (text := f.read()) and len(text) > 100:
    process(text)

在 while 循环里读取输入时尤其清爽：

while chunk := stream.read(8192):
    handle(chunk)

六、f-string 高阶玩法：对齐、补零、数字格式化

f-string 不只能插值，它的格式化能力被很多人低估：

n = 3.14159
name = "Python"

print(f"{name:>10}")        # 右对齐，宽度 10
print(f"{name:<10}")        # 左对齐
print(f"{name:^10}")        # 居中
print(f"{n:.2f}")           # 保留两位小数：3.14
print(f"{1000:,}")          # 千分位：1,000
print(f"{255:#010b}")       # 二进制补零：0b011111111
print(f"{0.15:.1%}")        # 百分比：15.0%

调试时还有个隐藏技巧（Python 3.8+），= 会自动把变量名也打印出来：

x = 42
print(f"{x=}")              # x=42

七、条件表达式（三目）：把 if-else 压成一行

简单赋值别再写四行：

if score >= 60:
    result = "及格"
else:
    result = "不及格"

result = "及格" if score >= 60 else "不及格"

但注意别嵌套太深，超过两层就该老老实实写成普通 if-else，可读性永远优先于炫技。

八、set 去重与集合运算

去重用 set，底层是哈希表，O(1) 查找：

dup = [1, 2, 2, 3, 3, 3]
unique = list(set(dup))     # [1, 2, 3]，但顺序会丢
unique_ordered = list(dict.fromkeys(dup))   # 保序去重

集合运算特别适合做数据分析时的对比：

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}

九、sorted() 的 key 参数：自定义排序逻辑

sorted 的 key 接收一个函数，比手写比较逻辑高效得多（Schwartzian 变换，每个元素只计算一次 key）：

students = [("Alice", 90), ("Bob", 85), ("Carol", 95)]

sorted(students, key=lambda s: s[1])

sorted(students, key=lambda s: s[1], reverse=True)

sorted(students, key=lambda s: (-s[1], s[0]))

配合 operator.itemgetter 更快更简洁：

from operator import itemgetter
sorted(students, key=itemgetter(1, 0))

十、上下文管理器 with：自动清理资源

文件、数据库连接、锁，都应该用 with 管理，保证异常时也能正确释放：

f = open("data.txt")
try:
    data = f.read()
finally:
    f.close()

with open("data.txt") as f:
    data = f.read()

多个资源可以叠加：

with open("in.txt") as fin, open("out.txt", "w") as fout:
    for line in fin:
        fout.write(line.upper())

自己写的类只要实现 __enter__ 和 __exit__，也能用 with 管理，这在管理线程锁、临时文件、事务时极其常用。

这 10 个技巧的共同点：它们都不是奇技淫巧，而是 Python 社区公认的「惯用写法」（Pythonic）。当你发现自己的代码里还有大量 range(len(...))、手动拼接字符串、逐个 append 的循环时，对照这份清单回去重构一遍，代码量通常能砍掉一半，可读性和性能还会同步提升。真正成熟的开法习惯，往往就藏在这些细节里。

更多相关技术内容咨询欢迎前往并持续关注好学星城论坛了解详情。

想高效系统的学习Python编程语言，推荐大家关注一个微信公众号：Python编程学习圈。每天分享行业资讯、技术干货供大家阅读，关注即可免费领取整套Python入门到进阶的学习资料以及教程，感兴趣的小伙伴赶紧行动起来吧。