Chapitre 2 - Fonctions et types construits

🎯 Objectifs du Chapitre

Comprendre ce qu'est une fonction en Python et apprendre à les définir et à les utiliser.
Découvrir l’importance de la réutilisation du code et de la modularité grâce aux fonctions.
Introduction aux types construits (listes, tuples, dictionnaires).

📖 1. Les fonctions

1.1 Qu'est-ce qu'une fonction ?

Une fonction est un bloc de code réutilisable qui permet d'effectuer une tâche spécifique. Elle prend en entrée des arguments et retourne un résultat. Les fonctions permettent de découper un programme en sous-programmes plus petits et plus faciles à gérer.

Sans fonction, un même calcul se réécrit à chaque endroit où on en a besoin. S'il est faux, il est faux partout, et il faut penser à le corriger partout.

Exemple :

print("Moyenne de Léa :", (12 + 15 + 9) / 3)
print("Moyenne de Tom :", (8 + 14 + 11) / 3)

Avec une fonction, le calcul est écrit une seule fois. Le corriger, c'est corriger une seule ligne, et le programme dit ce qu'il fait plutôt que comment il le fait.

def moyenne(a, b, c):
    return (a + b + c) / 3

print("Moyenne de Léa :", moyenne(12, 15, 9))
print("Moyenne de Tom :", moyenne(8, 14, 11))
>> Moyenne de Léa : 12.0
>> Moyenne de Tom : 11.0

1.2 Définir une fonction

En Python, une fonction se définit avec le mot-clé def suivi du nom de la fonction, des parenthèses (qui peuvent contenir des paramètres), et d’un bloc de code indenté.

Exemple :

def nom_de_la_fonction(param1, param2):
    # Bloc de code qui s'exécute
    return résultat  # (optionnel)

Pour appeler une fonction (c'est à dire l'exécuter), on utilise son nom suivi de parenthèses contenant les arguments à passer à la fonction.

Exemple :

def addition(a, b):
    c = a + b
    return c

print(addition(2, 3))
>> 5

1.3 Paramètres et arguments

Les paramètres sont des variables définies dans la déclaration de la fonction.
Les arguments sont les valeurs que l’on passe à la fonction lorsqu’on l’appelle.

Exemples :

def addition(a, b):  # a et b sont les paramètres
    c = a + b
    return c

a et b sont les paramètres de la fonction. Ce sont des variables locales à la fonction qui reçoivent des valeurs lorsque la fonction est appelée.

print(addition(2, 3))  # 2 et 3 sont les arguments passés à la fonction
>> 5

2 et 3 sont les arguments. Ce sont les valeurs que l'on passe à la fonction lorsque celle-ci est appelée. Ces valeurs sont affectées aux paramètres a et b à l'intérieur de la fonction.

1.4 Valeurs de retour (return)

Une fonction peut retourner une valeur avec l’instruction return. Si aucune valeur n'est retournée, Python renvoie None par défaut. La valeur retournée peut être de n'importe quel type (entier, chaîne de caractères, liste, etc.). La valeur retournée est la valeur par laquelle est remplacé l'appel de la fonction.

Exemple :

def addition(a, b):
    c = a + b
    return c # Retourne la somme des deux paramètres

print(addition(2, 3)) # addition(2, 3) est remplacé par la valeur 
                      # retournée par la fonction ce qui donne : print(5)
>> 5

Dans cet exemple, la fonction addition retourne la somme des deux paramètres a et b. Lorsque la fonction est appelée avec les arguments 2 et 3, elle retourne la valeur 5 qui est affichée par la fonction print().

return et print() sont souvent confondus, et ce n'est pas du tout la même chose. print() affiche une valeur à l'écran, puis l'oublie. return la renvoie à l'endroit d'où la fonction a été appelée, qui peut alors la stocker, la comparer ou s'en servir dans un autre calcul.

Exemple : une fonction qui affiche au lieu de retourner ne renvoie rien, c'est-à-dire None.

def double_affiche(n):
    print(n * 2)

resultat = double_affiche(5) + 1
>> 10
>> TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

Le 10 s'est bien affiché, mais double_affiche(5) ne vaut rien : il n'y a rien à ajouter à 1. Avec return, la valeur revient et le calcul se poursuit.

def double_retourne(n):
    return n * 2

print(double_retourne(5) + 1)
>> 11

1.5 Portée des variables

