Python学习第八天 匿名函数 函数式编程 高阶函数 map函数 reduce函数 filter函数 内置函数

九 匿名函数

匿名函数就是不需要显式的指定函数

#这段代码
def calc(n):
    return n**n
print(calc(10))
 
#换成匿名函数
calc = lambda n:n**n
print(calc(10))

你也许会说，用上这个东西没感觉有毛方便呀， 。。。。呵呵，如果是这么用，确实没毛线改进，不过匿名函数主要是和其它函数搭配使用的呢，如下

l=[3,2,100,999,213,1111,31121,333]
print(max(l))

dic={'k1':10,'k2':100,'k3':30}


print(max(dic))
print(dic[max(dic,key=lambda k:dic[k])])

res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
    print(i)

输出
1
25
49
16
64

res = map(lambda x:x**2,[1,5,7,4,8])
# for i in res:
#     print(i)
print(list(res))
输出
[1, 25, 49, 16, 64]

十 函数式编程

编程的方法论
# 面向过程
# 函数式
# 面向对象

峰哥原创面向过程解释：

函数的参数传入，是函数吃进去的食物，而函数return的返回值，是函数拉出来的结果，面向过程的思路就是，把程序的执行当做一串首尾相连的函数，一个函数吃，拉出的东西给另外一个函数吃，另外一个函数吃了再继续拉给下一个函数吃。。。

例如：
用户登录流程：前端接收处理用户请求-》将用户信息传给逻辑层，逻辑词处理用户信息-》将用户信息写入数据库
验证用户登录流程：数据库查询/处理用户信息-》交给逻辑层，逻辑层处理用户信息-》用户信息交给前端，前端显示用户信息

函数式编程： 

11 高阶函数

满足俩个特性任意一个即为高阶函数

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

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

map函数
map得到的结果是可迭代对象，导出一次后就变为空

array=[1,3,4,71,2]

ret=[]
for i in array:
    ret.append(i**2)
print(ret)

#如果我们有一万个列表,那么你只能把上面的逻辑定义成函数
def map_test(array):
    ret=[]
    for i in array:
        ret.append(i**2)
    return ret

print(map_test(array))

#如果我们的需求变了,不是把列表中每个元素都平方,还有加1,减一,那么可以这样
def add_num(x):
    return x+1
def map_test(func,array):
    ret=[]
    for i in array:
        ret.append(func(i))
    return ret

print(map_test(add_num,array))
#可以使用匿名函数
print(map_test(lambda x:x-1,array))


#上面就是map函数的功能,map得到的结果是可迭代对象
print(map(lambda x:x-1,range(5)))

reduce函数

from functools import reduce
#合并,得一个合并的结果
array_test=[1,2,3,4,5,6,7]
array=range(100)

#报错啊,res没有指定初始值
def reduce_test(func,array):
    l=list(array)
    for i in l:
        res=func(res,i)
    return res

# print(reduce_test(lambda x,y:x+y,array))

#可以从列表左边弹出第一个值
def reduce_test(func,array):
    l=list(array)
    res=l.pop(0)
    for i in l:
        res=func(res,i)
    return res

print(reduce_test(lambda x,y:x+y,array))

#我们应该支持用户自己传入初始值
def reduce_test(func,array,init=None):
    l=list(array)
    if init is None:
        res=l.pop(0)
    else:
        res=init
    for i in l:
        res=func(res,i)
    return res

print(reduce_test(lambda x,y:x+y,array))
print(reduce_test(lambda x,y:x+y,array,50))

from functools import reduce
li=[1,2,3,4,5]
print(reduce(lambda x,y:x+y,li,10))

filter函数 转为list类型输出，输出后结果清空

#电影院聚集了一群看电影bb的傻逼,让我们找出他们
movie_people=['alex','wupeiqi','yuanhao','sb_alex','sb_wupeiqi','sb_yuanhao']

def tell_sb(x):
    return x.startswith('sb')


def filter_test(func,array):
    ret=[]
    for i in array:
        if func(i):
            ret.append(i)
    return ret

print(filter_test(tell_sb,movie_people))


#函数filter,返回可迭代对象
print(filter(lambda x:x.startswith('sb'),movie_people))

 总结：

#当然了,map,filter,reduce,可以处理所有数据类型

