Fonctions

Fonctions#

Introduction#

En programmation, une fonction est un bloc de code (suite d'instructions) permettant de réaliser une tâche donnée et auquel nous donnons un nom.

Nous avons déjà rencontrées plusieurs fonctions dans les chapitres précédents:

  • print(...): affiche sur la console ce qui est indiqué entre parenthèse

    print("Hello world")

  • input(...): demande à l'utilisateur d'entrer une donnée

    prenom = input("Quel est ton prénom?")

  • int(...): convertit ce qui est entre parenthèse en nombre entier

    age = int(input("Quel est ton âge?"))

  • float(...): convertit ce qui est entre parenthèse en nombre à virgule

    prix = float(input("Quel est le prix de l'article?"))

  • range(...): renvoie une liste de nombres (de 0 à la valeur entre parenthèse - 1)

    for _ in range(3):
  print("Bonjour!")

Toutes les fonctions ci-dessus sont des fonctions intégrées, elles ont été prédéfinies pour nous. Nous pouvons les utilisez sans nous soucier de la manière dont elles ont été implémentées.

Modules#

Un module est comme une boite à outils. Il contient plein de fonctions déjà implémentées que nous pouvons utiliser. Par exemple, dans le module math, il y a la fonction sqrt(n) qui permet de calculer la racine carré du nombre n, ainsi que la constante π notée pi. Dans le module random, la fonction randint(a, b) permet de déterminer un nombre aléatoire entre a et b (inclus).

Avant de pouvoir utiliser une fonction d'un module, il faut l'importer ainsi:

from nom_du_module import nom_de_la_fonction

On peut également directement importer toutes les fonctions d'un module en utilisant le joker:

from nom_du_module import *

Astuce

Toutes les importations se font au début du programme. De cette manière, on sait tout de suite quels sont les modules utilisés dans celui-ci.

Exemple 1#

1# import des modules
2from math import sqrt, pi		# import de la fonction sqrt et de la constante pi du module math
3from random import randint		# import de la fonction randint du module random
4
5n = randint(1, 20)     # choisit un nombre aléatoire entre 1 et 20
6print(n)
7print(sqrt(40))        # calcule et affiche la racine carrée de 40
8print(pi)              # affiche la valeur de la constante pi

Exemple 2#

1# import des modules avec le jocker
2from math import *		# import de toutes les fonctions du module math
3from random import *	# import de toutes les fonctions du module random
4
5n = randint(1, 20)     # choisit un nombre aléatoire entre 1 et 20
6print(n)
7print(sqrt(40))        # calcule et affiche la racine carrée de 40
8print(pi)              # affiche la valeur de la constante pi

Définition et appel de fonctions#

Comme vu dans l'introduction aux fonctions, il est possible de définir nos propres fonctions au moyen du mot clé def, suivi du nom de la fonction et d'un bloc d'instructions.

Définir une nouvelle fonction permet notamment d'éviter les répétitions et de découper un programme en plusieurs petites tâches plus faciles à résoudre. Ainsi le code est plus lisible et plus facile à comprendre. Pour cela, il est essentiel de choisir un nom de fonction qui explique ce qu'elle fait.

Exemple 3#

1# définition de la fonction
2def calcule_et_affiche_aire_rectangle():
3  cote_1 = 4
4  cote_2 = 6
5  aire = cote_1 * cote_2
6  print(aire)
7
8# appel de la fonction
9calcule_et_affiche_aire_rectangle()

Cette fonction n'est pas très intéressante, car elle affiche toujours l'aire d'un rectangle de côtés 4 et 6. Si je souhaite calculer l'aire d'un autre rectangle, je dois définir une nouvelle fonction, ce qui n'est pas optimal.

Afin de modifier le comportement d'une fonction, nous pouvons utiliser des paramètres (noms donnés aux éléments notés entre parenthèses dans la définition de la fonction). Dans ce cours, l'appel de fonction se fera toujours avec le même nombre d'arguments (valeurs des paramètres) et le même ordre que les paramètres définis dans la fonction.

Exemple 4#

 1# définition de la fonction
 2def calcule_et_affiche_aire_rectangle(cote_1, cote_2):
 3  aire = cote_1 * cote_2
 4  print(aire)
 5
 6# appels de la fonction au moyen de valeurs numériques
 7calcule_et_affiche_aire_rectangle(10, 8)
 8calcule_et_affiche_aire_rectangle(2, 5.5)
 9
10largeur = 5
11longueur = 12
12
13# appel de la fonction au moyen des variables largeur et longueur
14calcule_et_affiche_aire_rectangle(largeur, longueur)

De manière générale, la syntaxe de définition et d'appel de fonction est la suivante:

# définition de la fonction
def nom_de_la_fonction(parametre_1, parametre_2, ...):
  # instruction 1
  # instruction 2
  # ...

# appel de la fonction
nom_de_la_fonction(valeur_du_parametre_1, valeur_du_parametre_2, ...)

Important

Les instructions exécutées par la fonction appartiennent à un même bloc d'instruction et doivent avoir la même indentation.

Important

L'ordre des paramètres lors de l'appel de la fonction doit être le même que lors de la définition de la fonction.

Astuce

Une fonction doit toujours être définie avant d'être appelée, c'est pourquoi il est préférable de placer toutes les définitions de fonctions au début du programme juste après les imports.

Exercices#

Exercice 1#

  1. Définissez une fonction calcule_et_affiche_perimetre_carre().

  2. Combien de paramètres sont nécessaires?

  3. Affichez le périmetre d'un carré de côté 7, d'un carré de côté 12, ainsi qu'en utilisant la variable base.

1# définition de la fonction
2# complétez le code ici
3
4base = 10
5
6# appels de la fonction
7# complétez le code ici

Solution

# définition de la fonction
def calcule_et_affiche_perimetre_carre(cote):
  perimetre = 4 * cote
  print(perimetre)

base = float(input("Côté: "))

# appels de la fonction
calcule_et_affiche_perimetre_carre(7)
calcule_et_affiche_perimetre_carre(12)
calcule_et_affiche_perimetre_carre(base)

Exercice 2#

Sans les exécuter, déterminez ce que vont afficher les programmes suivants.
Font-ils ce qui est demandé?
S'il y a une erreur, expliquez et corrigez le problème.

  1. Calculez l'aire d'un rectangle de côtés 20 et 100.

    1def calcule_et_affiche_aire_rectangle(largeur, longueur):
2  aire = largeur * longueur
3  print(aire)
4
5calcule_et_affiche_aire_rectangle(20, 100)

  2. Calculez l'aire d'un rectangle de côtés 40 et 15.

    1def calcule_et_affiche_aire_rectangle(largeur, longueur):
2  aire = largeur * longueur
3  print(aire)
4
5largeur = 40
6longueur = 15
7
8calcule_et_affiche_aire_rectangle(largeur, longueur)

  3. Calculez l'aire d'un rectangle de côtés 12 et 18.

    1def calcule_et_affiche_aire_rectangle(largeur, longueur):
2  aire = largeur * longueur
3  print(aire)
4
5base = 12
6hauteur = 18
7
8calcule_et_affiche_aire_rectangle(largeur, longueur)

  4. Calculez le prix d'un article qui coûte 35 CHF avec un rabais de 10%.

    1def calcule_et_affiche_pourcentage(prix, pourcentage):
2  prix = (1 - pourcentage / 100) * prix
3  print(prix)
4
5calcule_et_affiche_pourcentage(35, 10)

  5. Calculez le prix d'un article qui coûte 52 CHF avec un rabais de 15%.

    1def calcule_et_affiche_pourcentage(prix, pourcentage):
2  prix = (1 - pourcentage / 100) * prix
3  print(prix)
4
5calcule_et_affiche_pourcentage(15, 52)

  6. Calculez l'aire d'un carré de côté 9.

    1def calcule_et_affiche_aire_carre(cote):
2  aire = cote ** 2
3  print(aire)
4
5cote = 9
6calcule_et_affiche_aire_carre()

  7. Calculez l'aire d'un disque de rayon 4.

    1def calcule_et_affiche_aire_disque(rayon):
2  aire = rayon ** 2 * pi
3  print(aire)
4
5calcule_et_affiche_aire_disque(4)

Solution

  1. Correct.

  2. Correct.

  3. Pas correct. Les variables largeur et longueur ne sont pas définies dans le programme. Il faut modifier la ligne 8 par:

    calcule_et_affiche_aire_rectangle(base, hauteur)

  4. Correct.

  5. Pas correct. Attention dans ce cas, l'ordre des paramètres a de l'importance. Il faut modifier la ligne 5 par:

    calcule_et_affiche_pourcentage(52, 15)

  6. Pas correct. La fonction calcule_et_affiche_aire_carre(cote) a un paramètre. Lorsqu'on l'appelle, il est obligatoire de passer un argument. Il faut modifier la ligne 6 par:

    calcule_et_affiche_aire_carre(cote)

  7. Pas correct. Il manque l'import de pi du module math. Il faut ajouter la ligne suivant au tout début de programme:

    from math import pi

Exercice 3#

Complétez les programmes suivants uniquement où il y a des ...:

  1. Calculez le périmètre d'un rectangle de côtés 4 et 7.

    1def calcule_et_affiche_perimetre_rectangle(..., ...):
2  perimetre = 2 * (longueur + largeur)
3  print(perimetre)
4
5... = 4
6... = 7
7calcule_et_affiche_perimetre_rectangle(cote_1, cote_2)

  2. Calculez le périmètre d'un carré de côté 11.

    1def calcule_et_affiche_perimetre_carre(cote):
2  perimetre = 4 * ...
3  print(perimetre)
4
5calcule_et_affiche_perimetre_carre(11)

  3. Calculez le périmètre d'un cercle de rayon 5.

    1from math import *
2
3def calcule_et_affiche_perimetre_cercle(...):
4  perimetre = 2 * r * pi
5  print(perimetre)
6
7rayon = 5
8calcule_et_affiche_perimetre_cercle(...)

Exercice 4#

Sans l'exécuter, déterminez ce que va afficher le programme suivant. Ensuite, exécutez-le pour vérifier votre réponse.

def mystery_1(z):
  z += 1
  print(z)

def mystery_2(x):
  x *= 2
  if x >= 0:
    mystery_1(x + 2)
  else:
    mystery_1(x)

y = 5
mystery_1(y)
mystery_2(y)
mystery_2(y - 10)
print(y)

Fonctions avec valeur de retour#

La commande return sert à terminer l’exécution de la fonction et à transmettre un (ou plusieurs) résultat(s). Cette commande return n'est pas obligatoire à la fin de la fonction si il n'y a aucune valeur à retourner, mais il est recommandé de la mettre pour plus de clarté.

Exemple 5#

 1from math import pi
 2 
 3# calcul l'aire d'un cercle
 4def aire_cercle(rayon):
 5    aire=pi*rayon**2
 6    return aire
 7
 8print("aire d'un cercle de rayon 1: ", aire_cercle(1))
 9print("aire d'un cercle de rayon 3: ", aire_cercle(3))
10print("aire d'un cercle de rayon 10: ", aire_cercle(10))

Exemple 6#

 1# définition des fonctions
 2def discriminant(a, b, c):
 3  return(b ** 2 - 4 * a * c)
 4
 5# programme principal
 6
 7# affiche le nombre de solution
 8delta = discriminant(1, 2, 1)
 9if delta > 0:
10  print("L'équation a deux solutions.")
11elif delta == 0:
12  print("L'équation a une solution.")
13else:
14  print("L'équation n'a pas de solution.")

Améliorations possibles de l'exemple:

  1. Demandez les valeurs des coefficients a, b et c à l'utilisateur.

  2. Affichez les solutions quand elles existent.

Important

return interrompt la fonction. Tout ce qui se trouve dans la fonction, mais après le return sera ignoré.

1def double(x):
2  return 2*x
3  print("Ce texte ne s'affichera pas.")
4
5print(double(5))
6print("Fin du programme")

Exercices#

Exercice 5#

Les cinq programmes ci-dessous sont similaires, mais les résultats sont à chaque fois différentse ressemblent. déterminez ce que va afficher chaque programme, prédisez ce qui s'affiche à l'écran, puis vérifiez en réfléchissant à ce que fait vraiment chaque appel de fonction. Si le programme n'affiche rien, écrivez rien.

  1. def double(nombre):
    return nombre
    nombre * 2

print(double(5))

  2. def double(nombre):
    nombre = nombre * 2
    return nombre

double(5)

  3. def double(nombre):
    return nombre * 2

resultat = double(5)
print(resultat)

  4. def double(nombre):
    return nombre * 2

print(double(5) + double(10))

Solution

  1. 5 La valeur retournée est le nombre reçu (5). La multiplication est effectuée seulement après la commande return et ne sera donc jamais exécutée.

  2. rien il n'a pas de print, la valeur retournée n'est ainsi pas utilisée

  3. 10. Cette fois l'appel est capté dans la variable resultat, que le print affiche ensuite.

  4. 30. Un appel qui retourne une valeur peut s'utiliser directement dans un calcul : double(5) vaut 10, double(10) vaut 20, et c'est leur somme qui est affichée.

Exercice 6#

Déterminez ce que font les programmes suivants et corrigez les erreurs.

  1. 1def convertit_min_sec(min):
2  return min * 60
3
4convertit_min_sec(145)
5print("145 minutes donnent", nb_secondes, "secondes.")

  2. 1def convertit_sec_min(sec):
2  min = sec / 60
3
4nb_minutes = convertit_sec_min(38700)
5print("38700 secondes donnent", nb_minutes, "minutes.")

  3. 1def calcule_double_moins_trois(x):
2  x = 2 * x
3  return x
4  x = x - 3
5
6print(calcule_double_moins_trois(4))

Solution

  1. Il faut sauvegarder la valeur de retour dans la variable nb_secondes

    1def convertit_min_sec(min):
2  return min * 60
3
4nb_secondes = convertit_min_sec(145)
5print("145 minutes donnent", nb_secondes, "secondes.")

  2. Il manque le return dans la fonction. Dans ce cas, la valeur retournée est None.

    1def convertit_sec_min(sec):
2  return sec / 60
3
4nb_minutes = convertit_sec_min(38700)
5print("38700 secondes donnent", nb_minutes, "minutes.")

  3. Le return n'est pas à la bonne place.

    1def calcule_double_moins_trois(x):
2  x = 2 * x
3  x = x - 3
4  return x
5
6print(calcule_double_moins_trois(4))

Exercice 7#

Sans l'exécuter, déterminez ce que va afficher le programme suivant. Ensuite, exécutez-le pour vérifier votre réponse.

 1def mystery_1(z):
 2  z *= 2
 3  return z
 4
 5def mystery_2(x):
 6  x -= 7
 7  if x < 0:
 8    return x
 9  else:
10    return x % 2
11
12y = 5
13print(mystery_1(y))
14print(mystery_2(y))
15print(mystery_2(2 * y))
16print(y // 2)

Exercice 8#

Complétez le programme ci-dessous. Nous avons défini une fonction majeur pour tester si une personne est majeure ou pas.

 1def majeur(age):
 2  if ... :
 3    return True
 4  else:
 5    return False
 6
 7# Demandez son âge à l'utilisateur
 8age = ...
 9
10if majeur(age):
11  print("Tu as le droit de vote")
12else:
13  print("Tu pourras voter dans", ..., "ans.")

Solution

def majeur(age):
  if age >= 18 :
    return True
  else:
    return False

# Demandez son âge à l'utilisateur
age = int(input("Quel âge as-tu?"))

if majeur(age):
  print("Tu as le droit de vote")
else:
  print("Tu pourras voter dans", 18 - age, "ans.")

Exercice 9#

  1. Écrivez une fonction qui convertit un nombre de bits en octets.

  2. Écrivez une fonction qui convertit un nombre d'octets en bits.

  3. Convertissez 3664000 bits en octets.

  4. Convertissez 512 octets en bits.

Astuce

Un octet contient 8 bits.

1# Écrire le programme ici

Solution

 1# Convertit des bits en octets
 2def conversion_bits_octets(a):
 3  return a / 8
 4
 5# Convertit des bits en octets
 6def conversion_octets_bits(a):
 7  return a * 8
 8
 9nb_octets = conversion_bits_octets(3664000)
10print("La conversion de 3664000 bits en octets donne", nb_octets)
11
12nb_bits = conversion_octets_bits(512)
13print("La conversion de 512 octets en bits donne", nb_bits)

Exercice 10#

Reprenez les claculs de conversion Celsius et Fahrenheit que l'on a fait dans le chapitre Entrées et sorties afin de définir une fonction Conversion_Celsius_Fahrenheit() et une fonction Conversion_Fahrenheit_Celsius(). Faites un petit programme de test qui répète 10 fois l'opération suivante:

  1. Génère une température aléatoire c en Celsius: utilisez la fonction randint() vue en haut de la page

  2. Convertit cette température en Fahrenheit

  3. Convertit cette température à nouveau en Celsius

  4. Affiche un message d'erreur si le résultat de la double conversion n'est pas égal à la température aléatoire c originale

1from random import randint		# import de la fonction randint du module random
2# Complétez le programme

Solution

 1from random import randint	# import de la fonction randint du module random
 2
 3# conversion °C->°F
 4def Conversion_Celsius_Fahrenheit(c):
 5   return c*9/5 +32
 6
 7# conversion °F->°C
 8def Conversion_Fahrenheit_Celsius(f):
 9   return (f - 32) / 1.8
10   
11# test: si on convertit °C->°F->°C on doit retomber sur la valeur initiale
12nb_tests = 10
13nb_succes = 0
14for i in range(nb_tests):
15   c = randint(-40, 50)
16   f = Conversion_Fahrenheit_Celsius(c)
17   c2 = Conversion_Celsius_Fahrenheit(f)
18   print(c, f, c2)
19   if abs(c-c2)< 0.001:
20     nb_succes += 1
21print()
22if nb_tests == nb_succes :
23    print("Le test est réussi!")
24else:
25    print("Le test est raté!")

Exercice 11#

On veut déterminer si un nombre est premier. Pour ceci, nous allons créer 3 fonctions:

  1. Ecrivez une fonction est_diviseur() qui permet de déterminer si un nombre est diviseur d'un autre nombre

    1def est_diviseur(nombre, diviseur):
2# à compléter
3
4
5# test de la fonction
6n = int(input("nombre: "))
7d = int(input("diviseur: "))
8print(n , "et", d, ": ", est_diviseur(n, d))

  2. Une fois que vous avez bien testé votre fonction est_diviseur() avec plusieurs paires de nombres, utilisez-la pour définir une nouvelle fonction plus_petit_diviseur() qui reçoit un nombre et retourne son plus petit diviseur (qui est plus grand ou égal à 2).

    1def plus_petit_diviseur(...)
2# à compléter
3
4# test de la fonction

  3. Une fois que vous avez bien testé votre fonction plus_petit_diviseur() avec plusieurs nombres, utilisez-la pour définir une nouvelle fonction est_premier() qui reçoit un nombre et retourne True si son plus petit diviseur est égal à lui-même.

    1# Écrivez votre programme ici

  4. Complétez votre programme en demandant à l'utilisteur un nombre, en vérifiant que le nombre entré est bien un nombre positif et en affichant si ce nombre est premier ou pas.

  5. Testez votre fonction avec différents nombre premiers et non-premiers.

Solution

 1def est_diviseur(nombre, diviseur):
 2  if nombre % diviseur == 0:
 3    return True
 4  else:
 5    return False
 6
 7def plus_petit_diviseur(nombre):
 8  for i in range(2, nombre+1):
 9    if est_diviseur(nombre, i):
10      return i 
11
12def est_premier(nombre):
13  if plus_petit_diviseur(nombre) == nombre:
14    return True
15  else:
16    return False
17
18nombre = int(input("Choisir un nombre entier strictement positif:"))
19while nombre <= 0:
20  nombre = int(input("Le nombre doit être strictement positif!"
21        "Choisir un nombre entier strictement positif:"))
22
23if est_premier(nombre):
24  print(nombre, "est un nombre premier.")
25else:
26  print(nombre, "n'est pas un nombre premier.")