有哪些让人眼前一亮的函数？

有很多函数可以让人眼前一亮，它们在编程世界里扮演着重要的角色，或者以其优雅、高效、或者强大的能力而著称。以下我将从几个不同的角度，为你详细介绍一些让人眼前一亮的函数，并尽量详细地解释它们为何如此特别：

一、 函数式编程的利器：让代码更简洁、更具表达力

函数式编程是一种编程范式，强调将计算视为数学函数的求值，避免使用共享状态和可变数据。在函数式编程中，函数本身就是一等公民，可以作为参数传递、作为返回值返回，甚至可以被组合。这类函数往往能让代码更简洁、更具表达力，也更容易理解和测试。

1. `map()` 转换的魔法师

是什么？ `map()` 函数接收一个函数和一个可迭代对象（如列表、元组、字符串），然后将该函数应用于可迭代对象中的每一个元素，并返回一个包含所有应用结果的新可迭代对象。
为什么眼前一亮？
简洁高效的批量操作： 想象一下，你需要将一个列表中所有的数字都乘以2。如果没有 `map()`，你可能需要写一个循环：
```python
numbers = [1, 2, 3, 4, 5]
doubled_numbers = []
for num in numbers:
doubled_numbers.append(num 2)
print(doubled_numbers) [2, 4, 6, 8, 10]
```
使用 `map()`，可以瞬间化繁为简：
```python
numbers = [1, 2, 3, 4, 5]
doubled_numbers = list(map(lambda x: x 2, numbers)) 或者 map(lambda x: x 2, numbers) 如果不需要立刻转成list
print(doubled_numbers) [2, 4, 6, 8, 10]
```
`lambda x: x 2` 是一个匿名函数，它接收一个参数 `x` 并返回 `x` 乘以2。`map()` 就像一位魔法师，将这个魔法应用到列表的每个元素上。
数据转换的通用工具： `map()` 不仅仅局限于数学运算，它可以用于任何类型的转换。例如，将一个字符串列表中的所有字符串转换为大写：
```python
words = ["hello", "world", "python"]
uppercase_words = list(map(str.upper, words)) str.upper 是一个内置方法
print(uppercase_words) ['HELLO', 'WORLD', 'PYTHON']
```
延迟计算的潜力 (惰性求值): 在 Python 中，`map()` 返回的是一个迭代器（在 Python 3 中）。这意味着它不会立即计算所有结果，而是在需要时才逐个生成。这在处理大型数据集时可以节省大量内存。只有当你将它转换为列表（如 `list(map(...))`）或在其上进行迭代时，计算才会发生。
可以类比： 想象你有一个大箱子装着各种形状的积木，你想把所有积木都涂成红色。`map()` 函数就像一个喷漆机器人，它会给箱子里的每一块积木都喷上红漆，然后把这些喷好红漆的积木放进一个新的箱子里。

2. `filter()` 精选的筛子

是什么？ `filter()` 函数也接收一个函数和一个可迭代对象。但它返回的是一个新可迭代对象，其中只包含那些使函数返回 `True`（或真值）的元素。
为什么眼前一亮？
数据过滤的艺术： 假设你想从一个数字列表中找出所有偶数。
```python
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers) [2, 4, 6, 8, 10]
```
`filter()` 就像一个精明的守门员，只有那些符合条件的（偶数）才能通过，不符合条件的则被拦在外面。
条件筛选的强大： 可以用来过滤掉不符合特定条件的数据，保持数据的纯净。例如，从一个包含空字符串的列表中移除空字符串：
```python
data = ["apple", "", "banana", "orange", "", "grape"]
filtered_data = list(filter(None, data)) None 作为函数会过滤掉所有假值（如空字符串、0、False）
print(filtered_data) ['apple', 'banana', 'orange', 'grape']
```
配合 `map()` 实现更复杂的逻辑： 你可以先用 `filter()` 筛选出需要的数据，再用 `map()` 对筛选出的数据进行处理，实现更精细的数据操作。
可以类比： 想象你有一篮子水果，你只想挑出红色的苹果。`filter()` 函数就像一个美食家，它会仔细检查篮子里的每一个水果，只把那些红色的苹果挑出来放在另一个篮子里。