name_dic=[
    {'name':'alex','age':1000},
    {'name':'wupeiqi','age':10000},
    {'name':'yuanhao','age':9000},
    {'name':'linhaifeng','age':18},
]
#利用filter过滤掉千年王八,万年龟,还有一个九千岁
def func(x):
    age_list=[1000,10000,9000]
    return x['age'] not in age_list


res=filter(func,name_dic)
for i in res:
    print(i)

res=filter(lambda x:x['age'] == 18,name_dic)
for i in res:
    print(i)


#reduce用来计算1到100的和
from functools import reduce
print(reduce(lambda x,y:x+y,range(100),100))
print(reduce(lambda x,y:x+y,range(1,101)))

#用map来处理字符串列表啊,把列表中所有人都变成sb,比方alex_sb
name=['alex','wupeiqi','yuanhao']

res=map(lambda x:x+'_sb',name)
for i in res:
    print(i)

#处理序列中的每个元素，得到的结果是一个‘列表’，该‘列表’元素个数及位置与原来一样
# map()

#filter遍历序列中的每个元素，判断每个元素得到布尔值，如果是True则留下来

people=[
    {'name':'alex','age':1000},
    {'name':'wupei','age':10000},
    {'name':'yuanhao','age':9000},
    {'name':'linhaifeng','age':18},
]
print(list(filter(lambda p:p['age']<=18,people)))


#reduce:处理一个序列，然后把序列进行合并操作
from functools import reduce
print(reduce(lambda x,y:x+y,range(100),100))
print(reduce(lambda x,y:x+y,range(1,101)))

十一 内置函数

# 字典的运算：最小值，最大值，排序，不同类型之间不能比较；字符比较时，挨个字符比较，比出大小后，不再看后边字符
salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}
# 迭代字典，取得是key，因而比较的是key的最大和最小值
# print( max(salaries))
# # 'yuanhao'
# print( min(salaries))
# # 'alex'

# 可以取values，来比较
# print( max(salaries.values()))
# print( min(salaries.values()))
# 但通常我们都是想取出，工资最高的那个人名，即比较的是salaries的值，得到的是键
# print(max(salaries,key=lambda k:salaries[k]))
# print(min(salaries,key=lambda k:salaries[k]))
# 也可以通过zip的方式实现(zip函数相当于拉链，如果参数某一侧多了则会把多的舍掉）
# salaries_and_names=zip(salaries.values(),salaries.keys())
# 先比较值，值相同则比较键
# print( max(salaries_and_names))
# (100000000, 'alex')
# salaries_and_names是迭代器，因而只能访问一次
# print( min(salaries_and_names))

# sorted(iterable，key=None,reverse=False)

# print(abs(-1))
# print(abs(1))
#
# print(all([1,2,'1']))
# print(all([1,2,'1','']))
# print(all(''))

# print(any([0,'']))
# print(any([0,'',1]))


# print(bin(3))

#空，None，0的布尔值为False，其余都为True
# print(bool(''))
# print(bool(None))
# print(bool(0))

# name='你好'
# print(bytes(name,encoding='utf-8'))
# print(bytes(name,encoding='utf-8').decode('utf-8'))
#
# print(bytes(name,encoding='gbk'))
# print(bytes(name,encoding='gbk').decode('gbk'))
#
# print(bytes(name,encoding='ascii'))#ascii不能编码中文

# print(chr(46))

# print(dir(dict))

# print(divmod(10,3))

# dic={'name':'alex'}
# dic_str=str(dic)
# print(dic_str)

#可hash的数据类型即不可变数据类型，不可hash的数据类型即可变数据类型
# print(hash('12sdfdsaf3123123sdfasdfasdfasdfasdfasdfasdfasdfasfasfdasdf'))
# print(hash('12sdfdsaf31231asdfasdfsadfsadfasdfasdf23'))
#
# name='alex'
# print(hash(name))
# print(hash(name))
#
#
# print('--->before',hash(name))
# name='sb'
# print('=-=>after',hash(name))


# print(help(all))

# print(bin(10))#10进制->2进制
# print(hex(12))#10进制->16进制
# print(oct(12))#10进制->8进制



# print(isinstance(1,int))
# print(isinstance('abc',str))
# print(isinstance([],list))
# print(isinstance({},dict))
# print(isinstance({1,2},set))

