第六章

Python函数与模块

函数是指由程序组织好、可重复使用、用来实现单一或相关联功能的代码段。它能提高程序应用的模块性和代码的重复利用率。Python提供了许多内建函数，比如print()。也可以由程序开发者根据项目需要自己创建函数，这种由开发者创建的函数叫做用户自定义函数。

6.1 自定义函数

自己定义函数的规则：

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

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

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

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

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

语法：

def functionname( parameters ): "函数_文档字符串" function_suite return [expression]

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

实例：

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

#!/usr/bin/python

# -*- coding: GBK -*-

def printme( str ):

"打印传入的字符串到标准显示设备上"

print(st)

return

6.1.1 函数调用

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

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

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

#!/usr/bin/python

# -*- coding: GBK -*-

# 定义函数

def printme( str ):

"打印任何传入的字符串"

print (str)

return

# 调用函数

printme("我要调用用户自定义函数!")

printme("再次调用同一函数")

以上实例输出结果：

我要调用用户自定义函数!

再次调用同一函数

6.1.2 参数传递

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

a=[1,2,3]

a="Runoob"

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

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

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

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

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

python 函数的参数传递：

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

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

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

python 传不可变对象实例:

#!/usr/bin/python

# -*- coding: GBK -*-

# 定义函数

def ChangeInt( a ):

a = 10

b = 2

ChangeInt(b)

print (b) # 结果是 2

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

传可变对象实例:

#!/usr/bin/python

# -*- coding: GBK -*-

# 可写函数说明

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

参数:

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

(1)必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。调用printme()函数，必须传入一个参数，不然会出现语法错误：

#!/usr/bin/python

# -*- coding: GBK -*-

#可写函数说明

def printme( str ):

"打印任何传入的字符串"

print (str)

return #调用printme函数

printme()

以上实例输出结果：

Traceback (most recent call last):

File "mypywk", line 8, in <module>

printme()

TypeError: printme() missing 1 required positional argument: 'str'

(2)关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

以下实例在函数 printme() 调用时使用参数名：

#!/usr/bin/python

# -*- coding: GBK -*-

#可写函数说明

def printme( str ):

"打印任何传入的字符串"

print (str)

return #调用printme函数

printme( str = "My string")

以上实例输出结果：

My string

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

#!/usr/bin/python

# -*- coding: GBK -*-

#可写函数说明

def printinfo( name, age ):

"打印任何传入的字符串"

print ("Name: ", name)

print ("Age ", age)

return #调用printinfo函数

printinfo( age=50, name="miki" )

以上实例输出结果：

Name: miki

Age 50

(3)默认参数

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

#!/usr/bin/python

# -*- coding: GBK -*-

#可写函数说明

def printinfo( name, age = 35 ):

"打印任何传入的字符串"

print ("Name: ", name)

print ("Age ", age)

return #调用printinfo函数

printinfo( age=50, name="miki" )

printinfo( name="miki" )

以上实例输出结果：

Name: miki

Age 50

Name: miki

Age 35

(4)不定长参数

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

def functionname([formal_args,] *var_args_tuple ):

"函数_文档字符串"

function_suite

return [expression]

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

#!/usr/bin/python

# -*- coding: GBK -*-

#可写函数说明

def printinfo( arg1, *vartuple ):

"打印任何传入的参数"

print ("输出: ")

print (arg1)

for var in vartuple:

print (var)

return # 调用printinfo 函数

printinfo( 10 )

printinfo( 70, 60, 50 )

以上实例输出结果：

输出:

10

输出:

70

60

50

6.1.4 匿名函数

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

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

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

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

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

语法

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

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

如下实例：

#!/usr/bin/python

# -*- coding: GBK -*-

#可写函数说明

sum = lambda arg1, arg2: arg1 + arg2 # 调用sum函数

print ("相加后的值为 : ", sum( 10, 20 ))

print ("相加后的值为 : ", sum( 20, 20 ))

以上实例输出结果：

相加后的值为 : 30

相加后的值为 : 40

6.1.5 return 语句

return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，下面我们来看实例操作：

实例

#!/usr/bin/python

# -*- coding: GBK -*-

#可写函数说明

def sum( arg1, arg2 ):

# 返回2个参数的和."

total = arg1 + arg2

print ("函数内 : ", total)

return total # 调用sum函数

total = sum( 10, 20 )

以上实例输出结果：

函数内 : 30

6.1.6 变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。

两种最基本的变量作用域为：全局变量和局部变量。

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

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

#!/usr/bin/python

# -*- coding: GBK -*-

#可写函数说明

total = 0 # 这是一个全局变量

def sum( arg1, arg2 ): #返回2个参数的和."

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

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

return total #调用sum函数

sum( 10, 20 )

print ("函数外是全局变量 : ", total)

以上实例输出结果：