Les variables définies à l’intérieur d’une fonction sont locales à cette fonction. Cela signifie qu'elles ne sont pas accessibles en dehors de la fonction.

Exemple :

def fonction_a():
    x = 10  # Variable locale
    print("dans la fonction, x vaut", x)
    return x

fonction_a() # La fonction est bien exécutée
>> dans la fonction, x vaut 10

print(x) # Mais x n'existe que le temps de l'appel
>> NameError: name 'x' is not defined

1.6 Annotations de type

Une fonction peut être annotée avec des types de données pour indiquer le type des paramètres et de la valeur de retour. Elles permettent de documenter le code et d'améliorer sa lisibilité. Python ne les vérifie pas à l'exécution : ce sont votre éditeur et les outils d'analyse qui s'en servent pour signaler les erreurs de typage avant de lancer le programme.

Les annotations de type (ou encore typage) font partie des bonnes méthodes de programmation que vous devez adopter. Il faudra donc les utiliser dans chaque fonction que vous écrirez dans vos programmes.

Exemple :

#Fonction addition sans annotations de type
def addition(a, b):
    c = a + b
    return c

#Fonction addition avec annotations de type
def addition(a: int, b: int) -> int:
    c = a + b
    return c

Dans cet exemple, les annotations de type indiquent que les paramètres a et b ainsi que la valeur de retour de la fonction addition sont des entiers.

✏️ Exercice 7 : Calculatrice simple avec fonctions

Objectif : Écrire un programme qui permet de réaliser des opérations arithmétiques simples (addition, soustraction, multiplication, division) à l'aide de fonctions.

Étapes à suivre :

Créer une fonction addition(a, b) qui prend en paramètre deux nombres entiers et retourne leur somme.

Créer une fonction soustraction(a, b) qui prend en paramètre deux nombres entiers et retourne leur différence.

Créer une fonction multiplication(a, b) qui prend en paramètre deux nombres entiers et retourne leur produit.

Créer une fonction division(a, b) qui prend en paramètre deux nombres entiers et retourne leur quotient (Attention au type de la valeur de retour de la fonction).

Demander à l'utilisateur de saisir deux nombres entiers et une opération arithmétique à réaliser. Pour choisir l'opération, l'utilisateur doit saisir un symbole associé (+, -, *, /).

Utiliser les fonctions précédemment créées pour afficher le résultat de l'opération demandée.

Testez maintenant votre programme en donnant deux nombres flottants au lieu de deux nombres entiers. Que se passe-t-il ? Pourquoi ?

Changer votre programme pour qu'il puisse gérer les nombres flottants (n'oubliez pas de modifier les annotations de type des fonctions).

Notes :

Ne pas oublier de gérer les cas d'erreur (division par zéro, opération non reconnue, etc.).

Vous savez maintenant écrire des fonctions simples en Python et vous découvrez comment gérer leur typage.

📖 2. Les types construits

A partir des types de base, on peut construire des types plus complexes appelés types construits. Les types construits les plus courants sont les listes, les p-uplets et les dictionnaires, ils sont génériques et peuvent être mis en oeuvre dans de nombreux langages de programmation.

2.1 Les p-uplets (tuple)

Un p-uplet est une collection ordonnée d'éléments. Chaque élément peut être de n'importe quel type. Les p-uplets sont immuables, c'est-à-dire qu'ils ne peuvent pas être modifiés après leur création. Si les valeurs du p-uplet doivent être changées au cours de l'exécution du programme alors il faut utiliser un autre type de variable comme une liste/tableau (voir partie suivante : Les tableaux).

2.1.1 Création d'un p-uplet

Pour créer un p-uplet, on utilise des parenthèses et on sépare les éléments par des virgules.

Exemple :

# Création d'un p-uplet
p = (1, 2, 3, 4, 5)
print(p)
>> (1, 2, 3, 4, 5)

Un p-uplet ne contenant qu'un seul élément doit être suivi d'une virgule. Cela permet de différencier un p-uplet d'une expression entre parenthèses.

Exemple : p = (1,) et non p = (1)

2.1.2 Accès aux éléments d'un p-uplet

Pour accéder à un élément d'un p-uplet, on utilise l'index de l'élément (sa position dans le p-uplet). Pour un p-uplet de taille n, les index des éléments vont de 0 à n-1.

p[i] permet d'accéder à l'élément à l'index i du p-uplet p.

Exemple :

