07 - Fonctions (2)

Les exercices se font dans Thonny, dans le fichier 07_fonctions_2.py.

Cours associé : 08 - Fonctions .

Exercice 0 : QCM – vérification des prérequis

Pour chaque question, une seule réponse est correcte.

1. Quelle est la différence entre print et return dans une fonction ?

• A. print renvoie une valeur, return l’affiche
• B. print affiche une valeur à l’écran, return renvoie une valeur à l’appelant
• C. print et return font exactement la même chose
• D. return n’est utilisable que dans le programme principal

2. Que vaut x après l’exécution du code suivant ?

def double(n):
    return n * 2

x = double(5) + 1

• A. 10
• B. 11
• C. None
• D. Une erreur

3. Quelle annotation de type correspond à une fonction qui prend un entier et renvoie un booléen ?

• A. def f(n: bool) -> int:
• B. def f(n: int) -> bool:
• C. def f(n: int) -> str:
• D. def f(n) -> int:

4. Que se passe-t-il si une fonction ne contient pas de return ?

• A. Python lève une erreur SyntaxError
• B. La fonction renvoie 0
• C. La fonction renvoie None
• D. La fonction ne peut pas être appelée

Exemple travaillé : construire une fonction avec return

Problème : écrire une fonction qui détermine si un nombre est divisible par un autre, puis l’utiliser dans un programme.

Étape 1. Prototype (signature, annotations de type et documentation) :

def est_divisible(a: int, b: int) -> bool:
    """Détermine si a est divisible par b.

    Paramètres :
        a (int) : le nombre à tester
        b (int) : le diviseur (> 0)

    Retour :
        bool : True si a est divisible par b, False sinon
    """

Étape 2. Corps de la fonction :

    return a % b == 0

La comparaison a % b == 0 renvoie directement un booléen. Il est inutile d’écrire if a % b == 0: return True else: return False.

Étape 3. Tests avec assert :

assert est_divisible(12, 3) == True   # 12 = 3 × 4
assert est_divisible(12, 5) == False  # 12 = 5 × 2 + 2
assert est_divisible(0, 7) == True    # 0 est divisible par tout entier
print("Tous les tests passent.")

Étape 4. Utilisation dans un programme :

n = int(input("Entrer un nombre : "))
if est_divisible(n, 2):
    print(f"{n} est pair")
else:
    print(f"{n} est impair")

Points clés :

• return renvoie une valeur réutilisable : on peut l’affecter à une variable ou la tester dans un if.
• print se contente d’afficher : si on remplaçait return par print, est_divisible(12, 3) vaudrait None.
• Les annotations de type (int, bool) et la docstring documentent le contrat de la fonction.

Exercice 1 – Paquets et poids

1. Écrire une fonction poids_total(n, poids) qui prend en paramètres deux entiers : un nombre de paquets et le poids d’un paquet (tous les paquets ont le même poids). Si le poids total est strictement inférieur à 105 kg, la fonction doit renvoyer True, sinon elle doit renvoyer False.

   def poids_total(n : int, poids : int) -> bool:
       """Fonction qui détermine si le poids total est strictement inférieur à 105 kg.
   
       Paramètres
       ----------
           n (int)
           poids (int)
   
       Sortie
       ------
           True (bool) ou False (bool)
       """
       pass
   

   Indice

   Calculer le poids total n * poids : sa comparaison avec 105 vaut déjà True ou False, comme dans l’exemple travaillé.

2. Écrire le programme principal qui doit reproduire cette situation : on veut faire un premier envoi de 10 paquets de 13 kg chacun, puis un second envoi de 12 paquets de 5 kg chacun. Pour chaque envoi, le programme doit appeler la fonction et :

   • si elle renvoie True il affiche : "envoi Ok" ;
   • sinon il affiche : "envoi impossible".
   Indice

   Appeler poids_total dans la condition d’un if, une fois pour chaque envoi.

def poids_total(n: int, poids: int) -> bool:
    """Détermine si le poids total est strictement inférieur à 105 kg."""
    return n * poids < 105

# Premier envoi : 10 paquets de 13 kg = 130 kg > 105
if poids_total(10, 13):
    print("envoi Ok")
else:
    print("envoi impossible")

