python编程语言模块_Python 模块引用和编译

Python 编译

以下是常见Python文件

py 源文件

pyc 源文件编译后的文件

pyo 源文件优化编译后的文件

pyd 其他语言写的python库

python并非完全是解释性语言，它是有编译的，先把py文件编译成pyc或者pyo，然后由python的执行，相对于py文件来说，编译成pyc和pyo本质上和py没有太大区别，只是对于这个模块的加载速度提高了，并没有提高代码的执行速度，通常情况下不用主动去编译pyc文件，文档上说只要调用了import 那么model.py就会先编译成pyc然后加载

如果需要特殊的单独编译，则只需要使用py_complie这个模块就行了，如下

import py_compile

py_compile.compile(r‘H:\\test.py‘)

compile原型：

compile(file[, cfile[, dfile[, doraise]]])

file 表示需要编译的py文件的路径

cfile 表示编译后的pyc文件名称和路径，默认为直接在file文件名后加c 或者 o，o表示优化的字节码

dfile 错误消息保存的路径

doraise 可以是两个值，True或者False，如果为True，则会引发一个PyCompileError，否则如果编译文件出错，则会有一个错误，默认显示sys.stderr中，而不会引发异常

如果要把一个文件夹下的所有py文件都进行编译，则用下面的命令

import compileall

compileall.compile_dir(dirpath)

dirpath是我们要编译的的绝对路径

如果要编译pyo文件则

编译成 pyo 就是在执行 python -O -m py_compile file.py

其中file.py就是我们要编译的源文件

模块引入

模块间相互独立相互引用是任何一种编程语言的基础能力。对于“模块”这个词在各种编程语言中或许是不同的，但我们可以简单认为一个程序文件是一个模块，文件里包含了类或者方法的定义。对于编译型的语言，比如C#中的一个.cs文件，Java中的一个.java或者编译后的.class文件可以认为是一个模块（但常常不表述为模块）；对于解释型的语言会更加直观些，比如PHP的.php文件，在Python中就是.py文件可以认为是一个模块。在“模块”之上有“包”，主要是为了方便组织和管理模块。比如C#中编译后的.dll文件（但常常不表述为包Package，而是库Library），Java将.class打包后的.jar文件，PHP的.phar文件（模仿Java包），在Python中一个特殊定义的文件夹是一个包，可以打包为egg文件。但对于解释型语言“包”并没有编译成低级语言而后打包的意思，只是更加方便模块化和管理模块间的依赖。每种编程语言对于模块和包管理都有一定的约定，不了解这些约定，那会给学习这种语言的带来障碍。下面我想来梳理一下Python的这些约定。

其中Java在有模块相互引用时通常需要到最上层目录对文件进行编译，Python 解释器命令有一些选项是用于模块引用，下面顺带提提解释器常用的选项

选项

作用

-d

提供调试输出

-O

