"在Python中,函数本身也是对象"
这一本质.那不妨慢慢来,从最基本的概念开始,讨论一下这个问题：
① Python中一切皆对象
这恐怕是学习Python最有用的一句话.想必你已经知道Python中的list, tuple, dict等内置数据结构,当你执行：
时,你就创建了一个列表对象,并且用alist这个变量引用它：
当然你也可以自己定义一个类:
class House(object):
def __init__(self, area, city):
self.area = area
self.city = city
def sell(self, price):
[...] #other code
return price
然后创建一个类的对象：
和list, tuple, dict以及用House创建的对象一样,当你定义一个函数时,函数也是对象：
def func(a, b):
return a+b
在全局域,函数对象被函数名引用着,它接收两个参数a和b,计算这两个参数的和作为返回值.
所谓第一类对象,意思是可以用标识符给对象命名,并且对象可以被当作数据处理,例如赋值、作为参数传递给函数,或者作为返回值return 等
所以呢,你完全可以用其他变量名引用这个函数对象：
add = func
或者将函数对象作为参数,传递给另一个函数：
def caller_func(f):
if __name__ == "__main__":
print caller_func(func)
可以看到,
函数对象func作为参数传递给caller_func函数,传参过程类似于一个赋值操作f=func；
于是func函数对象,被caller_func函数作用域中的局部变量f引用,f实际指向了函数func；cc
无论是把函数赋值给新的标识符,还是作为参数传递给新的函数,针对的都是函数对象本身,而不是函数的调用.
用一个更加简单,但从外观上看,更容易产生混淆的例子来说明这个问题.例如定义了下面这个函数：
def func():
return "hello,world"
然后分别执行两次赋值：
ref1 = func #将函数对象赋值给ref1
很多初学者会混淆这两种赋值,通过Python内建的type函数,可以查看一下这两次赋值的结果：
Out[10]: False
传参的效果与之类似.
所谓闭包,就是将组成函数的语句和这些语句的执行环境打包在一起时,得到的对象
听上去的确有些复杂,还是用一个栗子来帮助理解一下.假设我们在foo.py模块中做了如下定义：
#foo.py
filename = "foo.py"
def call_func(f):
return f() #如前面介绍的,f引用一个函数对象,然后调用它
在另一个func.py模块中,写下了这样的代码：
#func.py
import foo #导入foo.py
filename = "func.py"
def show_filename():
return "filename: %s" % filename
print foo.call_func(show_filename) #注意：实际发生调用的位置,是在foo.call_func函数中
当我们用python func.py命令执行func.py时输出结果为：
filename:func.py
很显然show_filename()函数使用的filename变量的值,是在与它相同环境(func.py模块)中定义的那个.尽管foo.py模块中也定义了同名的filename变量,而且实际调用show_filename的位置也是在foo.py的call_func内部.
而对于嵌套函数,这一机制则会表现的更加明显：闭包将会捕捉内层函数执行所需的整个环境：
#enclosed.py
import foo
def wrapper():
filename = "enclosed.py"
print foo.call_func(show_filename) #输出：filename: enclosed.py
实际上,每一个函数对象,都有一个指向了该函数定义时所在全局名称空间的__globals__属性：
#show_filename inside wrapper
#show_filename.__globals__
{
'__builtins__': module '__builtin__' (built-in), #内建作用域环境
'__file__': 'enclosed.py',
'__package__': None,
'__name__': '__main__',
'foo': module 'foo' from '/home/chiyu/foo.pyc', #全局环境
'__doc__': None
}
当代码执行到show_filename中的return "filename: %s" % filename语句时,解析器按照下面的顺序查找filename变量：
Local - 本地函数(show_filename)内部,通过任何方式赋值的,而且没有被global关键字声明为全局变量的filename变量；
Enclosing - 直接外围空间(上层函数wrapper)的本地作用域,查找filename变量(如果有多层嵌套,则由内而外逐层查找,直至最外层的函数)；
Global - 全局空间(模块enclosed.py),在模块顶层赋值的filename变量；
Builtin - 内置模块(__builtin__)中预定义的变量名中查找filename变量；
在任何一层先找到了符合要求的filename变量,则不再向更外层查找.如果直到Builtin层仍然没有找到符合要求的变量,则抛出NameError异常.这就是变量名解析的：LEGB法则.
总结：
闭包最重要的使用价值在于：封存函数执行的上下文环境；
闭包在其捕捉的执行环境(def语句块所在上下文)中,也遵循LEGB规则逐层查找,直至找到符合要求的变量,或者抛出异常.
那么闭包和装饰器又有什么关系呢?
上文提到闭包的重要特性：封存上下文,这一特性可以巧妙的被用于现有函数的包装,从而为现有函数更加功能.而这就是装饰器.
还是举个例子,代码如下：
def lazy_sum():
return reduce(lambda x, y: x+y, alist)
我们定义了一个函数lazy_sum,作用是对alist中的所有元素求和后返回.alist假设为1到100的整数列表：
alist = range(1, 101)
但是出于某种原因,我并不想马上返回计算结果,而是在之后的某个地方,通过显示的调用输出结果.于是我用一个wrapper函数对其进行包装：
return lazy_sum
lazy_sum = wrapper() #wrapper() 返回的是lazy_sum函数对象
if __name__ == "__main__":
这是一个典型的Lazy Evaluation的例子.我们知道,一般情况下,局部变量在函数返回时,就会被垃圾回收器回收,而不能再被使用.但是这里的alist却没有,它随着lazy_sum函数对象的返回被一并返回了(这个说法不准确,实际是包含在了lazy_sum的执行环境中,通过__globals__),从而延长了生命周期.
当你需要动态的给已定义的函数增加功能时,比如：参数检查,类似的原理就变得很有用：
def add(a, b):
这是很简单的一个函数：计算a+b的和返回,但我们知道Python是 动态类型+强类型 的语言,你并不能保证用户传入的参数a和b一定是两个整型,他有可能传入了一个整型和一个字符串类型的值：
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
①. def add(a, b):
TypeError: unsupported operand type(s) for +: 'int' and 'str'
于是,解析器无情的抛出了一个TypeError异常.
动态类型：在运行期间确定变量的类型,python确定一个变量的类型是在你第一次给他赋值的时候；
强类型：有强制的类型定义,你有一个整数,除非显示的类型转换,否则绝不能将它当作一个字符串(例如直接尝试将一个整型和一个字符串做+运算)；
所以呢,为了更加优雅的使用add函数,我们需要在执行+运算前,对a和b进行参数检查.这时候装饰器就显得非常有用：
import logging
logging.basicConfig(level = logging.INFO)
return a + b
def checkParams(fn):
def wrapper(a, b):
if isinstance(a, (int, float)) and isinstance(b, (int, float)): #检查参数a和b是否都为整型或浮点型
return fn(a, b) #是则调用fn(a, b)返回计算结果
#否则通过logging记录错误信息,并友好退出
logging.warning("variable 'a' and 'b' cannot be added")
return
return wrapper #fn引用add,被封存在闭包的执行环境中返回
#将add函数对象传入,fn指向add
#等号左侧的add,指向checkParams的返回值wrapper
add = checkParams(add)
注意checkParams函数：
首先看参数fn,当我们调用checkParams(add)的时候,它将成为函数对象add的一个本地(Local)引用；
在checkParams内部,我们定义了一个wrapper函数,添加了参数类型检查的功能,然后调用了fn(a, b),根据LEGB法则,解释器将搜索几个作用域,并最终在(Enclosing层)checkParams函数的本地作用域中找到fn；
注意最后的return wrapper,这将创建一个闭包,fn变量(add函数对象的一个引用)将会封存在闭包的执行环境中,不会随着checkParams的返回而被回收；
当调用add = checkParams(add)时,add指向了新的wrapper对象,它添加了参数检查和记录日志的功能,同时又能够通过封存的fn,继续调用原始的add进行+运算.
WARNING:root:variable 'a' and 'b' cannot be added
有人觉得add = checkParams(add)这样的写法未免太过麻烦,于是python提供了一种更优雅的写法,被称为语法糖：
@checkParams
这只是一种写法上的优化,解释器仍然会将它转化为add = checkParams(add)来执行.
def addspam(fn):
def new(*args):
print "spam,spam,spam"
return fn(*args)
return new
@addspam
def useful(a,b):
首先看第二段代码：
@addspam装饰器,相当于执行了useful = addspam(useful).今天这一节题主有一个理解误区：传递给addspam的参数,是useful这个函数对象本身,而不是它的一个调用结果；
再回到addspam函数体：
return new 返回一个闭包,fn被封存在闭包的执行环境中,不会随着addspam函数的返回被回收；
而fn此时是useful的一个引用,当执行return fn(*args)时,实际相当于执行了return useful(*args)；
最后附上一张代码执行过程中的引用关系图,希望能帮助你理解：
Python 是一种解释型语言.这就是说,与C 语言和C 的衍生语言不同,Python 代码在运行之前不需要编译.其他解释型语言还包括PHP 和Ruby.
- Python 是动态类型语言,指的是你在声明变量时,不需要说明变量的类型.你可以直接编写类似x=111 和x="I'm a string"这样的代码,程序不会报错.
- Python 非常适合面向对象的编程（OOP）,因为它支持通过组合（composition）与继承（inheritance）的方式定义类（class）.
- Python 中没有访问说明符（access specifier,类似C++中的public 和private）,这么设计的依据是"大家都是成年人了".
- 在Python 语言中,函数是第一类对象（first-class objects）.这指的是它们可以被指定给变量,函数既能返回函数类型,也可以接受函数作为输入.类（class）也是第一类对象.
- Python 代码编写快,但是运行速度比编译语言通常要慢.好在Python 允许加入基于C语言编写的扩展,所以呢我们能够优化代码,消除瓶颈,这点通常是可以实现的.numpy 就是一个很好地例子,它的运行速度真的非常快,因为很多算术运算其实并不是通过Python 实现的.
- Python 用途非常广泛——网络应用,自动化,科学建模,大数据应用,等等.它也常被用作"胶水语言",帮助其他语言和组件改善运行状况.
- Python 让困难的事情变得容易,所以呢程序员可以专注于算法和数据结构的设计,而不用处理底层的细节.
黑马程序员含有全套的介绍,并且有和其他语言的对比.他们很多公开课也说过.我就是看黑马的课学的Python,祝好
Python 函数
函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段.
函数能提高应用的模块性,和代码的重复利用率.你已经知道Python提供了许多内建函数,比如print().但你也可以自己创建函数,这被叫做用户自定义函数.
定义一个函数
你可以定义一个由自己想要功能的函数,以下是简单的规则：
函数代码块以?def?关键词开头,后接函数标识符名称和圆括号().
任何传入参数和自变量必须放在圆括号中间.圆括号之间可以用于定义参数.
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明.
函数内容以冒号起始,并且缩进.
return [表达式]?结束函数,选择性地返回一个值给调用方.不带表达式的return相当于返回 None.
语法
def functionname( parameters ): ? "函数_文档字符串"
function_suite
return [expression]
默认情况下,参数值和参数名称是按函数声明中定义的顺序匹配起来的.
实例
以下为一个简单的Python函数,它将一个字符串作为传入参数,再打印到标准显示设备上.
def printme( str ): ? "打印传入的字符串到标准显示设备上"
print str
函数调用
定义一个函数只给了函数一个名称,指定了函数里包含的参数,和代码块结构.
这个函数的基本结构完成以后,你可以通过另一个函数调用执行,也可以直接从Python提示符执行.
如下实例调用了printme（）函数：
# 定义函数def printme( str ): ? "打印任何传入的字符串"
# 调用函数printme("我要调用用户自定义函数!")printme("再次调用同一函数")
以上实例输出结果：
我要调用用户自定义函数!再次调用同一函数
参数传递
在 python 中,类型属于对象,变量是没有类型的：
a="Runoob"
可更改(mutable)与不可更改(immutable)对象
在 python 中,strings, tuples, 和 numbers 是不可更改的对象,而 list,dict 等则是可以修改的对象.
python 函数的参数传递：
不可变类型：类似 c++ 的值传递,如 整数、字符串、元组.如fun（a）,传递的只是a的值,没有影响a对象本身.比如在 fun（a）内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身.
可变类型：类似 c++ 的引用传递,如 列表,字典.如 fun（la）,则是将 la 真正的传过去,修改后fun外部的la也会受影响
python 中一切都是对象,严格意义我们不能说值传递还是引用传递,我们应该说传不可变对象和传可变对象.
python 传不可变对象实例
def ChangeInt( a ): ? ?a = 10
传可变对象实例
# 可写函数说明def changeme( mylist ): ? "修改传入的列表"
print "函数内取值: ", mylist
实例中传入函数的和在末尾添加新内容的对象用的是同一个引用,故输出结果如下：
参数
以下是调用函数时可使用的正式参数类型：
必备参数
关键字参数
默认参数
不定长参数
必备参数须以正确的顺序传入函数.调用时的数量必须和声明时的一样.
调用printme()函数,你必须传入一个参数,不然会出现语法错误：
#可写函数说明def printme( str ): ? "打印任何传入的字符串"
#调用printme函数printme()
Traceback (most recent call last):
File "test.py", line 11, in module
printme()TypeError: printme() takes exactly 1 argument (0 given)
关键字参数和函数调用关系紧密,函数调用使用关键字参数来确定传入的参数值.
使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值.
以下实例在函数 printme() 调用时使用参数名：
#调用printme函数printme( str = "My string")
My string
下例能将关键字参数顺序不重要展示得更清楚：
#可写函数说明def printinfo( name, age ): ? "打印任何传入的字符串"
print "Name: ", name
print "Age ", age
调用函数时,默认参数的值如果没有传入,则被认为是默认值.下例会打印默认的age,如果age没有被传入：
def functionname([formal_args,] *var_args_tuple ): ? "函数_文档字符串"
加了星号（*）的变量名会存放所有未命名的变量参数.不定长参数实例如下：
# 可写函数说明def printinfo( arg1, *vartuple ): ? "打印任何传入的参数"
print "输出: "
print arg1
for var in vartuple: ? ? ?print var
匿名函数
python 使用 lambda 来创建匿名函数.
lambda只是一个表达式,函数体比def简单很多.
lambda的主体是一个表达式,而不是一个代码块.仅仅能在lambda表达式中封装有限的逻辑进去.
lambda函数拥有自己的命名空间,且不能访问自有参数列表之外或全局命名空间里的参数.
虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率.
lambda函数的语法只包含一个语句,如下：
如下实例：
return 语句
return语句[表达式]退出函数,选择性地向调用方返回一个表达式.不带参数值的return语句返回None.之前的例子都没有示范如何返回数值,下例便告诉你怎么做：
print "函数内 : ", total
return total
变量作用域
一个程序的所有的变量并不是在哪个位置都可以访问的.访问权限决定于这个变量是在哪里赋值的.
变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称.两种最基本的变量作用域如下：
全局变量
局部变量
全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域.
局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问.调用函数时,所有在函数内声明的变量名称都将被加入到作用域中.如下实例：
print "函数内是局部变量 : ", total