Python内置函数map，enumerate，reduce，filter，zip

这几个内置函数都是python函数式编程的体现啦，可以使你的循环迭代过程变得更加简便快速。还是挺实用的，很Pythonic的说。

map
map(函数，操作对象)，map的两个参数分别是一个函数（可以是自定义的函数，内置函数，或者是lambda表达式），和一个操作对象（序列或可迭代对象）。过程是依次对操作对象里面的元素进行函数的处理。# 可迭代对象就是可以拿去循环的，英文叫iterator

#自定义函数
def add_1(x):
    return x + 1
    
a = range(5)
# map常和 list()一起使用
list(map(add_1,a))
#[1, 2, 3, 4, 5]

#内置函数
string = '12345'
list_ = list(string)
#['1', '2', '3', '4', '5']
list(map(int,list_))
#[1, 2, 3, 4, 5]

#lambda表达式（匿名函数）
b = range(1,8,2) # 1到7的奇数
new_list = list(map(lambda item: item**2, b))
print(new_list)
#[1, 9, 25, 49]

#其他操作

# 输入三个整数用空格隔开
a,b,c = map(int,input().split())
# input进来的是一个字符串，用split方法后生成一个列表，每个元素用int()处理，然后进行解包获得a，b，c的值

# 爬虫多线程
from multiprocessing.dummy import Pool
pool = Pool(4)#四核咯
results = pool.map(函数名，url列表)
pool.close()
pool.join()

enumerate
对可迭代对象进行枚举，enumerate的参数是一个可迭代对象，每次返回一个元组，这个元组长这样：(索引，可迭代对象的元素)。

string = 'abcd'
for item in enumerate(list(string)):
    print(item)
#(0, 'a')返回索引和可迭代对象元素的元组
#(1, 'b')
#(2, 'c')
#(3, 'd')

# 生成一个字典，以string的元素为键，元素对应的下标为值
string = 'abcd'
for value,key in enumerate(list(string)):
    dict_[key] = value
print(dict_)
# {'a': 0, 'b': 1, 'c': 2, 'd': 3}

# 升级一下，等价于
string = 'abcd'
# 字典推导式
dict1 = {key:value for value,key in enumerate(list(string))}
print(dict1)
# {'a': 0, 'b': 1, 'c': 2, 'd': 3}

# 竖着打印一哈键值对
y = zip(dict_.keys(),dict_.values())# 同时迭代连个列表
for key,value in y:# 注意这个操作只能迭代一次，是生成器对象哦
    print(key,value)
#a 0
#b 1
#c 2
#d 3

reduce
要从functools里面导入reduce，此函数有两个参数reduce(函数，可迭代对象)，注意：作为第一个参数的函数必须是由两个参数的函数。结果返回一个值，即可迭代对象的元素从左到右被函数处理后的值

from functools import reduce

# 计算5的阶乘
# 作用过程是：把第一次计算得到的过程作为作用函数的第一个参数，下一个元素作为作用函数的第二个参数
range_ = list(range(1,6))
print(reduce(lambda x,y: x*y, range_))
# 120

# 把序列里面的元素合并成一个字符串
list_ = list(range(1,10))
string = reduce(lambda x,y: x+y,map(str,list_))# 注意map返回的是一个可迭代对象
print(string)
# '123456789'

filter
filter是一个过滤器，filter(单参数函数，可迭代对象)，返回经过函数处理值为True的元素

# 选出大于5的数
list_ = list(range(1,11))
list(filter(lambda x:x>5,list_))
# [6, 7, 8, 9, 10]

# 筛选为奇数的值
list_1 = list(range(14))
list(filter(lambda x:x%2!=0, list_1))
# [1, 3, 5, 7, 9, 11, 13]

# 除去列表里面为None的元素，数据清洗
mylist = [2,None,34,645,None,5,None]
list(filter(lambda index:index is not None, mylist))
# [2, 34, 645, 5]

zip
可以把多个可迭代对象进行压缩，以最小的序列为界限，即只会压缩到最短的序列的结束。返回可迭代的zip对象，即你可以同时循环迭代多个可迭代对象，常常配合序列解包使用，爬虫里面听常用的说。

list_int = list(map(int,range(5)))
list_float = list(map(float,range(5)))
list_str = list(map(str,range(5)))
for item in zip(list_int,list_float,list_str):
	print(item)
#(0, 0.0, '0')返回元组
#(1, 1.0, '1')
#(2, 2.0, '2')
#(3, 3.0, '3')
#(4, 4.0, '4')

for a,b,c in zip(list_int,list_float,list_str):
    print(a,b,c)
#0 0.0 0
#1 1.0 1
#2 2.0 2
#3 3.0 3
#4 4.0 4

待续~