正心全栈编程-文档站

Appearance

Python 内置函数大全 ​

Python 解释器内置了许多函数和类型，列表如下（按字母排序）（省略了几个不常用的）。

翻译总结自官方文档： 原文地址

内建函数表
abs()delattr()hash()memoryview()set()
all()dict()help()min()setattr()
any()dir()hex()next()slice()
ascii()divmod()id()object()sorted()
bin()enumerate()input()oct()staticmethod()
bool()eval()int()open()str()
breakpoint()exec()isinstance()ord()sum()
bytearray()filter()issubclass()pow()super()
bytes()float()iter()print()tuple()
callable()format()len()property()type()
chr()frozenset()list()range()vars()
classmethod()getattr()locals()repr()zip()
compile()globals()map()reversed()__import__()
complex()hasattr()max()round()

命令式编程 VS 函数式编程 ​

首先从大家熟悉的命令式编程开始，我们先回顾下平时在写代码时主要的情景。

其实，不管我们的业务代码有多复杂，都离不开以下几类操作：

  • 函数定义：def

  • 条件控制：if, elif, else

  • 循环控制：for, break, continue, while

当然，这只是部分操作类型，除此之外还应该有类和模块、异常处理等等。我们目前就先只关注上面这三种最常见的操作。

对应地，函数式编程也有自己的关键字。在 Python 语言中，用于函数式编程的主要由 2 个基本函数和 1 个算子，还有一些其他的函数进行辅助计算。

  • 基本函数：map()、filter()

  • 算子(operator)：lambda

令人惊讶的是，仅仅采用这几个函数和算子就基本上可以实现任意 Python 程序。

提示

能实现是一回事儿，实际编码时是否这么写又是另外一回事儿。估计要真只采用这几个基本单元来写所有代码的话，不管是在表达上还是在阅读上应该都挺别扭的。不过，尝试采用这几个基本单元来替代上述的函数定义、条件控制、循环控制等操作，对理解函数式编程如何通过函数和递归表达流程控制应该会很有帮助。

在开始尝试将命令式编程转换为函数式编程之前，我们还是需要先熟悉下这几个基本单元。

常见高级函数 ​

lambda ​

它们在其他语言中也被称为匿名函数。如果你不想在程序中对一个函数使用两次，你也许会想用 lambda表达式，它们和普通的函数完全一样。

python
lambda argument: manipulate(argument)  # -> lambda 参数:操作(参数)

使用普通函数实现两个内容相加

python
>>> def add(x, y): return x + y
>>> add(3, 5)
8

等价于

python
>>> # lambda 一般都是一次性的
>>> add = lambda x, y: x + y
>>> add(3, 5)
8

案例：使用匿名函数对二维列表排序

python
>>> arr = [(1, 2), (4, 1), (9, 10), (13, -3)]
>>> def f(x): return x[1]
...
>>> arr.sort(key=f)
>>> arr
[(13, -3), (4, 1), (1, 2), (9, 10)]

>>> arr = [(1, 2), (4, 1), (9, 10), (13, -3)]
>>> arr.sort(key=lambda x: x[1])
>>> arr
[(13, -3), (4, 1), (1, 2), (9, 10)]

sorted ​

python
sorted(iterable, *, key=None, reverse=False)

从 iterable 中的 item 中返回一个新的排序列表。

有两个可选参数，必须将其指定为关键字参数。

  • key：指定一个带有一个参数的函数，用于从每个列表元素中提取比较键：key=str.lower。默认值是 None（直接比较元素）。
  • reverse：是一个布尔值。如果设置为 True，那么列表元素按照每个比较被颠倒的顺序进行排序。

内置的 sorted() 函数排序是稳定的。如果确保不会更改比较相等的元素的相对顺序，则排序是稳定的 。

案例：根据元素内的第二个参数进行排序

python
>>> arr = [(3, 4), (1, 6), (5, 8), (8, 4)]
>>> def sort_ket(x): return x[1]
...
>>> sorted(arr, key=sort_ket)
[(3, 4), (8, 4), (1, 6), (5, 8)]
>>> sorted(arr, key=lambda x: x[1])
[(3, 4), (8, 4), (1, 6), (5, 8)]