3. `reduce()` 聚合的灵魂

是什么？ `reduce()` 函数（在 Python 3 中需要从 `functools` 模块导入）接收一个函数（通常称为累加器函数）和一个可迭代对象。它会将累加器函数应用于序列的元素，从左到右，从而将序列“减少”为一个单一的值。累加器函数接收两个参数：到目前为止的累加结果，以及序列中的下一个元素。
为什么眼前一亮？
将复杂运算归于简单： 它的核心思想是将一个序列的所有元素通过一个操作连接起来。最经典的例子是计算列表中所有数字的总和：
```python
from functools import reduce

numbers = [1, 2, 3, 4, 5]
total_sum = reduce(lambda x, y: x + y, numbers)
print(total_sum) 15
```
`lambda x, y: x + y` 就是累加器函数。第一次调用时，它接收 1 和 2，返回 3。第二次调用时，它接收上一次的结果 3 和下一个元素 3，返回 6。以此类推，直到序列结束。
实现更广泛的聚合： `reduce()` 不仅仅是求和。你可以用它来实现乘积、找到最大/最小值、连接字符串，甚至实现更复杂的自定义聚合逻辑。
```python
计算乘积
product = reduce(lambda x, y: x y, numbers) 120

找到最大值
max_value = reduce(lambda x, y: x if x > y else y, numbers) 5

连接字符串
words = ["hello", " ", "world", "!"]
sentence = reduce(lambda x, y: x + y, words) "hello world!"
```
函数组合的基石： `reduce()` 是函数式编程中非常重要的一个概念，它能够将多个操作串联起来，实现复杂的计算流程。
可以类比： 想象你要把一串散落的零件组装成一个完整的机器。`reduce()` 函数就像一个熟练的工人，他会拿起第一个零件，然后拿起第二个零件和第一个零件组合，再拿起第三个零件和已经组合好的部分组合，直到所有的零件都被组装起来形成最终的机器。

4. 列表推导式 / 生成器表达式 (List Comprehensions / Generator Expressions) 简洁的语言

是什么？ 列表推导式和生成器表达式是 Python 中一种非常简洁的语法糖，它们允许你通过一个表达式来创建列表或生成器。它们的语法形式通常是 `[expression for item in iterable if condition]`。
为什么眼前一亮？
替代 `map()` 和 `filter()` 的更 Pythonic 方式： 很多时候，列表推导式可以替代 `map()` 和 `filter()` 的组合，而且更易读。
```python
使用列表推导式实现上面 map 的例子
numbers = [1, 2, 3, 4, 5]
doubled_numbers = [x 2 for x in numbers]
print(doubled_numbers) [2, 4, 6, 8, 10]

使用列表推导式实现上面 filter 的例子
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = [x for x in numbers if x % 2 == 0]
print(even_numbers) [2, 4, 6, 8, 10]

结合 map 和 filter 的效果
words = ["apple", "", "banana", "orange", "", "grape"]
filtered_words = [word.upper() for word in words if word] 同时过滤空字符串并转大写
print(filtered_words) ['APPLE', 'BANANA', 'ORANGE', 'GRAPE']
```
强大的表达能力： 它们可以非常直观地表达复杂的过滤和转换逻辑，甚至可以嵌套使用。
```python
嵌套推导式：生成一个3x3的矩阵
matrix = [[j for j in range(3)] for i in range(3)]
print(matrix) [[0, 1, 2], [0, 1, 2], [0, 1, 2]]

矩阵转置
matrix = [[1, 2, 3], [4, 5, 6]]
transposed_matrix = [[row[i] for row in matrix] for i in range(len(matrix[0]))]
print(transposed_matrix) [[1, 4], [2, 5], [3, 6]]
```
生成器表达式的内存效率： 使用圆括号 `()` 而不是方括号 `[]` 创建的是生成器表达式，它们同样是惰性求值的，非常适合处理大型数据集，避免一次性加载所有数据到内存中。
可以类比： 列表推导式就像一个精心设计的菜单，你只需要写下你想要的菜式（表达式）和食材来源（迭代器），以及一些特殊要求（条件），厨师就能立即为你制作出美味的菜肴（列表）。

