Python盒子：模块、包和程序

最新推荐文章于 2024-07-12 13:19:45 发布

jason_cuijiahui

最新推荐文章于 2024-07-12 13:19:45 发布

阅读量1k

点赞数 1

分类专栏： 2017 python 文章标签： 2017 python

本文链接：https://blog.csdn.net/jason_cuijiahui/article/details/73607254

版权

2017 同时被 2 个专栏收录

75 篇文章 0 订阅

订阅专栏

python

53 篇文章 1 订阅

订阅专栏

命令行参数

test.py

import sys
print('Program arguments:', sys.argv)

这里写图片描述

模块和import语句

简单用法

当前目录如下：
-f1
    - __init__.py
    - haha.py
mycode.py

python mycode.py

会把mycode当前的目录.加入到路径中，如果要用包f1下的模块haha.py（注：文件夹下一定要有 $__init__.py$ ，这样f1才会被当成包），可以这样写：

import f1.haha.py

详细说明

在多个文件之间创建和使用Python代码。
一个模块仅仅是Python代码的一个文件。

引用其它模块的代码时使用import语句，被引用模块中的代码和变量对该程序可见。

导入模块

report.py

author = 'jason'
def get_description():
    '''Return random weather, just like the pros'''
    # 我们只需要名为choice的函数，并无其他名为choice的函数，所以我们直接从random模块导入函数choice(), 无需random.前缀
    from random import choice
    possibilities = ['rain', 'snow', 'sleet', 'fog', 'sun', 'who knows']
    # 此处改为random.return choice(possibilities)会出错
    return choice(possibilities)

weatherman.py

# 导入了整个report模块，但是需要把report.作为get_description()的前缀。通过模块名称限定模块的内容，可以避免命名冲突。
import report
# 可以调用report模块的函数get_description
description = report.get_description()
print('Today\'s weather:', description)
# 可以修改report模块的变量author
report.author = 'Cui'
print('Author: ', report.author)

这里写图片描述

如果被导入的代码被多次使用，就应该考虑在函数外部导入；如果被导入的代码使用有限，就在函数内部导入。

一些人更喜欢把所有的import都放在文件的开头，从而使代码之间的依赖关系清晰。

使用别名导入模块

在主程序weatherman.py中，我们调用了import report。但是，如果存在同名的另一个模块或者你想使用更短更好记的名字，该如何做呢？

import report as wr
description = wr.get_description()
print('Today\'s weather:', description)

导入模块的一部分

在Python中，可以导入一个模块的若干部分。每一部分都有自己的原始名字或者你想起的别名。

from report import get_description as do_it
description = do_it()
print('Today\'s weather:', description)

模块搜索路径

Python会在什么地方寻找文件来导入模块？可以从sys.path中可以看出，Python会通过上述目录进行依次查找，你可以读取和修改sys.path这个列表：
这里写图片描述

最开始的空白输出行是空字符串”，代表当前目录。因为空字符串是在sys.path的开始位置，Python会先搜索当前目录：import report会寻找文件report.py。

第一个匹配到的模块会先被使用，这也就意味着如果你在标准库之前的搜索路径上定义一个模块random，就不会导入标准库中的random模块。

包

为了使Python应用更具可扩展性，你可以把多个模块组织成文件层次，称之为包。

例子

也许我们需要两种类型的天气预报：一种是次日的，一种是下周的。一种可行的方式是新建目录sources，在该目录上新建两个模块daily.py和weekly.py。每一个模块都有一个函数forecast。

boxes
- weather.py
- sources
  - daily.py
  - weekly.py
  - _init_.py

# boxes/weather.py
from sources import daily. weekly
print('Daily forecast:', daily.forecast())
print('Weekly forecast:')
# 从1开始枚举
for number, outlook in enumerate(weekly.forecast(), 1):
    print(number, outlook)

# boxes/sources/daily.py
def forecast():
   'fake daily forecast'
   return 'like yesterday'

def forecast():
    '''Fake weekly forecast'''
    return ['snow', 'more snow', 'sleet', 'freezing rain', 'rain', 'fog', 'hail']

sources目录下_init_.py

该文件可以为空，但Python需要它，以便把该目录作为一个包。

只要一个文件夹下面有个_init_.py 文件，那么这个文件夹就可以看做是一个包。包导入的过程和模块的基本一致，只是导入包的时候会执行此包目录下的_init_.py 而不是模块里面的语句了。

