DIGICOM

Algorithme & programmation

Fonction et Liste

FONCTIONS

Introduction

Objectif

Intro

import turtle as tl

Intro

import turtle as tl

# Carré rouge de 100 px de côté
tl.pencolor("red")
tl.fillcolor("red")
tl.begin_fill()
for i in range(4):
    tl.forward(100)
    tl.left(90)
tl.end_fill()

Intro

import turtle as tl

# Carré rouge de 100 px de côté
tl.pencolor("red")
tl.fillcolor("red")
tl.begin_fill()
for i in range(4):
    tl.forward(100)
    tl.left(90)
tl.end_fill()

# Déplacement sans tracer
tl.penup()
tl.forward(150)
tl.pendown()

Intro

import turtle as tl

# Carré rouge de 100 px de côté
tl.pencolor("red")
tl.fillcolor("red")
tl.begin_fill()
for i in range(4):
  tl.forward(100)
  tl.left(90)
tl.end_fill()

# Déplacement sans tracer
tl.penup()
tl.forward(150)
tl.pendown()

# Carré bleu de 100 px de côté
tl.pencolor("blue")
tl.fillcolor("blue")
tl.begin_fill()
for i in range(4):
  tl.forward(100)
  tl.left(90)
tl.end_fill()

Intro

Définition

On appelle fonction une partie de code recevant une ou plusieurs informations à partir desquelles elle retourne une ou plusieurs informations.

Les informations fournies à la fonction sont appelées arguments ou paramètres de la fonction.

Les informations renvoyées par la fonction sont appelées résultats.

Intro

Approche

En 3 temps :

Simple (sans paramètres ni sorties)
Avec paramètres
Avec return

FONCTIONS

Simple

L'idée

On parle ici d'une fonction qui n'a pas de paramètre et ne renvoie rien.

Simple

Les 2 étapes

Il faut dissocier :

la création (ou déclaration) d'un fonction,
son utilisation (ou appel).

C'est comme pour un outil, créer un marteau n'a rien a voir avec l'utiliser !

Simple

Comment ça marche : création d'une fonction

def nom_fonction():
    bloc d'instructions

Simple

Comment ça marche : création d'une fonction

def nom_fonction():
    bloc d'instructions

Remarques :

le mot clé def permet de créer une fonction.
Les deux points : à la fin de la ligne de def sont obligatoires.
Les instructions d'une fonction sont indentés (comme pour for)
Les variables créées dans une fonction n'existent que dans cette fonction !

Simple

Comment ça marche : création d'une fonction

def nom_fonction():
    bloc d'instructions

Remarques :

le mot clé def permet de créer une fonction.
Les deux points : à la fin de la ligne de def sont obligatoires.
Les instructions d'une fonction sont indentés (comme pour for)
Les variables créées dans une fonction n'existent que dans cette fonction !

Simple

Comment ça marche : création d'une fonction

def nom_fonction():
    bloc d'instructions

Remarques :

le mot clé def permet de créer une fonction.
Les deux points : à la fin de la ligne de def sont obligatoires.
Les instructions d'une fonction sont indentées (comme pour for)
Les variables créées dans une fonction n'existent que dans cette fonction !

Simple

Comment ça marche : création d'une fonction

def nom_fonction():
    bloc d'instructions

Remarques :

le mot clé def permet de créer une fonction.
Les deux points : à la fin de la ligne de def sont obligatoires.
Les instructions d'une fonction sont indentées (comme pour for)
Les variables créées dans une fonction n'existent que dans cette fonction !

Simple

Comment ça marche : Utilisation d'une fonction

Vous avez déjà utilisé des fonctions : begin_fill(), end_fill()
En python :

nom_fonction()

Remarques :

Il fait mettre les deux parenthèses () à la fin, même s'il n'y a rien dedans.
Une fonction n'a besoin d'être créée qu'une fois pour être utilisée autant de fois que nécessaire.

Simple

Exemple 1

Création puis utilisation d'une fonction bonjour qui affiche "Bonjour à tous" dans le terminal.

# définition de la fonction



# utilisation la fonction

Simple

Exemple 2

Création puis utilisation d'une fonction carre_100 qui affiche un carré de 100 pixels.

import turtle as tl

FONCTIONS

Paramètres

Objectif

Paramètres

L'idée

