20 个常用 Python 技巧：提升代码可读性与效率

5. 列表生成式

列表推导式是 Python 中创建新列表的强力工具，比传统循环更简洁。

# 将列表中每个元素乘以 2
original_list = [1, 2, 3, 4]

new_list = [2 * x for x in original_list]

print(new_list)
# 输出：[2, 4, 6, 8]

注意： 列表推导式在内存效率和代码可读性上通常优于显式的 for 循环。

6. 变量交换

Python 支持多变量赋值，无需临时变量即可交换两个变量的值。

a = 1
b = 2

a, b = b, a

print(a)  # 2
print(b)  # 1

注意： 这是元组解包机制的应用，底层会自动处理值的传递。

7. 字符串拆分为子字符串列表

使用 split() 函数可以根据指定的分隔符将字符串分割成列表。

string_1 = "My name is Chaitanya Baweja"
string_2 = "sample/ string 2"

# 默认分隔符为空格
print(string_1.split())
# 输出：['My', 'name', 'is', 'Chaitanya', 'Baweja']

# 定义分隔符为 '/'
print(string_2.split('/'))
# 输出：['sample', ' string 2']

注意： 如果未指定分隔符，split() 会自动按空白字符分割并去除多余空格。

8. 多个字符串组合为一个字符串

使用 join() 方法可以将列表中的字符串连接成一个长字符串，效率高于使用 + 号累加。

list_of_strings = ['My', 'name', 'is', 'Chaitanya', 'Baweja']

# 使用逗号作为分隔符连接
print(','.join(list_of_strings))

# 输出：My,name,is,Chaitanya,Baweja

注意： join() 是字符串对象的方法，参数必须是可迭代的字符串序列。

9. 检测字符串是否为回文

通过比较字符串与其反转后的版本，可以判断其是否为回文结构。

my_string = "abcba"

if my_string == my_string[::-1]:
    print("palindrome")
else:
    print("not palindrome")

# 输出：palindrome

注意： 实际应用中通常需要先去除空格和统一大小写。

10. 统计列表中元素的次数

使用 collections.Counter 类可以方便地统计元素频率。

from collections import Counter

# 查找列表中每个元素的频率
my_list = ['a', 'a', 'b', 'b', 'b', 'c', 'd', 'd', 'd', 'd', 'd']
count = Counter(my_list)  # 定义计数器对象

print(count)  # 所有元素
# 输出：Counter({'d': 5, 'b': 3, 'a': 2, 'c': 1})

print(count['b'])  # 单个元素
# 输出：3

print(count.most_common(1))  # 出现最多的元素
# 输出：[('d', 5)]

注意： Counter 继承自字典，支持大部分字典操作。

11. 判断两个字符串是否为 Anagrams

Anagrams 指两个单词包含相同的字符且频率相同。使用 Counter 比较是最直接的方法。

from collections import Counter

str_1, str_2, str_3 = "acbde", "abced", "abcda"
cnt_1, cnt_2, cnt_3 = Counter(str_1), Counter(str_2), Counter(str_3)

if cnt_1 == cnt_2:
    print('1 and 2 anagram')
if cnt_1 == cnt_3:
    print('1 and 3 anagram')

# 输出：1 and 2 anagram

注意： 此方法对大小写敏感，如需忽略大小写，请先统一转换。

12. 使用 try-except-else-finally 模块

结构化异常处理能确保程序在出错时优雅降级，并在最后执行清理工作。

a, b = 1, 0

try:
    print(a / b)
    # 当 b 为 0 时会抛出异常
except ZeroDivisionError:
    print("division by zero")
else:
    print("no exceptions raised")
finally:
    print("Run this always")

# 输出：
# division by zero
# Run this always

注意： else 块仅在无异常时执行，finally 块无论是否发生异常都会执行。

13. 使用枚举函数得到 key/value 对

enumerate() 允许在遍历列表时同时获取索引和值。