p = (1, 2, 3, 4, 5)
print(p[0]) # Permet d'accéder à l'élément à l'index 0 du p-uplet p
>> 1
print(p[4]) # Permet d'accéder à l'élément en 5e position (index 4) du p-uplet p
>> 5

La fonction len() permet de connaître la taille d'un p-uplet. Elle permet par exemple d'accéder au dernier élément d'un p-uplet.

Exemple :

p = (6, 7, 8, 9, 10)
print(len(p)) # Permet de connaître la taille du p-uplet p
>> 5
print(p[len(p)-1]) # Permet d'accéder au dernier élément du p-uplet p
>> 10

2.1.3 Un p-uplet ne se modifie pas

C'est ce que veut dire immuable : une fois le p-uplet créé, aucun de ses éléments ne peut être remplacé. Python refuse l'affectation.

Exemple :

p = (1, 2, 3)
p[0] = 9
>> TypeError: 'tuple' object does not support item assignment

On choisit donc un p-uplet pour un groupe de valeurs qui ne doit pas changer — des coordonnées, une date, les trois composantes d'une couleur. Dès qu'il faut ajouter, retirer ou remplacer un élément, c'est une liste qu'il faut.

2.2 Les tableaux / Les listes (list)

Un tableau est une collection ordonnée d'éléments qui sont organisés séquentiellement (les uns à la suite des autres). Contrairement aux p-uplets, les tableaux sont mutables/muables, c'est-à-dire qu'ils peuvent être modifiés après leur création.
En Python, les tableaux sont appelés listes.

2.2.1 Création d'une liste

Les listes sont créées en utilisant des crochets et en séparant les éléments par des virgules.

Exemple :

# Création d'une liste
l = [1, 2, 3, 4, 5]
print(l)
>> [1, 2, 3, 4, 5]

2.2.2 Accès aux éléments d'une liste

De la même manière que pour un p-uplet, pour accéder à un élément d'une liste, on utilise l'index de l'élément. Pour une liste de taille n, les index des éléments vont de 0 à n-1.

l[i] permet d'accéder à l'élément à l'index i de la liste l.

Exemple :

l = [1, 2, 3, 4, 5]
print(l[0]) # Permet d'accéder à l'élément à l'index 0 de la liste l
>> 1
print(l[4]) # Permet d'accéder à l'élément en 5e position (index 4) de la liste l
>> 5

2.2.3 Modification d'une liste par affectation

Pour modifier un élément d'une liste, on utilise l'index de l'élément et on lui affecte une nouvelle valeur.

Exemple :

l = [1, 2, 3, 4, 5]
l[1] = 10 # Modifie la valeur de l'élément à l'index 1 de la liste l
print(l)
>> [1, 10, 3, 4, 5]

2.2.4 Ajout/suppression d'éléments d'une liste

Pour ajouter une valeur à la fin d'une liste, on utilise la méthode append().
Pour supprimer une valeur d'une liste, on utilise la méthode remove().

Exemple :

l = [1, 2, 3, 4, 5]
l.append(6) # Ajoute l'élément 6 à la fin de la liste l
print(l)
>> [1, 2, 3, 4, 5, 6]

l.remove(3) # Supprime l'élément 3 de la liste l
print(l)
>> [1, 2, 4, 5, 6]

l.remove(l[0]) # Supprime le premier élément de la liste l
print(l)
>> [2, 4, 5, 6]

Attention : remove() prend la valeur à supprimer, et non sa position. Elle ne retire que la première rencontrée. Pour supprimer par position, on utilise del.

Exemple :

l = [10, 20, 30, 20]
l.remove(20) # Retire le premier 20, pas l'élément d'index 20
print(l)
>> [10, 30, 20]

del l[0] # Retire l'élément d'index 0
print(l)
>> [30, 20]

2.2.5 Méthodes spécifiques aux listes

La méthode sort() permet de trier les éléments d'une liste.
La méthode reverse() permet d'inverser l'ordre des éléments d'une liste.
La méthode index() permet de récupérer l'index d'un élément dans une liste.
La méthode count() permet de compter le nombre d'occurrences d'un élément dans une liste.
L'opérateur in indique si une valeur se trouve dans la liste, et répond True ou False.

Exemple :

l = [5, 2, 8, 1, 3]
l.sort() # Trie les éléments de la liste l
print(l)
>> [1, 2, 3, 5, 8]

