Python之模块与包(上)

Posted 肌力兔子。

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python之模块与包(上)相关的知识,希望对你有一定的参考价值。

1、什么是模块

定义:一个模块就是一个包含了python定义和声明的文件(文件名就是模块名字加上.py的后缀),模块可以被导入使用。

先来定义个模块:

#spam.py:spam 模块里有 print 的语句,当加载 spam 模块的时候,会解析出来执行
print(from the spam.py)

money=1000

def read1():
    print(spam模块:,money)

def read2():
    print(spam模块)
    read1()

def change():
    global money
    money=0

2、模块导入方法 import

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

#模块可以包含可执行的语句和函数的定义,这些语句的目的是初始化模块,它们只在模块名第一次遇到导入import语句时才执行(import语句是可以在程序中的任意位置使用的,且针对同一个模块import多次,为了防止你重复导入,python的优化手段是:第一次导入后就将模块名加载到内存了,后续的import语句仅是对已经加载到内存中的模块对象增加了一次引用,不会重新执行模块内的语句),如下

技术分享图片
#test.py
import spam #只在第一次导入时才执行spam.py内代码,此处的显式效果是只打印一次‘from the spam.py‘,当然其他的顶级代码也都被执行了,只不过没有显示效果.
import spam
import spam
import spam

‘‘‘
执行结果:
from the spam.py
‘‘‘
test.py

首次 import 做了三件事


#1.为源文件(spam模块)创建新的名称空间,在spam中定义的函数和方法若是使用到了global时访问的就是这个名称空间。

#2.在新创建的名称空间中执行模块中包含的代码,见初始导入import spam
提示:导入模块时到底执行了什么?
In fact function definitions are also ‘statements’ that are ‘executed’; the execution of a module-level function definition enters the function name in the module’s global symbol table.
事实上函数定义也是“被执行”的语句,模块级别函数定义的执行将函数名放入模块全局名称空间表,用globals()可以查看
有点绕是不是?简单一句话,就是把模块里面的函数放到当前文件里面,相当于在当前文件里面写了这么一个函数,并加载

#3.创建名字spam来引用该命名空间
这个名字和变量名没什么区别,都是‘第一类的’,且使用spam.名字的方式可以访问spam.py文件中定义的名字,spam.名字与test.py中的名字来自两个完全不同的地方。


被导入模块有独立的名称空间

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

技术分享图片
#test.py
import spam 
money=10
print(spam.money)

‘‘‘
执行结果:
from the spam.py
1000
‘‘‘



#test.py
import spam
def read1():
    print(========)
spam.read1()

‘‘‘
执行结果:
from the spam.py
执行流程:通过:spam->找:read1->打印:money 1000
‘‘‘



#test.py
import spam
money=1
spam.change()
print(money)

‘‘‘
执行结果:
from the spam.py
1
‘‘‘
View Code


为模块名起别名

为已经导入的模块起别名的方式对编写可扩展的代码很有用

import spam as sm
print(sm.money)

例1:有两中sql模块mysql和oracle,根据用户的输入,选择不同的sql功能

技术分享图片
#mysql.py
def sqlparse():
    print(from mysql sqlparse)
#oracle.py
def sqlparse():
    print(from oracle sqlparse)

#test.py
db_type=input(>>: )
if db_type == mysql:
    import mysql as db
elif db_type == oracle:
    import oracle as db

db.sqlparse()
View Code

例2:假设有两个模块xmlreader.py和csvreader.py,它们都定义了函数read_data(filename):用来从文件中读取一些数据,但采用不同的输入格式。可以编写代码来选择性地挑选读取模块

技术分享图片
if file_format == xml:
    import xmlreader as reader
elif file_format == csv:
    import csvreader as reader
data=reader.read_date(filename)
View Code


3、模块导入方法 from ... import

from spam import read1,read2

from...import 与 import 的对比

#唯一的区别就是:使用from...import...则是将spam中的名字直接导入到当前的名称空间中,所以在当前名称空间中,直接使用名字就可以了、无需加前缀:spam.

#from...import...的方式有好处也有坏处
好处:使用起来方便了
坏处:容易与当前执行文件中的名字冲突

验证一:当前位置直接使用read1和read2就好了,执行时,仍然以spam.py文件全局名称空间

技术分享图片
#测试一:导入的函数read1,执行时仍然回到spam.py中寻找全局变量money
#test.py
from spam import read1
money=1000
read1()
‘‘‘
执行结果:
from the spam.py
通过:spam->执行:read1->打印:money 1000
‘‘‘

#测试二:导入的函数read2,执行时需要调用read1(),仍然回到spam.py中找read1()
#test.py
from spam import read2
def read1():
    print(==========)
