Apprendre le mécanisme d'importation de modules Python et les spécifications des grands projets

La colonne

Tutoriel vidéo Python vous présente aujourd'hui l'apprentissage du mécanisme d'importation de module Python et les spécifications des grands projets.

Préface

Dans le processus d'utilisation de Python dans nos projets quotidiens, nous devons souvent résoudre les problèmes d'importation de chaque module, et nous rencontrons souvent des références recherches de chemin. Il y a des problèmes tels que l'importation croisée de modules, etc., j'ai donc écrit cet article pour décrire le mécanisme d'importation de modules de Python et les spécifications d'importation de modules que nous devrions suivre dans nos projets quotidiens à grande échelle

Module Python import

Dans la programmation quotidienne, afin de réutiliser la logique de code que nous avons écrite, nous encapsulerons ces codes dans des modules. Si nécessaire, nous pourrons directement les importer et les réutiliser pour améliorer notre efficacité de développement. Les modules peuvent définir des fonctions, des classes, des variables et peuvent également contenir du code exécutable. Il existe trois types de sources de modules : ①Modules intégrés Python (bibliothèque standard) ; ②Modules tiers ; ③Modules personnalisés ;

Principe de l'importation

L'importation de modules se fait généralement en utilisant le mot-clé import dans l'en-tête du fichier. Importer un module équivaut à l'exécuter une fois et. puis l'importer. module, puis établit une connexion avec l'espace de noms du module importé dans cet espace de noms, ce qui équivaut à créer une nouvelle variable dans cet espace de noms. Le nom de cette variable est le nom du module importé et pointe vers le module. espace de noms du module importé. Par conséquent, le module importé est équivalent à une variable, Par conséquent, l'importation multiple du même module ne sera exécutée que lors de sa première importation (Les importations ultérieures détermineront que cette variable de module existe déjà et seront ne pas être exécuté)

Mécanisme de recherche de chemin

Chaque module importé sera dans le dictionnaire intégré Python sys.modules. Une fois Python démarré, il sera chargé en mémoire, lorsque nous importerons de nouveaux modules, sys.modules enregistrera automatiquement le module. Le mécanisme de chemin de recherche de module de Python est :

1. Recherchez si le module existe dans tous les chemins de sys.path, et si c'est le cas, ouvrez un nouvel espace pour charger le module
Vérifiez s'il y a des packages intégrés ou des packages tiers installés dans sys.modules, et si c'est le cas, ouvrez un nouvel espace pour charger le module

Donc pour le ; modules que nous écrivons nous-mêmes, si nous emballons et publions. En ce qui concerne PyPi, vous pouvez l'installer directement avec pip install et le charger dans la mémoire au démarrage. Vous pouvez le visualiser via sys.modules. Pour les modules qui doivent uniquement être réutilisés dans ce projet, nous ajoutons leurs chemins à

sys.path dans le code réutilisé, et le module peut également être référencé.

Importation de chemin absolu

Toutes les importations de modules démarrent à partir du "nœud racine". L'emplacement du nœud racine est déterminé par le chemin dans sys.path. Le répertoire racine du projet se trouve généralement automatiquement dans sys.path. Si vous souhaitez que le programme soit exécuté partout, vous devez modifier manuellement sys.path

import sys,os
BASE_DIR = os.path.dirname(os.path.abspath(__file__))#项目根目录所在的绝对路径sys.path.append(BASE_DIR)import A, B #导入A、B包复制代码

Importation de chemin relatif

Attention simplement à l'emplacement du module par rapport à votre répertoire actuel. Il ne peut pas être exécuté directement à l'intérieur du package (une erreur sera signalée). Peu importe où se trouve le nœud racine, la position relative des modules dans le package est correcte.

#from . import b2 #这种导入方式会报错，只有在包内部直接执行的时候才可以这样导入。import b2#正确b2.print_b2()复制代码

Questions fréquemment posées sur l'importation de modules Python

