你写的Python代码一眼就能看出是新手？换掉这5个习惯，代码瞬间高级起来

上周一个学员在群里发了一段代码，让我帮忙看看哪里写得不好。他入职三个月，leader说他「代码不够 Pythonic」，他自己也不明白什么意思。

我看了一眼，问题其实很明显。他的代码逻辑是对的，但写法处处透着「从Java/C转过来的味道」——明明有更简洁优雅的方式，偏偏用最啰嗦的写法。

如果你也经常写 Python，但总感觉自己写的代码和公司里老手的代码「气质不一样」，那这篇文章就是为你准备的。我会列出 5 个新手最容易踩中的写法习惯，并告诉你该怎么改。每改掉一个，你的代码就离「专业感」近一步。

一、别再写 range(len()) 了，用 enumerate

这可能是 Python 新手暴露率最高的一种写法。需要同时拿到列表的索引和元素时，几乎每一个从 C 或 Java 转过来的程序员都会本能地写成这样：

fruits = ['apple', 'banana', 'cherry']

# 新手写法：这也太 Java 了
for i in range(len(fruits)):
    print(f"{i}: {fruits[i]}")

这段代码能跑吗？能跑。但任何一个有经验的 Python 程序员看到它，都会在心里给这段代码默默打上一个「新手标签」。

Python 提供了一个内置函数 enumerate()，专门用来同时获取索引和值。它的存在就是为了消灭 range(len()) 这种写法：

fruits = ['apple', 'banana', 'cherry']

# Pythonic 写法：简洁、清晰、高效
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

好处不止是少写了一行。enumerate 直接返回一个迭代器，它在遍历时一次只生成一个 (index, value) 对，不需要像 range(len()) 那样先生成一个完整的数字序列再逐个取用。代码更清晰、效率更高——这就是 Pythonic 的含义。

另外 enumerate 还支持第二个参数——起始索引。比如你想让它从 1 开始计数：

# 输出格式：第1名: 张三, 第2名: 李四...
for rank, name in enumerate(students, start=1):
    print(f"第{rank}名: {name}")

一句话总结：需要索引和元素同时出现的地方，用 enumerate。除非你的逻辑真的需要拿到列表长度做别的事，否则没有理由用 range(len())。

二、for 循环里疯狂 append？试试列表推导式

先看一段新手代码，你可能也这么写过：

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = []

for num in numbers:
    if num % 2 == 0:
        even_numbers.append(num)

print(even_numbers)  # [2, 4, 6, 8, 10]

逻辑没问题，但 6 行代码才完成了一个「筛选偶数」的操作。在 Python 中，这个需求用列表推导式一行就够：

even_numbers = [num for num in numbers if num % 2 == 0]

列表推导式的基本语法就是：[表达式 for 变量 in 可迭代对象 if 条件]。把你想塞进列表的东西写在最前面，然后依次是循环和条件。

它的能力远不止「筛选」，你还可以在表达式中做运算：

# 把所有名字转成大写
names = ['alice', 'bob', 'charlie']
upper_names = [name.upper() for name in names]

# 把价格打八折（只保留大于 100 的）
prices = [50, 120, 200, 80, 150]
discounted = [p * 0.8 for p in prices if p > 100]

看到优势了吧？不仅仅是少写几行代码，更重要的是可读性。列表推导式让你的意图一目了然：「我要对这个可迭代对象做什么操作，生成一个什么列表。」

有一点需要注意：列表推导式不适合嵌套太深。如果一个推导式里有两层 for 加两个 if，那就该考虑拆开来写普通循环了。追求简洁是真，牺牲可读性是假。

三、还在用下标同时遍历多个列表？zip 了解一下

假设你有两个列表：一个是学生姓名，一个是分数。你需要把每个学生和他的分数配对输出。很多新手会这样写：

names = ['张三', '李四', '王五']
scores = [85, 92, 78]

# 又来了，又是下标...
for i in range(len(names)):
    print(f"{names[i]}: {scores[i]}分")

这次 range(len()) 又来了，而且这次的问题比单纯拿索引更严重——如果两个列表长度不一致，走到后面会直接 IndexError。

Python 提供了 zip() 函数来优雅地解决这个问题：

names = ['张三', '李四', '王五']
scores = [85, 92, 78]

# Pythonic 写法：干净、安全
for name, score in zip(names, scores):
    print(f"{name}: {score}分")

zip 会把多个可迭代对象「拉链」到一块，返回一个元组的迭代器。它还有一个特性：以最短的可迭代对象为准，多余的部分自动忽略。这在很多时候是合理的默认行为，避免了数组越界。

如果你需要对所有列表「一视同仁」，可以用 zip_longest：

from itertools import zip_longest

# 短的列表用 None 补齐
for name, score in zip_longest(names, scores):
    print(f"{name}: {score}")

