python模块调用

篇一：python中导入模块的方法

python有三种导入模块的方法

1.引用

importmodname

模块是指一个可以交互使用，或者从另一Python 程序访问的代码段。只要导入了一个模块，就可以引用它的任何公共的函数、类或属性。模块可以通过这种方法来使用其它模块的功能。

用import语句导入模块，就在当前的名称空间(namespace)建立了一个到该模块的引用.这种引用必须使用全称，也就是说，当使用在被导入模块中定义的函数时，必须包含模块的名字。所以不能只使用funcname，而应该使用modname.funcname

2.导入到本地名字空间

frommodname import funcname

frommodname import fa, fb, fc

或者 from modname import *

与第1种方法的区别：funcname被直接导入到本地名字空间去了，所以它可以直接使用，而不需要加上模块名的限定

* 表示，该模块的所有公共对象(public objects)都被导入到当前的名称空间，也就是任何只要不是以”_”开始的东西都会被导入。

modname没有被定义，所以modname.funcname这种方式不起作用。并且，如果funcname如果已经被定义，它会被新版本（该导入模块中的版本）所替代。如果funcname被改成指向其他对象，modname不能不会觉察到。

建议:

1)如果你要经常访问模块的属性和方法，且不想一遍又一遍地敲入模块名，使用 from module import

2)如果你想要有选择地导入某些属性和方法，而不想要其它的，使用 from module import

3)如果模块包含的属性和方法与你的某个模块同名，你必须使用import module来避免名字冲突

4)尽量少用 from module import * ，因为判定一个特殊的函数或属性是从哪来的有些困难，并且会造成调试和重构都更困难。

3.将模块内容放到模块文件中

内建函数__import__()

除了前面两种使用import关键字的方法以外，我们还可以使用内建函数 __import__()

来导入 module。两者的区别是，import 后面跟的必须是一个类型(type)，而__import__() 的参数是一个字符串，这个字符串可能来自配置文件，也可能是某个表达式计算结果。例如 mymodule = __import__ (’module_name’)

附注:

1) 模块的内容都放在一个模块文件中，如mymodule的内容应该放在PYTHONPATH 目录下

的一个mymodule.py中，C实现的除外

2)包可以将几个模块名称空间组织起来, 如A.b就表示在包A中的一个子模块b 可以单独导入某一个子模块，如Python文档中给出的例子

importsound.effects.echo

这样必须使用全称对里面的对象进行引用，如

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

还可以使用下面的语句来加载echo子模块

fromSound.Effects import echo

它在没有包前缀的情况下也可以使用，所以它可以如下方式调用：

echo.echofilter(input, output, delay=0.7, atten=4)

不主张从一个包或模块中用import * 导入所有模块，因为这样的通常会导致可读性很差。 from Package import specific_submodule的用法并没有错，实际上这还是推荐的用法，除非导入的模块需要使用其它包中的同名子模块(the importing module needs to use submodules with the same name from different packages).

综上所述，一般情况应该使用import , 但有几个例外

1)module文档告诉你要用from-import的

2)导入一个包组件。需要一个包里面的某个子模块，一般用from A.b import c比import A.b.c更方便且不会冒混淆的危险.

篇二：Python自定义包使用方法

1.介绍

python中的Module是比较重要的概念，每个py可以看成一个module。常见的情况是，事先写好一个.py文件，在另一个文件中需要import时，将事先写好的.py文件拷贝到当前目录，或者是在sys.path中增加事先写好的.py文件所在的目录，然后import。

如果将相关的py文件放到一个目录下然后在加上一个__init__.py文件，就构成了一个包。在每一个包中，都有一个__init__.py文件（这个文件定义了包的属性和方法）然后是一些模块文件和子目录，假如子目录中也有__init__.py那么它就是这个包的子包了。当你将一个包作为模块导入（比如从xml导入dom）的时候，实际上导入了它的__init__.py文件。一个包是一个带有特殊文件__init__.py的目录。__init__.py文件定义了包的属性和方法。其实它可以什么也不定义；可以只是一个空文件，但是必须存在。

python在执行import语句时，它执行了如下操作：

第1步，创建一个新的，空的module对象（它可能包含多个module）；

第2步，把这个module对象插入sys.module中

第3步，装载module的代码（如果需要，首先必须编译）

第4步，执行新的module中对应的代码。

在执行第3步时，首先要找到module程序所在的位置，其原理为：

1）当前目录

2）环境变量中PYTHONPATH中指定的路径列表中依次搜索

3）python的安装设置相关的默认路径，在Unix下，通常为/user/local/lib/python

