Python入门学习笔记——5.高阶函数

###############################################################
#1.递归函数
'''
递归函数：
    递归函数就是定义了一个函数，然后在函数内，自己调用了自己这个函数
    递归函数内必须要有结束，不然就会一只调用下去，直到调用的层数越来越多，栈溢出
    递归函数是一层一层的进入，再一层一层的返回，
    例子：
        就像是以前上学一样，你坐在最后面一排，最前面有个漂亮的妹子，你想要要的电话，这时怎么办？
        你去拍一拍前面同学的肩膀，让他帮我问问前面妹子的电话，于是这个同学继续拍一拍前面同学的肩膀
        让他问问前面妹子的电话，之后一直从后向前传递这个信息，一只在重复这个过程，
        直到最后一个通过拍了最前面妹子的肩膀，要到了电话之后一层层的返回到最开始的同学手中

斐波那契数列
    1，1，2，3，5，8，13。。。
实现一个数的阶乘：
    1*2*3*4*5*6*7
'''

# 初步认识 递归函数  3 2 1 0
def digui(num):
    print(num) # 3 2 1 0
    # 检测当前的值是否到了零
    if num > 0:
        # 调用函数本身
        digui(num-1)
    print(num) # 0 1 2 3

digui(3)

'''
解析当前递归函数的执行过程：
digui(3) ==> 3 
    digui(3-1) ==> 2
        digui(2-1) ==> 1
            digui(1-1) ==> 0
            digui(0) ==> 0
        digui(1) ==> 1
    gidui(2) ==>2
digui(3) ==> 3
'''
###############################################################
# 2.实现阶乘 求一个数的阶乘结果  7 1*2*3*4*5*6*7

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

res = jiecheng(7)
print(res)

'''
jiecheng(7) = 5040
7*jiecheng(6)
    6*jiecheng(5)
        5*jiecheng(4)    
            4*jiecheng(3)    
                3*jiecheng(2)    
                    2*jiecheng(1) 
                        jiecheng(1) ==> 1   
                    2*1 ==> 2
                3*2  ==> 6
            4*6 ==> 24
        5*24 ==> 120
    6*120 ==> 720
7*720 ==> 5040
'''

'''
递归函数的效率并不高，尽量能不用就不用。。。
一个函数如果调用后，没有结束，那么在栈空间中就一直存在，直到这个函数运算结束才销毁
'''

###############################################################
#3.递归函数的练习

# 斐波那契数列 1，1，2，3，5，8，13。。。
# 求第n位上的数是多少？ 例如第六位 第6位 8

def feibo(n):
    if n == 1 or n == 2:
        return 1
    else:
        print(n-1,n-2)
        return feibo(n-1) + feibo(n-2)

res = feibo(6)
print(res)
'''
5 4
4 3
3 2
2 1
2 1
3 2
2 1

feibo(6) ==>  feibo(5)                +          feibo(4)
                5                                 3
              ==> feibo(4) + feibo(3)             ==> feibo(3) + feibo(2)
                      3          2                     2         1
                            ==> feibo(2) + feibo(1)
                                   1         1
                 ==> feibo(3) + feibo(2)             ==> feibo(2) + feibo(1)
                       2          1                        1        1
                   ==> feibo(2) + feibo(1)
                            1      1

'''

###############################################################
#4.回调函数

# 定义一个函数,函数中的一个参数要求是另一个函数
# 带有回调函数参数的函数
# def func(f):
    # print(f,type(f))
    # 并且在函数中调用了传递进来的行参函数
    # f()


# 回调函数
# def love():
#     print('123')
#
# func(love)


def func(x,y,f):
    '''
    当前这个函数接收两个数值，并把这两个数值传递给第三个参数进行运算
    x，y  int
    f     function
    :return:
    '''
    # print(f([x,y]))
    print(f(x,y))

# func(2,3,pow)

# map() sorted() filter()  reduce()

###############################################################
#5.闭包函数

# 钱包
money = 0

# 工作
def work():
    global money
    money += 100

# 加班
def overtime():
    global money
    money += 200

# 购物
def buy():
    global money
    money -= 50


# work()
# work()
# work()
# overtime()
# buy()
# # 银行垮台了，没钱了。。。
# money = 0
# work()
# print(money)

# 对程序进行改造


'''
闭包的特点
    1。在外函数中定义了局部变量，并且在内部函数中使用了这个局部变量
    2。在外函数中返回了内函数，返回的内函数就是闭包函数
    3。⚠主要在于保护了外函数中的局部变量，既可以被使用，又不会被破坏

'''
def person():
    money = 0
    # 工作    在外函数中定义的内函数
    def work():
        nonlocal money   # 在内函数中使用了外函数的临时变量
        money += 100
        print(money)
    # 在外函数中返回了内函数，这个内函数就是闭包函数
    return work

res = person() # return work  res = work
res() # res() == work()
res()
res()
res()
# 此时 就不能够在全局中对money这个局部变量进行任何操作了，
# 闭包的作用：保护了函数中的变量不受外部的影响，但是又能够不影响使用

## 如何检测一个函数是否为闭包函数
# 函数名.__closure__ 如果是闭包函数返回 cell
print(work.__closure__)

###############################################################
#6.匿名函数  lambda 表达式

'''
语法：
lambda [参数列表]:返回值
'''

# 封装一个函数做加法运算
# 普通函数
def jia(x,y):
    return x+y

# print(jia(2,3))

# 改成lambda表达式来封装
res = lambda x,y:x+y
# print(res(4,4))

# lambda是一个表达式，因为不能写太复杂的逻辑，功能相对单一
# lambda是否可以使用分支结构
def func(sex):
    if sex == '男':
        return '很man'
    else:
        return '很nice'

# res = func('男')
# print(res)

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

###############################################################
#7.迭代器

# range(10,3,-1)  返回一个可迭代的对象，
# for i in range(10,3,-1):
#     print(i)

# arr = ['a','b','c',4,5]
# for i in arr:
#     print(i)


'''
iter()
    功能：把可迭代的对象，转为一个迭代器对象
    参数：可迭代的对象 （str，list，tuple，dict，set，range。。。）
    返回值： 迭代器对象
注意：迭代器一定是一个可以迭代的对象，但是可迭代对象不一定是迭代器
'''
# 定义一个列表，是一个可迭代的对象
f4 = ['赵四','刘能','小沈阳','海参炒面']
# 可以使用for循环来遍历数据

# 可以把可迭代对象转为迭代器使用
res = iter(f4)
# print(res,type(res)) # <list_iterator object at 0x109063810> <class 'list_iterator'>



# 取值方案
'''
迭代器取值的方案
    1。 next() 调用一次获取一次，直到数据被取完
    2。 list() 使用list函数直接取出迭代器中的所有数据
    3。 for    使用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

varstr = '123456'
res = iter(varstr)

# type() 函数返回当前数据的类型，
# isinstance() 检测一个数据是不是一个指定的类型
r1 = isinstance(varstr,Iterable) # True 可迭代对象
r2 = isinstance(varstr,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

###############################################################