Python中的高阶函数

Map、Reduce主要应用于分布式中。

分布式思想：将一个连续的字符串转为列表，元素类型为字符串类型，将其都变成数字类型，使用分布式思想【类似于一件事一个人干起来慢，但是如果人多呢？效率则可以相应的提高】
同理，一台电脑处理数据比较慢，但是如果有100台电脑同时处理，则效率则会快很多，最终将每台电脑上处理的数据进行整合。

python的优点：内置了map()和reduce()函数，可以直接使用。

# python内置了map()和reduce()函数
'''
def myMap(func,li):
	resList = []
	for paser in li:
		res = func(paser)
		resList.append(res)
'''       

map()函数

功能：将传入的函数依次作用在序列中的每一个元素，并把结果作为新的Iterator返回
语法：
map(func, lsd)

注意：参数1是函数，参数2是序列
func:有且只有一个参数.并且要将结果返回

#一、map()
#原型 map(func, lsd)
#将单个字符转成对应的字面量整数
def chrToint(chr):
    return {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}[chr]

list1 = ["2","1","4","5"]
res = map(chrToint, list1)
#[chr2int("2"),chr2int("1"),chr2int("4"),chr2int("5")]
print(res)
print(list(res))
# res的输出结果，是一个可迭代对象 <map object at 0x00000262E8F55588>
# 将可迭代对象转化为列表，输出的是 [2, 1, 4, 5]

#将整数元素的序列，转为字符串型
#[1，2，3，4] --》[“1”，“2”，“3”，“4”]
l = map(str,[1,2,3,4])
print(list(l))

练习：使用map函数，求列表中数的平方

listn = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(map(lambda x:x*x,listn)))

reduce()函数

reduce()函数被封装到functools模块中
需要在functools模块中导入

from functools import reduce

功能：一个函数作用在序列上，这个函数必须接受两个参数，reduce把结果继续和序列的下一个元素累计运算

语法：reduce(func，lsd)
参数1为函数，参数2为列表

reduce(f，[1，2，3，4])等价于f(f(f(1，2)，3)，4)，类似于递归

import functools
#需求，求一个序列的和
list2 = [1, 2, 3, 4]
def mySum(x,y)
	return x+y
r = functools.reduce(mySum,list2)
print("r=",r)
# 输出的结果为1+2+3+4的和

练习，将字符串转成对应字面量数字

#将字符串转成对应字面量数字
def strToint(str1)
	def fc(x, y):
        return x*10 + y
    def fs(chr):
   		return {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}[chr]
    return reduce(fc,map(fs,list(str1)))
a = strToint("12345")
print(a)
print(type(a))

#模拟map()函数
def myMap(func,li):
    resList = []
    for n in li:
        res = func(n)
        resList.append(res)

练习：使用reduce()函数用一行代码输出1+1000

print(reduce(lambda x,y:x+y,range(1,1000)))

filter()函数

作用：把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留该元素还是丢弃该元素【通过一定的条件过滤列表中的元素】

'''
语法：
filter(func,lsd)
参数一：函数名
参数二：序列
功能：用于过滤序列
简单理解：把传入的函数依次作用于序列红的每一个元素，根据返回的True还是False，决定是否保留该元素。
'''
#需求：将列表中的偶数筛选出来。
list1 = [1,2,3,4,5,6,7,8]
#筛选条件
def func(num):
    #保留偶数元素
    if num%2 == 0:
        return True
    #剔除奇数元素
    return False
l = filter(func,list1)
print(l)
print(list1)

注意：使用filter()这个高阶函数，关键在正确实现一个“筛选”函数，filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter完成计算结果，需要使用list()函数获取所有的结果并且返回list.

练习

需求；将爱好为“无”的数据剔除掉

data= [[“姓名”,“年龄”,“爱好”],[“tom”, 25, “无”],[“hanmeimei”, 26, “金钱”]]

def func3(obj):
    if obj[-1] == "无":
        return False
    else:
        return True

# print(list(filter(func3,data)))

print(list(filter(lambda x: False if x[-1]=="无" else True,data)))

sorted() 函数

作用：实现对列表的排序。

语法： sorted(iterable,key,reverse)
参数一:参于排序的序列
参数二:用于比较的关键字或函数
参数三:排序的规则,默认升序

iterable：是可迭代类型;
cmp：用于比较的函数，比较什么由key决定;
key：用列表元素的某个属性或函数进行作为关键字，有默认值，迭代集合中的一项;
reverse：排序规则. reverse = True 降序 或者 reverse = False 升序，有默认值。
返回值：是一个经过排序的可迭代类型，与iterable一样。

#排序
#第一类：冒泡 选择
#第二类：快速，插入，计数器
#注意：如果数据量小的情况下，上述两类用法的效率基本相同，但是，如果数据量大的情况下，第一类的效率很低

#1.普通排序
list1 = [4,3,5,6,1]
#默认为升序排序
list2 = sorted(list1)
print(list2)

#2.按绝对值大小排序
list3 = [4，-3，5，2，-9]
#key接受函数来实现自定义排序规则
#abs表示通过绝对值进行排序
list4 = sorted(list3, key=abs)
#利用map可以实现取绝对值之后的排序
list5 = sorted(map(abs,list3))
print(list3)
print(list4)
print(list5)

#3.降序排序
list5 = [2,1,4,5,6,7]
#通过设置reverse=True来表示反转
list6 = sorted(list5,reverse=True)
print(list5)
print(list6)

list7 = ['a','b','c','d']
list8 = sorted(list7)
print(list7)
#同样也可以实现升序排列，结果为abcd，排序依据为ASCII值
print(list8)

#自定义函数：按照字符串的长短来进行排序
def myLen(str1)：
	return len(str1)
list7 = ['sddd','dded','et54y5','6576986oy']
#使用自定义函数，进行排序，key=函数名
list8 = sorted(list7, key = myLen)
print(list7)
print(list8)

练习：按照年龄的升序排序

data = [{"name":"lili","age":18},{"name":"xiaoming","age":20},{"name":"xiaohong","age":19}]

print(sorted(data2,key=lambda x:x.get("age")))

zip()函数

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

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

利用 * 号操作符，与zip相反，进行解压，以元组的形式返回(二维的).

zip() 函数语法：

zip(iterable1,iterable2, ...)

参数说明：

• iterable – 一个或多个可迭代对象（字符串、列表、元祖、字典）

返回值：

• Python2中直接返回一个由元组组成的列表，Python3中返回的是一个对象，如果想要得到列表，可以用 list() 函数进行转换。

>>> a = [1,2,3] #此处可迭代对象为列表
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)
>>> zipped
<zip object at 0x02B01B48> #返回的是一个对象
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)] #使用list()函数转换为列表
>>> list(zip(a,c))
[(1, 4), (2, 5), (3, 6)]
>>> zipped = zip(a,b)
>>> list(zip(*zipped)) #解压也使用list进行转换
[(1, 2, 3), (4, 5, 6)]