# Second envoi : 12 paquets de 5 kg = 60 kg < 105
if poids_total(12, 5):
    print("envoi Ok")
else:
    print("envoi impossible")

Exercice 2 – Température

Écrire une fonction stat_temp() qui recueille au clavier les températures de 10 jours successifs, puis affiche les températures minimale, maximale et moyenne.

def stat_temp():
    """Fonction qui :
          1. lit (avec input) les températures sur 10 jours ;
          2. calcule le minimum, le maximum et la moyenne ;
          3. affiche ces trois valeurs.

    Paramètres
    ----------
        Aucun

    Sortie
    ------
        Aucune : la fonction affiche ses résultats.
    """
    # compléter ici

def stat_temp():
    t = float(input("Température du jour 1 : "))
    tmin = t
    tmax = t
    somme = t
    for jour in range(2, 11):
        t = float(input(f"Température du jour {jour} : "))
        if t < tmin:
            tmin = t
        if ...:
            ...
        somme = ...
    tmoy = ...
    print(f"Min : {tmin}, Max : {tmax}, Moyenne : {round(tmoy, 1)}")

def stat_temp():
    """Lit 10 températures, puis affiche le minimum, le maximum et la moyenne."""
    t = float(input("Température du jour 1 : "))
    tmin = t
    tmax = t
    somme = t

    for jour in range(2, 11):
        t = float(input(f"Température du jour {jour} : "))
        if t < tmin:
            tmin = t
        if t > tmax:
            tmax = t
        somme += t

    tmoy = somme / 10
    print(f"Min : {tmin}, Max : {tmax}, Moyenne : {round(tmoy, 1)}")

# Appel
stat_temp()

Exercice 3 – Produit des entiers successifs

Écrire une fonction produit(n) qui prend un nombre n en paramètre et qui renvoie le produit des entiers successifs de 1 jusqu’à n.

Exemples :

• print(produit(3)) doit afficher 6 (qui est le résultat de \(1\times2\times3\)) ;
• print(produit(5)) doit écrire 120 (qui est le résultat de \(1\times2\times3\times4\times5\)).

def produit(n: int) -> int:
    """
    Documentation
    """
    pass

def produit(n: int) -> int:
    """Renvoie le produit des entiers de 1 à n (factorielle de n).

    >>> produit(3)
    6
    >>> produit(5)
    120
    >>> produit(1)
    1
    """
    resultat = 1
    for i in range(1, n + 1):
        resultat = resultat * i
    return resultat

Exercice 4 – Moyenne

Écrire une fonction qui calcule la moyenne d’un certain nombre de notes entrées par l’utilisateur. Cette fonction prendra comme paramètre un nombre n, qui correspond au nombre de notes qui seront demandées à l’utilisateur. En sortie, elle renverra la moyenne des différentes notes.

Pour tester :

• moyenne(5) en entrant 4 5 6 7 et 8 devra renvoyer 6 ;
• moyenne(3) en entrant 4 5 et 6 devra renvoyer 5.

def moyenne(n: int ) -> float:
    """
    Documentation
    """
    pass

def moyenne(n: int) -> float:
    """Lit n notes au clavier et renvoie leur moyenne.

    Paramètre : n (int), nombre de notes à saisir
    Sortie : (float), la moyenne des n notes
    """
    somme = 0
    for i in range(n):
        note = float(input(f"Note {i + 1} : "))
        somme += note
    return somme / n

Exercice 5 – Années bissextiles

Les années bissextiles sont les années divisibles par 4, à l’exception de celles qui sont divisibles par 100 sans l’être par 400.

Par exemple :

• 2000 est une année bissextile (le nombre 2000 est divisible par 4, par 100 mais aussi par 400 : il ne fait donc pas partie des exceptions).
• 2012 est divisible par 4 mais pas par 100 : 2012 est bissextile.
• 1900 est divisible par 4, par 100 mais pas par 400 : 1900 n’est pas bissextile.

Définissez une fonction dont le paramètre est un entier naturel non nul (l’année) puis qui renvoie True lorsque l’année est bissextile et False dans le cas contraire.