生成优化的字节码(生成.pyo文件）

-S

不导入site模块，以在启动时自动查找Python路径

-v

冗余输出

-m mod

将一个模块以脚本的方式运行

-Q opt

除尘选项

-c cmd

运行系统命令，一般是shell内部命令

import 语句

模块的引入

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

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

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

模块名.函数名

当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。

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

support.py：

def print_func( par ):

print "Hello : ", par

return

引用文件：

#!/usr/bin/python

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

# 导入模块

import support

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

support.print_func("Runoob")

以上实例输出结果：

Hello : Runoob

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

From…import

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

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

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

from fib import fibonacci

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

From…import*

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

from modname import *

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

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

from math import *

搜索路径

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

当前目录

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

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

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

Windows

In [1]: import sys

In [2]: sys.path

Out[2]:

['',

'D:\\Dev\\Anaconda3\\Scripts',

'D:\\Dev\\Anaconda3\\python36.zip',

'D:\\Dev\\Anaconda3\\DLLs',

'D:\\Dev\\Anaconda3\\lib',

'D:\\Dev\\Anaconda3',

'D:\\Dev\\Anaconda3\\lib\\site-packages',

'D:\\Dev\\Anaconda3\\lib\\site-packages\\Babel-2.5.0-py3.6.egg',

'D:\\Dev\\Anaconda3\\lib\\site-packages\\win32',

'D:\\Dev\\Anaconda3\\lib\\site-packages\\win32\\lib',

'D:\\Dev\\Anaconda3\\lib\\site-packages\\Pythonwin',

'D:\\Dev\\Anaconda3\\lib\\site-packages\\IPython\\extensions',

'C:\\Users\\oneTO\\.ipython']

Linux

In [1]: import sys

In [2]: sys.path

Out[2]:

['',

'/home/whoami/.pyenv/versions/anaconda3/envs/my-r-env/bin',

'/home/whoami/.pyenv/versions/anaconda3/envs/my-r-env/lib/python36.zip',

'/home/whoami/.pyenv/versions/anaconda3/envs/my-r-env/lib/python3.6',

'/home/whoami/.pyenv/versions/anaconda3/envs/my-r-env/lib/python3.6/lib-dynload',

'/home/whoami/.pyenv/versions/anaconda3/envs/my-r-env/lib/python3.6/site-packages',

'/home/whoami/.pyenv/versions/anaconda3/envs/my-r-env/lib/python3.6/site-packages/IPython/extensions',

'/home/whoami/.ipython']

也可以通过sys模块的append方法在Python环境中增加搜索路径

In [3]: sys.path.append('/home/whoami/DjangoEnv/')

In [4]: sys.path

Out[4]:

['',

'/home/whoami/.pyenv/versions/anaconda3/envs/my-r-env/bin',

'/home/whoami/.pyenv/versions/anaconda3/envs/my-r-env/lib/python36.zip',

'/home/whoami/.pyenv/versions/anaconda3/envs/my-r-env/lib/python3.6',

'/home/whoami/.pyenv/versions/anaconda3/envs/my-r-env/lib/python3.6/lib-dynload',

'/home/whoami/.pyenv/versions/anaconda3/envs/my-r-env/lib/python3.6/site-packages',

'/home/whoami/.pyenv/versions/anaconda3/envs/my-r-env/lib/python3.6/site-packages/IPython/extensions',

'/home/whoami/.ipython',

'/home/whoami/DjangoEnv/']

PYTHONPATH 变量

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

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

set PYTHONPATH=c:\python27\lib;

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

set PYTHONPATH=/usr/local/lib/python

Python中的包

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

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

pkg0

├── __init__.py

├── main.py

├── pkg1

│ ├── A.py

│ └── __init__.py

└── pkg2

├── B.py

└── __init__.py

引用子目录的包

在main.py中引用package2/B的方法

# main.py

from pkg2 import B

B.someMethod()

这个写法很糟糕，但能解决目前问题。糟糕的地方在于隐晦的引入pkg2。更好的方式是相对引用。

from .pkg2 import B

B.someMethod()

但如果用 python pkg0/main.py 执行会报错，此处原因请参考这。原因是相对引用默认作为包的方式才能运行。

正确执行方法(linux shell下)： python -m pkg0.main

这个写法也不够好！B 在具体的代码行，看不出其出处。更好的方式是

from . import t2

pkg2.B.someMethod()

但运行时会报错！

AttributeError: ‘module‘ object has no attribute ‘B‘

大致意思是， 模块对象没有B属性！这点从java/.net转过来的也许有一点不习惯！

python引入一个模块(import m) <==> 引入m/__init__.py文件，所以可以在m/__init__.py引入本地模块

import B

-or-

from . import B

这样就能解决在运行上层文件main.py时引用下层模块不会报错了。

跨目录引用

在 pkg1.__init__.py 中 import 本地模块

from . import A

然后在模块 pkg2.B 中可以这样引用模块 pkg1.A

from .. import pkg1

pkg1.A.someMethod()

其中 . 和 .. 有点类似于Linux文件路径的意思。