Lorsque vous importez un nom de package individuellement, tous les sous-modules contenus dans le package ne seront pas importés. Solution : Le package importé contient également l'importation d'autres packages. À ce stade, vous devez importer tous les modules sous le package dans le fichier
• init.py de chaque package. Seule la couche supérieure peut directement référencer le package. couche inférieure. Les classes et méthodes du package

init fichier

Quand il y a

init.py dans un dossier, il signifie ce fichier Un dossier est un package (package), et plusieurs modules (modules) en dessous forment un tout, et ces modules (modules) peuvent être importés dans d'autres codes via le même package (package). Le fichier init.py est utilisé pour organiser les packages, faciliter la gestion des références entre modules et contrôler le comportement d'importation des packages.

Le fichier ne peut contenir aucun contenu, c'est-à-dire qu'il s'agit d'un fichier vide (lorsqu'il est vide, rien ne peut être fait en utilisant simplement le formulaire d'importation [package]). Il a juste besoin d'exister, ce qui est le cas). équivalent à une marque.

En python3, même s'il n'y a pas de fichier init.py sous le package, le package d'importation ne signalera toujours pas d'erreur, tandis qu'en python2, le fichier doit être sous le package, sinon importer Le package signalera une erreur

allLa variable

all est une variable importante utilisée pour spécifier que ce package (package) est importé * Quand, quels modules seront importés dans [la portée actuelle]. Les modules ne figurant pas dans la liste tous ne seront pas référencés par d'autres programmes. Vous pouvez réécrire all, tel que all= ['nom du module 1 du package actuel auquel il appartient', 'nom du module 1']. le nom du module dans la liste sera utilisé Import.

name变量

在包内部直接运行时，包的name == 'main'，但是在外部导入包是，可以通过

if __name__ == '__main__':复制代码

来避免实现包内部调试时的逻辑

循环导入

当两个模块A和B之间相互import时，就会出现循环导入的问题，此时程序运行会报错：can not import name xxx,如：

# a.pyprint('from a.py')from b import x

y = 'a'复制代码

# b.pyprint('from b.py')from a import y

x = 'b'复制代码

我们来分析一下这种错误是怎么出现的：

1. 在sys.modules中查找 符号“module b”；
2. 如果符号“module b”存在，则获得符号“module b”对应的module对象； 从的dict中获得 符号“x”对应的对象。如果“x”不存在，则抛出异常“ImportError: cannot import name ‘x’”
3. 如果符号“module b”不存在，则创建一个新的 module对象。不过此时该新module对象的dict为空。然后执行module b.py文件中的语句，填充的dict。

因此在a.py中执行from b import x的顺序就是1->3，先引入b，b里面from a import y由相当于执行了a.py，顺序是1->2,因为此时b已经引入所以不会执行3，2中无法找到x对象，因为引入b时还没执行到x='b'这一步，所以报错了

解决办法

1. 延迟导入，把import语句写在方法/函数里，将它的作用域限制在局部；
2. 顶层先引入模块，再把from x import y改成import x.y形式；
3. 其实出现循环引用问题的根本原因是程序设计不合理，每个包都应该由上层使用的模块去导入，而不应该在包与包之间各种相互导入，所以应该更改代码布局，可合并或分离竞争资源；

大型项目中Python模块导入规范

分离模块，将同一类别的模块放在同一目录下，形成类别分明的目录架构，如：

1. 每一个模块目录都要写init.py文件，可以同时定义all限定可导入的范围；
2. 源码根目录可以定义BASE_DIR，限定好根目录路径，启动py文件可以用绝对路径导入各个模块，将必要模块都加入到sys.path中；
3. 各个服务之间（例如model需要引入common的模块方法），可以通过相对路径引用模块；
4. 程序设计时避免循环导入，可由调用者(服务文件)作为上层第三方引入需要的各个模块，这样就可以减少各个模块的相互导入。

更多相关免费学习推荐：python视频教程

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!