python的import 机制是怎么实现的

目录
  • import 机制功能
  • 单模块导入
  • 级联导入
  • from & import
  • import & as
  • from & import & as
  • 与module对象有关的名字空间问题
  • 小结

import 机制功能

Python 的 import 机制基本上可以切分为三个不同的功能:

  • Python运行时的全局模块池的维护和搜索;
  • 解析与搜索模块路径的树状结构;
  • 对不同文件格式的模块执行动态加载机制;

尽管 import 的表现形式千变万化,但是都可以归结为:import x.y.z 的形式,当然 import sys 也可以看成是 x.y.z 的一种特殊形式。而诸如 from、as 与 import 的结合,实际上同样会进行 import x.y.z 的动作,只是最后在当前名字空间中引入的符号各有不同。

然后导入模块,虚拟机会调用 __import__,那么我们就来看看这个函数长什么样子。

static PyObject *
builtin___import__(PyObject *self, PyObject *args, PyObject *kwds)
{
    static char *kwlist[] = {"name", "globals", "locals", "fromlist",
                             "level", 0};
    //初始化globals、fromlist都为NULL
    PyObject *name, *globals = NULL, *locals = NULL, *fromlist = NULL;
    int level = 0;//表示默认绝对导入

    //从PyTupleObject中解析出需要的信息
    if (!PyArg_ParseTupleAndKeywords(args, kwds, "U|OOOi:__import__",
                    kwlist, &name, &globals, &locals, &fromlist, &level))
        return NULL;
    //导入模块
    return PyImport_ImportModuleLevelObject(name, globals, locals,
                                            fromlist, level);
}

里面有一个PyArg_ParseTupleAndKeywords函数,我们需要提一下,它在虚拟机中是一个被广泛使用的函数,原型如下:

//Python/getargs.c
int PyArg_ParseTupleAndKeywords(PyObject *, PyObject *,
                                const char *, char **, ...);

这个函数的作用是参数解析,负责将 args 和 kwds 中所包含的所有对象(指针)按指定的格式 format 解析成各种目标对象,可以是 Python 的对象,例如 PyListObject、PyLongObject,也可以是 C 的原生对象。

我们知道这个 builtin__import__ 里面的参数 args 指向一个 PyTupleObject ,包含了 import 函数运行所需要的参数和信息,它是虚拟机在执行 IMPORT_NAME 指令的时候打包产生的。

然而在这里,虚拟机进行了一个逆动作,将打包后的这个 PyTupleObject 拆开,重新获得当初的参数。Python 在自身的实现中大量使用了这样的打包、拆包策略,使得可变数量的对象能够很容易地在函数之间传递。

该系列完结后,会介绍如何用 C 给 Python 写扩展,到时候会剖析这个函数的用法。

在完成了对参数的拆包动作之后,会进入 PyImport_ImportModuleLevelObject ,这个我们在 import_name 中已经看到了,当然它内部也是调用了 __import__。

另外每个包和模块都有一个__name__和__path__属性。

import numpy as np
import numpy.core
import six
print(np.__name__, np.__path__)
"""
numpy ['C:\\python38\\lib\\site-packages\\numpy']
"""
print(np.core.__name__, np.core.__path__)
"""
numpy.core ['C:\\python38\\lib\\site-packages\\numpy\\core']
"""
print(six.__name__, six.__path__)
"""
six []
"""

name__就是模块名或者包名,如果是包下面的包或者模块,那么就是包名.包名或者包名.模块名;至于__path__则是包所在的路径,对于模块而言, __path 为空列表。

此外还有一个 file 属性,对于模块而言就是其自身的完整路径;对于包而言则分两种情况,如果包内部存在 __init__.py 文件,那么得到的就是 __init__.py 文件的完整路径,没有则为 None。

下面来看一下不同的导入方式对应的字节码,然后在虚拟机的层面来理解这些导入方式。

单模块导入

以一个简单的模块导入为例:

import sys
"""
  0 LOAD_CONST               0 (0)
  2 LOAD_CONST               1 (None)
  4 IMPORT_NAME              0 (sys)
  6 STORE_NAME               0 (sys)
  8 LOAD_CONST               1 (None)
 10 RETURN_VALUE
"""

这是我们一开始考察的例子,现在我们已经很清楚地了解了 IMPORT_NAME 的行为。在 IMPORT_NAME 指令的最后,虚拟机会将 PyModuleObject对象(指针)压入到运行时栈,随后会将 <"sys", PyModuleObject *> 存放到当前的 local名字空间中。

级联导入