二、 方便快捷的工具函数：解决常见痛点

有些函数虽然不属于特定的编程范式，但它们以其独特的便利性和解决常见编程痛点的能力而让人眼前一亮。

5. `zip()` 数据的巧妙组合

是什么？ `zip()` 函数接收多个可迭代对象作为参数，并返回一个迭代器，该迭代器生成元组，每个元组包含来自每个可迭代对象的对应元素。当最短的可迭代对象耗尽时，`zip()` 就会停止。
为什么眼前一亮？
并行迭代的利器： 当你需要同时处理来自多个列表或可迭代对象的元素时，`zip()` 是一个绝佳的选择。
```python
names = ["Alice", "Bob", "Charlie"]
ages = [30, 25, 35]
cities = ["New York", "London", "Paris"]

for name, age, city in zip(names, ages, cities):
print(f"{name} is {age} years old and lives in {city}.")
输出:
Alice is 30 years old and lives in New York.
Bob is 25 years old and lives in London.
Charlie is 35 years old and lives in Paris.
```
这比使用索引手动控制多个循环要简洁得多。
数据结构转换： `zip()` 也可以用来将字典的键值对解压出来，或者将多个列表转换为字典：
```python
将两个列表合并成一个字典
keys = ['a', 'b', 'c']
values = [1, 2, 3]
my_dict = dict(zip(keys, values))
print(my_dict) {'a': 1, 'b': 2, 'c': 3}

解压字典的键值对
my_dict = {'x': 10, 'y': 20}
unzipped_keys, unzipped_values = zip(my_dict.items()) 使用 解包
print(unzipped_keys) ('x', 'y')
print(unzipped_values) (10, 20)
```
处理不同长度的可迭代对象： `zip()` 会在最短的序列结束时停止，这在某些情况下非常有用。如果需要让所有序列都参与，可以使用 `itertools.zip_longest()`。
可以类比： 想象你手里有几张卡片，每张卡片上写着一个名字、一个年龄、一个城市。`zip()` 函数就像一个组合器，它会把所有名字卡片上的名字、年龄卡片上的年龄、城市卡片上的城市，按照顺序一一对应地组合起来，给你一叠新的信息组合卡。

6. `enumerate()` 索引与元素的完美结合

是什么？ `enumerate()` 函数接收一个可迭代对象，并返回一个迭代器，该迭代器生成一个包含两个元素的元组：当前元素的索引和元素本身。
为什么眼前一亮？
避免手动维护索引： 在需要同时获取元素和其索引时，`enumerate()` 可以省去手动创建计数器变量的麻烦。
```python
fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits):
print(f"Index: {index}, Fruit: {fruit}")
输出:
Index: 0, Fruit: apple
Index: 1, Fruit: banana
Index: 2, Fruit: cherry
```
如果没有 `enumerate()`，你可能需要这样写：
```python
fruits = ["apple", "banana", "cherry"]
index = 0
for fruit in fruits:
print(f"Index: {index}, Fruit: {fruit}")
index += 1
```
灵活的起始索引： `enumerate()` 还可以接受一个 `start` 参数，指定起始索引的值。
```python
fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits, start=1): 从 1 开始计数
print(f"Item No: {index}, Fruit: {fruit}")
输出:
Item No: 1, Fruit: apple
Item No: 2, Fruit: banana
Item No: 3, Fruit: cherry
```
与列表推导式结合： `enumerate()` 也可以很好地与列表推导式结合使用，创建带有索引的列表。
```python
fruits = ["apple", "banana", "cherry"]
indexed_fruits = [(index, fruit) for index, fruit in enumerate(fruits)]
print(indexed_fruits) [(0, 'apple'), (1, 'banana'), (2, 'cherry')]
```
可以类比： 想象你在给一排学生编号。`enumerate()` 函数就像一个班主任，它不仅知道每个学生的姓名，还知道他们在队伍中的位置（索引），并且可以从任何一个数字开始编号。

7. `itertools` 模块中的函数 组合与优化的瑞士军刀

`itertools` 是 Python 标准库中一个非常强大的模块，它提供了许多用于迭代的工具函数，这些函数通常是 C 语言实现的，效率极高，并且可以创建各种有趣的迭代模式。其中一些函数可以让你眼前一亮。

