Python 学习笔记（十三）：内置高阶函数

python 内置高阶函数

1. map 函数

使用可迭代对象中的每个元素调用函数，将返回值作为新可迭代对象元素；返回值为新可迭代对象。

• 语法：

re = map(函数， 可迭代对象)

• 实例

>>> list01 = ['a', 'b', 'c', 'd']
>>> re = map(lambda x: x.upper(), list01)
>>> re
<map object at 0x7f05c4378908>
>>> for item in re:
...     print(item, end=" ")
A B C D

2. sorted 函数

排序，返回值为排序结果。与 list.sort() 方法在原地修改不同，sorted 函数会产生新的迭代对象。

• 语法：key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

re = sorted(可迭代对象， key = 函数， reverse = 布尔值)

• 实例

>>> list01 = ['tony', 'peter', 'python', 'deeplearning', 'ironman']
>>> re = sorted(list01, key=len, reverse=True)
>>> re
['deeplearning', 'ironman', 'python', 'peter', 'tony']

3. filter 函数

filter 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

• 语法：接收两个参数，第一个为函数，第二个为可迭代对象，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

re = filter(函数，可迭代对象)

• 实例

>>> list01 = ['tony', 'peter', 'python', 'deeplearning', 'ironman']
>>> re = filter(lambda x: 'p' in x, list01)
>>> for item in re:
...     print(item)
peter
python
deeplearning

4. max 和 min 函数

max 函数：根据函数获取可迭代对象的最大值，返回可迭代对象
min 函数：根据函数获取可迭代对象的最小值，返回可迭代对象

• 语法：

max(可迭代对象，key = 函数)
min(可迭代对象，key = 函数)

• 实例

>>> list01 = ['tony', 'peter', 'python', 'deeplearning', 'ironman']
>>> re01 = max(list01, key=lambda x: len(x))
>>> re01
'deeplearning'
>>> re02 = min(list01, key=lambda x: len(x))
>>> re02
'tony'

5. zip 函数

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

可以使用 list() 转换来输出列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

• 语法：

re = zip(可迭代对象1，可迭代对象2，...)

• 实例

>>> a = (1,2,3)
>>> b = (4,5)
>>> c = (6,7)
>>> re = list(zip(a,b,c))
>>> re
[(1, 4, 6), (2, 5, 7)]

• zip( * ) : 与 zip 相反，zip( * )可理解为解压，返回二维矩阵式

>>> d, e, f = zip(*re)
>>> d, e, f
((1, 2), (4, 5), (6, 7))
>>> list(d)
[1, 2]

6. enumerate 函数

将一个可迭代的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

• 语法：

re = enumerate(可迭代对象, start=0)

• 实例

>>> list01
['tony', 'peter', 'python', 'deeplearning', 'ironman']
>>> re = enumerate(list01)
>>> re
<enumerate object at 0x7fbddefdd240>
>>> list(re)
[(0, 'tony'), (1, 'peter'), (2, 'python'), (3, 'deeplearning'), (4, 'ironman')]
>>> re = enumerate(list01, start=1)
>>> list(re)
[(1, 'tony'), (2, 'peter'), (3, 'python'), (4, 'deeplearning'), (5, 'ironman')]
>>>

7. eval 函数

• 语法：

eval(expression, globals=None, locals=None)

它有三个参数，其中 expression 是一个字符串类型的表达式或代码对象，用于做运算；globals 与 locals 是可选参数，默认值是 None。
具体而言，expression 只能是单个表达式，不支持复杂的代码逻辑，例如赋值操作、循环语句等等。

globals 用于指定运行时的全局命名空间，类型是字典，缺省时使用的是当前模块的内置命名空间。locals 指定运行时的局部命名空间，类型是字典，缺省时使用 globals 的值。两者都缺省时，则遵循 eval 函数执行时的作用域。值得注意的是，这两者不代表真正的命名空间，只在运算时起作用，运算后则销毁。

• 举例：

>>> x = 10
>>> y = 20
>>> a = eval('x+y')
>>> a
30
>>> b = eval('x+y',{'x':1,'y':2})
>>> b
3
>>> c = eval('x+y',{'x':1,'y':2},{'y':3,'z':4})
>>> c
4
>>> x, y
(10, 20)

当指定了命名空间的时候，变量会在对应命名空间中查找。而且，它们的值不会覆盖实际命名空间中的值。

8. exec 函数

exec 执行储存在字符串或文件中的 Python 语句，并且 exec 函数返回值永远为 None，相比于 eval，exec可以执行更复杂的 Python 代码。

• 语法：

exec(object, globals, locals)

• 实例

>>> x = 1
>>> y = exec('x = x + 1')
>>> x
2
>>> y

exec() 内外的命名空间是相通的，变量由此传递出去，而不像 eval() 函数，需要一个变量来接收函数的执行结果。

9. eval 和 exec 的用途和细节

常见用途：将字符串转成相应的对象，例如 string 转成 list ，string 转成 dict，string 转 tuple 等等。

• 实例：

>>> a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
>>> eval(a)
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
>>> a = "{'name': 'peter', 'age': 18}"
>>> eval(a)
{'name': 'peter', 'age': 18}
>>> a = "my_dict = {'name': 'peter', 'age': 18}"
>>> a
"my_dict = {'name': 'peter', 'age': 18}"
>>> exec(a)
>>> my_dict
{'name': 'peter', 'age': 18}

• eval() 函数的返回值是其 expression 的执行结果，在某些情况下，它会是 None
• exec() 函数的返回值只会是 None，与执行语句的结果无关
• 两个函数中的 globals 和 locals 参数，起到的是白名单的作用，通过限定命名空间的范围，防止作用域内的数据被滥用。

10. repr 函数

repr() 函数将对象转化为供解释器读取的形式。

>>> s = 'python'
>>> repr(s)
"'python'"
>>> dict = {'python':101, 'java':102}
>>> repr(dict)
"{'python': 101, 'java': 102}"

• 与 str 函数的区别：
  函数str() 用于将值转化为适于人阅读的形式，另外，当我们把一个字符串传给 str() 函数再打印到终端的时候，输出的字符不带引号。而将一个字符串传给 repr() 函数再打印到终端的时候，输出的字符带有引号。

>>> print(str('123456789'))
123456789
>>> print(repr('123456789'))
'123456789'

但对于不同的数据类型有不同的处理，如数值、列表或字典，两者打印结果相同；对于字符串处理结果不同。

>>> listA = [1,2,3]
>>> str(listA)
'[1, 2, 3]'
>>> repr(listA)
'[1, 2, 3]'