30 个 Python 常用操作技巧与示例

建议： 若返回值较多且需明确含义，推荐使用字典或数据类（dataclass），避免解包错误。

4. 链式比较

Python 支持数学中的链式比较写法，这是许多其他语言不具备的特性。

x = 5
print(1 < x < 30)  # True

优势： 比 1 < x and x < 30 更直观，符合数学表达习惯，且执行效率相同。

5. 字符串转列表

使用 ast.literal_eval 安全地将字符串转换为 Python 对象，避免 eval 的安全风险。

import ast
string = "[[1, 2, 3],[4, 5, 6]]"
my_list = ast.literal_eval(string)
print(my_list)

安全提示： 永远不要对不可信输入使用 eval()，literal_eval 仅解析字面量，更安全。

6. For-Else 结构

for 循环配合 else 子句，当循环正常结束（未被 break）时执行，常用于搜索失败后的处理。

number_List = [1, 3, 8, 9, 1]
for number in number_List:
    if number % 2 == 0:
        print(number)
        break
else:
    print("No even numbers found!")

区别： 原代码逻辑有误，此处修正为标准的 for-else 用法，体现 Python 特有的控制流。

7. 查找最大最小值

使用 heapq 模块高效查找 Top N 元素，无需对整个列表排序。

import heapq
numbers = [80, 25, 68, 77, 95, 88, 30, 55, 40, 50]
print(heapq.nlargest(5, numbers))
print(heapq.nsmallest(5, numbers))

性能： 相比排序后切片，此方法在处理大数据集时更高效，时间复杂度为 O(n log k)。

8. 字符串重复

使用乘法运算符直接重复字符串，语法简洁。

value = "Taha"
print(value * 5)  
print("-" * 21)

用途： 常用于打印分隔线、填充文本或生成测试数据。

9. 查找元素索引

使用 list.index() 获取元素首次出现的位置，注意索引从 0 开始。

cities = ['Vienna', 'Amsterdam', 'Paris', 'Berlin']
print(cities.index('Berlin'))

异常处理： 若元素不存在会抛出 ValueError，建议先检查存在性或捕获异常。

10. 多元素打印控制

使用 end 和 sep 参数精细控制打印格式，实现跨行或单行输出。

print("Analytics", end="")
print("Vidhya")
print('Data', 'science', sep=', ')

效果： 第一行无换行，第二行逗号分隔，灵活控制输出布局。

11. 数字格式化阅读

整数中可使用下划线分组，提高可读性，不影响数值大小。

print(5_000_000_000_000)
print(7_543_291_635)

版本要求： Python 3.6+ 支持，旧版本需使用千位分隔符处理。

12. 列表切片反转

使用负步长实现切片反转，是最常用的字符串/列表反转方式。

sentence = "Data science blogathon"
print(sentence[::-1])

说明： 原示例索引计算复杂，标准做法是 [::-1] 获取完整反转，包含首尾字符。

13. is 与 == 的区别

== 比较值是否相等，is 比较内存地址是否相同，理解二者差异至关重要。

list1 = [7, 9, 4]
list2 = [7, 9, 4]
print(list1 == list2)  # True
print(list1 is list2)  # False

原理： 两个不同列表对象即使内容相同，地址也不同，小整数缓存除外。

14. 合并字典

使用解包操作符 ** 合并字典，Python 3.5+ 推荐写法。

first_dct = {"London": 1, "Paris": 2}
second_dct = {"Tokyo": 3, "Seoul": 4}
merged = {**first_dct, **second_dct}
print(merged)

兼容性： Python 3.5+ 支持。旧版本可用 update() 方法逐个更新。

15. 字符串前缀检查

使用 startswith() 判断开头字符，支持传入元组检查多个前缀。

sentence = "Analytics Vidhya"
print(sentence.startswith("A"))  # True

扩展： 可传入 ("A", "B") 检查任意一个前缀，比多次调用更高效。

16. 获取 Unicode 码点

使用 ord() 获取字符编码，配合 chr() 可实现双向转换。

print(ord("T"))
print(ord("A")) 

反向： 使用 chr(84) 将码点转为字符，常用于字符编码处理。

17. 遍历字典键值对

使用 .items() 同时迭代键和值，是遍历字典的标准方式。

cities = {'London': 1, 'Paris': 2}
for key, value in cities.items():
    print(f"Key: {key}, Value: {value}")

替代： .keys() 和 .values() 分别获取键或值，视需求选择。

18. 列表插入与追加

append 加末尾，insert 指定位置，注意性能差异。