zip 还有一个很实用的场景：把两个列表转成字典。这种需求在新手代码里经常用 for 循环一行一行写，实际上 zip 配合 dict() 一行秒杀：

keys = ['name', 'age', 'city']
values = ['小明', 25, '深圳']

info = dict(zip(keys, values))
# {'name': '小明', 'age': 25, 'city': '深圳'}

一旦你习惯了 zip，就再也回不去那种手动维护下标的写法了。

四、还在手动 open 和 close？你已经错过 Python 最好用的功能之一

几乎所有 Python 教程在教文件操作时，都会先教这种写法：

# 新手最熟悉的写法——但并不推荐
f = open('data.txt', 'r')
content = f.read()
f.close()

这个写法有一个致命缺陷：如果 f.read() 执行过程中抛了异常，f.close() 就不会被执行，文件句柄就一直占用着。在生产环境里，这种问题可能跑几天才触发一次，排查起来极其痛苦。

Python 的 with 语句就是为了解决这个问题而生的：

# 推荐写法：不用你操心 close
with open('data.txt', 'r') as f:
    content = f.read()
# 出了 with 块，文件自动关闭，就算出异常也一样

with 语句利用了 Python 的「上下文管理器」机制。进入 with 块时自动执行准备工作（比如打开文件），离开 with 块时自动执行清理工作（比如关闭文件）。即便在 with 块内部抛了异常，清理工作也会执行。

更重要的是，with 语句不仅用于文件操作。数据库连接、网络请求、线程锁——这些需要「用完即关」的资源，都可以（也应该）用 with：

import sqlite3

# 数据库连接也建议用 with
with sqlite3.connect('app.db') as conn:
    cursor = conn.cursor()
    cursor.execute('SELECT * FROM users')
    # 离开 with 块会自动 commit 或 rollback

写文件的时候也一样：

# 写入文件：with 保证写完自动关
with open('output.txt', 'w') as f:
    f.write('Hello Python')

把 open 换成 with open，是你从「能跑就行」到「写出靠谱代码」的标志性一步。

五、动不动就创建一个大列表？生成器表达式了解一下

很多新手喜欢先把数据全读到内存里再处理。比如计算一个超大文件里所有数字的平方和：

# 新手写法：先生成一个包含所有平方的大列表，再求和
numbers = range(1, 10000001)  # 一千万个数字
squares = [n ** 2 for n in numbers]  # 这行会吃掉大量内存
total = sum(squares)

这段代码在一千万个数据面前可能直接 OOM（内存溢出）。因为 [n ** 2 for n in numbers] 这个列表推导式会把所有一千万个平方数一次性加载到内存里。

解决方案简单得离谱：把方括号换成圆括号，就变成了**生成器表达式**：

# 把方括号改成圆括号，内存占用从天壤之别
total = sum(n ** 2 for n in range(1, 10000001))

生成器表达式不会一次性生成所有数据，而是「惰性求值」——每次只产生一个值，给 sum 处理后就丢弃，下一个值再接着来。所以整个过程的内存占用基本上是常数级的。

列表推导式 vs 生成器表达式的选择原则很简单：

如果你需要多次遍历、随机访问、或者要获取长度——用列表推导式（方括号）。

如果你只是遍历一次，用完就扔——用生成器表达式（圆括号）。

几个常见的生成器表达式使用场景：

# 用 any/all 检查条件（这里用生成器，找到一个就停）
has_large = any(len(word) > 10 for word in words)

# 用 join 拼接字符串（比先构造列表再 join 省内存）
result = ', '.join(str(n) for n in range(1000000))

# 用 max/min 找极值
longest = max(words, key=len)

这可能是五个改进里最「看不见」但最有价值的一个。你写的代码在处理几百条数据时完全没问题，但一旦数据量翻到几十万、几百万，内存问题就会暴露出来。而养成用生成器表达式的习惯，从根本上杜绝了这类隐患。

写在最后

这五个改进分别解决了一个核心问题：

enumerate 让你告别下标思维，zip 让你优雅地处理多个序列，列表推导式把六行变一行，with 语句让你不再忘记关资源，生成器表达式让你不必担心内存爆炸。

它们每一个单独拿出来都不起眼，但凑在一起，就是你写的代码从「能跑就行」变成「看着舒服」的关键跨越。

如果你也在刚开始学 Python，或者正在准备面试、跳槽，建议把这五个点刻在肌肉记忆里。它们不仅让你的代码更好看，更高效，更重要的是——你会开始像 Python 程序员一样思考问题，而不是像一个只会用 Python 语法的 C 程序员。

你在写 Python 的过程中还遇到过哪些「一看就是新手」的写法？欢迎在留言区分享你的发现和踩坑经历，我们一起进步。

以上就是“你写的Python代码一眼就能看出是新手？换掉这5个习惯，代码瞬间高级起来”的详细内容，想要了解更多Python教程欢迎持续关注编程学习网。