第四章 函数之高级函数

4.4 函数小高级

1. 函数名作为变量

   • 带括号就执行函数，返回函数返回值；不加括号指向函数地址，函数不执行

   • 函数可以作为字典的键值，可以作为键

   # 典例一
   def func():
       print(123)    
   v1 = func   # func函数不执行
   func    # func函数不执行
   v1（）    # 执行func函数
   ​
   # 典例二
   def func():
       print(123)    
   v1 = func() # func函数返回值
   func()  # 执行func函数
   print(v1)   # None
   def func():
       print(123)
       
   func_list = [func, func, func]  # func_list为三个func函数地址
   func_list = [func(), func(), func()]    # [None, None, None]
   # func_list[0]()
   # func_list[1]()
   # func_list[2]()
   for item in func_list:
       v = item()  #123    循环3次
       print(v)    #None
   def func():
       print(123)
   ​
   def bar():
       print(666)
   ​
   info = {'k1': func, 'k2': bar}
   ​
   info['k1']()    # 执行函数func  123
   info['k2']()    # 执行函数bar   666
   def func():
       return 123
   ​
   func_list1 = [func,func,func]
   func_list2 = [func(),func(),func()]
   ​
   print(func_list1)   #func()函数地址 * 3
   print(func_list2)   # 123 123 123
   ​
   info = {
       'k1':func,
       'k2':func(),
   }
   print(info) # {'k1': <function func at 0x000001D5315DDA60>, 'k2': 123}

    

2. 函数可以当作参数进行传递

   • 当参数时有（），得到返回值；当参数时无（），得到函数地址

   def func(arg):
       print(arg)
       
   func(1) # 执行func    1
   func([1,2,3,4]) # 执行func    [1,2,3,4]
   ​
   def show():
       return 999
   func(show)  # show不执行 指向函数地址
   func(show())    # show执行    999
   def func(arg):
       v1 = arg()#函数show执行 v1为函数show返回值
       print(v1)
       
   def show():
       print(666)#输出666
       
   func(show)#指向函数show地址不执行
   def func(arg):
       v1 = arg()
       print(v1)
       
   def show():
       print(666)
       
   result = func(show)#result为函数func的返回值
   print(result)

    

3. 数据类型中的方法到底有没有返回值？

   • 无返回值

     v = [11,22,33]
     v.append(99) # 无返回值

   • 仅有返回值：

     v = "alex"
     result = v.split('l')
     ​
     v = {'k1':'v2'}
     result1 = v.get('k1')
     result2 = v.keys()

   • 有返回+修改数据

     v = [11,22,33]
     result = v.pop()

   • 常用需要记住

     • str 字符串的所有方法基本上都是返回值为新值

       • strip，返回字符串

       • split，返回列表

       • replace，返回字符串

       • join，返回字符串。

     • list 列表所有方法基本上都是返回值None

       • append，无

       • insert，无

       • pop，返回要删除的数据

       • remove，无

       • find/index，返回索引的位置。

     • dict

       • get ，返回指定键值

       • keys，返回所有键

       • values，返回所有值

       • items，返回所有键值对

4. 函数内部的数据是否会混乱。

   • 函数内部执行相互之间不会混乱

   • 执行完毕 + 内部元素不被其他人使用 => 销毁

4.5 函数中高级

1. 函数做返回值

   • 就找函数何时被谁创建

   def func():
       print(123)  #输出123
   def bar():
       return fun  #返回函数fun
   v = bar()   #执行函数bar()
   v() # 执行函数func()
   name = 'oldboy'
   def func():
       print(name)
   def bar():
       return func
   v = bar()
   v() # oldboy
   def bar():
       def inner():
           print(123)
       return inner
   v= bar() 
   v() # 123
   name = 'oldboy'
   def bar():
       name = 'alex'
       def inner():
           print(name)
       return inner
   v = bar()
   v() # alex
   name = 'oldboy'
   def bar(name):
       def inner():
           print(name)
       return inner
   v1 = bar('alex')
   v2 = bar('eric')
   v1()    # alex
   v2()    # eric
   # 示例一
   name = 'alex'
   def base():
       print(name)   
   def func():
       name = 'eric'
       base()
   func()  # alex
   ​
   # 示例二
   name = 'alex'
   def func():
       name = 'eric'
       def base():
           print(name)
       base()   
   func()  # eric
   ​
   # 示例三
   name = 'alex'
   def func():
       name = 'eric'
       def base():
           print(name)
       return base 
   base = func()
   base()  # eric

2. 闭包

   • 闭包概念：为函数创建一块区域并为其维护自己数据，以后执行时方便调用。

   • 闭包应用场景：装饰器、SQLAlchemy源码

   • a函数里面有b函数,并且返回值为b函数（b函数只被调用，没被执行；b函数引用a函数的变量）

   　　   def func(name):
              def inner():
                 print(name)
         return inner 
   ​
   　　  v1 = func('alex') # 执行func（）函数值为alex，返回inner
        v1()    #执行inner（）函数，输出alex
        v2 = func('eric')
        v2()

3. 高阶函数

   • 把函数当做参数传递

   • 把函数当做返回值

   • 对函数进行复制

4. 递归

   • 含义：函数自己调自己(效率低)

     def func():
         print(1)
         func()
         
     func()
     ​
     # 示例
     def func(i):
         print(i)
         func(i+1)
         
     func(1)   # 1,2,3---988报错，死循环

   • 斐契那波数列(有限制)

     def func(a,b):
         # 1
         # 1
         # 2
         # 3 
         # 5 
         print(b) 
         func(b,a+b)
         
     func(0,1)

   • 递归函数返回值

     # 示例一
     def func(a):
         if a == 5:
             return 100000
         result = func(a+1) + 10
         return result 
     ​
     v = func(1)
     print(v)    #  10040
     ​
     # 示例二
     def func(a):
         if a == 5:
             return 100000
         result = func(a+1) + 10
     ​
     v = func(1)
     ​
     name = 'alex'
     def func():
         def inner():
             print(name)
          return inner
     v =func()

      

5. 总结

   • 函数执行的流程分析（函数是由谁创建的）

     def base():
         return i 
     ​
     def func(arg):
         def inner():
             return arg
         return inner
     ​
     base_list = [] # [base,base,]
     func_list = [] # [由第一次执行func函数的内存地址，内部arg=0 创建的inner函数，有arg=1的inner函数 ]
     for i in range(10): # i = 0 ，1
         base_list.append(base)
         func_list.append(func(i))
         
     

     # 1. base_list 和 func_list中分别保存的是什么？
     """
     base_list中存储都是base函数。
     func_list中存储的是inner函数，特别要说的是每个inner是在不同的地址创建。
     """
     # 2. 如果循环打印什么？
     for item in base_list:
         v = item() # 执行base函数
         print(v) # 都是9
     for data in func_list:
         v = data()
         print(v) # 0 1 2 3 4