Dans cet article, vous apprendrez à créer et à importer des modules personnalisés en Python. En outre, vous trouverez différentes techniques pour importer et utiliser des modules personnalisés et intégrés en 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.pyest appelé un module, et son nom de module serait example.
Nous utilisons des modules pour décomposer les grands programmes en petits fichiers gérables et organisés. De plus, les modules permettent la réutilisation du 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 à l' add()intérieur d'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 importmot - 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'importera pas les noms des fonctions définies dans exampledirectement dans la table de symboles courante. Il importe uniquement le nom du module examplelà-bas.
En utilisant le nom du module, nous pouvons accéder à la fonction en utilisant l' .opérateur point . 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'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 à l'aide de l' importinstruction et accéder aux définitions qu'il contient à l'aide de 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:
La valeur de pi est 3,141592653589793
Importer avec renommer
Nous pouvons 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 mathmodule en m. Cela peut nous faire gagner du temps dans certains cas.
Notez que le nom mathn'est pas reconnu dans notre périmètre. Par conséquent, math.pin'est pas valide et m.piconstitue la bonne implémentation.
Instruction Python from… import
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 n'avons importé que l' piattribut du mathmodule.
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 étendue sauf 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 dupliquées pour un identifiant. Cela entrave également la lisibilité de notre code.
Chemin de recherche du module Python
Lors de l'importation d'un module, Python regarde plusieurs endroits. L'interpréteur recherche d'abord un module intégré. Ensuite (si le module intégré n'est pas trouvé), Python regarde dans 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 ')
We can add and modify this list to add our own path.
Reloading a module
The Python interpreter imports a module only once during a session. This makes things more efficient. Here is an example to show how this works.
Suppose we have the following code in a module named my_module.
# This module shows the effect of # multiple imports and reload print("This code got executed")
Now we see the effect of multiple imports.
>>> import my_module This code got executed >>> import my_module >>> import my_module
We can see that our code got executed only once. This goes to say that our module was imported only once.
Now if our module changed during the course of the program, we would have to reload it.One way to do this is to restart the interpreter. But this does not help much.
Python provides a more efficient way of doing this. We can use the reload() function inside the imp module to reload a module. We can do it in the following ways:
>>> import imp >>> import my_module This code got executed >>> import my_module >>> imp.reload(my_module) This code got executed
The dir() built-in function
Nous pouvons utiliser la dir()fonction pour trouver les noms définis dans un module.
Par exemple, nous avons défini une fonction add()dans le module exampleque nous avions au début.
Nous pouvons utiliser dirdans le examplemodule 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, l' __name__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 la dir()fonction sans aucun argument.
>>> a = 1 >>> b = "hello" >>> import math >>> dir() ('__builtins__', '__doc__', '__name__', 'a', 'b', 'math', 'pyscripter')
