函数参数： 普通参数,默认参数,普通收集参数,命名关键字参数,关键字收集参数

收集参数:不确定需要传递多少个实参,直接用一个形参来接收

1.普通收集参数:收集普通参数,形参前面加*
接收的多余的参数会以元组形式存储在args中
def func(x='+',*args):
   print(type(args))   #<class 'tuple'>
   if x == '+':
      print('加法运算',args)
func('+',200,300)  #加法运算 (200, 300)

2.关键字收集参数:用于专门收集多余关键字实参,形成一个新的字典
    语法:参数前面加**  例:**kwargs  
    def love(a,b,c,*args,name,**kwargs):     #kw==keyword
    print(a,b,c)
    print(args)         #普通收集参数,把多余参数收集成元组
    print(kwargs)         #关键字收集,把多余关键字参数收集为字典
love(1,2,3,112,123,name=222,age=25,sex='ccc')

形参声明的位置顺序:

普通参数 -> 默认参数 -> 收集参数 -> 命名关键字参数 -> 关键字收集参数

递归

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

# 初步认识 递归函数  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

回调函数

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

闭包函数

在一个函数内返回了一个内函数， 并且这个返回的内函数还使用了外函数中局部变量，这就是闭包函数

检测一个函数是否为闭包函数，可以使用 函数名.closure如果是闭包函数返回 cell

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

迭代器的取值方案

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

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

高阶函数

sorted(iterable,[reverse,key])
map(func, *iterables)
reduce(func,iterable)
filter(func,iterable)

求和函数:

sum(iterable[, start]) ，iterable为可迭代对象，如：
sum([ ], start) #iterable为list列表
sum(( ), start ) #iterable为tuple元组
start默认为0