Le guide du débutant pour la tortue Python – Real Python

Quand j'étais enfant, j'avais l'habitude d'apprendre Logo, un langage de programmation qui impliquait une tortue que vous pouviez déplacer sur l'écran avec seulement quelques commandes. Je me souviens de me sentir comme un génie informatique alors que je contrôlais ce petit objet sur mon écran, et c'est ce qui m'a d'abord intéressé à la programmation. Le Python tortue La bibliothèque est livrée avec une fonctionnalité interactive similaire qui donne aux nouveaux programmeurs un aperçu de ce que c'est que de travailler avec Python.

Dans ce tutoriel, vous allez:

• Comprendre ce que le Python tortue la bibliothèque est
• Apprendre comment régler tortue sur votre ordinateur
• Programme avec le Python tortue bibliothèque
• Saisir quelques concepts importants de Python et tortue commandes
• Développer un jeu court mais divertissant utilisant ce que vous avez appris

Si vous êtes un débutant en Python, ce didacticiel vous aidera à faire vos premiers pas dans le monde de la programmation à l'aide de Python. tortue bibliothèque!

Apprendre à connaître le Python tortue Bibliothèque

tortue est une bibliothèque Python préinstallée qui permet aux utilisateurs de créer des images et des formes en leur fournissant un canevas virtuel. Le stylet à l'écran que vous utilisez pour dessiner est appelé tortue et c'est ce qui donne son nom à la bibliothèque. En bref, le Python tortue La bibliothèque aide les nouveaux programmeurs à se faire une idée de ce qu'est la programmation avec Python d'une manière amusante et interactive.

tortue est principalement utilisé pour initier les enfants au monde des ordinateurs. C'est une manière simple mais polyvalente de comprendre les concepts de Python. Cela en fait un excellent moyen pour les enfants de faire leurs premiers pas dans la programmation Python. Cela étant dit, le Python tortue la bibliothèque n'est pas réservée aux tout-petits! Il s'est également révélé extrêmement utile pour les adultes qui s'essaient à Python, ce qui le rend idéal pour les débutants en Python.

Avec le Python tortue bibliothèque, vous pouvez dessiner et créer différents types de formes et d'images. Voici un exemple des types de dessins que vous pouvez réaliser avec tortue:

Cool, non? Ceci n'est qu'un des nombreux dessins différents que vous pouvez créer à l'aide de Python tortue bibliothèque. La plupart des développeurs utilisent tortue pour dessiner des formes, créer des dessins et créer des images. D'autres utilisent tortue pour créer des mini-jeux et des animations, tout comme celui que vous avez vu ci-dessus.

Commencer avec tortue

Avant de continuer, vous devez effectuer deux opérations importantes pour tirer le meilleur parti de ce didacticiel:

1. Environnement Python: Assurez-vous que vous connaissez bien votre environnement de programmation. Vous pouvez utiliser des applications comme IDLE ou Jupyter Notebook pour programmer avec tortue. Cependant, si vous n'êtes pas à l'aise avec eux, vous pouvez programmer avec le REPL, que vous utiliserez dans ce didacticiel.

2. Version Python: Assurez-vous que la version 3 de Python est installée sur votre ordinateur. Sinon, vous pouvez le télécharger à partir du site Web Python. Pour obtenir de l'aide sur la configuration, consultez le Guide d'installation et de configuration de Python 3.

La bonne chose à propos de tortue c'est qu'il s'agit d'une bibliothèque intégrée, vous n'avez donc pas besoin d'installer de nouveaux packages. Tout ce que vous avez à faire est d'importer la bibliothèque dans votre environnement Python, qui dans ce cas serait le REPL. Une fois que vous avez ouvert votre application REPL, vous pouvez exécuter Python 3 dessus en tapant la ligne de code suivante:

Cela appelle Python 3 dans votre application REPL et ouvre l'environnement pour vous.

Avant de commencer votre programmation Python, vous devez comprendre ce qu'est un bibliothèque est. Dans le monde non informatique, une bibliothèque est un endroit où sont stockés différents types de livres. Vous pouvez accéder à ces livres à tout moment, prendre toutes les informations dont vous avez besoin et les retourner au même endroit.

Dans le monde informatique, une bibliothèque fonctionne de la même manière. Par définition, un bibliothèque est un ensemble de fonctions et de méthodes importantes auxquelles vous pouvez accéder pour faciliter votre programmation. Le Python tortue La bibliothèque contient toutes les méthodes et fonctions dont vous aurez besoin pour créer vos images. Pour accéder à une bibliothèque Python, vous devez l'importer dans votre environnement Python, comme ceci:

Maintenant que vous avez tortue dans votre environnement Python, vous pouvez commencer la programmation avec. tortue est une bibliothèque graphique, ce qui signifie que vous devrez créer une fenêtre distincte (appelée écran) pour exécuter chaque commande de dessin. Vous pouvez créer cet écran en initialisant une variable pour celui-ci.

