递归函数

在定义的函数内，调用该函数

# 斐波那契数列指的是这样一个数列：1、1、2、3、5、8、13、21、34、……，即F(n)=F(n-1)+F(n-2)
# fib(n),其中参数n的含义：斐波那契数的序号（如：n = 1时，返回1；n=3时，返回2）。
def fib(n):
    """
    :type n: int
    :rtype: int
    """
    while (n > 0):
        if (n == 1 or n == 2):
            return 1
        else:
            return fib(n - 1) + fib(n - 2)
    return 0

print(fib(3))

# 实现一个数的阶乘
def jiecheng(n):
    if n == 1:
        return 1
    else:
        return n*jiecheng(n-1)

print(jiecheng(2))

回调函数

函数A中使用函数作为参数，且调用了该函数参数

def love():
     print('123')
     
def func(f): # 使用函数作为参数
    print(f,type(f))
    f() #调用了函数参数

func(love)

闭包函数

函数A中返回值为A中的内函数，并且该内函数使用了A中局部变量。内函数就是闭包函数

特点

内函数使用了外函数中定义的局部变量
外函数返回值为内函数，返回的内函数就是闭包函数
用于保护外函数中的局部变量，既可以使用，又不会被外界破坏
使用 函数名.__closure__ 检测是否为闭包函数 如果是闭包函数返回 cell

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

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

匿名函数 lambda 表达式

使用lambda表达式定义匿名函数
lambda 参数1，参数2… : 返回值

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 参数列表: 真区间 if 表达式判断 else 假区间
res = lambda sex:"很man" if sex=='男' else "很nice"
print(res('女'))

迭代器

可迭代对象可以转化为迭代器对象，从第一个元素从前往后遍历，直到集合中的所有元素被访问完毕

iter()

功能：把可迭代的对象，转为一个迭代器对象
参数：只能是可迭代的对象 （字符串，列表，元组，字典）
返回值：迭代器对象
注意：迭代器一定是一个可以迭代的对象，但是可迭代对象不一定是迭代器

next()

next()函数可以去调用迭代器，并返回迭代器中的下一个数据

迭代器的取值方案

next() 调用一次获取一次，直到数据被取完
list() 使用list函数直接取出迭代器中的所有数据
for 使用for循环遍历迭代器的数据

r = ['张三','李四','王五','二麻子']
'''
1. next() 调用一次获取一次，直到数据被取完                   
2. list() 使用list函数直接取出迭代器中的所有数据              
3. for    使用for循环遍历迭代器的数据  
'''
res = iter(r)
# print(next(res)) #1
# print(list(res)) #2
# 3
for i in res:
    print(i)

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

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

迭代器一定是可迭代的对象，可迭代的对象不一定是迭代器

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)         
# 迭代器一定是一个可迭代的对象，可迭代对象不一定是迭代器