另外，如果只是单纯的导入包，而包的 _init_.py 中又没有明确的其他初始化操作，那么此包下面的模块是不会自动导入的。

检验

test.py
PA
- _init_.py
- wave.py
- PB1
  - _init_.py
  - pb1_m.py
- PB2
  - _init_.py
  - pb2_m.py

# ./PA/PB1/__init__.py
print('PB1->__init__.py')

import PA.PB1.pb1_m
print('---')
import PA.PB1
print('---')

结果：

PB1->__init__.py
---
---

import PA.PB1
print('---')
import PA.PB1.pb1_m
print('---')

结果：

PB1->__init__.py
---
---

import PA.PB1

结果：

PB1->__init__.py

import PA.PB1.pb1_m

结果：

PB1->__init__.py

综上，首次涉及包的调用就会执行_init_.py。

import机制详解

标准import

Python中所有加载到内存的模块都放在 sys.modules 。
当 import 一个模块时首先会在这个列表中查找是否已经加载了此模块
- 如果加载了则只是将模块的名字加入到正在调用 import 的模块(调用方)的 Local 名字空间中。
- 如果没有加载则从 sys.path 目录中按照模块名称查找模块文件，模块可以是py、pyc、pyd，找到后将模块载入内存，并加到 sys.modules 中，并将名称导入到调用方的 Local 名字空间。

一个模块不会重复载入

多个不同的模块都可以用 import 引入同一个模块到自己的 Local 名字空间，其实背后的 PyModuleObject 对象只有一个。

import 只能导入模块，不能导入模块中的对象（类、函数、变量等）

例如：模块 A（A.py）中有个函数 getName，另一个模块不能通过 import A.getName 将 getName导入到本模块，只能用 from A import getName。

嵌套import

顺序嵌套

例如：本模块导入 A 模块（import A），A 中又 import B，B 模块又可以 import 其他模块……

这中嵌套比较容易理解，需要注意的一点就是各个模块的 Local 名字空间是独立的。

对于上面的例子，本模块 import A 之后本模块只能访问模块 A，不能访问模块 B 及其他模块。虽然模块 B 已经加载到内存了，如果访问还要再明确的在本模块中 import B。

循环嵌套

例子

# A.py
from B import D
class C: pass

# B.py
from A import C
class D: pass

执行A.py将会出错。

而若把B.py中的from A import C修改为import B就不会出错。

这跟Python内部 import 的机制是有关的。

from B import D的执行方式

执行from B import D，Python 内部会分成几个步骤：

在 sys.modules 中查找符号 “B”
- 如果符号 B 存在，则获得符号 B 对应的 module 对象。从的 dict 中获得符号 “D” 对应的对象，如果 “D” 不存在，则抛出异常。
- 如果符号 B 不存在，则创建一个新的 module 对象 (注意: 此时，module 对象的 _dict_ 为空)。然后接着执行 B.py ，进而填充的 dict。最后，再从的 dict 中获得 “D” 对应的对象，如果 “D” 不存在，则抛出异常。

例子分析

1、执行 A.py 中的 from B import D，所以在 sys.modules 中并没有存在，首先为 B.py 创建一个 module 对象 () ，注意，这时创建的这个 module 对象是空的，在 Python 内部创建了这个 module 对象之后，就会解析执行 B.py，其目的是填充这个 dict。
2、执行 B.py中的from A import C 在执行B.py的过程中，会碰到这一句，首先检查sys.modules这个module缓存中是否已经存在了，由于这时缓存还没有缓存，所以类似的，Python内部会为A.py创建一个module对象()，然后，同样地，执行A.py中的语句
3、再次执行A.py中的from B import D 这时，由于在第1步时，创建的对象已经缓存在了sys.modules中，所以直接就得到了，但是，注意，从整个过程来看，我们知道，这时还是一个空的对象，所以从这个module中获得符号”D”的操作就会抛出异常。而如果这里只是import B，由于”B”这个符号在sys.modules中已经存在，所以是不会抛出异常的。

包 import

只要一个文件夹下面有个 init.py 文件，那么这个文件夹就可以看做是一个包。包导入的过程和模块的基本一致，只是导入包的时候会执行此包目录下的 init.py 而不是模块里面的语句了。

另外，如果只是单纯的导入包，而包的 _init_.py 中又没有明确的其他初始化操作，那么此包下面的模块是不会自动导入的。

