（转）函数作用域，匿名函数，函数式编程，面向过程，面向对象

函数作用域　　

 
          def 
          first(): 
         
          name  
          = 
          'Wangben' 
         
          def 
          second(): 
         
          name  
          = 
          'Mengtian' 
         
          def 
          third(): 
         
          print 
          (name) 
         
          return 
          third 
         
          return 
          second 
         
          first()()()     
          #打印输出Mengtian,每一个()相当于一个函数调用

"""
运行程序:
　　r1 = foo()
　　print(r1)
　　r2 = foo()()
　　print(r2)
　　r3 = foo()()()
　　print(r3)
输出结果:
　　<function foo.<locals>.bar at 0x0000017F85725AE8>　　　　　　　　只返回地址
　　<function foo.<locals>.bar.<locals>.tt at 0x0000017F857371E0>
　　wopeiqi
　　None
"""

匿名函数:

 1 """ 用 lambda 关键字定义 """
 2 
 3 lambda x:x+1        """x 为函数的形参，x+1 为函数的返回值 """
 4 
 5 """ 相当于"""
 6 def plus(x):
 7     return x+1

 1 """ 在没有把lambda赋给其他变量的情况下，其本身不知如何使用"""
 2 """ 因此一般与其他函数结合使用，要使用时要赋给其他变量"""
 3 
 4 name = 'zhizhi'
 5 
 6 func = lambda x:x + '_celebrate'
 7 
 8 print(func(name))
 9 
10 """得到""   
11     zhizhi_celebrate

1 """ 要返回多个值需要加 ()"""
2 
3 func = lambda x,y,z :( x+2,y**x,z/2)
4 
5 print(func(2,6,8))
6 
7 """ 得到 """
8     (4, 36, 9.0)

函数式编程，面向过程，面向对象：

　　egon09.blog.51cto.com/9161406/1842475　　该文章已经被博主隐藏 --_-- 伤心。。。

　　以下为原文（看着视频敲出来的，原文作者linhaifeng老师）：

　　介绍：

　　　　当下主流的编程方法有三种：函数式、面向过程、面向对象，三者相当于编程界的三大门派，每个门派有自己的独门秘籍，都是用来解决问题的。三种流派都是一种编程方法论，只不过是各自的风格不同，在不同的应用场景下也各显优势。

　　　　一、函数式编程：函数式=编程语言定义的函数+数学意义的函数

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

　　　　PART 1特征：

　　　　　　1. 不可变数据

　　　　　　2. 第一类对象

扫描二维码关注公众号，回复： 2742568 查看本文章

　　　　　　3. 尾调用优化（尾递归）

　　　　例一：不可变：不用变量保存状态，不修改变量

 1 #非函数式
 2 a = 1
 3 def incr_test1():
 4     global a
 5     a +=1
 6     return a 
 7 incr_test1()
 8 print(a)            　　 #---->得到 2
 9 
10 #函数式
11 n = 1
12 def incr_test2(n):
13     return n+1
14 
15 print(incr_test2(2))    #---->得到 3
16 
17 print(n)        　　　　　#---->得到 1

　　　　例二：第一类对象：函数即“变量”

　　　　　　1.函数名可以当作参数传递

　　　　　　2.返回值可以是函数名

　　　　高阶函数：

　　　　　　1.函数接受的参数是一个函数名（把函数当作参数传给另外一个函数）

　　　　　　2.返回值中包含函数

 1 #把函数当作参数传给另外一个函数
 2 
 3 def foo(n):
 4     print(n)
 5 
 6 def bar(name):
 7     print('my name is %s' %name)
 8 
 9 foo(2)        #----->2
10 foo(bar)     #-----><function bar at 0x0000018A7F895D90> 返回地址，因为不是运行函数
11 foo(bar('风云'))    #----> my name is 风云

 1 #返回值中包含函数
 2 
 3 def bar():
 4     print('from')
 5 def foo():
 6     print('from foo')
 7     return bar
 8 n = foo()
 9 n()
10 
11 #得到
12     from foo
13     from bar
14 #n()相当于foo()(),即运行了foo函数之后，返回的时bar函数，运行bar函数
15 
16 def test1():
17     print('from test1')
18 def test2():
19     print('from handle')
20     return test1()    #----->直接运行test1，相当于test1()
21 
22 
23 #得到
24     from handle
25     from test1

　　　　例三：

　　　　　　尾调用：在函数的最后一步调用另外一个函数（最后一行不一定是函数的最后一步）

#函数bar在foo内为尾调用
def bar(n):
    return n
def foo(x):
    return bar(x)
""" 例"""
a = foo(8)
print(a)    #---->得到 8


#函数bar和bar2在foo内均为尾调用，二者在if判断条件不同的情况下都有可能作为函数的最后一步
def bar1(n):
    return n

def bar2(n):
    return n+1
def foo(x):
    if type(x) is str:
        return bar1(x)
    elif type(x) is int:
        return bar2(x)

#函数bar在foo内为非尾调用
def bar(n):
    return n

def foo(x):
    y = bar(x)
    return y

#函数bar在foo内为非尾调用
def bar(n):
    return n
def foo(x):
    return bar(x)+1

转自：
Python 学习 --day-16 - UMRzg - 博客园
http://www.cnblogs.com/qinzheg/articles/9394420.html