Module d'importation en Python avec des exemples

Table des matières:

Anonim

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 de 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.

Dans ce tutoriel, 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
  • Utilisation du module from to import
  • Tout importer depuis le module
  • Utilisation du module d'importation
  • Utilisation de l'importation *
  • La fonction dir ()
  • Paquets
  • PythonModuleSearchPath
  • Utilisation de l'alias de module dans l'importation
  • Importations absolues et relatives en Python
  • UsingAbsoluteImports
  • 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 à l' aide du mot-clé import . 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, comme dactylographié, 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 données pour créer un module en python.

La structure de dossiers utilisée pour tester le code est la suivante:

modtest/test.pydisplay.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) À l'intérieur de 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 uniquement 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 testprint(test.display_message())

Étape 6)

Lorsque vous exécutez display.py, vous obtiendrez la sortie suivante:

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.pydisplay.py

Créez un fichier appelé Car.py avec le code suivant:

Nom de 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_nameself.model = modelself.manu_year = manu_yeardef 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 de fichier: display.py

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

Production:

BMWCar brand is BMWCar model is Z5Car manufacture year is 2020Car brand is BMWCar model is Z5

Nous pouvons donc accéder à toutes les variables et fonctions de Car.py en utilisant le module Car.

Utilisation du module from to import

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 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 de dossiers utilisée pour tester le code est la suivante:

modtest/test.pydisplay.py

Dans test.py, il y a 2 fonctions comme indiqué:

Nom de fichier: test.py

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

Vous voulez maintenant la fonction display_message (). La fonction ou la variable que vous importez est accessible directement comme indiqué ci-dessous:

Nom du fichier: display.py

from test import display_messageprint(display_message())

Production:

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

Production:

Traceback (most recent call last):File "display.py", line 3, in print(display_message1())Name Error: name 'display_message1' is not defined

Tout importer depuis le module

L'importation vous permet d'importer le module complet en utilisant import suivi du nom du module, c'est-à-dire le nom de fichier ou la bibliothèque à utiliser.

Syntaxe:

Import module

Ou en utilisant

from module import *

La structure de dossiers utilisée pour tester le code est la suivante:

modtest/test.pydisplay.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!"

Utilisation du 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 de fichier: display.py

Import testprint(test.display_message())print(test.display_message1())print(test.my_name)print(test.my_address)

Le test du nom du module est utilisé pour faire référence à la fonction et aux variables à l'intérieur du test du module.

Production:

Welcome to Guru99 Tutorials!All about Python!Guru99Mumbai

Utilisation de l'importation *

Voyons un exemple utilisant import * . En utilisant 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)

Production:

Welcome to Guru99 Tutorials!All about Python!Guru99Mumbai

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 qui sont présentes à l'intérieur du module.

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

La structure des dossiers pour tester le code sera la suivante:

test prop/Car.pytest.py

Nom de 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_nameself.model = modelself.manu_year = manu_yeardef 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 de fichier: test.py

import Carclass_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 jsonjson_details = dir(json)print(json_details)

Production:

['JSONDecodeError', 'JSONDecoder', 'JSONEncoder', '__all__', '__author__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', '__version__', '_default_decoder', '_default_encoder', 'codecs', 'decoder', 'detect_encoding', 'dump', 'dumps', 'encoder', 'load', 'loads', 'scanner']

Paquets

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 avoir le fichier init.pyfile. Le fichier init.py crée le répertoire sous forme de package. Voici la mise en page 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 package est prêt à être utilisé. 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 mod1print(mod1.mod1_func1())print(mod1.mod1_func2())print(mod1.mod1_func2())

Production:

Welcome to Module1 function1NoneWelcome to Module1 function2NoneWelcome to Module1 function2None

Nous venons de démontrer le package avec un module simple avec des fonctions à l'intérieur. Selon votre projet, vous pouvez également créer des packages 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 essaie 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 résumer, l'interpréteur 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:

importsysprint(sys.path)

Production:

['Python Latest\\task2', 'Users\\AppData\\Local\\Programs\\Python\\Python37\\python37.zip', 'Users\\AppData\\Local\\Programs\\Python\\Python37\\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 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.pydisplay.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 maintenant un alias pour test.py dans display.py

Import test as tprint(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.

Production:

Welcome to Guru99 Tutorials!All about Python!Guru99Mumbai

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 dans les dossiers peuvent être importés à l'aide d'importations absolues ou relatives.

Considérez que vous avez la structure de vos dossiers de projet, comme indiqué ci-dessous:

Le dossier racine est mon projet /. Il a deux sous-dossiers package1 et package2.

Le dossier package1 comprend 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éemyfunc1.
  • Dans module2.py, il existe une fonction appeléemyfunc2.
  • Dans module3.py, il existe une fonction appeléemyfunc3.
  • Dans module4.py, il existe une fonction appeléemyfunc4.

Utilisation d'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 se référer aux fonctions présentes dans chacun des modules.

Pour travailler avec la fonction myfunc1, vous devrez importer comme suit:

from package1.module1 import myfunc1orfrom package1 import module1module1.myfunc1()

Pour travailler avec la fonction myfunc3, vous devrez importer comme suit:

from package1.subpkg.module3 import myfunc3orfrom package1.subpkg import module3module3.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:

Désavantages:

  • Le chemin d'importation peut devenir très long au 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 que celle mentionnée ci-dessous, nous verrons comment importer la même chose à l'aide d'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 à l'aide de .

Ce sera 2 périodes (…) 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 existe une fonction appeléemyfunc1.
  • Dans module2.py, il existe une fonction appeléemyfunc2.
  • Dans module3.py, il existe une fonction appeléemyfunc3.
  • Dans module4.py, il existe une fonction appeléemyfunc4.

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

Désavantages:

  • En utilisant des importations relatives, il est difficile de retracer 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 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 dactylographié, JavaScript, java, ruby, etc.
  • Un module est 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.
  • 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 pouvez vous référer au code à l'intérieur du fichier dont vous avez besoin.
  • Python a ses modules intégrés, et aussi 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 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 avoir le __init.pyfile. Le fichier init.py crée le répertoire sous forme de package. Voici la mise en page du package sur lequel nous allons travailler.
  • Pendant l'exécution, lorsque python rencontre le 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, 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.
  • Dans l'importation relative, le module à importer est relatif à l'emplacement actuel qui est l'emplacement où l'instruction d'importation est présente.