今天的内容真的很多，不得不说，听得很爽，都试了一下：
#关于匿名函数，关键字为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就翻车了，要睡觉了，拜拜