python重新载入模块

Ⅰ python怎么载入自己定义的模块

一般来说，我们会将自己写的python模块与python自带的模块分开存放以达到便于维护的目的。
Python 运行环境在查找库文件时是对 sys.path 列表进行遍历，如果我们想在运行环境中注册新的类库，主要有以下三种方法：
在sys.path列表中添加新的路径。
设置PYTHONPATH环境变量。
将库文件复制到sys.path列表中的目录里（如site-packages目录）。
其实，最简单的办法是用 .pth 文件来实现。Python 在遍历已知的库文件目录过程中，如果见到一个 .pth 文件，就会将文件中所记录的路径加入到 sys.path 设置中，这样 .pth 文件说指明的库也就可以被 Python 运行环境找到。
操作：
在Python/Lib/site-package目录下创建一个MyMole.pth文件，其中内容为自定义的模块所在的路径。
Config代码
C:\Project
C:\Project 这样Project目录下的python文件就可以被找到了。

Ⅱ python 怎么安装新的模块

先在命令行里打一下pip，确认下这个模块安装了没有。
如果没有则，
首先安装easy_install
下载地址:https://pypi.python.org/pypi/ez_setup
解压,安装.

pythonez_setup.py

安装好easy_install 之后 再安装pip
下载地址:https://pypi.python.org/pypi/pip
解压,安装.

pythonsetup.pyinstall

之后要安装的包就直接

pipinstallxxx

Ⅲ python中怎么import自己写的模块

只需要在文件中import与你写的文件的文件名一致的模块名即可，这时Python会为你创建一个pyc文件的。
即，如果你已经写了一个名为ssss.py的文件，而现在你需要在名为aaaa.py的文件中使用ssss.py中定义的方法，那么你只需要在aaaa.py中加入import ssss，然后你就可以在aaaa.py中使用ssss.py中的方法（当然方法前需要加模块名来引用）。你还可以在aaaa.py中如下写
from ssss import ....
....可替换为ssss.py中定义的方法的名称
或
from ssss import *
导入ssss.py中的所用定义，使用以上这两种方法导入ssss.py中的定义，你在aaaa.py中可不用使用模块名来引用。

Ⅳ 如何导入python中的模块

定义模块，只要使用文本编辑器，把一些python代码输入到文本中，然后以.py为后缀名进行保存，任何此类文件都会被认为是python模块。
比如说，下面的代码输入到一个文件中，就可以看作是一个模块：
def printme(var): print varif __name__ == '__main__': printme(1)

假设说输入到a.py中，那么import a就可以把这个模块导入。
然后可执行a.printme(3)，屏幕即可打印出3：
>>> a.printme(3)3>>>

一个模块顶层定义的变量，会自动变成模块的属性。例如：
data=[1,2,3]def printme(var): print varif __name__ == '__main__': printme(1)

data变量就是模块的一个属性。其实printme也是一个属性，只不过是一个函数罢了。
引入模块示例如下：（假定此时data=[1,2,3]未定义）

>>> import a>>> a.data Traceback (most recent call last): File "<pyshell#1>", line 1, in <mole> a.dataAttributeError: 'mole' object has no attribute 'data'>>> reload(a)<mole 'a' from 'C:/py\a.pyc'>>>> a.data Traceback (most recent call last): File "<pyshell#3>", line 1, in <mole> a.dataAttributeError: 'mole' object has no attribute 'data'>>>

从上述提示可以看出data属性未定义，此时再在a.py文件中定义data=[1,2,3]，重新加载a模块，并输出data属性：
>>> reload(a)<mole 'a' from 'C:/py\a.py'>>>> a.data[1, 2, 3]>>>

这里的reload函数可以重新加载一个模块。如果在模块代码中更改了，那么需要重新加载。
上面a.data，就是访问模块中的属性。
上面的例子是导入一个文件作为一个模块。
其实python的模块导入还有更丰富的内容。
除了模块名之外，python也可以导入指定目录路径。python代码的目录就称为包。因此，这类导入就称为包导入。事实上，包导入是把计算机上的目录变成python的一个命名空间。而属性就是目录中包含的子目录或者是模块文件。
看下面例子：
在我的桌面上有一个aa文件夹，里面有bb文件夹，bb里面有a.py这个文件。
那么在aa和bb文件夹中分别放置一个__init__.py，之后，在命令行中import aa.bb.a，就可以导入模块a了。

