什么是模块

  1. 使用python编写的代码（.py文件）
  2. 已被编译为共享库或DLL的C或C++扩展
  3. 含一组模块的包
  4. 使用C编写并链接到Python解释器的内置模块

    为何要使用模块

    为了实现代码和功能的复用。

    案例一：import自定义模块my_module.py

    文件名my_module.py，模块名my_module ```python

    my_module.py

    print(‘from the my_module.py’) money = 100

def read1(): print(‘my_module->read1->money’,money)

def read2(): print(‘my_module->read2 calling read1’) read1()

def change(): global money money = 0

  1. 然后在别的文件中可以引用my_module这个模块。
  2. ```python
  3. import  my_module
  5. my_module.read1()
  6. my_module.read2()

模块可以包含可执行的语句和函数定义，他们的目的是初始化模块，他们只在模块名第一次遇到导入语句import时才调用。
import语句可以在程序中的任意位置使用，同一个模块也可以import多次，但python在第一次导入后将模块加载到内存了，后续的只是对内存中模块对象的引用，不会重新执行模块内的语句。

每一个模块都是一个独立的命名空间，所以不用担心模块中的全局变量会与使用者的全局变量冲突。

  1. import my_module
  3. money = 1
  4. my_module.change()
  5. print(money)
  6. print(my_module.money)
  • 总结：首次导入模块my_module时会做三件事
    • 为原文件my_module创建一个新的命名空间，在my_module中若是定义了全局变量使用了global访问的就是这个命名空间
    • 在新创建的这个命名空间执行模块的代码
    • 创建名字my_module来引用该命名空间

      为模块名取别名

      ```python import my_module as m1

print(m1.money)

  2. - 实例
  4. 有两种sql模块mysql和oracle，根据用户的输入，选择不同的sql功能
  5. ```python
  6. # mysql.py
  7. def sqlparse():
  8.     print("this is mysql sqlparse")
  10. # oracle.py
  11. def sqlparse():
  12.     print("this is mysql sqlparse")
  14. # test.py
  16. db_type = input("请输入选择的服务>>")
  17. if db_type == 'mysql':
  18.     import mysql as db
  19. if db_type == 'oracle':
  20.     import oracle as db
  22. db.sqlparse()

from … import …

