高阶函数

一、递归函数

1.定义一个函数，在函数内自己调用自己

例题：斐波那契数列：1，1，2，3，5，8，21，，，，

​ 实现一个阶乘：1 * 2 * 3 * 4* 5

#实现一个递归：3，2，1，0
def func1(n):
  print(n)
  #检测当前的值是否到0
  if n > 0:
    func1(n-1)#调用自己
   
func1(3)

2.递归函数内必须要有结束，不然就会一直调用下去，直到调用的层数越来越多，栈溢出

3.递归函数是一层一层的进入，再一层一层的返回

#实现斐波那契数列
def func1(n):
    if n == 1 or n == 2:
         return 1
    else:
         #print(n-1,n-2)
         return func1(n-1) + func1(n-2)
        
        
#实现阶乘

def func2(n):
    if n == 1:
        return 1
    else:
        return n * func2(n-1)

4.递归函数的效率不高，尽量不要用

5.一个函数如果调用后没有结束，那么在栈空间就一直存在，知道这个函数运算结束在销毁。

二：回调函数—把一个函数作为行参

定义：在一个函数中 要求传递的参数是一个函数作为参数，并且在函数中使用了传递进来的函数

#带有回调参数的函数
def func3(f):
    #print(f,type(f))
    #在函数中调用了传递进来的函数
    f()
    
#回调函数
def func4():
    print('exo')

    
func3(func4)#exo

def func5(x,y,f):
  '''
  当这个函数接受两个数值，并把两个数值传递给第三个参数进行计算
  x,y,int
  f   function
  return 
  '''

  print(f(x,y))
  
 def func5(x,y,pow):
  print(pow(x,y))
  
  func5(2,3,pow)
  
#都要求传递一个函数进去
map(),sorted(),filter(),reduce()

三：闭包函数—在一个函数中返回一个函数

定义：在一个函数内返回一个内函数，并且这个返回的内函数还使用了外函数中的局部变量

def person():
    money = 0#在外函数中定义了局部变量，并且在内部函数中使用了这个局部变量
    #工作：在外函数中定义的内函数
    def work():
        nonlocal money#在内函数中使用了外函数的临时变量
        money += 100
        print(money)
    #加班
    def overtime():
        nonlocal money
        money += 200
    #购物
    def buy():
        nonlocal money
        money -= 50
        
    #在外函数中返回内函数，这个内函数就是闭包函数
    return work
res = person()#接收一下,res = work
res()#res() == work()


#检测一个函数是否为闭包函数
print(res.__closure__)#(<cell at 0x11083bf48: int object at 0x10b94b790>,)

#此时不能在全局中对money 这个局部变量进行任何操作

闭包的作用：

保护了函数中的变量不受外部的影响，但是又能够不影响使用

闭包的特点：

1，在外函数中定义了局部变量，并且在内部函数中使用了这个局部变量

2，在外函数中返回了内函数，返回的内函数就是闭包函数

3，主要在于保护了外函数中的局部变量，既可以被使用，又不会被破坏

如何检测一个函数是否为闭包函数

函数名.closure 如果是闭包函数返回 cell

四：匿名函数 lambda 表达式：称为一行代码函数

定义：可以不使用def定义，并且这个函数也没有名字

​ 在python中可以使用lambda表达式来定义匿名函数

Tips：

lambda仅仅是一个表达式，即一行代码；不是一个代码块；

lambda表达式也有行参，并且不能访问除了自己行参之外的任何数据包括全局变量

#lambda [参数列表]:返回值
res = lambda x,y:x+y#拿一个变量接受
print(res(2,3))

lambda是一个表达式，因为不能写太复杂的逻辑，功能相对单一

lambda可以使用分支结构

#带有分支结构
#lambda参数列表：真区间 if 表达式判断 else 假区间
res = lambda sex:'man' if sex == '男' else 'woman'
print(res('女'))

五：迭代器

特点

是python中最具特色的功能之一；

是访问集合元素的一种方式；

是一个可以记住访问遍历的位置的对象；

从集合的第一个元素开始访问，知道集合中的所有元素被访问完毕；

只能从前往后一个一个遍历，不能后退；

能被next()函数调用，并不断返回下一个值的对象 称为迭代器（iterator迭代对象）

# 定义一个列表，是一个可迭代的对象
f4 = ['赵','刘','小','海']
#提取数据出来
#可迭代对象：可以用for循环
# 可以使用for循环来遍历数据
for i in f4:
    print(i)
# 可以把可迭代对象转为迭代器使用
res = iter(f4)
print(res,type(res)) # <list_iterator object at 0x109063810> <class 'list_iterator'>

iter()

功能：把可迭代的对象，转为一个迭代器对象

参数：可迭代的对象 （str，list，tuple，dict，set，range。。。）

return： 迭代器对象

Tips ：迭代器一定是一个可以迭代的对象，但是可迭代对象不一定是迭代器

迭代器取值的方案

next() 调用一次获取一次，直到数据被取完

list() 使用list函数直接取出迭代器中的所有数据

使用for循环遍历迭代器的数据

迭代器取值的特点：取出一个少一个，直到都取完，最后再获取就会报错

#1.使用next()函数去调用迭代器对象
print(next(res))
#print(next(res))


#2.使用list取值
r = list(res)
print(r)

#3.使用for循环
for i in res:
    print(i)

# print(next(res))  #当调用次数用完，超出可迭代的范围，报错；StopIteration

检测迭代器和可迭代对象的方法

from collections.abc import Iterator,Iterable

str1 = '123456'
res = iter(str1)

# 1 type() 函数返回当前数据的类型，
# 2 isinstance() 检测一个数据是不是一个指定的类型
r1 = isinstance(str1,Iterable) # True 可迭代对象
r2 = isinstance(str1,Iterator) # False 不是一个迭代器
r3 = isinstance(res,Iterable) # True 可迭代对象
r4 = isinstance(res,Iterator) # True 是一个迭代器
print(r1,r2)
print(r3,r4)
# 迭代器一定是一个可迭代的对象，可迭代对象不一定是迭代器

# next(varstr) # TypeError: 'str' object is not an iterator

#Iterable:检测是不是一个可迭代对象
#Iterator:检测是不是一个迭代器