Importer le module dans Python avec des exemples
Anna Blake
Quels sont les modules dans Python?
Un module est un fichier avec du code python. Le code peut se présenter sous la forme de variables, de fonctions ou de classes définies. 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 en python. Pour utiliser le module, vous devez l'importer en utilisant l'importation mot-clé. La fonction ou les variables présentes à l'intérieur du fichier peuvent être utilisées dans un autre fichier en important le module. Cette fonctionnalité est disponible dans d'autres langues, comme TypeScript, JavaScript, java, ruby, 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 en 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 display.py, importez le fichier moduletest.py, comme indiqué ci-dessous :
import test
Lors de l'importation, vous n'êtes pas obligé de mentionner le test.py mais juste le nom du fichier.
Étape 5) Ensuite, vous pouvez appeler la fonction display_message() depuis test.py dans display.py, vous devez 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 ce qui suit Sortie :
Welcome to Guru99 Tutorials!
Importer une classe dans Python
Plus tôt, nous avons vu un module simple avec une fonction. Ici, nous créerons une classe et ferons référence à la classe 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)
Dans le fichier Car.py , il y a les attributs brand_name, model et manu_year. Les fonctions définies à l'intérieur de la classe sont car_details(), get_Car_brand(), 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 ne pouvez importer qu'une petite partie du module, c'est-à-dire uniquement les fonctions et noms de variables requis du module au lieu d'importer le code complet.
Lorsque vous souhaitez importer uniquement des éléments spécifiques, 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 test.py il y a 2 fonctions comme indiqué :
Nom du fichier : test.py
defdisplay_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Maintenant, vous voulez 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!
Maintenant, si vous utilisez la fonction display_message1() , cela générera une erreur indiquant que la fonction n'est pas définie comme indiqué 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
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
En utilisant simplement le nom du module d'importation, pour faire référence aux variables et aux fonctions à l'intérieur du module, il doit être préfixé 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 du module test est utilisé pour faire référence à la fonction et aux variables à l'intérieur du test du module.
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( )
Le dir() est une fonction intégrée en python. Le 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 dir() est utilisé sur le module, il vous donnera les variables, fonctions présentes à l'intérieur du module.
Voici un exemple fonctionnel de dir() sur un module. Nous avons une classe appelée Car.py, importons Car et attribuons-la à dir() pour voir 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 Python. Essayons la même chose sur json module comme indiqué dans l’exemple ci-dessous. Il affichera toutes les propriétés et méthodes disponibles dans 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']
Packs
Un package est un répertoire dans lequel tous les modules sont définis. Pour faire un Python l'interprète le traite comme un package, votre répertoire doit avoir le fichier init.py. Le init.py crée le répertoire sous forme de package. Voici la disposition du package sur lequel nous allons travailler.
Le nom du paquet est mon colis. Pour commencer à travailler avec le package, créez un répertoire appelé package/. Dans le répertoire, créez un fichier vide appelé __init__.py. Créez 3 fichiers supplémentaires module1.py, module2.py et module3.py et définissez les fonctions comme indiqué dans la capture d'écran. Voici les détails de 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 paquetest prêt à l’emploi. Appelez maintenant le package dans l'un de vos fichiers comme indiqué ci-dessous :test.py :
Ici, le mypackage.module1 est importé et reçoit un nom d'alias comme mod1. De même, vous pouvez utiliser d'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 démontrer le package avec un module simple contenant des fonctions. Selon votre projet, vous pouvez également créer un package avec des sous-packages. Sous-dossiers/ayant des modules avec des classes définies.
Python Chemin de recherche du module
Pendant l'exécution, lorsque Python apparaît nom du module d'importation, l'interprète tente de localiser le module. Il recherche le module dans la liste des modules intégrés. Later en tout, 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 imprimant le sys.path. Il vous donnera 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 convertir le nom du module en une forme plus courte en lui donnant un alias. L'alias peut être créé à l'aide du 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 . Ainsi, la fonction et les variables de test.py peuvent être référencées en utilisant l'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 mon projet/. 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 module1.py, il existe une fonction appelée myfunc1.
- Dans module2.py, il existe une fonction appelée myfunc2.
- Dans module3.py, il existe une fonction appelée myfunc3.
- Dans 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 à partir du 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 travailler avec la fonction myfunc1, vous devrez importer comme suit :
from package1.module1 import myfunc1 or from package1 import module1 module1.myfunc1()
Pour travailler avec la fonction myfunc3 vous devrez 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 retracer les modules pour la vérification du code.
- Facile à utiliser et très simple.
- Si le projet est déplacé vers un chemin différent, les importations resteront les mêmes.
Inconvénients de l'utilisation des importations absolues
Voici les inconvénients de l’utilisation des importations absolues :
Inconvénients :
- Le chemin d'importation peut devenir très long dans le cas où les modules sont imbriqués et si le nom des modules est long.
Utilisation des importations relatives
En considérant la même structure de dossiers mentionnée ci-dessous, nous verrons comment les importer à l'aide d'importations relatives.
En importation relative, le module à importer est relatif à l'emplacement actuel qui est l'emplacement où l'instruction d'importation est présente.
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 2 points (..) avant le nom du module si le module se trouve au niveau supérieur à celui de l'emplacement actuel.
En nous référant à la figure de structure des dossiers mentionnée ci-dessus, nous avons les modules suivants avec leur fonction, auxquels nous devons nous référer.
- Dans module1.py, il existe une fonction appelée myfunc1.
- Dans module2.py, il existe une fonction appelée myfunc2.
- Dans module3.py, il existe une fonction appelée myfunc3.
- Dans module4.py, il existe une fonction appelée myfunc4.
Pour travailler avec la fonction myfunc1, vous devrez importer comme suit :
from .module1 import myfunc1
Pour travailler avec la fonction myfunc3, vous devrez importer comme suit :
from .subpkg.module3 import myfunc3
Avantages des importations relatives
Avantages :
- 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
Inconvénients :
- En utilisant les importations relatives, il est difficile de retracer où réside le code
Résumé
- Importer dans Python vous aide à faire référence au code, c'est-à-dire aux fonctions/objets qui sont écrits dans un autre fichier. Il est également utilisé pour importer des bibliothèques/packages Python qui sont installés à l'aide de pip (gestionnaire de packages Python), et que vous devez ensuite utiliser dans votre code.
- La fonctionnalité d'importation est disponible dans d'autres langues comme TypeScript, JavaScript, java, ruby, etc.
- Un module est python, c'est le code écrit dans le fichier, par exemple (test.py). Dans votre fichier, vous pouvez définir vos variables, fonctions ou votre classe. Le fichier entier devient un module et peut être importé dans un autre fichier pour faire référence au code.
- Avec la fonctionnalité du module, vous pouvez diviser votre code en différents fichiers au lieu de tout écrire dans un seul fichier. Later, en utilisant l'importation, vous pouvez vous référer au code contenu dans le fichier dont vous avez besoin.
- Python a ses modules intégrés, ainsi que des bibliothèques/packages externes installés à l'aide d'un gestionnaire de paquets python (pip), par exemple, pandas, NumPy, etc. sont appelés modules.
- Vous ne pouvez importer qu'une petite partie du module, c'est-à-dire uniquement les fonctions et noms de variables requis du module au lieu d'importer le code complet.
- Vous pouvez également convertir le nom du module en une forme plus courte en lui donnant un alias. L'alias peut être créé à l'aide du mot-clé.
- Un package est un répertoire dans lequel tous les modules sont définis. Pour faire un Python l'interprète le traite comme un package, votre répertoire doit avoir le fichier __init.py. Le init.py crée le répertoire sous forme de package. Voici la disposition du package sur lequel nous allons travailler.
- Pendant l'exécution, lorsque Python apparaît nom du module d'importation, l'interprète tente de localiser le module. Il recherche le module dans la liste des modules intégrés. Later en tout, les répertoires définis dans sys.path.
- Pour les importations absolues, vous devez ajouter le chemin complet de votre module directement à partir du dossier racine du projet.
- En importation relative, le module à importer est relatif à l'emplacement actuel qui est l'emplacement où l'instruction d'importation est présente.