cities = ["London", "Vienna", "Rome"]
cities.append("Seoul")
cities.insert(0, "Berlin")
print(cities)

性能： insert(0) 时间复杂度 O(n)，频繁操作建议使用 collections.deque。

19. Filter 函数

使用 filter() 过滤迭代器，返回迭代器对象，惰性求值。

mixed_number = [8, 15, 25, 30, 34, 67, 90, 5, 12]
filtered_value = filter(lambda x: x > 20, mixed_number)
print(list(filtered_value))

对比： 列表推导式通常更 Pythonic，但在处理大型流数据时 filter 更节省内存。

20. 不定长参数

使用 *args 接收任意数量参数，实现通用聚合函数。

def multiplication(*arguments):
    mul = 1
    for i in arguments:
        mul *= i
    return mul
print(multiplication(3, 4, 5))

应用： 通用计算器、日志记录或动态构建 SQL 查询。

21. 并行迭代

使用 zip() 同时遍历多个序列，自动截断至最短长度。

capital = ['Vienna', 'Paris']
countries = ['Austria', 'France']
for cap, country in zip(capital, countries):
    print(f"{cap} is capital of {country}")

注意： 长度不一致时以最短为准，如需保留所有项可使用 itertools.zip_longest。

22. 内存大小检测

使用 sys.getsizeof() 查看对象占用内存，辅助性能调优。

import sys
mul = 5*6
print(sys.getsizeof(mul))

限制： 不包含引用计数或其他开销，仅供参考，大对象需用 tracemalloc。

23. Map 函数

使用 map() 对序列应用函数，返回迭代器，适合函数式编程风格。

values_list = [8, 10, 6, 50]
quotient = map(lambda x: x/2, values_list)
print(list(quotient))

趋势： 现代 Python 推荐列表推导式替代 map，除非涉及 C 扩展函数。

24. 统计元素次数

使用 count() 方法统计出现频率，简单直接。

cities = ["Paris", "Berlin", "Paris"]
print(cities.count("Paris"))

局限： 仅适用于列表，字典需用 Counter 或 defaultdict。

25. 元组查找索引

元组同样支持 index() 方法，但无法修改内容。

cities_tuple = ("Berlin", "Paris", 5)
print(cities_tuple.index("Paris"))

特性： 元组不可变，查找后无法修改，适合存储配置或常量。

26. 集合合并

使用 union() 合并集合，去除重复元素。

set1 = {'Vienna', 'Paris'}
set2 = {'Tokyo', 'Rome'}
print(set1.union(set2))

符号： 也可用 | 运算符，语义更简洁。

27. 按频率排序

使用 collections.Counter 统计并排序，快速获取高频元素。

from collections import Counter
count = Counter([7, 6, 5, 6, 8, 6, 6, 6])
print(count.most_common())

结果： 返回按频率降序排列的列表，常用于词频分析。

28. 去除重复值

转换为集合再转回列表，快速去重。

cities_list = ['Vienna', 'Paris', 'Paris']
cities_list = list(set(cities_list))

警告： 集合无序，会丢失原始顺序，需保持顺序请用 dict.fromkeys。

29. 列表差异计算

使用集合对称差找出不同元素，比对数据变更。

cities_list1 = ['Vienna', 'Paris', 'Berlin']
cities_list2 = ['Vienna', 'Paris', 'Seoul']
diff = set(cities_list1) ^ set(cities_list2)
print(diff)

场景： 比对数据库表结构、配置文件差异等。

30. 列表转字典

使用 zip() 结合 dict() 构建映射，建立 ID 到名称关系。

number = [1, 2, 3]
cities = ['Vienna', 'Paris', 'Seoul']
result = dict(zip(number, cities))
print(result)

应用： 建立 ID 到名称的映射关系，常用于表单选项或 API 响应。

总结

以上 30 个技巧涵盖了 Python 日常开发中的高频场景，从基础数据结构操作到标准库的高效利用。熟练掌握这些基础但高效的用法，能够编写出更简洁、高效的代码。建议在实际项目中多加练习，根据具体需求选择最合适的实现方式。持续积累最佳实践，将有助于提升编程水平，写出更具可维护性的 Python 代码。

进阶建议

除了掌握上述技巧外，建议进一步学习 Python 的类型注解、装饰器、上下文管理器以及异步编程。这些高级特性能进一步提升代码的健壮性和并发处理能力。同时，关注 PEP 规范，保持代码风格统一，也是成为优秀 Python 开发者的必经之路。