例子

有下面的包结构：

test.py
PA
- _init_.py
- wave.py
- PB1
  - _init_.py
  - pb1_m.py
- PB2
  - _init_.py
  - pb2_m.py

有如下程序：

# test.py
import sys
# 导入模块PA.wave
import PA.wave              #1
# 导入包PA.PB1
import PA.PB1               #2
# 导入模块PA.PB1.pb1_m
import PA.PB1.pb1_m as m1   #3
# 导入模块PA.PB2.pb2_m
import PA.PB2.pb2_m         #4

PA.wave.getName()           #5
m1.getName()                #6
PA.PB.pb2_m.getName()       #7

1) 当执行 #1 后，sys.modules 会同时存在 PA、PA.wave 两个模块，此时可以调用 PA.wave 的任何类或函数了。但不能调用 PA.PB1(2) 下的任何模块。(当前 Local 中有了 PA 名字)

2) 当执行 #2 后，只是将 PA.PB1 载入内存，sys.modules 中会有 PA、 PA.wave、PA.PB1 三个模块，但是 PA.PB1 下的任何模块都没有自动载入内存，此时如果直接执行 PA.PB1.pb1_m.getName() 则会出错，因为 PA.PB1 中并没有 pb1_m 。(当前 Local 中还是只有 PA 名字，并没有 PA.PB1 名字)

3) 当执行 #3 后，会将 PA.PB1 下的 pb1_m 载入内存，sys.modules 中会有 PA、PA.wave、PA.PB1、PA.PB1.pb1_m 四个模块，此时可以执行 PA.PB1.pb1_m.getName() 了。(由于使用了 as，当前 Local中除了 PA 名字，另外添加了 m1 作为 PA.PB1.pb1_m 的别名。)

4) 当执行 #4 后，会将 PA.PB2、PA.PB2.pb2_m 载入内存，sys.modules 中会有 PA、PA.wave、PA.PB1、PA.PB1.pb1_m、PA.PB2、PA.PB2.pb2_m 六个模块。(当前 Local 中还是只有 PA、m1)

下面的 #5，#6，#7 都是可以正确运行的。

关于Local

# test.py
print(0, locals())
print()
import sys
print(1, locals())
print()
import PA.wave
print(2, locals())
print()
import PA.PB1
print(3, locals())
print()
import PA.PB1.pb1_m     # 没有as m1，作为非一级名称，所以无需添加至local
print(4, locals())
print()
import PA.PB2.pb2_m
print(5, locals())
print()

这里写图片描述

# test.py
print(0, locals())
print()
import sys
print(1, locals())
print()
import PA.wave
print(2, locals())
print()
import PA.PB1
print(3, locals())
print()
import PA.PB1.pb1_m as m1   # 有as m1，所以作为一级名称，添加至local
print(4, locals())
print()
import PA.PB2.pb2_m
print(5, locals())
print()

这里写图片描述

python中import 不同目录中的模块的方法

主程序与模块程序在同一目录下

`-- src   
    |-- mod1.py   
    `-- test1.py

若在程序test1.py中导入模块mod1, 则直接使用import mod1或from mod1 import *;

主程序所在目录是模块所在目录的父(或祖辈)目录

`-- src   
    |-- mod1.py   
    |-- mod2   
    |   `-- mod2.py   
    `-- test1.py

若在程序test1.py中导入模块mod2, 需要在mod2文件夹中建立空文件init.py文件(使mod2成为包);

然后使用 from mod2.mod2 import * 或import mod2.mod2.

主程序导入上层目录中模块或其他目录(平级)下的模块

`-- src   
    |-- mod1.py   
    |-- mod2   
    |   `-- mod2.py   
    |-- sub   
    |   `-- test2.py   
    `-- test1.py

若在程序test2.py中导入模块mod1和mod2。首先需要在mod2下建立init.py文件(使mod2成为包)。

import sys   
# 把上级目录即src添加至搜素路径
sys.path.append("..")   
import mod1   
import mod2.mod2

同名问题

模块a 和模块b 中都有同名的 xxx 函数

from a import xxx as name_1
from b import xxx as name_2

同名的模块a和模块a

利用构造的包进行区分

`-- src   
    |-- main.py   
    |-- a1   
    |   `-- a.py   
    |   `-- __init__.py
    |-- a2   
    |   `-- a.py
    |   `-- __init__.py

import a1.a
import a2.a

