Module d'importation en Python avec des exemples

Quels sont les modules en Python ?

Un module est un fichier avec du code python. Le code peut être 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é de module, vous pouvez diviser votre code en différents fichiers au lieu de tout écrire dans un seul fichier.

Dans ce didacticiel, vous apprendrez :

Quels sont les modules en Python ?
Module d'importation Python
Comment créer et importer un module en Python ?
Importer une classe en Python
Utiliser from pour importer le module
Tout importer depuis le module
Utilisation du module d'importation
Utiliser l'importation *
La fonction dir( )
Forfaits
PythonModuleSearchPath
Utiliser l'alias de module dans l'importation
Importations absolues et relatives en Python
UtiliserAbsoluteImports
Utilisation des importations relatives

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 utilisantl'import mot-clé. La fonction ou les 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, tels que 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 de dossier 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'avez pas à mentionner le test.py mais juste le nom du fichier.

Étape 5)

Ensuite, vous pouvez appeler la fonction display_message() de test.py à l'intérieur de 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 obtenez 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 va créer une classe et référencer 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.

Utiliser from pour importer le module

Vous ne pouvez importer qu'une petite partie du module, c'est-à-dire uniquement les fonctions requises et les noms de variables du module au lieu d'importer le code complet.

Lorsque vous souhaitez que seules des choses spécifiques soient importées, vous pouvez utiliser le mot-clé "from" pour importer ce que vous voulez.

Donc la syntaxe est

from  module import your function_name , variables,... etc.

La structure de dossier 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, s'il vous arrive d'utiliser la fonction display_message1() , une erreur s'affichera 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

Tout importer 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 la bibliothèque à utiliser.

Syntaxe :

Import module

Ou en utilisant

from module import *

La structure de dossier 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 préfixer avec 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.

Sortie :

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Utiliser l'importation *

Voyons un exemple en utilisant import * . Utiliser 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, les fonctions présentes dans le module.

Voici un exemple fonctionnel de dir() sur un module. Nous avons une classe appelée Car.py, importons Car et attribuons à dir() pour voir la sortie.

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 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']

Forfaits

Un package est un répertoire avec tous les modules définis à l'intérieur. Pour qu'un interpréteur Python le traite comme un package, votre répertoire doit contenir le fichier init.py. Le init.py fait du répertoire un package. Voici le layout 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 autres fichiers 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 forfait est prêt à l'emploi. Appelez maintenant le package dans n'importe lequel de vos fichiers comme indiqué ci-dessous :test.py:

Ici, le mypackage.module1 est importé et reçoit un nom d'alias en tant que 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 avec des fonctions à l'intérieur. Selon votre projet, vous pouvez également empaqueter avec des sous-paquetages. Sous-dossiers/ayant des modules avec des classes définies.

Chemin de recherche du module Python

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

En résumé, l'interpréteur 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 imprimer 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.

Utiliser l'alias du module dans l'import

Vous pouvez également convertir le nom du module en une forme plus courte en lui donnant un nom d'alias. L'alias peut être fait en utilisant le 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 à l'intérieur de test.py

my_name = "Guru99"
my_address = "Mumbai"

def display_message():
	return "Welcome to Guru99 Tutorials!"	
	
def display_message1():
	return "All about Python!"

Utilisera désormais 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 à l'aide de l'alias t.

Sortie :

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Importations absolues et relatives en Python

Vous savez maintenant importer un fichier en tant que module dans un autre fichier. Voyons maintenant comment gérer les fichiers disponibles dans les dossiers. Les fichiers dans les dossiers peuvent être importés en utilisant des importations absolues ou relatives.

Considérez que vous avez la structure de 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 a 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 y a une fonction appelée myfunc1.
Dans module2.py, il y a une fonction appelée myfunc2.
Dans module3.py, il y a une fonction appelée myfunc3.
Dans module4.py, il y a 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 travailler avec la fonctionmyfunc1, 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 si 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 importer la même chose en utilisant des importations relatives.

Dans l'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 de .

Il y aura 2 points (..) avant le nom du module si le module est au niveau supérieur à partir de l'emplacement actuel.

En se référant à la figure de structure de dossier mentionnée ci-dessus, nous avons les modules suivants avec leur fonction, auxquels nous devons nous référer.

Dans module1.py, il y a une fonction appelée myfunc1.
Dans module2.py, il y a une fonction appelée myfunc2.
Dans module3.py, il y a une fonction appelée myfunc3.
Dans module4.py, il y a une fonction appelée myfunc4.

Pour travailler avec la fonctionmyfunc1, 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.
Depuis l'emplacement actuel, les importations peuvent être raccourcies par rapport aux importations absolues.

Inconvénients des importations relatives

Inconvénients :

En utilisant des importations relatives, il est difficile de retracer où réside le code

Résumé :

L'importation en Python vous aide à vous référer 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 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 tels que Tapuscrit, JavaScript, Java, Ruby, etc.
Un module en python est le code écrit à l'intérieur du fichier, par exemple (test.py). Dans votre fichier, vous pouvez définir vos variables, vos 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.
Grâce à la fonctionnalité de module, vous pouvez décomposer 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 dans le fichier dont vous avez besoin.
Python a ses modules intégrés, ainsi que des bibliothèques/paquets 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 requises et les noms de variables 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 nom d'alias. L'alias peut être fait en utilisant le mot-clé.
Un package est un répertoire avec tous les modules définis à l'intérieur. Pour qu'un interpréteur Python le traite comme un package, votre répertoire doit contenir le fichier __init.pyfile. Le init.py fait du répertoire un package. Voici le layout du package sur lequel nous allons travailler.
Pendant l'exécution, lorsque python rencontre nom du module d'importation , l'interpréteur essaie de localiser le module. Il recherche le module dans la liste des modules intégrés. Plus tard dans l'ensemble, les répertoires définis à l'intérieur de sys.path.
Pour les importations absolues, vous devez ajouter le chemin complet de votre module directement depuis le dossier racine du projet.
En importation relative, le module à importer est relatif à l'emplacement actuel, c'est-à-dire l'emplacement où se trouve l'instruction d'importation.

Multithreading en Python avec exemple :Apprendre GIL en Python Débogueur Python :améliorez sans effort vos compétences de débogage

Python