`itertools.count(start=0, step=1)` 无限序列生成器
是什么？ 创建一个从 `start` 开始，以 `step` 为步长的无限递增的数字序列。
为什么眼前一亮？ 它的“无限”特性非常吸引人。虽然在实际编程中我们通常不会处理真正的无限序列，但它可以与其他函数结合，创造出非常强大的模式。例如，与 `zip()` 结合，可以为一个无限的序列加上索引，而不需要担心序列长度。
```python
import itertools

counter = itertools.count(start=10, step=2)
print(next(counter)) 10
print(next(counter)) 12
print(next(counter)) 14

names = ["A", "B", "C"]
for index, name in zip(itertools.count(1), names): 类似 enumerate(names, start=1) 但更通用
print(f"{index}. {name}")
```

`itertools.cycle(iterable)` 循环播放器
什么是？ 创建一个迭代器，它会不断地循环播放 `iterable` 中的元素。
为什么眼前一亮？ 当你需要重复使用一组数据时非常有用，例如轮流给不同的任务分配资源。
```python
import itertools

colors = itertools.cycle(['red', 'green', 'blue'])
print(next(colors)) red
print(next(colors)) green
print(next(colors)) blue
print(next(colors)) red (循环了)
```

`itertools.chain(iterables)` 连接多条流水线
是什么？ 将多个可迭代对象串联起来，形成一个新的单一迭代器。
为什么眼前一亮？ 它允许你像处理一个长序列一样处理多个序列，而无需显式地将它们合并成一个大的列表，节省内存。
```python
import itertools

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
list3 = [True, False]

chained_iterator = itertools.chain(list1, list2, list3)
for item in chained_iterator:
print(item)
输出: 1, 2, 3, 'a', 'b', 'c', True, False
```

`itertools.islice(iterable, start, stop[, step])` 切片进阶
是什么？ 类似于列表的切片操作，但它作用于可迭代对象，并且是惰性求值的。
为什么眼前一亮？ 它可以让你在处理大型或无限迭代器时，只获取其中的一部分元素，而不需要一次性加载所有数据。
```python
import itertools

counter = itertools.count(1)
first_five_even = itertools.islice(filter(lambda x: x % 2 == 0, counter), 5)
print(list(first_five_even)) [2, 4, 6, 8, 10]
```

三、 优雅的元编程和装饰器：提升代码的复用性和可读性

8. 装饰器 (Decorators) 代码的“包装”艺术

