三、函数+

一、函数可以当作数据传递

1、可以被引用

2、可以被当作参数传递

3、返回值可以是函数

4、可以当作容器类型的元素

二、函数嵌套

1、嵌套定义

def aaa():
    def bbb():
        def ccc():
            print('hello')
　　　　　ccc()
　　bbb()

2. 嵌套调用

def max(x,y):
    return x if x > y else y

def max4(a,b,c,d):
    res1=max(a,b)
    res2=max(res1,c)
    res3=max(res2,d)
    return res3
print(max4(1,2,3,4))

 三、局部变量与全局变量

1. 函数内部使用变量名时，现在函数内部找局部变量，如果内部没有局部变量，再使用全局变量

    局部变量名和全局变量名相同时，修改局部变量值，全局变量不变

name='hao'
def change_name():
    name='quan'
    print(name)
change_name()
print(name)
    
quan
hao

2. 当定义局部变量时，全面加global，则会同时改变全局变量值

　nonlocal

name='hao'
def change_name():
    global name
    name='quan'
    print(name)
change_name()
print(name)

quan
quan

 nonlocal

num=5
def outer():
    num=8
    def innn():
        num = 10
        def inner():
            nonlocal num   # nonlocal关键字声明同时改变上一层变量值
            num = 100
            print(num)
        inner()
        print(num)
    innn()
    print(num)
outer()    
print(num)

100
100
8
5

3. 前向引用

def aaa():
    print('hello')
    bbb()
#报错，在调用函数bbb前必须先定义

def aaa():
    print('hello')
    bbb()
def bbb():
    print('everyone')
aaa()

#aaa在调用bbb时bbb还没有定义，但是在执行aaa之前已经定义，故不会报错

def aaa():
    print('hello')
    
def bbb():
    print('everyone')
    aaa()
bbb()

四、函数嵌套及作用域

name='alex'
def name1():
    name='alex1'
    def name2():
        name='alex2'
        print(name)
    name2()
    print(name)
    
name2()
print(name)

#函数name2是在name1中定义的，不可以直接调用name2

name='alex'
def foo():
    name='lhf'
    def bar():
        name='wu'
        def tt():
            print(name)
        return tt
    return bar

foo()()()


运行结果:
wu
#函数tt内没有给定变量name的值，则使用时向外一层寻找name值
#执行函数时使用foo()()()，foo()调用函数foo得到返回值bar，此时再加一对括号才能完成调用函数bar，得到返回值tt，再加括号调用函数tt

五、递归调用

　　递归特性:

　　　　1. 必须有一个明确的结束条件

　　　　2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

　　　　3. 递归效率不高，递归层次过多会导致栈溢出

def cal(n):
    print(n)
    if int(n/2)==0:
        return n
    return cal(int(n/2))
cal(10)

10
5
2
1
#当n=1时，if语句为真，执行return n，不再运行后面的语句

 六、匿名函数 lambda

calc=lambda x,y:x+x*y
print(calc(5,2))

15

res=map(lambda x:x**2,[1,2,3,4,5])
print(list(res))

[1,4,9,16,25]

七、高阶函数

　　　满足以下两个特性任意一个即为高阶函数：

　　　　1.函数的传入参数是一个函数名

　　　　2.函数的返回值是一个函数名

1. map函数

　　map（函数，可迭代对象）

　　　　将可迭代对象中每个元素取出来，进行函数运算，得到新的可迭代对象

def func(x):
    return x**2
aa=[1,2,3,4]
print(list(map(func,aa)))  #map返回的是内存地址，需使用list

#一步到位
print(list(map(lambda x:x**2,[1,2,3,4])))

2. reduce函数

　　reduce（函数，可迭代对象，默认值）

　　　　数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 （有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用  函数　　　　运算，最后得到一个结果，如果指定了默认值，默认值也参与运算

from functools import reduce
aaa=[1,2,3,4]
print(reduce(lambda x,y:x+y,aaa,50))

#60

from functools import reduce
aaa=[1,2,3]
print(reduce(lambda x,y:x*2+y,aaa,5))

运行结果：51
5*2+1=11
11*2+2=24
24*2*3=51

3. filter函数

　　filter（函数，可迭代对象）

　　依次取出可迭代对象的元素，用前面函数的逻辑判断true/false，返回判断为true的元素

aaa=['ahsug','dghud','asdf','sdgd']
print(list(filter(lambda x:x.startswith('a'),aaa)))

['ahsug','asdf']

name_dic=[
    {'name':'alex','age':1000},
    {'name':'wupeiqi','age':10000},
    {'name':'yuanhao','age':9000},
    {'name':'linhaifeng','age':18},
]

def func(x):
    age_list=[1000,10000,9000]
    return x['age'] not in age_list


res=filter(func,name_dic)
for i in res:
    print(i)

res=filter(lambda x:x['age'] == 18,name_dic)
for i in res:
    print(i)

{'name':'linhaifeng','age':18}
{'name':'linhaifeng','age':18}