正因为存在这样的顺序，如果当前路径或PYTHONPATH中存在与标准module同样的module，则会覆盖标准module。也就是说，如果当前目录下存在xml.py，那么执行importxml时，导入的是当前目录下的module，而不是系统标准的xml。

2.简单目录结构下模块调用方法

如t

est中调用fun中的sum函数，目录机构如下：

1）在同一目录下。直接引用名字即可

--maindir

fun.py

test.py

调用方法：importfun

fun.sum()

2）不同目录

--maindir

--subdir

fun.py

sum.py

调用方法1：1）在subdir中创建文件__init__.py（将subdir看成

一个包对待）

2)在test.py中

importsubdir.fun

subdir.fun.sum()

调用方法2：将subdir目录添加到搜索路径，在test中：

#加载到fun所在的目录

importsys

sys.path.append('subdir'）##也可通过添加环境变量的方法，如exportPYTHONPAHT=$PYTHONPATH:maindir/subdir

###此后使用等同于同一目录

importfun

fun.sum()

从上例可看出，如果添加fun.py的路径到模块调用的搜索路径下，那就等同于与其在同一目录下的使用。如上2中的调用方法2。如果搜索路径是fun.py所在的目录，可将其目录添加__init__.py)的方式，看成一个包，通过import目录名.fun的加载方式使用其中函数，如上2中的调用方法1

3.复杂目录架构下模块调用方法

采用sys.path.append加载到文件所在目录的方式，对于少数文件还可，如果目录层次复杂、数目较多时，就会变得吃力。此时就要通过环境变量PYTHONPATH和__init__.py同步使用的方式。如下多级目录：

--dir1

--subdir1

fun.py

--dir2

--subdir2

test.py

调用方法：

1)将maindir作为一个主目录，增加到环境变量中，如miandir所在目录为/system_enc/python/maindir，可将subdir1目录添加到环境变量中： exportPYTHONPAHT=$PYTHONPATH:/system_enc/python/maindir

此后，加载模块时，可以此开始。（通过os.sys.path查看）

2）在需要被调用的模块的所在层级目录中均增加__init__.py文件，到上述所添加的环境变量中的主目录为止。此后编译会将其层目录看做一个包进行处理，查找其下的文件模块。

如上，test.py调用fun.py，就需要在fun.py所在的目录subdir1及上级目录dir1都增加__init__.py文件，到主目录maindir为止。

--maindir

--dir1

__init__.py

__init__.py

fun.py

--dir2

--subdir2

test.py

注：上述中1）和2）缺一不可。__init__.py，被动的模块中需要增加，主调函数所在目录中不需要添加。

4.__init__.py文件内容

一个包是一个带有特殊文件__init__.py的目录。__init__.py文件定义了包的属性和方法。其实它可以什么也不定义；可以只是一个空文件，但是必须存在。__init__.py可以为空，只要它存在，就表明此目录应被作为一个package处理。当然，__init__.py中也可以设置相应的内容，下文详细介绍。

1.定义一个函数

在__init__.py中定义一个函数，可直接通过目录名.函数名来调用。

如上3中，在dir1总定义一个demo函数,在test.py中,可通过importdir1

dir1.demo（）来进行调用

--maindir

--dir1

篇三：python学习笔记--类与模块

类（New-Style-Class）：

名字空间： >>> class User(object): pass >>> u = User()

>>> type(u)

<class '__main__.User'>

>>> u.__class__

<class '__main__.User'>

1、类型 (class) 存储了所有的静态字段和?法 (包括实例?法)，而实例 (instance) 仅存储实例字段，从基类 object 开始，所有继承层次上的实例字段。官?文档将所有成员统称为 Attribute。

2、类型和实例各自拥有?己的名字空间。 3、访问对象成员时，就从这几个名字空间中查找，?非以往的 globals、locals。成员查找顺序: instance.__dict__ -> class.__dict__ -> baseclass.__dict__注意分清对象成员和普通名字的差别。就算在对象?法中，普通名字依然遵循 LEGB (local,enclosing,global,builtin)规则。

字段Field：

? 实例字段存储在 instance.__dict__，代表单个对象实体的状态。 ? 静态字段存储在 class.__dict__，为所有同类型实例共享。 ? 必须通过类型和实例对象才能访问字段。 ? 以双下划线开头的 class 和 instance 成员视为私有，会被重命名。(module 成员不变)

1、可以在任何时候添加实例字段，仅影响该实例名字空间，与其他同类型实例?关。

2、要访问静态字段，除了 class.<name> 外，也可以? instance.<name>。按照成员查找规则，只要没有同名的实例成员，那么就继续查找 class.__dict__。

