python 前向引用，递归，变量的作用域，函数编程，匿名函数（lambda）

一、前向引用

def foo():
    print('from foo')
    bar()
foo() #name 'bar' is not defined
def bar():
    print('from bar')

在定义foo（）函数之后bar（）函数定义之前会报错，因为调用foo（）函数的时候bar还未定义。

def foo():
    print('from foo')
    bar()

def bar():
    print('from bar')

foo()

在定义foo（）和bar（）之后调用foo（），虽然foo（）定义在bar（）之前，且调用了bar（），但是在python中，若不执行函数，函数并不会执行，且在调用之前已经定义了bar（），所以不会报错，这就是前向引用。

二、递归

在函数中调用自身的方式叫做递归。

递归特性：

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

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

3.递归效率不高，递归层数过多会导致溢出（在计算机中，函数调用时通过栈实现的，每进入一个函数调用，栈就会再加一层，每当函数返回或结束，栈就会减少一层，由于栈的大小并不是无限的，所以，调用次数过多会导致堆栈溢出。）

#递归
def calc(n):
     print(n)
     if int(n / 2) == 0:
         return n
     return calc(n / 2)
 calc(10)

三、变量的作用域

def a():
    name = 'a'
    def b():
        name = 'b'
        def c():
            print(name)
        return c
    return b
var = a()
var()()
#定义域：name输出的b，输出的变量会向上一级寻找，直到找到相同名字的变量。

python中，变量的作用域为当前函数或者当前函数所包含的函数范围，调用某个变量时，若该变量所处的函数没有定义此变量，则会向该函数的上一层函数寻找，知道找到该变量为止。

四、函数式编程

通俗的说，函数式就是编程语言去实现数学函数，这种函数内，对象是永恒不变的，要么参数是函数，要么返回值是函数，没有for和while的循环，所有的循环都由递归实现，无变量的赋值。

def cal(x):
     return 2 * x + 1

五、匿名函数（lambda）

def calc(x):
    return x + 1
res = calc(10)
print(res)
#相当于
print(lambda x : x + 1)#打印的为内存地址<function <lambda> at 0x02AE4660>
func = lambda x : x + 1
print(func(10))
#这种用法只适合于lambada独立存在时候使用，适合于简单的计算。
name = 'a'#a改成ab
f = lambda x : x + "b"
print(f(name))

python中，在某种程度上来说，函数也可被被当做一种变量。

def foo(n):
     print(n)

def bar():
     print("bar()")
     return 1
def test():
     return bar

foo(bar)#打印是bar函数的内存地址
foo(bar())#打印的是bar的返回值。
foo(test()())#打印的是1
#test()将bar的内存地址返回，加上()后悔执行bar(),foo()会将bar的返回值1打印出来

高阶函数：

满足如下两个特性则为高阶函数。

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

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

匿名函数的部分使用：

1.map

num = [1,2,3]
def map_test(func,array):
    ret = []
    for i in num:
        res = func(i)
        ret.append(res)
    return  ret

print(map_test(lambda x:x+1,num))
#相当于
map(lambda x:x+1,num)#返回值是列表所存放的内存地址

map会对序列中的每个元素进行处理，返回的是列表的内存地址，在改地址中存放的元素顺序和原来的一模一样。

2.filter

def filter_t(func,array):
    ret = []
    for p in array:
        if not func(p):
            ret.append(p)
    return ret
filter_t(lambda n : n.startswith('a'),ab)
#相当于
filter(lambda n : n.startswith('a'),ab)

filter遍历序列中的每个元素，按照条件判断每个元素是否符合，若结果为True则保留，最后返回的和map的返回一样。

3.reduce

num_l = [1,2,3,100]
def reduce_t(func,array,init = None):
    if init is None:
        res = array.pop(0)
    else:
        res = init
    for num in array:
        res = func(res,num)
    return  res
reduce(lambda  x,y:x + y ,num_l)
#相当于
reduce_t(lambda x,y:x*y,num_l)