Dans ce tutoriel python, nous vous parlons des modules et les importions.

Structurer le code python : modules, importations et espaces de noms

À mesure que nous nous aventurons dans la création de programmes de plus en plus élaborés, il devient pertinent de structurer le code en plusieurs fichiers. Chaque fichier .py individuel est désigné comme un module. En application, l’introduction d’un module se réalise en utilisant la fonction “import” suivie du nom du module, qui par défaut correspond au nom du fichier (à l’exclusion de l’extension .py).

Lorsque nous faisons l’importation d’un module, son code est exécuté. Normalement, cette exécution se restreint à la définition de fonctions et de classes, bien qu’en théorie, elle puisse inclure n’importe quel élément. De plus, le module dispose d’un espace réservé où ces fonctions et classes sont déclarées, ce que l’on nomme son espace de noms.

Les fichiers twofunctions.py et theimporter.py. Ces fichiers semblent définir deux fonctions f(x) et g(x) dans le fichier twofunctions.py et ensuite, dans le fichier theimporter.py, vous importez le module twofunctions et définissez à nouveau une fonction f(x) avec une logique différente.

Voici le contenu des deux fichiers :

twofunctions.py :

# File: twofunctions.py
def f(x):
    return 2 * x + 3

def g(x):
    return x ** 2 - 1

theimporter.py :

# File: theimporter.py
import twofunctions

def f(x):
    return x - 1

print(twofunctions.f(1)) # Cela affichera 5
print(f(1)) # Cela affichera 0
print(twofunctions.g(4)) # Cela affichera 15

Lorsque vous exécutez theimporter.py, il importe le module twofunctions et utilise les fonctions f(x) et g(x) définies dans ce module, ainsi que la fonction f(x) redéfinie localement dans le fichier theimporter.py. Le résultat de l’exécution sera comme indiqué dans les commentaires.

L’importation place le nom du module dans l’espace de noms actuel. Vous pouvez l’utiliser pour identifier les fonctions du module.

Gérer l’importation de modules

L’importation est loin d’être mystérieuse. En réalité, elle revient essentiellement à informer le programme en cours des réalisations d’un autre programme. Étant donné que l’importation entraîne généralement l’exécution du module, il est recommandé d’ajuster le comportement d’un script en fonction de son exécution directe ou de son exécution en tant qu’importation. Cela peut être déterminé en examinant l’attribut de nom du module. Lorsque vous exécutez le module en tant que script, la variable “name” est automatiquement définie sur “main”. En revanche, si le module est en cours d’importation, le nom par défaut est celui du module lui-même.

Vous pouvez touchez tout à travers cet exemple: 

# File: mymodule.py
print("The name of this module is", __name__)
The name of this module is __main__
# File: theimporter.py
import mymodule
print("Notice that it will print something different when imported?")

Voici comment nous utilisons l’attribut name pour vérifier comment le programme est
en cours d’exécution.

def somefunction():
print("Real important stuff here.")
if __name__ == ’__main__’:
somefunction()

Output: Real important stuff here.

Dans l’exemple précédent, le message est affiché uniquement lorsque le module est exécuté en tant que script, et il n’est pas affiché (c’est-à-dire, la fonction “some” n’est pas appelée) lors de l’importation du module. Cette situation est courante en Python.

Importation de modules en Python et gestion des espaces de noms

Il est essentiel de noter que les modules ne s’exécutent qu’à la première importation. Par exemple, si nous importons le même module deux fois, il ne sera exécuté qu’une seule fois. À ce stade, l’espace de noms est déjà établi et accessible pour la deuxième importation. Cela empêche également la création de boucles infinies qui pourraient survenir si deux modules s’importaient mutuellement.

Il existe quelques autres formes courantes de déclarations d’importation standard. Vous avez la possibilité d’importer un nom spécifique ou un groupe de noms depuis un module en utilisant la syntaxe suivante : “from nom_du_module import nom_de_l’élément”. Cette action introduit le nom de l’élément désiré dans l’espace de noms actuel sans nécessiter de préfixe avec le nom du module suivi d’un point.

Vous pouvez importer tous les noms du module dans l’espace de noms actuel : from modulename import *. Si vous faites cela, chaque nom défini dans le module sera accessible dans l’espace de noms actuel.
Il n’est pas nécessaire d’être précédé de modulename et d’un point. Bien que facile à écrire et rapide pour de nombreuses choses, cela est généralement mal vu car vous ne savez souvent pas exactement quels noms vous importez lorsque vous le faites.

Vous pouvez renommer le module après l’avoir importé : importez numpy en tant que np.

Cela vous permet d’utiliser un nom différent pour faire référence aux objets du

module. Dans cet exemple, je peux écrire np.array au lieu de numpy.array.

La raison la plus courante de le faire est d’avoir un nom plus court. Une autre utilisation plus fondamentale est d’éviter les conflits de nommage.