l.reverse() # Inverse l'ordre des éléments de la liste l
print(l)
>> [8, 5, 3, 2, 1]

print(l.index(5)) # Récupère l'index de l'élément 5 dans la liste l
>> 1

print(l.count(5)) # Compte le nombre d'occurrences de l'élément 5 dans la liste l
>> 1

print(5 in l) # Indique si la valeur 5 se trouve dans la liste l
>> True

2.3 Les dictionnaires (dict)

Un dictionnaire est une collection d'éléments non indexée : on n'y accède pas par une position, mais par une clé. Chaque élément est constitué d'une clé et d'une valeur. Les dictionnaires sont mutables/muables et conservent l'ordre dans lequel les éléments y ont été ajoutés. Les clés doivent être uniques et les valeurs peuvent être de n'importe quel type.

2.3.1 Création d'un dictionnaire

Un nouveau dictionnaire est créé en utilisant des accolades et en séparant les éléments par des virgules. Chaque élément est constitué d'une clé et d'une valeur séparées par deux points (clé: valeur).

Exemple :

#                       clés
#      ____________________________________
#      |                  |               |
d = {"nom": "Dupont", "prénom": "Jean", "âge": 30}
#              |                   |            |
#              ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
#                              valeurs

2.3.2 Accès aux éléments d'un dictionnaire

Les éléments d'un dictionnaire ne sont pas indexés, contrairement à ceux des listes et des p-uplets. Il est donc impossible d'accéder au n-ième élément d'un dictionnaire, même s'il garde l'ordre dans lequel les éléments y ont été ajoutés. Pour accéder à une valeur, on utilise la clé associée à cette valeur. C'est la raison pour laquelle les clés doivent être uniques.

d[clé] permet d'accéder à la valeur associée à la clé clé du dictionnaire d.

Exemple :

d = {"nom": "Dupont", "prénom": "Jean", "âge": 30}
print(d["nom"]) # Accès à la valeur associée à la clé "nom" du dictionnaire d
>> Dupont
print(d[0])
>> KeyError: 0 # Renvoie une erreur car la clé 0 n'existe pas dans le dictionnaire d

2.3.3 Modification d'un dictionnaire par affectation

Il est possible de modifier, ajouter ou supprimer des éléments d'un dictionnaire en utilisant la clé associée à l'élément.

Exemple :

d = {"nom": "Dupont", "prénom": "Jean", "âge": 30}
d["âge"] = 31 # Modifie la valeur associée à la clé "âge" du dictionnaire d
print(d)
>> {'nom': 'Dupont', 'prénom': 'Jean', 'âge': 31}

d["ville"] = "Paris" # Ajoute un nouvel élément au dictionnaire d
print(d)
>> {'nom': 'Dupont', 'prénom': 'Jean', 'âge': 31, 'ville': 'Paris'}

del d["prénom"] # Supprime l'élément associé à la clé "prénom" du dictionnaire d
print(d)
>> {'nom': 'Dupont', 'âge': 31, 'ville': 'Paris'}

2.3.4 Méthodes spécifiques aux dictionnaires

La méthode keys() permet de récupérer la liste des clés d'un dictionnaire.
La méthode values() permet de récupérer la liste des valeurs d'un dictionnaire.
La méthode items() permet de récupérer la liste des couples clé-valeur d'un dictionnaire.

Le fait d'avoir ces éléments sous forme de liste permet de les manipuler plus facilement (par exemple pour les parcourir avec une boucle).

Exemple :

d = {"nom": "Dupont", "prénom": "Jean", "âge": 30}
print(d.keys()) # Récupère la liste des clés du dictionnaire d
>> dict_keys(['nom', 'prénom', 'âge'])

print(d.values()) # Récupère la liste des valeurs du dictionnaire d
>> dict_values(['Dupont', 'Jean', 30])

print(d.items()) # Récupère la liste des couples clé-valeur du dictionnaire d
>> dict_items([('nom', 'Dupont'), ('prénom', 'Jean'), ('âge', 30)])

2.3.5 Parcourir un dictionnaire

Parcourir un dictionnaire avec une boucle for donne ses clés. On s'en sert pour atteindre chaque valeur. items() donne directement les deux à la fois, ce qui évite de revenir chercher la valeur.

Exemple :

d = {"nom": "Dupont", "âge": 30}

for cle in d: # La boucle parcourt les clés
    print(cle, "->", d[cle])
