python中指向函数 python变量指向对象

python中函数的作用

Python 函数定义以及参数传递

1.函数定义

#形如def func(args...):

doSomething123

以关键字def 开头python中指向函数，后面是函数名和参数下面是函数处理过程。

举例：

def add( a, b ):

return a+b12

参数可以设定默认值python中指向函数，如：

def add( a, b=10 ): #注意：默认值参数只会运算一次

return a+b12

默认值参数只会运算一次是什么意思python中指向函数？

def func( a, b=[] ): #bpython中指向函数的默认值指向一个空的列表，每次不带默认值都会指向这块内存

b.append(a) return b

print(func(1))#向默认的空列表里加入元素1 ，默认列表里已经是[1]print(func(2))#向默认的列表里加入元素2,默认列表里已经是[1,2]print(func(3,[]))#向b指向的空列表里加入元素1 ，默认列表里还是[1,2]print(func(4))#向默认的列表里加入元素4,默认列表里已经是[1,2,4]'''

结果：

[1]

[1, 2]

[3]

[1, 2, 4]

'''12345678910111213141516

这下明白为什么默认参数只计算一次python中指向函数了吧，函数参数不传递时默认值总是指向固定的内存空间，就是第一次计算的空间。

2.参数传递

def func(a, b):

print('a=%d, b=%d' % (a,b) )12

在使用函数时可以如下方式,结果都是相同的

func(10,20) #不使用参数名，需要按参数顺序传递func(a=10,b=20) #使用参数名可以不按顺序传递func(b=20,a=10)#结果：a=10, b=20a=10, b=20a=10, b=201234567

如果函数定义形式如下方式：

def func(*args): #这种定义会把传递的参数包成元组

print(args,type(args))

func(10,20)#结果：#(10, 20) class 'tuple'1234567

举一个和上述过程相反的例子：

def func(a,b):

print('a=%d, b=%d' % (a,b) )

a = (10, 20)

func(*a) #在调用函数使用`*`则会把元组解包成单个变量按顺序传入函数#结果：a=10, b=20123456

总结：*号在定义函数参数时，传入函数的参数会转换成元组，如果 *号在调用时则会把元组解包成单个元素。

另一种定义：

def func(**kw):#使用**定义参数会把传入参数包装成字典dict

print(kw, type(kw) )

func(a=10,b=20)#这种函数在使用时必须指定参数值，使用key=value这种形式#结果：{'b': 20, 'a': 10} class 'dict'12345

相反的例子：

def func(a,b):

print('a=%d, b=%d' % (a,b) )

d = {'a':10, 'b':20 }

func(**d) #在调用时使用**会把字典解包成变量传入函数。12345

def func(*args, **kw):#这种形式的定义代表可以接受任意类型的参数

print(args,kw )12

总结：**号在定义函数参数时，传入函数的参数会转换成字典，如果 **号在调用时则会把字典解包成单个元素。

lambda表达式

lambda表达式就是一种简单的函数

形如 f = lambda 参数1，参数2： 返回的计算值

例如：

add = lambda x,y: x+y

print(add(1,2))'''

结果：3

