Fonctions et modules Python : des bases aux concepts avancés

Introduction

Dans ce laboratoire, vous allez explorer 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 les fonctions et les variables connexes dans des fichiers séparés, favorisant 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 organisé.

Ceci est un Guided Lab, qui fournit des instructions étape par étape pour vous aider à apprendre et à pratiquer. Suivez attentivement les instructions pour compléter chaque étape et acquérir une expérience pratique. Les données historiques montrent que c'est un laboratoire de niveau débutant avec un taux de réussite de 87%. Il a reçu un taux d'avis positifs de 98% de la part des apprenants.

Définition et utilisation des fonctions

Dans cette étape, vous allez apprendre à 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 (>>>), ce qui indique 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 ce qui suit :
```
>>> def greet(name):
...     return f"Hello, {name}!"
...
>>> result = greet("Alice")
>>> print(result)
Hello, Alice!
```
1. 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é.
2. Cette fonction prend un paramètre name et renvoie une chaîne de salutation. Nous appelons ensuite la fonction avec l'argument "Alice" et affichons le résultat.
3. 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.
4. Les fonctions peuvent être utilisées pour encapsuler du code réutilisable et effectuer des tâches spécifiques. C'est le bloc de construction principal des programmes Python.

Maintenant, créons une fonction qui effectue un calcul :

>>> def calculate_area(length, width):
...     return length * width
...
>>> area = calculate_area(5, 3)
>>> print(f"The area is: {area}")
The area is: 15

Cette fonction calcule l'aire d'un rectangle à partir de sa longueur et de sa largeur.

Les fonctions peuvent également avoir des valeurs par défaut pour les paramètres :
```
>>> def power(base, exponent=2):
...     return base ** exponent
...
>>> print(power(3))
9
>>> print(power(3, 3))
27
```
Ici, si aucun exposant n'est fourni, la fonction utilise 2 comme valeur par défaut.

Les fonctions peuvent renvoyer plusieurs valeurs à l'aide de tuples :

>>> def min_max(numbers):
...     return min(numbers), max(numbers)
...
>>> minimum, maximum = min_max([1, 5, 3, 9, 2])
>>> print(f"Minimum: {minimum}, Maximum: {maximum}")
Minimum: 1, Maximum: 9

Cette fonction renvoie à la fois la valeur minimale et la valeur maximale d'une liste de nombres.

N'oubliez pas que l'indentation est cruciale en Python. Les corps de fonction doivent être indentés de manière cohérente.

Comprendre la portée des fonctions

Dans cette étape, vous allez apprendre à propos de la portée des fonctions et du 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  ## Variable globale

>>> def print_x():
...     print(f"Global x: {x}")
...
>>> print_x()
Global x: 10

>>> def change_x():
...     x = 20  ## Variable locale
...     print(f"Local x: {x}")
...
>>> change_x()
Local x: 20
>>> print(f"Global x after change_x(): {x}")
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 globale x.

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()
Modified global x: 30
>>> print(f"Global x after modify_global_x(): {x}")
Global x after modify_global_x(): 30

Maintenant, la variable globale x 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)
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 exempt de bogues. Cela permet d'éviter les effets de bord non désirés et rend vos fonctions plus prévisibles.

Création et utilisation de modules

Dans cette étape, vous allez apprendre à créer et à utiliser des modules Python.

Quittez l'interpréteur Python en tapant exit() ou en appuyant sur Ctrl+D.
Ouvrez l'éditeur WebIDE dans l'environnement de la machine virtuelle (VM) 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 (l'enregistrement automatique est activé 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 le fichier 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 une sortie similaire à ceci :
```
Addition: 8
Subtraction: 6
Multiplication: 12
Division: 5.0
Value of PI: 3.14159
```

En créant des modules, vous pouvez organiser les fonctions et les variables connexes dans des fichiers séparés, rendant votre code plus maintenable et réutilisable.

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 les 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.

Importation de fonctions spécifiques à partir de modules

Dans cette étape, vous allez apprendre à importer des fonctions spécifiques à partir de 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 le fichier 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 le fichier 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 à partir du 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 une sortie similaire à ceci :

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éation d'un package

Dans cette étape finale, vous allez apprendre à 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 nécessaire pour que Python traite le répertoire comme un package. Il peut être vide ou contenir du code d'initialisation pour le package.

Ouvrez le fichier 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 le fichier 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 une sortie similaire à ceci :

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 connexes 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 à partir de modules et à organiser des modules connexes en packages.

Vous avez commencé par créer des fonctions simples et vous êtes progressivement passé à des concepts plus complexes tels que la portée des fonctions et les variables globales. Vous avez ensuite appris à créer des modules pour organiser les fonctions et les variables connexes dans des fichiers séparés, rendant votre code plus maintenable et réutilisable.

Vous avez exploré différentes méthodes d'importation de fonctions à partir de modules, notamment l'importation de fonctions spécifiques et l'utilisation d'alias. Cette connaissance vous permet 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 connexes.

Ces concepts de fonctions et de modules sont essentiels pour écrire un code Python bien organisé, efficace et réutilisable. Au fur et à mesure de votre progression dans le monde de Python, vous trouverez ces compétences indispensables pour construire des programmes plus complexes et collaborer sur des projets plus importants. N'oubliez pas de pratiquer régulièrement ces concepts et d'explorer l'immense écosystème de modules et de packages Python disponibles pour améliorer vos capacités de programmation.

Fonctions et modules Python