Ⅳ python怎么导自定义模块

python中导入自定义模块的方法：

1、py执行文件和模块同属于同个目录（父级目录）
直接使用import <模块名>命令导入模块，然后使用模块.变量|函数语句即可使用模块中的函数。
2、先使用sys模块导入自定义模块的路径，然后使用import导入模块
导入步骤：

1、使用import sys导入sys模块
2、使用sys.path.append(path)函数导入自定义模块所在目录
3、然后使用import <模块名>命令导入模块
更多Python知识请关注Python自学网。

Ⅵ python如何导入自定义模块

1、相同目录下，若在程序test1.py中导入模块mod1,
则直接使用import
mod1或from
mod1
import
*;
2、主程序所在目录是模块所在目录的父(或祖辈)目录则要建立空文件__init__.py文件然后使用
from
mod2.mod2
import
*

Ⅶ python 类和继承，包及模块导入 求解答

一 .mole

通常模块为一个文件，直接使用import来导入就好了。可以作为mole的文件类型有".py"、".pyo"、".pyc"、".pyd"、".so"、".dll"。

二. package

通常包总是一个目录，可以使用import导入包，或者from + import来导入包中的部分模块。包目录下为首的一个文件便是 __init__.py。然后是一些模块文件和子目录，假如子目录中也有 __init__.py 那么它就是这个包的子包了。

一.模块你可以使用import语句将一个源代码文件作为模块导入.例如:

[python]view plain

• #file:spam.py

• a=37#一个变量

• deffoo:#一个函数

• print"I'mfoo"

• classbar:#一个类

• defgrok(self):

• print"I'mbar.grok"

• b=bar()#创建一个实例

使用import spam 语句就可以将这个文件作为模块导入。系统在导入模块时，要做以下三件事：

• 1.为源代码文件中定义的对象创建一个名字空间，通过这个名字空间可以访问到模块中定义的函数及变量。


• 2.在新创建的名字空间里执行源代码文件.


• 3.创建一个名为源代码文件的对象，该对象引用模块的名字空间，这样就可以通过这个对象访问模块中的函数及变量，如：



[python]view plain

• importspam#导入并运行模块spam

• printspam.a#访问模块spam的属性

• spam.foo()

• c=spam.bar()

用逗号分割模块名称就可以同时导入多个模块:

[python]view plain

• importsocket,os,regex

• 模块导入时可以使用 as 关键字来改变模块的引用对象名字:

[python]view plain

• importosassystem

• importsocketasnet,threadasthreads

• system.chdir("..")

• net.gethostname()

• 使用from语句可以将模块中的对象直接导入到当前的名字空间. from语句不创建一个到模块名字空间的引用对象，而是把被导入模块的一个或多个对象直接放入当前的名字空间:



[python]view plain

• fromsocketimportgethostname#将gethostname放如当前名字空间

• printgethostname()#直接调用

• socket.gethostname()#引发异常NameError:socket

from语句支持逗号分割的对象，也可以使用星号(*)代表模块中除下划线开头的所有对象:

[python]view plain

• fromsocketimportgethostname,socket

• fromsocketimport*#载入所有对象到当前名字空间

• 不过，如果一个模块如果定义有列表__all__，则from mole import * 语句只能导入__all__列表中存在的对象。



[python]view plain

• #mole:foo.py

• __all__=['bar','spam']#定义使用`*`可以导入的对象

另外, as 也可以和 from 联合使用:

[python]view plain

• h=hostname()

import 语句可以在程序的任何位置使用，你可以在程序中多次导入同一个模块，但模块中的代码*仅仅*在该模块被首次导入时执行。后面的import语句只是简单的创建一个到模块名字空间的引用而已。sys.moles字典中保存着所有被导入模块的模块名到模块对象的映射。这个字典用来决定是否需要使用import语句来导入一个模块的最新拷贝.

• from mole import * 语句只能用于一个模块的最顶层.*特别注意*：由于存在作用域冲突，不允许在函数中使用from 语句。


• 每个模块都拥有 __name__ 属性，它是一个内容为模块名字的字符串。最顶层的模块名称是 __main__ .命令行或是交互模式下程序都运行在__main__ 模块内部. 利用__name__属性，我们可以让同一个程序在不同的场合（单独执行或被导入)具有不同的行为，象下面这样做：



[python]view plain