def bissextile(annee):
    """Fonction qui détermine si une année donnée est bissextile.

    Paramètres
    ----------
        annee (int) : entier strictement positif

    Sortie
    ------
        True (bool) si annee est bissextile, False (bool) sinon
    """
    pass

def bissextile(annee):
    if annee % 400 == 0:
        return True
    elif ...:
        return False
    elif ...:
        ...
    else:
        ...

def bissextile(annee: int) -> bool:
    """Détermine si une année est bissextile.

    >>> bissextile(2000)
    True
    >>> bissextile(2012)
    True
    >>> bissextile(1900)
    False
    >>> bissextile(2023)
    False
    """
    if annee % 400 == 0:
        return True
    elif annee % 100 == 0:
        return False
    elif annee % 4 == 0:
        return True
    else:
        return False

def bissextile(annee: int) -> bool:
    return (annee % 4 == 0 and annee % 100 != 0) or (annee % 400 == 0)

Exercice 6 – Suite de Fibonacci

On appelle nombres de Fibonacci les nombres obtenus par somme des deux précédents.

Les deux premiers nombres de Fibonacci sont \(F_0=1\) et \(F_1=1\).

On a ensuite \(F_2=2\), \(F_3=3\), \(F_4=5\), \(F_5=8\), \(F_6=13\), etc.

Complétez le corps de la fonction fibo() suivante en respectant les spécifications décrites dans son prototype (docstring).

def fibo(n):
    """Fonction qui calcule le n-ième terme de la suite de Fibonacci.

    Paramètres
    ----------
        n (int) : nombre entier naturel.

    Sortie
    ------
        (int) : n-ième terme de la suite de Fibonacci.
    """
    pass

def fibo(n):
    if n == 0 or n == 1:
        return 1
    a, b = 1, 1
    for i in range(2, n + 1):
        a, b = ..., ...
    return b

def fibo(n: int) -> int:
    """Renvoie le n-ième terme de la suite de Fibonacci.

    >>> fibo(0)
    1
    >>> fibo(1)
    1
    >>> fibo(6)
    13
    >>> fibo(10)
    89
    """
    if n == 0 or n == 1:
        return 1

    a, b = 1, 1
    for i in range(2, n + 1):
        a, b = b, a + b
    return b

Exercice 7 – Nombres de Armstrong

Un nombre de Armstrong est un entier positif égal à la somme des cubes de ses chiffres.

Exemple : \(153 = 1^3 + 5^3 + 3^3 = 1 +125 +27 = 153\).

Écrire une fonction est_armstrong qui prend un nombre n en entrée. Cette fonction doit renvoyer True si ce nombre est un nombre de Armstrong et False sinon.

Pour tester :

• est_armstrong(153) doit renvoyer True ;
• est_armstrong(154) doit renvoyer False (car \(1^3 + 5^3 + 4^3 =1 + 125 + 64=190\) qui est différent de \(154\)).

Aide : il faut convertir le nombre n en chaîne de caractères pour pouvoir parcourir tous les chiffres du nombre un par un, puis reconvertir en entier pour calculer le cube de chacun d’entre eux.

def est_armstrong(n : int) -> bool:
    """Fonction qui détermine si un entier est un nombre de Armstrong ou non.

    Paramètres
    ----------
        n (int) : entier naturel

    Sortie
    ------
        True (bool) si n est un nombre de Armstrong, False (bool) sinon

    """
    pass

def est_armstrong(n: int) -> bool:
    """Détermine si n est un nombre de Armstrong.

    >>> est_armstrong(153)
    True
    >>> est_armstrong(154)
    False
    >>> est_armstrong(370)
    True
    >>> est_armstrong(1)
    True
    """
    chaine = str(n)
    somme = 0
    for caractere in chaine:
        chiffre = int(caractere)
        somme += chiffre ** 3
    return somme == n

Exercice 8 – Nombres de Armstrong (suite)

Écrire une fonction armstrong qui affiche les nombres de Armstrong inférieurs à un nombre n passé en paramètre.

Exemple : armstrong(2000) doit afficher les valeurs suivantes :

1
153
370
371
407

Aide : il est fortement conseillé de réutiliser la fonction est_armstrong(n) qui vérifie si un nombre n est un nombre de Armstrong.

def armstrong(n: int ) -> None:
    """
    Documentation
    """
    pass

