Python函数和模块
函数
Python 定义函数使用 def 关键字,一般格式如下:
def` `函数名(参数列表):`` ``函数体
让我们使用函数来输出"Hello World!":
>>> ``def` `hello() :`` ``print``(``"Hello World!"``)` ` ` `>>> hello()``Hello World!``>>>
更复杂点的应用,函数中带上参数变量:
def` `area(width, height):`` ``return` `width ``*` `height`` ` `def` `print_welcome(name):`` ``print``(``"Welcome"``, name)` `print_welcome(``"Fred"``)``w ``=` `4``h ``=` `5``print``(``"width ="``, w, ``" height ="``, h, ``" area ="``, area(w, h))
以上实例输出结果:
Welcome Fred``width ``=` `4` `height ``=` `5` `area ``=` `20
函数变量作用域
定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域。
通过以下实例,你可以清楚了解Python函数变量的作用域:
#!/usr/bin/env python3``a ``=` `4` `# 全局变量`` ` `def` `print_func1():`` ``a ``=` `17` `# 局部变量`` ``print``(``"in print_func a = "``, a)``def` `print_func2(): `` ``print``(``"in print_func a = "``, a)``print_func1()``print_func2()``print``(``"a = "``, a)
以上实例运行结果如下:
in` `print_func a ``=` `17``in` `print_func a ``=` `4``a ``=` `4
关键字参数
函数也可以使用 kwarg=value 的关键字参数形式被调用.例如,以下函数:
def` `parrot(voltage, state``=``'a stiff'``, action``=``'voom'``, ``type``=``'Norwegian Blue'``):`` ``print``(``"-- This parrot wouldn't"``, action, end``=``' ')`` ``print``(``"if you put"``, voltage, ``"volts through it."``)`` ``print``(``"-- Lovely plumage, the"``, ``type``)`` ``print``(``"-- It's"``, state, ``"!"``)
可以以下几种方式被调用:
parrot(``1000``) ``# 1 positional argument``parrot(voltage``=``1000``) ``# 1 keyword argument``parrot(voltage``=``1000000``, action``=``'VOOOOOM'``) ``# 2 keyword arguments``parrot(action``=``'VOOOOOM'``, voltage``=``1000000``) ``# 2 keyword arguments``parrot(``'a million'``, ``'bereft of life'``, ``'jump'``) ``# 3 positional arguments``parrot(``'a thousand'``, state``=``'pushing up the daisies'``) ``# 1 positional, 1 keyword
以下为错误调用方法:
parrot() ``# required argument missing``parrot(voltage``=``5.0``, ``'dead'``) ``# non-keyword argument after a keyword argument``parrot(``110``, voltage``=``220``) ``# duplicate value for the same argument``parrot(actor``=``'John Cleese'``) ``# unknown keyword argument
返回值
Python的函数的返回值使用return语句,可以将函数作为一个值赋值给指定变量:
def` `return_sum(x,y):`` ``c ``=` `x ``+` `y`` ``return` `c` `res ``=` `return_sum(``4``,``5``)``print``(res)
你也可以让函数返回空值:
def` `empty_return(x,y):`` ``c ``=` `x ``+` `y`` ``return` `res ``=` `empty_return(``4``,``5``)``print``(res)
可变参数列表
最后,一个最不常用的选择是可以让函数调用可变个数的参数.这些参数被包装进一个元组(查看元组和序列).在这些可变个数的参数之前,可以有零到多个普通的参数:
def` `arithmetic_mean(``*``args):`` ``sum` `=` `0`` ``for` `x ``in` `args:`` ``sum` `+``=` `x`` ``return` `sum` `print``(arithmetic_mean(``45``,``32``,``89``,``78``))``print``(arithmetic_mean(``8989.8``,``78787.78``,``3453``,``78778.73``))``print``(arithmetic_mean(``45``,``32``))``print``(arithmetic_mean(``45``))``print``(arithmetic_mean())
以上实例输出结果为:
244``170009.31``77``45``0
模块
在前面的几个章节中我们脚本上是用python解释器来编程,如果你从Python解释器退出再进入,那么你定义的所有的方法和变量就都消失了。
为此 Python 提供了一个办法,把这些定义存放在文件中,为一些脚本或者交互式的解释器实例使用,这个文件被称为模块。
模块是一个包含所有你定义的函数和变量的文件,其后缀名是.py。模块可以被别的程序引入,以使用该模块中的函数等功能。这也是使用python标准库的方法。下面是一个使用python标准库中模块的例子。
#!/usr/bin/python3``# Filename: using_sys.py` `import` `sys` `print``(``'命令行参数如下:'``)``for` `i ``in` `sys.argv:`` ``print``(i)` `print``(``'/n/nThe PYTHONPATH is'``, sys.path, ``'/n'``)
执行结果如下所示:
E:\python33\src>python using_sys.py 参数``1` `参数``2``命令行参数如下:``using_sys.py``参数``1``参数``2``/``n``/``nThe PYTHONPATH ``is` `[``'E:\\python33\\src'``, 'C:\\Windows\\system32\\python33.``zip``', '``E:\\python33\\DLLs``', '``E:\\python33\\lib``', '``E:\\python33``', '``E:\\python33\\lib``\\site``-``packages'] ``/``n
- 1、import sys引入python标准库中的sys.py模块;这是引入某一模块的方法。
- 2、sys.argv是一个包含命令行参数的列表。
- 3、sys.path包含了一个Python解释器自动查找所需模块的路径的列表。
当我们使用import语句的时候,Python解释器是怎样找到对应的文件的呢?
这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找锁引入的模块。
这看起来很像环境变量,事实上,也可以通过定义环境变量的方式来确定搜索路径。
搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量,做一个简单的实验,在交互式解释器中,输入以下代码:
import` `sys``sys.path
输出结果:
>>> sys.path``['``', '``E:\\python33\\Lib\\idlelib``', '``C:\\Windows\\system32\\python33.``zip``', '``E:\\python33\\DLLs``', '``E:\\python33\\lib``', '``E:\\python33``', '``E:\\python33\\lib\\site``-``packages']
sys.path输出是一个列表,其中第一项是空串’',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),亦即我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。
因此若像我一样在当前目录下存在与要引入模块同名的文件,就会把要引入的模块屏蔽掉。
了解了搜索路径的概念,就可以在脚本中修改sys.path来引入一些不在搜索路径中的模块。
现在,在解释器的当前目录或者sys.path中的一个目录里面来创建一个fibo.py的文件,代码如下:
# Fibonacci numbers module` `def` `fib(n): ``# write Fibonacci series up to n`` ``a, b ``=` `0``, ``1`` ``while` `b < n:`` ``print``(b, end``=``' '``)`` ``a, b ``=` `b, a``+``b`` ``print``()` `def` `fib2(n): ``# return Fibonacci series up to n`` ``result ``=` `[]`` ``a, b ``=` `0``, ``1`` ``while` `b < n:`` ``result.append(b)`` ``a, b ``=` `b, a``+``b`` ``return` `result
然后进入Python解释器,使用下面的命令导入这个模块:
>>> ``import` `fibo
这样做并没有把直接定义在fibo中的函数名称写入到当前符号表里,只是把模块fibo的名字写到了那里。
可以使用模块名称来访问函数:
>>> fibo.fib(``1000``)``1` `1` `2` `3` `5` `8` `13` `21` `34` `55` `89` `144` `233` `377` `610` `987``>>> fibo.fib2(``100``)``[``1``, ``1``, ``2``, ``3``, ``5``, ``8``, ``13``, ``21``, ``34``, ``55``, ``89``]``>>> fibo.__name__``'fibo'
如果你打算经常使用一个函数,你可以把它赋给一个本地的名称:
>>> fib ``=` `fibo.fib``>>> fib(``500``)``1` `1` `2` `3` `5` `8` `13` `21` `34` `55` `89` `144` `233` `377
深入模块
模块除了方法定义,还可以包括可执行的代码。这些代码一般用来初始化这个模块。这些代码只有在第一次被导入时才会被执行。
每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。
所以,模块的作者可以放心大胆的在模块内部使用这些全局变量,而不用担心把其他用户的全局变量搞花。
从另一个方面,当你确实知道你在做什么的话,你也可以通过 modname.itemname 这样的表示法来访问模块内的函数。
模块是可以导入其他模块的。在一个模块(或者脚本,或者其他地方)的最前面使用 import 来导入一个模块,当然这只是一个惯例,而不是强制的。被导入的模块的名称将被放入当前操作的模块的符号表中。
还有一种导入的方法,可以使用 import 直接把模块内(函数,变量的)名称导入到当前操作模块。比如:
>>> ``from` `fibo ``import` `fib, fib2``>>> fib(``500``)``1` `1` `2` `3` `5` `8` `13` `21` `34` `55` `89` `144` `233` `377
这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。
这还有一种方法,可以一次性的把模块中的所有(函数,变量)名称都导入到当前模块的字符表:
>>> ``from` `fibo ``import` `*``>>> fib(``500``)``1` `1` `2` `3` `5` `8` `13` `21` `34` `55` `89` `144` `233` `377
这将把所有的名字都导入进来,但是那些由单一下划线(_)开头的名字不在此例。大多数情况, Python程序员不使用这种方法,因为引入的其它来源的命名,很可能覆盖了已有的定义。
__name__属性
一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。
#!/usr/bin/python3``# Filename: using_name.py` `if` `__name__ ``=``=` `'__main__'``:`` ``print``(``'程序自身在运行'``)``else``:`` ``print``(``'我来自另一模块'``)
运行输出如下:
$ python using_name.py
程序自身在运行
$ python``>>> ``import` `using_name``我来自另一模块``>>>
说明: 每个模块都有一个__name__属性,当其值是’main’时,表明该模块自身在运行,否则是被引入。
dir() 函数
内置的函数 ``dir``() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:``<``/``p>``<pre>``>>> ``import` `fibo, sys``>>> ``dir``(fibo)``[``'__name__'``, ``'fib'``, ``'fib2'``]``>>> ``dir``(sys) ``[``'__displayhook__'``, ``'__doc__'``, ``'__excepthook__'``, ``'__loader__'``, ``'__name__'``,`` ``'__package__'``, ``'__stderr__'``, ``'__stdin__'``, ``'__stdout__'``,`` ``'_clear_type_cache'``, ``'_current_frames'``, ``'_debugmallocstats'``, ``'_getframe'``,`` ``'_home'``, ``'_mercurial'``, ``'_xoptions'``, ``'abiflags'``, ``'api_version'``, ``'argv'``,`` ``'base_exec_prefix'``, ``'base_prefix'``, ``'builtin_module_names'``, ``'byteorder'``,`` ``'call_tracing'``, ``'callstats'``, ``'copyright'``, ``'displayhook'``,`` ``'dont_write_bytecode'``, ``'exc_info'``, ``'excepthook'``, ``'exec_prefix'``,`` ``'executable'``, ``'exit'``, ``'flags'``, ``'float_info'``, ``'float_repr_style'``,`` ``'getcheckinterval'``, ``'getdefaultencoding'``, ``'getdlopenflags'``,`` ``'getfilesystemencoding'``, ``'getobjects'``, ``'getprofile'``, ``'getrecursionlimit'``,`` ``'getrefcount'``, ``'getsizeof'``, ``'getswitchinterval'``, ``'gettotalrefcount'``,`` ``'gettrace'``, ``'hash_info'``, ``'hexversion'``, ``'implementation'``, ``'int_info'``,`` ``'intern'``, ``'maxsize'``, ``'maxunicode'``, ``'meta_path'``, ``'modules'``, ``'path'``,`` ``'path_hooks'``, ``'path_importer_cache'``, ``'platform'``, ``'prefix'``, ``'ps1'``,`` ``'setcheckinterval'``, ``'setdlopenflags'``, ``'setprofile'``, ``'setrecursionlimit'``,`` ``'setswitchinterval'``, ``'settrace'``, ``'stderr'``, ``'stdin'``, ``'stdout'``,`` ``'thread_info'``, ``'version'``, ``'version_info'``, ``'warnoptions'``]
如果没有给定参数,那么 dir() 函数会罗列出当前定义的所有名称:
>>> a ``=` `[``1``, ``2``, ``3``, ``4``, ``5``]``>>> ``import` `fibo``>>> fib ``=` `fibo.fib``>>> ``dir``() ``# 得到一个当前模块中定义的属性列表``[``'__builtins__'``, ``'__name__'``, ``'a'``, ``'fib'``, ``'fibo'``, ``'sys'``]``>>> a ``=` `5` `# 建立一个新的变量 'a'``>>> ``dir``()``[``'__builtins__'``, ``'__doc__'``, ``'__name__'``, ``'a'``, ``'sys'``]``>>>``>>> ``del` `a ``# 删除变量名a``>>>``>>> ``dir``()``[``'__builtins__'``, ``'__doc__'``, ``'__name__'``, ``'sys'``]``>>>
标准模块
Python 本身带着一些标准的模块库,在 Python 库参考文档中将会介绍到(就是后面的"库参考文档")。
有些模块直接被构建在解析器里,这些虽然不是一些语言内置的功能,但是他却能很高效的使用,甚至是系统级调用也没问题。
这些组件会根据不同的操作系统进行不同形式的配置,比如 winreg 这个模块就只会提供给 Windows 系统。
应该注意到这有一个特别的模块 sys ,它内置在每一个 Python 解析器中。变量 sys.ps1 和 sys.ps2 定义了主提示符和副提示符所对应的字符串:
>>> ``import` `sys``>>> sys.ps1``'>>> '``>>> sys.ps2``'... '``>>> sys.ps1 ``=` `'C> '``C> ``print``(``'Yuck!'``)``Yuck!``C>
包
包是一种管理 Python 模块命名空间的形式,采用"点模块名称"。
比如一个模块的名称是 A.B, 那么他表示一个包 A中的子模块 B 。
就好像使用模块的时候,你不用担心不同模块之间的全局变量相互影响一样,采用点模块名称这种形式也不用担心不同库之间的模块重名的情况。
这样不同的作者都可以提供 NumPy 模块,或者是 Python 图形库。
不妨假设你想设计一套统一处理声音文件和数据的模块(或者称之为一个"包")。
现存很多种不同的音频文件格式(基本上都是通过后缀名区分的,例如: .wav,:file:.aiff,:file:.au,),所以你需要有一组不断增加的模块,用来在不同的格式之间转换。
并且针对这些音频数据,还有很多不同的操作(比如混音,添加回声,增加均衡器功能,创建人造立体声效果),所你还需要一组怎么也写不完的模块来处理这些操作。
这里给出了一种可能的包结构(在分层的文件系统中):
sound``/` `Top``-``level package`` ``__init__.py Initialize the sound package`` ``formats``/` `Subpackage ``for` `file` `format` `conversions`` ``__init__.py`` ``wavread.py`` ``wavwrite.py`` ``aiffread.py`` ``aiffwrite.py`` ``auread.py`` ``auwrite.py`` ``...`` ``effects``/` `Subpackage ``for` `sound effects`` ``__init__.py`` ``echo.py`` ``surround.py`` ``reverse.py`` ``...`` ``filters``/` `Subpackage ``for` `filters`` ``__init__.py`` ``equalizer.py`` ``vocoder.py`` ``karaoke.py`` ``...
在导入一个包的时候,Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。
目录只有包含一个叫做 init.py 的文件才会被认作是一个包,主要是为了避免一些滥俗的名字(比如叫做 string)不小心的影响搜索路径中的有效模块。
最简单的情况,放一个空的 :file:init.py就可以了。当然这个文件中也可以包含一些初始化代码或者为(将在后面介绍的) __all__变量赋值。
用户可以每次只导入一个包里面的特定模块,比如:
import` `sound.effects.echo
这将会导入子模块:mod:song.effects.echo。 他必须使用全名去访问:
sound.effects.echo.echofilter(``input``, output, delay``=``0.7``, atten``=``4``)
还有一种导入子模块的方法是:
from` `sound.effects ``import` `echo
这同样会导入子模块:mod:echo,并且他不需要那些冗长的前缀,所以他可以这样使用:
echo.echofilter(``input``, output, delay``=``0.7``, atten``=``4``)
还有一种变化就是直接导入一个函数或者变量:
from` `sound.effects.echo ``import` `echofilter
同样的,这种方法会导入子模块:mod:echo,并且可以直接使用他的:func:echofilter函数:
echofilter(input, output, delay=0.7, atten=4)
注意当使用from package import item这种形式的时候,对应的item既可以是包里面的子模块(子包),或者包里面定义的其他名称,比如函数,类或者变量。
import语法会首先把item当作一个包定义的名称,如果没找到,再试图按照一个模块去导入。如果还没找到,恭喜,一个:exc:ImportError 异常被抛出了。
反之,如果使用形如import item.subitem.subsubitem这种导入形式,除了最后一项,都必须是包,而最后一项则可以是模块或者是包,但是不可以是类,函数或者变量的名字。
从一个包中导入*
设想一下,如果我们使用 from sound.effects import *会发生什么?
Python 会进入文件系统,找到这个包里面所有的子模块,一个一个的把它们都导入进来。
但是很不幸,这个方法在 Windows平台上工作的就不是非常好,因为Windows是一个大小写不区分的系统。
在这类平台上,没有人敢担保一个叫做 ECHO.py 的文件导入为模块:mod:echo还是:mod:Echo甚至:mod:ECHO。
(例如,Windows 95就很讨厌的把每一个文件的首字母大写显示)而且 DOS 的 8+3 命名规则对长模块名称的处理会把问题搞得更纠结。
为了解决这个问题,只能烦劳包作者提供一个精确的包的索引了。
导入语句遵循如下规则:如果包定义文件 init.py 存在一个叫做 all 的列表变量,那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。
作为包的作者,可别忘了在更新包之后保证 all 也更新了啊。你说我就不这么做,我就不使用导入*这种用法,好吧,没问题,谁让你是老板呢。这里有一个例子,在:file:sounds/effects/init.py中包含如下代码:
__all__ ``=` `[``"echo"``, ``"surround"``, ``"reverse"``]
这表示当你使用from sound.effects import *这种用法时,你只会导入包里面这三个子模块。
如果__all__真的而没有定义,那么使用from sound.effects import 这种语法的时候,就不会*导入包:mod:sound.effects里的任何子模块。他只是把包:mod:sound.effects和它里面定义的所有内容导入进来(可能运行:file:init.py里定义的初始化代码)。
这会把 :file:init.py里面定义的所有名字导入进来。并且他不会破坏掉我们在这句话之前导入的所有明确指定的模块。看下这部分代码:
import` `sound.effects.echo``import` `sound.effects.surround``from` `sound.effects ``import` `*
这个例子中,在执行from…import前,包:mod:sound.effects中的echo和surround模块都被导入到当前的命名空间中了。(当然如果定义了__all__就更没问题了)
通常我们并不主张使用*这种方法来导入模块,因为这种方法经常会导致代码的可读性降低。不过这样倒的确是可以省去不少敲键的功夫,而且一些模块都设计成了只能通过特定的方法导入。
记住,使用from Package import specific_submodule这种方法永远不会有错。事实上,这也是推荐的方法。除非是你要导入的子模块有可能和其他包的子模块重名。
如果在结构中包是一个子包(比如这个例子中对于包:mod:sound来说),而你又想导入兄弟包(同级别的包)你就得使用导入绝对的路径来导入。比如,如果模块:mod:sound.filters.vocoder 要使用包:mod:sound.effects中的模块:mod:echo,你就要写成 from sound.effects import echo。
from` `. ``import` `echo``from` `.. ``import` `formats``from` `..filters ``import` `equalizer
无论是隐式的还是显式的相对导入都是从当前模块开始的。主模块的名字永远是"main",一个Python应用程序的主模块,应当总是使用绝对路径引用。
包还提供一个额外的属性,:attr:path。这是一个目录列表,里面每一个包含的目录都有为这个包服务的:file:init.py,你得在其他:file:init.py被执行前定义哦。可以修改这个变量,用来影响包含在包里面的模块和子包。
这个功能并不常用,一般用来扩展包里面的模块。