• #检查是单独执行还是被导入

• if__name__=='__main__':

• #Yes

• statements

• else:

• #No(可能被作为模块导入)

• statements



• 模块搜索路径


• 导入模块时,解释器会搜索sys.path列表,这个列表中保存着一系列目录。一个典型的sys.path 列表的值：


• Linux:


• ['', '/usr/local/lib/python2.0',


• '/usr/local/lib/python2.0/plat-sunos5',


• '/usr/local/lib/python2.0/lib-tk',


• '/usr/local/lib/python2.0/lib-dynload',


• '/usr/local/lib/python2.0/site-packages']


• Windows:


• ['', 'C:\WINDOWS\system32\python24.zip', 'C:\Documents and Settings\weizhong', 'C:\Python24\DLLs', 'C:\Python24\lib', 'C:\Python24\lib\plat-win', 'C:\Python24\lib\lib-tk', 'C:\Python24\Lib\site-packages\pythonwin', 'C:\Python24', 'C:\Python24\lib\site-packages', 'C:\Python24\lib\site-packages\win32', 'C:\Python24\lib\site-packages\win32\lib', 'C:\Python24\lib\site-packages\wx-2.6-msw-unicode']


• 空字符串 代表当前目录. 要加入新的搜索路径,只需要将这个路径加入到这个列表.




• 模块导入和汇编


• 到现在为止，本章介绍的模块都是包含Python源代码的文本文件. 不过模块不限于此，可以被 import 语句导入的模块共有以下四类:


• •使用Python写的程序( .py文件)


• •C或C++扩展(已编译为共享库或DLL文件)


• •包(包含多个模块)


• •内建模块(使用C编写并已链接到Python解释器内)


• 当查询模块 foo 时,解释器按照 sys.path 列表中目录顺序来查找以下文件(目录也是文件的一种):


• 1.定义为一个包的目录 foo


• 2.foo.so, foomole.so, foomole.sl,或 foomole.dll (已编译扩展)


• 3.foo.pyo (只在使用 -O 或 -OO 选项时)


• 4.foo.pyc


• 5.foo.py




• 对于.py文件,当一个模块第一次被导入时,它就被汇编为字节代码,并将字节码写入一个同名的 .pyc文件.后来的导入操作会直接读取.pyc文件而不是.py文件.(除非.py文件的修改日期更新,这种情况会重新生成.pyc文件) 在解释器使用 -O 选项时，扩展名为.pyo的同名文件被使用. pyo文件的内容虽去掉行号,断言,及其他调试信息的字节码，体积更小,运行速度更快.如果使用-OO选项代替-O,则文档字符串也会在创建.pyo文件时也被忽略.


• 如果在sys.path提供的所有路径均查找失败,解释器会继续在内建模块中寻找,如果再次失败，则引发 ImportError 异常.


• .pyc和.pyo文件的汇编,当且仅当import 语句执行时进行.


• 当 import 语句搜索文件时,文件名是大小写敏感的。即使在文件系统大小写不敏感的系统上也是如此(Windows等). 这样, import foo 只会导入文件foo.py而不会是FOO.PY.




• 重新导入模块


• 如果更新了一个已经用import语句导入的模块，内建函数reload()可以重新导入并运行更新后的模块代码.它需要一个模块对象做为参数.例如:


• import foo


• ... some code ...


• reload(foo) # 重新导入 foo


• 在reload()运行之后的针对模块的操作都会使用新导入代码，不过reload()并不会更新使用旧模块创建的对象，因此有可能出现新旧版本对象共存的情况。 *注意* 使用C或C++编译的模块不能通过 reload() 函数来重新导入。记住一个原则，除非是在调试和开发过程中，否则不要使用reload()函数.

Ⅷ python怎么导入同一包的模块

一、何为模块

1.一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。

2.模块目的和函数，对象等一样，是为了代码的复用性而存在的。即一个py程序写了很多功能，也可以被其他py程序调用。被调用后被作为模块，此时会产生一个pyc的文件即为这个模块的缓存文件，相当于编译了模块文件使该py模块被调用的速度变快。一个大的项目一个人肯定是不行的，所以模块也为程序员相互间的合作提供了便利。

二、模块妙用

1.import

只需要在py程序开头加上import 文件名（不能有.py后缀）。例如，模块的文件名是span.py，那么只需在自己的py程序加import span。

