Une introduction sur la façon d'éviter les méthodes d'importation circulaires en Python

Dans les projets Python à grande échelle, en raison d'une mauvaise conception de l'architecture, des références mutuelles entre les modules peuvent se produire. L'article suivant vous présente principalement des informations pertinentes sur la façon d'éviter le problème d'importation circulaire de Python. Les amis dans le besoin peuvent s'y référer.

Préface

Lors de l'utilisation de packages en Python, les problèmes d'importation circulaire sont très courants. Nous avons créé le package suivant pour illustrer ce problème :

pkg
 ├── __init__.py
 ├── module_a.py
 └── module_b.py

Parmi eux,

__init__.py spécifie pkg comme un package Python défini dans

module_a. py Une fonction

est définie dans module_b.py, qui fait référence à un attribut dans module_b.py, tel qu'une fonction ou une variable action_a()

module_b.py définit une fonction

, qui fait référence à module_a Un attribut dans .py, comme une fonction ou une variable action_b()

Dans ce cas, une erreur

sera générée lors de l'exécution du package, c'est-à-dire une référence circulaire, car lorsque module_a essaie d'introduire module_b, et module_b doit d'abord introduire module_a, ce qui empêchera l'interpréteur Python de s'exécuter. circular import error

Cependant, nous pouvons utiliser des méthodes astucieuses pour faire fonctionner correctement la logique ci-dessus tout en évitant les erreurs introduites par les boucles.

Alors, quand est-ce que ça marche, quand ça ne marche pas, et quelles sont les raisons pour lesquelles ça marche ?

Quand est-ce que ça marchera ?

1. Introduire en haut du module, ne pas utiliser from, introduction relative, valable uniquement en Python 2

dans le module Top import, tel que

, la fonction dans le module fait référence à la fonction ou à la variable dans un autre_module sous la forme de import another_module. La raison pour laquelle cette méthode fonctionne est que another_module.attribute est une référence relative basée sur le répertoire courant, et c'est une référence implicite si le module est importé depuis un autre package, il deviendra invalide. De plus, import another_module Cette syntaxe n'est plus supportée dans Python 3, n'utilisez donc pas cette méthode dans votre code pour éviter l'introduction de boucles. import another_module

Par exemple :

# pkg/module_a.py 
from __future__ import print_function
import module_b
 
def action_a():
 print(module_b.action_b.__name__)
 
 
# pkg/module_b.py
from __future__ import print_function
import module_a
 
def action_b():
 print(module_a.action_a.__name__)

2. Importer en haut du module, ne pas utiliser from, importer absolument.

Importez en haut du module, en utilisant le chemin absolu à partir du package, tel que

, et les fonctions du module font référence à des fonctions ou des variables dans un autre_module dans le forme de import package.another_module. La raison pour laquelle vous devez raccrocher le nom du package à importer est parce que package.another_module.attribute cette forme d '"importation relative" signalera une erreur de syntaxe et raccrochera l'importation absolue du package, Python 2 et 3 prennent tous deux en charge import .another_module

Cas :

# pkg/module_a.py
from __future__ import print_function
import pkg2.module_b
 
def action_a():
 print(pkg2.module_b.action_b.__name__)
 
 
# pkg/module_b.py
from __future__ import print_function
import pkg2.module_a
 
def action_b():
 print(pkg2.module_a.action_a.__name__)

3. Introduire l'attribut d'un autre module en bas du module au lieu d'un autre module, utiliser from.

est importé en bas du module (au moins après l'attribut référencé), et les attributs de

sont directement introduits, comme par exemple depuis another module. également pris en charge, comme package.another_module import attribute, et les fonctions du module sont directement utilisées. Utilisez simplement l'attribut référencé. from .another_module import attribute

Par exemple :

# pkg/module_a.py
from __future__ import print_function
 
def action_a():
 print(action_b.__name__)
 
from .module_b import action_b
 
 
# pkg/module_b.py
from __future__ import print_function
 
def action_b():
 print(action_a.__name__)
 
from .module_a import action_a

Introduit en haut de la fonction, vous pouvez utiliser from.

L'importation en haut de la fonction du module, telle que

, prend également en charge l'importation relative, un module ou un attribut peut être introduit. from package import another_module

Tels que :

# pkg/module_a.py
from __future__ import print_function
 
def action_a():
 from . import module_b
 print(module_b.action_b.__name__)
 
 
# pkg/module_b.py
from __future__ import print_function
 
def action_b():
 from . import module_a
 print(module_a.action_a.__name__)

ou

# pkg/module_a.py
from __future__ import print_function
 
def action_a():
 from .module_b import action_b
 print(action_b.__name__)
 
 
# pkg/module_b.py
from __future__ import print_function
def action_b():
 from .module_a import action_a
 print(action_a.__name__)

Ce kind Bien que Python 2 et 3 prennent en charge cette méthode, le codage n'est pas assez élégant et affecte la lisibilité du code. Il n'est pas recommandé d'utiliser

Remarque.

Le problème abordé dans cet article est de savoir comment éviter d'introduire des boucles lors de l'appel de packages en Python

Lorsqu'un module Python est exécuté directement sur la ligne de commande, la situation applicable n'est pas exactement la même

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!