Modules Python
Modules Python
Dans cet article, vous apprendrez à créer et importer des modules personnalisés en Python. Vous trouverez également différentes techniques pour importer et utiliser des modules personnalisés et intégrés dans Python.
Vidéo :Modules Python
Que sont les modules en Python ?
Les modules font référence à un fichier contenant des instructions et des définitions Python.
Un fichier contenant du code Python, par exemple :example.py , est appelé un module, et son nom de module serait example .
Nous utilisons des modules pour décomposer les gros programmes en petits fichiers gérables et organisés. De plus, les modules permettent de réutiliser le code.
Nous pouvons définir nos fonctions les plus utilisées dans un module et l'importer, au lieu de copier leurs définitions dans différents programmes.
Créons un module. Tapez ce qui suit et enregistrez-le sous example.py .
# Python Module example
def add(a, b):
"""This program adds two
numbers and return the result"""
result = a + b
return result
Ici, nous avons défini une fonction add() dans un module nommé example . La fonction prend deux nombres et renvoie leur somme.
Comment importer des modules en Python ?
Nous pouvons importer les définitions à l'intérieur d'un module vers un autre module ou l'interpréteur interactif en Python.
Nous utilisons le import mot-clé pour ce faire. Pour importer notre module précédemment défini example , nous tapons ce qui suit dans l'invite Python.
>>> import example
Cela n'importe pas les noms des fonctions définies dans example directement dans la table des symboles courante. Il importe uniquement le nom du module example là.
En utilisant le nom du module, nous pouvons accéder à la fonction en utilisant le point . opérateur. Par exemple :
>>> example.add(4,5.5)
9.5 Python a des tonnes de modules standard. Vous pouvez consulter la liste complète des modules standard Python et leurs cas d'utilisation. Ces fichiers se trouvent dans le répertoire Lib à l'intérieur de l'emplacement où vous avez installé Python.
Les modules standard peuvent être importés de la même manière que nous importons nos modules définis par l'utilisateur.
Il existe différentes manières d'importer des modules. Ils sont listés ci-dessous..
Instruction d'importation Python
Nous pouvons importer un module en utilisant le import et accédez aux définitions qu'elle contient en utilisant l'opérateur point comme décrit ci-dessus. Voici un exemple.
# import statement example
# to import standard module math
import math
print("The value of pi is", math.pi) Lorsque vous exécutez le programme, la sortie sera :
The value of pi is 3.141592653589793
Importer avec renommer
On peut importer un module en le renommant comme suit :
# import module by renaming it
import math as m
print("The value of pi is", m.pi)
Nous avons renommé le math module comme m . Cela peut nous faire gagner du temps de saisie dans certains cas.
Notez que le nom math n'est pas reconnu dans notre périmètre. Par conséquent, math.pi n'est pas valide, et m.pi est la bonne implémentation.
Python de... déclaration d'importation
Nous pouvons importer des noms spécifiques à partir d'un module sans importer le module dans son ensemble. Voici un exemple.
# import only pi from math module
from math import pi
print("The value of pi is", pi)
Ici, nous avons importé uniquement le pi attribut du math module.
Dans de tels cas, nous n'utilisons pas l'opérateur point. Nous pouvons également importer plusieurs attributs comme suit :
>>> from math import pi, e
>>> pi
3.141592653589793
>>> e
2.718281828459045 Importer tous les noms
Nous pouvons importer tous les noms (définitions) d'un module en utilisant la construction suivante :
# import all names from the standard module math
from math import *
print("The value of pi is", pi) Ici, nous avons importé toutes les définitions du module mathématique. Cela inclut tous les noms visibles dans notre champ d'application, à l'exception de ceux commençant par un trait de soulignement (définitions privées).
Tout importer avec le symbole astérisque (*) n'est pas une bonne pratique de programmation. Cela peut conduire à des définitions en double pour un identifiant. Cela nuit également à la lisibilité de notre code.
Chemin de recherche du module Python
Lors de l'importation d'un module, Python examine plusieurs endroits. Interpreter recherche d'abord un module intégré. Ensuite (si le module intégré n'est pas trouvé), Python examine une liste de répertoires définis dans sys.path . La recherche est dans cet ordre.
- Le répertoire actuel.
PYTHONPATH(une variable d'environnement avec une liste de répertoires).- Le répertoire par défaut dépendant de l'installation.
>>> import sys >>> sys.path ['', 'C:\\Python33\\Lib\\idlelib', 'C:\\Windows\\system32\\python33.zip', 'C:\\Python33\\DLLs', 'C:\\Python33\\lib', 'C:\\Python33', 'C:\\Python33\\lib\\site-packages']
Nous pouvons ajouter et modifier cette liste pour ajouter notre propre chemin.
Recharger un module
L'interpréteur Python n'importe un module qu'une seule fois au cours d'une session. Cela rend les choses plus efficaces. Voici un exemple pour montrer comment cela fonctionne.
Supposons que nous ayons le code suivant dans un module nommé my_module .
# This module shows the effect of
# multiple imports and reload
print("This code got executed") Nous voyons maintenant l'effet des importations multiples.
>>> import my_module
This code got executed
>>> import my_module
>>> import my_module Nous pouvons voir que notre code n'a été exécuté qu'une seule fois. Cela signifie que notre module n'a été importé qu'une seule fois.
Maintenant, si notre module changeait au cours du programme, nous devions le recharger. Une façon de faire est de redémarrer l'interpréteur. Mais cela n'aide pas beaucoup.
Python fournit un moyen plus efficace de le faire. Nous pouvons utiliser le reload() fonction à l'intérieur du imp module pour recharger un module. Nous pouvons le faire de la manière suivante :
>>> import imp
>>> import my_module
This code got executed
>>> import my_module
>>> imp.reload(my_module)
This code got executed
<module 'my_module' from '.\\my_module.py'> La fonction intégrée dir()
Nous pouvons utiliser le dir() fonction pour trouver les noms qui sont définis à l'intérieur d'un module.
Par exemple, nous avons défini une fonction add() dans le module example que nous avions au début.
Nous pouvons utiliser dir en example module de la manière suivante :
>>> dir(example)
['__builtins__',
'__cached__',
'__doc__',
'__file__',
'__initializing__',
'__loader__',
'__name__',
'__package__',
'add']
Ici, nous pouvons voir une liste triée de noms (avec add ). Tous les autres noms commençant par un trait de soulignement sont des attributs Python par défaut associés au module (non définis par l'utilisateur).
Par exemple, le __name__ l'attribut contient le nom du module.
>>> import example
>>> example.__name__
'example'
Tous les noms définis dans notre espace de noms actuel peuvent être trouvés en utilisant le dir() fonction sans aucun argument.
>>> a = 1
>>> b = "hello"
>>> import math
>>> dir()
['__builtins__', '__doc__', '__name__', 'a', 'b', 'math', 'pyscripter'] Python