On parle ici d'une fonction qui a des paramètres mais pas de return.

Les paramètres sont là pour "paramétrer" / modifier le comportement de la fonction lors de son exécution.

Paramètres

Comment ça marche : création d'une fonction avec paramètres

def nom_fonction(par1, par2):
  bloc d'instructions

Paramètres

Comment ça marche : création d'une fonction avec paramètres

def nom_fonction(par1, par2):
    bloc d'instructions

Remarques :

Les paramètres d'une fonction sont placés entre parenthèses et séparés par des virgules s'il y en a plusieurs.
Les instructions dans la fonctions utilisent les paramètres grâce à leurs noms donnés entre parenthèses.

Paramètres

Comment ça marche : création d'une fonction avec paramètres

def nom_fonction(par1, par2):
    instructions1
    instructions2

Remarques :

Les paramètres d'une fonction sont placés entre parenthèses et séparés par des virgules s'il y en a plusieurs.
Les instructions dans la fonctions utilisent les paramètres grâce à leurs noms donnés entre parenthèses.

Paramètres

Comment ça marche : Utilisation d'une fonction avec paramètres

Là encore, vous avez déjà utilisé des fonctions avec paramètres : print(), input(), int(), ...

Paramètres

Comment ça marche : Utilisation d'une fonction avec paramètres

a = valeur
nom_fonction(a, 3)

Paramètres

a = valeur
        nom_fonction(a, 3)

Remarques :

La valeur d'un paramètre peut être donné

directement (3).
par une variable (a).
par une expression (calcul, ...).

De préférence, les instructions dans une fonction n'utilisent pas directement des variables définies hors de la fonction.

Paramètres

Comment ça marche : Utilisation d'une fonction avec paramètres

Là encore, vous avez déjà utilisé des fonctions avec paramètres : print(), input(), int(), ...
En python :

a = valeur
nom_fonction(a, 3)

Remarques :

La valeur d'un paramètre peut être donné

directement (3).
par une variable (a).
par une expression (calcul, ...).

Les instructions dans une fonction ne peuvent pas utiliser directement des variables définies hors de la fonction.

Paramètres

Exemple 1

Création puis utilisation d'une fonction 'bonjour' prend un paramètre 'prenom' qui affiche "Bonjour " puis prenom dans le terminal.

# définition de la fonction
def bonjour(prenom):
    print(f"Bonjour {prenom}")
print("coucou")
bonjour("Bob")
un_prenom = "Abdel"
bonjour(un_prenom)

Exemple 2

Création d'un côté d'un carré de longueur 'long' (avec la rotation de 90°).

from turtle import *
# Définition de la fonction cote_carre(long)
def cote_carre(long):
    forward(long)
    left(90)
# Utilisation pour faire un carré
for i in range(4):
    cote_carre(50)
up()
forward(150)
down()
# Utilisation pour faire une spirale
l = 20
for i in range(1,6):
    cote_carre(i*l)

FONCTIONS

`return`

# définition de la fonction
def super_calcul(nombre):
        resultat = 2*nombre

# utilisation de la fonction
super_calcul(7)
print(resultat)

Objectif

`return`

L'idée