import sklearn.linear_model.ridge
"""
  0 LOAD_CONST               0 (0)
  2 LOAD_CONST               1 (None)
  4 IMPORT_NAME              0 (sklearn.linear_model.ridge)
  6 STORE_NAME               1 (sklearn)
  8 LOAD_CONST               1 (None)
 10 RETURN_VALUE
"""

如果是级联导入,那么 IMPORT_NAME 的指令参数则是完整的路径信息,该指令的内部将解析这个路径,并为 sklearn, sklearn.linear_model, sklearn.linear_model.ridge都创建一个 PyModuleObject 对象,这三者都存在于 sys.modules 里面。

但是我们看到 STORE_NAME 是 sklearn,表示只有 sklearn 这个符号暴露在了当前模块的 local 空间里面。可为什么是sklearn呢?难道不应该是 sklearn.linear_model.ridge 吗?

其实经过我们之前的分析这一点已经不再是问题了,因为 import sklearn.linear_model.ridge并不是说导入一个模块或包叫做 sklearn.linear_model.ridge,而是先导入 sklearn,然后把 linear_model 放在 sklearn 的属性字典里面,再把 ridge 放在 linear_model 的属性字典里面。

同理 sklearn.linear_model.ridge 代表的是先从 local 空间里面找到 sklearn,再从 sklearn 的属性字典中找到 linear_model,然后在 linear_model 的属性字典里面找到ridge。因为 linear_model 和 ridge 已经在相应的属性字典里面,我们通过 sklearn 一级一级往下找是可以找到的,因此只需要将符号 skearn 暴露给 local 空间即可。

或者说暴露 sklearn.linear_model.ridge 本身就是不合理的,因为这表示导入一个名字就叫做 sklearn.linear_model.ridge 的模块或者包,但显然不存在。而即便我们创建了这样的一个模块或包,由于 Python 的语法解析规范依旧不会得到想要的结果。不然的话,假设 import test_import.a,那是导入名为 test_import.a 的模块或包呢?还是导入 test_import 下的 a 呢?

也正如我们之前分析的 test_import.a,我们在导入 test_import.a 的时候,会把 test_import 加载进来,然后把 a 加到 test_import 的属性字典里面,最后只需要把 test_import 返回即可。

因为通过 test_import 可以找到 a,或者说 test_import.a 代表的含义就是从 test_import 的属性字典里面获取 a,所以 import test_import.a 必须要返回 test_import,而且只需返回 test_import。

至于 sys.modules 里面虽然存在字符串名为 "test_import.a"的 key 的,但这是为了避免重复加载所采取的策略,它依旧表示从 test_import 的属性字典里面获取 a。

import pandas.core

print(pandas.DataFrame({"a": [1, 2, 3]}))
"""
   a
0  1
1  2
2  3
"""
# 所以通过 pandas.DataFrame 是可以调用的

导入 pandas.core 会先导入 pandas,也就是执行 pandas 内部的 init 文件。虽然 sys.modules 里面同时有 "pandas" 和 "pandas.core",但是暴露在 local 空间的只有 pandas,所以调用 pandas.DataFrame 是完全合理的。至于 pandas.core 显然它无法暴露,因为这不符合 Python 的变量命名规范,变量的名称里面不能出现小数点,它只是单纯地表示从 pandas 的属性字典中加载 core。

from & import

from sklearn.linear_model import ridge
"""
  0 LOAD_CONST               0 (0)
  2 LOAD_CONST               1 (('ridge',))
  4 IMPORT_NAME              0 (sklearn.linear_model)
  6 IMPORT_FROM              1 (ridge)
  8 STORE_NAME               1 (ridge)
 10 POP_TOP
 12 LOAD_CONST               2 (None)
 14 RETURN_VALUE
"""

注意此时的 2 LOAD_CONST 不再是 None 了,而是一个元组,虚拟机将 ridge 放到了当前模块的 local 空间中。并且 sklearn.linear_model 和 sklearn 都被导入了,存在 sys.modules 里面。

但是 sklearn 却并不在当前 local 空间中,尽管它被创建了,但是又被隐藏了。IMPORT_NAME 是 sklearn.linear_model,也表示导入 sklearn,然后把 sklearn 下面的 linear_model 加入到 sklearn 的属性字典里面。

而之所以 sklearn 没在 local 空间里面,可以这样理解。当只出现 import 的时候,那么我们必须从头开始一级一级向下调用,所以顶层的包必须加入到 local 空间里面。但这里通过 from ... import ...把 ridge 导出了,此时 ridge 已经指向了 sklearn 下面的 linear_model 下面的 ridge,那么就不需要 sklearn 了,或者说 sklearn 就没必要暴露在 local 空间里面了,但它确实被导入进来了。

