Pierre papier ciseaux! – Vrai Python

Qu'est-ce que les ciseaux à papier de roche?

Vous avez peut-être déjà joué aux ciseaux à papier de roche. Peut-être que vous l'avez utilisé pour décider qui paie pour le dîner ou qui obtient le premier choix de joueurs pour une équipe.

Si vous n'êtes pas familier, les ciseaux à papier de roche sont un jeu à la main pour deux joueurs ou plus. Les participants disent «pierre, papier, ciseaux», puis forment simultanément leurs mains sous la forme d'une pierre (un poing), d'un morceau de papier (paume vers le bas) ou d'une paire de ciseaux (deux doigts étendus). Les règles sont simples:

• Roche casse les ciseaux.
• Papier couvre la roche.
• Les ciseaux papier découpé.

Maintenant que vous avez les règles, vous pouvez commencer à réfléchir à la façon dont elles pourraient se traduire en code Python.

Jouez à une seule partie de Rock Paper Scissors en Python

En utilisant la description et les règles ci-dessus, vous pouvez faire un jeu de ciseaux à papier de roche. Avant de plonger, vous devrez importer le module que vous utiliserez pour simuler les choix de l'ordinateur:

Impressionnant! Vous pouvez désormais utiliser les différents outils à l'intérieur Aléatoire pour randomiser les actions de l'ordinateur dans le jeu. Maintenant quoi? Étant donné que vos utilisateurs devront également être en mesure de choisir leurs actions, la première chose logique dont vous avez besoin est un moyen de prendre en compte les entrées de l'utilisateur.

user_action = contribution("Entrez un choix (pierre, papier, ciseaux):")

