一. 匿名函数:
1.什么是匿名函数:
def 定义的是有名函数. 特点是可以通过名字重复调用.
def func() # func = 函数的内存地址
pass
匿名函数就是没有名字的函数, 特点是只能在定义的时候使用一次.
2.为何要用匿名函数:
强调:
匿名函数的定义就相当于只产生一个变量在值,而没有绑定任何名字.
所以会在定义完之后就被回收,无法重复使用,只能在定义时使用一次.
应用:
当某个功能仅使用一次就没有再重复使用的必要了,就应该定义成匿名函数
3.如何使用匿名函数:
lambda x,y:x+y
示例: 求x+y等于多少.
res = (lanbda x,y:x+y)(1,2)
print(res)
二.各种内置函数的使用方法:
max :(求最大的值)
salaries = {
'egon':3000,
'alex':1000000,
'wupeiqi':10000,
'yuanhao':2000}
print(max(salaries.values()))
key = 函数的内存地址:作用是控制max函数的比较的值
def func(k):
return salaries[k]
print(max(salaries,key=func))
1.将可迭代对象salaries编程迭代器对象iter_obj
2.next(iter_obj)得到一个人名,然后将该人名当做参数传给key指定的函数,
然后调用函数将函数的返回值当做比较依据
3.比较大小,取出最大值对应人名
print(max(salaries,key=lambda k:salaries[k]))
print(min(salaries,key=lambda k:salaries[k]))
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:(有映射的作用,将一个可迭代对象按照指定的规则映射成另一个可迭代对象)
方式一:手动实现
names = ['alex','wupeiqi','yuanhao','kevin','hulaoshi']
new_names = []
for name in names:
new_names.append(name+'dsb')
print(new_names)
方式二:列表生成式
nwe_names = [name + 'dsb' for name in names]
print(new_names)
方式三:map+匿名函数
res = map(lambda x:x + 'dsb',name)
print(list(res))
##由此可见.还是map函数比较简洁一点.
reduce:(把值合并到一起,必须用模块调用:from functools import reduce)
方式一:手动实现
求1+到100的和
res = 0
for i in range(101):
res+=i
print(res)
方式二:列表生成式
print(sum([i for i in range(101)]))
方式三:reduce+匿名函数
from functools import reduce
print(reduce(lambda x,y:x+y,[i for i in range(101)]))
reduce可以添加三个参数,默认为两个相加!
filter:(按照给的规则过滤值.合格的留下.不合格的剔除)
names = ['alex_dsb','wxx_dsb','kevin_dsb','hulaoshi_dsb','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_name)
方式三:filter+匿名函数
res = filter(lambda name:name.endswith('sb'),names)
print(list(res))
二.函数的递归与二分法:
1.什么是函数的递归:
函数的递归调用是函数嵌套调用的一种特殊形式,
特殊在调用一个函数的过程中又直接或间接的调用了函数本身.
递归本质就是个一循环的过程:
但是递归必须满足两个原则:
1.每进入下一层递归,问题的规模必须有所减少
2.递归必须有一个明确的结束条件或者说有一个明确的进入下一层递归的条件
并且递归有两个明确的阶段
1, 回溯:一层一层的递归调用下去
2, 递推:在某一层结束掉递归,然后一层一层返回
2.为何要用递归:
在某些情况下.基于递归来使用重复的过程比while循环更加简单
3.如何用递归
递归的示例:
求一个循环的大两岁的人的年龄:
age(n) = age(n-1)+2
age(1) = 18
def age(n):
if n == 1:
return 18
return age(n-1)+2
res = age(5)
print(res)
小练习: (把lists 的值一个个取出来)
lists = [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(lists)
二分法: 二分法是算法的一种,算法是如何高效的解决问题的思路
nums = [1,13,15,23,27,31,33,57,73,81,93,97,101]
def binary_search(find_num,nums):
print(nums) #方便看运行了几次找到的
if len(nums) == 0:
print('not exists')
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(97,nums)
三.面向过程编程:
核心是过程二字,过程指的是解决问题的步骤,即先干什么在干什么后干什么..
基于该思想编写程序脑子里应该思考过程二字.就好比在设计一条流水线.是一种机械师的思维方式.
优点: 把复杂的问题流程化.进而简单化
缺点: 扩展性很差. 牵一发而动全身.