En Python, vous utilisez les variables pour stocker des informations que vous utiliserez plus tard dans votre programme. Vous initialiser une variable lorsque vous lui affectez une valeur de départ. La valeur de la variable n'étant pas constante, elle peut changer plusieurs fois au cours de l'exécution de votre programme.

Maintenant, pour ouvrir le tortue , vous initialisez une variable pour celle-ci de la manière suivante:

>>> s = tortue.getscreen()

Vous devriez voir une fenêtre séparée s'ouvrir:

Cette fenêtre est appelée écran. C'est là que vous pouvez voir la sortie de votre code. La petite forme triangulaire noire au milieu de l'écran est appelée tortue.

Ensuite, vous initialisez la variable t, que vous utiliserez ensuite tout au long du programme pour faire référence à la tortue:

>>> t = tortue.Tortue()

Tout comme pour l'écran, vous pouvez également donner à cette variable un autre nom comme une ou Jeanne ou même my_turtle, mais dans ce cas, vous vous en tiendrez t.

Vous avez maintenant votre écran et votre tortue. L'écran agit comme une toile, tandis que la tortue agit comme un stylo. Vous pouvez programmer la tortue pour qu'elle se déplace sur l'écran. La tortue a certaines caractéristiques modifiables, comme la taille, la couleur et la vitesse. Il pointe toujours dans une direction spécifique et se déplacera dans cette direction, sauf indication contraire:

• Quand il est en haut, cela signifie qu'aucune ligne ne sera tracée lors de son déplacement.
• Quand il est vers le bas, cela signifie qu'une ligne sera tracée lors de son déplacement.

Dans la section suivante, vous allez explorer les différentes façons de programmer avec Python tortue bibliothèque.

Programmation avec tortue

La première chose que vous apprendrez en matière de programmation avec Python tortue bibliothèque est de savoir comment faire bouger la tortue dans la direction où vous voulez qu'elle aille. Ensuite, vous apprendrez à personnaliser votre tortue et son environnement. Enfin, vous apprendrez quelques commandes supplémentaires avec lesquelles vous pouvez effectuer certaines tâches spéciales.

Déplacer la tortue

Il y a quatre directions dans lesquelles une tortue peut se déplacer:

• Vers l'avant
• En arrière
• La gauche
• Droite

La tortue bouge .vers l'avant() ou .backward () dans la direction à laquelle il fait face. Vous pouvez changer cette direction en la tournant .la gauche() ou .droite() d'un certain degré. Vous pouvez essayer chacune de ces commandes comme ceci:

>>> t.droite(90)
>>> t.vers l'avant(100)
>>> t.la gauche(90)
>>> t.en arrière(100)

Lorsque vous exécutez ces commandes, la tortue tourne à droite de quatre-vingt-dix degrés, avance de cent unités, tourne à gauche de quatre-vingt-dix degrés et recule de cent unités. Vous pouvez voir à quoi cela ressemble dans l'image ci-dessous:

Vous pouvez également utiliser les versions raccourcies de ces commandes:

• t.rt () au lieu de t.right ()
• t.fd () au lieu de t.forward ()
• t.lt () au lieu de t.left ()
• t.bk () au lieu de t. en arrière ()

Vous pouvez également tracer une ligne de votre position actuelle vers toute autre position arbitraire sur l'écran. Cela se fait à l'aide de coordonnées:

L'écran est divisé en quatre quadrants. Le point où la tortue est initialement positionnée au début de votre programme est (0,0). C'est appelé Accueil. Pour déplacer la tortue vers une autre zone de l'écran, vous utilisez .aller à() et entrez les coordonnées comme ceci:

Votre sortie ressemblera à ceci:

Vous avez tracé une ligne entre votre position actuelle et le point (100 100) sur l'écran.

Pour ramener la tortue à sa position d'origine, vous tapez ce qui suit:

C'est comme une commande de raccourci qui renvoie la tortue au point (0,0). C'est plus rapide que de taper t.goto (0,0).

Dessiner une forme

Maintenant que vous connaissez les mouvements de la tortue, vous pouvez passer à des formes réelles. Vous pouvez commencer par dessiner polygones car ils sont tous constitués de lignes droites reliées à certains angles. Voici un exemple que vous pouvez essayer:

>>> t.fd(100)
>>> t.rt(90)
>>> t.fd(100)
>>> t.rt(90)
>>> t.fd(100)
>>> t.rt(90)
>>> t.fd(100)

Votre sortie ressemblera à ceci:

Bien joué! Vous venez de dessiner un carré. De cette façon, la tortue peut être programmée pour créer différentes formes et images.

Maintenant, essayez de dessiner un rectangle, en utilisant ce code comme modèle. N'oubliez pas que dans un rectangle, les quatre côtés ne sont pas égaux. Vous devrez modifier le code en conséquence. Une fois que vous avez fait cela, vous pouvez même essayer de créer d'autres polygones en augmentant le nombre de côtés et en changeant les angles.