Toutes les fonctions ont des résultats (c'est leur buts) mais jusqu'à présent nous n'avons vu des résultats que dans le terminal ou dans la fenêtre de turtle.
Voyons à présent un type de fonction qui a des paramètres et renvoi des informations dans le programme qui l'a appelée à l'aide d'un return.

`return`

Comment ça marche : création d'une fonction avec `return`

def nom_fonction(par1, par2):
    instructions
    return resultat

`return`

Comment ça marche : création d'une fonction avec `return`

def nom_fonction(par1, par2):
    instructions
    return resultat

Remarques :

resultat peut-être une variable créée dans la fonction, une expression ou une valeur
return est un mot clé réservé au renvoi des résultats d'une fonction dans le programme ou elle a été appeler.
Une fois la ligne du return exécutée, la fonction s'arrête et l'exécution continue dans le programme principal.

`return`

Comment ça marche : création d'une fonction avec `return`

def nom_fonction(par1, par2):
    instructions
    return resultat

Remarques :

resultat peut-être une variable créée dans la fonction, une expression ou une valeur
return est un mot clé réservé au renvoi des résultats d'une fonction dans le programme ou elle a été appeler.
Une fois la ligne du return exécutée, la fonction s'arrête et l'exécution continue dans le programme principal.

`return`

Comment ça marche : création d'une fonction avec `return`

def nom_fonction(par1, par2):
    instructions
    return resultat

Remarques :

resultat peut-être une variable créée dans la fonction, une expression ou une valeur
return est un mot clé réservé au renvoi des résultats d'une fonction dans le programme ou elle a été appeler.
Une fois la ligne du return exécutée, la fonction s'arrête et l'exécution continue dans le programme principal.

`return`

Comment ça marche : Utilisation d'une fonction avec `return`

Là encore, vous avez déjà utilisé des fonctions avec return : input() et int() par exemple.

De manière général, on stocke le retour des fonctions dans une ou des variables, mais il est aussi possible de les afficher directement


res = super_calcul(3)
print(res)
print(super_calcul(2))

`return`

Exemple 1

Création puis utilisation d'une fonction 'bonjour' prend un paramètre 'prenom' qui retourne "Bonjour " puis prenom.

# définition de la fonction

`return`

Exemple 2

Création d'une qui calcule l'angle entre les côtés d'un polygône régulier pour turtle à partir du nombre de côtés.

from turtle import *
# Définition de la fonction angle(nb_cote)
def angle(nb_cote):
    return 360/nb_cote


# Triangle de 100px de côté

LISTE

Objectif :
Comment créer cette frise.

import turtle as tl


def carre(couleur):
    tl.pencolor(couleur)
    tl.fillcolor(couleur)
    tl.begin_fill()
    for i in range(4):
        tl.forward(25)
        tl.left(90)
    tl.end_fill()
    tl.forward(25)

import turtle as tl


def carre(couleur):
    tl.pencolor(couleur)
    tl.fillcolor(couleur)
    tl.begin_fill()
    for i in range(4):
        tl.forward(25)
        tl.left(90)
    tl.end_fill()
    tl.forward(25)

carre("black")
carre("gray")
carre("red")
carre("green")
carre("blue")
carre("orange")
carre("maroon")
carre("fuchsia")
carre("gold")
carre("aqua")
carre("indigo")

import turtle as tl


def carre(couleur):
    tl.pencolor(couleur)
    tl.fillcolor(couleur)
    tl.begin_fill()
    for i in range(4):
        tl.forward(25)
        tl.left(90)
    tl.end_fill()
    tl.forward(25)

COULEURS = ["black", "gray", "red", "green", "blue", "orange", "maroon", "fuchsia", "gold", "aqua", "indigo"] 
for c in COULEURS:
      carre(c)

LISTE

L'idée

Comment enregistrer une liste de valeurs ?
Ex : les prénoms d'une classe, la température d'une pièce toute les minutes, ...
→ ~~Variable normale~~ : difficilement manipulable !
→ Un nouveau type de variable : les tableaux list

LISTE

Comment ça marche : créer une liste

Les tableau (list) en python

Créer une liste vide :

nom_liste = [   ]

Créer une liste déjà remplie :

nom_liste = [va0, va1, ...]

LISTE

Comment ça marche : créer une liste

Exemples :

entiers = [1, 2, 8, 78] # liste d'entiers
strings = ["slt", "bjr", "cc"] # liste de strings
mixte = [2, "dd", 2.5] # liste contenant plusieurs type de valeurs
liste_de_liste = [[12, 4], [5, 4, 3],[4]] # liste contenant des listes
liste_vide = [] # ou list()

LISTE

A retenir: créer une liste

En python, les tableaux sont contenus dans des crochets [ ... ]
Les éléments sont séparés par des virgules ,

[ élement1 , élement2 , élement3 ]

LISTE

Tableau vide

Il est possible de créer un tableau vide


# Créer un tableau vide
mon_tableau = []

Tableau non vide

Il est aussi possible de l'initialiser avec des valeurs


# Créer un tableau à partir de valeurs
>>> mon_tableau = ["Alan", "Ada", "Grace", "Ian"]
["Alan", "Ada", "Grace", "Ian"]

Tableau de valeurs identiques

Enfin si l'on veut, il est aussi possible de l'initialiser avec les mêmes valeurs


# Créer un tableau contenant 5 zéros
>>> mon_tableau = [0]*5
[0, 0 , 0, 0, 0]

LISTE

Comment ça marche : Accéder à un élément

Pour accéder à un élément, on utilise son index (sa position dans la liste)

L'index d'une liste commence à 0.

[\underbrace{\text{"Alan"}}_{0}, \underbrace{\text{"Ada"}}_{1}, \underbrace{\text{"Grace"}}_{2}, \underbrace{\text{"Ian"}}_{3}]

LISTE

Comment ça marche : Accéder à un élément

L'instruction pour accéder à un élément est construite à partir du nom du tableau et de l'index (la position) de l’élément souhaité entre crochets [].

LISTE

Comment ça marche : Accéder à un élément

Le tableau s'appelle mon_tableau et l'élément Ada est en position 1.

On accède donc à cet élément avec l'instruction


>>> mon_tableau = ["Alan", "Ada", "Grace", "Ian"]
>>> print(mon_tableau[1])
"Ada"

LISTE

Comment ça marche : Les index négatifs

Comment accéder aux derniers éléments d'un tableau ?

notes = [12, 14, 11, 16, 17, 15, 18, 15, 19]

LISTE

Comment ça marche : Les index négatifs

Pour atteindre le dernier élément d'un tableau, il faudrait connaître le nombre total d'éléments du tableau (en utilisant la fonction len) et lui soustraire 1.

LISTE

Comment ça marche : Les index négatifs


notes = [12, 14, 11, 16, 17, 15, 18, 15, 19]
nb_notes = len(notes)
print(notes[nb_notes - 1])

LISTE

Comment ça marche : Les index négatifs


notes = [12, 14, 11, 16, 17, 15, 18, 15, 19]
print( notes[len(notes) - 1])

LISTE

Comment ça marche : Les index négatifs


notes = [12, 14, 11, 16, 17, 15, 18, 15, 19]
print( notes[-1])

LISTE

Exercice 1

On considère le code suivant :


tab = ["Alan", "Ada", "Grace", "Ian", "Charles", "Guido"]

Que vaut tab[3] ?

LISTE

Exercice 2

Après l'affectation suivante :


alphabet = [ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',
'M', 'N','O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' ]

Quelle instruction permet d'accéder à la lettre E ?

Quelle instruction permet d'accéder à la lettre Y ?

LISTE

Modification d'un élément

LISTE

Comment ça marche : Modification d'un élément

Pour modifier la valeur d'un élément, il faut acceder à cet élément par son index et lui affecter une nouvelle valeur à l'aide du signe =.

nom_tableau[index ] = nouvelle valeur

LISTE

Comment ça marche : Modification d'un élément

Quel affichage résultera de l'éxécution du code ci-dessous ?


informaticiens= ["Alan", "Ada", "Grace", "Ian"]
informaticiens[1] = "Ada Lovelace"
print(informaticiens)

LISTE

Comment ça marche : Modification d'un élément

Quel affichage résultera de l'éxécution du code ci-dessous ?


informaticiens = ["Alan", "Ada", "Grace", "Ian"]
informaticiens[1] = "Ada Lovelace"
print(informaticiens)
["Alan", "Ada Lovelace", "Grace", "Ian"]

LISTE

Comment ça marche : Modification d'un élément

On considère le script suivant :


tab = [2, 8, 9, 2]
tab[2] = 4

Quelle est la valeur de tab à la fin de son exécution ?

LISTE

Comment ça marche : Modification d'un élément

On considère le script suivant :


tab = [2, 8, 9, 2]
tab[2] = tab[2] + 5

Quelle est la valeur de tab à la fin de son exécution ?

LISTE

Comment ça marche : Modification d'un élément

On considère le script suivant :


 
tab = [2, 8, 9, 2]
tab[3] = tab[1] + 5
tab[2] = tab[3] + 5

Quelle est la valeur de tab à la fin de son exécution ?

Ajouter des éléments

Méthodes

Il existe plusieurs façons d'ajouter des éléments à un tableau donné.
On peut :

ajouter un élement,
étendre un tableau à partir d'un second tableaux,
concatener 2 tableaux pour en former un troisième.

Ajouter un élément

Pour ajouter un seul élément, on utilise la méthode append. La méthode append modifie sur place l'objet tableau qui l'appelle.


mon_tableau = ["Alan", "Ada", "Grace", "Ian"]
mon_tableau.append("George")
print(mon_tableau)
["Alan", "Ada", "Grace", "Ian", "George"]

Etendre une liste

Pour ajouter un tableau d'élément, on utilise la méthode extend. La méthode extend modifie sur place l'objet tableau qui l'appelle.


mon_tableau = ["Alan", "Ada", "Grace", "Ian"]
tableau_2 = ["Charles", "Guido"]
mon_tableau.extend(tableau_2)
print(mon_tableau)
["Alan", "Ada", "Grace", "Ian", "Charles", "Guido"]

Ajout par concaténation

Il est aussi possible de concaténer 2 listes pour en créer une troisième à l'aide de l'instruction +.


tableau_1 = ["Alan", "Ada", "Grace", "Ian"]
tableau_2 = ["Charles", "Guido"]
mon_tableau = tableau_1 + tableau_2
print(mon_tableau)
["Alan", "Ada", "Grace", "Ian", "Charles", "Guido"]

Exercices

Qu'affiche le programme python suivant ?


tab1 = [3,2,2]
tab2 = [1,5,1]
tab1.append(tab2)
print(tab1)

Parcourir un tableau

Il existe deux manières de parcourir les éléments d'une liste :

Parcourir une liste à partir des index des éléments
Parcourir une liste par itération sur les éléments

Parcours à partir de l'index des éléments

En python, les tableaux (list) fonction taille len( ) donnant le nombre d'éléments contenus dans la liste.
Associer à la fonction range(), on obtient un itérable composé de tous les index des éléments de la liste.

Parcours à partir de l'index des éléments


mon_tableau = ["Alan", "Ada", "Grace", "Ian", "Charles", "Guido"]
for index in range(len(mon_tableau)):
print(mon_tableau[index])

Dans cet exemple, la longueur de mon_tableau est 6.
L'instruction range(len(mon_tableau)) va être successivement évaluée par range(6) puis par un itérable de longueur 6 qui contiendra les valeurs 0, 1, 2, 3, 4 et 5 qui seront succéssivement données à la variable index.

Itération des éléments

Comme pour tout les itérables, il est aussi possible de parcourir un tableau en itérant les éléments du tableau, avec les instructions

for v in iterable.

Exemple


mon_tableau = ["Alan", "Ada", "Grace", "Ian", "Charles", "Guido"]
for elmt in mon_tableau:
print(elmt)

Dans cet exemple, la variable elmt prendra successivement les valeurs contenues dans la variable mon_tableau, c'est à dire "Alan", "Ada", "Grace", "Ian".

remarque

Il est souvent utile de bien nommée la variable créée dans la boucle for. Ainsi pour le code précédent, il aurait été préférable d'écrire :


mon_tableau = ["Alan", "Ada", "Grace", "Ian", "Charles", "Guido"]
for informaticien in mon_tableau:
print(informaticien)

Exercice

On considère le code suivant :


def feed(t):
for i in range(len(t)):
    t[i] = t[i] + i
return t

Que renvoie l'instruction feed([12, 24, 32]) ?

LISTE

Comment ça marche : modifier un élément d'une liste

En python :

nom_liste[indice] = nouvelle_valeur

Exemples :

entiers = [1, 2, 8, 78] # liste d'entiers
entiers[1] = 14 # change la valeur à l'indice 1 par 14
print(entiers) # renvoie [1, 14, 8, 78]

LISTE

Comment ça marche : nombre d'éléments dans une liste

En python :

len(nom_liste)

Exemples :

entiers = [1, 2, 8, 78] # liste d'entiers
print(len(entiers)) # renvoie 4

LISTE

Comment ça marche : ajouter un élément dans une liste

Il existe différentes façons d'ajouter un élément dans une liste, en voici deux.
En python :

nom_liste.append(valeur)
nom_liste.insert(indice, valeur)

Exemples :

entiers = [1, 2, 8, 78] # liste d'entiers
entiers.append(22) # ajoute 22 à la fin de entiers
print(entiers) # renvoie [1, 2, 8, 78, 22]
entiers.insert(2,-12)
print(entiers) # renvoie [1, 2, -12, 8, 78, 22]

Remarques :

.append(valeur) permet d'ajouter une valeur à la fin de la liste.
.insert(indice, valeur) permet d'insérer une valeur à l'indice précisé comme premier paramètre.
Elles doivent être collés à la liste où l'on souhaite insérer une valeur.

LISTE

Comment ça marche : supprimer un élément dans une liste

Voici une première façon de supprimer un élément dans une liste.
En python :

nom_liste.pop(indice)

Exemples :

entiers = [1, 8, 2, 8, 78, 9] # liste d'entiers
val = entiers.pop() # supprime le dernier élément de entiers et le stocke dans val
print(val) # renvoie 9
print(entiers) # renvoie [1, 8, 2, 8, 78]
val = entiers.pop(3) # supprime la valeur de l'indice 2 et la retourne
print(val) # renvoie 8
print(entiers) # renvoie [1, 8, 2, 78]

Remarques :

.pop() supprime la dernière valeur et renvoie la valeur supprimée.
.pop(indice) supprime la valeur de l'indice donné et renvoie la valeur supprimée.
Elle doit être collé à la liste à laquelle on souhaite supprimer la valeur.

LISTE

Comment ça marche : supprimer un élément dans une liste

Voici une seconde façon de supprimer un élément dans une liste.
En python :

nom_liste.remove(valeur)

Exemple :

entiers = [1, 8, 2, 8, 78, 9] # liste d'entiers
entiers.remove(8) # supprime le premier 8
print(entiers) # renvoie [1, 2, 8, 78, 9]

Remarques :

.remove(valeur) supprime la première occurence de la valeur donné en paramètre.
Elle doit être collé à la liste à laquelle on souhaite supprimer la valeur.

LISTE

Exemple 1

Création d'une liste ma_liste contenant les valeurs 4, 6, 7, 12, 15, 22, -465.
Affichage d'une valeur par ligne

ma_liste = [4, 6, 7, 12, 15, 22, -46]
for valeur in ma_liste:
    print(valeur)

Exemple 2

Création d'une spirale dont les côtés ont les valeurs suivante : 5, 10, 15, 22, 25, 28, 35, 50, 100.

from turtle import *
# Définition de la fonction cote_carre()
def cote_carre(l):
    forward(l)
    left(90)

longs = [5, 10, 15, 22, 25, 28, 35,\
50, 80, 90, 100]
for l_cote in longs:
    cote_carre(l_cote)

Titre du popup

Message du popup !

DIGICOM

Algorithme & programmation

Fonction et Liste

FONCTIONS

Introduction

Objectif

Intro

Intro

Intro

Intro

Intro

Définition

Intro

Approche

FONCTIONS

Simple

Simple

L'idée

Simple

Les 2 étapes

Simple

Comment ça marche : création d'une fonction

Simple

Comment ça marche : création d'une fonction

Simple

Comment ça marche : création d'une fonction

Simple

Comment ça marche : création d'une fonction

Simple

Comment ça marche : création d'une fonction

Simple

Comment ça marche : Utilisation d'une fonction

Simple

Exemple 1

Simple

Exemple 2

FONCTIONS

Paramètres

Objectif

Paramètres

L'idée

Paramètres

Comment ça marche : création d'une fonction avec paramètres

Paramètres

Comment ça marche : création d'une fonction avec paramètres

Paramètres

Comment ça marche : création d'une fonction avec paramètres

Paramètres

Comment ça marche : Utilisation d'une fonction avec paramètres

Paramètres

Comment ça marche : Utilisation d'une fonction avec paramètres

Paramètres

Paramètres

Comment ça marche : Utilisation d'une fonction avec paramètres

Paramètres

Exemple 1

Exemple 2

FONCTIONS

return

return

Objectif

return

L'idée

return

Comment ça marche : création d'une fonction avec return

return

Comment ça marche : création d'une fonction avec return

return

Comment ça marche : création d'une fonction avec return

return

Comment ça marche : création d'une fonction avec return

return

Comment ça marche : Utilisation d'une fonction avec return

return

Exemple 1

return

Exemple 2

LISTE

LISTE

L'idée

`return`

`return`

`return`

`return`

Comment ça marche : création d'une fonction avec `return`

`return`

Comment ça marche : création d'une fonction avec `return`

`return`

Comment ça marche : création d'une fonction avec `return`

`return`

Comment ça marche : création d'une fonction avec `return`

`return`

Comment ça marche : Utilisation d'une fonction avec `return`

`return`

`return`