案例：根据元素里面的内容的总和进行排序

python
>>> arr = [(3, 4), (1, 6), (5, 8), (8, 4)]
>>> def sort_ket_2(x):
...     """定义一个函数只用了一次 函数复用"""
...     return x[0] + x[1]
...
>>> sorted(arr, key=sort_ket_2)
[(3, 4), (1, 6), (8, 4), (5, 8)]
>>> sorted(arr, key=lambda x: x[0] + x[1])
[(3, 4), (1, 6), (8, 4), (5, 8)]

map ​

python
map(function, iterable, ...)

返回一个将 function 应用于每个 iterable item 的迭代器，从而产生结果。如果传递额外的 iterable 参数，function 必须采用多个参数并应用于并行所有迭代中的项目。使用多个迭代器时，当最短迭代器耗尽时，迭代器停止。

python
>>> arr = [4, 3, 7, 1, 9]
>>> map_arr = map(str, arr)
>>> map_arr
<map object at 0x000002A73CE13B80>
>>> list(map_arr)
['4', '3', '7', '1', '9']

enumerate ​

python
enumerate(*iterable *, *start = 0 *)

返回一个枚举对象。 iterable 必须是一个序列，一个迭代器或其他支持迭代的对象。由 enumerate() 返回的迭代器的 __next__() 方法返回一个元组，该元组包含一个计数（从 start 开始，默认值为 0）以及遍历迭代获得的值。

python
>>> arr = ['Spring', 'Summer', 'Fall', 'Winter']
>>> for e in enumerate(arr):
...     print(e)
...
(0, 'Spring')
(1, 'Summer')
(2, 'Fall')
(3, 'Winter')

zip ​

python
zip(*iterables)

制作一个迭代器，用于聚合来自每个迭代器的元素。

返回元组的迭代器，其中第 i 个元组包含来自每个参数序列或迭代的第 i 个元素。当最短的输入迭代耗尽时，迭代器停止。使用单个迭代参数，它将返回 1 元组的迭代器。没有参数，它返回一个空的迭代器。

与 * 操作符一起使用 zip() 可用于解压缩列表：

python
>>> x = [1, 2, 3]
>>> x = ['a', 'b', 'c']
>>> y = [1, 2, 3]
>>> zipped = zip(x, y)
>>> list(zipped)
[('a', 1), ('b', 2), ('c', 3)]
>>> list(zip(*zip(x, y)))
[('a', 'b', 'c'), (1, 2, 3)]

filter ​

python
filter(*function, iterable *)

用那些 function 返回 true 的 iterable 元素构造一个迭代器。iterable 可以是序列，支持迭代的容器或迭代器。如果 function 为 None，则假定标识函数为 false，即为 false 的所有元素都被删除。

过滤 0-10 之间的偶数

python
>>> list(filter(lambda x: x%2==0, range(10)))
[0, 2, 4, 6, 8]

案例 ​

python
score = [('9.', '1'), ('8.', '8'),
         ('9.', '0'), ('9.', '0'),
         ('9.', '0'), ('8.', '9'),
         ('9.', '1'), ('9.', '3'),
         ('9.', '3'), ('9.', '2')]
name = ['龙猫', '阿飞正传', '爱·回家', '海洋', '我爱你', '黄金三镖客', '迁徙的鸟', '千与千寻', '海上钢琴师',
        '天堂电影院']

# 把分数合并

# 电影名与分数一一对应

# 筛选 9.0 分以上电影

# 排序 分数从高到低
参考答案
python
# 把分数合并 zip 合并多个列表
print(list(map(lambda x: float(x[0] + x[1]), score)))

# 名字与分数一一对应
print(list(zip(name, map(lambda x: float(x[0] + x[1]), score))))

# 筛选 9.0 分以上电影
print(*filter(lambda x: x[1] >= 9.0, zip(name, map(lambda x: float(x[0] + x[1]), score))))

# 排序 分数从高到低
print(sorted(filter(lambda x: x[1] >= 9.0, zip(name, map(lambda x: float(x[0] + x[1]), score))), key=lambda x: x[1],
             reverse=True))