Modules

Tout au long de notre parcours d'apprentissage de Python, nous avons utilisé des fonctions prédéfinies comme print(), input(), type(), etc. Python dispose d'un grand nombre de fonctions, et elles ne sont pas toutes directement accessibles depuis un nouveau script Python. Au lieu de cela, elles sont stockées dans des fichiers séparés, appelés modules. Pour utiliser ces fonctions, nous devons importer le module qui les contient. Cela se fait à l'aide de l'instruction import. Illustrons cela :

import math           # Importation du module math

print(math.pi)        # Accès à la constante pi du module math
print(math.sqrt(16))  # Accès à la fonction racine carrée du module math

Ce programme affichera la valeur de pi (3.141592653589793) et la racine carrée de 16 (4.0).

Nous pouvons également importer des attributs ou des fonctions spécifiques d'un module en utilisant l'instruction from...import :

from math import pi, sqrt  # Importation uniquement de pi et sqrt du module math

print(pi)                  # Nous pouvons utiliser pi directement sans le préfixer par le nom du module
print(sqrt(16))            # De même, nous pouvons utiliser sqrt directement

La sortie du programme sera la même que celle du précédent.

Parfois, les modules ont de longs noms, et taper le nom complet chaque fois que nous voulons utiliser une fonction peut être fastidieux. Pour éviter cela, nous pouvons utiliser le mot-clé as pour attribuer un nom différent (alias) au module.

import math as m   # Importation du module math et renommage en m

print(m.pi)        # Maintenant, nous pouvons utiliser le court alias
print(m.sqrt(16))  # Utilisation de la fonction sqrt en utilisant l'alias

La sortie sera également 3.141592653589793 et 4.0, comme précédemment.

En conclusion, les modules en Python sont comme des boîtes à outils qui contiennent des fonctions et variables prédéfinies que nous pouvons importer et utiliser dans nos programmes. Ils aident à organiser le code et à le rendre plus efficace.

Comment fonctionnent les modules en coulisses

Lorsque vous importez un module, Python effectue des opérations en coulisses qui ne sont pas immédiatement apparentes. Voici un aperçu de ce qui se passe lorsque vous utilisez l'instruction import :

Localisation du module : Python recherche d'abord le module en vérifiant les emplacements spécifiés dans sa liste sys.path. Cette liste inclut le répertoire courant, le répertoire des packages Python intégrés et tous les chemins spécifiés dans la variable d'environnement PYTHONPATH. Si Python trouve le module, il passe aux étapes suivantes. Sinon, il lève une exception ModuleNotFoundError.

Initialisation du module : Une fois le fichier du module localisé, Python crée un nouvel objet module (types.ModuleType). Ensuite, il charge le contenu du module dans ce nouvel objet, en exécutant tout le code de niveau supérieur du fichier du module. Cela inclut les définitions de fonctions, de classes, de variables, ainsi que l'exécution du code d'initialisation.

Mise en cache du module : Après l'initialisation, le module est mis en cache dans sys.modules (un dictionnaire). Cette étape garantit que lorsque le même module est importé à nouveau dans le script (ou par d'autres scripts), Python n'a pas besoin de localiser et d'initialiser le module à nouveau. Il peut utiliser la version mise en cache. La clé de ce dictionnaire est le nom du module, et la valeur est l'objet module.

Ajout du module à l'espace de noms de l'importateur : Enfin, Python ajoute le nom du module à l'espace de noms du script ou du module qui l'a importé. Ce nom fait référence à l'objet module, de sorte que vous pouvez accéder aux fonctions et variables du module en utilisant la notation par point.

Illustrons cela avec du code :

import sys
import math

print(sys.path)       # Le chemin où Python recherche les modules
print(sys.modules)    # Les modules mis en cache
print(math.sqrt(16))  # Accès à une fonction du module math

Le sys.path affiche une liste de répertoires où Python recherche les modules. Le sys.modules affiche un dictionnaire des noms de modules (clés) et de leurs objets module respectifs (valeurs).

Défi : Nombres Aléatoires

Dans le monde de la cryptographie, les nombres aléatoires jouent un rôle extrêmement crucial. Les algorithmes cryptographiques s'appuient souvent sur la génération de séquences de nombres aléatoires pour assurer la sécurité des données.

Dans ce défi, votre tâche est de simuler un générateur de nombres aléatoires simple qui nous aidera à comprendre la randomisation de manière plus tangible. Python est fourni avec un module intégré nommé random qui possède diverses fonctions pour générer des nombres aléatoires. Vous êtes invité à utiliser ce module pour générer une liste de n entiers aléatoires entre deux nombres donnés a et b. Cependant, la randomisation ne doit pas être véritablement aléatoire : nous devons fixer la graine à 42 pour la reproductibilité de l'expérience. Vous pouvez utiliser la fonction seed() pour fixer la graine et randint() pour générer un nombre aléatoire.

La première ligne de l'entrée contient trois entiers séparés par des espaces : n, a et b. Les nombres a et b déterminent l'intervalle (inclusif) à partir duquel les nombres aléatoires doivent être choisis, et n détermine combien de nombres vous devez générer.

Le programme doit afficher n nombres aléatoires séparés par des espaces, générés dans l'intervalle [a, b] avec la graine aléatoire fixée à 42.

Entrée	Sortie
10 1 100	82 15 4 95 36 32 29 18 95 14
5 1 5	1 1 3 2 2
3 10 20	20 11 10

Remarque : Comme nous avons fixé la graine aléatoire à 42, la séquence de sortie doit rester la même à chaque exécution du programme. C'est une fonctionnalité que nous exploitons pour les tests, le débogage et d'autres scénarios où une sortie déterministe est nécessaire.

Défi : Nombres Aléatoires

Constraints

To check your solution you need to sign in

Sign in to continue