在 Python 编程世界里，代码的简洁性与可读性至关重要。简洁优雅的代码不仅便于自己后期维护，也能让其他开发者快速理解逻辑。而 Python 丰富的内置函数和一些实用的第三方库函数，就是实现这一目标的有力武器。接下来，就为大家介绍几个能让代码“脱胎换骨”的函数，助力写出简洁又优雅的代码。

 

 

一、 map  函数：批量操作元素

 

 map  函数接收两个参数，一个是函数，一个是可迭代对象（比如列表、元组等 ），它会将传入的函数依次作用到可迭代对象的每个元素上，返回一个新的迭代器。

 

场景示例：列表元素平方

 

如果要对一个列表  nums = [1, 2, 3, 4]  中的每个元素求平方，常规的  for  循环写法是这样：

 

nums = [1, 2, 3, 4]

result = []

for num in nums:

    result.append(num ** 2)

print(result)  

 

 

用  map  函数则简洁很多：

 

nums = [1, 2, 3, 4]

result = map(lambda x: x ** 2, nums)

# 转为列表查看结果，实际使用中若后续迭代可直接用迭代器

print(list(result))  

 

 

这里利用  lambda  匿名函数配合  map ，一行代码就完成了对列表所有元素的平方操作，省去了手动初始化空列表、写循环体的步骤，代码更紧凑。

 

二、 filter  函数：精准筛选元素

 

 filter  函数同样接收函数和可迭代对象作为参数，传入的函数需返回布尔值，它会筛选出可迭代对象中使函数返回  True  的元素，返回一个迭代器。

 

场景示例：筛选列表中的偶数

 

对于列表  nums = [1, 2, 3, 4, 5, 6] ，要筛选出其中的偶数，常规循环：

 

nums = [1, 2, 3, 4, 5, 6]

result = []

for num in nums:

    if num % 2 == 0:

        result.append(num)

print(result)  

 

 

用  filter  函数：

 

nums = [1, 2, 3, 4, 5, 6]

result = filter(lambda x: x % 2 == 0, nums)

print(list(result))  

 

 

借助  filter  ，把筛选逻辑（判断是否为偶数 ）提炼成函数（这里用  lambda  ），直接筛选出符合条件的元素，代码逻辑清晰又简洁。

 

三、 zip  函数：高效聚合多个可迭代对象

 

 zip  函数能将多个可迭代对象中对应位置的元素打包成元组，返回一个迭代器。当你需要同时遍历多个可迭代对象，取出对应位置元素进行操作时，它非常好用。

 

场景示例：合并两个列表对应元素

 

有两个列表  names = ["Alice", "Bob"] ， ages = [20, 25] ，要将姓名和年龄一一对应合并，常规思路可能用索引遍历：

 

names = ["Alice", "Bob"]

ages = [20, 25]

result = []

for i in range(len(names)):

    result.append((names[i], ages[i]))

print(result)  

 

 

用  zip  函数：

 

names = ["Alice", "Bob"]

ages = [20, 25]

result = zip(names, ages)

print(list(result))  

 

 

 zip  自动帮我们把对应位置元素配对，代码简洁直观，尤其当可迭代对象数量更多时，优势更明显，比如三个列表  a = [1,2] ,  b = [3,4] ,  c = [5,6]  ， zip(a,b,c)  能轻松打包成  [(1,3,5),(2,4,6)]  这样的形式。

 

四、 enumerate  函数：遍历带索引

 

在遍历可迭代对象时，有时需要同时获取元素的索引和元素本身。 enumerate  函数就可以在遍历过程中，为每个元素配上其索引，返回一个枚举对象（迭代器 ）。

 

场景示例：遍历列表并获取索引

 

对于列表  fruits = ["apple", "banana", "orange"] ，要打印出“索引：元素”的形式，常规做法：

 

fruits = ["apple", "banana", "orange"]

index = 0

for fruit in fruits:

    print(f"{index}: {fruit}")

    index += 1

 

 

用  enumerate  函数：

 

fruits = ["apple", "banana", "orange"]

for index, fruit in enumerate(fruits):

    print(f"{index}: {fruit}")

 

 

 enumerate  自动处理了索引的递增，代码更简洁，也避免了手动管理索引变量可能出现的错误，让遍历带索引的场景变得轻松。

 

五、 collections.defaultdict ：便捷处理字典默认值

 

在使用普通字典  dict  时，如果访问不存在的键，会抛出  KeyError  异常。而  collections  模块里的  defaultdict  ，可以指定一个默认工厂函数，当访问不存在的键时，会自动用默认工厂函数生成对应的值。

 

场景示例：统计列表中各元素出现次数（常规字典对比 ）

 

常规字典统计列表  words = ["apple", "banana", "apple"]  中单词出现次数：

 

words = ["apple", "banana", "apple"]

count_dict = {}

for word in words:

    if word in count_dict:

        count_dict[word] += 1

    else:

        count_dict[word] = 1

print(count_dict)  

 

 

用  defaultdict ：

 

from collections import defaultdict

words = ["apple", "banana", "apple"]

count_dict = defaultdict(int) # int 作为默认工厂函数，调用 int() 得到 0

for word in words:

    count_dict[word] += 1

print(dict(count_dict))  

 

 

 defaultdict  帮我们省去了判断键是否存在的步骤，直接对键进行操作即可，在处理一些需要默认值的字典场景时，让代码简洁又高效。

 

六、 functools.lru_cache ：缓存优化递归或重复计算

 

对于一些递归函数或者会重复计算相同参数结果的函数， functools  模块里的  lru_cache  装饰器可以缓存函数的调用结果，当再次以相同参数调用函数时，直接返回缓存的结果，避免重复计算，提升效率，同时也能让代码更简洁（无需手动实现缓存逻辑 ）。

 

场景示例：计算斐波那契数列（递归优化 ）

 

常规递归计算斐波那契数列（存在大量重复计算 ）：

 

def fibonacci(n):

    if n <= 1:

        return n

    return fibonacci(n - 1) + fibonacci(n - 2)

# 计算 fibonacci(30) 时会有很多重复计算

print(fibonacci(30))  

 

 

用  lru_cache  装饰器优化：

 

from functools import lru_cache

 

@lru_cache(maxsize=None) # maxsize=None 表示缓存无限大

def fibonacci(n):

    if n <= 1:

        return n

    return fibonacci(n - 1) + fibonacci(n - 2)

 

print(fibonacci(30))  

 

 

加上  lru_cache  后，函数自动缓存了计算结果，后续相同参数调用直接取缓存，大大提升了递归效率，代码上也只是添加一个装饰器，简洁又实用。

 

七、这些 Python 函数（包括内置函数和部分库函数 ），从数据处理的批量操作、筛选、聚合，到遍历优化、字典便捷处理，再到函数计算优化，覆盖了多种常见编程场景。合理运用它们，能让代码摆脱繁琐的循环、条件判断等冗余结构，变得更加简洁优雅，同时也能提升代码的执行效率和可读性。当然，Python 中还有很多其他好用的函数和特性，大家在日常编程中可以不断探索挖掘，让自己的代码越来越“Pythonic” ，写出更优质的程序。