函数内是局部变量 : 30

函数外是全局变量 : 0

6.2 模块

Python 模块(Module)是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

模块让你能够有逻辑地组织你的 Python 代码段。把相关的代码分配到一个模块里能让你的代码更好用，更易懂。模块能定义函数，类和变量，模块里也能包含可执行的代码。

下例是个简单的模块：

support.py 模块：

def print_module( mychar ):

print （"Hello : ", mychar）

return

6.2.1 自定义模块导入报错详解

在我们学习如何导入自定义模块之前，先来看看容易出现的问题。

刚开始学习导入模块时，我们有时会遇到这样的问题，即自定义 Python 模块后，在其它文件中用 import（或 from...import） 语句导入该文件时，Python 解释器提示如下错误：

ModuleNotFoundError: No module named '模块名'

意思是 Python 没有发现该名字的模块。

要解决这个问题，我们首先要知道 Python 解释器查找模块文件的过程，通常情况下，当使用 import 语句导入模块后，Python 会按照以下顺序查找指定的模块文件：

（1）在当前目录，即当前执行的程序文件所在目录下查找；

（2）到 PYTHONPATH（环境变量）下的每个目录中查找；

（3）到 Python 默认的安装目录下查找。

以上所有涉及到的目录，都保存在标准模块 sys 的 sys.path 变量中，通过此变量我们可以看到指定程序文件支持查找的所有目录。换句话说，如果要导入的模块没有存储在sys.path 显示的目录中，那么导入该模块并运行程序时，Python 解释器就会抛出 ModuleNotFoundError（未找到模块）异常。

下面我们就介绍2种解决方案：

（1）将自定义模块放在工程项目加载路径中；

（2）设置 path 系统环境变量。

方案一：将自定义模块保存到工程项目所在目录下

如果要安装某些通用性模块，比如复数功能支持的模块、矩阵计算支持的模块、图形界面支持的模块等，这些都属于对 Python 本身进行扩展的模块，这种模块应该直接安装在 Python 内部，以便被所有程序共享，此时就可借助于 Python 默认的模块加载路径。Python 程序默认的模块加载路径保存在 sys.path 变量中，因此，我们可以在 print_work.py 程序文件中先看看 sys.path 中保存的默认加载路径，向 print_work.py 文件中输出 sys.path 的值，如下所示：

#!/usr/bin/python

# -*- coding: GBK -*-

# 导入python sys.path

import sys

#在窗口中打印sys.path的完整路径

print(sys.path)

窗口显示默认工程项目加载路径：

['D:\\Users\\python_work', 'D:\\Users\\python_work','C:\\Users\\chenyegen\\AppData\\Local\\Programs\\Python\\Python36-32\\python36.zip', 'C:\\Users\\chenyegen\\AppData\\Local\\Programs\\Python\\Python36-32\\DLLs', 'C:\\Users\\chenyegen\\AppData\\Local\\Programs\\Python\\Python36-32\\lib', 'C:\\Users\\chenyegen\\AppData\\Local\\Programs\\Python\\Python36-32', 'C:\\Users\\chenyegen\\AppData\\Local\\Programs\\Python\\Python36-32\\lib\\site-packages']

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

(program exited with code: 0)

请按任意键继续. . .

上面的运行结果中，列出的所有路径都是 Python 默认的模块加载路径，但通常来说，我们默认将 自定义模块添加在该工程项目的目录路径下。所以，我们可以直接将我们已编写好的 hello.py 文件添加到D:\\Users\\python_work 路径下，这样任何 Python 程序都可使用该模块。

移动工作完成之后，再次运行 print_work.py 文件，可以看到成功运行的结果：

Hello：Shenhai!

方案二：设置环境变量

PYTHONPATH 环境变量（简称 path 变量）的值是很多路径组成的集合，Python 解释器会按照 path 包含的路径进行一次搜索，直到找到指定要加载的模块。当然，如果最终依旧没有找到，则 Python 就报 ModuleNotFoundError 异常。

由于不同平台，设置 path 环境变量的设置流程也不尽相同，因此接下来我们就使用最多的 Windows、Linux、Mac OS X 这 3 个平台，给大家介绍如何设置 path 环境变量。

（1）Windows 平台环境变量的设置

首先，在桌面上的“计算机”（或者我的电脑）图标上单击鼠标右键，在弹出的对话页面中单击“属性”。此时会显示“控制面板\所有控制面板项\系统”窗口，单击该窗口左边栏中的“高级系统设置”菜单，出现“系统属性”对话框，如图 1 所示。

图 1 系统属性对话框

如图 1 所示，点击“环境变量”按钮，此时将弹出图 2 所示的对话框：

图 2 环境变量对话框

