python: 函数详解

def square(x): return x**2

>>> square <function square at 0x031AA230> >>> dir(square) ['__call__', '__class__', '__closure__','__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__','__get__', '__getattribute__', '__globals__', '__hash__', '__init__','__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__','__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'func_closure','func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals','func_name'] >>>

其中,一些重要的函数属性包括以下几个:

1. __doc__返回指定函数的文档字符串。

def square(x): """return square of givennumber""" return x**2 >>> square.__doc__ 'return square of given number'

2. __name__返回函数名字。

def square(x): """return square of givennumber""" return x**2 >>> square.func_name 'square'

3. __module__返回函数定义所在模块的名字。

def square(x): """return square of givennumber""" return x**2 >>> square.__module__ '__main__'

4. func_defaults返回一个包含默认参数值的元组,默认参数将在后文进行讨论。

5. func_globals返回一个包含函数全局变量的字典引用。

def square(x): """return square of givennumber""" return x**2 >>> square.func_globals {'__builtins__': <module '__builtin__'(built-in)>, '__name__': '__main__', 'square': <function square at0x10f099c08>, '__doc__': None, '__package__': None}

6. func_dict返回支持任意函数属性的命名空间。

def square(x): """return square of givennumber""" return x**2 >>> square.func_dict {}

7. func_closure返回一个胞体元组,其中胞体包含了函数自由变量的绑定,闭包将在后文讨论。

函数可以作为参数传递给其他函数。这些以其他函数作为参数的函数通常称为更高阶函数,这就构成了函数式编程中一个非常重要的部分。高阶函数一个很好的例子就是map函数,该函数接受一个函数和一个迭代器作为参数,并将函数应用于迭代器中的每一项,最后返回一个新的列表。我们将在下面的例子中演示这一点,例子中将前面定义的square函数和一个数字迭代器传递给map函数。

>>> map(square, range(10)) [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 此外,函数也可以在其他函数代码块内部定义,同时也能从其他函数调用中返回。 def outer(): outer_var = "outer variable" def inner(): return outer_var return inner

在上面的例子中,我们在函数outer中定义了另一个函数inner,并且当函数outer执行时将返回inner函数。此外,像任何其他Python对象一样,函数也可以赋值给变量,如下所示:

def outer(): outer_var = "outer variable" def inner(): return outer_var return inner >>> func = outer() >>> func <function inner at 0x031AA270> >>>

在上面的例子中,outer函数被调用时将会返回一个函数,并将返回的函数赋值给变量func。最后,该变量就可以像被返回的函数一样被调用:

>>> func() 'outer variable'

函数定义

关键字def用于创建用户自定义函数,函数定义就是一些可执行的语句。

def square(x): return x**2

在上面的square函数中,当包含该函数的模块加载到Python解释器中时,或者如果该函数在Python REPL中定义,那么将会执行函数定义语句def square(x)。然而,这对以可变数据结构作为值的默认参数有一些影响,这一点我们将会在后文讲述。函数定义的执行会绑定当前本地命名空间中的函数名(可以将命名空间当作名字到值的一种映射,并且这种映射还可以嵌套,命名空间和范围会在另一个教程中详细介绍)到一个函数对象,该对象是一个对函数中可执行代码的包装器。这个函数对象包含了一个对当前全局命名空间的引用,而当前命名空间指该函数调用时所使用的全局命名空间。此外,函数定义不会执行函数体,只有在函数被调用时才会执行函数体。

函数调用参数

除了正常的参数之外,Python函数还支持数量可变的参数。这些参数有主要有下面描述的三种类别:

1. 默认参数值:这允许用户为函数的参数定义一些默认值。这种情况下,可以以更少的参数来调用该函数,而函数调用时未提供的参数,Python会使用默认提供的值作为这些参数值。下面的例子展示了这种用法:

def show_args(arg, def_arg=1, def_arg2=2): return "arg={}, def_arg={}, def_arg2={}".format(arg, def_arg,def_arg2)

上面例子函数的定义中,包含一个正常位置的参数arg和两个默认参数def_arg和def_arg2。该函数可以以下面中的任何一种方式进行调用:

(1)只提供非缺省位置参数值。在本例中,缺省参数取默认值:

def show_args(arg, def_arg=1, def_arg2=2): return "arg={}, def_arg={}, def_arg2={}".format(arg, def_arg,def_arg2) >>> show_args("tranquility") 'arg=tranquility, def_arg=1, def_arg2=2'

(2)用提供的值覆盖一些默认的参数值,包括非缺省位置参数:

def show_args(arg, def_arg=1, def_arg2=2): return "arg={}, def_arg={}, def_arg2={}".format(arg, def_arg,def_arg2) >>> show_args("tranquility", "to Houston") 'arg=tranquility, def_arg=to Houston, def_arg2=2'

(3)为所有参数提供值,可以用这些值覆盖默认参数值:

def show_args(arg, def_arg=1, def_arg2=2): return "arg={}, def_arg={}, def_arg2={}".format(arg, def_arg,def_arg2) >>> show_args("tranquility", "to Houston","the eagle has landed") 'arg=tranquility, def_arg=to Houston,def_arg2=the eagle has landed'

当使用可变的默认数据结构作为默认参数时,需要特别小心。因为函数定义只执行一次,所以这些可变的数据结构(引用值)只在函数定义时创建一次。这就意味着,相同的可变数据结构将用于所有函数调用,如下面例子所示:

def show_args_using_mutable_defaults(arg,def_arg=[]): def_arg.append("Hello World") return "arg={}, def_arg={}".format(arg, def_arg) >>> show_args_using_mutable_defaults("test") "arg=test, def_arg=['Hello World']" >>> show_args_using_mutable_defaults("test 2") "arg=test 2, def_arg=['Hello World', 'Hello World']"

在每个函数调用中,“Hello World”都被添加到了def_arg列表中,在调用两次函数之后,默认参数中将有两个“Hello World”字符串。当使用可变默认参数作为默认值时,注意到这一点非常重要。当我们讨论Python数据模型时,将会清楚理解其原因。

2. 关键字参数:以“kwarg=value”的形式使用关键字参数也可以调用函数。其中,kwarg指函数定义中使用的参数名称。以下面定义的含有默认和非默认参数的函数为例:

def show_args(arg, def_arg=1): return "arg={}, def_arg={}".format(arg, def_arg)

为了演示使用关键字参数调用函数,下面的函数可以以后面的任何一种方式调用:

show_args(arg="test", def_arg=3) show_args(test) show_args(arg="test") show_args("test", 3)

在函数调用中,关键字参数不得早于非关键字参数,所以以下调用会失败:

show_args(def_arg=4)

函数不能为一个参数提供重复值,所以下面的调用方法是非法的:

show_args("test",arg="testing")

在上面的例子中,参数arg是位置参数,所以值“test”会分配给它。而试图将其再次分配给关键字arg,意味着在尝试多重赋值,而这是非法的。

传递的所有关键字参数必须匹配一个函数接受的参数,而包含非可选参数的关键字顺序并不重要,所以下面调换了参数顺序的写法是合法的:

show_args(def_arg="testing",arg="test")

3. 任意的参数列表:Python还支持定义这样的函数,该函数可以接受以元组形式传递的任意数量的参数,Python教程中的一个例子如下所示:

def write_multiple_items(file, separator,*args): file.write(separator.join(args))

任意数量的参数必须在正常参数之后。在本例中,任意数量参数存在于参数file和separator之后。下面是一个调用上述定义函数的示例:

f = open("test.txt","wb") write_multiple_items(f, " ","one", "two", "three", "four","five")

上面的参数one、two、three、four、five捆绑在一起共同组成了一个元组,通过参数args就能访问该元组。

解包函数参数

有时候,函数调用的参数可能是以元组、列表或字典的形式存在。可以通过使用“*”或“**”操作符将这些参数解包到函数内部以供调用。以下面的函数为例,该函数接受两个位置参数,并打印出两个参数的值。

def print_args(a, b): print a print b

如果提供给函数的参数值是以列表形式存在,那么我们可以直接将这些值解包到函数中,如下所示:

>>> args = [1, 2] >>> print_args(*args) 1 2

类似的,当我们有关键词时,可以使用字典来存储kwarg到值的映射关系,并利用“**”操作符将关键字参数解包到函数,如下所示:

>>> def parrot(voltage, state=’astiff’, action=’voom’): print "-- This parrot wouldn’t", action, print "if you put", voltage, "volts through it.", print "E’s", state, "!" >>> d = {"voltage":"four million", "state": "bleedin’ demised","action": "VOOM"} >>> parrot(**d) >>> This parrot wouldn’t VOOM ifyou put four million volts through it. E’s bleedin’ demised

利用“*”和“**”定义函数

有时候,当定义一个函数时,我们之前可能不知道参数的数量。这就导致了下面签名的函数定义:

show_args(arg, *args, **kwargs)

“*args”参数表示未知的位置参数序列长度,而“**kwargs”代表包含关键字和值映射关系的字典,它可以包含任意数量的关键字和值映射,并且在函数定义中“*args”必须位于“**kwargs”前面。下面的代码演示了这种情况:

def show_args(arg, *args, **kwargs): print arg for item in args: print args for key, value in kwargs: print key, value >>> args = [1, 2, 3, 4] >>> kwargs = dict(name='testing',age=24, year=2014) >>> show_args("hey",*args, **kwargs) hey 1 2 3 4 age 24 name testing year 2014

必须向函数提供正常的参数,但“*args”和“**kwargs”却是可选的,如下所示:

>>> show_args("hey",*args, **kwargs) hey

函数调用中,普通参数以正常方式提供,而可选参数则可以通过解包的形式到达函数调用中。

匿名函数

Python也支持匿名函数,这些函数使用lambda关键字创建。Python中Lambda表达式的形式如下所示:

lambda_expr ::= "lambda" [parameter_list]:expression

Lambda表达式返回评估后的函数对象,并且具有与命名函数相同的属性。在Python中,Lambda表达式通常只用于非常简单的函数,如下所示:

>>> square = lambda x: x**2 >>> for i in range(10): square(i) 0 1 4 9 16 25 36 49 64 81 >>>

上面的lambda表达式的功能与下面命名函数的功能相同:

def square(x): return x**2

嵌套函数和闭包

在一个函数内部定义函数就创建了嵌套函数,如下所示:

def outer():

outer_var = "outer variable"

def inner():

return outer_var

return inner

在这种类型的函数定义中,函数inner只在函数outer内部有效,所以当内部函数需要被返回(移动到外部作用范围)或被传递给另一个函数时,使用嵌套函数通常比较方便。在如在上面的嵌套函数中,每次调用外部函数时都会创建一个新的嵌套函数实例,这是因为,在每次执行外部函数时,都会执行一次内部函数定义,而其函数体则不会被执行。

嵌套函数可以访问创建它的环境,这是python函数定义语义的直接结果。一个结果是,外部函数中定义的变量可以在内部函数中引用,即使外部函数已经执行结束。

def outer(): outer_var = "outer variable" def inner(): return outer_var return inner >>> x = outer() >>> x <function inner at 0x0273BCF0> >>> x() 'outer variable'

当内部嵌套的函数引用外部函数中的变量时,我们说嵌套函数相对于引用变量是封闭的。我们可以使用函数对象的一个特殊属性“__closure__”来访问这个封闭的变量,如下所示:

>>> cl = x.__closure__ >>> cl (<cell at 0x029E4470: str object at0x02A0FD90>,) >>> cl[0].cell_contents 'outer variable'

Python中的闭包有一个古怪的行为。在Python2.x及更低版本中,指向不可变类型(例如字符串和数字)的变量不能在闭包内反弹。下面的例子说明了这一点:

def counter(): count = 0 def c(): count += 1 return count return c >>> c = counter() >>> c() Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 4, in c UnboundLocalError: local variable 'count'referenced before assignment

一个相当不可靠的解决方案是,使用一个可变类型来捕获闭包,如下所示:

def counter(): count = [0] def c(): count[0] += 1 return count[0] return c >>> c = counter() >>> c() 1 >>> c() 2 >>> c() 3

Python 3引入了“nonlocal”关键字用来解决下面所示的闭包范围问题。在本教程命名空间一节中,我们更加详细地描述了这些古怪用法。

def counter(): count = 0 def c(): nonlocal count count += 1 return count return c

闭包可以用来维持状态(与类作用不同),在一些简单的情况下,还可以提供一种简洁性与可读性比类更强的解决方案,我们使用tech_pro中的一个日志例子来说明这一点。假设一个非常简单的日志API,它使用基于类的面向对象思想,并可以在不同级别上打印日志:

class Log: def __init__(self, level): self._level = level def __call__(self, message): print("{}: {}".format(self._level, message)) log_info = Log("info") log_warning = Log("warning") log_error = Log("error")

相同的功能也可以使用闭包来实现,如下所示:

def make_log(level): def _(message): print("{}: {}".format(level, message)) return _ log_info = make_log("info") log_warning = make_log("warning") log_error = make_log("error")

原文发布于微信公众号 - 机器学习算法与Python学习(guodongwei1991)

原文发表时间:2016-06-10

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏web前端

JavaScript基础学习--14 json、数组

Demos:   https://github.com/jiangheyan/JavaScriptBase 一、json      1、格式与取值:{key:...

283100
来自专栏python3

python 内置函数

基本的数据操作基本都是一些数学运算(当然除了加减乘除)、逻辑操作、集合操作、基本IO操作,然后就是对于语言自身的反射操作,还有就是字符串操作。

15920
来自专栏我的博客

插入排序

原理: 1. 从第一个元素开始,该元素可以认为已经被排序 2. 取出下一个元素,在已经排序的元素序列中从后向前扫描 3. 如果该元素(已排序)大于新元素,...

26460
来自专栏GreenLeaves

JavaScript引用类型之Array数组的toString()和valueof()方法的区别

一、转换方法 1、在JavaScript中几乎所有对象都具有toLocaleString()、toString和valueof()方法,因为,所有的对象都继承自...

22970
来自专栏浪淘沙

实训day04--二维数组,面向对象

2018.06.07 1.方法的签名 cn.edu360.function.Demo1.add(int ,int)

11430
来自专栏转载gongluck的CSDN博客

野指针分析

1. 野指针的概念   所谓的野指针,就是说指针指向的那块内存,你没有合法操作的权限,也就是指针指向非法的内存空间,这样的指针就叫做野指针。 2. 野指针产...

39470
来自专栏程序员的知识天地

20分钟搞定Python 函数基础知识

简单地说,一个函数就是一组Python语句的组合,它们可以在程序中运行一次或多次运行。Python中的函数在其他语言中也叫做过程或子例程,那么这些被包装起来的语...

14530
来自专栏小白的技术客栈

Python之解析式您知多少?

解析式 解析式 今天给大家介绍Python中的解析式。 ? 解析式简单介绍 解析式, 列表解析 # Python2只有列表解析 生成器解析 # Python...

47250
来自专栏超然的博客

ECMAScript 6 笔记(三)

  ES6 的写法还有两个好处:首先,阅读代码的人,可以立刻意识到哪些参数是可以省略的,不用查看函数体或文档;其次,有利于将来的代码优化,即使未来的版本在对外接...

9320
来自专栏机器学习和数学

[编程经验] Python正则表达式

Hello,大家好。又见面了,今天给大家介绍一下,正则表达式在Python中是如何使用的。这样说的原因是正则表达式并不是Python所独有的,而是自成体系,在很...

27940

扫码关注云+社区

领取腾讯云代金券