Python之旅的第八天（匿名函数、内置函数、map、filter、reduce）

今天的内容真的很多，不得不说，听得很爽，都试了一下：

#关于匿名函数，关键字为lambda
#首先是看一下之前没有用匿名函数的时候如果简单的是这样
# def test(x):
#     return x+1
# print(test(10))

#然后是使用lambda的方式  匿名函数的基本书写模式：lambda 形参： 计算方法  （返回计算方法中的结果，类似return后面的东东）
# test = lambda x:x+1    #这里将x 和 x+1的关系用lambda固定，即传入x后进行x+1的运算
# #test的作用是为了接收匿名函数lambda，因为匿名函数没有名称，不方便调用，所以使用变量进行接收
# print(test(10))   #此处则直接开始进行运算

#lambda的演示，多与其他函数合并使用,匿名函数不能有很复杂的运算
# test = lambda x : x + '_sb'
# print('匿名函数的运行结果是：',test('alex'))  #---->输出结果：'alex_sb'

#lambda输入多个参数，返回多个值的写法lambda x,y,z : (x+1,y+1,z+1）  这里要记得加括号
# test = lambda x,y,z : (x+y+z,x-y-z)
# print(test(7,9,6))    #return在返回结果时会帮加上元组括号，lambda需要自己加

# 编程的方法论：面向过程、函数式、面向对象
# 面向过程：找到解决问题的入口，按照一个固定的流程模拟解决问题

# 函数式编程：  函数式 = 编程语言定义的函数 + 数学意义的函数
# 通俗讲，函数式就是编程语言去实现数学函数。这种函数内对象是永恒不变的，幺妹参数是函数
# ，要么返回值是函数，没有for和while循环，所有的循环都由递归去实现，无变量的赋值（即不用变量保存状
# 态，无赋值即不改变（python不是严格意义上的函数式语言）

# def foo(n):
#     print(n)
#
# def bar(name):    #不是高阶函数（不知道说了这么多这个是干啥的）
#     print('my name is %s'%name)
#
# foo(bar)  #输出bar的内存地址
# foo(bar('name')) #bar加上（）括号，即为表示执行bar函数
# #foo(bar('name')) 的运算结果，首先是输出bar（）内的print语句
# #随后bar()没有返回值，运行foo(),传入参数为None，打印出结果为None
# #运算结果my name is name
# None

#返回值当中包含函数
# def bar():
#     print('from bar')
#
# def foo():
#     print('from foo')
#     return bar   #此处bar后面是否有括号已经无所谓了
#
# n = foo()  #给n赋值一个函数，此时n就表示foo()
# n()    #此处等同于foo()()
# #运行结果是：from foo  随后是from bar

# def handle():
#     print('from handle')
#     return handle    #此处如果有括号则直接进行再次运行,没有括号则不继续进行运行
# h = handle()    #输出from handle
# h()   #输出from handle

#高阶函数：1.函数接收的参数是一个函数名   2.返回值中包含函数

#关于递归，递归在进入下一层预算时是否需要保留当前层的状态，取决于进入下一层函数运算时，进入下一层
#之后，当前层是否还有为完成运算的代码，如果本层还有未运行的则需要保留本层的运行状态，所以为了更好
#优化递归，有必要进行尾递归的优化

#尾递归调用优化，函数的最后一步进行调用，进入下一层
#尾递归的优化示例

#尾递归的优化
#非尾递归
# def cal(seq):
#     if len(seq) == 1:
#         return seq[0]
#     head,*tail = seq
#     return head + cal(tail)
# print(cal(range(100)))

#尾递归（优化后）
# def cal(l):
#     print(l)
#     if len(l) == 1:
#         return 1[0]
#     first,second,*args = 1
#     l[0] = first + second
#     l.pop(l)
#     return cal(l)
#
# x = cal([i for i in range(10)])
# print(x)


#map函数

#提出需求 把num_l = [1,2,10,3,7]中每个元素的平方值求出来
#原有函数模式的写法（求每个平方、自增、自减）
#首先是我的复杂错误示例
# num_l = [1,2,10,3,7]
# def test(x):   #求平方方法
#     num = []
#     for i in num_l:
#         num.append(i**2)
#     return num
#
# def test_1(x):   #自增1的方法
#     num = []
#     for i in num_l:
#         num.append(i+1)
#     return num
#
# print(test(num_l))
# print(test_1(num_l))

