python常用模块 (五)_python hmac.new

概念

• 一般来说，变成语言中，库、包、模块是同一种概念，是代码组织方式
• Python中只有一种模块对象类型，但是为了模块化组织模块的便利，提供了“包”的概念

模块module，指的是Python的源代码文件
包package，指的是模块组织在一起的包名同名的目录及其相关文件

导入语句

import语句

1. 找到指定的模块，加载和初始化它，生成模块对象。找不到，抛出异常
2. 在import所在的作用域的局部命名空间中，增加名称和上一步创建的对象关联

import functools #导入模块
print(die()) # [..., 'functools']
print(functools) # <module 'functools' from ''path/to/functools.py'>
print(functools.wraps) # <function wraps at 0x0000018ECFA1AF28>
1234
import os.path # 导入os.path,os加入当前名词空间
print(dir()) #[..., 'os']
print(os) # # <module 'os' from ''path/to/os.py'>
print(os.path) # 完全限定名词访问path
1234
import os.path as osp # 导入os.path并赋给osp
print(dir()) # [..., 'osp']
print(osp) # <mdule 'ntpath' form 'path/to/path.py'>
123
def testimport():
	import os.path # 局部
	print(dir())

testimport() # ['os']
print(globals().keys()) # 没有‘os’,但有'testimport'
# dict_keys(['__name__', '__doc__', '__package__',\
'__loader__', '__spec__', '__annotations__', \
'__builtins__', '__file__', '__cached__', 'testimport'])
123456789
import os.stat # 不可导入
# ModuleNotFoundError: No module named 'os.stat'; 'os' is not a package
12
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

总结

• 导入顶级模块，其名词会加入到本地名词空间中，并绑定到其模块对象
• 导入非顶级模块，值将顶级模块吗形参加入到本地名词空间中。导入的模块必须使用完全限定名称来访问
• 如果使用了as，as后的名词直接绑定到导入的模块对象，并将该名词加入到本地名词空间中

导入语句

from语句

from pathlib import Path, PosixPath # 在当前名词空间导入该模块指定的成员
print(dir()) # [..., 'Path', 'PosixPath']
12
from pathlib import * # 在当前名词空间导入该模块所有公共成员（非下划线开头成员）或指定成员
print(dir()) # [...，'Path', 'PosixPath', 'PurePath', 'PurePosixPath', 'PureWindowsPath', 'WindowsPath']
12
from functools import wraps as wr,partial # 别名
print(dir)) # [..., 'wr', 'partial]
12
from os.path import exists

if exists('c://'):
	print('Found') # Found
else:
	print('Not Found')

print(dir()) # [..., 'exists']
print(exists) # <function exists at 0x000001C57FF9AD08>
123456789
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4中方式获得同一个对象exists

import os

print(os.path.exists)
print(exists)
print(os.path.__dict__['exists']) # 字符串
print(getattr(os.path, 'exists')) # 字符串
# 打印结果都为
<function exists at 0x0000022CC806AD08>
12345678
1
2
3
4
5
6
7
8
9

总结

• 找到from子句中指定的模块，加载并初始化它（注意不是导入）
• 对于import子句后的名词
  1.先查from子句导入的模块是否具有该名词的属性
  2.如果不是，则尝试导入该名词的子模块
  3.还没有找到，则抛出ImportError异常
  4.这个名称保存到本地名词空间中，如果有as子句，则使用as子句后的名称

from pathlib import Path # 导入类Path
print(Path, id(Path)) # <class 'pathlib.Path'> 2089961619096

import pathlib as p1 # 导入模块使用别名
print(dir()) # [..., 'Path','p1']
print(p1) # <module 'pathlib' from 'path/to/pathlib.py'>
print(p1.Path, id(p1.Path)) # <class 'pathlib.Path'> 2089961619096
1234567
1
2
3
4
5
6
7
8

可以看出，导入的名词Path和p1.Path是统一个对象

自定义模块

自定义模块：.py文件就是一个模块

# t1.py文件
print('This is t1 module')

class A:
    def showmodule(self):
        print(1, self.__module__, self)
        print(2, self.__dict__)
        print(3, self.__class__.__dict__)
        print(4, self.__class__.__name__)

a = A()
a.showmodule()

# t2.py文件
import t1

a = t1.A()
a.showmodule()

# t3.py文件
from t1 import A as cls

a = cls()
a.showmodule()
123456789101112131415161718192021222324
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

自定义模块命名规范

1. 模块名就是文件名
2. 模块名必须符合标识符的要求，是非数字开头的字母、数字和下划线的组合。
3. test-module.py这样的文件名不能作为模块名，也不要使用中文
4. 不要使用系统模块名来命名，避免冲突
5. 通常模块名为全小写，下划线来分割单词

模块搜索顺序

使用sys.path查看搜索顺序

import sys

# print(*sys.path, sep='\n')
for p in sys.path:
    print(p) 