Dessin de figures prédéfinies

Supposons que vous vouliez dessiner un cercle. Si vous essayez de le dessiner de la même manière que vous avez dessiné le carré, ce serait extrêmement fastidieux, et vous devriez passer beaucoup de temps juste pour cette forme. Heureusement, le Python tortue bibliothèque fournit une solution pour cela. Vous pouvez utiliser une seule commande pour dessiner un cercle:

Vous obtiendrez une sortie comme celle-ci:

Le nombre entre parenthèses est le rayon du cercle. Vous pouvez augmenter ou diminuer la taille du cercle en modifiant la valeur de son rayon.

De la même manière, vous pouvez également dessiner un point, qui n'est rien d'autre qu'un cercle rempli. Tapez cette commande:

Vous obtiendrez un cercle rempli comme celui-ci:

Le nombre entre parenthèses est le diamètre du point. Tout comme avec le cercle, vous pouvez augmenter ou diminuer la taille du point en modifiant la valeur de son diamètre.

Excellent travail jusqu'à présent! Vous avez appris à déplacer la tortue et à créer différentes formes avec elle. Dans les sections suivantes, vous verrez comment personnaliser votre tortue et son environnement, en fonction de vos besoins.

Changer la couleur de l'écran

Par défaut, tortue ouvre toujours un écran avec un fond blanc. Cependant, vous pouvez modifier Couleur de l'écran à tout moment en utilisant la commande suivante:

Vous pouvez remplacer "bleu" avec toute autre couleur. Essayer "vert" ou "rouge". Vous obtiendrez un résultat comme celui-ci:

Vous pouvez utiliser une variété de couleurs pour votre écran en tapant simplement leur numéro de code hexadécimal. Pour en savoir plus sur l'utilisation de différentes couleurs, consultez le Python tortue documentation de la bibliothèque.

Changer le titre de l'écran

Parfois, vous souhaiterez peut-être modifier Titre de votre écran. Vous pouvez le rendre plus personnel, comme "Mon programme Tortue"ou mieux adapté à ce sur quoi vous travaillez, comme "Dessiner des formes avec une tortue". Vous pouvez changer le titre de votre écran à l'aide de cette commande:

>>> s.Titre("Mon programme Tortue")

Votre barre de titre affichera maintenant ceci:

De cette façon, vous pouvez modifier le titre de votre écran selon vos préférences.

Changer la taille de la tortue

Vous pouvez augmenter ou diminuer la Taille de la tortue à l'écran pour l'agrandir ou la réduire. Cela modifie uniquement la taille de la forme sans affecter la sortie du stylet lorsqu'il dessine à l'écran. Essayez de taper les commandes suivantes:

>>> t.façonner(1,5,dix)
>>> t.façonner(dix,5,1)
>>> t.façonner(1,dix,5)
>>> t.façonner(dix,1,5)

Vos sorties ressembleront à ceci:

Les chiffres donnés sont les paramètres pour la taille de la tortue:

• Longueur extensible
• Largeur extensible
• Largeur du contour

Vous pouvez les modifier selon vos préférences. Dans l'exemple donné ci-dessus, vous pouvez voir une différence visible dans l'apparence de la tortue. Pour plus d'informations sur la façon dont vous pouvez modifier la taille de la tortue, consultez le Python tortue documentation de la bibliothèque.

Modification de la taille du stylo

La commande précédente a uniquement modifié la taille de la forme de la tortue. Cependant, parfois, vous devrez peut-être augmenter ou diminuer la épaisseur de votre stylo. Vous pouvez le faire en utilisant la commande suivante:

>>> t.penser(5)
>>> t.vers l'avant(100)

Il en résulte un résultat comme celui-ci:

Comme vous pouvez le voir, la taille de votre stylo est maintenant cinq fois la taille d'origine (qui était une). Essayez de dessiner d'autres lignes de différentes tailles et comparez la différence d'épaisseur entre elles.

Changer la couleur de la tortue et du stylo

Lorsque vous ouvrez un nouvel écran pour la première fois, la tortue commence comme une figure noire et dessine à l'encre noire. En fonction de vos besoins, vous pouvez faire deux choses:

• Changez la couleur de la tortue: Cela change la couleur de remplissage.
• Changez la couleur du stylo: Cela change le contour ou la couleur de l'encre.

Vous pouvez même choisir les deux si vous le souhaitez. Avant de changer les couleurs, augmentez la taille de votre tortue pour vous aider à voir plus clairement la différence de couleur. Tapez ce code:

>>> t.façonner(3,3,3)

Maintenant, pour changer la couleur de la tortue (ou le remplissage), vous tapez ce qui suit:

>>> t.la couleur de remplissage("rouge")