3、私有字段以双下划线开头，?论是静态还是实例成员，都会被重命名: _<class>__<name>。

4、某些时候，我们既想使用私有字段，又不想放弃外部访问权限。 ? 用重命名后的格式访问。

? 只?一个下划线，仅提醒，不重命名。

属性Property：

1、属性方法多半都很简单，? lambda 实现会更加简洁。鉴于 lambda 函数不能使?赋值语句，故改用 setattr。还得注意别?会被重命名的私有字段名做参数。

2、属性总是比同名实例字段优先，尽可能用属性，而不是直接暴露内部字段。

方法：

1、实例?法和函数的最?区别是 self 这个隐式参数。

2、在?法里访问对象成员时，必须使?对象实例引用。否则会当做普通名字，依照 LEGB 规则查找。

3、个特殊的可选?法：

? __new__: 创建对象实例。构造?法 __new__ 可返回任意类型，但不同的类型会导致 __init__ ?法不被调用。

? __init__: 初始化对象状态。

? __del__: 对象回收前被调用。

继承：

1、除了所有基类的实例字段都存储在 instance.__dict__ 外，其他成员依然是各归各家。

2、如果派?类不提供初始化?法，则默认会查找并使用基类的?法。基类引用存储在 __base__，直接派?类存储在 __subclasses__。

3、可以用 issubclass() 判断是否继承?某个类型，或用 isinstance() 判断实例对象的基类。

4、成员查找规则允许我们?实例引用基类所有成员，包括实例?法、静态?法、静态字段。 但这?有个坑：如果派生类有一个与基类实例?法同名的静态成员，那么首先被找到的是该静态成员，?不是基类的实例?法了。因为派生类的名字空间优先于基类。故此，可以在派生类中创建一个同名实例方法，就可实现“覆盖（override）”。

5、多重继承成员搜索顺序，也就是 mro (method resolution order) 要稍微复杂?点。归纳?下就是：从下到上 (深度优先，从派?类到基类)，从左到右 (基类声明顺序)。mro 和成员查找规则是有区别的，__mro__ 列表中并没有 instance。在多重继承中使用supper会引发一些问题，

复杂化，建议改用组合模式实现类似的功能。

6、__bases__类型对象有两个相似的成员： __base__: 只读，总是返回 __bases__[0]。__bases__: 基类列表，可直接修改来更换基类，影响 mro 顺序。

7、抽象类：无法实例化。如果派?类也是抽象类型，那么可以部分实现或完全不实现基类抽象成员。派?类 Manager 也是抽象类，它实现了部分基类的抽象成员，?增加了新的抽象成员。这种做法在面向对象模式?很常见，只须保证整个继承体系?下来，所有层次的抽象成员都被实现即可。

8、开发类：在运行期也可以随意的改动对象，增加删除成员。增加成员时需要明确放在哪。

将实例方法放到 instance.__dict__ 是没效果的。因为不是 bound method，所以必须显式传递对象引用。正确的做法是放到 class.__dict__。静态?法必须?装饰器 staticmethod、classmethod 包装?下，否则会被当做实例?法。

在运?期调整对象成员，时常要用到几个以字符串为参数的内置函数。其中 hasattr、getattr 依照成员查找规则搜索对象成员，而 setattr、delattr 则直接操作实例和类型的名字空间。

__slots__ 属性会阻止虚拟机创建实例 __dict__，仅为名单中的指定成员分配内存空间。这有助于减少内存占用，提升执?性能，尤其是在需要?量此类对象的时候。可以? dir() 和 inspect.getmembers() 获取实例成员信息。其派?类同样必须? __slots__ 为新增字段分配

存储空间 (即便是空 __slots__ = [])，否则依然会创建 __dict__，反而导致更慢的执?效率。

9、操作符重载

__setitem__ 索引器，像序列或字典类型那样操作对象。

__call__ 像函数那样调?用对象，也就是 callable。

__dir__ 配合 __slots__ 隐藏内部成员。 __getattr__

? __getattr__: 访问不存在的成员。

? __setattr__: 对任何成员的赋值操作。

? __delattr__: 删除成员操作。

? __getattribute__: 访问任何存在或不存在的成员，包括 __dict__。 不要在这?个?法里直接访问对象成员，也不要?hasattr/getattr/setattr/delattr 函数，因为它们会被再次拦截，形成?限循环。正确的做法是直接操作 __dict__。而 __getattribute__ 连 __dict__ 都会拦截，只能?基类的 __getattribute__ 返回结果。

__cmp__ 通过返回数字来判断?小，?而 __eq__ 仅用于相等判断。

模块：

模块是一种组织形式，包含可执行代码、函数和类。

模块对象有?个重要属性：