并且 sys.modules 里面也不存在 "ridge"这个key,存在的是 "sklearn.linear_model.ridge",暴露给 local空间的符号是 ridge。

所以正如上面所说,不管什么导入,都可以归结为 import x.y.z 的形式,只是暴露出来的符号不同罢了。

import & as

import sklearn.linear_model.ridge as xxx
"""
  0 LOAD_CONST               0 (0)
  2 LOAD_CONST               1 (None)
  4 IMPORT_NAME              0 (sklearn.linear_model.ridge)
  6 IMPORT_FROM              1 (linear_model)
  8 ROT_TWO
 10 POP_TOP
 12 IMPORT_FROM              2 (ridge)
 14 STORE_NAME               3 (xxx)
 16 POP_TOP
 18 LOAD_CONST               1 (None)
 20 RETURN_VALUE
""

这个和上面的 from & import 类似,"sklearn", "sklearn.linear_model", "sklearn.linear_model.ridge" 都在 sys.modules 里面。但是我们加上了 as xxx,那么这个 xxx 就直接指向了 sklearn 下面的 linear_model 下面的 ridge,此时就不需要 sklearn 了。

因此只有 xxx 暴露在了当前模块的 local空间里面,而 sklearn 虽然也被导入了,但它只在 sys.modules 里面,没有暴露给当前模块的 local 空间。

from & import & as

from sklearn.linear_model import ridge as xxx

这个我想连字节码都不需要贴了,和之前的 from & import 一样,只是最后暴露给 local 空间的 ridge 变成了我们自己指定的 xxx。

与module对象有关的名字空间问题

同函数、类一样,每个 PyModuleObject 也有自己的名字空间。一个模块不能直接访问另一个模块的内容,尽管模块内部的作用域比较复杂,比如:遵循 LEGB 规则,但是模块与模块之间的划分则是很明显的。

# test1.py
name = "古明地觉"
def print_name():
    return name
# test2.py
from test1 import name, print_name
name = "古明地恋"
print(print_name())  # 古明地觉

执行 test2.py 之后,发现打印的依旧是"古明地觉"。我们说 Python 是根据 LEGB 规则进行查找,而 print_name 函数里面没有 name,那么去外层找。test2.py 里面的 name 是"古明地恋",但是打印的依旧是 test1.py 里面的 "古明地觉"。为什么?

还是那句话,模块与模块之间的作用域划分的非常明显,print_name 是 test1.py 里面的函数,所以在返回 name 的时候,只会从 test1.py 中搜索,无论如何都是不会跳过test1.py、跑到 test2.py 里面的。

再来看个例子:

# test1.py
name = "古明地觉"
nicknames = ["小五", "少女觉"]
# test2.py
import test1
test1.name = "古明地觉"
test1.nicknames = ["觉大人"]
from test1 import name, nicknames
print(name)  # 古明地觉
print(nicknames)  # ['觉大人']

此时打印的结果变了,很简单,这里是直接把 test1 里面的变量修改了。因为这种方式,相当于直接修改 test1 的属性字典。那么后续再导入的时候,打印的就是修改之后的值。

# test1.py
name = "古明地觉"
nicknames = ["小五", "少女觉"]
# test2.py
from test1 import name, nicknames
name = "古明地恋"
nicknames.remove("小五")
from test1 import name, nicknames
print(name)  # 古明地觉
print(nicknames)  # ["少女觉"]

如果是 from test1 import name, nicknames,那么相当于在当前的 local空间中新创建变量 name 和 nicknames,它们和 test1 中的 name 和 nicknames 指向相同的对象。

name = "古明地觉" 相当于重新赋值了,所以不会影响test1里的 name;而 nicknames.remove 则是在本地进行修改,所以会产生影响。

小结

以上就是模块(包)相关的内容,虽然一个项目可以有很多个文件,但是每个文件的执行原理是一致的。无论一个文件是作为模块被导入,还是直接作为启动文件被执行,虚拟机的执行流程都没有变化。

通过模块和包,我们便可以对项目进行功能上的划分,从而更好地组织项目。

到此这篇关于python的import 机制是怎么实现的的文章就介绍到这了,更多相关import 机制内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • python之import机制详解

    本文详述了Python的import机制,对于理解Python的运行机制很有帮助! 1.标准import: Python中所有加载到内存的模块都放在 sys.modules .当 import 一个模块时首先会在这个列表中查找是否已经加载了此模块,如果加载了则只是将模块的名字加入到正在调用 import 的模块的 Local 名字空间中.如果没有加载则从 sys.path 目录中按照模块名称查找模块文件,模块可以是py.pyc.pyd,找到后将模块载入内存,并加到 sys.modules 中,并

  • Python 中的 import 机制之实现远程导入模块

    所谓的模块导入( import ),是指在一个模块中使用另一个模块的代码的操作,它有利于代码的复用. 在 Python 中使用 import 关键字来实现这个操作,但不是唯一的方法,还有 importlib.import_module() 和 __import__() 等. 也许你看到这个标题,会说我怎么会发这么基础的文章? 与此相反.恰恰我觉得这篇文章的内容可以算是 Python 的进阶技能,会深入地探讨并以真实案例讲解 Python import Hook 的知识点. 当然为了使文章更系统.

  • 详解Python中import机制

    Python语言中import的使用很简单,直接使用import module_name语句导入即可.这里我主要写一下"import"的本质. Python官方定义: Python code in one module gains access to the code in another module by the process of importing it. 1.定义: 模块(module):用来从逻辑(实现一个功能)上组织Python代码(变量.函数.类),本质就是*.py文

  • Python中import机制详解

    Python语言中import的使用很简单,直接使用 import module_name 语句导入即可.这里我主要写一下"import"的本质. Python官方 定义:Python code in one module gains access to the code in another module by the process of importing it. 1.定义: 模块(module):用来从逻辑(实现一个功能)上组织Python代码(变量.函数.类),本质就是*.p

  • Python入门基础之import机制

    一.前言 本文基于开源项目: github.com/pwwang/pyth- 补充扩展讲解,希望能够让读者一文搞懂 Python 的 import 机制. 1.1 什么是 import 机制? 通常来讲,在一段 Python 代码中去执行引用另一个模块中的代码,就需要使用 Python 的 import 机制.import 语句是触发 import 机制最常用的手段,但并不是唯一手段. importlib.import_module 和 __import__ 函数也可以用来引入其他模块的代码.

  • python 全局变量的import机制介绍

    先把有问题的代码晒一下: IServer.py from abc import ABCMeta, abstractmethod print __name__ class IServer: def __init__(self): pass @abstractmethod def DoWithA(self): pass @abstractmethod def DoWithB(self): pass IServer_A.py import IServer serverType ='1001' prin

  • python的import 机制是怎么实现的

    目录 import 机制功能 单模块导入 级联导入 from & import import & as from & import & as 与module对象有关的名字空间问题 小结 import 机制功能 Python 的 import 机制基本上可以切分为三个不同的功能: Python运行时的全局模块池的维护和搜索: 解析与搜索模块路径的树状结构: 对不同文件格式的模块执行动态加载机制: 尽管 import 的表现形式千变万化,但是都可以归结为:import x.y.

  • 简单谈谈python的反射机制

    对编程语言比较熟悉的朋友,应该知道"反射"这个机制.Python作为一门动态语言,当然不会缺少这一重要功能.然而,在网络上却很少见到有详细或者深刻的剖析论文.下面结合一个web路由的实例来阐述python的反射机制的使用场景和核心本质. 一.前言 def f1(): print("f1是这个函数的名字!") s = "f1" print("%s是个字符串" % s) 在上面的代码中,我们必须区分两个概念,f1和"f1

  • Python类反射机制使用实例解析

    这篇文章主要介绍了Python类反射机制使用实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 反射就是通过字符串的形式,导入模块:通过字符串的形式,去模块寻找指定函数并执行. Python有四个内置函数: 函数 功能 getattr(object, attr[, default]) 获取指定字符串名称的对象属性或方法,如果对象有该属性则返回属性值,如果有该方法则返回该方法的内存地址,如果都没有就报错,如果指定了默认值找不到不会报错会取默认

  • python轮询机制控制led实例

    我就废话不多说了,大家还是直接看代码吧! # -*- coding:utf-8 -*- # File: ceshitianqi import urllib2 import json import time import datetime import serial import random import os import sys APIKEY = 'ZPdLyl***=' #改成你的APIKEY ser=serial.Serial("/dev/ttyUSB2",9600,timeo

  • 详解Python垃圾回收机制和常量池的验证

    Python的引入 人类认识世界是从认识世界中的一个又一个实物开始,然后再对其用语言加以描述.例如当中国人看到苹果时,便会用中文"苹果"加以描述,而用英语的一些国家则会用"apple"加以描述. 以上说到的中文和英文都是人类认识并描述世界的一个工具,而在计算机的世界中,为了让计算机去认知世界,从而帮助人类完成更多的任务.在计算机领域中也发展了语言这个工具,从早期的机器语言到汇编语言再到现在使用范围较广的高级语言.而我们接下来要介绍的Python则属于高级语言这一分支

随机推荐