>> nom -> Dupont
>> âge -> 30

for cle, valeur in d.items(): # Les deux à la fois
    print(cle, "->", valeur)
>> nom -> Dupont
>> âge -> 30

2.3.6 Vérifier qu'une clé existe

Accéder à une clé absente arrête le programme sur une KeyError. L'opérateur in permet de regarder avant d'accéder.

in cherche parmi les clés, pas parmi les valeurs : "Dupont" in d répond False alors que "Dupont" est bien dans le dictionnaire.

Exemple :

d = {"nom": "Dupont", "âge": 30}
print("nom" in d)
>> True
print("Dupont" in d)
>> False

✏️ Exercice 8 : Manipulation de p-uplets colorés

Créez un p-uplet nommé couleurs qui contient les éléments suivants : "rouge", "vert", "bleu", "jaune", et "noir". Affichez la première et la dernière couleur du p-uplet.

Utilisez la fonction len() pour afficher la taille du p-uplet couleurs. Affichez la couleur située à la troisième position dans le p-uplet.

Créez un p-uplet contenant uniquement la couleur "blanc". Assurez-vous qu’il est bien reconnu comme un p-uplet.

Créez un deuxième p-uplet nommé nouvelles_couleurs avec les éléments "rose" et "violet". Créez un troisième p-uplet, toutes_couleurs, qui combine couleurs et nouvelles_couleurs. Affichez le p-uplet toutes_couleurs.

Vous savez maintenant manipuler des p-uplets en Python.

Très bien, voici un exercice plus ouvert et ludique qui laisse un peu de place à la créativité :

✏️ Exercice 9 : "Créer mon sandwich parfait"

Consigne : Vous allez créer un programme qui aide à créer un sandwich personnalisé en fonction de différents ingrédients.

Liste des ingrédients disponibles
Créez une liste nommée ingredients_disponibles avec les éléments suivants : "pain", "jambon", "fromage", "salade", "tomate", "mayo", "poulet", "thon", "oeuf", "cornichon".

Création d'une liste de sandwich
Créez une liste vide appelée mon_sandwich.

Choix des ingrédients
Utilisez une boucle pour afficher chaque ingrédient de ingredients_disponibles avec une option de choix, par exemple :

Voulez-vous ajouter pain à votre sandwich ? (oui/non)

Si la réponse est "oui", ajoutez cet ingrédient à mon_sandwich.

Affichage du sandwich final
Affichez un message avec la liste des ingrédients choisis dans mon_sandwich, par exemple :

Votre sandwich contient : [pain, jambon, tomate].

Option d'ajout d'un ingrédient spécial
Proposez à l'utilisateur d’ajouter un ingrédient spécial de son choix qui n’est pas dans la liste initiale. Ajoutez cet ingrédient, le cas échéant.

