Ce chapitre explore les concepts fondamentaux des fonctions en Python, y compris leur définition, leur syntaxe de retour, la gestion de la valeur None, la documentation des fonctions, les appels imbriqués et la portée des variables.

Syntaxe de définition du retour de fonction

Les fonctions peuvent retourner une valeur calculée à l'aide de l'instruction return. La valeur retournée peut être capturée par une variable pour une utilisation ultérieure.

def additionner(a, b):
    resultat = a + b
    # Le code après 'return' ne sera pas exécuté
    return resultat
    print("Ceci ne sera pas affiché")

# Appel de la fonction et stockage du résultat
somme = additionner(5, 6)
print(f"Le résultat de l'addition est : {somme}")

La valeur de retour None

Une fonction qui n'a pas d'instruction return explicite retourne implicitement None. Il est également possible de retourner None explicitement.

Fonction sans instruction return explicite

def saluer():
    print("Bonjour !")

# Appel de la fonction et vérification de la valeur de retour
retour_saluer = saluer()
print(f"La valeur de retour d'une fonction sans return explicite est : {retour_saluer}")
print(f"Le type de retour est : {type(retour_saluer)}")

Fonction retournant None explicitmeent

def saluer_deux():
    print("Bonjour à vous !")
    return None

# Appel de la fonction et vérification de la valeur de retour
retour_saluer_deux = saluer_deux()
print(f"La valeur de retour d'une fonction retournant None est : {retour_saluer_deux}")
print(f"Le type de retour est : {type(retour_saluer_deux)}")

Utilisation de None dans les conditions

None est évalué comme False dans un contexte booléen. Cela est utile pour vérifier si une fonction a retourné une valeur valide.

def verifier_age(age):
    if age > 18:
        return "Accès autorisé"
    else:
        return None

resultat_age = verifier_age(16)
if not resultat_age:
    # Si resultat_age est None (False), ce bloc est exécuté
    print("Accès refusé : vous êtes mineur.")

Utilisation de None pour déclarer des variables

None peut être utilisé pour initialiser une variable dont la valeur sera assignée ultérieurement.

nom = None
# ... plus tard dans le code ...
# nom = "Alice"

Documentation des fonctions (Docstrings)

Les docstrings (chaînes de documentation) sont utilisées pour epxliquer ce que fait une fonction. Elles sont placées juste après la définition de la fonction et peuvent être accessibles via l'attribut __doc__ de la fonction.

def additionner_avec_doc(x, y):
    """
    La fonction additionner_avec_doc prend deux arguments numériques et retourne leur somme.

    Args:
        x (int/float): Le premier nombre à additionner.
        y (int/float): Le second nombre à additionner.

    Returns:
        int/float: La somme de x et y.
    """
    resultat = x + y
    print(f"Le résultat de l'addition est : {resultat}")
    return resultat

# Accéder à la docstring
print(additionner_avec_doc.__doc__)
additionner_avec_doc(5, 6)

Appels de fonctions imbriqués

Il est possible d'appeler une fonction depuis l'intérieur d'une autre fonction.

def fonction_externe():
    print("Ceci est la fonction externe.")

    def fonction_interne():
        print("Ceci est la fonction interne.")

    fonction_interne() # Appel de la fonction interne depuis la fonction externe

fonction_externe()
print("Exécution après l'appel de la fonction externe.")

Portée des variables dans les fonctions

La portée d'une variable détermine où elle est accessible. Les variables définies à l'intérieur d'une fonction sont locales à cette fonction, tandis que celles définies à l'extérieur sont globales.

Portée locale

def exemple_portee_locale():
    variable_locale = 100
    print(f"Dans la fonction : {variable_locale}")

exemple_portee_locale()
# print(variable_locale) # Ceci générerait une erreur NameError car variable_locale est locale

Mot-clé global

Le mot-clé global permet de modifier une variable globale depuis l'intérieur d'une fonction.

variable_globale = 200

def fonction_a():
    print(f"Dans fonction_a (avant modif globale) : {variable_globale}")

def fonction_b():
    global variable_globale # Déclare que nous allons modifier la variable globale
    variable_globale = 500 # Modifie la variable globale
    print(f"Dans fonction_b (après modif globale) : {variable_globale}")

fonction_a()
fonction_b()
print(f"En dehors des fonctions : {variable_globale}") # Affiche 500 car la variable globale a été modifiée

Exemple d'application complet de fonctions

Voici un exemple simulant un système bancaire simple utilisant plusieurs fonctions pour gérer le solde, les dépôts et les retraits.

solde_compte = 5000000
nom_utilisateur = input("Veuillez entrer votre nom : ")

def afficher_solde(montrer_entete):
    """Affiche le solde actuel du compte."""
    if montrer_entete:
        print("---------- Consultation du solde ----------")
    print(f"{nom_utilisateur}, votre solde actuel est de {solde_compte} unités.")

def deposer_argent(montant_depot):
    """Ajoute un montant au solde du compte."""
    global solde_compte
    solde_compte += montant_depot
    print("---------- Dépôt effectué ----------")
    print(f"Vous avez déposé {montant_depot} unités avec succès.")
    afficher_solde(False)

def retirer_argent(montant_retrait):
    """Retire un montant du solde du compte."""
    global solde_compte
    if montant_retrait <= solde_compte:
        solde_compte -= montant_retrait
        print("--------- Retrait effectué ---------")
        print(f"{nom_utilisateur}, vous avez retiré {montant_retrait} unités avec succès.")
        afficher_solde(False)
    else:
        print("--------- Retrait impossible ---------")
        print("Solde insuffisant.")

def afficher_menu():
    """Affiche le menu principal et retourne le choix de l'utilisateur."""
    print("\n---------- Menu Principal ----------")
    print(f"{nom_utilisateur}, bienvenue à la banque ATM. Veuillez choisir une opération :")
    print("1. Consulter le solde")
    print("2. Déposer de l'argent")
    print("3. Retirer de l'argent")
    print("4. Quitter")
    return input("Entrez votre choix (1-4) : ")

# Boucle principale du programme
while True:
    choix = afficher_menu()

    if choix == '1':
        afficher_solde(True)
    elif choix == '2':
        try:
            depot = float(input("Entrez le montant à déposer : "))
            if depot > 0:
                deposer_argent(depot)
            else:
                print("Le montant du dépôt doit être positif.")
        except ValueError:
            print("Entrée invalide. Veuillez entrer un nombre.")
    elif choix == '3':
        try:
            retrait = float(input("Entrez le montant à retirer : "))
            if retrait > 0:
                retirer_argent(retrait)
            else:
                print("Le montant du retrait doit être positif.")
        except ValueError:
            print("Entrée invalide. Veuillez entrer un nombre.")
    elif choix == '4':
        print("Merci d'avoir utilisé nos services. Au revoir !")
        break
    else:
        print("Choix invalide. Veuillez sélectionner une option entre 1 et 4.")