对比import … ，from … import …也会创建新的名称空间，但是将my_module中的名字直接导入到当前的名
称空间中，在当前名称空间中，直接使用名字就可以了。

  • import：my_module.函数名
  • from … import …：函数名 ```python from my_module import read1,read2 money = 1000 def read1(): print(‘‘10)

read1()

导入的函数read1，被当前位置定义的read1覆盖掉了(解决方法是给导入的函数read1起别名)

read2()

导入的函数read2，执行时需要调用read1(),仍然回到my_module.py中找read1()

运行结果

from the my_module.py

my_module->read2 calling read1 my_module->read1->money 100

  1. **from my_module import * **把my_module中所有的**不是以下划线(_)开头**的名字都导入到当前位置<br />大部分情况下我们的python程序不应该使用这种导入方式，因为*你不知道你导入什么名字，很有可能<br />会覆盖掉你之前已经定义的名字。而且可读性极其的差，在交互式环境中导入时没有问题。
  3. 在my_module.py中新增一行
  4. ```python
  5. __all__ = ['money','read1']
  6. # 这样在另外一个文件中用from my_module import *就这能导入列表中规定的两个名字
  • 编写好的一个python文件可以有两种用途：
    • 脚本，一个文件就是整个程序，用来被执行
    • 模块，文件中存放着一堆功能，用来被导入使用
  • python为我们内置了全局变量name
    • 当文件被当作脚本执行时：name 等于’main‘
    • 当文件被当做模块导入时： name等于模块名
  • 作用：用来控制.py文件在不同的应用场景下执行不同的逻辑（或者是在模块文件中测试代码）
    • if name == ‘main‘: ```python def fib(n): a, b = 0, 1 while b < n: print(b, end=’,’) a, b = b, a+b print()

if name == “main“: print(name) num = input(‘num :’) fib(int(num)) 

  1. <a name="orPiU"></a>
  2. # 模块的搜索路径
  4. 模块的查找顺序是：**内存中已经加载的模块**->**自建模块**->**sys.path路径中包含的模块**
  6. 1. 在第一次导入某个模块时（比如my_module），会先检查该模块是否已经被加载到内存中（当前<br />执行文件的名称空间对应的内存），如果有则直接引用<br />ps：python解释器在启动时会自动加载一些模块到内存中，可以使用sys.modules查看
  7. 1. 如果没有，解释器则会查找同名的内建模块
  8. 1. 如果还没有找到就从sys.path给出的目录列表中依次寻找my_module.py文件。
  10. 注意：自定义的模块名不应该与系统内置模块重名
  11. <a name="yLwZK"></a>
  12. # 编译python文件
  13. 为了提高加载模块的速度，python解释器会在 `__pycache__ `目录中下缓存每个模块编译后的版本，格<br />式为：module.version.pyc。通常会包含python的版本号。例如，在CPython3.3版本下，<br />my_module.py模块会被缓存成 `__pycache__/my_module.cpython-33.pyc` 。这种命名规范保证了编译<br />后的结果多版本共存。
  14. <a name="KVD6T"></a>
  15. # 什么是包
  16. 包就是一个含有__init__.py文件的文件夹，所以我们创建包的目的是用文件夹将文件/模块组织起来。
  18. 需要强调的是：
  20. 1. 在python3中，即使包下没有 __init__.py 文件，import 包仍然不会报错，而在python2中，包
  22. 下一定要有该文件，否则import 包报错。
  24. 2. 创建包的目的不是为了运行，而是被导入使用。包只是模块的一种形式，包的本质是一种模块。
  25. <a name="4xUZe"></a>
  26. # 为何要使用包
  27. **包的本质就是一个文件夹，那么文件夹唯一的功能就是将文件组织起来**<br />随着功能越写越多，我们无法将所有功能都放到一个文件中，于是我们使用模块去组织功能，而随着模<br />块越来越多，我们就需要用文件夹将模块文件组织起来，以此来提高程序的结构性和可维护性
  29. <a name="hi8vV"></a>
  30. ## 注意事项
  32. 1. 关于包相关的导入语句也分为 import 和 from ... import ... 两种，但是无论哪种，无论在什
  34. 么位置，在导入时都必须遵循一个原则：凡是在导入时带点的，点的左边都必须是一个包，否则非<br />法。可以带有一连串的点，如 item.subitem.subsubitem ,但都必须遵循这个原则。但对于导入<br />后，在使用时就没有这种限制了，点的左边可以是包,模块，函数，类(它们都可以用点的方式调用<br />自己的属性)。
  36. 2. import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样
  38. 来源于文件，即包下的 __init__.py ，导入包本质就是在导入该文件
  40. 3. 包A和包B下有同名模块也不会冲突，如A.a与B.a来自俩个命名空间
  41. <a name="sus64"></a>
  42. ## 包的使用
  43. 示例文件
  44. > glance/                   #Top-level package
  45. > ├── __init__.py      #Initialize the glance package
  46. > ├── api                  #Subpackage for api
  47. > │   ├── __init__.py
  48. > │   ├── policy.py
  49. > │   └── versions.py
  50. > ├── cmd                #Subpackage for cmd
  51. > │   ├── __init__.py
  52. > │   └── manage.py
  53. > └── db                  #Subpackage for db
  54. >     ├── __init__.py
  56. >     └── models.py
  59. ```python
  60. # 文件内容
  62. #policy.py
  63. def get():
  64.     print('from policy.py')
  66. #versions.py
  67. def create_resource(conf):
  68.     print('from version.py: ',conf)
  70. #manage.py
  71. def main():
  72.     print('from manage.py')
  74. #models.py
  75. def register_models(engine):
  76.     print('from models.py: ',engine)

使用import导入包

  1. import glance.db.models
  2. # 在导入glance的时候会执行glance下的__init__.py中的代码
  4. glance.db.models.register_models('mysql')

单独导入包名称时不会导入包中所有包含的所有子模块

  1. import glance
  2. glance.cmd.manage.main()

解决方法

  1. # glance/__init__.py
  2. from . import cmd
  4. # glance/cmd/__init__.py
  5. from . import manage

使用from （具体的路径） import （具体的模块）

需要注意的是from后import导入的模块，必须是明确的一个不能带点，否则会有语法错误，如：from
a import b.c 是错误语法

  1. from glance.api import *

想从包api中导入所有，实际上该语句只会导入包api下__init__.py 文件中定义的名字，我们可以在这
个文件中定义 __all__

  1. # api/__init__.py
  3. x = 10
  5. def func():
  6.     print('from api.__init.py')
  8. __all__=['x','func','policy']
  1. from glance.api import *
  3. func()
  4. print(x)
  5. policy.get()

绝对导入和相对导入

  • 绝对导入：以glance作为起始
  • 相对导入：用.或者..的方式最为起始（只能在一个包中使用，不能用于不同目录内）

绝对导入:以执行文件的sys.path为起始点开始导入,称之为绝对导入

  1. 优点: 执行文件与被导入的模块都可以使用
  2. 缺点: 每次导入都要从sys.path为起始点,十分麻烦

相对导入: 参照当前所在文件的文件夹为起始开始查找,称之为相对导入

  1. 符号: .代表当前所在文件的文件加,..代表上一级文件夹,…代表上一级的上一级文件夹
  2. 优点: 导入更加简单
  3. 缺点: 只能在导入包中的模块时才能使用