12345
1
2
3
4
5
6

显示结果为，Python模块的路径搜索顺序

• 当加载一个模块的时候，需要从这些搜索路径中从前到后依次查找，并不搜索这些目录的子目录
• 搜索到模块就加载，搜索不到就抛异常
• 路径也可以为字典、zip文件、egg文件名
• .egg文件，由setuptools库创建的包，第三方库常用的格式。添加了元数据（版本号、依赖项等）信息的zip文件
• 路径顺序为
  程序主目录，程序运行的主程序脚本所在的目录
  PYTHONPATH目录，环境变量PYTHONPATH设置的目录也是搜索模块的路径
  标准库目录，Python自带的模块所在目录

sys.path虽可以被修改，增加新的目录，但不建议修改

模块的重复导入

# t1.py文件
print('This is t1 module')

class A:
    def showmodule(self):
        print(1, self.__module__, self)
        print(2, self.__dict__)
        print(3, self.__class__.__dict__)
        print(4, self.__class__.__name__)

a = A()
a.showmodule()

# t2.py文件
import t1

print('local module')
import t1
import t1

# t2.py文件中执行结果
This is t1 module
1 t1 <t1.A object at 0x0000022070CD9668>
2 {
   }
3 {
   '__module__': 't1', 'showmodule': <function A.showmodule at 0x0000022070CD5268>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
4 A
local module
123456789101112131415161718192021222324252627
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

从执行结果来看，不会产生重复导入的现象。
所有加载的模块都会记录在sys.modules中，sys.modules是储存已经加载过的所有模块的的字典
打印sys.modules可以看到os、os.path都已经加载了

模块运行

• __name__，每个模块都会定义一个__name__特殊变量来储存当前模块的名词，如果不指定，则默认为源代码文件名，如果是包则有限定名。
• 解释器初始化的时候，会初始化sys.modules字典（保存已加载的模块），加载builtins（全局函数、常量）模块、__main__模块、sys模块，以及初始化模块搜索路径sys.path
• Python是脚本语言，任何一个脚本都可以直接执行，也可以作为模块被导入
• 当从标准输入（命令行方式敲代码）、脚本（$ python t1.py) 或交互式读取的时候，会将模块的__name__设置为__main__，模块的顶层代码就在__main__这个作用域中执行。顶层代码：模块中缩进最外层的代码
• 如果是import导入的，其__name__默认就是模块名

# t1.py
# 判断模块是否以程序的方式运行
if __name__ == '__main__':
    print('in __main__') # 程序的方式运行的代码
else:
    print('in imported module') # 模块导入的方式运行的代码

# 执行结果
in __main__

# t2.py
import t1

# 执行结果
in imported module
123456789101112131415
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

if __name__ == '__main__'：用途

1. 本模块的功能测试
   对于非主模块，测试本模块内的函数、类
2. 避免主模块变更的副作用
   顶层代码，没有封装，主模块使用时没有问题。但是，一旦有了新的主模块，老的主模块成了被导入模块，由于原来代码没有封装，就会一并执行

模块的属性

print(__file__)
print(__name__)

# 执行结果
C:/Users/mayn/PycharmProjects/mypython/new/t3.py
__main__
123456
1
2
3
4
5
6
7

包

• 包，特殊的模块
• Python模块支持目录

实验

• 新建一个目录m

import m
print(m)
print(type(m))
print(dir(m)) # 没有__file__
print(m.__path__)

# 执行结果
<module 'm' (namespace)>
<class 'module'>
['__doc__', '__loader__', '__name__', '__package__', '__path__', '__spec__']
_NamespacePath(['C:\\Users\\mayn\\PycharmProjects\\mypython\\m'])
1234567891011
1
2
3
4
5
6
7
8
9
10
11
12

• 一个目录文件没有__file__，但是有__path__
• 上例中可以看出，可以导入目录m，目录也是文件，所以可以导入。
• Python为了解决能在目录模块中写代码，建立了一个特殊文件__init__.py。

pycharm中，创建Directory和创建Pyhon pcakage不同，前者是创建普通的目录，后者是创建一个带有__init__.py文件的目录即包

子模块

• 包目录下的py文件、子目录都是其子模块

m
|-- __init__.py
|-- m1.py
|-- m2
	|-- __init__.py
	|-- m21
		|-- __init__.py
	|-- m22.py
12345678
1
2
3
4
5
6
7
8
9

如上建立子模块和目录和文件，所有的py文件中都写入代码print(__name__)

# 注意观察已经加载的模块、当前名词空间的名词
# import m
# import m.m1
# from m import m1
# from m.m2 import m21
import m.m2.m21

print('-' * 30)
print(dir())

print('-' * 30)
import sys
# print(sys.modules.keys())
print(sorted(filter(lambda x:x.startswith('m'), sys.modules.keys())))

# 执行结果
m
m.m2
m.m2.m21
------------------------------
['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'm']
------------------------
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21