Python学习（七）——匿名函数、map函数、filter函数、reduce函数与其他内置函数

匿名函数

 lambda x: x + 1
 # lambda:定义匿名函数的关键字
 # x：形参
 # x+1：程序处理逻辑
 fun = lambda x: x + 1
 print(fun(5))
 #6                       

 fun = lambda name: name + "_new"
 print(fun("Cindy"))
 #Cindy_new                      

注意：

1、匿名函数一般不会单独使用，而是与其他函数配合使用

2、匿名函数的程序处理逻辑简单，不可以使用多行

 fun = lambda x, y, z: (x + 1, y + 1, z + 1)
 print(fun(1, 3, 5))
 # (2, 4, 6)                                   

函数式编程

编程的方法论：

1、面向过程：找到解决问题的入口，按照一个固定的流程去模拟解决问题的流程

2、函数式编程：编程语言定义的函数+数学意义的函数，即用编程语言去实现数学函数，返回值是函数，没有for和while循环，所有循环使用递归实现。

　　特点：a.不可变数据：不用变量保存状态，不修改变量 b.第一类对象：函数即“变量” c.尾调用优化（尾递归）：在函数的最后一步（不一定是最后一行）进行递归

 def test1(x):
     return x
 def test2(y):
     return test1(y) + 1      #不是尾递归
 # 拆解：res = test1(y)
 #      return res + 1                    

3、面向对象

高阶函数

满足下列任一要求即为高阶函数：

1、函数的传入参数是一个函数名

2、函数的返回值是一个函数名

map函数

 def plus_one(x):
     return x + 1
 def minis_one(x):
     return x - 1
 def square(x):
     return x**2
 def map_test(func,num) :
     nl = []
     for i in num:
         nl.append(func(i))
     return nl

 num = [1,2,3,4,5]
 nl = map_test(square,num)
 print(nl)
 # [1, 4, 9, 16, 25]
 nl1 = map_test(plus_one,num)
 print(nl1)
 # [2, 3, 4, 5, 6]