Votre tortue ressemblera à ceci:

Pour modifier la couleur du stylo (ou le contour), vous tapez ce qui suit:

>>> t.couleur de crayon("vert")

Votre tortue ressemblera à ceci:

Pour modifier la couleur des deux, vous tapez ce qui suit:

>>> t.Couleur("vert", "rouge")

Votre tortue ressemblera à ceci:

Ici, la première couleur est pour le stylo et la seconde pour le remplissage. Notez que la modification de la couleur du stylo et du remplissage modifie également la couleur de la tortue à l'écran en conséquence.

Remplir une image

La coloration d'une image la rend généralement plus belle, n'est-ce pas? Le Python tortue bibliothèque vous donne la possibilité d'ajouter de la couleur à vos dessins. Essayez de taper le code suivant et voyez ce qui se passe:

>>> t.begin_fill()
>>> t.fd(100)
>>> t.lt(120)
>>> t.fd(100)
>>> t.lt(120)
>>> t.fd(100)
>>> t.end_fill()

Lorsque vous exécutez ce code, vous obtiendrez un triangle rempli avec une couleur unie, comme ceci:

Lorsque vous utilisez .beginfill (), vous dites à votre programme que vous allez dessiner une forme fermée qui devra être remplie. Ensuite, vous utilisez .endfill () pour indiquer que vous avez fini de créer votre forme et qu'elle peut maintenant être remplie.

Changer la forme de la tortue

La forme initiale de la tortue n'est pas vraiment une tortue, mais une figure triangulaire. Cependant, vous pouvez changer l'apparence de la tortueet vous disposez de quelques options pour ce faire. Vous pouvez en voir certains en tapant les commandes suivantes:

>>> t.forme("tortue")
>>> t.forme("La Flèche")
>>> t.forme("cercle")

La forme de la tortue changera en conséquence, comme ceci:

Vous avez également quelques autres options que vous pouvez essayer:

• Carré
• La Flèche
• Cercle
• Tortue
• Triangle
• Classique

La forme classique est la forme originale. Découvrez le Python tortue documentation de la bibliothèque pour en savoir plus sur les types de formes que vous pouvez utiliser.

Modification de la vitesse du stylet

La tortue se déplace généralement à un rythme modéré. Si vous voulez diminuer ou augmenter le la vitesse pour que votre tortue se déplace plus lentement ou plus rapidement, vous pouvez le faire en tapant ce qui suit:

>>> t.la vitesse(1)
>>> t.vers l'avant(100)
>>> t.la vitesse(dix)
>>> t.vers l'avant(100)

Ce code diminuera d'abord la vitesse et fera avancer la tortue, puis augmentera la vitesse et fera de nouveau avancer la tortue, comme ceci:

La vitesse peut être un nombre compris entre 0 (la vitesse la plus lente) et 10 (la vitesse la plus élevée). Vous pouvez jouer avec votre code pour voir à quelle vitesse ou quelle vitesse la tortue ira.

Personnalisation sur une seule ligne

Supposons que vous souhaitiez définir les caractéristiques de votre tortue comme suit:

• Couleur du stylo: violet
• La couleur de remplissage: Orange
• Taille du stylo: dix
• Vitesse du stylo: 9

D'après ce que vous venez d'apprendre, le code devrait ressembler à ceci:

>>> t.couleur de crayon("violet")
>>> t.la couleur de remplissage("Orange")
>>> t.penser(dix)
>>> t.la vitesse(9)
>>> t.begin_fill()
>>> t.cercle(90)
>>> t.end_fill()

C'est assez long, mais pas si mal, non?

Maintenant, imaginez si vous aviez dix tortues différentes. Changer toutes leurs caractéristiques serait extrêmement fastidieux pour vous! La bonne nouvelle est que vous pouvez réduire votre charge de travail en modifiant les paramètres dans une seule ligne de code, comme ceci:

>>> t.stylo(couleur de crayon="violet", la couleur de remplissage="Orange", penser=dix, la vitesse=9)
>>> t.begin_fill()
>>> t.cercle(90)
>>> t.end_fill()

Cela vous donnera un résultat comme celui-ci:

Cette seule ligne de code a changé la plume entière, sans que vous ayez à changer chaque caractéristique individuellement. Pour en savoir plus sur cette commande, consultez le Python tortue documentation de la bibliothèque.

Bon travail! Maintenant que vous avez appris à personnaliser votre tortue et l'écran, jetez un œil à quelques autres commandes importantes qui sont requises lors du dessin avec Python tortue bibliothèque.

Ramasser le stylo de haut en bas

Parfois, vous pouvez déplacer votre tortue vers un autre point de l'écran sans rien dessiner sur l'écran lui-même. Pour ce faire, vous utilisez .penup (). Ensuite, lorsque vous souhaitez recommencer à dessiner, vous utilisez .pendown (). Essayez-le en utilisant le code que vous avez utilisé précédemment pour dessiner un carré. Essayez de taper le code suivant:

>>> t.fd(100)
>>> t.rt(90)
>>> t.penup()
>>> t.fd(100)
>>> t.rt(90)
>>> t.pendre()
>>> t.fd(100)
>>> t.rt(90)
>>> t.penup()
>>> t.fd(100)
>>> t.pendre()

Lorsque vous exécutez ce code, votre sortie ressemblera à ceci:

Ici, vous avez obtenu deux lignes parallèles au lieu d'un carré en ajoutant des commandes supplémentaires entre le programme d'origine.

Annulation des modifications

Quelle que soit votre prudence, il est toujours possible de faire une erreur. Mais ne vous inquiétez pas! Le Python tortue bibliothèque vous donne la possibilité d'annuler ce que vous avez fait. Si tu veux annuler la toute dernière chose que vous avez faite, puis tapez ce qui suit:

Cela annule la dernière commande que vous avez exécutée. Si vous souhaitez annuler vos trois dernières commandes, vous devez taper t.undo () trois fois.

Effacer l'écran

En ce moment, vous en avez probablement beaucoup sur votre écran depuis que vous avez commencé ce didacticiel. Pour faire de la place pour plus, tapez simplement la commande suivante:

Cela nettoiera votre écran afin que vous puissiez continuer à dessiner. Notez ici que vos variables ne changeront pas et que la tortue restera dans la même position. Si vous avez d'autres tortues sur votre écran autres que la tortue d'origine, leurs dessins ne seront pas effacés à moins que vous ne les appeliez spécifiquement dans votre code.

Réinitialisation de l'environnement

Vous avez également la possibilité de commencer sur une table rase avec un réinitialiser commander. L'écran disparaîtra et les paramètres de la tortue seront tous restaurés à leurs paramètres par défaut. Il vous suffit de taper la commande suivante:

Cela efface l'écran et ramène la tortue à sa position d'origine. Vos paramètres par défaut, comme la taille, la forme, la couleur et d'autres fonctionnalités de la tortue, seront également restaurés.

Maintenant que vous avez appris les principes de base de la programmation avec Python tortue bibliothèque, vous découvrirez quelques fonctionnalités bonus que vous voudrez peut-être utiliser lors de la programmation.

Laisser un tampon

Vous avez la possibilité de laisser un timbre de votre tortue sur l'écran, qui n'est rien d'autre qu'une empreinte de la tortue. Essayez de taper ce code pour voir comment cela fonctionne:

>>> t.timbre()
8
>>> t.fd(100)
>>> t.timbre()
9
>>> t.fd(100)

Votre sortie ressemblera à ceci:

Les chiffres qui apparaissent sont l'emplacement de la tortue ou ID de tampon. Maintenant, si vous souhaitez supprimer un tampon particulier, utilisez simplement ce qui suit:

Cela effacera celui avec l'ID de tampon de 8.

Clonage de votre tortue

Parfois, vous devrez peut-être avoir plus d'une tortue sur votre écran. Vous en verrez un exemple plus loin dans le projet final. Pour l'instant, vous pouvez obtenir une autre tortue en clonage votre tortue actuelle dans votre environnement. Essayez d'exécuter ce code pour créer une tortue clone, c, puis déplacez les deux tortues à l'écran:

>>> c = t.cloner()
>>> t.Couleur("magenta")
>>> c.Couleur("rouge")
>>> t.cercle(100)
>>> c.cercle(60)

La sortie ressemblera à ceci:

Impressionnant!

Maintenant que vous avez une idée de quelques commandes importantes de Python tortue bibliothèque, vous êtes prêt à passer à quelques autres concepts que vous devrez comprendre. Ces concepts sont indispensables pour la programmation dans n'importe quel langage.

Utilisation de boucles et d'instructions conditionnelles

Lorsque vous entrez dans la programmation de niveau supérieur, vous vous retrouverez à utiliser boucles et instructions conditionnelles très souvent. C'est pourquoi, dans cette section, vous allez parcourir quelques programmes tortue qui utilisent ces types de commandes. Cela vous donnera une approche pratique pour comprendre ces concepts. Avant de commencer, cependant, voici trois définitions à retenir:

1. Boucles sont un ensemble d'instructions qui sont répétées en continu jusqu'à ce qu'une condition particulière soit satisfaite.
2. Expressions conditionnelles effectuer une certaine tâche en fonction d'une condition remplie.
3. Indentations sont utilisés pour définir des blocs de code, en particulier lors de l'utilisation de boucles et d'instructions conditionnelles. En général, vous créez une indentation en appuyant sur le Languette touche du clavier.

Maintenant, allons-y et explorons ces commandes!

pour Boucles

Vous souvenez-vous du programme que vous avez utilisé pour créer un carré? Vous avez dû répéter la même ligne de code quatre fois, comme ceci:

>>> t.fd(100)
>>> t.rt(90)
>>> t.fd(100)
>>> t.rt(90)
>>> t.fd(100)
>>> t.rt(90)
>>> t.fd(100)
>>> t.rt(90)

Une manière beaucoup plus courte de le faire consiste à pour boucle. Essayez d'exécuter ce code:

>>> pour je dans intervalle(4):
...     t.fd(100)
...     t.rt(90)

Ici le je Est comme un compteur qui part de zéro et continue d'augmenter de 1. Quand vous dites à portée (4), vous dites au programme que la valeur de cette je devrait être inférieur à 4. Il mettra fin au programme avant je atteint 4.

Voici une description du fonctionnement du programme:

1. À i = 0, la tortue avance de 100 unités puis tourne de 90 degrés vers la droite.
2. À i = 0 + 1 = 1, la tortue avance de 100 unités puis tourne de 90 degrés vers la droite.
3. À i = 1 + 1 = 2, la tortue avance de 100 unités puis tourne de 90 degrés vers la droite.
4. À i = 2 + 1 = 3, la tortue avance de 100 unités puis tourne de 90 degrés vers la droite.

La tortue sortira alors de la boucle. Pour vérifier la valeur de je, tapez je puis appuyez sur la touche Entrer clé. Vous obtiendrez la valeur de je égal à 3:

Notez que l'espace blanc qui précède la ligne 2 et la ligne 3 du programme est le échancrure. Cela indique que les 3 lignes forment un seul bloc de code. En apprendre davantage sur pour boucles en Python, consultez Python «for» Loops (Definite Iteration).

tandis que Boucles

le tandis que La boucle est utilisée pour effectuer une certaine tâche alors qu'une condition est toujours satisfaite. Si la condition n'est plus remplie, votre code mettra fin au processus. Vous pouvez utiliser un tandis que boucle pour créer une série de cercles en tapant ce code:

>>> n=dix
>>> tandis que n <= 40:
...     t.cercle(n)
...     n = n+dix

Lorsque vous exécutez ce code, vous verrez les cercles apparaître l'un après l'autre et chaque nouveau cercle sera plus grand que le précédent:

Ici, n est utilisé comme compteur. Vous devrez spécifier de combien vous voulez que la valeur de n pour augmenter dans chaque boucle. Jetez un œil à cette mini présentation pour voir comment fonctionne le programme:

1. À n = 10, la tortue dessine un cercle d'un rayon de 10 unités. Après cela, la valeur de n est augmenté de 10.
2. À n = 20, la tortue dessine un cercle d'un rayon de 20 unités. Encore une fois, la valeur de n est augmenté de 10.
3. À n = 30, la tortue dessine un cercle d'un rayon de 30 unités. Pour la troisième fois, la valeur de n est augmenté de 10.
4. À n = 40, la tortue dessine un cercle d'un rayon de 40 unités. Pour la dernière fois, la valeur de n est augmenté de 10.
5. À n = 50, n n'est plus inférieur ou égal à 40. La boucle est terminée.

Pour en savoir plus sur tandis que boucles, consultez les boucles Python «while» (itération indéfinie).

Expressions conditionnelles

Vous utilisez des instructions conditionnelles pour vérifier si une condition donnée est vraie. Si tel est le cas, la commande correspondante est exécutée. Essayez de taper dans ce programme:

>>> u = contribution("Voulez-vous que je dessine une forme? Tapez oui ou non:")
>>> si u == "Oui":
...     t.cercle(50)

contribution() est utilisé pour obtenir contribution de l'utilisateur. Ici, il stockera la réponse de l'utilisateur sous la variable u. Ensuite, il comparera la valeur de u avec la condition fournie et vérifier si la valeur de u est "Oui". Si c'est "Oui", votre programme trace un cercle. Si l'utilisateur saisit autre chose, le programme ne fera rien.

Lorsque vous ajoutez un autre clause à une si , vous pouvez spécifier deux résultats selon que la condition est vraie ou fausse. Voyons cela dans un programme:

>>> u = contribution("Voulez-vous que je dessine une forme? Tapez oui ou non:")
>>> si u == "Oui":
...     t.cercle(50)
>>> autre:
...     impression("D'accord")

Ici, vous dites au programme d'afficher une sortie particulière même lorsque l'utilisateur ne dit pas "Oui". Tu utilises impression() pour afficher certains caractères prédéfinis à l'écran.

Notez que l'utilisateur n'a pas besoin de taper "non". Ils peuvent taper autre chose, auquel cas le résultat sera toujours "D'accord", car vous ne dites pas explicitement au programme que l'utilisateur doit taper "non". Ne vous inquiétez pas, cependant, car cela peut être résolu. Vous pouvez ajouter un elif pour fournir au programme plusieurs conditions et leurs sorties respectives, comme vous pouvez le constater ici:

