Introduction
Dans ce laboratoire, vous explorerez deux concepts fondamentaux de la programmation Python : les fonctions et les modules. Les fonctions vous permettent d'organiser votre code en blocs réutilisables, rendant vos programmes plus modulaires et plus faciles à comprendre. Les modules vous permettent d'organiser des fonctions et des variables connexes dans des fichiers distincts, favorisant ainsi la réutilisabilité et la maintenabilité du code. En maîtrisant ces concepts, vous serez en mesure d'écrire un code Python plus efficace et mieux structuré.
Définir et utiliser des fonctions
Dans cette étape, vous apprendrez à définir et à utiliser des fonctions en Python.
Ouvrez l'interpréteur Python en tapant la commande suivante dans votre terminal :
python
Vous devriez voir l'invite Python (>>>), indiquant que vous êtes maintenant dans le shell interactif Python.
Commençons par définir une fonction simple qui salue une personne. Dans l'interpréteur Python, tapez d'abord la définition de la fonction :
def greet(name):
return f"Hello, {name}!"
Après avoir tapé la ligne return indentée, appuyez une fois sur Entrée sur une ligne vide pour terminer la définition de la fonction. Exécutez ensuite la fonction dans le même interpréteur :
result = greet("Alice")
print(result)
Vous devriez voir le résultat suivant :
Hello, Alice!
Les fonctions sont définies à l'aide du mot-clé def suivi du nom de la fonction et des paramètres entre parenthèses. Le corps de la fonction est indenté.
Cette fonction prend un paramètre name et renvoie une chaîne de caractères de salutation. Nous appelons ensuite la fonction avec l'argument "Alice" et affichons le résultat.
L'instruction return est utilisée pour renvoyer une valeur depuis la fonction. Si aucune instruction return n'est présente, la fonction renvoie None.
Les fonctions peuvent être utilisées pour encapsuler du code réutilisable et effectuer des tâches spécifiques. C'est l'élément de base des programmes Python.
Maintenant, créons une fonction qui effectue un calcul. Définissez d'abord la fonction :
def calculate_area(length, width):
return length * width
Appuyez sur Entrée sur une ligne vide pour terminer la définition, puis appelez la fonction :
area = calculate_area(5, 3)
print(f"The area is: {area}")
Vous devriez voir le résultat suivant :
The area is: 15
Cette fonction calcule l'aire d'un rectangle en fonction de sa longueur et de sa largeur.
Les fonctions peuvent également avoir des valeurs de paramètres par défaut. Définissez d'abord la fonction :
def power(base, exponent=2):
return base ** exponent
Appuyez sur Entrée sur une ligne vide, puis testez les deux appels :
print(power(3))
print(power(3, 3))
Vous devriez voir le résultat suivant :
9
27
Ici, si aucun exposant n'est fourni, la fonction utilise 2 comme valeur par défaut.
Les fonctions peuvent renvoyer plusieurs valeurs en utilisant des tuples. Définissez d'abord la fonction :
def min_max(numbers):
return min(numbers), max(numbers)
Appuyez sur Entrée sur une ligne vide, puis appelez la fonction :
minimum, maximum = min_max([1, 5, 3, 9, 2])
print(f"Minimum: {minimum}, Maximum: {maximum}")
Vous devriez voir le résultat suivant :
Minimum: 1, Maximum: 9
Cette fonction renvoie à la fois les valeurs minimale et maximale d'une liste de nombres.
N'oubliez pas que l'indentation est cruciale en Python. Le corps des fonctions doit être indenté de manière cohérente.
Comprendre la portée des fonctions
Dans cette étape, vous découvrirez la portée des fonctions et le comportement des variables à l'intérieur et à l'extérieur des fonctions.
Dans l'interpréteur Python, explorons les variables locales et globales :
x = 10 ## Global variable
def print_x():
print(f"Global x: {x}")
print_x()
def change_x():
x = 20 ## Local variable
print(f"Local x: {x}")
change_x()
print(f"Global x after change_x(): {x}")
Vous devriez voir le résultat suivant :
Global x: 10
Local x: 20
Global x after change_x(): 10
Notez que la fonction change_x() crée une nouvelle variable locale x, qui n'affecte pas la variable x globale.
Pour modifier une variable globale à l'intérieur d'une fonction, utilisez le mot-clé global :
def modify_global_x():
global x
x = 30
print(f"Modified global x: {x}")
modify_global_x()
print(f"Global x after modify_global_x(): {x}")
Vous devriez voir le résultat suivant :
Modified global x: 30
Global x after modify_global_x(): 30
Maintenant, la variable x globale a été modifiée.
Les fonctions peuvent également accéder aux variables de leur portée englobante :
def outer_function(x):
def inner_function():
print(f"x from outer function: {x}")
inner_function()
outer_function(40)
Vous devriez voir le résultat suivant :
x from outer function: 40
La fonction interne peut accéder au paramètre x de la fonction externe.
Comprendre la portée des fonctions est crucial pour écrire un code propre et sans bug. Cela aide à prévenir les effets secondaires involontaires et rend vos fonctions plus prévisibles.
Créer et utiliser des modules
Dans cette étape, vous apprendrez à créer et à utiliser des modules Python.
Quittez l'interpréteur Python en tapant exit() ou en appuyant sur Ctrl+D.
Ouvrez le WebIDE dans l'environnement de la machine virtuelle LabEx.
Créez un nouveau fichier nommé math_operations.py dans le répertoire ~/project :
touch ~/project/math_operations.py
Ouvrez le fichier nouvellement créé dans l'éditeur WebIDE et ajoutez le contenu suivant :
## math_operations.py
def add(a, b):
return a + b
def subtract(a, b):
return a - b
def multiply(a, b):
return a * b
def divide(a, b):
if b != 0:
return a / b
else:
return "Error: Division by zero"
PI = 3.14159
Ce module contient quatre opérations mathématiques de base et une constante PI.
Enregistrez le fichier (la sauvegarde automatique est activée dans le WebIDE).
Maintenant, créez un autre fichier nommé use_math_module.py dans le même répertoire :
touch ~/project/use_math_module.py
Ouvrez use_math_module.py dans l'éditeur WebIDE et ajoutez le contenu suivant :
## use_math_module.py
import math_operations
result_add = math_operations.add(5, 3)
result_subtract = math_operations.subtract(10, 4)
result_multiply = math_operations.multiply(2, 6)
result_divide = math_operations.divide(15, 3)
print(f"Addition: {result_add}")
print(f"Subtraction: {result_subtract}")
print(f"Multiplication: {result_multiply}")
print(f"Division: {result_divide}")
print(f"Value of PI: {math_operations.PI}")
Ce script importe le module math_operations et utilise ses fonctions et sa constante.
Enregistrez le fichier et exécutez-le en utilisant la commande suivante dans le terminal :
python ~/project/use_math_module.py
Vous devriez voir un résultat similaire à celui-ci :
Addition: 8
Subtraction: 6
Multiplication: 12
Division: 5.0
Value of PI: 3.14159
En créant des modules, vous pouvez organiser des fonctions et des variables connexes dans des fichiers séparés, rendant votre code plus facile à maintenir et à réutiliser.
Lorsque vous importez un module, Python le compile en bytecode et stocke le code compilé dans un répertoire __pycache__. Ce répertoire est créé au même emplacement que le fichier du module et contient des fichiers de bytecode compilés (.pyc ou .pyo).
Vous pouvez ignorer ce répertoire en toute sécurité, car Python gère automatiquement la compilation et la mise en cache des modules.
Importer des fonctions spécifiques depuis des modules
Dans cette étape, vous apprendrez à importer des fonctions spécifiques depuis des modules et à utiliser des alias pour rendre votre code plus concis.
Créez un nouveau fichier nommé advanced_math.py dans le répertoire ~/project :
touch ~/project/advanced_math.py
Ouvrez advanced_math.py dans l'éditeur WebIDE et ajoutez le contenu suivant :
## advanced_math.py
import math
def square_root(x):
return math.sqrt(x)
def power(base, exponent):
return math.pow(base, exponent)
def sin(angle):
return math.sin(math.radians(angle))
def cos(angle):
return math.cos(math.radians(angle))
Ce module utilise le module intégré math de Python pour fournir des opérations mathématiques plus avancées.
Maintenant, créez un fichier nommé use_advanced_math.py dans le même répertoire :
touch ~/project/use_advanced_math.py
Ouvrez use_advanced_math.py dans l'éditeur WebIDE et ajoutez le contenu suivant :
## use_advanced_math.py
from advanced_math import square_root, power
from advanced_math import sin as sine, cos as cosine
x = 16
y = 2
angle = 30
print(f"Square root of {x}: {square_root(x)}")
print(f"{x} to the power of {y}: {power(x, y)}")
print(f"Sine of {angle} degrees: {sine(angle)}")
print(f"Cosine of {angle} degrees: {cosine(angle)}")
Ce script importe des fonctions spécifiques depuis le module advanced_math et utilise des alias pour sin et cos.
Enregistrez le fichier et exécutez-le en utilisant la commande suivante dans le terminal :
python ~/project/use_advanced_math.py
Vous devriez voir un résultat similaire à celui-ci :
Square root of 16: 4.0
16 to the power of 2: 256.0
Sine of 30 degrees: 0.49999999999999994
Cosine of 30 degrees: 0.8660254037844387
En important des fonctions spécifiques et en utilisant des alias, vous pouvez rendre votre code plus lisible et éviter les conflits de noms entre différents modules.
Créer un package
Dans cette dernière étape, vous apprendrez à créer un package, qui est un moyen d'organiser des modules connexes dans une hiérarchie de répertoires.
Créez un nouveau répertoire nommé geometry dans le répertoire ~/project :
mkdir ~/project/geometry
À l'intérieur du répertoire geometry, créez deux fichiers : __init__.py et shapes.py :
touch ~/project/geometry/__init__.py
touch ~/project/geometry/shapes.py
Le fichier __init__.py est requis pour que Python traite le répertoire comme un package. Il peut être vide ou contenir du code d'initialisation pour le package.
Ouvrez shapes.py dans l'éditeur WebIDE et ajoutez le contenu suivant :
## geometry/shapes.py
import math
def circle_area(radius):
return math.pi * radius ** 2
def rectangle_area(length, width):
return length * width
def triangle_area(base, height):
return 0.5 * base * height
Maintenant, créez un fichier nommé use_geometry_package.py dans le répertoire ~/project :
touch ~/project/use_geometry_package.py
Ouvrez use_geometry_package.py dans l'éditeur WebIDE et ajoutez le contenu suivant :
## use_geometry_package.py
from geometry.shapes import circle_area, rectangle_area, triangle_area
radius = 5
length = 4
width = 6
base = 3
height = 8
print(f"Area of circle with radius {radius}: {circle_area(radius):.2f}")
print(f"Area of rectangle with length {length} and width {width}: {rectangle_area(length, width)}")
print(f"Area of triangle with base {base} and height {height}: {triangle_area(base, height)}")
Enregistrez le fichier et exécutez-le en utilisant la commande suivante dans le terminal :
python ~/project/use_geometry_package.py
Vous devriez voir un résultat similaire à celui-ci :
Area of circle with radius 5: 78.54
Area of rectangle with length 4 and width 6: 24
Area of triangle with base 3 and height 8: 12.0
En créant un package, vous avez organisé des modules connexes dans une hiérarchie de répertoires, ce qui facilite la gestion et l'importation de fonctionnalités liées dans vos projets.
Résumé
Dans ce laboratoire, vous avez exploré deux concepts fondamentaux de la programmation Python : les fonctions et les modules. Vous avez appris à définir et à utiliser des fonctions, à comprendre la portée des fonctions, à créer et à utiliser des modules, à importer des fonctions spécifiques depuis des modules et à organiser des modules connexes en packages.
Vous avez commencé par créer des fonctions simples et avez progressivement abordé des concepts plus complexes comme la portée des fonctions et les variables globales. Vous avez ensuite appris à créer des modules pour organiser des fonctions et des variables connexes dans des fichiers séparés, rendant votre code plus facile à maintenir et à réutiliser.
Vous avez exploré différentes manières d'importer des fonctions depuis des modules, notamment l'importation de fonctions spécifiques et l'utilisation d'alias. Ces connaissances vous permettent d'écrire un code plus concis et plus lisible tout en évitant les conflits de noms entre différents modules.
Enfin, vous avez appris à créer un package, qui est un moyen d'organiser des modules connexes dans une hiérarchie de répertoires. Cela est particulièrement utile pour les projets plus importants où vous devez gérer plusieurs modules liés.
Ces concepts de fonctions et de modules sont cruciaux pour écrire un code Python bien organisé, efficace et réutilisable. Au fur et à mesure que vous poursuivrez votre apprentissage de Python, vous trouverez ces compétences essentielles pour construire des programmes plus complexes et collaborer sur des projets de plus grande envergure. N'oubliez pas de pratiquer régulièrement ces concepts et d'explorer le vaste écosystème de modules et de packages Python disponibles pour améliorer vos capacités de programmation.
