Python中常用的内建函数

  Python中有许多强大的内建函数，通过这些函数可以很方便的完成一项功能。如果能够熟练的运用能够在编码的时候帮上大忙。当然内建函数不止下面这些，后面会逐渐补充学习。

1. eval(source[, globals[, locals]])

执行一个字符串表达式，并返回执行的结果（可以理解为去掉引号后python代码）：

>>> x = 10
>>> y = 5
>>> eval('x+y')
15
>>> eval('[1,2,3,4]')
[1, 2, 3, 4]
>>> eval('123')
123

2. filter(function or None, sequence) -> list, tuple, or string

filter用来提取系列中满足function函数的元素，
当第一个参数为None是，则判断条件为系列中的每隔元素是否为False（在Python中None, '', 0表示False）
下面是计算10以内的偶数：

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

函数为None时, 只是将0过滤了：

>>> filter(None, range(10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

3. enumerate(iterable[, start]) -> iterator for index, value of iterable

用enumerate返回下面的结构，

(0, seq[0]), (1, seq[1]), (2, seq[2]), ...

因此可以很方便的遍历一个可迭代的对象，并且知道其索引，start为索引的开始值。下面用enumerate方法打印出字符串的每个字母及其索引：

>>> for index, c in enumerate('hello world'):
    print index, c

0 h
1 e
2 l
3 l
4 o
5  
6 w
7 o
8 r
9 l
10 d

start为10：

>>> for index, c in enumerate('hello world', 10):
    print index, c

10 h
11 e
12 l
13 l
14 o
15  
16 w
17 o
18 r
19 l
20 d

4. map(function, sequence[, sequence, ...]) -> list

又一个强大好用的内建函数，下面的function为空时候的例子，但是后面的系列不能为None，否则抛出异常：

>>> map(None, 'hello', (1,2,3), [5,6,7,8])
[('h', 1, 5), ('e', 2, 6), ('l', 3, 7), ('l', None, 8), ('o', None, None)]

  由此可见当后面有多个序列，并且长度不一致时，按照最长的系列来生成元组，其它长度不够的用None补足。实际上第一个参数就是用来处理生成的系列中的元组的，把处理的结果作为元素组成一个列表返回。
  根据上面的例子可以知道第一个参数可以为空，那么对于作为第一个参数的函数有什么要求吗？

>>> map(lambda x:x, (1,2,3),(4,5,6))

Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    map(lambda x:x, (1,2,3),(4,5,6))
TypeError: <lambda>() takes exactly 1 argument (2 given)

当函数只传递一个参数的时候，程序报错了。根据错误信息：提供了两个参数，但实际只有一个，所以对第一个参数要求传入的参数个数必须等于后面系列的个数

>>> map(lambda x,y : x+y, (1,2,3),(4,5,6))
[5, 7, 9]

5. max

max函数有两种形式：
max(iterable[, key=func]) -> value
  第一种是计算一个可迭代对象的最大值，如果需要对每个元素处理后再计算最大值还可以传递一个函数作为比较依据。

• 计算整数列表中的最大值：

>>> max([1,3,6,2,4,9,8,2,7])
9
>>> max('hello world')
'w'

• 包含key的情况：计算年龄最大的用户

>>> users = [{'name':'zhao','age':18},{'name':'qian','age':20},{'name':'sun','age':19}]
>>> max(users, key=lambda item:item['age'])
{'age': 20, 'name': 'qian'}

max(a, b, c, ...[, key=func]) -> value
  第二种是直接传递多个要比较的元素。

• 计算多个数字之间的最大值：

>>> max(1,3,6,2,4,9,8,2,7)
9

• 包含key的情况：计算年龄最大的用户

>>> max({'name':'zhao','age':18},{'name':'qian','age':20},{'name':'sun','age':19}, key=lambda item:item['age'])
{'age': 20, 'name': 'qian'}

6. min

min函数同max一样，只不过是用来计算最小值的。

7. set

set方法用来创建一个不重复的集合

>>> set()
set([])
>>> set('hello world')
set([' ', 'e', 'd', 'h', 'l', 'o', 'r', 'w'])
>>> set((1,3,3,4,5,9,7))
set([1, 3, 4, 5, 7, 9])

8. len(object) -> integer

len()函数用来计算一个序列或者集合对象的元素个数

>>> len('hello world')
11
>>> len((1,2,3))
3
>>> len({'name':'zhao','age':18})
2
>>> len(set('hello world'))
8

9. range

range(stop) -> list of integers
生成从0到stop的一个列表，步长为1：

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

range(start, stop[, step]) -> list of integers
生成列表的时候可以指定步长step，且默认值为1:

>>> range(0,10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(9,-1,-1)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> range(0,10,2)
[0, 2, 4, 6, 8]

10. round(number[, ndigits]) -> floating point number

四舍五入计算，第二个可选参数表示小数点后面的精度。返回的结果跟传入的数据类型无关，都是float类型。

>>> round(1)
1.0
>>> round(1.2574, 2)
1.26

另外，在math模块中有两个方法与round方法类似，但是需要先用import math引入才能使用：

• floor(x)
  取地板计算：返回给定值的整数部分，返回的结果也是float类型。如果参数为整数，则返回结果等同于float(x)

>>> import math
>>> math.floor(1)
1.0
>>> math.floor(1.222)
1.0
>>> math.floor(1.999)
1.0

• ceil(x)
  取天花板计算：返回比给定值大的最小整数，不过这里依然是float类型。当给定值为整数类型时，返回结果等同于float(x)

>>> import math
>>> math.ceil(1)
1.0
>>> math.ceil(1.222)
2.0
>>> math.ceil(1.999)
2.0

11. sum(iterable[, start]) -> value

字面意思：求和运算，如果有传递start，则最后还要加上start；当序列为空（不是None）时就返回start，start默认为0

>>> sum([])
0
>>> sum([],2)
2
>>> sum([1,2,3,4,5])
15
>>> sum([1,2,3,4,5],6)
21

12. sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list

对可迭代得对象进行排序，并返回一个新列表
参数说明：

• iterable: 用来排序得可迭代对象
• cmp：默认为None，用来比较iterable中两个元素得先后顺序（类似于Java中的Comparetor）。且这个函数有两个参数，当大于时返回1，小于时返回-1，等于时返回0
• key：这个参数与max和min函数中的key用法类似，该函数只有一个参数，即迭代对象中的元素
• reverse：False表示升序，True表示降序，默认为升序

下面是对字符串中得字母和列表排序：

>>> sorted('hello world')
[' ', 'd', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
>>> sorted([8,3,5,7,9,0,1,2,4])
[0, 1, 2, 3, 4, 5, 7, 8, 9]
>>> sorted([8,3,5,7,9,0,1,2,4], reverse=True)
[9, 8, 7, 5, 4, 3, 2, 1, 0]

在其它一些复杂使用场景下，实现cmp函数或者key和reverse组合的方式都可以达到排序的目的：

# 测试要用到的数据
>>> persons = [{'name':'zhao','age':18},{'name':'qian','age':20},{'name':'sun','age':19},{'name':'li','age':17}]

• 实现cmp函数来根据age进行排序：

# 升序
>>> sorted(persons, cmp=lambda x,y:x['age']-y['age'])
[{'age': 17, 'name': 'li'}, {'age': 18, 'name': 'zhao'}, {'age': 19, 'name': 'sun'}, {'age': 20, 'name': 'qian'}]
# 降序
>>> sorted(persons, cmp=lambda x,y:y['age']-x['age'])
[{'age': 20, 'name': 'qian'}, {'age': 19, 'name': 'sun'}, {'age': 18, 'name': 'zhao'}, {'age': 17, 'name': 'li'}]

• 用key和reverse来实现排序：

# 升序
>>> sorted(persons, key=lambda x:x['age'])
[{'age': 17, 'name': 'li'}, {'age': 18, 'name': 'zhao'}, {'age': 19, 'name': 'sun'}, {'age': 20, 'name': 'qian'}]
# 降序
>>> sorted(persons, key=lambda x:x['age'], reverse=True)
[{'age': 20, 'name': 'qian'}, {'age': 19, 'name': 'sun'}, {'age': 18, 'name': 'zhao'}, {'age': 17, 'name': 'li'}]