函数参数、作用域、高阶函数、递归函数、高阶函数

#-----必须参数、关键字参数、默认参数-----

def user_info(name,age,sex="male"):
    print("Nmae: %s"% name)
    print("Age: %d" % age)
    print("Sex：%s" % sex)

#必须参数('dream',18)
user_info('dream',18) #Nmae: dream Age: 18 Sex：male
#关键字参数(age=10,name='rise')
user_info(age=10,name='rise') #Nmae: rise Age: 10 Sex：male
#默认参数(sex="male")
user_info("xiaohong",12,"madam") #Nmae: xiaohong Age: 12 Sex：madam

#-----sum() 方法对系列进行求和计算-----

语法 sum(iterable[, start])
参数
    1、iterable -- 可迭代对象，如：列表、元组、集合。
    2、start -- 指定相加的参数，如果没有设置这个值，默认为0。

#-----不定长参数使用(*args,**kwargs)-----

#-----加法器

def add(*args):
    print(args,type(args)) #((1, 2, 3, 4, 5) <class 'tuple'> #args是可迭代对象（元组）
    sum1 = sum(args)
    print(sum1)
add(1,2,3,4,5)

def print_info(name,age,**kwargs):
    print("Nmae: %s"% name)
    print("Age: %d" % age)
    for i in kwargs:
        print("%s:%s"% (i,kwargs[i]))

print_info("xiaohong",12,sex="madam",job="IT")

#结论：关于不定长参数位置：*args放在左边，**kargs 参数放在右边

def print_info(name,age,sex = "male",*args,**kwargs):
    print("Nmae: %s"% name)
    print("Age: %d" % age)
    print("Sex：%s" % sex)
    for i in args:
        print(i)
    for j in kwargs:
        print("%s:%s"% (j,kwargs[j]))

print_info("xiaohong",12,"madam",1,2,job="IT",learn="python")

#-----return-----

return作用
    1、结束函数
    2、返回某个对象

#-----注意问题：
    1、函数里如果没有return，会默认返回一个None
    2、如果return 多个对象，那么python会帮我们多个对象封装为成一个元组（返回一个对象）

def f():
    return 1
print(f()) #return 返回1（return返回给调用者）

def add(*args):
    print(args,type(args)) #((1, 2, 3, 4, 5) <class 'tuple'> #args是可迭代对象（元组）
    return sum(args)
print(add(1,2,3,4,5))

#-----作用域

#作用域：

    1、L: local，局部作用域，即函数中定义的变量
    2、E: enclosing,嵌套父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是全局作用域。
    3、G： globa 全局变量，模块级别定义的变量。
    4、B： built-in 系统固定模块里面的变量

作用域优先级：局部作用域>外部作用域>当前模块中的全局作用域>python内置作用域

count = 10
def outer():

    # print(count) #local variable 'count' referenced before assignment
    global count   #全局变量使用global 关键字
    print(count) #10
    count = 5
    print(count) #5
outer()

def outer():
    count = 10
    def inner():
        nonlocal count  #嵌套作用域变量使用nonlocal 关键字
        print(count) #10
        count = 20
        print(count) #20
    inner()
outer()

#-----高阶函数-----

#1、函数名可以进行赋值
#2、函数名可以作为参数，函数名还可以做为函数的返回值

def f(n):
    return n*n
def foo(a,b,f):
    return f(a)+f(b)
print(foo(2,3,f)) #13

def a():
    def b():
        return 6
    return b
ret = a()
print(ret()) # 6

#-----递归函数-----

#定义：在函数内部，可以调用其他函数。如果一个函数在内部调用自身（本身），这个函数就是递归。

#-----阶乘实例

def num1(n):
    ret = 1
    for i in range(1,n+1):
        ret = ret * i
    return ret
print(num1(4))

def num2(n):
    if n ==  1:
        return 1
    return n*num2(n-1)
print(num2(4))

#-----斐波那契数列1 1 2 3 5 8 13

def fibo(n):
    if n <= 1:
        return n
    return fibo(n-1)+fibo(n-2)

print(fibo(8))

def fi(n):
    before = 0
    after = 1
    for i in range(n-1):
        before,after = after,before+after
    return after
print(fi(6))

#-----内置函数-----

#-----filter过滤器

str = ['a','b','c']
def fun1(s):
    if s != 'a':
        return s

ret = filter(fun1,str)  #filter迭代器对象
print(list(ret)) #['b', 'c']

#-----map处理序列（拼接、修剪、删除）

str = ['a','b','c']
def fun1(s):
    if s != 'a':
        return s+'alvin'
ret = map(fun1,str) # 迭代器对象
print(list(ret)) #[None, 'balvin', 'calvin']

#-----reduce的结果就是一个值

from functools import reduce
def add1(x,y):
    return x + y

print(reduce(add1,range(1,101)))  #36  (1+2+3+4+5....+8+9)

#-----lambda匿名函数

add = lambda a,b : a+b
print(add(2,3)) #5