2. import可以在程序的任意位置调用，但一次调用后会驻留内存，下次再调用会直接调用内存中的模块（python的优化）。

3.个模块都是一个独立的名称空间，定义在这个模块中的函数，把这个模块的名称空间当做全局名称空间，这样我们在编写自己的模块时，就不用担心我们定义在自己模块中全局变量会在被导入时，与使用者的全局变量冲突。

print('from the spam.py')

money=1000def read1(): print('spam->read1->money',1000)def read2(): print('spam->read2 calling read')
read1()def change(): global money
money=0

支持tab自动补全

Ⅸ Python中怎么引入模块

项目中想使用以前的代码，或者什么样的需求致使你需要导入外部的包
如果是web 下，比如说django ，那么你新建一个app，把你需要导入的说用东东，都写到这个app中，然后在setting中的app也配上基本就ok了
如果是本地代码，可以有几种方式，
1、这种最简单，也可能最不实用，将你的外部文件放到跟需要调用外部文件的文件同一个包下，同一目录
folder
------toinvoke.py
------tobeinvoded.py
这样在toinvoke.py 中引入
import toveinvoked 或 from tobeinvoked import *
即可
2、你的其他文件不是单个文件，或者不能如上所说放到同一目录下，而是在不同目录中，子目录
folder
------tobeinvodedA.py
------tobeinvodedB.py
------tobeinvodedC.py
toinvoke.py
这种情况，现在folder 下新建一个__init__.py 的空文件，此时的folder不再是一个普通的文件夹，而是一个包 package,现在像这样
folder #文件夹 现在的性质为一个python包package
------__init__.py
------tobeinvoded.py
------tobeinvodedA.py
------tobeinvodedB.py
------tobeinvodedC.py
toinvoke.py
这样在toinvoke.py 中引入
import folder.toveinvoked 或 from folder.tobeinvoked import *
即可
3、同理，如果是如下的情况,folderB中的模块要调用folderA中的模块，方法同上，有什么改变，你已经知道了

folderA
------tobeinvoded.py
------tobeinvodedA.py
------tobeinvodedB.py
------tobeinvodedC.py

folderB
--------toinvoke.py

这样在toinvoke.py 中引入

import folder.toveinvoked 或 from folder.tobeinvoked import *
即可
4、将要被调用的代码拷贝到$PYTHONHOME$\Lib\site-packages 下面，这个就跟Eclipse插件安装差不多

5、在$PYTHONHOME$\Lib\site-packages 下面新建一个.pth文件,比如说是MyPackage.pth,里面的内容是你的包的绝对路径比如：E:/PythonPrj
那么，在E:/PythonPrj下的所有包都可以按照包所在的相对路径引入，这个跟Eclipse插件安装的link 方式差不多
6、跟上面的差不多，也可以加个环境变量，这个就不多说了

总结、看看Python的包搜索路径
Python会在以下路径中搜索它想要寻找的模块：
1. 程序所在的文件夹
2. 标准库的安装路径
3. 操作系统环境变量PYTHONPATH所包含的路径

将自定义库的路径添加到Python的库路径中去，有如下两种方法：
1. 动态的添加库路径。在程序运行过程中修改sys.path的值，添加自己的库路径
import sys
sys.path.append(r'your_path')
2. 在Python安装目录下的\Lib\site-packages文件夹中建立一个.pth文件，内容为自己写的库路径。示例如下
E:\\work\\Python\\http
E:\\work\\Python\\logging

Ⅹ Python调用自定义模块方法有什么

import语句

自定义模块可以采用import语句来进行引入，其操作步骤是先导入模块，再调用模块中包含的函数，可将自定义模块放入当前目录，便于解释器路径搜索，以下是导入自定义hello.py模块，并调用World函数的实例：

#!/usr/bin/python

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

#导入模块

import hello

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

support.print_func("World")

输出结果为：

Hello World!

以上实例也可以采用from…import的方法进行实现，是指从一个模块中导入指定的部分到当前命名空间中，以上功能可写成：

#!/usr/bin/python

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

from hello import World

如果要将模块中的所有内容全部导入当前命名空间，可采用from…import*的方法，具体实例如下：

#!/usr/bin/python

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

from hello import *

还需注意，当要导入一个模块时，Python解释器会对模块的位置进行搜索，具体搜索顺序规律如下：

1.当前目录;

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

3.如果都找不到，Python会察看默认路径。