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

函数作用域　　

?

1 2 3 4 5 6 7 8 9 10

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
"""

匿名函数:

""" 用 lambda 关键字定义 """

lambda x:x+1        """x 为函数的形参，x+1 为函数的返回值 """

""" 相当于"""
def plus(x):
    return x+1

　

""" 在没有把lambda赋给其他变量的情况下，其本身不知如何使用"""
""" 因此一般与其他函数结合使用，要使用时要赋给其他变量"""

name = 'zhizhi'

func = lambda x:x + '_celebrate'

print(func(name))

"""得到""   
    zhizhi_celebrate

""" 要返回多个值需要加 ()"""

func = lambda x,y,z :( x+2,y**x,z/2)

print(func(2,6,8))

""" 得到 """
    (4, 36, 9.0)

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

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

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

　　介绍：

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

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

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

　　　　PART 1特征：

　　　　　　1. 不可变数据

　　　　　　2. 第一类对象

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

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

　　　　

#非函数式
a = 1
def incr_test1():
    global a
    a +=1
    return a 
incr_test1()
print(a)            　　 #---->得到 2

#函数式
n = 1
def incr_test2(n):
    return n+1

print(incr_test2(2))    #---->得到 3

print(n)        　　　　　#---->得到 1

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

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

　　　　　　2.返回值可以是函数名

　　　　高阶函数：

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

　　　　　　2.返回值中包含函数

#把函数当作参数传给另外一个函数

def foo(n):
    print(n)

def bar(name):
    print('my name is %s' %name)

foo(2)        #----->2
foo(bar)     #-----><function bar at 0x0000018A7F895D90> 返回地址，因为不是运行函数
foo(bar('风云'))    #----> my name is 风云

#返回值中包含函数

def bar():
    print('from')
def foo():
    print('from foo')
    return bar
n = foo()
n()

#得到
    from foo
    from bar
#n()相当于foo()(),即运行了foo函数之后，返回的时bar函数，运行bar函数

def test1():
    print('from test1')
def test2():
    print('from handle')
    return test1()    #----->直接运行test1，相当于test1()


#得到
    from handle
    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