Importer le module dans Python avec des exemples
Anna Blake
⚡ Résumé intelligent
Importer dans Python Permet à un fichier de réutiliser les variables, fonctions et classes définies dans un autre. Un module est simplement un fichier .py, tandis qu'un paquet regroupe des modules apparentés dans un répertoire marqué par un fichier __init__.py.
Les sections ci-dessous expliquent les modules, les packages, les différents styles d'importation et le fonctionnement des importations absolues et relatives. Python.
Quels sont les modules dans Python?
Un module est un fichier contenant Python Le code peut prendre la forme de variables, de fonctions ou d'une classe définie. Le nom du fichier devient le nom du module.
Par exemple, si votre nom de fichier est guru99.py, le nom du module sera guru99. Avec la fonctionnalité du module, vous pouvez diviser votre code en différents fichiers au lieu de tout écrire dans un seul fichier.
Qu'est ce que le Python module d'importation ?
Un fichier est considéré comme un module dans PythonPour utiliser le module, vous devez l'importer en utilisant le importer mot-clé. Les fonctions ou variables présentes dans le fichier peuvent être utilisées dans un autre fichier en important le module. Cette fonctionnalité est disponible dans d'autres langages comme TypeScript, JavaScénario, Java, Rubis, etc.
Comment créer et importer un module dans Python?
Nous allons maintenant créer un module et l'importer dans un autre fichier.
Voici le flux pour créer et importer le module comme indiqué dans la capture d'écran :
Suivez les étapes indiquées pour créer un module dans Python.
La structure des dossiers utilisée pour tester le code est la suivante :
modtest/ test.py display.py
Étape 1) Créez un fichier et nommez-le test.py
Étape 2) Dans test.py, créez une fonction appelée display_message()
Def display_message():
return "Welcome to Guru99 Tutorials!"
Étape 3) Créez maintenant un autre fichier display.py.
Étape 4) Dans le fichier display.py, importez le module test.py, comme indiqué ci-dessous :
import test
Lors de l'importation, il n'est pas nécessaire de mentionner le fichier test.py, mais simplement son nom.
Étape 5) Vous pouvez ensuite appeler la fonction `display_message()` de `test.py` à l'intérieur de `display.py`. Il vous faut utiliser `module_name.function_name`.
Par exemple test.display_message().
Import test
print(test.display_message())
Étape 6) Lorsque vous exécutez display.py, vous obtiendrez le résultat suivant Sortie :
Welcome to Guru99 Tutorials!
Importer une classe dans Python
Nous avons précédemment vu un module simple contenant une fonction. Ici, nous allons créer une classe et y faire référence dans un autre fichier.
La structure des dossiers pour tester le code est la suivante :
myproj/ Car.py display.py
Créez un fichier appelé Car.py avec le code suivant :
Nom du fichier : Car.py
class Car: brand_name = "BMW" model = "Z4" manu_year = "2020" def __init__(self, brand_name, model, manu_year): self.brand_name = brand_name self.model = model self.manu_year = manu_year def car_details(self): print("Car brand is ", self.brand_name) print("Car model is ", self.model) print("Car manufacture year is ", self.manu_year) def get_Car_brand(self): print("Car brand is ", self.brand_name) def get_Car_model(self): print("Car model is ", self.model)
Le fichier Car.py contient les attributs brand_name, model et manu_year. Les fonctions définies dans la classe sont car_details(), get_Car_brand() et get_Car_model().
Utilisons maintenant le fichier Car.py comme module dans un autre fichier appelé display.py.
Nom du fichier : display.py
import Car car_det = Car.Car("BMW","Z5", 2020) print(car_det.brand_name) print(car_det.car_details()) print(car_det.get_Car_brand()) print(car_det.get_Car_model())
Sortie :
BMW Car brand is BMW Car model is Z5 Car manufacture year is 2020 Car brand is BMW Car model is Z5
Nous pouvons donc accéder à toutes les variables et fonctions de Car.py en utilisant le module Car.
Utilisation du module d'importation
Vous pouvez importer seulement une petite partie du module, c'est-à-dire uniquement les fonctions et les noms de variables nécessaires au lieu d'importer la totalité du code.
Lorsque vous souhaitez importer uniquement certains éléments, vous pouvez utiliser le mot-clé « from » pour importer ce que vous voulez.
La syntaxe est donc
from module import your function_name , variables,... etc.
La structure des dossiers utilisée pour tester le code est la suivante :
modtest/ test.py display.py
Dans le fichier test.py, on trouve 2 fonctions comme indiqué :
Nom du fichier : test.py
defdisplay_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Vous souhaitez maintenant utiliser la fonction display_message(). La fonction ou la variable que vous importez est directement accessible comme indiqué ci-dessous :
Nom du fichier : display.py
from test import display_message print(display_message())
Sortie :
Welcome to Guru99 Tutorials!
Si vous utilisez la fonction display_message1(), une erreur indiquant que la fonction n'est pas définie sera générée, comme illustré ci-dessous :
from test import display_message print(display_message1())
Sortie :
Traceback (most recent call last): File "display.py", line 3, in <module> print(display_message1()) Name Error: name 'display_message1' is not defined
Importer tout depuis le module
La commande `import` vous permet d'importer le module complet en utilisant `import` suivi du nom du module, c'est-à-dire le nom du fichier ou de la bibliothèque à utiliser.
syntaxe:
Import module
Ou en utilisant
from module import *
La structure des dossiers utilisée pour tester le code est la suivante :
modtest/ test.py display.py
Voici les détails du code dans test.py
my_name = "Guru99" my_address = "Mumbai" defdisplay_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Utiliser le module d'importation
Pour faire référence aux variables et aux fonctions à l'intérieur du module en utilisant uniquement son nom d'importation, vous devez les préfixer par le nom du module.
Exemple
Nom du fichier : display.py
Import test print(test.display_message()) print(test.display_message1()) print(test.my_name) print(test.my_address)
Le nom de module « test » est utilisé pour faire référence aux fonctions et aux variables contenues dans le module « test ».
Sortie :
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
Utilisation de l'importation *
Voyons un exemple utilisant importer *. En utilisant importer *, les fonctions et variables sont directement accessibles, comme le montre l'exemple ci-dessous :
from test import * print(display_message()) print(display_message1()) print(my_name) print(my_address)
Sortie :
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
La fonction dir( )
La fonction dir() est une fonction intégrée dans PythonLa fonction dir() renvoie toutes les propriétés et méthodes, y compris les propriétés intégrées de l'objet donné.
Ainsi, lorsque la fonction dir() est utilisée sur le module, elle vous donnera les variables et les fonctions présentes à l'intérieur du module.
Voici un exemple concret d'utilisation de la fonction `dir()` sur un module. Prenons une classe nommée `Car.py`. Importons-la et assignons-la à `dir()` pour observer le résultat.
La structure des dossiers pour tester le code sera la suivante :
test prop/ Car.py test.py
Nom du fichier : Car.py
class Car: brand_name = "BMW" model = "Z4" manu_year = "2020" def __init__(self, brand_name, model, manu_year): self.brand_name = brand_name self.model = model self.manu_year = manu_year def car_details(self): print("Car brand is ", self.brand_name) print("Car model is ", self.model) print("Car manufacture year is ", self.manu_year) def get_Car_brand(self): print("Car brand is ", self.brand_name) def get_Car_model(self): print("Car model is ", self.model)
Nom du fichier : test.py
import Car class_contents = dir(Car) print(class_contents)
La sortie nous donne le nom de la classe et toutes les fonctions définies dans Car.py.
Vous pouvez également essayer d'utiliser dir() sur un module intégré disponible dans PythonEssayons la même chose sur le json module comme illustré dans l'exemple ci-dessous. Il affichera toutes les propriétés et méthodes disponibles dans le json module.
Import json
json_details = dir(json)
print(json_details)
Sortie :
['JSONDecodeError', 'JSONDecoder', 'JSONEncoder', '__all__', '__author__', '__bu iltins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__pac kage__', '__path__', '__spec__', '__version__', '_default_decoder', '_default_en coder', 'codecs', 'decoder', 'detect_encoding', 'dump', 'dumps', 'encoder', 'loa d', 'loads', 'scanner']
Forfaits
Un package est un répertoire dans lequel tous les modules sont définis. Pour faire un Python L'interpréteur le considère comme un paquet ; votre répertoire doit donc contenir le fichier __init__.py. Ce fichier __init__.py transforme le répertoire en paquet. Voici l'arborescence du paquet sur lequel nous allons travailler.
Le nom du paquet est mon colisPour commencer à utiliser le package, créez un répertoire nommé mypackage/. Dans ce répertoire, créez un fichier vide nommé __init__.py. Créez ensuite trois autres fichiers : module1.py, module2.py et module3.py, et définissez les fonctions comme indiqué dans la capture d'écran. Voici le détail des fichiers module1.py, module2.py et module3.py.
module1.py
def mod1_func1(): print("Welcome to Module1 function1") def mod1_func2(): print("Welcome to Module1 function2") def mod1_func3(): print("Welcome to Module1 function3")
module2.py
def mod2_func1(): print("Welcome to Module2 function1") def mod2_func2(): print("Welcome to Module2 function2") def mod2_func3(): print("Welcome to Module2 function3")
module3.py
def mod3_func1(): print("Welcome to Module3 function1") def mod3_func2(): print("Welcome to Module3 function2") def mod3_func3(): print("Welcome to Module3 function3")
Le paquet est prêt à l'emploi. Appelez maintenant le package dans n'importe lequel de vos fichiers, comme indiqué ci-dessous dans test.py :
Ici, le mypackage.module1 est importé et reçoit un nom d'alias comme mode1De même, vous pouvez utiliser les autres modules module2.py et module3.py de mon package.
import mypackage.module1 as mod1 print(mod1.mod1_func1()) print(mod1.mod1_func2()) print(mod1.mod1_func2())
Sortie :
Welcome to Module1 function1 None Welcome to Module1 function2 None Welcome to Module1 function2 None
Nous venons de présenter le package avec un module simple contenant des fonctions. Selon votre projet, vous pouvez également créer des packages contenant des sous-packages, c'est-à-dire des sous-dossiers contenant des modules avec des classes définies.
Python Chemin de recherche du module
Lors de l'exécution, lorsque Python rencontrer nom du module d'importationL'interpréteur tente alors de localiser le module. Il le recherche d'abord dans la liste des modules intégrés, puis dans tous les répertoires définis dans sys.path.
En résumé, l'interprète effectue la recherche suivante pour localiser le module :
- Dans votre répertoire actuel.
- Dans la liste des modules intégrés.
- Dans les répertoires sys.path.
Vous pouvez obtenir les détails de sys.path en important le module sys et en affichant sys.path. Vous obtiendrez ainsi la liste des répertoires, comme indiqué ci-dessous :
importsys
print(sys.path)
Sortie :
['Python Latest\\task2', 'Users\\AppData\\Local\\Programs\\Python\ \Python37\\python37.zip', 'Users\\AppData\\Local\\Programs\\Python\\P ython37\\DLLs']
Vous pouvez également modifier le chemin et conserver les répertoires selon vos besoins.
Utilisation de l'alias de module dans l'importation
Vous pouvez également raccourcir le nom du module en lui attribuant un alias. Cet alias peut être créé à l'aide de la as mot-clé.
syntaxe:
import filename as alias name
La structure des dossiers pour tester le code sera la suivante :
Mod test/ test.py display.py
Voici le code dans test.py
my_name = "Guru99" my_address = "Mumbai" def display_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Nous allons maintenant utiliser un alias pour test.py dans display.py
Import test as t print(t.display_message()) print(t.display_message1()) print(t.my_name) print(t.my_address)
L'alias utilisé pour le module de test est t. Les fonctions et variables du fichier test.py peuvent donc être référencées à l'aide de cet alias t.
Sortie :
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
Importations absolues et relatives dans Python
Vous savez maintenant comment importer un fichier en tant que module dans un autre fichier. Voyons maintenant comment gérer les fichiers disponibles dans les dossiers. Les fichiers des dossiers peuvent être importés à l'aide d'importations absolues ou relatives.
Considérez que vous avez la structure des dossiers de votre projet, comme indiqué ci-dessous :
Le dossier racine est myproject/. Il contient deux sous-dossiers : package1 et package2.
Le dossier package1 contient deux modules : module1.py et module2.py.
Le dossier package2 a une classe myclass.py, un sous-package subpkg avec module3.py et le dernier module4.py.
- Dans le fichier module1.py, il existe une fonction appelée myfunc1.
- Dans le fichier module2.py, il existe une fonction appelée myfunc2.
- Dans le fichier module3.py, il existe une fonction appelée myfunc3.
- Dans le fichier module4.py, il existe une fonction appelée myfunc4.
Utilisation des importations absolues
Pour les importations absolues, vous devez ajouter le chemin complet de votre module directement depuis le dossier racine du projet.
Voyons maintenant comment utiliser les importations absolues pour faire référence aux fonctions présentes dans chacun des modules.
Pour utiliser la fonction myfunc1, vous devrez l'importer comme suit :
from package1.module1 import myfunc1 or from package1 import module1 module1.myfunc1()
Pour utiliser la fonction myfunc3, vous devrez l'importer comme suit :
from package1.subpkg.module3 import myfunc3 or from package1.subpkg import module3 module3.myfunc3()
Avantages et inconvénients de l'utilisation des importations absolues
Voici les avantages de l’utilisation des importations absolues :
- Il devient facile de tracNous renvoyons les modules pour vérification du code.
- Facile à utiliser et très simple.
- Si le projet est déplacé vers un autre emplacement, les importations resteront inchangées.
Inconvénients de l'utilisation des importations absolues
Voici les inconvénients de l'utilisation des importations absolues :
- Le chemin d'importation peut devenir très long si les modules sont imbriqués et que leurs noms sont longs.
Utilisation des importations relatives
En reprenant la même structure de dossiers mentionnée ci-dessus, nous verrons comment l'importer en utilisant des importations relatives.
Dans une importation relative, le module à importer est relatif à l'emplacement actuel, c'est-à-dire à l'emplacement où se trouve l'instruction d'importation.
Syntaxe
Dans les importations relatives, vous devez ajouter un point (.) avant le nom du module lors de l'importation à l'aide de à partir de.
Il y aura deux points (..) avant le nom du module si celui-ci se trouve un niveau au-dessus de l'emplacement actuel.
En nous référant au schéma de structure des dossiers mentionné ci-dessus, nous avons les modules suivants avec leurs fonctions, auxquels nous devons nous référer.
- Dans le fichier module1.py, il existe une fonction appelée myfunc1.
- Dans le fichier module2.py, il existe une fonction appelée myfunc2.
- Dans le fichier module3.py, il existe une fonction appelée myfunc3.
- Dans le fichier module4.py, il existe une fonction appelée myfunc4.
Pour utiliser la fonction myfunc1, vous devrez l'importer comme suit :
from .module1 import myfunc1
Pour utiliser la fonction myfunc3, vous devrez l'importer comme suit :
from .subpkg.module3 import myfunc3
Avantages des importations relatives
- Il est facile de travailler avec des importations relatives.
- À partir de l'emplacement actuel, les importations peuvent être raccourcies par rapport aux importations absolues.
Inconvénients des importations relatives
- En utilisant des importations relatives, il est difficile de trace retour à l'endroit où se trouve le code.