>>> u = contribution("Voulez-vous que je dessine une forme? Tapez oui ou non:")
>>> si u == "Oui":
...     t.cercle(50)
>>> elif u == "non":
...     impression("D'accord")
>>> autre:
...     impression("Réponse invalide")

Comme vous pouvez le voir, ce programme a maintenant plus d'un résultat, selon les informations qu'il reçoit. Voici comment ce code fonctionne:

• Si vous tapez "Oui", puis le code traite l'entrée et dessine un cercle, selon vos instructions.
• Si vous tapez "non", puis le code s'imprime "D'accord" et votre programme est terminé.
• Si vous tapez autre chose, comme "Bonjour" ou "Sandwich", puis le code s'imprime "Réponse invalide" et votre programme est terminé.

Notez que ce programme est sensible à la casse, donc lorsque vous l'essayez, assurez-vous de mettre les chaînes en majuscules ou en minuscules en conséquence.

Pour en savoir plus sur les instructions conditionnelles, consultez les instructions conditionnelles en Python.

Projet final: La course des tortues Python

Jusqu'à présent, vous avez appris à personnaliser votre environnement de tortue, à programmer votre tortue pour qu'elle se déplace sur l'écran et à utiliser des boucles et des instructions conditionnelles pour améliorer votre code. Il est maintenant temps pour la partie la plus importante de votre parcours de programmation. Dans cette section, vous allez mettre en œuvre tout ce que vous avez appris dans un seul programme en créant un jeu amusant auquel vous pouvez jouer avec vos amis.

Avant de commencer, voici ce que vous devez savoir sur le jeu:

1. L'objectif: Le joueur dont la tortue atteint son domicile remporte la partie en premier.

2. Comment jouer:

   • Chaque joueur lance un dé pour obtenir un numéro.
   • Le joueur déplace ensuite sa tortue de ce nombre d'étapes.
   • Les joueurs alternent les tours jusqu'à ce que l'un d'eux gagne.

3. La structure:

   • Chaque joueur avait une tortue indiquée par une couleur différente. Vous pouvez avoir plus de deux joueurs, mais pour ce didacticiel, vous allez créer un jeu à deux joueurs.
   • Chaque tortue a une position d'origine qu'elle doit atteindre.
   • Chaque joueur utilise un dé pour choisir une valeur au hasard pour son tour. Dans votre programme, le dé est représenté par une liste de nombres de 1 à 6.

Maintenant que vous avez compris la logique du jeu, vous pouvez commencer et le créer! Tout d'abord, vous devrez configurer l'environnement.

Configuration de l'environnement de jeu

Commencez par importer le Python tortue bibliothèque. Après cela, importez le intégré Aléatoire bibliothèque, que vous utiliserez de manière aléatoire, sélectionnez un élément dans une liste:

>>> importation tortue
>>> importation Aléatoire

Une fois ces bibliothèques appelées avec succès dans votre environnement, vous pouvez continuer avec le reste de votre programme.

Installation des tortues et des maisons

Vous devez maintenant créer les deux tortues qui représenteront les joueurs. Chaque tortue sera d'une couleur différente, correspondant aux différents joueurs. Ici, le premier joueur est vert et le joueur deux est bleu:

>>> player_one = tortue.Tortue()
>>> player_one.Couleur("vert")
>>> player_one.forme("tortue")
>>> player_one.penup()
>>> player_one.aller à(-200,100)
>>> player_two = player_one.cloner()
>>> player_two.Couleur("bleu")
>>> player_two.penup()
>>> player_two.aller à(-200,-100)

Une fois que vous avez créé les tortues, vous les placez à leurs positions de départ et assurez-vous que ces positions sont alignées. Notez que vous avez créé la tortue du joueur deux en clonant la tortue du joueur un, en changeant sa couleur et en la plaçant à un point de départ différent.

Vous devez maintenant installer des maisons pour les tortues. Ces maisons serviront de points d'arrivée pour chaque tortue. Chacune des tortues maisons sera représenté par un cercle. Ici, vous devez vous assurer que les deux maisons sont à égale distance du point de départ:

>>> player_one.aller à(300,60)
>>> player_one.pendre()
>>> player_one.cercle(40)
>>> player_one.penup()
>>> player_one.aller à(-200,100)
>>> player_two.aller à(300,-140)
>>> player_two.pendre()
>>> player_two.cercle(40)
>>> player_two.penup()
>>> player_two.aller à(-200,-100)

Après avoir dessiné les maisons respectives, vous renvoyez les tortues à leurs positions de départ:

Impressionnant! Les aspects visuels de votre jeu sont complets. Vous pouvez maintenant créer le dé que vous utiliserez pour jouer au jeu.

Création de la matrice

Vous pouvez créer un dé virtuel pour votre jeu avec un liste, qui est une séquence ordonnée d'articles. Dans la vraie vie, vous pourriez préparer des listes d'épicerie et des listes de tâches pour vous aider à rester organisé. En Python, les listes fonctionnent de manière similaire.

