📚 Fonctions en Python

Modularité et réutilisabilité du code

🎯 Définitions

🔧 Qu'est-ce qu'une Fonction ?

Une fonction est un bloc de code réutilisable qui effectue une tâche spécifique. Elle permet de modulariser le code et d'éviter les répétitions.

⚙️

Fonction

Bloc de code réutilisable qui effectue une tâche précise. Peut recevoir des données et retourner un résultat.

📥

Paramètre

Variable d'entrée qui permet à la fonction de recevoir des données pour son fonctionnement.

📤

Valeur de Retour

Résultat que la fonction renvoie après avoir effectué ses calculs ou traitements.

📋 Structure d'une Fonction

def nom_de_fonction(variable_1: type, variable_2: type) -> type_renvoi:
    """
    Documentation de la fonction :
    - Explications de ce que fait la fonction
    - Description des paramètres
    - Description de la valeur de retour
    """
    # Corps de la fonction
    resultat = # calculs ou traitements
    return resultat  # ou None si pas de retour

💡 Exemple Concret : Convertir des températures Celsius en Fahrenheit
Formule : Temperature_Fahrenheit = (Temperature_Celsius × 9/5) + 32

💻 Exemples de Fonctions

def celsius_vers_fahrenheit(temp_celsius: int) -> float:
    """
    Convertit une température Celsius en Fahrenheit.

    Args:
        temp_celsius (int): Température en degrés Celsius

    Returns:
        float: Température en degrés Fahrenheit
    """
    temp_fahrenheit = (temp_celsius * (9/5)) + 32
    return temp_fahrenheit

def afficher_bonjour(prenom: str) -> None:
    """
    Affiche un message de salutation personnalisé.

    Args:
        prenom (str): Le prénom de la personne à saluer

    Returns:
        None: Cette fonction n'a pas de valeur de retour
    """
    print('Bonjour, ' + prenom)

# Utilisation des fonctions
print(celsius_vers_fahrenheit(19))  # Affiche: 66.2
print(celsius_vers_fahrenheit(25))  # Affiche: 77.0
afficher_bonjour('Eudes')           # Affiche: Bonjour, Eudes
afficher_bonjour('Germaine')        # Affiche: Bonjour, Germaine

🔍 Anatomie d'une Fonction

🏷️

Mot-clé def

Indique le début de la définition d'une fonction

📛

Nom de fonction

Identifiant unique pour appeler la fonction (ex: celsius_vers_fahrenheit)

📥

Paramètres

Variables d'entrée avec leur type (ex: temp_celsius: int)

📝

Documentation

Bloc de texte expliquant le rôle, les paramètres et le retour

⚙️

Corps de fonction

Instructions à exécuter quand la fonction est appelée

📤

Valeur de retour

Résultat renvoyé par return (optionnel)

⚠️ Attention : Une fonction sans return renvoie None par défaut.
Exemple : print(afficher_bonjour('Eudes')) affichera None

🌍 Variables Locales et Globales

📍 Portée des Variables

En Python, la portée d'une variable détermine où elle peut être utilisée dans le programme.

🏠

Variable Locale

Définie à l'intérieur d'une fonction. Accessible uniquement dans cette fonction.

🌐

Variable Globale

Définie en dehors de toute fonction. Accessible partout dans le programme.

🏠 Exemple : Variable Locale

def ma_fonction():
    variable_locale = 10  # Variable locale
    print(variable_locale)

ma_fonction()              # Affiche 10 ✅
# print(variable_locale)   # ❌ Erreur ! Variable non accessible ici

🌐 Exemple : Variable Globale

variable_globale = 20  # Variable globale

def ma_fonction():
    print(variable_globale)  # Accès à la variable globale ✅

ma_fonction()                # Affiche 20
print(variable_globale)      # Affiche 20

🔧 Modification d'une Variable Globale :
Utilisez le mot-clé global pour modifier une variable globale dans une fonction

🔧 Modification avec global

compteur = 0  # Variable globale

def incrementer():
    global compteur  # Déclaration nécessaire pour modification
    compteur += 1

print(compteur)    # Affiche 0
incrémenter()
print(compteur)    # Affiche 1

💡 Bonnes Pratiques

📝

Documentation

Utilisez des docstrings pour expliquer le rôle, les paramètres et le retour de vos fonctions.

🏷️

Noms Explicites

Choisissez des noms de fonctions qui décrivent clairement leur action.

🎯

Spécialisation

Créez des fonctions courtes qui accomplissent une seule tâche efficacement.

📝 Documentation avec Docstrings

def calculer_aire_rectangle(longueur: float, largeur: float) -> float:
    """
    Calcule l'aire d'un rectangle.

    Args:
        longueur (float): La longueur du rectangle
        largeur (float): La largeur du rectangle

    Returns:
        float: L'aire du rectangle
    """
    return longueur * largeur

🏷️ Noms de Fonctions Explicites

# ✅ Bon : nom explicite
def calculer_moyenne(notes):
    return sum(notes) / len(notes)

# ❌ Moins bon : nom peu clair
def calc(n):
    return sum(n) / len(n)

🎯 Fonctions Spécialisées

def est_pair(nombre):
    """Vérifie si un nombre est pair."""
    return nombre % 2 == 0

def filtrer_nombres_pairs(liste_nombres):
    """Filtre les nombres pairs d'une liste."""
    return [n for n in liste_nombres if est_pair(n)]

🚀 Conseil : Une fonction bien écrite est facile à comprendre, tester et réutiliser !