Recherche de site Web

Module d'importation en Python avec exemples

Quels sont les modules en 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 module d'importation Python ?

Un fichier est considéré comme un module en python. Pour utiliser le module, vous devez l'importer en utilisant le mot clé import. 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 langages, comme TypeScript, JavaScript, Java, Ruby, etc.

Comment créer et importer un module en 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 le résultat suivant :

Welcome to Guru99 Tutorials!

Importer une classe en 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())

Résultat :

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())

Résultat :

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())

Résultat :

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 module test.

Résultat :

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Utilisation de l'importation *

Voyons un exemple utilisant import *. Grâce à import *, 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)

Résultat :

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 en Python. Essayons la même chose sur le module json comme indiqué dans l'exemple ci-dessous. Il affichera toutes les propriétés et méthodes disponibles dans le module json .

Import json
json_details = dir(json)
print(json_details)

Résultat :

['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 qu'un interpréteur Python le traite comme un package, votre répertoire doit contenir 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 package est mon package. 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 package est prêt à l’emploi. Appelez maintenant le package dans l'un de vos fichiers comme indiqué ci-dessous :test.py :

Ici, mypackage.module1 est importé et reçoit un alias 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())

Résultat :

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.

Chemin de recherche du module Python

Pendant l'exécution, lorsque python rencontre le nom du module d'importation, l'interpréteur tente de localiser le module. Il recherche le module dans la liste des modules intégrés. Plus tard, les répertoires définis dans sys.path.

En résumé, l'interprète effectue la recherche suivante pour localiser le module :

  1. Dans votre répertoire actuel.
  2. Dans la liste des modules intégrés
  3. 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)

Résultat :

['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.

Résultat :

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Importations absolues et relatives en 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 en utilisant depuis.

Il y aura 2 points (..) avant le nom du module si le module se trouve au niveau supérieur par rapport à 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 l'endroit où réside le code

Résumé

  • L'importation en Python vous aide à faire référence au code, c'est-à-dire aux .fonctions/objets écrits dans un autre fichier. Il est également utilisé pour importer des bibliothèques/packages python installés à l'aide de pip (gestionnaire de packages python), et vous devez ensuite les utiliser dans votre code.
  • La fonctionnalité d'importation est disponible dans d'autres langages 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. Plus tard, en utilisant l'importation, vous pourrez vous référer au code contenu dans le fichier dont vous avez besoin.
  • Python a ses modules intégrés, ainsi que les bibliothèques/packages externes installés à l'aide d'un gestionnaire de packages 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 qu'un interpréteur Python le traite comme un package, votre répertoire doit contenir 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 rencontre le nom du module d'importation, l'interpréteur tente de localiser le module. Il recherche le module dans la liste des modules intégrés. Plus tard, 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.

Articles connexes