也可以写成

 plus_one = lambda x: x + 1
 minis_one = lambda x: x - 1
 square = lambda x: x**2
 def map_test(func,num) :
     nl = []
     for i in num:
         nl.append(func(i))
     return nl              

 num = [1,2,3,4,5]
 nl = map_test(square,num)
 print(nl)
 # [1, 4, 9, 16, 25]
 nl1 = map_test(plus_one,num
 print(nl1)
 # [2, 3, 4, 5, 6]          

最好的写法：

 def map_test(func,num) :
     nl = []
     for i in num:
         nl.append(func(i))
     return nl                       

 num = [1,2,3,4,5]
 nl = map_test(lambda x: x + 1,num)
 print(nl)
 # [2, 3, 4, 5, 6]                   

map函数

功能：依次处理序列中的每个元素，得到的结果是一个“列表”，该“列表”元素个数及位置与原来一样

注意：得到的结果并不是真正的列表

 num = [1, 2, 3, 4, 5]
 res = map(lambda x: x + 1, num)
 print(res)
 #<map object at 0x000002205AF765C0>
 print(list(res))
 # [2, 3, 4, 5, 6]

map的第一个参数是处理逻辑，第二个参数是可迭代对象，得到的结果是一个可迭代对象

 str = "hello"
 res = map(lambda x: x.upper(), str)
 print(list(res))
 #['H', 'E', 'L', 'L', 'O']
 print(res)
 # <map object at 0x000002672E8282E8>

filter函数

功能：遍历序列中的每个元素，判断每个元素得到布尔值，True的元素保留下来，否则过滤掉

filter的第一个参数是处理逻辑，第二个参数是可迭代对象，得到的结果是一个可迭代对象

前一个参数得到的结果是布尔值，是True则保留，是False则过滤掉，可以在处理逻辑处＋not来反过滤

 array = ["Allen", "Leo", "jennifer"]
 res = filter(lambda x: x.istitle(), array)
 print(res)
 # <filter object at 0x00000291B3981470>
 print("英文人名有：",list(res))
 # 英文人名有： ['Allen', 'Leo']

也可以处理其他的

 people = [
     {"name":"A","age":9000},
     {"name":"B","age":900},
     {"name":"C","age":18},
     {"name":"D","age":50}
 ]
 res = filter(lambda x: x["age"] < 100, people)
 print(list(res))
 # [{'name': 'C', 'age': 18}, {'name': 'D', 'age': 50}]

reduce函数

功能：把所有数据合并

 num = [1,2,3,100]
 def reduce_test(func,num):
     res = 1
     for i in num:
         res = func(i,res)
     return res
 res = reduce_test(lambda x,y: x * y, num)
 print(res)
 #

指定一个倍数

 num = [1,2,3,100]
 def reduce_test(func,num,initial = None):
     if initial == None:
         res = 1
     else:
         res = initial

         for i in num:
             res = func(i,res)
         return res
 res = reduce_test(lambda x,y: x * y, num, 10)
 print(res)
 #

reduce函数

 from functools import reduce

 num = [1, 2, 3, 100]
 res = reduce(lambda x, y: x * y, num, 10)
 print(res)
 #

注意：map和reduce适合共同在大数据中使用

内置函数

abs() 绝对值

all() 判断内部所有元素的布尔值为Ture则Ture，否则假

注意：如果可迭代对象是空的返回True

any() 判断内部元素的布尔值有一个为Ture则Ture，否则假

bin() 十进制转成二进制

hex() 十进制转十六进制

oct() 十进制转八进制

bool() 求布尔值

注意：None，空，0的布尔值为False

bytes(）转换成字节，需要指定编码

 name = "你好"
 print(bytes(name,encoding = "utf-8"))
 # b'\xe4\xbd\xa0\xe5\xa5\xbd'

.decode() 按指定编码方式解码

 print(bytes(name,encoding = "utf-8").decode("utf-8"))
 # 你好

dir() 打印某一对象的方法，但不解释

help() 打印方法且详细解释

divmod(a,b) a除b的商并取余

 a = divmod(10,3)
 print(a)
 #(3, 1)

eval() 把字符串中的数据结构提取出来、把字符串中的数学运算计算出来

hash() 得出固定值，不能根据得到结果反推原数据，只要数据不变则得到结果不变

hashable即不可变数据类型，unhashable即可变数据类型

 name = "aff"
 print("old_value:",hash(name))
 print(hash(name))
 print(hash(name))
 name = "s"
 print("new_value:",hash(name))
 # old_value: 9152753171858710842
 #            9152753171858710842
 #            9152753171858710842
 # new_value: -4828918846689666711

isinstance() 判断是否是类型

 print(isinstance(1,int))
 print(isinstance(1.11,float))
 print(isinstance("",int))
 print(isinstance("",str))
 print(isinstance([],list))
 # True
 # True
 # False
 # True
 # True

globals() 打印全局变量（包括系统提供的）

locals() 打印局部变量

zip() 按照一一对应的关系生成一个个元组，两边长度不一致时从左到右取较短相同长度的元素

 print(zip(("a","b","c"),(1,2,3)))
 #<zip object at 0x00000289A9C7E148>
 print(list(zip(("a","b","c"),(1,2,3))))
 #[('a', 1), ('b', 2), ('c', 3)]
 print(list(zip(("a","b","c","d"),(1,2,3))))
 #[('a', 1), ('b', 2), ('c', 3)]
 print(list(zip(("a","b","c"),(1,2,3,4))))
 #[('a', 1), ('b', 2), ('c', 3)]

只要传入的两个值都是有序列的即可

 p = {"name":"Jenny","age":18,"gender":"female"}
 print(list(zip(p.keys(),p.values())))
 #[('name', 'Jenny'), ('age', 18), ('gender', 'female')]
 print(list(zip("hello","")))
 # [('h', '1'), ('e', '2'), ('l', '4'), ('l', '5'), ('o', '4')]

max()取最大值      min()取最小值

对字典比较默认比key，从左到右一一比较

 l = {"A_age":18,'B_age':89,"C_age":50,"D_age":30}
 m_list = list(zip(l.values(),l.keys()))
 print(m_list)
 print(max(m_list))
 # [(18, 'A_age'), (89, 'B_age'), (50, 'C_age'), (30, 'D_age')]
 # (89, 'B_age')

从元素的第一位往后比值，一旦有一位是最大的，后面不再比较

 d = {"a10","a8","a03"}
 print(max(d))
 #a8 第一位一样，比第二位，8>1>0,直接得出最大值，后面不比了

可以指定比较逻辑

 ages = [
     {"name": "a", "age": 18},
     {"name": "b", "age": 50},
     {"name": "c", "age": 99}]
 print(max(ages, key=lambda dic: dic["age"]))
 # {'name': 'c', 'age': 99}

sorted() 升序排序，用法与max()类似

注意：排序本质就是比较大小，同类型之间才可以比较

 prices = {
     "a": 900,
     "b": 800,
     "c": 1000
 }
 print(sorted(prices, key=lambda key: prices[key]))
 # ['b', 'a', 'c']
 print(sorted(zip(prices.values(), prices.keys())))
 # [(800, 'b'), (900, 'a'), (1000, 'c')]

ord() 打印出ASCII码字母代表的数字

chr() 打印出ASCII码数字代表的字母 pow()

 print(chr(97))
 print(ord("a"))
 # a
 #

pow()

pow(a,b) 求a^b

pow(a,b,c) 求a^b%c

reversed() 反转

反转后没有保存

round() 四舍五入

set() 变成集合

slice()切片

主要为了提高程序的可读性，可以指定步长

 m = "hello"
 s = slice(3,5)
 print(m[s])
 #lo

sum() 求和

type() 查看数据类型

vars() 如果没有参数，等于locals()，有参数则显示帮助

import 导入模块

 import test #调用.py文件名
 test.hi()
 #HELLO
 z = __import__("test") #调用字符串名
 z.hi()
 #HELLO