def armstrong(n: int) -> None:
    """Affiche tous les nombres de Armstrong strictement inférieurs à n.

    >>> armstrong(500)
    1
    153
    370
    371
    407
    """
    for i in range(1, n):
        if est_armstrong(i):
            print(i)

Exercice 9 – ADN

Une molécule d’ADN est formée d’environ six milliards de nucléotides. L’ordinateur est donc un outil indispensable pour l’analyse de l’ADN. Dans un brin d’ADN il y a seulement quatre types de nucléotides qui sont notés A, C, T ou G. Une séquence d’ADN est donc un long mot de la forme : TAATTACAGACCTGAA...

Écrire une fonction presence_de_A(sequence) qui teste la présence du nucléotide A dans une séquence d’ADN.

Tests :

• presence_de_A("CTTGCT") doit renvoyer False ;
• presence_de_A("CTTACT") renvoie True.

def presence_de_A(sequence: str) -> bool:
    """
    Documentation
    """
    pass

def presence_de_A(sequence: str) -> bool:
    """Teste la présence du nucléotide A dans une séquence d'ADN.

    >>> presence_de_A("CTTGCT")
    False
    >>> presence_de_A("CTTACT")
    True
    >>> presence_de_A("")
    False
    >>> presence_de_A("AAAA")
    True
    """
    for nucleotide in sequence:
        if nucleotide == "A":
            return True
    return False

Exercice 10 – ADN 2 (difficile)

Écrire une fonction position_de_AT(sequence) qui teste si une séquence contient le nucléotide A suivi du nucléotide T et renvoie l’indice de la première occurrence trouvée.

Exemples :

• position_de_AT("CTTATGCT") renvoie 3 ;
• position_de_AT("GATATAT") renvoie 1 ;
• position_de_AT("GACCGTA") renvoie None

def position_de_AT(sequence: str):
    """
    Documentation
    """
    pass

def position_de_AT(sequence: str):
    for i in range(len(sequence) - 1):
        if ... and ...:
            return i
    return None

def position_de_AT(sequence: str):
    """Renvoie l'indice de la première occurrence de 'AT' dans la séquence.
    Renvoie None si 'AT' n'est pas trouvé.

    >>> position_de_AT("CTTATGCT")
    3
    >>> position_de_AT("GATATAT")
    1
    >>> position_de_AT("GACCGTA")
    """
    for i in range(len(sequence) - 1):
        if sequence[i] == "A" and sequence[i + 1] == "T":
            return i
    return None

Exercice 11 – ADN 3 (encore plus difficile)

Écrire une fonction position(code, sequence) qui teste si une séquence contient un code donné et renvoie l’indice de la première occurrence. Si la séquence n’est pas trouvée, la fonction doit renvoyer -1.

Exemples :

• position("CCG", "CTCCGTT") doit renvoyer 2 ;
• position("GT", "TACGTTA") doit renvoyer 3 ;
• position("GTTA", "TACGTTA") doit renvoyer 3 ;
• position("TAC", "TACGTTA") doit renvoyer 0 ;
• position("GAT", "TACGTTA") doit renvoyer -1

def position(code: str, sequence: str) -> int:
    """
    Documentation
    """
    pass

def position(code: str, sequence: str) -> int:
    n = len(sequence)
    m = len(code)
    for i in range(n - m + 1):
        trouve = True
        for j in range(m):
            if sequence[i + j] != ...:
                trouve = False
        if trouve:
            return ...
    return -1

def position(code: str, sequence: str) -> int:
    """Renvoie l'indice de la première occurrence de code dans sequence.
    Renvoie -1 si code n'est pas trouvé.

    >>> position("CCG", "CTCCGTT")
    2
    >>> position("GT", "TACGTTA")
    3
    >>> position("GTTA", "TACGTTA")
    3
    >>> position("TAC", "TACGTTA")
    0
    >>> position("GAT", "TACGTTA")
    -1
    """
    n = len(sequence)
    m = len(code)

    for i in range(n - m + 1):
        # Vérifier si code apparaît à la position i
        trouve = True
        for j in range(m):
            if sequence[i + j] != code[j]:
                trouve = False
                break
        if trouve:
            return i

    return -1