'''12345

相关问答

Q1: python 高阶函数有哪些

1、高阶函数

变量可以指向函数，函数的参数可以接收变量，那么函数可以接收另一个函数作为参数，这种函数称为高阶函数。

(1)把函数作为实参

(2)把函数作为返回值

2、系统的内置高阶函数

(1)map函数：接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并且把结果作为新的列表返回

(2)reduce函数：把一个函数作用到一个序列上，这个函数必须接收两个参数，reduce把结果和序列的下一个元素做累积计算

(3)filter函数：也接收一个函数和一个序列，和map函数不同的是，filter函数把传入的函数依次作用于每个元素，然后返回返回值是True的元素

(4)sorted函数：排序函数

把用户名按照首字母不区分大小写排序

(5)sorted()函数按照关键字排序

关键字：商品个数

(6)sorted()函数按照关键字排序，用键值来查找

(7)lambda匿名函数：有时候传参数时不需要显示自定义的函数，直接传入匿名函数更方便；冒号前面的x,y表示函数参数，匿名函数不需要担心函数名的冲突，匿名函数也是一个函数对象，可以把匿名函数赋值给一个变量，再利用变量来调用函数，匿名函数也可以作为返回值返回

3、高阶函数的应用：

(1)sorted函数：

(2)sorted函数默认是从小到大排序

4、装饰器

装饰器就是用来装饰函数的：想要增加原有函数的功能，但是不希望修改原有函数的定义，在代码运行期间动态增加功能的方式

(1)此装饰器的功能：计算函数的运行时间

import functools

@functools.wraps(f)   ##保留原有函数的属性

运行结果：

(2)此装饰器的功能：用户登录认证

运行结果：

(3)此装饰器的功能：认证用户的同时，显示用户的转账金额

import inspect

inspect.getcallargs()将传的参数封装为一个字典，字典的key值是形式参数，value值是实参

(4)此装饰器的功能：确保收到的每个参数都是整数，是整数就求和，否则抛出错误

(5)此装饰器的功能：给装饰器传参数，是整数和浮点数就求和

python学习网，大量的免费python视频教程，欢迎在线学习！

Q2: Python的函数都有哪些？

Python 函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

定义一个函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。

任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。

函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

函数内容以冒号起始，并且缩进。

return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

语法

def functionname( parameters ):   "函数_文档字符串"

  function_suite

  return [expression]

默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。

实例

以下为一个简单的Python函数，它将一个字符串作为传入参数，再打印到标准显示设备上。

实例(Python 2.0+)

def printme( str ):   "打印传入的字符串到标准显示设备上"

  print str

  return

函数调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。

如下实例调用了printme（）函数：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

# 定义函数def printme( str ):   "打印任何传入的字符串"

  print str

  return

# 调用函数printme("我要调用用户自定义函数!")printme("再次调用同一函数")

以上实例输出结果：

我要调用用户自定义函数!再次调用同一函数

参数传递

在 python 中，类型属于对象，变量是没有类型的：

a=[1,2,3]

a="Runoob"

以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。

可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

python 传不可变对象实例

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

def ChangeInt( a ):    a = 10

b = 2ChangeInt(b)print b # 结果是 2

实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。

传可变对象实例

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

# 可写函数说明def changeme( mylist ):   "修改传入的列表"

  mylist.append([1,2,3,4])

  print "函数内取值: ", mylist

  return

# 调用changeme函数mylist = [10,20,30]changeme( mylist )print "函数外取值: ", mylist

实例中传入函数的和在末尾添加新内容的对象用的是同一个引用，故输出结果如下：

函数内取值:  [10, 20, 30, [1, 2, 3, 4]]函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

参数

以下是调用函数时可使用的正式参数类型：

必备参数

关键字参数

默认参数

不定长参数

必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

调用printme()函数，你必须传入一个参数，不然会出现语法错误：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

#可写函数说明def printme( str ):   "打印任何传入的字符串"

  print str

  return

#调用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() 调用时使用参数名：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

#可写函数说明def printme( str ):   "打印任何传入的字符串"

  print str

  return

#调用printme函数printme( str = "My string")

以上实例输出结果：

My string

下例能将关键字参数顺序不重要展示得更清楚：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

#可写函数说明def printinfo( name, age ):   "打印任何传入的字符串"

  print "Name: ", name

  print "Age ", age

  return

#调用printinfo函数printinfo( age=50, name="miki" )

以上实例输出结果：

Name:  mikiAge  50

默认参数

调用函数时，默认参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

#可写函数说明def printinfo( name, age = 35 ):   "打印任何传入的字符串"

  print "Name: ", name

  print "Age ", age

  return

#调用printinfo函数printinfo( age=50, name="miki" )printinfo( name="miki" )

以上实例输出结果：

Name:  mikiAge  50Name:  mikiAge  35

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：

def functionname([formal_args,] *var_args_tuple ):   "函数_文档字符串"

  function_suite

  return [expression]

加了星号（*）的变量名会存放所有未命名的变量参数。不定长参数实例如下：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

# 可写函数说明def printinfo( arg1, *vartuple ):   "打印任何传入的参数"

  print "输出: "

  print arg1

  for var in vartuple:      print var

  return

# 调用printinfo 函数printinfo( 10 )printinfo( 70, 60, 50 )

以上实例输出结果：

输出:10输出:706050

匿名函数

python 使用 lambda 来创建匿名函数。

lambda只是一个表达式，函数体比def简单很多。

lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。

虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法

lambda函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

如下实例：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

# 可写函数说明sum = lambda arg1, arg2: arg1 + arg2

# 调用sum函数print "相加后的值为 : ", sum( 10, 20 )print "相加后的值为 : ", sum( 20, 20 )

以上实例输出结果：

相加后的值为 :  30相加后的值为 :  40

return 语句

return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，下例便告诉你怎么做：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

# 可写函数说明def sum( arg1, arg2 ):   # 返回2个参数的和."

  total = arg1 + arg2

  print "函数内 : ", total

  return total

# 调用sum函数total = sum( 10, 20 )

以上实例输出结果：

函数内 :  30

变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：

全局变量

局部变量

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

total = 0 # 这是一个全局变量# 可写函数说明def sum( arg1, arg2 ):   #返回2个参数的和."

  total = arg1 + arg2 # total在这里是局部变量.

  print "函数内是局部变量 : ", total

  return total

#调用sum函数sum( 10, 20 )print "函数外是全局变量 : ", total

以上实例输出结果：

函数内是局部变量 :  30函数外是全局变量 :  0

Q3: Python中变量名是标签，指向一块内存，函数名是不是也是这个道理？

是的。Python里应该大多数都是标签，指向一块内存的。比如说我定义一个a函数，单独输入函数名后也可以发现它是一个标签，指向了一块内存function a at 0x041CC6A8。

def a():

pass

a

function a at 0x041CC6A8

Q4: python有没有指针

如果您曾经使用过C或C ++等低级语言，那么您可能已经听说过指针。指针允许您在部分代码中创建高效率。它们也会给初学者带来困惑，并且可能导致各种内存管理错误，即使对于专家也是如此。那么在Python中有指针的存在吗？

指针广泛用于C和C ++。本质上，它们是保存另一个变量的内存地址的变量。有关指针的更新，可以考虑在C指针上查看此概述。

为什么Python没有指针？

实际上指针为何不存在的原因现在还不知道，也许指针违背了Python的禅宗。指针鼓励隐含的变化而不是明确的变化。但通常情况下，它们很复杂而不是很简单，特别是对于初学者。更糟糕的是，当他们用指针指向自己的方法，或做一些非常危险的事情，比如从你无法获取的的一些变量中读取数据。

Python更倾向于尝试从用户那里抽象出内存地址来实现具体细节，所以Python通常关注可用性而不是速度。因此，Python中的指针并没有多大意义。但是在有些情况下，Python会为您提供使用指针的一些好处。

想要理解Python中的指针，需要理解Python实现指针功能的具体细节。简单来说，需要了解这些知识点：

不可变对象和可变对象【Python中的对象】

Python变量/名称【Python中的变量】

【在Python中模拟实现指针】

Q5: Python 里为什么函数可以返回一个函数内部定义的函数

“在Python中，函数本身也是对象”

这一本质。那不妨慢慢来，从最基本的概念开始，讨论一下这个问题：

1. Python中一切皆对象

这恐怕是学习Python最有用的一句话。想必你已经知道Python中的list, tuple, dict等内置数据结构，当你执行：

alist = [1, 2, 3]

时，你就创建了一个列表对象，并且用alist这个变量引用它：

当然你也可以自己定义一个类:

class House(object):

def __init__(self, area, city):

self.area = area

self.city = city

def sell(self, price):

[...] #other code

return price

然后创建一个类的对象：

house = House(200, 'Shanghai')

OK，你立马就在上海有了一套200平米的房子，它有一些属性(area, city)，和一些方法(__init__, self)：

2. 函数是第一类对象

和list, tuple, dict以及用House创建的对象一样，当你定义一个函数时，函数也是对象：

def func(a, b):

return a+b

在全局域，函数对象被函数名引用着，它接收两个参数a和b，计算这两个参数的和作为返回值。

所谓第一类对象，意思是可以用标识符给对象命名，并且对象可以被当作数据处理，例如赋值、作为参数传递给函数，或者作为返回值return 等

因此，你完全可以用其他变量名引用这个函数对象：

add = func

这样，你就可以像调用func(1, 2)一样，通过新的引用调用函数了：

print func(1, 2)

print add(1, 2) #the same as func(1, 2)

或者将函数对象作为参数，传递给另一个函数：

def caller_func(f):

return f(1, 2)

if __name__ == "__main__":

print caller_func(func)

可以看到，

函数对象func作为参数传递给caller_func函数，传参过程类似于一个赋值操作f=func；

于是func函数对象，被caller_func函数作用域中的局部变量f引用，f实际指向了函数func；cc

当执行return f(1, 2)的时候，相当于执行了return func(1, 2)；

因此输出结果为3。

3. 函数对象 vs 函数调用

无论是把函数赋值给新的标识符，还是作为参数传递给新的函数，针对的都是函数对象本身，而不是函数的调用。

用一个更加简单，但从外观上看，更容易产生混淆的例子来说明这个问题。例如定义了下面这个函数：

def func():

return "hello,world"

然后分别执行两次赋值：

ref1 = func #将函数对象赋值给ref1

ref2 = func() #调用函数，将函数的返回值("hello,world"字符串)赋值给ref2

很多初学者会混淆这两种赋值，通过Python内建的type函数，可以查看一下这两次赋值的结果：

In [4]: type(ref1)

Out[4]: function

In [5]: type(ref2)

Out[5]: str

可以看到，ref1引用了函数对象本身，而ref2则引用了函数的返回值。通过内建的callable函数，可以进一步验证ref1是可调用的，而ref2是不可调用的：

In [9]: callable(ref1)

Out[9]: True

In [10]: callable(ref2)

Out[10]: False

传参的效果与之类似。

4. 闭包LEGB法则

所谓闭包，就是将组成函数的语句和这些语句的执行环境打包在一起时，得到的对象

听上去的确有些复杂，还是用一个栗子来帮助理解一下。假设我们在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

if __name__ == "__main__":

print foo.call_func(show_filename) #注意：实际发生调用的位置，是在foo.call_func函数中

当我们用python func.py命令执行func.py时输出结果为：

chiyu@chiyu-PC:~$ python 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"

def show_filename():

return "filename: %s" % filename

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',

'wrapper': function wrapper at 0x7f84768b6578, #直接外围环境

'__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规则逐层查找，直至找到符合要求的变量，或者抛出异常。

5. 装饰器语法糖(syntax sugar)

那么闭包和装饰器又有什么关系呢？

上文提到闭包的重要特性：封存上下文，这一特性可以巧妙的被用于现有函数的包装，从而为现有函数更加功能。而这就是装饰器。

还是举个例子，代码如下：

#alist = [1, 2, 3, ..., 100] -- 1+2+3+...+100 = 5050

def lazy_sum():

return reduce(lambda x, y: x+y, alist)

我们定义了一个函数lazy_sum，作用是对alist中的所有元素求和后返回。alist假设为1到100的整数列表：

alist = range(1, 101)

但是出于某种原因，我并不想马上返回计算结果，而是在之后的某个地方，通过显示的调用输出结果。于是我用一个wrapper函数对其进行包装：

def wrapper():

alist = range(1, 101)

def lazy_sum():

return reduce(lambda x, y: x+y, alist)

return lazy_sum

lazy_sum = wrapper() #wrapper() 返回的是lazy_sum函数对象

if __name__ == "__main__":

lazy_sum() #5050

这是一个典型的Lazy Evaluation的例子。我们知道，一般情况下，局部变量在函数返回时，就会被垃圾回收器回收，而不能再被使用。但是这里的alist却没有，它随着lazy_sum函数对象的返回被一并返回了(这个说法不准确，实际是包含在了lazy_sum的执行环境中，通过__globals__)，从而延长了生命周期。

当在if语句块中调用lazy_sum()的时候，解析器会从上下文中(这里是Enclosing层的wrapper函数的局部作用域中)找到alist列表，计算结果，返回5050。

当你需要动态的给已定义的函数增加功能时，比如：参数检查，类似的原理就变得很有用：

def add(a, b):

return a+b

这是很简单的一个函数：计算a+b的和返回，但我们知道Python是 动态类型+强类型 的语言，你并不能保证用户传入的参数a和b一定是两个整型，他有可能传入了一个整型和一个字符串类型的值：

In [2]: add(1, 2)

Out[2]: 3

In [3]: add(1.2, 3.45)

Out[3]: 4.65

In [4]: add(5, 'hello')

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

/home/chiyu/ipython-input-4-f2f9e8aa5eae in module()

---- 1 add(5, 'hello')

/home/chiyu/ipython-input-1-02b3d3d6caec in add(a, b)

1 def add(a, b):

---- 2 return a+b

TypeError: unsupported operand type(s) for +: 'int' and 'str'

于是，解析器无情的抛出了一个TypeError异常。

动态类型：在运行期间确定变量的类型，python确定一个变量的类型是在你第一次给他赋值的时候；

强类型：有强制的类型定义，你有一个整数，除非显示的类型转换，否则绝不能将它当作一个字符串(例如直接尝试将一个整型和一个字符串做+运算)；

因此，为了更加优雅的使用add函数，我们需要在执行+运算前，对a和b进行参数检查。这时候装饰器就显得非常有用：

import logging

logging.basicConfig(level = logging.INFO)

def add(a, b):

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，被封存在闭包的执行环境中返回

if __name__ == "__main__":

#将add函数对象传入，fn指向add

#等号左侧的add，指向checkParams的返回值wrapper

add = checkParams(add)

add(3, 'hello') #经过类型检查，不会计算结果，而是记录日志并退出

注意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进行+运算。

因此调用add(3, 'hello')将不会返回计算结果，而是打印出日志：

chiyu@chiyu-PC:~$ python func.py

WARNING:root:variable 'a' and 'b' cannot be added

有人觉得add = checkParams(add)这样的写法未免太过麻烦，于是python提供了一种更优雅的写法，被称为语法糖：

@checkParams

def add(a, b):

return a + b

这只是一种写法上的优化，解释器仍然会将它转化为add = checkParams(add)来执行。

6. 回归问题

def addspam(fn):

def new(*args):

print "spam,spam,spam"

return fn(*args)

return new

@addspam

def useful(a,b):

print a**2+b**2

首先看第二段代码：

@addspam装饰器，相当于执行了useful = addspam(useful)。在这里题主有一个理解误区：传递给addspam的参数，是useful这个函数对象本身，而不是它的一个调用结果；

再回到addspam函数体：

return new 返回一个闭包，fn被封存在闭包的执行环境中，不会随着addspam函数的返回被回收；

而fn此时是useful的一个引用，当执行return fn(*args)时，实际相当于执行了return useful(*args)；

最后附上一张代码执行过程中的引用关系图，希望能帮助你理解：

python中指向函数的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于python变量指向对象、python中指向函数的信息别忘了在本站进行查找喔。