possible_actions = [[[["Roche", "papier", "les ciseaux"]
action_ordinateur = Aléatoire.choix(possible_actions)

impression(F" nTu choisis user_action, l'ordinateur a choisi action_ordinateur. n")

si user_action == action_ordinateur:
    impression(F"Les deux joueurs sélectionnés user_action. C'est une cravate!")
elif user_action == "Roche":
    si action_ordinateur == "les ciseaux":
        impression("Rock brise les ciseaux! Vous gagnez!")
    autre:
        impression("Le papier recouvre la roche! Vous perdez.")
elif user_action == "papier":
    si action_ordinateur == "Roche":
        impression("Le papier couvre la roche! Vous gagnez!")
    autre:
        impression("Les ciseaux coupent le papier! Vous perdez.")
elif user_action == "les ciseaux":
    si action_ordinateur == "papier":
        impression("Les ciseaux coupent le papier! Vous gagnez!")
    autre:
        impression("Rock brise les ciseaux! Vous perdez.")

importer Aléatoire

user_action = contribution("Entrez un choix (pierre, papier, ciseaux):")
possible_actions = [[[["Roche", "papier", "les ciseaux"]
action_ordinateur = Aléatoire.choix(possible_actions)
impression(F" nTu choisis user_action, l'ordinateur a choisi action_ordinateur. n")

si user_action == action_ordinateur:
    impression(F"Les deux joueurs sélectionnés user_action. C'est une cravate!")
elif user_action == "Roche":
    si action_ordinateur == "les ciseaux":
        impression("Rock brise les ciseaux! Vous gagnez!")
    autre:
        impression("Le papier recouvre la roche! Vous perdez.")
elif user_action == "papier":
    si action_ordinateur == "Roche":
        impression("Le papier couvre la roche! Vous gagnez!")
    autre:
        impression("Les ciseaux coupent le papier! Vous perdez.")
elif user_action == "les ciseaux":
    si action_ordinateur == "papier":
        impression("Les ciseaux coupent le papier! Vous gagnez!")
    autre:
        impression("Rock brise les ciseaux! Vous perdez.")

Jouez à plusieurs jeux d'affilée

Même si un seul jeu de ciseaux à papier rock est super amusant, ne serait-il pas mieux si vous pouviez jouer à plusieurs jeux d'affilée? Boucles sont un excellent moyen de créer des événements récurrents. En particulier, vous pouvez utiliser un tandis que boucle pour jouer indéfiniment:

importer Aléatoire

tandis que Vrai:
    user_action = contribution("Entrez un choix (pierre, papier, ciseaux):")
    possible_actions = [[[["Roche", "papier", "les ciseaux"]
    action_ordinateur = Aléatoire.choix(possible_actions)
    impression(F" nTu choisis user_action, l'ordinateur a choisi action_ordinateur. n")

    si user_action == action_ordinateur:
        impression(F"Les deux joueurs sélectionnés user_action. C'est une cravate!")
    elif user_action == "Roche":
        si action_ordinateur == "les ciseaux":
            impression("Rock brise les ciseaux! Vous gagnez!")
        autre:
            impression("Le papier recouvre la roche! Vous perdez.")
    elif user_action == "papier":
        si action_ordinateur == "Roche":
            impression("Le papier couvre la roche! Vous gagnez!")
        autre:
            impression("Les ciseaux coupent le papier! Vous perdez.")
    elif user_action == "les ciseaux":
        si action_ordinateur == "papier":
            impression("Les ciseaux coupent le papier! Vous gagnez!")
        autre:
            impression("Rock brise les ciseaux! Vous perdez.")

    rejouer = contribution("Rejouer? (O / n):")
    si rejouer.inférieur() ! = "y":
        Pause

Notez les lignes en surbrillance ci-dessus. Il est important de vérifier si l'utilisateur souhaite jouer à nouveau et de Pause s'ils ne le font pas. Sans cette vérification, l'utilisateur serait obligé de jouer jusqu'à ce qu'il termine la console en utilisant Ctrl+C ou une méthode similaire.

Le chèque pour jouer à nouveau est un chèque contre la corde "y". Mais vérifier quelque chose de spécifique comme celui-ci peut rendre plus difficile l'arrêt de la lecture par l'utilisateur. Et si l'utilisateur tape "Oui" ou "non"? La comparaison de chaînes est souvent délicate car vous ne savez jamais ce que l'utilisateur peut entrer. Ils peuvent tous faire des minuscules, des majuscules ou même un mélange des deux.

Voici les résultats de quelques comparaisons de chaînes différentes:

>>> rejouer = "Oui"
>>> rejouer == "n"
Faux
>>> rejouer ! = "y"
Vrai

Hmm. Ce n’est pas ce que vous voulez. L'utilisateur ne sera peut-être pas très heureux s'il entre "Oui" s'attend à jouer à nouveau mais est expulsé du match.

Décrivez une action avec enum.IntEnum

Étant donné que les comparaisons de chaînes peuvent entraîner des problèmes comme vous l’avez vu ci-dessus, il est judicieux de les éviter dans la mesure du possible. L'une des premières choses que votre programme demande, cependant, est que l'utilisateur saisisse une chaîne! Et si l'utilisateur saisissait "Roche" ou "Roche" par erreur? Les majuscules sont importantes, elles ne seront donc pas égales:

>>> impression("Roche" == "Roche")
Faux

Puisque la capitalisation compte, "r" et "R" ne sont pas égaux. Une solution possible serait d'utiliser des nombres à la place. Attribuer un numéro à chaque action peut vous éviter des problèmes:

ROCK_ACTION = 0
PAPER_ACTION = 1
SCISSORS_ACTION = 2

Cela vous permet de référencer différentes actions par leur numéro attribué. Les nombres entiers ne souffrent pas des mêmes problèmes de comparaison que les chaînes, cela pourrait donc fonctionner. Vous pouvez maintenant demander à l'utilisateur de saisir un nombre et de le comparer directement à ces valeurs:

user_input = contribution("Entrez un choix (rock[0], papier[1], les ciseaux[2]): ")
user_action = int(user_input)
si user_action == ROCK_ACTION:
    # Poignée ROCK_ACTION

Car contribution() renvoie une chaîne, vous devez convertir la valeur de retour en un entier en utilisant int (). Ensuite, vous pouvez comparer l'entrée à chacune des actions ci-dessus. Cela fonctionne bien, mais il se peut que vous ayez à nommer correctement les variables pour en garder une trace. Une meilleure façon est d'utiliser enum.IntEnum et définissez votre propre classe d'action!

En utilisant enum.IntEnum vous permet de créer des attributs et de leur attribuer des valeurs similaires à celles indiquées ci-dessus. Cela aide à nettoyer votre code en regroupant les actions dans leurs propres espaces de noms et en rendant le code plus expressif:

de énumération importer IntEnum

classe action(IntEnum):
    Roche = 0
    Papier = 1
    Les ciseaux = 2

Cela crée une coutume action que vous pouvez utiliser pour référencer les différents types d'actions que vous prenez en charge. Il fonctionne en attribuant à chaque attribut qu'il contient à une valeur que vous spécifiez.

Les comparaisons sont toujours simples, et elles sont désormais associées à un nom de classe utile:

>>> action.Roche == action.Roche
Vrai

Étant donné que les valeurs des membres sont identiques, la comparaison est égale. Les noms de classe indiquent également plus clairement que vous souhaitez comparer deux actions.

Vous pouvez même créer un action d'un int:

>>> action.Roche == action(0)
Vrai
>>> action(0)

action regarde la valeur transmise et renvoie la valeur appropriée action. Ceci est utile car vous pouvez désormais prendre en compte l'entrée utilisateur en tant que int et créez un action à partir de cela. Ne vous inquiétez plus de l'orthographe!

Le flux (graphique) de votre programme

Bien que les ciseaux à papier de roche puissent sembler simples, il est important d'examiner attentivement les étapes à suivre pour y jouer afin d'être sûr que votre programme couvre tous les scénarios possibles. Pour tous les projets, même les plus petits, il est utile de créer un organigramme du comportement souhaité et implémentez le code autour de lui. Vous pourriez obtenir un résultat similaire en utilisant une liste à puces, mais il serait plus difficile de capturer des éléments tels que les boucles et la logique conditionnelle.

Les organigrammes ne doivent pas être trop compliqués ni même utiliser du vrai code. Le simple fait de décrire le comportement souhaité à l'avance peut vous aider à résoudre les problèmes avant qu'ils ne surviennent!

Voici un organigramme qui décrit un seul jeu de ciseaux à papier de roche:

Chaque joueur sélectionne une action puis un gagnant est déterminé. Cet organigramme est précis pour un seul jeu tel que vous l’avez codé, mais il n’est pas nécessairement exact pour les jeux réels. Dans la vraie vie, les joueurs sélectionnent leurs actions simultanément plutôt qu'une à la fois comme le suggère l'organigramme.

Dans la version codée, cependant, cela fonctionne car le choix du joueur est caché à l’ordinateur et le choix de l’ordinateur est caché au joueur. Les deux joueurs peuvent faire leurs choix à des moments différents sans affecter l'équité du jeu.

Les organigrammes vous aident à détecter rapidement les erreurs possibles et vous permettent également de voir si vous souhaitez ajouter plus de fonctionnalités. Par exemple, voici un organigramme qui décrit comment jouer à des jeux à plusieurs reprises jusqu'à ce que l'utilisateur décide d'arrêter:

Sans écrire de code, vous pouvez voir que le premier organigramme n'a pas de moyen de jouer à nouveau. Cette approche vous permet de résoudre des problèmes comme ceux-ci avant la programmation, ce qui vous aide à créer un code plus net et plus gérable!

Divisez votre code en fonctions

Maintenant que vous avez décrit le déroulement de votre programme à l'aide d'un organigramme, vous pouvez essayer d'organiser votre code de manière à ce qu'il ressemble davantage aux étapes que vous avez identifiées. Une façon naturelle de procéder consiste à créer une fonction pour chaque étape de l'organigramme. Les fonctions sont un excellent moyen de séparer de plus gros morceaux de code en morceaux plus petits et plus faciles à gérer.

Vous n’avez pas nécessairement besoin de créer une fonction pour que le contrôle conditionnel soit à nouveau lu, mais vous pouvez le faire si vous le souhaitez. Vous pouvez commencer par importer Aléatoire si vous ne l'avez pas déjà fait et définissez votre action classe:

importer Aléatoire
de énumération importer IntEnum

classe action(IntEnum):
    Roche = 0
    Papier = 1
    Les ciseaux = 2

Espérons que tout cela semble familier jusqu'à présent! Voici maintenant le code pour get_user_selection (), qui ne prend aucun argument et renvoie un action:

def get_user_selection():
    user_input = contribution("Entrez un choix (rock[0], papier[1], les ciseaux[2]): ")
    sélection = int(user_input)
    action = action(sélection)
    revenir action

Remarquez comment vous prenez l'entrée utilisateur en tant que int et récupérer un action. Ce long message pour l'utilisateur est cependant un peu fastidieux. Que se passerait-il si vous vouliez ajouter plus d'actions? Vous devrez ajouter encore plus de texte à l'invite.

Au lieu de cela, vous pouvez utiliser une compréhension de liste pour générer une partie de l'entrée:

def get_user_selection():
    les choix = [[[[F"action.Nom[[[[action.valeur]" pour action dans action]
    choix_str = ",".joindre(les choix)
    sélection = int(contribution(F"Entrez un choix (choix_str): "))
    action = action(sélection)
    revenir action

Désormais, vous n'avez plus à vous soucier d'ajouter ou de supprimer des actions à l'avenir! En testant cela, vous pouvez voir comment le code invite l'utilisateur et renvoie une action associée à la valeur d'entrée de l'utilisateur:

>>> get_user_selection()
Entrez un choix (rock[0], papier[1], les ciseaux[2]): 0

Vous avez maintenant besoin d’une fonction pour obtenir l’action de l’ordinateur. Comme get_user_selection (), cette fonction ne doit prendre aucun argument et retourner un action. Parce que les valeurs pour action plage de 0 à 2, vous allez vouloir générer un nombre aléatoire dans cette plage. random.randint () peut vous aider.

random.randint () renvoie une valeur aléatoire entre un minimum et un maximum spécifiés (inclus). Vous pouvez utiliser len () pour vous aider à déterminer la limite supérieure de votre code:

def get_computer_selection():
    sélection = Aléatoire.Randint(0, len(action) - 1)
    action = action(sélection)
    revenir action

Parce que le action les valeurs commencent à compter de 0, et len ​​() commence à compter à partir de 1, il est important de faire len (Action) - 1.

Lorsque vous testez ceci, aucune invite ne s'affiche. Il renverra simplement l'action associée au nombre aléatoire:

>>> get_computer_selection()

Ça a l'air bien! Ensuite, vous avez besoin d'un moyen de déterminer un gagnant. Cette fonction prendra deux arguments, l'action de l'utilisateur et l'action de l'ordinateur. Il n'a pas besoin de renvoyer quoi que ce soit car il affichera simplement le résultat dans la console:

def determine_winner(user_action, action_ordinateur):
    si user_action == action_ordinateur:
        impression(F"Les deux joueurs sélectionnés user_action.Nom. C'est une cravate!")
    elif user_action == action.Roche:
        si action_ordinateur == action.Les ciseaux:
            impression("Rock brise les ciseaux! Vous gagnez!")
        autre:
            impression("Le papier recouvre la roche! Vous perdez.")
    elif user_action == action.Papier:
        si action_ordinateur == action.Roche:
            impression("Le papier couvre la roche! Vous gagnez!")
        autre:
            impression("Les ciseaux coupent le papier! Vous perdez.")
    elif user_action == action.Les ciseaux:
        si action_ordinateur == action.Papier:
            impression("Les ciseaux coupent le papier! Vous gagnez!")
        autre:
            impression("Rock brise les ciseaux! Vous perdez.")

C'est assez similaire à la première comparaison que vous avez utilisée pour déterminer un gagnant. Maintenant, vous pouvez simplement comparer directement action types sans se soucier de ces chaînes embêtantes!

Vous pouvez même tester cela en passant différentes options à determine_winner () et voir ce qui est imprimé:

>>> determine_winner(action.Roche, action.Les ciseaux)
Rock brise les ciseaux! Vous gagnez!

Puisque vous créez une action à partir d'un nombre, que se passerait-il si votre utilisateur tentait de créer une action à partir de 3? N'oubliez pas que le plus grand nombre que vous avez défini jusqu'à présent est 2:

>>> action(3)
ValueError: 3 n'est pas une action valide

Oups! Vous ne voulez pas que cela se produise. Où dans l'organigramme pouvez-vous ajouter une logique pour vous assurer que l'utilisateur a saisi un choix valide?

Il est judicieux d'inclure la vérification immédiatement après que l'utilisateur a fait son choix:

Si l’utilisateur entre une valeur non valide, vous répétez l’étape pour obtenir le choix de l’utilisateur. La seule exigence réelle pour la sélection de l’utilisateur est qu’elle se situe entre 0 et 2, inclus. Si l'entrée de l'utilisateur est en dehors de cette plage, alors un ValueError l'exception sera soulevée. Pour éviter d'afficher le message d'erreur par défaut à l'utilisateur, vous pouvez manipuler l'éxéption.

Maintenant que vous avez défini quelques fonctions qui reflètent les étapes de votre organigramme, votre logique de jeu est beaucoup plus organisée et compacte. C'est tout votre tandis que la boucle doit contenir maintenant:

tandis que Vrai:
    essayer:
        user_action = get_user_selection()
    sauf ValueError comme e:
        range_str = F"[0[0[0[0len(action) - 1]"
        impression(F"Sélection non valide. Entrez une valeur dans la plage range_str")
        continuer

    action_ordinateur = get_computer_selection()
    determine_winner(user_action, action_ordinateur)

    rejouer = contribution("Rejouer? (O / n):")
    si rejouer.inférieur() ! = "y":
        Pause

Cela n'a-t-il pas l'air beaucoup plus propre? Remarquez comment si l'utilisateur ne parvient pas à sélectionner une plage valide, vous utilisez continuer plutôt que Pause. Cela permet au code de passer à l'itération suivante de la boucle plutôt que d'en sortir.

Ciseaux à papier de roche… Lizard Spock

Si vous avez vu La théorie du Big Bang, alors vous connaissez peut-être les ciseaux à papier rock Spock. Sinon, voici un diagramme illustrant le jeu et les règles déterminant le gagnant:

Vous pouvez utiliser les mêmes outils que vous avez appris ci-dessus pour implémenter ce jeu. Par exemple, vous pouvez ajouter à action et créez des valeurs pour le lézard et Spock. Ensuite, il vous suffirait de modifier get_user_selection () et get_computer_selection () pour intégrer ces options. Mise à jour determine_winner (), cependant, serait beaucoup plus de travail.

Au lieu d'ajouter beaucoup de si … elif … autre à votre code, vous pouvez utiliser un dictionnaire pour vous aider à montrer les relations entre les actions. Les dictionnaires sont un excellent moyen de montrer un relation clé-valeur. Dans ce cas, le clé peut être une action, comme des ciseaux, et le valeur peut être une liste d'actions qu'il bat.

Alors, à quoi cela ressemblerait-il pour votre determine_winner () avec seulement trois options? Eh bien, chacun action ne peut battre qu'un autre action, donc la liste ne contiendrait qu'un seul élément. Voici à quoi ressemblait votre code avant:

def determine_winner(user_action, action_ordinateur):
    si user_action == action_ordinateur:
        impression(F"Les deux joueurs sélectionnés user_action.Nom. C'est une cravate!")
    elif user_action == action.Roche:
        si action_ordinateur == action.Les ciseaux:
            impression("Rock brise les ciseaux! Vous gagnez!")
        autre:
            impression("Le papier recouvre la roche! Vous perdez.")
    elif user_action == action.Papier:
        si action_ordinateur == action.Roche:
            impression("Le papier couvre la roche! Vous gagnez!")
        autre:
            impression("Les ciseaux coupent le papier! Vous perdez.")
    elif user_action == action.Les ciseaux:
        si action_ordinateur == action.Papier:
            impression("Les ciseaux coupent le papier! Vous gagnez!")
        autre:
            impression("Rock brise les ciseaux! Vous perdez.")

Maintenant, au lieu de comparer à chacun action, vous pouvez avoir un dictionnaire qui décrit les conditions de victoire:

def determine_winner(user_action, action_ordinateur):
    victoires = 
        action.Roche: [[[[action.Les ciseaux],  # Rock bat les ciseaux
        action.Papier: [[[[action.Roche],  # Le papier bat le rock
        action.Les ciseaux: [[[[action.Papier]  # Les ciseaux battent le papier
    

    défaites = victoires[[[[user_action]
    si user_action == action_ordinateur:
        impression(F"Les deux joueurs sélectionnés user_action.Nom. C'est une cravate!")
    elif action_ordinateur dans défaites:
        impression(F"user_action.Nom    Beats action_ordinateur.Nom! Vous gagnez!")
    autre:
        impression(F"action_ordinateur.Nom    Beats user_action.Nom! Tu as perdu.")

Vous faites toujours la même chose qu'avant et vérifiez d'abord l'état de l'attache. Mais au lieu de comparer chacun action, vous comparez plutôt l'action que le user_input bat contre le action_ordinateur. Étant donné que la paire clé-valeur est une liste, vous pouvez utiliser l'opérateur d'appartenance dans pour vérifier si un élément y réside.

Puisque vous n'utilisez plus longtemps si … elif … autre affirmations, il est relativement simple d’ajouter des vérifications pour ces nouvelles actions. Vous pouvez commencer par ajouter un lézard et Spock à action:

classe action(IntEnum):
    Roche = 0
    Papier = 1
    Les ciseaux = 2
    Lézard = 3
    Spock = 4

Ensuite, ajoutez toutes les relations de victoire du diagramme. Assurez-vous de le faire en dessous action pour que victoires pourra tout référencer dans action:

victoires = 
    action.Les ciseaux: [[[[action.Lézard, action.Papier],
    action.Papier: [[[[action.Spock, action.Roche],
    action.Roche: [[[[action.Lézard, action.Les ciseaux],
    action.Lézard: [[[[action.Spock, action.Papier],
    action.Spock: [[[[action.Les ciseaux, action.Roche]

Remarquez comment maintenant chacun action a une liste contenant deux éléments qu'il bat. Dans la mise en œuvre de base des ciseaux à papier de roche, il n'y avait qu'un seul élément.

Parce que tu as écrit intentionnellement get_user_selection () pour s'adapter aux nouvelles actions, vous n'avez rien à changer à ce code. La même chose est vraie pour get_computer_selection (). Depuis la durée de action a changé, la plage de nombres aléatoires changera également.

Regardez à quel point le code est maintenant plus court et plus gérable! Pour voir le code complet de votre programme complet, développez la zone ci-dessous.

importer Aléatoire
de énumération importer IntEnum

classe action(IntEnum):
    Roche = 0
    Papier = 1
    Les ciseaux = 2
    Lézard = 3
    Spock = 4

victoires = 
    action.Les ciseaux: [[[[action.Lézard, action.Papier],
    action.Papier: [[[[action.Spock, action.Roche],
    action.Roche: [[[[action.Lézard, action.Les ciseaux],
    action.Lézard: [[[[action.Spock, action.Papier],
    action.Spock: [[[[action.Les ciseaux, action.Roche]


def get_user_selection():
    les choix = [[[[F"action.Nom[[[[action.valeur]" pour action dans action]
    choix_str = ",".joindre(les choix)
    sélection = int(contribution(F"Entrez un choix (choix_str): "))
    action = action(sélection)
    revenir action

def get_computer_selection():
    sélection = Aléatoire.Randint(0, len(action) - 1)
    action = action(sélection)
    revenir action

def determine_winner(user_action, action_ordinateur):
    défaites = victoires[[[[user_action]
    si user_action == action_ordinateur:
        impression(F"Les deux joueurs sélectionnés user_action.Nom. C'est une cravate!")
    elif action_ordinateur dans défaites:
        impression(F"user_action.Nom    Beats action_ordinateur.Nom! Vous gagnez!")
    autre:
        impression(F"action_ordinateur.Nom    Beats user_action.Nom! Tu as perdu.")

tandis que Vrai:
    essayer:
        user_action = get_user_selection()
    sauf ValueError comme e:
        range_str = F"[0[0[0[0len(action) - 1]"
        impression(F"Sélection non valide. Entrez une valeur dans la plage range_str")
        continuer

    action_ordinateur = get_computer_selection()
    determine_winner(user_action, action_ordinateur)

    rejouer = contribution("Rejouer? (O / n):")
    si rejouer.inférieur() ! = "y":
        Pause

C'est ça! Vous avez implémenté des ciseaux à papier de roche lézard Spock dans du code Python. Vérifiez à nouveau pour vous assurer de ne rien manquer et lancez-le.

Conclusion

Toutes nos félicitations! Vous venez de terminer votre premier jeu Python! Vous savez maintenant comment créer des ciseaux à papier de roche à partir de zéro et vous êtes en mesure d'augmenter le nombre d'actions possibles dans votre jeu avec un minimum d'effort.

Dans ce didacticiel, vous avez appris à:

• Codez le vôtre Pierre papier ciseaux Jeu
• Prenez en compte les commentaires des utilisateurs avec contribution()
• Jouez à plusieurs jeux d'affilée en utilisant un tandis que boucle
• Nettoyez votre code avec Enum et les fonctions
• Décrivez des règles plus complexes avec un dictionnaire

Ces outils continueront de vous aider tout au long de vos nombreuses aventures de programmation. Si vous avez des questions, n'hésitez pas à nous contacter dans la section commentaires ci-dessous.