read2()
‘‘‘
执行结果:
from the spam.py
spam->read2 calling read1
spam->read1->money 1000
‘‘‘
View Code

验证二:如果当前有重名read1或者read2,那么会有覆盖效果。

技术分享图片
#测试三:导入的函数read1,被当前位置定义的read1覆盖掉了
#test.py
from spam import read1
def read1():
    print(==========)
read1()
‘‘‘
执行结果:
from the spam.py
==========
‘‘‘
View Code

验证三:导入的方法在执行时,始终是以源文件为准的

技术分享图片
from spam import money,read1
money=100 #将当前位置的名字money绑定到了100
print(money) #打印当前的名字
read1() #读取spam.py中的名字money,仍然为1000

‘‘‘
from the spam.py
spam->read1->money 1000
‘‘‘
View Code


from ... import * 调用模块的所有方法,尽量不要用,可能和自己定义的起冲突

#大部分情况下我们的python程序不应该使用这种导入方式,因为*你不知道你导入什么名字,很有可能会覆盖掉你之前已经定义的名字,而且可读性极其的差。

技术分享图片
from spam import * # 将模块spam中所有不是以下划线(_)开头的名字都导入到当前名称空间
print(money)
print(read1)
print(read2)
print(change)

‘‘‘
执行结果:
from the spam.py
1000
<function read1 at 0x1012e8158>
<function read2 at 0x1012e81e0>
<function change at 0x1012e8268>
可以使用__all__来控制*(用来发布新版本),在spam.py中新增一行
__all__=[‘money‘,‘read1‘] #这样在另外一个文件中用from spam import *就这能导入列表中规定的两个名字
View Code


4、模块与脚本

#编写好的一个python文件可以有两种用途:

一:脚本,一个文件就是整个程序,用来被执行

二:模块,文件中存放着一堆功能,用来被导入使用


#python为我们内置了全局变量__name__,

当文件被当做脚本执行时:__name__ 等于‘__main__‘

当文件被当做模块导入时:__name__等于模块名


#作用:用来控制.py文件在不同的应用场景下执行不同的逻辑

if __name__ == ‘__main__‘:

run() # 执行当前脚本里的逻辑

技术分享图片
#fib.py

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

if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))


#执行:python fib.py <arguments>
python fib.py 50 #在命令行执行
脚本例子


5、模块搜索路径

模块的查找顺序是:内存中已经加载的模块->内置模块->sys.path路径中包含的模块

1、在第一次导入某个模块时(比如spam),会先检查该模块是否已经被加载到内存中(当前执行文件的名称空间对应的内存),如果有则直接引用

ps:python解释器在启动时会自动加载一些模块到内存中,可以使用sys.modules查看

2、如果没有,解释器则会查找同名的内建模块

3、如果还没有找到就从sys.path给出的目录列表中依次从左到右寻找spam.py文件。

#需要特别注意的是:我们自定义的模块名不应该与系统内置模块重名。比如:不要自定义一个叫 json.py 的模块

#在初始化后,python程序可以修改sys.path,路径放到前面的优先于标准库被加载。

>>> import sys

>>> sys.path.append(/a/b/c/d)

>>> sys.path.insert(0,/x/y/z) #排在前的目录,优先被搜索

注意:搜索时按照sys.path中从左到右的顺序查找,位于前的优先被查找,sys.path中还可能包含.zip归档文件和.egg文件,python会把.zip归档文件当成一个目录去处理。


6、编译python文件

为了提高加载模块的速度,强调强调强调:提高的是加载速度而绝非运行速度。

python解释器会在__pycache__目录中下缓存每个模块编译后的版本,格式为:module.version.pyc。

通常会包含python的版本号。例如,在CPython3.3版本下,spam.py模块会被缓存成__pycache__/spam.cpython-33.pyc。这种命名规范保证了编译后的结果多版本共存。

Python检查源文件的修改时间与编译的版本进行对比,如果过期就需要重新编译。这是完全自动的过程。并且编译的模块是平台独立的,所以相同的库可以在不同的架构的系统之间共享,即pyc是一种跨平台的字节码,是由python虚拟机来执行的,但是pyc的内容跟python的版本相关,不同的版本编译后的pyc文件不同,2.5编译的pyc文件不能到3.5上执行,并且pyc文件是可以反编译的,因而它的出现仅仅是用来提升模块的加载速度的,不是用来加密的。

.



















以上是关于Python之模块与包(上)的主要内容,如果未能解决你的问题,请参考以下文章

python之模块与包

python之模块与包

python之模块与包

Python/模块与包之模块

Python之模块与包(下)

py基础之模块与包