Dessiner des formes avec le module Python Turtle

notre compréhension de base du langage Python est de savoir que nous pouvons programmer des fonctions, introduire des itérations à l’aide de boucles Python et décider quel programme exécuter à l’aide d’instructions conditionnelles telles que if, elifet else. Mais Python est bien plus puissant que cela ; il peut accéder et traiter des fichiers, créer des jeux intéressants, simuler des concepts scientifiques, traiter du Big Data, générer des modèles d’apprentissage automatique et bien plus encore !

Dans cet article, nous utiliserons Python pour créer des sorties graphiques à l’aide du module Python Turtle. Il s’agit d’un didacticiel adapté aux débutants qui apprend à dessiner des formes et à programmer des dessins à l’aide de Python. Pour aller plus loin, il est essentiel d’avoir une compréhension approfondie des fondamentaux de Python : instructions de base, boucles, classes et objets, et accès aux modules.

Module Tortue de Python

Le turtle Le module en Python est un module qui permet des sorties graphiques via du code. Le module fournit un pointeur, qui peut être personnalisé comme une tortue (d’où le nom), et le mouvement de la tortue laisse une trace derrière elle, dessinant des formes et créant des motifs visuels sur l’écran. Le module est installé avec la bibliothèque standard Python, ce qui signifie que nous n’avons pas besoin d’installer le module nous-mêmes. Ses classes et fonctions sont facilement accessibles via les éléments suivants import déclaration:

from turtle import *

Maintenant, plongeons-nous en profondeur dans ce module à travers la documentation officielle de Python : https://docs.python.org/3/library/turtle.html

Commandes de base de la tortue

Comme le montre la documentation liée ci-dessus, les commandes de base que nous pouvons donner à notre tortue sont les suivantes :

• forward() Cette fonction indique à la tortue d’avancer d’une distance spécifique. Il prend une valeur entière comme argument.
• backward()Cette fonction indique à la tortue de reculer d’une distance spécifique. Il prend également une valeur entière comme argument.
• left()Cela indique à la tortue de tourner vers la gauche d’un certain angle qui a été transmis à la fonction comme argument.
• right()Cela indique à la tortue de tourner vers la droite d’un certain angle qui a été transmis à la fonction comme argument.
• color() Cela changera la couleur de la tortue en fonction de la chaîne qui a été passée à cette fonction comme argument (par exemple, « rose »). Les noms de couleurs sont accessibles depuis ici.
• width() Cela modifiera la largeur du pointeur de la valeur entière
• exitonclick() Cela nous permettra de fermer l’écran qui a été généré en sortie de notre code, simplement en cliquant sur l’écran.

Exécutez le code suivant et modifiez-le selon vos besoins pour comprendre ce que fait la tortue lorsque chacune des fonctions ci-dessus est appelée.

from turtle import *
color("pink")
width(5)
forward(100)
left(45)

color("blue")
width(4)
forward(100)
left(45)
forward(20)

color("red")
width(4)
forward(60)
left(45)
backward(50)

color("yellow")
width()
forward(100)
right(45)

exitonclick()

Utilisation des graphiques de tortue POO

Maintenant que nous avons vu comment fonctionnent les fonctions de base du module et comment la sortie est générée, nous allons utiliser le concept de programmation orientée objet expliqué dans la documentation pour approfondir notre compréhension. Le concept de classes et d’objets, créé via le constructeur, facilite la programmation d’énormes programmes complexes avec des variables ayant des paramètres similaires mais des valeurs différentes. C’est là que la POO est utile, et son incorporation dans le module nous permettra d’utiliser plus d’une tortue à la fois.

Afin d’aller de l’avant, il est important d’avoir une compréhension de base des classes et des objets, en particulier de la manière dont les objets peuvent être créés avec leurs attributs et leurs méthodes.

Créons nos objets tortue et écran :

from turtle import Turtle, Screen

my_turtle = Turtle()
print(my_turtle)

Comme le montre la capture d’écran ci-dessus, l’objet tortue a été créé et son emplacement est défini. Nous allons maintenant utiliser la documentation pour personnaliser notre tortue.

Nous définirons la forme, la couleur et la largeur de notre tortue en utilisant le code suivant :

my_turtle.shape("turtle")
my_turtle.color("coral1")
my_turtle.width(4)

Définissons également l’objet écran et personnalisons-le.

screen = Screen()
screen.title('Drawing Shapes with Turtle Module')
screen.bgcolor("white")
screen.exitonclick()

L’objet écran a été défini ci-dessus et ses couleurs de titre et d’arrière-plan ont été définies en conséquence. Passons maintenant à l’objectif principal de ce tutoriel !

Dessiner des formes

Nous allons maintenant apprendre à dessiner différentes formes avec notre tortue personnalisée !

Triangle

La première forme que nous allons dessiner est un triangle. Cela peut être dessiné en utilisant les fonctions de base dont nous avons parlé ci-dessus : avant et droite. On sait qu’un triangle est constitué de 3 côtés, et pour un triangle équilatéral, l’angle entre chaque côté est de 60. On peut dessiner ce triangle en utilisant les lignes de code suivantes :

my_turtle.forward(200)
my_turtle.right(120)
my_turtle.forward(200)
my_turtle.right(120)
my_turtle.forward(200)
my_turtle.right(120)

Comme on peut le voir, nous avons réussi à créer un triangle avec l’aide de notre tortue. Notez que nous avons fixé l’angle de déplacement de la tortue vers la droite à 120, ce qui signifie que l’angle restant qui deviendra l’angle interne du triangle sera de 180 – 120 = 60. C’était notre objectif. Nous travaillerons de la même manière pour la forme suivante.

