Accueil » Leçon 3 - Les fonctions

Leçon 3 - Les fonctions

Objectifs de la leçon :

L'objectif de la leçon est de maîtriser la notion de fonction.

Les fonctions sont analogues à des sous-programmes. Elles représentent des blocs de code qui peuvent être appelés à partir du programme principal (ou à partir d'autres fonctions).

Plutôt que de faire défiler tout le code dans un seul flux d'instructions, on le découpe en blocs fonctionnels sur lesquels on se branche à un moment ou à un autre.

L'objectif est :

Pré-requis :

La leçon 1 : afficher, saisir, les variables, les calculs.

La leçon 2 : les structures conditionnelles.


Des exemples pour démarrer

Exemple : Prix total de N articles

Observez le code suivant :
Il contient une fonction nommée prixTotal qui attend 2 paramètres nommés prixUnitaire et quantite, qui les multiplie et qui retourne leur produit (nommé pTotal).
Bien que cette fonction soit écrite en tête de script, ce n'est pas elle qui sera lancée lorsque le script démarrera. La première instruction du script est :
pU = 15.50
C'est la troisième instruction du script qui utilise la fonction prixTotal :
pT = prixTotal (pU , N)
A ce niveau du script, on va se brancher sur la fonction prixTotal qui effectuera le produit de pU et N et retournera sa valeur. Cette valeur sera ensuite stockée dans la variable pT.

Remarquez bien ceci :
  • L'en-tête de fonction débute par le mot réservé def. Il est suivi du nom de la fonction et de la liste des paramètres qu'elle attend.
  • Le corps de la fonction est indenté par rapport à l'en-tête.
  • Le mot clé return retourne le résultat où la fonction a été appelée. Ici, la valeur de pTotal est retournée au programme principal et remplace l'appel prixTotal (pU , N). Ce qui permet ensuite de stocker ce résultat dans la variable pT.



Exemple : La famille Simpson

Observez bien l'affichage des membres de la famille Simpson.
Ce code vous montre des fonctions qui n'attendent pas de paramètres et qui ne retournent rien. Il vous montre aussi qu'une fonction (afficheFamilleSimpson) peut elle-même appeler d'autres fonctions (afficheParentsSimpsons et afficheEnfantsSimpsons).

Même quand une fonction n'attend pas de paramètre, son appel doit se faire avec des parenthèses vides :
print (\"Affichage parents\")
afficheParentsSimpsons()

Exemple : Affichage encadré

Ce code contient la fonction encadre. Elle attend la phrase à encadrer et la caractère d’encadrement. Elle affiche la phrase encadrée et ne retourne rien.
Par exemple, l'instruction :
encadre("J'aime Python","*")
affiche :
***************
*J'aime Python*
***************

L'ESSENTIEL AVEC DES EXEMPLES DE BASE

A la fin de cette leçon, vous devrez bien savoir :

  • Définir une fonction.
    • La spécifier : savoir ce qu'elle attend, ce qu'elle doit faire et ce qu'elle doit retourner.
    • La coder.
  • Appeler une fonction.
  • La documenter correctement.



Définir et utiliser une fonction

Exemple : Perimètre d'un rectangle, une fonction avec return.

Ce programme contient une fonction qui retourne le périmètre d'un rectangle et qui l'utilise dans le programme principal.

Remarquez bien ceci :
  • L'en-tête de fonction débute par le mot réservé def. Il est suivi du nom de la fonction et de la liste des paramètres qu'elle attend.
  • Le corps de la fonction est indenté par rapport à l'en-tête.
  • Le mot clé return retourne le résultat où la fonction a été appelée. Ici, la valeur du périmètre est retournée au programme principal et remplace l'appel perimetre (L,l). Ce qui permet ensuite de stocker ce résultat dans la variable per.
  • Bien que les premières lignes du script soient consacrées à la définition de la fonction, ce ne sont pas celles qui sont exécutées lors du lancement. Le script débute par l'instruction L = 50 du programme principal et ce n'est qu'au moment de l'appel perimetre (L,l) qu'on se branchera sur le code de la fonction perimetre.




Exemple : Dessine-moi un rectangle ! Une fonction sans return.

Ce programme contient une fonction qui dessine un rectangle :
  • Le premier paramètre est la longueur ;
  • le deuxième, la hauteur ;
  • le troisième le caractère de dessin.

Cette fonction affiche le rectangle mais ne retourne rien.

Remarquez ici que, puisque la fonction ne retourne rien, son appel est direct :
dessineRectangle(9,6,"*")
et non :
variable = dessineRectangle(9,6,"*")




Exemple : Générer un nombre aléatoire entre 0 et 100. Une fonction sans paramètre en entrée mais plusieurs return.

Ce programme contient une fonction qui génère un nombre aléatoire entre 0 et 100 et qui retourne l'entier :
  • 1, si le nombre généré est entre 0 et 24 ;
  • 2 s'il est entre 25 et 49 ;
  • 3 s'il est entre 50 et 74 ;
  • 4 s'il est entre 75 et 100.

Le programme principal récupère cet entier :

code = genereNombre ()
puis affiche le bon message selon les 4 cas de figure.
Faites tourner plusieurs fois le programme pour voir les différents résultats.

Bien que cette fonction présente plusieurs return, elle ne retourne qu'une valeur !
Dans le code d'une fonction, dès que le mot clé return est rencontré, la fonction est stoppée, et s'il reste du code après le mot-clé return, il n'est pas exécuté.




Exemple : Une fonction qui n'attend rien et ne retourne rien. Le menu d'un fast-food.

Ce programme se contente d'afficher le menu d'un fast-food
Remarquez dans le programme principal, l'appel direct et sans paramètre de la fonction menu :
menu()




Documenter une fonction

Pour rendre son code maintenable, réutilisable par d'autres et par soi-même, il est absolument indispensable de documenter les fonctions.

Après chaque en-tête de fonction il faut indiquer :

  • à quoi elle sert ;
  • les paramètres qu'elle attend ;
  • la valeur et le sens de ce qui est retourné.

Il est même très souvent utile d'indiquer un ou plusieurs exemples d'appels pour que le lecteur comprenne.

La PEP 0257 nous indique de baliser notre documentation en début de fonction en utilisant les triples guillemets comme ceci :

def MaFonction():
    """
    Je documente ici
    """
 

Un exemple :

def perimetre (longueur , largeur) :
   """
   Retourne le périmètre d'un rectangle
   Entrées :
      longueur : la longueur du rectangle
      largeur : la largeur du rectangle
   Sortie :
      le périmètre du rectangle calculé par la formule :
      longueur * 2 + largeur * 2
   Exemple d'appel :
      perim = perimetre (8,6)
   """

   perim = longueur * 2 + largeur * 2 # calcul du périmètre
   return perim # retour de la valeur du périmètre


Petit résumé :

Une fonction peut correspondre aux 4 schémas suivants :
  • Une ou plusieurs entrées, une sortie (perimetre)
  • Une ou plusieurs entrées, pas de sortie (dessineRectangle)
  • Pas d'entrée, une sortie (genereNombre)
  • Pas d'entrée, pas de sortie (menu)

Une fonction doit être documentée. La doc doit être entre triples guillemets.
Le mot-clé return interrompt l'exécution d'une fonction et retourne éventuellement une valeur à la fonction appelante.

Quelques exemples plus poussés

Comparaison de formules de cinéma :

Exemple : Places de cinéma
Un cinéphile a le choix entre 3 formules :
  • F1 : acheter les billets à l'unité. Prix de la place 9,50 €
  • F2 : acheter des cartes de 10 billets à 65 € la carte.
  • F3 : prendre un abonnement annuel pour un nombre de places illimité. Coût mensuel : 20,50 €.

Le programme suivant renseigne l'utilisateur en lui indiquant pour chaque formule ce que sera sa dépense annuelle pour un nombre de films allant de 10 à 50 en augmentant de 10 à chaque fois.
La fonction prixPlaceCinema affiche le prix pour un nombre de places donné pour les 3 formules.



Conversion Celsius/Fahrenheit :

Exemple : Convertisseur Celsius/Fahrenheit

Nous voulons un convertisseur Celsius/Fahrenheit qui fonctionne dans les deux sens. C'est à dire :
  • Si on lui passe une valeur en Celsius, il nous renvoie la valeur en Fahrenheit.
  • Si on lui passe une valeur en Fahrenheit, il nous renvoie la valeur en Celsius.
  • Si on ne lui précise pas l'unité, il nous dit qu'il ne peut pas convertir.

Nous allons utiliser la notion de "valeur par défaut" intégrée aux fonctions afin de gérer le dernier cas.

Notez bien le mécanisme de valeur par défaut :
def convertisseurCelsiusFarenheit(degres, unite = "NA"):
Le fait d'avoir affecté la valeur "NA" au paramètre unite permet au code de s'exécuter même si un seul paramètre est renseigné comme dans le troisième appel :
print("35° est égale à", convertisseurCelsiusFarenheit(35))
Si cette précaution n'avait pas été prise, cette instruction aurait provoqué un plantage alors qu'ici elle est gérée par un message d'erreur explicite.



Indiquer la nature d'un caractère dont le code ASCII est compris entre 0 et 255

Exemple : Nature d'un caractère

La fonction natureCar génère un nombre aléatoire carac compris entre 0 et 255 puis renvoie un code indiquant la nature du caractère de code ASCII carac :
  • 0 si ce n'est ni une lettre, ni un chiffre ;
  • 1 si c'est une voyelle minuscule ;
  • 2 si c'est une console minuscule ;
  • 3 si c'est une voyelle majuscule ;
  • 4 si c'est une console majuscule ;
  • 5 si c'est un chiffre.

Indication : vous aurez peut-être besoin de lire ceci.
Faites tourner de nombreuses fois le programme pour essayer d'obtenir les 6 cas de figure.

Les variables de cet exemple :
carac # le code ASCII du caractère aléatoire généré par la fonction
chr(carac) # le caractère lui-même
# par exemple, si carac = 67, chr(carac) = "C"
ord("A") # le code ASCII de "A", c'est 65.

Des pièges à éviter


Oublier d'indenter ou mal indenter :

Exemple : Mauvaise indentation

Comme la salade est mal indentée, elle est considérée comme étant le début du programme principal et non comme la fin de la fonction menu !



Croire qu'on retourne une variable alors qu'on retourne une valeur :

Exemple : Bug de retour

Le programme principal cherche à afficher aireRect mais cette variable n'est définie que pendant l'exécution de la fonction aireRectangle et elle est donc inconnue du programme principal, d'où le crash....

La notion sous-jacente ici est la portée des variables.
La variable aireRect est définie dans la fonction aireRectangle. Sa portée est donc réduite à la fonction aireRect. Ailleurs, elle est inconnue, elle est hors de portée.
On dit aussi que la variable aireRect est une variable locale à la fonction aireRectangle.




Se tromper dans l'ordre de passage des paramètres :

Exemple : Un taux de TVA négatif !

La fonction toTVA attend le prix hors taxes, puis le prix toutes taxes comprises pour calculer le taux de TVA.
Dans le programme principal, on fait l'appel en inversant les paramètres. Du coup, on se retrouve avec un taux de TVA de -25 % au lieu d'un taux de 33.3 %...



Croire qu'on est tenu de nommer les paramètres effectifs comme les paramètres formels :

Exemple : Des paramètres différents qui portent le même nom.

Un peu de vocabulaire :
Dans le contexte des fonctions les paramètres qui interviennent dans la définition d'une fonction sont appelés les paramètres formels alors que ceux qui apparaissent dans l'appel de la fonction sont les paramètres effectifs.

def aireRectangle(L,l) : # L et l sont les paramètres formels
return L*l

### programme principal ###
long = 30
larg = 20
aire = aireRect(long,larg) # long et larg sont les paramètres effectifs
Les paramètres effectifs n'ont pas à porter le même nom que les paramètres formels, même si des fois on le fait pour accentuer la lisibilité du code.
Quand on le fait, on doit savoir que ce sont des variables différentes même si elles portent le même nom.
Utilisez l'outil "Visualiser" pour vous en persuader !

Bon à savoir


Les fonctions lambda :

Les fonctions lamda sont des mini-fonctions définies à la volée. Pour en savoir plus, voir ici.

On peut tout à fait vivre sans fonction lambda mais si vous cherchez à utiliser le code d'autres développeurs, vous pourrez en trouver.



Une fonction Python peut retourner plusieurs valeurs :

Exemple : Une fonction avec plusieurs retours.

A la différence de nombreux autres langages de programmation, Python permet de retourner plusieurs valeurs.
C'est le cas de la fonction minMaxMoy ci-dessous qui retourne dans cet ordre le min, la moyenne et le max des 3 valeurs qui lui sont passées en paramètres.



Une fonction Python ne modifie pas une donnée passée en paramètre lorsque celle-ci est de type int, float ou string :

Exemple : Fausse modif

Les fonctions Python ne modifient pas les paramètres qui leur sont passés lorsque ces paramètres sont de type int, float ou string.
Si vous faites tourner le programme ci-dessous et que vous analysez finement les messages de sortie vous verrez que :
  • le x passé à la fonction est une copie du paramètre effectif (a, b ou t). A l'entrée dans la fonction, le x vaut bien a, b ou t ;
  • dans la fonction, x est modifié par le code : 3 est augmenté de 1, 7.3 est multiplié par 2, "toto va à la plage", devient "toto va à la plages" ;
  • mais en sortie de fonction, les paramètres effectifs a, b et t n'ont pas été modifiés : a vaut toujours 1, b toujours 7.3 et "toto va à la plage" termine par un "e".

Dans les 3 cas, c'est la copie x de a, b ou t qui a été modifiée et pas l'original !

  • Le mécanisme de passage par copie sera encore mieux visible si vous utilisez l'option "Visualiser". Vous verrez la copie modifiée et l'original préservé !
  • Vous verrez plus loin dans le cours que certains objets passés en paramètres sont modifiables par une fonction. C'est le cas des listes notamment.





La récursivité :

C'est un sujet très ardu qui nécessiterait de nombreuses pages d'explications mais sachez que dans le corps d'une fonction, on peut faire appel à la fonction elle-même. Cet appel est nommé appel récursif.

Dans le cadre de ce cours, on utilisera des fonctions récursives, notamment dans le traitement des fichiers et le parcours d'arborescence de dossiers. Pour l'instant, on va se contenter d'illustrer par un exemple simple : le calcul de la factorielle d'un nombre :

Exemple : Factorielle

Rappel : n ! = n * (n-1) * (n-2) * ... * 2 * 1
Exemple : 5 ! = 5 * 4 * 3 * 2 * 1 = 120
Puisque n ! = n * (n-1) * (n-2) * ... * 2 * 1, on voit que n ! = n * (n-1) !
C'est cette dernière relation, combinée au fait que 0 ! = 1, qui va conduire à la définition récursive de la fonction factorielle :
Le système va remplacer tour à tour :
  • 5 ! par  5 * 4 !
  • puis 4 ! par 4 * 3 !, ce qui donnera 5 ! = 5 * 4 * 3 !
  • puis 3 ! par 3 * 2 !, ce qui donnera 5 ! = 5 * 4 * 3 * 2 !
  • puis 2 ! par 2 * 1 !, ce qui donnera 5 ! = 5 * 4 * 3 * 2 * 1 !
  • puis 1 ! par 1 * 0 !, ce qui donnera 5 ! = 5 * 4 * 3 * 2 * 1 * 0 ! = 5 * 4 * 3 * 2 * 1 = 120


  • Le mécanisme récursif sera mieux visible si vous utilisez l'option "Visualiser".



Le quizz

Exercice à choix multiple : Appels imbriqués
Une fonction peut appeler une autre fonction.
Bien !

Exercice à réponse courte : Calcul d'image
def f(a,b) :
return a**2 + b//2

print(f(3, 5))
Quelle sera la valeur affichée ?
Bien !

Exercice à réponse courte : Calcul d'image
def f(a,b) :
return a*2 + b//3

x= 5
print(f(x, 2*x))
Quelle sera la valeur affichée ?
Bien !

Exercice à réponse courte : Calcul d'image
def f(a) :
if a % 2 == 0 :
return a/2
else :
return 3*a + 1

x= 5
print(f(f(x)))
Quelle sera la valeur affichée ?
Bien !

Exercice à choix multiple : Return 1
Le corps d'une fonction peut contenir plusieurs return.
Bien !

Exercice à choix multiple : Return 2
Le corps d'une fonction peut ne contenir aucun return.
Bien !

Exercice à choix multiple : Return 3
Quand une instruction return est exécutée, la fonction s'arrête.
Bien !

Exercice à choix multiple : Return 4
Dans le corps d'une fonction qui ne retourne pas de valeur, il ne peut pas y avoir de return.
Bien !

Exercice à choix multiple : Retourner plusieurs valeurs
Une fonction Python peut retourner plusieurs valeurs.
Bien !

Exercice à réponse courte : Calcul d'image
def f(a) :
a*=10

x = 5
f(x)
f(x)
f(x)
print(x)
Quelle sera la valeur affichée ?
Bien !

Questions souvent posées


A la différence d'autres langages, on ne précise pas en Python les types des paramètres passés aux fonctions quand on les définit. Pourquoi ?

Python est un langage peu typé. Le fait d'autoriser le programmeur à ne pas préciser les types attendus lui permet de créer des fonctions multiformes qui s'adaptent aux paramètres effectivement reçus. En revanche, le programmeur doit être rigoureux et si le paramètre n'est pas de type attendu, il doit le gérer :

def f(x) : # f attend un int
   if not isinstance (x,int) : # si x n'est pas un int
      print ("Erreur 213B, cette fonction attend un int")
      return # sortie de fonction sans rien faire

   ... # code à effectuer si x est bien un int


Comment peut-il y avoir plusieurs return dans le corps d'une fonction puisque return stoppe la fonction ? Le code écrit après un return n'est jamais exécuté !

C'est possible quand les return sont effectués sous condition :

def f(x) : 
   if ... :
      ...
      ...
      return 1
   elif ... :
      ...
      ...
      return 2
   else :
      ...
      ...
      return 3


J'ai vu des return dans des fonctions qui ne retournent rien ! Ce sont juste des instructions return isolées, sans valeur retournée. A quoi ça sert ?

A stopper la fonction quand le traitement est effectué, sans perdre du temps machine à lire le code qui suit  :

def f(x) :
   if x > 10 :
      traitement1
      return
   elif x < 5 :
      traitement2
      return
   else : # 5 <= x <= 10
      traitement3

#### programme principal ####
f(20) # va effectuer le traitement1 et sortira sans lire la suite
f(2) # va effectuer le traitement2 et sortira sans lire la suite
f(7) # va effectuer le traitement3 et sortira (puisque fin de fonction)


Lors de la définition d'une fonction qui effectue un calcul, vaut-il mieux afficher le résultat dans la fonction ou le retourner à la fonction appelante ?

Il vaut toujours mieux renvoyer le résultat à la fonction appelante ! C'est une condition quasi-indispensable pour pouvoir réutiliser la fonction dans un autre contexte.



Est-ce que je peux appeler une fonction dans une autre fonction ?

Tout à fait, on le fait tout le temps !

Exemple : La famille Simpson

La fonction (afficheFamilleSimpson) appelle les autres fonctions (afficheParentsSimpsons et afficheEnfantsSimpsons).
... et les fonctions afficheParentsSimpsons et afficheEnfantsSimpsons appellent la fonction print !



Pourquoi n'est-on pas obligé de garder les mêmes noms quand on appelle une fonction ? Pourquoi les paramètres qu'on passe quand on appelle la fonction ne doivent pas être nommés pareil que les paramètres qu'on donne quand on définit la fonction ? Comment le système fait pour s'y retrouver ?

Tout d'abord, rassure-toi ! Quand on se pose ces questions là, c'est qu'on est sur la bonne voie !

En fait le système s'y retrouve comme nous les humains nous nous y retrouvons, prenons un exemple :

Exemple : Capital après N années

Je dépose un capital K au taux d'intérêt annuel de 4% pendant N années.
Le capital final est K*1.04^N (exposant N). Le capital est donc fonction du nombre d'années et du capital de départ.
Si j'appelle "Capital", la fonction qui calcule le capital après N années, l'expression de la fonction est alors Capital(K,N) = K*1.04^N. D'où :
  • Capital(1000,8) = 1000*1.04^8
  • Capital(200,10) = 200*1.04^10
  • Capital(1000,P) = 1000*1.04^P
  • Capital(C,nbAnnees) = C*1.04^nbAnnees

Ce ne sont pas les noms des paramètres qui comptent, mais leur valeur !



Dans d'autres langages de programmation, on parle de passage par référence ou par valeur. Qu'est-ce qu'il en est en Python ?

C'est un peu les deux :

Exemple : Valeur ou référence

  • Les objets non mutables comme les int, les float et les string sont passés par valeur. C'est à dire qu'une copie de la variable est passée à la fonction. Toute modification de la copie laissera donc l'original inchangé (il n'aura pas pu muter).
  • Les objets mutables comme les listes sont passés par référence. C'est une référence à l'original qui est reçue par la fonction donc toute modification de la référence modifiera l'orignal.



 

 

 

Exemples de questions de cours

  • Quelle est la syntaxe de définition d'une fonction ?
  • Définissez le plus complètement possible les rôles du mot-clé return.
  • Est-ce que le corps d'une fonction qui ne retourne pas de valeur peut contenir le mot-clé return ?
  • Lors de la définition d'une fonction qui effectue un calcul, vaut-il mieux afficher le résultat dans la fonction ou le retourner à la fonction appelante ? Justifiez.

Des exercices pour s'entraîner

Exercice de code : Aire d'un triangle

Définir une fonction qui attend la base d'un triangle et sa hauteur puis qui retourne son aire.
Rappel : aire du triangle = base * hauteur / 2
Dans le programme principal, on entrera dans cet ordre la base et la hauteur (des floats), puis on affichera l'aire au format suivant, l'aire étant bien sur calculée par appel à la fonction :
L'aire d'un triangle de base 10.5 et de hauteur 8.0 est 42.0
 
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Aire d'un disque

Définir une fonction qui attend le rayon d'un disque puis qui affiche son aire.
Rappel : aire du disque = pi * rayon^2
Dans le programme principal, on entrera le rayon (un float), puis on affichera l'aire au format suivant, l'aire étant bien sur calculée par appel à la fonction :
L'aire d'un disque de rayon 19.8 est 1231.6299839133426
Pour utiliser pi, importer la valeur pi du module math en tête de votre code :
from math import pi as Pi # on importe pi du module math et on l'appelle Pi
 
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : TVA

Définir une fonction qui attend le prix hors taxes (PHT) d'un article et un taux de TVA, puis qui retourne le prix toutes taxes comprises (PTTC) de l'article.
Rappels :
  • TVA = PHT * tauxTVA / 100
  • PTTC = PHT + TVA

Dans le programme principal, on entrera dans cet ordre le prix hors taxes et le taux de TVA (des floats), puis on affichera le prix TTC au format suivant, le prix TTC étant bien sur calculé par appel à la fonction :

Le prix TTC d'un article de prix HT 171.5 au taux de TVA 8.8 % est 186.592
 
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Carré

Définir une fonction qui attend un caractère et un nombre entier N, puis qui dessine le carré de N lignes et N colonnes dessiné avec le caractère donné.
Par exemple, si le caractère est * et que N = 5, la fonction dessine :
*****
*****
*****
*****
*****
Dans le programme principal, on entrera successivement le caractère et le nombre de lignes, puis on affichera le carré par appel à la fonction.

 
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Rectangle vide

Définir une fonction qui attend un caractère et deux nombres entiers C et H, puis qui dessine le rectangle vide de H lignes et C colonnes dessiné avec le caractère donné.
Par exemple, si le caractère est *, que H = 5 et C = 6, la fonction dessine :
******
* *
* *
* *
******
Dans le programme principal, on entrera dans cet ordre le caractère, le nombre de lignes et le nombre de colonnes puis on affichera le rectangle vide par appel à la fonction.

 
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Phrase encadrée

Définir une fonction qui attend une phrase et un caractère, puis qui encadre la phrase avec le caractère donné en laissant des espaces autour de la phrase.
Par exemple, si le caractère est % et que la phrase est "Homer et Bart vont à la plage", la fonction affiche :
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% Homer et Bart vont à la plage %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Dans le programme principal, on entrera dans cet ordre la phrase et le caractère d'encadrement puis on affichera la phrase encadrée par appel à la fonction.

 
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Phrase encadrée deux fois

Définir une fonction qui attend une phrase et deux caractères donnés, puis qui encadre la phrase avec un double cadre formé avec les deux caractères.
On ne laissera pas d'espace autour de la phrase.
Par exemple, si le premier caractère est %, le deuxième * et que la phrase est "Homer et Bart vont à la plage", la fonction affiche :
*********************************
*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*
*%Homer et Bart vont à la plage%*
*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*
*********************************
Dans le programme principal, on entrera dans cet ordre la phrase et les caractères d'encadrement puis on affichera la phrase encadrée par appel à la fonction.

 
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Températures

Définir une fonction qui attend les températures des 7 jours de la semaine à midi et qui retourne le minimum, le maximum, la moyenne et la moyenne corrigée.
Dans le programme principal, on entrera successivement les 7 températures (entières) puis on affichera les 4 résultats au format suivant, par appel à la fonction.
Mini : 18
Maxi : 23
Moyenne : 20.142857142857142
Moyenne corrigée : 20.0
   
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Conversions monétaires

On veut convertir une somme exprimée en dollar, euro ou livre dans les deux autres devises.
Définir une fonction qui attend la somme à convertir et la devise de départ et qui retourne les montants convertis dans les deux autres devises.
Dans le programme principal, on entrera dans cet ordre le montant à convertir (un float) et la devise de départ (€, $, £) puis on affichera les montants convertis au format suivant, après appel à la fonction. On affichera toujours dans l'ordre €, $, £.
Euro : 164.43389040727632
Dollar : 183.5
Livre : 117.59243021640755
Votre programme contiendra seulement les deux taux de conversion suivant :
  • euro2dollar = 1.11595 (au 12/8/2015)
  • euro2livre = 0.715135 (au 12/8/2015)




Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Palidromes, un exo pour les cracs....

Les palindromes sont des mots qui se lisent de façon identique dans les deux sens : radar, kayak, coloc, sms...
Définir une fonction récursive qui attend une chaine de caractères et qui renvoie True si la chaine est un palindrome et False sinon.
Dans le programme principal, on entrera la chaine à tester puis on affichera le résultat au format suivant, après appel à la fonction.
Marge n'est pas un palindrome
ou
kayak est un palindrome
 
Vous aurez probablement besoin de lire ceci.



Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Un résumé produit par des étudiants

Résumé du chapitre 3

Il a été réalisé par Mathieu BESSON et Yanis KAID KASBAH, promo 2016-2017

Il mérite d'être amélioré mais donne déjà des informations intéressantes.

On dit qu'on factorise le code.
Quand ça bugue, on sait plus facilement où aller.
Pour définir la fonction
prixTotal
prixUnitaire et quantite
Pour fonctionner ;-)
Si on ne le fait pas, cela provoque une erreur, à la différence de nombreux autres langages pour lesquels c'est conseillé mais pas obligatoire.
C'est longueur*2 + largeur*2
Pour définir la fonction
perimetre (sans accent !)
longueur et largeur
Ici, il y en a deux mais il pourrait y en avoir un seul, ou zéro ou autant qu'on veut...
Si on ne le fait pas, cela provoque une erreur, à la différence de nombreux autres langages pour lesquels c'est conseillé mais pas obligatoire.
Le codeur doit penser que le lecteur est un programmeur du même niveau que lui.
Ils font office de commentaires
name 'aireRect' is not defined
Quand on définit la fonction, on raisonne formellement, sans connaître les valeurs effectives de ces paramètres.
Lors de l'appel, ils sont effectivement passés.
Ce qui est toujours une bonne chose !
Les listes sont des objets mutables alors que int, float et string ne le sont pas.
Se lit "factorielle n"
C.F. leçon 5
Moyenne calculée sur 5 jours en enlevant la température max et la température min