如图 2 所示，通过该对话框，就可以完成 path 环境变量的设置。需要注意的是，该对话框分为上下 2 部分，其中上面的“用户变量”部分用于设置当前用户的环境变量，下面的“系统变量”部分用于设置整个系统的环境变量。

通常情况下，建议设置用户的 path 变量即可，因为此设置仅对当前登陆系统的用户有效，而如果修改系统的 path 变量，则对所有用户有效。

对于普通用户来说，设置用户 path 变量和系统 path 变量的效果是相同的，但 Python 在使用 path 变量时，会先按照系统 path 变量的路径去查找，然后再按照用户 path 变量的路径去查找。

这里我们选择设置当前用户的 path 变量。单击用户变量中的“新建”按钮， 系统会弹出如图 3 所示的对话框。

图 3 新建PYTHONPATH环境变量

其中，在“变量名”文本框内输入 PYTHONPATH，表明将要建立名为 PYTHONPATH 的环境变量；在“变量值”文本框内输入 .;D:\python_work。注意，这里其实包含了两条路径（以分号 ；作为分隔符）：

第一条路径为一个点（.），表示当前路径，当运行 Python 程序时，Python 将可以从当前路径加载模块；

第二条路径为D:\python_work，当运行 Python 程序时，Python 将可以从D:\python_work中加载模块。

然后点击“确定”，即成功设置 path 环境变量。此时，我们只需要将模块文件移动到和引入该模块的文件相同的目录，或者移动到D:\python_work路径下，该模块就能被成功加载。

（2）在 Linux 上设置环境变量

启动 Linux 的终端窗口，进入当前用户的 home 路径下，然后在 home 路径下输入如下命令：

ls – a

该命令将列出当前路径下所有的文件，包括隐藏文件。Linux 平台的环境变量是通过 .bash_profile 文件来设置的，使用无格式编辑器打开该文件，在该文件中添加 PYTHONPATH 环境变量。也就是为该文件增加如下一行：

#设置PYTHON PATH 环境变量

PYTHONPATH=.:/home/chenyegen /python_work

Linux 与 Windows 平台不一样，多个路径之间以冒号（:）作为分隔符，因此上面一行同样设置了两条路径，点（.）代表当前路径，还有一条路径是 /home/chenyegen/python_work。

在完成了 PYTHONPATH 变量值的设置后，在 .bash_profile 文件的最后添加导出 PYTHONPATH 变量的语句。

#导出PYTHONPATH 环境变量

export PYTHONPATH

重新登录 Linux 平台，或者执行如下命令：

source.bash_profile

这两种方式都是为了运行该文件，使在文件中设置的 PYTHONPATH 变量值生效。

在成功设置了上面的环境变量之后，接下来只要把前面定义的模块（Python 程序）放在与当前所运行 Python 程序相同的路径中（或放在 /home/chenyegen/python_work路径下），该模块就能被成功加载了。

（3）在Mac OS X 上设置环境变量

在 Mac OS X 上设置环境变量与 Linux 大致相同（因为 Mac OS X 本身也是类 UNIX 系统）。启动 Mac OS X 的终端窗口（命令行界面），进入当前用户的 home 路径下，然后在 home 路径下输入如下命令：

ls –a

该命令将列出当前路径下所有的文件，包括隐藏文件。Mac OS X 平台的环境变量也可通过，bash_profile 文件来设置，使用无格式编辑器打开该文件，在该文件中添加 PYTHONPATH 环境变量。也就是为该文件增加如下一行：

#设置PYTHON PATH 环境变盘

PYTHONPATH=.:/Users/chenyegen/python_work

Mac OS X 的多个路径之间同样以冒号（:）作为分隔符，因此上面一行同样设置了两条路径：点（.）代表当前路径，还有一条路径是/Users/chenyegen/python_work。

在完成了 PYTHONPATH 变量值的设置后，在 .bash_profile 文件的最后添加导出 PYTHONPATH 变量的语句。

#导出PYTHON PATH 环境变量

export PYTHONPATH

重新登录 Mac OS X 系统，或者执行如下命令：

source.bash_profile

这两种方式都是为了运行该文件，使在文件中设置的 PYTHONPATH 变量值生效。

在成功设置了上面的环境变量之后，接下来只要把前面定义的模块（Python 程序）放在与当前所运行 Python 程序相同的路径中（或放在Users/chenyegen/python_work路径下），该模块就能被成功加载了。

6.2.2 import 语句

模块定义好后，我们可以使用 import 语句来引入模块，语法如下：

import module1[, module2[,... moduleN]]

比如要引用模块 math，就可以在文件最开始的地方用 import math 来引入。在调用 math 模块中的函数时，必须这样引用：

模块名.函数名

当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support.py，需要把命令放在脚本的顶端：

test.py 文件代码：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

# 导入模块

import support

# 现在可以调用模块里包含的函数了

support.print_func("Shenhai")

以上实例输出结果：