Affichage final
Affichez à nouveau la liste complète des ingrédients de mon_sandwich après l’ajout de l’ingrédient spécial (si l'utilisateur a accepté).

Vous savez maintenant manipuler des listes en Python.

✏️ Exercice 10 : Cours de Potion avancé

Consigne : Dans cet exercice, vous allez créer une application qui permet à un apprenti sorcier de préparer des potions magiques en combinant divers ingrédients. Chaque ingrédient a des propriétés spécifiques, et certaines combinaisons peuvent produire des effets magiques supplémentaires.

Partie 1 : Définir les Ingrédients

Définissez une liste de dictionnaires pour les ingrédients, où chaque ingrédient a :

Un nom,
Une quantité de base,
Une unité (grammes ou millilitres),
Une propriété magique

Les ingrédients existent avec une quantité de base (dose unitaire) tels que :

Poudre de Lune, 10g, guérison
Écailles de Dragon, 5g, force
Larmes de Licorne, 2mL, invisibilité
Herbes Mystiques, 8g, sérénité
(Vous pouvez ajouter un autre ingrédient à cette liste si vous le souhaitez)

Partie 2 : Calculer les quantités

Définissez une fonction calculer_quantite qui prend deux arguments :

ingredient (type str) : le nom de l'ingrédient,
dose (type int) : le nombre de doses de cet ingrédient à utiliser.

Et retourne un p-uplet contenant :

La quantité totale de l'ingrédient, c'est-à-dire le nombre de doses multiplié par la quantité de base (type int),
L'unité de cette quantité (type str),
L'effet de l'ingrédient (type str).

Cette fonction doit :

Rechercher l'ingrédient dans la liste des ingrédients.
Multiplier la quantité de base de l'ingrédient par le nombre de doses souhaitées.
Retourner la quantité totale, l'unité et l'effet de l'ingrédient.

Aide pour le typage de la fonction :

def calculer_quantite(ingredient: str, dose: int) -> tuple[int, str, str]:
    # Code de la fonction

Partie 3 : Créer la Potion

Définissez une fonction creer_potion qui prend deux listes comme paramètres :

list_ingredients_choisis : une liste de noms d'ingrédients choisis.
list_quantites : une liste des quantités pour chaque ingrédient.

Et retourne un p-uplet contenant :

La quantité totale de la potion en grammes (type int),
La quantité totale de la potion en millilitres (type int),
Tous les effets de la potion (type list[str]).

Cette fonction doit :

Appeler calculer_quantite pour chaque ingrédient sélectionné.
Additionner les quantités en grammes et en millilitres séparément.
Rassembler tous les effets des ingrédients choisis.
Retourner la quantité totale en grammes et en millilitres ainsi que les effets de la potion.

N'oubliez pas de typer correctement la fonction creer_potion !

Partie 4 : Programme principal

Affichez un message de bienvenue pour plonger l'utilisateur dans l'ambiance du laboratoire de potions magiques.
Affichez les ingrédients avec leur quantité de base et leurs effets pour que l’utilisateur sache quoi choisir.
Demandez à l’utilisateur de choisir des ingrédients et de spécifier la quantité en doses pour chaque ingrédient. L’utilisateur doit taper "fin" pour terminer la sélection des ingrédients.
Une fois les choix terminés, appelez la fonction creer_potion, qui retournera les quantités totales en grammes et millilitres ainsi qu'une liste des effets des ingrédients.
Enfin, utilisez les valeurs retournées par creer_potion pour afficher la quantité totale et les effets de la potion.

Résultat attendu :

>> Bienvenue dans le laboratoire de potions magiques !
>> Vous allez pouvoir créer une potion en combinant différents ingrédients.
>> 
>> Ingrédients disponibles :
>> 1. Poudre de Lune, 10 grammes, guérison
>> 2. Écailles de Dragon, 5 grammes, force
>> 3. Larmes de Licorne, 2 millilitres, invisibilité
>> 4. Herbes Mystiques, 8 grammes, sérénité
>> Choisissez un ingrédient (1-4) ou tapez 'fin' pour terminer : 1
>> Entrez la quantité (en doses) : 5
>> Choisissez un ingrédient (1-4) ou tapez 'fin' pour terminer : 3
>> Entrez la quantité (en doses) : 2
>> Choisissez un ingrédient (1-4) ou tapez 'fin' pour terminer : 4
>> Entrez la quantité (en doses) : 1
>> Choisissez un ingrédient (1-4) ou tapez 'fin' pour terminer : fin
>> 
>> Potion créée :
>> Quantité totale : 58g, 4mL
>> Effets : guérison, invisibilité, sérénité

Vous savez maintenant manipuler les types construits ainsi que les fonctions en Python d'un niveau intermédiaire.

✏️ Exercice 10bis : Le Grand Casino

Pour terminer ce chapitre, deux exercices plus conséquents qui mobilisent tout ce que vous avez vu jusqu'ici : conditions, boucles, fonctions et types construits.

Consigne : Vous allez écrire un programme qui permet à un joueur de jouer à deux jeux de casino populaires : la roulette et le blackjack. L'utilisateur pourra parier de l'argent fictif et tenter de gagner ou de perdre en fonction des règles des deux jeux. Vous pourrez amender ensuite le Casino avec d’autres jeux de votre choix.

Etape 1 : Casino

Le joueur démarre avec une somme d'argent fictif (par exemple, 1000€).
Le programme doit proposer à l'utilisateur de choisir entre :

La roulette
Le blackjack
Quitter le casino

Après chaque jeu, le montant d'argent restant doit être mis à jour, en fonction des gains ou pertes du joueur.

Etape 2 : Roulette

Le joueur peut parier un montant et choisir entre :

Parier sur une couleur : rouge ou noir.
Parier sur un nombre : entre 0 et 36.

Un nombre aléatoire entre 0 et 36 est tiré par la roulette.
Si le joueur parie sur la bonne couleur, il double sa mise.
Si le joueur parie sur le bon nombre, il gagne 35 fois sa mise.
Si le pari est perdu, la mise est déduite de l'argent du joueur.

Etape 3 : Blackjack

Le joueur peut parier un montant et reçoit deux cartes.
Le croupier reçoit également deux cartes, dont une seule est visible.
Le joueur doit choisir s'il veut "tirer" une nouvelle carte ou "rester".
Le but est d'avoir une main dont la somme des valeurs ne dépasse pas 21, tout en étant supérieure à celle du croupier.
Le croupier doit continuer à tirer des cartes jusqu'à ce que sa main atteigne un score d'au moins 17.
Le joueur gagne s'il a un meilleur score que le croupier sans dépasser 21.
Si le joueur dépasse 21, il perd automatiquement.
En cas de victoire, le joueur récupère le double de sa mise.

Etape 4 : Fin du jeu

Le jeu continue tant que le joueur a de l'argent.
Le joueur peut choisir de quitter à tout moment.

✏️ Exercice 10ter : Sudoku

Consigne : Vous devez écrire un programme en Python pour résoudre un jeu de Sudoku 4x4. Vous devez afficher la solution du jeu.

Une grille de Sudoku 4x4 peut être représentée comme une liste de listes de cette manière :

_ = None
grid = [
    [1, _, 2, 3],
    [_, _, 1, 4],
    [4, 1, _, _],
    [_, _, 4, 1]
]

Note : Ici, _ représente une case vide.

Règles du Sudoku :

Chaque ligne doit contenir les chiffres de 1 à 4 sans répétition.
Chaque colonne doit contenir les chiffres de 1 à 4 sans répétition.
Chaque sous-grille (2x2) doit contenir les chiffres de 1 à 4 sans répétition.

Question 1 : Vérifier si la grille est correctement remplie
Créez une fonction is_grid_valid(grid) qui vérifie si la grille suit les règles du Sudoku.

Question 2 : Trouver les valeurs possibles pour une cellule
Créez une fonction possible_values(grid, row, col) qui prend une grille et la position d'une case vide (ligne et colonne) et renvoie une liste des valeurs possibles pour cette case selon les règles du Sudoku.

Question 3 : Résoudre la grille Créez une fonction solve(grid) qui essaie de remplir la grille Sudoku avec des valeurs valides. Utilisez une approche de type backtracking (à rechercher sur internet) pour tester différentes possibilités jusqu'à trouver une solution.

Astuce :

Squelette du programme :

_ = None  # Utilisation de _ pour représenter les cases vides (None)

def is_row_valid(grid: list, row: int) -> bool:
    """
    Vérifie si une ligne donnée est valide :
    
    Args:
        grid (list): La grille du Sudoku 4x4.
        row (int): Le numéro de la ligne à vérifier.
    
    Returns:
        bool: True si la ligne est valide, False sinon.
    """
def is_column_valid(grid: list, col: int) -> bool:
    """
    Vérifie si une colonne donnée est valide :
    
    Args:
        grid (list): La grille du Sudoku 4x4.
        col (int): Le numéro de la colonne à vérifier.
    
    Returns:
        bool: True si la colonne est valide, False sinon.
    """
def is_subgrid_valid(grid: list, row: int, col: int) -> bool:
    """
    Vérifie si une sous-grille 2x2 est valide :
    
    Args:
        grid (list): La grille du Sudoku 4x4.
        row (int): Le numéro de la ligne de départ de la sous-grille.
        col (int): Le numéro de la colonne de départ de la sous-grille.
    
    Returns:
        bool: True si la sous-grille est valide, False sinon.
    """
def is_grid_valid(grid: list) -> bool:
    """
    Vérifie si toute la grille est valide en respectant les règles du Sudoku.
    
    Args:
        grid (list): La grille du Sudoku 4x4.
    
    Returns:
        bool: True si toute la grille est valide, False sinon.
    """
def possible_values(grid: list, row: int, col: int) -> list:
    """
    Renvoie la liste des valeurs possibles pour une case vide donnée.
    
    Args:
        grid (list): La grille du Sudoku 4x4.
        row (int): Le numéro de la ligne de la case vide.
        col (int): Le numéro de la colonne de la case vide.
    
    Returns:
        list: Liste des valeurs possibles pour la case vide.
    """
def solve(grid: list) -> bool:
    """
    Résout la grille Sudoku en utilisant une approche de backtracking.
    
    Args:
        grid (list): La grille du Sudoku 4x4.
    
    Returns:
        bool: True si la grille est résolue, False sinon.
    """

✅ Récapitulatif de Chapitre

Définir une fonction

def moyenne(a, b, c):
    return (a + b + c) / 3

Les deux-points ouvrent le bloc, l'indentation le délimite. Sans return, la fonction renvoie None.

Paramètres et arguments

a, b, c Les paramètres, nommés à la définition
moyenne(12, 15, 9) Les arguments, donnés à l'appel

Un argument est affecté au paramètre de même rang, le temps de l'appel.

return ou print()

print() affiche la valeur, puis l'oublie. return la renvoie là où la fonction a été appelée.

total = moyenne(12, 15, 9)

Avec print() à la place de return, total vaudrait None.

Portée des variables

Une variable créée dans une fonction n'existe que le temps de l'appel. Y accéder depuis l'extérieur lève une NameError.

Pour récupérer une valeur calculée dans une fonction, il faut la return.

Annotations de type

def double(n: int) -> int:

Python ne les vérifie pas à l'exécution : elles documentent le code et servent à l'éditeur et aux outils d'analyse.

Pièges à éviter

Une fonction sans return renvoie None.
remove() prend la valeur à supprimer, del sa position.
in cherche parmi les clés d'un dictionnaire, jamais parmi les valeurs.
Un p-uplet ne se modifie pas : pour ajouter ou remplacer, il faut une liste.

P-uplet, liste ou dictionnaire ?

	P-uplet	Tableau (liste)	Dictionnaire
Notation	`(1, 8, 5)`	`[1, 8, 5]`	`{1: "Paul", 2: "Tom", 3: "Nadia"}`
Construction	P-uplet vide : `t = ()` `t1 = (1, 8, 5)`	Liste vide : `L = []` `L1 = [1, 8, 5]`	Dictionnaire vide : `D = {}` `d1 = {1: "Paul", 2: "Tom", 3: "Nadia"}`
Éléments de types différents	Oui `t2 = (1, 'b', True)`	Oui `L2 = [1, 'b', True]`	Les clés peuvent être de tout type, à condition d’être non modifiables : int, str, tuple `d2 = {4: "Léa", 5: "Téo"}`
Lecture du contenu	`t1[0]` renvoie `1` `t1[-1]` renvoie le dernier élément de `t1`, soit `5` `t2[2]` renvoie `True`	`L1[0]` renvoie `1` `L1[-1]` renvoie le dernier élément de `L1`, soit `5` `L2[2]` renvoie `True`	`d1[0]` renvoie une erreur (clé inexistante) `d1[1]` renvoie `'Paul'`
Parcours	`for x in t1:` donne chaque élément	`for x in L1:` donne chaque élément	`for cle in d1:` donne les clés `for cle, valeur in d1.items():` donne les deux
Appartenance	`8 in t1` renvoie `True` `3 in t1` renvoie `False`	`8 in L1` renvoie `True` `3 in L1` renvoie `False`	`1 in d1` renvoie `True` : `in` cherche parmi les clés `'Paul' in d1` renvoie `False`
Concaténation	`t1 + t2` renvoie `(1, 8, 5, 1, 'b', True)`	`L1 + L2` renvoie `[1, 8, 5, 1, 'b', True]`	Non `d1 + d2` renvoie une erreur de type
Modifiable par affectation	Non On peut créer un nouveau p-uplet	Oui Avec l'instruction `L1[2] = 4`, `L1` devient `[1, 8, 4]`	On peut modifier les valeurs, mais pas les clés Exemple : `d1[2] = "Joe"` remplace `'Tom'` par `'Joe'`
Longueur	`len(t1)` renvoie `3`	`len(L1)` renvoie `3`	`len(d1)` renvoie `3`
Méthodes	Aucune en propre	`L.append(x)` ajoute `x` à la fin `L.remove(x)` supprime le premier `x` `L.index(x)` index du premier `x` `L.count(x)` nombre de `x` `L.sort()` trie la liste `L.reverse()` inverse l'ordre	`d.keys()` les clés `d.values()` les valeurs `d.items()` les couples clé-valeur `d.get(cle)` la valeur, sans erreur si absente `d.pop(cle)` supprime et renvoie la valeur

🏋️ Exercices supplémentaires

🏋️ Exercices supplémentaires