python五个常用的内置函数

标题中所说的五个内置函数分别是：

1. enumerate
2. zip
3. filter
4. map
5. sorted

不只是常用，还是面试当中常考的知识点，自己记录下

enumerate：枚举
enumerate()函数将可迭代对象组合成一个索引序列，一般用在for循环中。具体如下介绍

如有一个列表 【‘张三’，‘李四’，‘王五’，‘赵柳儿’，…】(为了明显，用的中文格式)
现在需要打印列表中每个人的名字，并且知道他们在列表中的位置，如果不用enumerate函数的话是可以实现的，可以借助第三方变量，代码如下：

names = ['张三', '李四', '王五', '赵六儿']

i=0
for _ in names:
    print(i, names[i])
    i+=1

print('---------------')

for j in range(len(names)):
    print(j, names[j])

print('---------------')

for key, value in enumerate(names):
    print(key, value)

# 打印结果
0 张三
1 李四
2 王五
3 赵六儿
---------------
0 张三
1 李四
2 王五
3 赵六儿
---------------
0 张三
1 李四
2 王五
3 赵六儿

这样的话每次都是从0开始计算的，也就是说第一个人都是0，但是在公司是不可能这样做的，比如开始编号从1250212001开始往下累加，这样就有点费劲了。此时用enumerate函数就可以了

用法：enumerate(sequence[, start=0])

由此可见，enumerate的参数可以是一个，也可以是两个，第二个就是设置开始值
加入还是上边的列表，我想让张三从1250212001开始，既李四就是1250212002，以此类推，代码如下：

names = ['张三', '李四', '王五', '赵六儿']

for key, value in enumerate(names, start=1250212001):
    print(key, value)

# 打印结果
1250212001 张三
1250212002 李四
1250212003 王五
1250212004 赵六儿

zip
zip()函数将可迭代对象作为参数，将对应的元素组合成一个个元组，然后返回由这些元组组成的列表，如果参数不等的话，以短的为主，剩下的截掉
代码如下：

a = [1,2,3,4]
b = ['张三', '里斯', '王五']

print(zip(a, b))
for i in zip(a, b):
    print(i)

# 结果
<zip object at 0x7f855f098648>
(1, '张三')
(2, '里斯')
(3, '王五')

参数可以多个，如下：

a = [1,2,3,4]
b = ['张三', '里斯', '王五', '赵六', '吴大马']
c = ('sdf', 'asdfg', [1,2,3], (1,2,3))
d = {'name': 1, 'age': 22, 'gender': '男', 'bir': '1996', 'qq': 125}

print(zip(a, b, c, d))
for i in zip(a, b, c, d):
    print(i)

# 结果
<zip object at 0x7f0d6b541848>
(1, '张三', 'sdf', 'name')
(2, '里斯', 'asdfg', 'age')
(3, '王五', [1, 2, 3], 'gender')
(4, '赵六', (1, 2, 3), 'bir')

注意：字典只算key值

filter：过滤器
过滤出结果为True的数据
用法：
filter(function, iterable)
function： 函数，用来判断
iterable：可迭代对象，传给function

如现在有列表【1，2，3，4，5，66】
在这个列表中我只想取出奇数，用filter实现，代码如下：

# function
def is_odd(x):
    return x % 2 == 1

# iterable
lst = [1,2,3,4,55,66]

ret = filter(is_odd, lst)
print(ret)

for i in ret:
    print(i)

# 结果
<filter object at 0x7f2b7eb42908>
1
3
55

注意：<filter object at 0x7f2b7eb42908> 这不是一个错，我看网上有些人的博客说是错，这是一个迭代器，不占内存的。直接显示的话可以转换成列表、元组等
如下：

def is_odd(x):
    return x% 2 == 1

ret = list(filter(is_odd, [1,2,3,4,55,66]))  # 强制转换成列表（元组，集合..）即可
print(ret)  # [1, 3, 55]

filter函数的执行过程，for循环可迭代对象，将每个元素都执行指定的函数，如果为False直接过滤掉。并不是直接将可迭代对象一次性的全部传给指定函数。

filter过滤器可用列表表达式实现：

lst = [1,2,3,4,55,66]
ret = [i for i in lst if i%2==1]

map：对序列做映射
用法：map(function, iterable1, iterable2,… )
function：处理函数
iterable：可迭代对象
map()不会对序列的个数有影响，而filter处理后的个数小于等于处理前的个数。

如求列表的元素平方根

def num_power(x):
    return pow(x, 2)

lst = [1,2,3,4,5]

ret = list(map(num_power, lst))
ret1 = list(filter(num_power, lst))
print(ret1)  # [1,2,3,4,5]
print(ret)  # [1, 4, 9, 16, 25]

sorted：排序
和sort一样，sort在元序列上排序，不占内存；sorted生成新的列表，占内存。
用法：
sorted(iterable[,key=function, reverse=False])
iterable：可迭代对象
key：自定义排序的条件
reverse：升序或降序，False（默认）升序

如按长度降序排序

lst = ['    ', [1, 2], 'hello world']  # 四个空格

ret = sorted(lst, key=len, reverse=True)  # func可自定义
print(ret)  # ['hello world', '    ', [1, 2]]