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)
# 600

指定一个倍数

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)
# 6000

reduce函数

from functools import reduce

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

注意：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'xe4xbdxa0xe5xa5xbd'

.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("1",int))
print(isinstance("1",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","1245435")))
# [('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
# 97

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