匿名函数、内置函数、函数递归与二分法还有面向过程编程的概念
一、匿名函数和内置函数
1、什么是匿名函数
def定义的是有名函数：特点是可以通过名字重复调用
def func(): #func=函数的内存地址
pass
匿名函数就是没有名字的函数：特点是只能再定义时使用一次
2、为何要用匿名函数
强调：
匿名函数的定义就相当于只产生一个变量值，而没有绑定任何名字
所以会在定义完之后就被回收，无法重复使用，只能在定义时使用一次
应用：当某一个功能仅使用一次就没有再重复使用的必要了，就应该定义成匿名函数
3、如何用匿名函数
lambda x,y:x+y
print(lambda x,y:x+y)
res = (lambda x,y:x+y)(1,2)
print(res)
salaries = {
'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000
}
print(max(salaries.values()))
print(max(salaries,key = lambda x:salaries[x]))
sorted排序
nums = [10,-1,11,9,23]
print(sorted(nums))
print(nums)
salaries = {
'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000
}
print(sorted(salaries,key = lambda k:salaries[k]))
print(sorted(salaries,key = lambda k:salaries[k]),reverse=True)
map映射函数
#需求 在每个人的名字后面加大帅比（dsb）
names = ['alex','wupeiqi','yuanhao','kevin','zero']
方式一：手动实现
new_names = []
for name in names:
new_names.append(name+'dsb')
print(new_names)
方式二：列表生成式
new_names = [name + 'dsb' for name in names]
print(new_names)
方式三：map+匿名函数
res = map(lambda x:x+'dsb',names)
print(list(res))
reduce合并函数
方式一：手动实现
res = 0
for i in range(101):
res += i
print(res)
方式二：列表生成式
print(sum(i for i in range(101)))
方式三：reduce+匿名函数
from functions import refuce
print(reduce(lambda x,y:x+y,[i for i in range(101)],100))
filter 过滤函数
#需求：将列表中含sb的字符串取出来
names = ['alex_dsb','wxx_sb','kevin_sb','hu_sb','egon']
方式一：手动实现
new_names = []
for name in names:
if name.endswith('sb'):
new_names.append(name)
print(new_names)
方式二：列表生成式
new_names = [name for name in names if name.endswith('sb')]
print(new_names)
方式三：filter+匿名函数
res = filter(lambda name:name.endswith('sb'),names)
print(list(res))
二、函数递归与二分法
1、什么是函数递归
函数的递归调用是函数嵌套调用的一种特殊形式
特殊在调用一个函数的过程中又直接或者间接地调用了该函数本身
递归本质就是一个循环的过程，
但是递归必须满足两个原则：
1.每进入下一层递归，问题的规模必须有所减少
2.递归必须有一个明确的结束条件或者说有一个明确的进入下一层递归的条件
并且递归有两个明确的阶段
1.回溯：一层一层地递归调用下去
2.递推：在某一层结束掉递归，然后一层一层返回
2、为何要用递归：
在某些情况下，基于递归来使用重复的过程比while循环更加简单
3、如何用
def f2():
print(from f2)
f1()
def f1():
print('from f1')
f2()
f1()
递归举例：
age(5) = age(4) + 2
age(4) = age(3) + 2
age(3) = age(2) + 2
age(2) = age(1) + 2
age(1) = 18
age(n) = age(n-1) + 2 # n>1
age(1) = 18 #n =1
def age(n):
if n == 1:
return 18
return age(n-1) + 2
res = age(5)
print(res)
例2：#需求 打印出列表中的1~9
list1 = [1,[2,[3,[4,[5,[6,[7,[8,[9,]]]]]]]]]
def func(l):
for item in l:
if type(item) is list:
#将item当作一个新列表传给功能本身
func(item)
else:
print item
func(list1)
二分法：二分法是算法的一种，算法是如何高效地解决问题的思路
nums = [1,13,15,23,27,33,46,74,83,87,93] #从小到大排列的数字列表
def binary_search(find_num,nums):
print(nums)
if len(nums) == 0:
print('not exit!')
return
#功能
mid_index = len(nums)//2
if find_num > nums[mid_index]:
nums = nums[mid_index+1:]
binary_search(find_num,nums)
elif find_num < nums[mid_index]:
nums =nums[:mid_index]
binary_search(find_num,nums)
else:
print('find it')
binary_search(95,nums)
三、面向过程编程
核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么后干什么...
基于该思想编写程序脑子里应该是始终思考过程二字，就好比在设计一条流水线，是一种机械式的思维方式
有点：复杂的问题的流程化，进而简单化
缺点：扩展性差