本文章记录观看B站python教程学习笔记和实践感悟，视频链接：【花了2万多买的Python教程全套，现在分享给大家，入门到精通(Python全栈开发教程)】 https://www.bilibili.com/video/BV1wD4y1o7AS/?p=6&share_source=copy_web&vd_source=404581381724503685cb98601d6706fb
上节课学习函数的定义及调用，函数的参数传递-位置传参和关键字传参，函数的参数传递-默认值参数，函数的参数传递-可变参数，函数的返回值，变量的作用域，本节课学习匿名函数lambda的使用，函数的递归操作，斐波那契数列，常用的内置函数-类型转换函数，常用的内置函数-数学函数你，常用的内置函数-迭代器操作函数，常用的内置函数-其他函数。
一、匿名函数lambda的使用
p95介绍了匿名函数lambda：
基本语法：
变量=lambda 参数1,参数2:需要计算的结果#1.最简单的匿名函数的使用
def calc(a,b):return a+bprint(calc(10,20))
#下面引入匿名函数，首先要有关键字lambda，给calc函数传了两个参数所以也要给lambda传两个参数
#变量=lambda 参数1，参数2:需要计算的结果
s=lambda a,b:a+b #此时s表示的就是一个匿名函数
print(type(s)) #返回<class 'function'>
#调用匿名函数
print(s(10,20))
print('-'*30)
#匿名函数调用列表，对表的正常取值操作
lst=[10,20,30,40,50]
for i in range(len(lst)):print(lst[i])
print() #将表的所有内容单个输出for i in range(len(lst)):lambda result=x:x[i] #根据索引取值,result的类型是function，x形式参数print(result(lst)) #lst是实际参数#
student_scores=[{'name':'陈梅梅','score':98},{'name':'王一一','score':95},{'name':'张天乐','score':100},{'name':'白雪儿','score':65}
]
#对列表进行排序，排序的规则是按照字典中是成绩
student_scores.sort(key=lambda x:x.get('score'),reverse=True) #降序
print(student_scores)
运行结果如下：
30
<class 'function'>
30
------------------------------
10
20
30
40
5010
20
30
40
50
[{'name': '张天乐', 'score': 100}, {'name': '陈梅梅', 'score': 98}, {'name': '王一一', 'score': 95}, {'name': '白雪儿', 'score': 65}]进程已结束，退出代码为 0二、函数的递归操作
递归操作的定义如下：
因此递归操作通常会使用if-else结构来判断递归的调用个递归的终止。
简单来说，递归就是自己调用自己，以右边的阶乘为例，从n!=n*(n-1)!开始，那我们需要返回(n-1)!的值，但是(n-1)!=(n-1)*(n-2)!，所以应该得到(n-2)!的值，这样一步步算下来，最后找打到1!=1，从而返回上一步，得到2!的值，再回上一个3!，直到回到n！。
#第一步定义函数（这里设定名字为fac）
def fac(n): #n的阶乘 N!=N*(N-1)!,...,1!=1if n==1:return 1else:return n*fac(n-1) #这里属于是自己调用自己
print(fac(5)) #5!=5*4*3*2*1=120
最后结果是120
三、斐波那契数列
示例：
def fac(n):if n==1 or n==2:return 1else:return fac(n-1)+fac(n-2)
print(fac(9)) #求出第九位上的数字
#将前几位打印出来
for i in range(1,10):print(fac(i),end='\t') #\t表示换行
print()四、常用的内置函数-类型转换类型
print('非空字符串的布尔值：',bool('hello')) print('空字符串的布尔值：',bool('')) #注意空字符串不是空格字符串 print('空列表的布尔值：',bool([])) print('空列表的布尔值：',bool(list())) #使用内置函数创建：list() print('空元组的布尔值：',bool(())) print('空元组的布尔值：',bool(tuple())) #使用内置函数：tuple() print('空集合的布尔值：',bool(set())) print('空字典的布尔值：',bool({})) print('空字典的布尔值：',bool(dict())) #使用内置函数：dict()print('-'*30)print('非0数值的布尔值：',bool(123)) print('整数0的布尔值：',bool(0)) print('浮点数0.0的布尔值：',bool(0.0))#将其他类型转成字符串类型 lst=[10,20,30] print(type(lst),lst) s=str(lst) print(type(s),s) #float类型和str类型转成int类型 print('-'*30,'float类型和str类型转成int类型','-'*30) print(int(98.7)+int('97')) #注意带小数的字符串,以及非数值的字符不可以直接转成整数的 #print(int('98.7'))#ValueError: invalid literal for int() with base 10: '98.7' #print(int('a')) #ValueError: invalid literal for int() with base 10: 'a' #int类型和str类型转成float类型 print('-'*30,'int类型和str类型转成float类型','-'*30) print(float(90)+float('3.14')) s='hello' print(list(s)) #内置函数list()可以转成列表，从而将字符串中的字符作为列表中的元素seq=range(1,10) print(tuple(seq)) print(set(seq)) print(list(seq))运行结果如下：
非空字符串的布尔值： True 空字符串的布尔值： False 空列表的布尔值： False 空列表的布尔值： False 空元组的布尔值： False 空元组的布尔值： False 空集合的布尔值： False 空字典的布尔值： False 空字典的布尔值： False ------------------------------ 非0数值的布尔值： True 整数0的布尔值： False 浮点数0.0的布尔值： False <class 'list'> [10, 20, 30] <class 'str'> [10, 20, 30] ------------------------------ float类型和str类型转成int类型 ------------------------------ 195 ------------------------------ int类型和str类型转成float类型 ------------------------------ 93.14 ['h', 'e', 'l', 'l', 'o'] (1, 2, 3, 4, 5, 6, 7, 8, 9) {1, 2, 3, 4, 5, 6, 7, 8, 9} [1, 2, 3, 4, 5, 6, 7, 8, 9]进程已结束，退出代码为 0
五、常见的内置函数-数学函数
举例如下：
print('绝对值：',abs(100),abs(-100),abs(0))
print('商和余数：',divmod(13,4))
print('最大值：',max('hello')) #会按照ASCII码去计算，从而得到最大值
print('最大值：',max([10,4,56,78,4])) #在列表中找到最大的元素
print('最小值：',min('hello')) #会按照ASCII码去计算，从而得到最小值
print('最小值：',min([10,4,56,78,4]))#在列表中找到最小的元素#以前需要累加，现在可以用sum函数求和
print('求和：',sum([10,34,45]))
print('x的y次幂：',pow(2,3))
#四舍五入
print('四舍五入：',round(3.1415926))
print(round(3.1415926)) #round函数只有一个参数，那么它做的操作就是保留整数
print(round(3.9415926))
print(round(3.1415926,2))#round后面有两个参数，第一个是需要操作的对象，第二个是需要保留的小数点后的位数
print(round(314.15926,-1)) #-1表示对个位数进行四舍五入
print(round(314.15926,-2)) #-2表示对十位数进行四舍五入
结果如下：
六、常见的内置函数-迭代器操作函数
针对可迭代对象设计的迭代器函数，可迭代对象比如字符串，列表，元组都是可迭代对象。
lst=[54,56,77,4,567,34]
#(1)排序操作
asc_lst=sorted(lst)
desc_lst=sorted(lst,reverse=True)
print('原列表：',lst)
print('升序：',asc_lst)
print('降序：',desc_lst)
#(2)reversed反向
new_lst=reversed(lst)
print(type(new_lst))#<class 'list_reverseiterator'>说明结果不是我们想要的，而是一个迭代器对象
print(list(new_lst)) #需要将上面这个结果转换成列表才能正常看到#(3)zip
x=['a','b','c','d']
y=[10,20,30,40,50]
zipobj=zip(x,y)
print(type(zipobj)) #<class 'zip'>说明这个结果还是一个迭代器对象
print(list(zipobj))#需要将上面这个结果转换成列表才能正常看到
#(4)enumerate
enum=enumerate(y,start=1) #表示从1开始排，将每一个元素遍历出来
print(type(enum))#<class 'enumerate'>
print(tuple(enum)) #转成元组了#(5)all
lst2=[10,20,'',30]
print(all(lst2)) #False,因为列表中只有所有的元素都不为空才是true，而这里有空字符串
print(all(lst)) #True
#(6)any 列表当中所有元素对象的布尔值不全为false，该列表才是true
print(any(lst2)) #True#(7)next
x=['a','b','c','d']
y=[10,20,30,40,50]
zipobj=zip(x,y)
print(next(zipobj)) #运行一次，提取第一个元素
print(next(zipobj)) #运行二次，提取第二个元素
print(next(zipobj)) #运行三次，提取第三个元素#(8)filter，按照指定条件筛选
def fun(num):return num%2==1 #可能是True,False
obj=filter(fun,range(10)) #注意这里函数也是参数之一，将range(10)，也就是0到9的整数都执行一次fun
print(list(obj)) #[1, 3, 5, 7, 9]
#filter的作用就是，将第二个参数的数值用第一个参数的函数都执行一遍，放到对象中存储，只返回true的数值#(9)map
def upper(x):return x.upper() #意义就是将指定字符串转成大写
new_lst2=['hello','world','python']
obj2=map(upper,new_lst2) #函数不是调用所以不加括号，对于所有new_lst2中的元素都执行前面自定义的这个函数
print(list(obj2))结果如下：
原列表： [54, 56, 77, 4, 567, 34]
升序： [4, 34, 54, 56, 77, 567]
降序： [567, 77, 56, 54, 34, 4]
<class 'list_reverseiterator'>
[34, 567, 4, 77, 56, 54]
<class 'zip'>
[('a', 10), ('b', 20), ('c', 30), ('d', 40)]
<class 'enumerate'>
((1, 10), (2, 20), (3, 30), (4, 40), (5, 50))
False
True
True
('a', 10)
('b', 20)
('c', 30)
[1, 3, 5, 7, 9]
['HELLO', 'WORLD', 'PYTHON']进程已结束，退出代码为 0
由此可见，使用迭代器可以简化操作，比如我们以前需要使用for循环来遍历每一个元素，在这里我们只用迭代器函数，然后函数有座位函数的参数，依次调用元素。
七、常见的内置函数-其他函数
示例如下：
#(1)format()
print(format(3.14,'20')) #数值型默认右对齐，20表示占用宽度
print(format('hello','20')) #字符串默认左对齐
print(format('hello','*>20')) #>表示右对齐，*表示填充符，20表示显示的宽度
print(format('hello','*^20')) #^表示居中对齐，*表示填充符，20表示显示的宽度print(format(3.1415926,'.2f')) #带小数点的数值型默认右对齐,并且.2f表示保留两位小数
print(format(20,'b')) #数值型默认右对齐,并且b表示二进制
print(format(20,'o')) #并且o表示八进制
print(format(20,'x')) #并且o表示十六进制
print(format(20,'X')) #并且o表示十六进制#(2)len() 作用是计算对象的长度
print('-'*40)
print(len('helloworld')) #计算字符串的长度
print(len([10,20,30,40,50])) #计算列表的元素格式
#(3)id() 作用是查看对象的内存地址
print('-'*40)
print(id(10))
print(id('helloworld'))#(4)type() 作用是获取元素的类型
print(type('hello'),type(10))
#(5)eval() 作用是数据类型转换
print(eval('10+30'))
print(eval('10>30'))运行结果如下：
3.14
hello
***************hello
*******hello********
3.14
10100
24
14
14
----------------------------------------
10
5
----------------------------------------
2446115564112
2446123506352
<class 'str'> <class 'int'>
40
False进程已结束，退出代码为 0本节完
_列表过滤、列表排序)