Carré

Nous allons maintenant utiliser notre tortue pour dessiner un carré. Puisqu’un carré a 4 côtés, nous utiliserons la méthode du mouvement vers l’avant 4 fois, avec l’angle défini sur 360/4 = 90º chaque fois que nous utiliserons la bonne méthode. Changeons également la couleur de la tortue en turquoise foncé (Couleurs des tortues)

Voici notre code pour dessiner un carré :

my_turtle.color("dark turquoise")
my_turtle.forward(200)
my_turtle.right(90)
my_turtle.forward(200)
my_turtle.right(90)
my_turtle.forward(200)
my_turtle.right(90)
my_turtle.forward(200)
my_turtle.right(90)

Pentagone

Ensuite, nous allons créer un pentagone, qui est une forme à 5 côtés avec un angle entre chaque côté égal à 108. Cela signifie que l’angle extérieur sera égal à 72. Nous coderons ce qui précède dans notre code, cette fois en utilisant 5 lignes de code pour les 5 côtés. Nous changerons également la couleur de notre tortue.

my_turtle.color("spring green")
my_turtle.forward(150)
my_turtle.right(72)
my_turtle.forward(150)
my_turtle.right(72)
my_turtle.forward(150)
my_turtle.right(72)
my_turtle.forward(150)
my_turtle.right(72)
my_turtle.forward(150)
my_turtle.right(72)

Comme vous pouvez le voir dans le bloc de code ci-dessus, nous avons réduit le mouvement vers l’avant de 200 à 150 afin que le pentagone puisse être dessiné à l’intérieur de l’écran.

Construire l’algorithme

Nous avons utilisé le module tortue pour dessiner un triangle, un carré et un pentagone. Comme nous pouvons le voir ci-dessus, nous pouvons facilement détecter une tendance. La tortue avance et droite d’autant de côtés qu’il y en a. Pour dessiner un triangle, donc une forme à trois côtés, la tortue avance, puis à droite, puis en avant, puis à droite, puis encore en avant et encore à droite, un total de 3 séries d’avant et de droite. Pour un carré, le même ensemble est exécuté quatre fois, soit autant de côtés que la forme en possède. Et de même pour un pentagone. Ainsi, nous pouvons établir un modèle de fonctions récurrentes vers l’avant et vers la droite. Nous pouvons fixer une valeur fixe de la distance parcourue à chaque fois que la tortue avance. Quant à l’angle donné avec la bonne méthode, tout comme le nombre de fois que les instructions sont répétées dépend du nombre de côtés de la forme, de même, l’angle est également déterminé par le nombre de côtés. Cet angle extérieur peut facilement être calculé par la formule suivante :

Angle extérieur = 360 / Nombre de côtés

L’angle extérieur d’un triangle sera 360/3 = 120. L’angle extérieur d’un carré sera 360/4 = 90, et ainsi de suite. Cela servira à nourrir la bonne méthode.

Définir la fonction

Nous allons maintenant définir une fonction générique qui prend le nombre de côtés d’une forme pour dessiner la forme. Si on donne 3 comme argument, cela créera un triangle. Si on donne 8 comme argument, cela créera un octogone, etc.

def draw_shapes(num_sides):
    angle = 360 / num_sides
    for i in range(num_sides):
        my_turtle.forward(50)
        my_turtle.right(angle)

La fonction prend en compte le nombre de côtés, calcule l’angle extérieur, qui est transmis à la bonne méthode, et exécute la méthode avant et droite autant de fois qu’il y a de côtés. Donc, supposons que nous voulions dessiner un octogone, nous appellerons la fonction et donnerons le nombre 8 comme argument à la fonction. On peut également définir la couleur de la forme :

my_turtle.color("pale violet red")
draw_shapes(8)

Dessiner des formes dans une plage

Nous allons maintenant utiliser la fonction ci-dessus que nous avons définie et utiliser le for boucle pour parcourir une plage de nombres, chacun correspondant à un côté. Nous commencerons par 3 pour un triangle, et notre tortue dessinera autant de formes que nous le souhaiterons. Donc, supposons que nous voulions dessiner un triangle, un carré, un pentagone, etc. jusqu’à un décagone, nous allons parcourir les nombres 3 à 11, car 11 est exclu dans l’intervalle d’une boucle for.

Ajoutons également la possibilité de dessiner chaque forme avec une couleur différente. Pour cela, nous allons créer une liste de couleurs, et la boucle for parcourra également les couleurs de la liste.

my_colors = ["dark gray", "hot pink", "midnight blue", "orange", "indigo", "dark sea green", "tan", "pale violet red", "sky blue", "spring green"]

Une fois que nous aurons créé notre liste de couleurs, nous modifierons notre fonction pour inclure la fonction de changement de couleur, puis parcourrons la plage pour dessiner des formes.

def draw_shapes(num_sides):
    angle = 360 / num_sides
    my_turtle.color(my_colors[3-num_sides])
    for i in range(num_sides):
        my_turtle.forward(75)
        my_turtle.right(angle)

for shape_size_n in range(3,11):
    draw_shapes(shape_size_n)

Conclusion

Dans ce didacticiel, nous avons exploré le module tortue, compris ses fonctions de base et le concept de POO, et l’avons utilisé pour créer des formes. Il s’agissait d’un didacticiel Python de niveau intermédiaire qui nécessitait une compréhension de base des classes et des objets, la définition et l’appel de fonctions, ainsi que la personnalisation des couleurs à l’aide de Trinket. Ceci est un exemple de base de ce qui pourrait être fait avec le module Turtle. Nous pouvons explorer le module plus en profondeur et apprendre beaucoup de codage grâce à lui !