内置函数的使用

在Python语言中提供了若干内置函数，用于实现常用的功能，可以直接使用。

内置函数一览

Python中的内置函数如下表所示。

eval（）函数

使用内置的eval（）函数可以对动态表达式进行求值，其语法形式如下。

eval(expression[, globals[, locals]])

其中，expression 是动态表达式的字符串；globals 和 locals 是求值时使用的上下文环境的全局变量和局部变量，如果不指定，则使用当前运行上下文。例如：

>>> x = 2
>>> str_func = input('请输入表达式：')
请输入表达式：x ** 2 + 2 * x + 1
>>> eval(str_func)				# 对表达式 x ** 2 + 2 * x + 1 求值，输出 9
9
>>>

eval（）函数的功能是将字符串生成语句执行，如果字符串中包含不安全的语句（例如删除文件的语句），则存在注入安全隐患。

map（）函数

在Python 3中，map（）函数实现为内置的map（f，iterable，…）可迭代对象（类似列表），将函数f应用于可迭代对象，返回结果为可迭代对象。

map（）函数示例1：自定义函数is_odd，应用该函数到可迭代对象的每一个元素，返回是否为奇数的可迭代对象结果。

>>> def is_odd(x):
...     return x % 2 == 1
...
>>> list(map(is_odd, range(5)))
[False, True, False, True, False]

map（）函数示例2：使用内置函数abs返回绝对值列表。

>>> list(map(abs, [1, -3, 5, 6, -2, 4]))
[1, 3, 5, 6, 2, 4]
>>>

map（）函数示例3：使用内置函数str返回元素的字符串表示形式。

>>> list(map(str, [1,2,3,4,5]))
['1', '2', '3', '4', '5']
>>>

filter（）函数

在Python 3中，filter（）函数实现为内置的filter（f，iterable）可迭代对象，将函数f应用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素，返回结果为可迭代对象。

filter（）函数示例1：返回奇数的可迭代对象。

>>> def is_odd(x):
...     return x % 2 == 1
...
>>> list(filter(is_odd, range(10)))
[1, 3, 5, 7, 9]
>>>

filter（）函数示例2：返回三位数的回文数（正序和反序相同）可迭代对象。

>>> def is_palindrome(x):
...     s_str = str(x)
...     if s_str == s_str[::-1]:
...         return x
...
>>> list(filter(is_palindrome, range(100, 1000)))
[101, 111, 121, 131, 141, 151, 161, 171, 181, 191, 202, 212, 222, 232, 242, 252, 262, 272, 282, 292, 303, 313, 323, 333, 343, 353, 363, 373, 383, 393, 404, 414, 424, 434, 444, 454, 464, 474, 484, 494, 505, 515, 525, 535, 545, 555, 565, 575, 585, 595, 606, 616, 626, 636, 646, 656, 666, 676, 686, 696, 707, 717, 727, 737, 747, 757, 767, 777, 787, 797, 808, 818, 828, 838, 848, 858, 868, 878, 888, 898, 909, 919, 929, 939, 949, 959, 969, 979, 989, 999]

zip（） 函数

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同

a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]

result = zip(a, b)  # 打包为元组的列表
# 结果：[(1, 4), (2, 5), (3, 6)]

result = zip(a, c)  # 元素个数与最短的列表一致
# 结果：[(1, 4), (2, 5), (3, 6)]

Lambda 匿名函数

在上述例子中，作为参数传递的函数可以为内置函数，也可以为自定义函数。如果函数的形式比较简单且只需要作为参数传递给其他函数，则可使用Lambda表达式直接定义匿名函数。匿名函数广泛用于需要函数对象作为参数、函数比较简单并且只使用一次的场合。例如，filter（f，a）的第一个参数为函数对象，根据函数筛选列表的内容。

Lambda 是一种简便的、在同一行中定义函数的方法。Lambda 实际上生成一个函数对象，即匿名函数。

Lambda 表达式的基本格式如下。

lambda arg1, arg2 ... : <expression>

其中，arg1、arg2 等为函数的参数，＜expression＞为函数的语句，其结果为函数的返回值。例如，语句 lambda x，y：x+y 生成一个函数对象，函数参数为 x, y，返回值为 x+y。

匿名函数示例1

>>> f = lambda x, y: x + y
>>> type(f)
<class 'function'>
>>> f(12, 34)
46
>>>

匿名函数应用示例1：过滤列表，返回元素为奇数的可迭代对象。

>>> list(filter(lambda x: x % 2 == 1, range(10)))
[1, 3, 5, 7, 9]
>>>

匿名函数应用示例2：过滤列表，返回元素非空的可迭代对象。

>>> list(filter(lambda s: s and s.strip(), ['A', '', 'B', None, 'C', '']))
['A', 'B', 'C']
>>>

匿名函数应用示例3：过滤列表，返回元素大于零的可迭代对象。

>>> list(filter(lambda x: x > 0, [1, 0, -2, 8, 5]))
[1, 8, 5]
>>>

sorted（）函数

内置函数sorted（）把一个可迭代对象进行排序，返回结果列表。其语法形式如下。

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

其中，iterable是待排序的可迭代对象；key是比较函数（默认为None，按自然顺序排序）；reverse用于指定是否逆序排序。

>>> sorted([1, 5, 6, 9, 7, 4])
[1, 4, 5, 6, 7, 9]
>>> sorted(['Dog', 'Cat', 'Rabbit'], key=len)  # 按字符长度排序
['Dog', 'Cat', 'Rabbit']
>>> sorted(['Dog', 'Cat', 'Rabbit'], key=str.lower)  # 字符串不区分大小写排序
['Cat', 'Dog', 'Rabbit']
>>> sorted([('Bob', 75), ('Adam', 92), ('Lisa', 88)])  # 默认第 0 个元素排序
[('Adam', 92), ('Bob', 75), ('Lisa', 88)]
>>> sorted([('Bob', 75), ('Adam', 92), ('Lisa', 88)], key=lambda x:x[1])  # 指定第 1 个元素排序
[('Bob', 75), ('Lisa', 88), ('Adam', 92)]
>>>

偏函数

functools.partial() 通过把一个函数的部分参数设置为默认值的方式返回一个新的可调用（callable）的partial对象，其语法形式如下。

functools.partial(func, *args, **kwargs)

其中，func 为函数；args 为其位置参数；kwargs 为关键字参数。

partial() 函数主要用于设置预先已知的参数，从而减少调用时传递参数的个数。

functools.partial() 应用示例：2 的 n 次方。

>>> import functools, math
>>> pow2 = functools.partial(math.pow, 2)
>>> list(map(pow2, range(11)))
[1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0, 256.0, 512.0, 1024.0]
>>>