Dans ce cas, vous allez utiliser une liste pour créer votre dé. Tout d'abord, vous définissez votre liste de nombres dans l'ordre croissant de 1 à 6. Vous pouvez définir une liste en lui donnant un nom, puis en mettant ses éléments entre crochets, comme ceci:

>>> mourir = [[[[1,2,3,4,5,6]

Cette liste est maintenant devenue votre dé. Pour lancer les dés, tout ce que vous avez à faire est de programmer votre système pour en sélectionner un nombre au hasard. Le nombre sélectionné sera considéré comme la sortie du dé.

Développer le jeu

Il est temps de développer le code pour le reste du jeu. Vous allez utiliser des boucles et des instructions conditionnelles ici, vous devez donc être prudent avec les indentations et les espaces. Pour commencer, jetez un œil aux étapes que votre programme devra suivre pour exécuter le jeu:

1. Étape 1: Vous commencerez par dire à votre programme de vérifier si l'une ou l'autre des tortues a atteint sa maison.
2. Étape 2: Si ce n'est pas le cas, vous direz à votre programme d'autoriser les joueurs à continuer d'essayer.
3. Étape 3: Dans chaque boucle, vous dites à votre programme de lancer le dé en choisissant un nombre au hasard dans la liste.
4. Étape 4: Vous lui dites ensuite de déplacer la tortue respective en conséquence, avec le nombre d'étapes basé sur le résultat de cette sélection aléatoire.

Le programme continue de répéter ce processus et s'arrête une fois que l'une des tortues atteint le but. Voici à quoi ressemble le code:

    1 >>> pour je dans intervalle(20):
    2 ...     si player_one.pos() > = (300,100):
    3 ...             impression("Le joueur un gagne!")
    4 ...             Pause
    5 ...     elif player_two.pos() > = (300,-100):
    6 ...             impression("Joueur deux victoires!")
    sept ...             Pause
    8 ...     autre:
    9 ...             player_one_turn = contribution("Appuyez sur" Entrée "pour lancer le dé")
dix ...             die_outcome = Aléatoire.choix(mourir)
11 ...             impression("Le résultat du jet de dé est:")
12 ...             impression(die_outcome)
13 ...             impression("Le nombre d'étapes sera:")
14 ...             impression(20*die_outcome)
15 ...             player_one.fd(20*die_outcome)
16 ...             player_two_turn = contribution("Appuyez sur" Entrée "pour lancer le dé")
17 ...             ré = Aléatoire.choix(mourir)
18 ...             impression("Le résultat du jet de dé est:")
19 ...             impression(die_outcome)
20 ...             impression("Le nombre d'étapes sera:")
21 ...             impression(20*die_outcome)
22 ...             player_two.fd(20*die_outcome)

Votre résultat final ressemblera à quelque chose comme ceci:

En résumé, voici ce que fait le code:

1. Ligne 1 met en place un pour boucle avec une plage de 1 à 20.

2. Lignes 2 à 7 Vérifiez si l'un des joueurs a atteint son objectif. Si l'un d'eux a, le programme imprime l'instruction correspondante et rompt la boucle.

3. Ligne 8 déplace le programme sur la prochaine série d'étapes si aucun joueur n'a gagné.

4. Ligne 9 imprime une déclaration demandant au joueur un d'appuyer sur le Entrer clé pour lancer le dé.

5. Ligne 10 prend une valeur aléatoire dans la liste mourir et le stocke dans dice_outcome.

6. Ligne 11 imprime une déclaration avant d'afficher le résultat du lancer de dés.

7. Ligne 12 imprime le résultat des dés.

8. Ligne 14 multiplie cette valeur par 20 pour réduire le nombre total d'étapes nécessaires pour terminer le jeu.

9. Ligne 15 moves player one’s turtle forward by this number of steps.

10. Lines 16 to 22 repeat these steps for player two.

The entire pour loop is repeated until one of the player’s turtles reaches the final position.

Remember, you can customize the game however you want, so go ahead and play around with it! You can add more turtles, change the colors, change the speed, or even create some obstacles to challenge your players. It’s all up to you as the developer of the game!

Conclusion

In this tutorial, you’ve learned how to program with the Python turtle library and grasped some very important programming concepts. You know how to deal with variable initialization, loops, conditional statements, indentations, lists, and operators. This is a great start for you, especially if you’re new to the Python programming language!

Now you can:

• Set up the Python turtle library
• Move your turtle around
• Customize your turtle and its environment
• Program your turtle
• Utilisation basic programming concepts
• Créer a game that you can play with friends

Now you’re ready to venture into some higher-level Python programming. To progress further in your Python journey, check out Introduction to Python and 11 Beginner Tips for Learning Python Programming. Just remember to work hard and keep practicing, and you’ll find that you’re a Python expert in no time!