Python嵌套、递归、高阶函数

一、嵌套函数

　　1、嵌套函数简单的理解可以看作是在函数的内部再定义函数，实现函数的“私有”。

　　2、特点：

　　　　　　<1> 函数内部可以再次定义函数。

　　　　　　<2> 只有被调用时才会执行(外部函数被调用后，被嵌套函数调用才有效)。

　　3、实例如下：

#！/usr/bin/env python3
#-*- coding:utf-8 -*-
 
def func1():
    print('hello world!')
    def func2():
        print('everyone...')
 
func1() # 输出：hello world! ，此时func2未被调用并不执行

　　4、然而嵌套函数并一定就是长这样，不信，继续往下看...

　　　　为了更直观，我直接放出几种情形的案例，如下：

 #！/usr/bin/env python3
 #-*- coding:utf-8 -*-
 
 #情形1
 name = 'cc'
 def func1():
     name = 'sc'
     print(name)
     def func2():
         #name = 'df'
         print(name)
     func2()
 func1() #输出：sc  df，当第10行被注释时，输出：sc  sc，
         # 嵌套函数中的变量层层调用，当前函数中没有便向上一级函数查找
 
 #情形2
 age = 21
 def func1():
     def func2():
         print(age) #输出：18，当前函数中并没有定义（‘第二层局部变量’）age，向第一层找
     age = 18 #与func2位于同一层，‘第一层局部变量’
     func2()
 print(func1(),age)  #输出：None ,21，此时，函数外输出的age只能是全局变量
 
 #情形3
 age = 21
 def func1():
     def func2():
         print(age)
     func2()
     #age = 18
 func1() #当31行不被注释时，运行会报错，打印age时会混淆全局age和局部age；
         #当31行被注释时，输出： 21，此时func2调用全局age
 
 #情形4
 age = 21
 def func1():
     global age #声明全局变量
     def func2():
         print('func2中的：',age) #输出>>func2中的： 21, age此时引用的是36行的全局变量
     func2()
     age = 18 #由于已经声明age是全局变量，所以此处的重新赋值就是对全局修改
 func1()
 print('全局中的：',age)  #输出>>全局中的： 18, 变量age在函数func1中被修改
 
 #情形5
 age = 21
 def func1():
     global age
     def func2():
         print('func4中的：',age) #输出>>func2中的： 18,  age此时引用的是47行的全局变量
     age = 18  #由于已经声明age是全局变量，所以此处的重新赋值就是对全局修改
     func2()
 func1()
 print('全局中的：',age) #输出>>全局中的： 18， 变量age在函数func1中被修改

'''
    情形4和情形5的区别在于age变量的修改在程序中的执行顺序，在func2调用前还是在func2调用之后，
如果是在func2调用前修改age,则func2中输出的则是修改后的；如果是在func2调用后修改age,则func2中
输出的就是未修改时的全局变量age,所以两者func2函数中输出的age值不同，但最后的全局输出相同。
'''

二、递归函数

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

　　2、实例：　　

def calc(n):
    n = n // 2
    print(n)  # 输出：9 4 2 1 0 0 0 .... //到1000层结束调用
    calc(n)  # 重复调用自身
 
calc(19) 

　　　查看默认调用层次的方法:

# -*-coding:utf-8 -*-
import sys 
 
print(sys.getrecursionlimit())  #查看递归默认限制层数，默认是1000

　　3、递归调用的过程

#递归的执行过程
def func_re(n):
    n = n // 2  # 地板除，商保留整数
    print(n)
    if n > 0:
        func_re(n)
    print(n)
func_re(13)
'''
python中递归执行的逻辑是一层层调用，再一层层退出，可通过调试断点查看
6
3
1
0
0
1
3
6
'''

　　4、到这里，我们可以总结下递归的特性了：

　　　　<1> 必须要有明确的终止条件

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

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

　　5、了解了递归调用的过程，那么如果我不想它一直调用下去，而是满足某一条件就返回，不再执行了呢？该怎么做呢？

　　　　实例如下：

def calc(n,count):
    '''
    :param n: 需要进行递归的对象
    :param count: 计数器
    :return: 条件不成立时，返回最终值
    '''
    print(n,count)
    if count < 5: #运行第五次时退出
        return calc(n//2,count+1) #每一层接收它下一层的值，return必不可少，否则倒数第三层无法接收倒数第二层的返回值
    else:
        return n # 最终结果返回到倒数第二层(即上一个return)，只执行一次
func = calc(199,1)
print('res运算第五次时的结果：',func) # 输出>>res运算第五次时的结果： 12.4375

　　　　当然，递归的用处不止于此，二分查找就是递归很好的应用：

data1 = [1,23,43,54,654,4544,34523]
def search(data1,find_num):
    print(data1)
    if len(data1) > 1:
        middle = len(data1)//2
        if data1[middle] == find_num:
            print('找到了',data1[middle])
        elif data1[middle]>find_num:
            print('要找的数在%s左边'%data1[middle])
            return search(data1[middle],find_num)
        else:
            print('要找的数在%s右边'%data1[middle])
            return search(data1[middle], find_num)
    else:
        if data1[0] == find_num:
            print('找到了',data1[0])
        else:
            print('你要找的数不在列表中')
search(data1,54)

三、高阶函数

　　1、定义：变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，

　　　　　　　这种函数称之为高阶函数。
 
　 2、满足高阶函数的条件（任意一个）：
　　　　<1> 接受一个或多个函数作为输入
　　　　<2> return 返回另外一个函数
　3、实例如下:

#！/usr/bin/env python3
#-*- coding:utf-8 -*-
 
# 接受一个或多个函数作为输入
def func(a,b):
    return a-b
 
def func2(x):
    return x
 
f = func2(func)
print(f(5,2))  #
 
# reyurn 返回另外一个函数
def func3(a,b):
    return abs,a,b # abs为内置方法
 
res = func3(3,-5)
print(res) # 输出：(<built-in function abs>, 3,-5)，一个元组
print(res[0](res[1]+res[2])) #输出：2