Python标准库

资料

使用setdefault()和defaultdict()处理缺失的键

setdefault()

读取字典中不存在的键的值会抛出异常。使用字典函数get()返回一个默认值会避免异常发生。与get()的区别在于，setdefault()当键不存在时它会在字典中添加一项。
这里写图片描述

defaultdict()

setdefault方法虽然在一定程度上解决了dict中不存在默认值的问题，但是这时候我们会想，有没有一种字典它本身提供了默认值的功能呢？答案是肯定的，那就是collections.defaultdict。(关于collections模块)

defaultdict()在创建字典时，对每个新的键都会指定默认值。它的参数是一个函数。函数可以是自定义函数，也可以使用函数int()、list()或者dict()返回默认空的值（int()返回0，list()返回空列表[]，dict()返回空字典{}）。若不注明函数参数，新建的初始值会被设置为None。

这里写图片描述

顺便一提，也可以使用lambda来定义你的默认函数：
上面的例子可以转化为

y = defaultdict(lambda : 'default')

使用实例：计数器

# 普通字典
dict_counter = {}
for food in ['spam', 'spam', 'eggs', 'spam']:
    if food not in dict_counter:
        dict_counter[food] = 0
    else:
        dict_counter[food] += 1
for food, count in dict_counter.items():
    print(food, count)

# defaultdict
from collections import defaultdict
dict_counter = defaultdict(int)
for food in ['spam', 'spam', 'eggs', 'spam']:
    dict_counter[food] += 1

for food, count in dict_counter.items():
    print(food, count)

使用Counter()计数

这里写图片描述

most_common降序排序

函数most_common()以降序返回所有元素，或如果给定一个数字n，则会返回前n个结果。

>>> breakfast_counter.mostcommon()
[('spam', 3), ('eggs', 1)]
>>> breakfast_counter.mostcommon(1)
[('spam', 3)]

组合两个计数器的结果

这里写图片描述
A + B：组合AB两个计数结果
A - B：A有而B没有或AB均有而A比B多出的部分的计数结果
B - A：B有而A没有或AB均有而B比A多出的部分的计数结果
A & B：A与B的交集，并取二者中的较小计数
A | B：A与B的并集，并取二者中的较大计数

使用有序字典OrderedDict()按键排序

一个字典中的键的顺序是不可预知的：你可以按照顺序添加键a、b和c，但函数keys()可能返回c、a和b。

有序字典OrderedDict()记忆字典键添加的顺序（与修改顺序无关），然后从一个迭代器按照相同的顺序返回。
这里写图片描述

双端队列：栈+队列

deque是一种双端队列，同时具有栈和队列的特征。它可以从序列的任何一端添加和删除项。

现在，我们从一个词的两端扫向中间，判断是否为回文。

def palindrome(word):
    from collections import deque
    dq = deque(word)
    while len(dq) > 1:
        if dq.popleft() != dq.pop():
            return False
    return True

其实，如果想要写一个快速的判断回文的程序，只需要把字符串反转和原字符串进行比较。

def palindrome(word):
    return word == word[::-1]

使用itertools迭代代码结构（详细见）

itertools就是为了方便生成常用的迭代器的模块

示例：
1. itertools.chain([1, 2], [‘a’, ‘b’])等价于iter([1, 2, ‘a’, b’])—连接
2. itertools.cycle([1, 2])等价于iter([1, 2, 1, 2, …])—循环
3. itertools.accumlate([1, 2, 3, 4])等价于iter([1, 1+2, 1+2+3, 1+2+3+4]

# 可以把一个函数作为accumlate()的第二个参数，代替默认的加法函数
import itertools
def multiply(a, b):
    return a * b
# 等价于iter([1, multiply(1, 2), mltiply(mulitiply(1, 2), 3), multiply(mulitiply(mulitiply(1, 2), 3), 4)]
for item in itertools.accumlate([1, 2, 3, 4], multiply):
    print(item)

使用pprint()友好输出(Data pretty printer)(详细见)

indent — 锁进
width — 一行最大宽度
depth — 打印的深度，这个主要是针对一些可递归的对象，如果超出指定depth，其余的用”…”代替。eg: a=[1,2,[3,4,],5] a的深度就是2; b=[1,2,[3,4,[5,6]],7,8] b的深度就是3
stream — 指输出流对象，如果stream=None，那么输出流对象默认是sys.stdout
compact