Comment fonctionne l'importation de Python ?

Bonjour, je m'appelle somenzz, vous pouvez m'appeler frère Zheng.

L'importation de Python est très intuitive, mais même ainsi, vous constaterez parfois que même si le package est là, nous rencontrerons toujours ModuleNotFoundError. Évidemment, le chemin relatif est très correct, mais une erreur est signalée

ImportError: attempted relative import with no known parent package

Importation de modules dans le fichier. même répertoire Les modules dans différents répertoires sont complètement différents. Cet article analyse certains problèmes souvent rencontrés lors de l'utilisation de l'importation pour vous aider à gérer facilement l'importation. Sur cette base, vous pouvez facilement créer votre propre package.

1. Qu'est-ce qu'un module et qu'est-ce qu'un package ?

Module

La relation entre les modules et les packages peut être comparée aux fichiers et aux répertoires.

La documentation Python décrit cela, un fichier Python est un module et le nom du fichier Python (sans le suffixe .py) est le nom du module.

Un module peut contenir des variables, des fonctions et des classes, qui font partie de l'espace de noms défini par le module, donc la dénomination des variables n'est pas un problème car deux modules différents peuvent avoir des variables, des fonctions et des classes portant le même nom.

Package

La relation entre les modules et les packages peut être comparée aux fichiers et aux répertoires. Un package est un répertoire.

Un package peut contenir des modules ou des sous-packages. Un module définit un espace de noms afin que les variables, fonctions et classes puissent avoir le même nom dans deux modules différents. De même, un package fait la même chose pour ses packages et modules de composants. Le package principal est accessible via le point modules et packages dans. .

Un package de base peut inclure un sous-package, des modules, __init__.py (non requis après Python 3.3), setup.py. Une structure de package possible ressemble à ceci :

Et setup.py existe dans le répertoire personnel où se trouve votre package et contient des informations de configuration telles que les dépendances requises, les scripts et les sous-packages. Vous pouvez également spécifier des métadonnées sur le package, telles que le nom du package, son auteur, sa description, etc.

setup.py est le fichier que pip utilise pour installer votre package.

Que s'est-il passé lors de 2.import

Prenons d'abord un exemple simple. Par exemple, il y a deux fichiers dans le même répertoire, file1.py et file2.py. Le contenu est très simple. La différence est que File1 est importé dans file2.py :

#file1.py
print("This is file1.py")
#file2.py
print("This is file2.py")
import file1

L'exécution de file2.py peut obtenir les résultats suivants :

❯ python file2.py
This is file2.py
This is file1.py

On peut le voir :

• l'importation est très intuitive, quiconque l'utilise peut importer.
• La déclaration d'importation est une déclaration ordinaire et peut être placée n'importe où.
• Lorsqu'un fichier est importé, il sera exécuté et ses classes ou objets internes seront ajoutés à son espace de noms.

Nous devons également connaître l'ordre de recherche d'importation. N'oubliez pas une chose, c'est-à-dire que l'importation recherchera dans sys.path.

Par exemple, si j'ajoute une ligne de code à la fin de file2.py : import sys; print(sys.path), le chemin de recherche d'importation peut être imprimé :

Vous pouvez voir l'ordre des sys.path :

• sera d'abord Rechercher le chemin où se trouve le script d'exécution
• Bibliothèque standard
• Packages de sites de bibliothèques tierces

Ce à quoi vous devez faire attention à propos de sys.path est :

• Dans l'environnement de l'interpréteur, sys.path[0] est le démarrage de l'interpréteur. Le chemin où il se trouve''
• sys.path ne dépend pas du chemin de travail du programme actuel - os.getcwd(), mais dépend seulement sur le chemin où se trouve le premier script :

• Si un module importe un autre module et que ce dernier importe un autre module, le sys.path du premier module est l'endroit où l'interpréteur recherche la deuxième instruction d'importation.

Une fois qu'un module ou un package est trouvé, il sera exécuté. S'il existe un fichier d'initialisation __init__.py dans le package, __init__.py sera exécuté en premier lors de l'importation.

Ensuite, le projet à importer est ajouté à son espace de noms, et nous pouvons l'utiliser via xx.yy.

3. Quand utiliser l'importation relative et quand utiliser l'importation absolue

Regardons d'abord ce qu'est l'importation absolue. La soi-disant importation absolue est comme ceci :

import aa
import aa.bb
from aa import bb

Cette méthode est très intuitive. .path à rechercher. Si vous rencontrez ModuleNotFoundError, réfléchissez à la raison pour laquelle sys.path ne contient pas le package que nous souhaitons importer, ou insérez manuellement le chemin de ce package dans sys.path.

Jetons un coup d'œil à ce qu'est l'importation relative. La soi-disant importation relative se présente sous la forme :

from . import aa
from .aa import bb
from .. import yy

C'est-à-dire qu'il y a un signe . importé ou le package actuel.

Par exemple, nous créons un nouveau répertoire sous-package1 sous le répertoire pythonimportexample et créons deux nouveaux fichiers file3.py et file4.py dans le sous-package1.

Le contenu est le suivant :

file3.py :

print("This is file3.py")

file4.py :

from . import file3
print("This is file4.py")

只要我们直接运行 file4.py，那是一定会报错的：

Python 提示我们：

ImportError: attempted relative import with no known parent package

也就是说相对导入不知道父包是谁，换句话说，这是一个子包，必须让父包来调用它，直接运行这个文件是不行的，即使你在 file4.py 的目录 subpackage1 同级的目录执行该文件也是不行的，见上图。

但是在 file4.py 的目录 subpackage1 同级的目录作为一个 module 来执行是可以的，如下图：

换句话说，我们把 subpackage1 作为一个包来让别人用，相对导入是可以的，比如说我们在目录 subpackage1 同级的目录新建一个 file5.py 的文件，内容如下：

file5.py:

from subpackage1 import file4。

然后，执行 python file5.py 可以看出，相对导入已经正常工作：

结论

• 如果是当做脚本文件直接运行的，使用绝对导入。
• 如果是当做模块供其他文件导入，使用相对导入。

4.一个自定义包的例子

先上一个图来看下目录及引用结构，方块的是目录，椭圆的是文件，曲线是引用：

其中 import_example 目录下有 setup.py 和 run.py

run.py 导入了 file4、file5、file6。

file4 导入了 file3，file5 导入了 file3。

file6 导入了 file2，file2 导入了 file1。

现在我们来执行一下 run.py 看下效果：

可以看出所有相对导入都已正常工作，虽然 file3 被导入了两次，但只执行了一次，说明 Python 内部已经考虑了同一个包的多重导入问题。

自定义包就是让其他文件导入使用的，因此 pythonimportexample目录下都使用相对导入，源代码见：

https://gitee.com/somenzz/code-example/tree/master/import_example

点阅读原文也可以直接访问。

这里还有一些自定义包的例子：

• dbinterface[1]
• transferfile[2]

最后的话

本文分享了什么是模块(module)，什么是包(package)，import 的搜索路径，也分享了相对导入和绝对导入的区别，最后举了一个非常实用的 import 例子，方便你构建自己的包。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!