# #进行第一次优化
# #首先定义一个总的方法目录
# num_l = [5,6,7,8,9,10]
#
# def map_test(func,array):
#     res = []
#     for i in array:
#         a = func(i)
#         res.append(a)
#     return res
#
# #撰写局部方法
# def zizeng(x):  #自增方法
#     return x+1
# def zijian(x):  #自减方法
#     return x-1
# def pingfang(x):  #平方值的计算
#     return x**2
#
# # print(map_test(zizeng,num_l))
# # print(map_test(zijian,num_l))
# # print(map_test(pingfang,num_l))
# #
# # # 再次对输出语句进行优化,此处使用匿名函数lambd进行说明运算方法
# # print(map_test(lambda x : x + 1 ,num_l))
# # print(map_test(lambda x : x - 1,num_l))
# # print(map_test(lambda x : x**2,num_l))
#
# #最终的究极方法，Python内部自带的map函数，可实现上述全部函数的所有操作
# # 即直接输出：
# print(list(map(lambda x : x + 1 ,num_l)))   #以此实现对序列中每个元素自增
# print(list(map(zizeng,num_l)))    #对于简单的运算可使用lambda，复杂运算依旧可以直接饮用自己定义的def
# #因为map函数直接输出的是一个可迭代器，不能直接打印，需要用list方法进行操作后才能直接打印
# print(map(pingfang,num_l))   #输出结果为：<map object at 0x000001D030958518>
# #切记进行list操作


#filter函数的引入
#提出需求，将列表中前面有sb，或者后面又sb的去掉
#老式方法：
# people_list = ['xiaoming','xiaoli','xiaohong_sb','xiaoqiang_sb']
# # res = []
# # for p in people_list:
# #     if not p.endswith('sb'):
# #         res.append(p)
# # print(res)
#
# #使用函数引用，类似于刚才的map_test
# def end_test(x):   #判断结尾是否为sb
#     return not x.endswith('sb')
# # def start_test(x):   #判断开始是否为sb
#     return not x.startswith('sb')
# def filter_test(func,array):
#     res = []
#     for p in array:
#         if func(p):
#             res.append(p)
#     return res
#
# print(filter_test(end_test,people_list))
# #这个时候其实也可以开始使用lambda，匿名函数了
# print(filter_test(lambda x : not x.endswith('sb'),people_list))

# # 最后引入究极版本，Python中自带函数filter函数
# # filter函数书写规范，filter(函数方法(返回bool类型数值，如果返回True,保留后面参数内的元素)，可迭代参数)
# # 直接一句搞定上面的全部
# print(list(filter(lambda x : not x.endswith('sb'),people_list)))  #使用list的原因相同
# print(list(filter(end_test,people_list)))    #根据运算复杂程度决定用lambda，还是使用def自定义的函数运算
# #结果都相同

from functools import reduce

#reduce函数的引入
#需要从functools里面引入reduce先
#需求：num_l = [1,2,3,67,8,101] 所有数字的和或者积
# num_l = [1,2,3,100]
# res = num_l.pop(0)
# for num in num_l:
#     res = res + num
# print(res)

#以上方法过于固定，重新引入def的方式

# num_l = [1,2,3,100]
# def cheng(x,y):
#     return x*y
# def qiuhe(x,y):
#     return x+y
# # def reduce_test(func,array,init = None):  #reduce中初始值默认为零，
# #                                           # 在这里可以理解为给和或者积再加一个数或者乘一个数字
# #     res = array.pop(0)
# #     for i in array:
# #         res = func(res,i)
# #     return res
# #
# # print(reduce_test(cheng,num_l))
# # print(reduce_test(lambda x,y:x+y,num_l))
#
# # #此时引入究极方法reduce(这里和自己写的方法同时运行时候出现错误，还得深究）
# num_l = [1,2,3,100]
# print(reduce(lambda x,y : x*y,num_l))
# print(reduce(qiuhe,num_l))

下面是今天提到的Python内置函数
abs      取绝对值
all      对可迭代对象内的每个元素进行bool运算，如果全部为True或者可迭代对象为空，返回True
any      对可迭代对象每个元素进行bool运算，如果有一个返回值为True，则返回True
bin      十进制转二进制
bool     布尔运算
bytes    字符串转换为字节形式bytes(参数，encoding = 'utf-8/gbk等等')
decode   与前面的bytes正好相反，书写格式相同
chr　　　 数字对应的ASCII码
dict     字典
dir      显示某一方法对应目录
divmod   书写格式divmod（被除数，除数）得到（商，余数），用于做分页
evol     读取字符串中的数据结构，非常强大（返回字符串内的类型，如果包含数学运算，还会计算结果）
float　　 返回浮点型数字
hash　　  可被哈希的不可变数据，求出对应哈希值（哈希值特点：唯一固定，不随长度增加而明显增加长度，不可根据哈希值反推数据，内容不变哈希值不变）用于检测文件是否被修改
help     显示本方法所有解释
hex　　　 十进制转十六进制
oct      十进制转八进制
isinstance   检测数据类型是否正确  格式：isinstance（数据，类型），对应时返回True
locals   显示所有本地变量
globals  显示所有全局变量

就是这些了，这些内置方法估计还是得稍微练习一下，刚才eval就翻车了，要睡觉了，拜拜