name='哈哈哈哈哈哈哈哈哈哈哈哈哈哈啊哈粥少陈'
# print(globals())
# print(__file__)
#
# def test():
#     age='1111111111111111111111111111111111111111111111111111111111111'
#     # print(globals())  #全局变量
#     print(locals())     #局部变量
#
# test()

l=[1,3,100,-1,2]
print(max(l))
print(min(l))

# print(list(zip(('a','n','c'),(1,2,3))))
# print(list(zip(('a','n','c'),(1,2,3,4))))
# print(list(zip(('a','n','c','d'),(1,2,3))))
#
# p={'name':'alex','age':18,'gender':'none'}
# print(list(zip(p.keys(),p.values())))
# # print(list(p.keys()))
# # print(list(p.values()))
#
# print(list(zip(['a','b'],'12345')))


# l=[1,3,100,-1,2]
# print(max(l))
# print(min(l))


age_dic={'alex_age':18,'wupei_age':20,'zsc_age':100,'lhf_age':30}

# print(max(age_dic.values()))
#
# #默认比较的是字典的key
# # print(max(age_dic))
#
# for item in zip(age_dic.values(),age_dic.keys()): #[(18,'alex_age')  (20,'wupeiqi_age') () () ()]
#     print(item)
#
# print('=======>',list(max(zip(age_dic.values(),age_dic.keys()))))

# l=[
#     (5,'e'),
#     (1,'b'),
#     (3,'a'),
#     (4,'d'),
# ]
# # l1=['a10','b12','c10',100] #不同类型之间不能进行比较
# l1=['a10','a2','a10'] #不同类型之间不能进行比较
# print(list(max(l)))
# print('--->',list(max(l1)))



# l=[1,3,100,-1,2]
# print(max(l))
# dic={'age1':18,'age2':10}
# print(max(dic)) #比较的是key
# print(max(dic.values())) #比较的是key，但是不知道是那个key对应的
#
# print(max(zip(dic.values(),dic.keys()))) #结合zip使用
#
#
# people=[
#     {'name':'alex','age':1000},
#     {'name':'wupei','age':10000},
#     {'name':'yuanhao','age':9000},
#     {'name':'linhaifeng','age':18},
# ]
# # max(people,key=lambda dic:dic['age'])
# print('周绍陈取出来没有',max(people,key=lambda dic:dic['age']))

# ret=[]
# for item in people:
#     ret.append(item['age'])
# print(ret)
# max(ret)


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

# print(pow(3,3))  #3**3
# print(pow(3,3,2))  #3**3%2



# l=[1,2,3,4]
# print(list(reversed(l)))
# print(l)

#
# print(round(3.5))

# print(set('hello'))

# l='hello'
# s1=slice(3,5)
# s2=slice(1,4,2)
# # print(l[3:5])
# print(l[s1])
# print(l[s2])
# print(s2.start)
# print(s2.stop)
# print(s2.step)



# l=[3,2,1,5,7]
# l1=[3,2,'a',1,5,7]
# print(sorted(l))
# # print(sorted(l1)) #排序本质就是在比较大小，不同类型之间不可以比较大小
# people=[
#     {'name':'alex','age':1000},
#     {'name':'wupei','age':10000},
#     {'name':'yuanhao','age':9000},
#     {'name':'linhaifeng','age':18},
# ]
# print(sorted(people,key=lambda dic:dic['age']))
# name_dic={
#     'abyuanhao': 11900,
#     'alex':1200,
#     'wupei':300,
# }
# print(sorted(name_dic))
#
# print(sorted(name_dic,key=lambda key:name_dic[key]))
#
# print(sorted(zip(name_dic.values(),name_dic.keys())))

# print(str('1'))
# print(type(str({'a':1})))
# dic_str=str({'a':1})
# print(type(eval(dic_str)))

# l=[1,2,3,4]
# print(sum(l))
# print(sum(range(5)))
#
#
# print(type(1))
#
# msg='123'
#
# if type(msg) is str:
#     msg=int(msg)
#     res=msg+1
#     print(res)
#
# def test():
#     msg='撒旦法阿萨德防撒旦浪费艾丝凡阿斯蒂芬'
#     print(locals())
#     print(vars())
# test()
# print(vars(int))

#import------>sys----->__import__()
# import test
# test.say_hi()

# import 'test'#报错
module_name='test'
m=__import__(module_name)
m.say_hi()

内置参数详解 https://docs.python.org/3/library/functions.html?highlight=built#ascii