是什么？ 装饰器是一种特殊的函数，它可以接收另一个函数作为参数，并返回一个新的函数，这个新函数在执行原函数的功能基础上，添加了一些额外的行为（如日志记录、性能统计、访问控制等）。它的语法通常是通过 `@decorator_name` 来应用。
为什么眼前一亮？
代码的 DRY (Don't Repeat Yourself) 原则： 装饰器让你能够将通用的功能从具体的函数中抽离出来，放在一个单独的装饰器函数中，然后应用到多个函数上。这极大地提高了代码的可复用性和可维护性。
关注点分离： 它们可以帮助你分离代码的不同关注点。例如，可以将验证逻辑、日志记录逻辑与业务逻辑分开。
强大的扩展性： 装饰器可以用来实现许多高级功能，如路由注册（在Web框架中）、缓存、定时器等。
类装饰器和函数装饰器： 装饰器本身也可以是类，这提供了更灵活的实现方式。

一个简单的日志装饰器示例：
```python
import functools

def log_calls(func):
@functools.wraps(func) 保持原函数的元信息，如名称和文档字符串
def wrapper(args, kwargs):
print(f"Calling function: {func.__name__} with args: {args}, kwargs: {kwargs}")
result = func(args, kwargs)
print(f"Function {func.__name__} returned: {result}")
return result
return wrapper

@log_calls
def add(a, b):
"""This function adds two numbers."""
return a + b

add(5, 3)
输出:
Calling function: add with args: (5, 3), kwargs: {}
Function add returned: 8
```
可以类比： 装饰器就像给一个演员穿上戏服。戏服本身并不改变演员的演技，但它可以改变演员的形象，让他在舞台上更符合某个角色。你可以为一个函数加上不同的“戏服”（装饰器），让它拥有额外的行为，而无需修改函数本身的“演技”（核心逻辑）。

9. `functools.partial` 函数参数的“预填充”

是什么？ `functools.partial` 允许你“固定”一个函数的部分参数，生成一个新的“部分应用”的函数，这个新函数只需要提供剩余的参数就可以调用。
为什么眼前一亮？
创建特定功能的函数： 它非常适合创建具有特定预设参数的函数，从而提高代码的可读性和简洁性。
简化回调函数： 在需要传递函数作为回调时，如果原始函数有很多参数，使用 `partial` 可以创建一个只接受必需参数的回调函数。
实现Currying（柯里化）的类似效果： 虽然不是严格的柯里化，但 `partial` 提供了类似的功能，将多参数函数转换为一系列单参数函数。

示例：
```python
import functools

def multiply(x, y):
return x y

创建一个将第一个参数固定为2的新函数
double = functools.partial(multiply, 2)

print(double(5)) 实际上调用了 multiply(2, 5) > 10
print(double(10)) 实际上调用了 multiply(2, 10) > 20

创建一个将第二个参数固定为3的新函数
times_three = functools.partial(multiply, y=3) 注意：需要指定参数名来固定非首个参数

print(times_three(5)) 实际上调用了 multiply(5, 3) > 15
print(times_three(10)) 实际上调用了 multiply(10, 3) > 30
```
可以类比： 想象你有一个可以调节音量、亮度、对比度的电视遥控器。`functools.partial` 就像你可以预设好某些按钮的初始值。比如，你可以把音量按钮预设为 50，然后把这个“预设好音量”的遥控器交给别人使用，他只需要再按一下“播放”按钮，就能以 50 的音量开始播放节目。

总结

以上介绍的函数，从函数式编程的强大工具（`map`, `filter`, `reduce`），到 Pythonic 的简洁语法（列表推导式），再到实用的工具（`zip`, `enumerate`），以及高效的库 (`itertools`) 和优雅的代码组织方式（装饰器, `partial`），它们都以不同的方式让编写代码变得更轻松、更高效、更有趣。

识别和掌握这些函数，能够显著提升你的编程能力，让你写出更优雅、更强大、更易于维护的代码。当你遇到一个需要批量处理、条件筛选、数据组合或代码复用的场景时，不妨想想这些“眼前一亮”的函数，它们很可能就是解决问题的最佳方案。

当然是Windows系统提供的SetMonitorBrightness这个函数了！

这个函数可以设置电脑屏幕的亮度，如果设置成100%，你就会感到眼前一亮

参考资料：https://msdn.microsoft.com/en-us/library/windows/desktop/dd692972(v=vs.85).aspx

可能很多人都知道这个...

看上去没什么特别的，但是让我们把它的图像画出来：

？？？？？？？？？？？？？？

调调参数就能变成你喜欢的大小和形状。

果然还是平一点好（逃

------------------------------------------------

评论区说要有动图。。。这样是不是不太好

-----------------------------------------------------

评论有人说答主签名应景，rara明明是两个左矢，你们想到哪里去了← ←

-----------------------------------------------------

评论区有人说这个不是函数，其实是的，只不过plot的时候把横纵坐标换了一下而已，我发的图纵坐标是x，横坐标是y。

扯个本专业的函数——一类效用函数。

在宏观经济学当中，有一系列数据和（传统的）理论推导相悖的地方，被称为Puzzle，比如Equity Premium Puzzle，Risk-free Rate Puzzle等等。其中有一部分Puzzle其实是相互关联的，比如上面提到的这两个Puzzle，有观点认为，它们本质上的原因都是，我们通常所采用的CES utility function当中只有一个参数α，同时决定了风险厌恶水平（Risk Aversion）和跨期替代率（Inter-temporal Rate of Substitution），这使得消费（从Equity Premium的角度来说）被过分Smooth了。

于是我们就有了Epstein-Zin utility function，它是这样的：

如果取

这时候我们就有两个参数ρ和α了，ρ表示跨期替代率，α表示风险厌恶水平，问题就简单粗暴（但又不失优雅）地解决了。