Hello : Shenhai

一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。

6.2.3 from…import 语句

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：

from modname import name1[, name2[, ... nameN]]

例如，要导入模块 fib 的 fibonacci 函数，使用如下语句：

from fib import Fibonacci

这个声明不会把整个 fib 模块导入到当前的命名空间中，它只会将 fib 里的 fibonacci 单个引入到执行这个声明的模块的全局符号表。

6.2.4 from…import* 语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

from modname import*

这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

例如我们想一次性引入 math 模块中所有的东西，语句如下：

from math import *

6.2.5 搜索路径

当你导入一个模块，Python 解析器对模块位置的搜索顺序是：

1、当前目录

2、如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。

3、如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。

模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。

6.2.6 PYTHONPATH 变量

作为环境变量，PYTHONPATH 由装在一个列表里的许多目录组成。PYTHONPATH 的语法和 shell 变量 PATH 的一样。

在 Windows 系统，典型的 PYTHONPATH 如下：

set PYTHONPATH=c:\python27\lib;

在 UNIX 系统，典型的 PYTHONPATH 如下：

set PYTHONPATH=/usr/local/lib/python

6.2.7 命名空间和作用域

变量是拥有匹配对象的名字（标识符）。命名空间是一个包含了变量名称们（键）和它们各自相应的对象们（值）的字典。

一个 Python 表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。

每个函数都有自己的命名空间。类的方法的作用域规则和通常函数的一样。

Python 会智能地猜测一个变量是局部的还是全局的，它假设任何在函数内赋值的变量都是局部的。

因此，如果要给函数内的全局变量赋值，必须使用 global 语句。

global VarName 的表达式会告诉 Python， VarName 是一个全局变量，这样 Python 就不会在局部命名空间里寻找这个变量了。

例如，我们在全局命名空间里定义一个变量 Money。我们再在函数内给变量 Money 赋值，然后 Python 会假定 Money 是一个局部变量。然而，我们并没有在访问前声明一个局部变量 Money，结果就是会出现一个 UnboundLocalError 的错误。取消 global 语句前的注释符就能解决这个问题。

#!/usr/bin/python

# -*- coding: UTF-8 -*-

Money = 2000

def AddMoney():

# 想改正代码就取消以下注释:

# global Money

Money = Money + 1

print Money

AddMoney()

print Money

6.2.8 dir()函数

dir() 函数一个排好序的字符串列表，内容是一个模块里定义过的名字。

返回的列表容纳了在一个模块里定义的所有模块，变量和函数。如下一个简单的实例：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

# 导入内置math模块

import math

content = dir(math)

print content;

以上实例输出结果：

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan','atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log','log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']

在这里，特殊字符串变量__name__指向模块的名字，__file__指向该模块的导入文件名。

6.2.9 globals() 和 locals() 函数

根据调用地方的不同，globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。

如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。

如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。

两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。

6.2.10 reload() 函数

当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。

因此，如果你想重新执行模块里顶层部分的代码，可以用 reload() 函数。该函数会重新导入之前导入过的模块。语法如下：

reload(module_name)

在这里，module_name要直接放模块的名字，而不是一个字符串形式。比如想重载 hello 模块，如下：

reload(hello)

6.2.11 Python中的包

包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。

简单来说，包就是文件夹，但该文件夹下必须存在 __init__.py 文件, 该文件的内容可以为空。__init__.py 用于标识当前文件夹是一个包。

考虑一个在package_runoob目录下的runoob1.py、runoob2.py、__init__.py文件，test.py为测试调用包的代码，目录结构如下：

test.py

package_runoob

|-- __init__.py

|-- runoob1.py

|-- runoob2.py

源代码如下：

package_runoob/runoob1.py

#!/usr/bin/python

# -*- coding: UTF-8 -*-

def runoob1():

print "I'm in runoob1"

package_runoob/runoob2.py

#!/usr/bin/python

# -*- coding: UTF-8 -*-

def runoob2():

print "I'm in runoob2"

现在，在package_runoob目录下创建__init__.py：

package_runoob/__init__.py

#!/usr/bin/python

# -*- coding: UTF-8 -*-

if __name__ == '__main__':

print ('作为主程序运行')

else:

print ('package_runoob 初始化')

然后我们在package_runoob同级目录下创建 test.py 来调用package_runoob包

test.py

#!/usr/bin/python

# -*- coding: UTF-8 -*-

# 导入 Phone 包

from package_runoob.runoob1

import runoob1

from package_runoob.runoob2

import runoob2 runoob1() runoob2()

以上实例输出结果：

package_runoob 初始化

I'm in runoob1

I'm in runoob2

如上，为了举例，我们只在每个文件里放置了一个函数，但其实你可以放置许多函数。你也可以在这些文件里定义Python的类，然后为这些类建一个包。