my_list = ['a', 'b', 'c', 'd', 'e']

for index, value in enumerate(my_list):
    print('{0}: {1}'.format(index, value))

# 输出：
# 0: a
# 1: b
# 2: c
# 3: d
# 4: e

注意： 默认索引从 0 开始，可通过 start 参数自定义起始值。

14. 检查对象的内存使用情况

使用 sys.getsizeof() 可以查看对象占用的字节数，有助于内存优化。

import sys

num = 21

print(sys.getsizeof(num))

# Python 2 中通常为 24
# Python 3 中通常为 28

注意： 该函数仅返回对象本身的大小，不包含引用计数或其他开销。

15. 合并字典

Python 3.5+ 支持使用解包操作符 ** 快速合并字典。

dict_1 = {'apple': 9, 'banana': 6}
dict_2 = {'banana': 4, 'orange': 8}

combined_dict = {**dict_1, **dict_2}

print(combined_dict)
# 输出：{'apple': 9, 'banana': 4, 'orange': 8}

注意： 后合并的字典键值会覆盖先合并的字典同名键的值。

16. 计算执行一段代码所花费的时间

使用 time 模块记录起止时间，可评估代码段的运行耗时。

import time

start_time = time.time()
# 待测代码
for i in range(10**5):
    a, b = 1, 2
    c = a + b
# 待测代码结束
end_time = time.time()

time_taken_in_micro = (end_time - start_time) * (10**6)

print(time_taken_in_micro)

# 输出示例：18770.217895507812

注意： 对于极短的代码段，建议使用 timeit 模块以获得更精确的结果。

17. 列表展开

处理嵌套列表时，可以使用递归或迭代方式将其展平为一维列表。

from iteration_utilities import deepflatten

# 如果只有一层嵌套，可使用列表推导式
def flatten(l):
    return [item for sublist in l for item in sublist]

l = [[1, 2, 3], [3]]
print(flatten(l))
# 输出：[1, 2, 3, 3]

# 如果不知道嵌套深度，可使用第三方库
l = [[1, 2, 3], [4, [5], [6, 7]], [8, [9, [10]]]]

print(list(deepflatten(l, depth=3)))
# 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

注意： 标准库中没有内置的深度展开函数，复杂场景建议引入 more-itertools 等库。

18. 列表采样

使用 random.sample() 可以从列表中随机抽取指定数量的不重复元素。

import random

my_list = ['a', 'b', 'c', 'd', 'e']
num_samples = 2

samples = random.sample(my_list, num_samples)
print(samples)
# 输出：['a', 'e']  # 每次运行结果可能不同

注意： 样本数量不能超过列表总长度，否则会抛出 ValueError。

19. 数字化

将整数转换为数字列表，常用于处理数值位运算或加密算法。

num = 123456

# 使用 map 函数
list_of_digits = list(map(int, str(num)))

print(list_of_digits)
# 输出：[1, 2, 3, 4, 5, 6]

# 使用列表推导式
list_of_digits = [int(x) for x in str(num)]

print(list_of_digits)
# 输出：[1, 2, 3, 4, 5, 6]

注意： 两种方法性能差异微乎其微，列表推导式更符合 Python 风格。

20. 检查列表元素的唯一性

通过比较列表长度与集合长度，可快速判断是否存在重复元素。

def unique(l):
    if len(l) == len(set(l)):
        print("All elements are unique")
    else:
        print("List has duplicates")

unique([1, 2, 3, 4])
# 输出：All elements are unique

unique([1, 1, 2, 3])
# 输出：List has duplicates

注意： 集合去重操作的时间复杂度为 O(n)，适合大数据量初步筛查。

总结

以上 20 个技巧涵盖了 Python 开发中的高频场景。熟练掌握这些语法糖和内置函数，不仅能减少代码行数，还能显著提升程序的执行效率和可维护性。建议在实际项目中根据具体需求灵活选用。