"source": "from turtle import *\n\nwidth(50) # mettre l'épaisseur du trait à 50\nforward(20) # avancer de 20 pas\nwidth(10) # mettre l'épaisseur du trait à 10\nforward(60) # avancer de 60 pas\nwidth(50) # mettre l'épaisseur du trait à 50\nforward(20) # avancer de 20 pas\nwidth(10) # mettre l'épaisseur du trait à 10\nforward(40) # avancer de 40 pas\nleft(45) # tourner à gauche de 45°\nforward(60) # avancer de 60 pas\n\ndone()"
"source": "from turtle import *\n\n# dessiner le premier verre\nwidth(50) \nforward(20)\n\n# dessiner le pont (nez)\nwidth(10) \nforward(60)\n\n# dessiner le second verre\nwidth(50)\nforward(20)\n\n# dessiner la monture\nwidth(10)\nforward(40)\n\n# dessiner la branche\nleft(45)\nforward(60)\n\ndone()"
"source": "from turtle import *\n\nforward(160)\nleft(90)\nforward(100)\nleft(90)\n\nbackward(-160) # équivalent à forward(160)\nright(-90) # équivalent à left(90)\nbackward(-100) # avance de 100\nright(-90) # trouner à gauche de 90° \n\ndone()"
Dans ce chapitre, nous explorons ce que c’est un programme et nous prenons l’exemple du dessin. Ici, un programme est une séquence d’instructions pour dessiner une image.
Allons de l’avant (forward) avec la programmation. Nous allons voir que :
- l’expression `from turtle import *` met à disposition les fonctions de dessin,
- les instructions `forward()`, `backward()` permettent de tracer une ligne,
- les instructions `left()`, `right()` permettent de changer de direction.
- l'instruction `done()` permet de finaliser. Elle lance le tracage de la figure.
%% Cell type:markdown id: tags:
## 1.1 Le module `turtle`
Dans le langage de programmation Python, le module `turtle` (signifiant tortue en anglais) présente une façon sympathique pour faire des dessins. C’est pour cela que nous commençons notre aventure de programmation avec cet animal qui avance tout doucement à son propre rythme.
On s’imagine une tortue qui se déplace sur un canevas et laisse une trace.
Ci-dessous, vous trouvez notre premier programme de trois lignes :
- dans la première ligne, nous importons toutes (`*`) les fonctions du module turtle,
- avec `shape('turtle')`, nous affichons une tortue (au lieu de la flèche),
- avec `forward(150)`, nous faisons avancer la tortue de 150 pixels,
- avec `done()`, nous lançons de tracage de la figure.
%% Cell type:markdown id: tags:
### Exercice 1
Ajoutez d’autres instructions telles que `backward()`, `left()` et `right()` pour faire un dessin.
%% Cell type:markdown id: tags:
<divclass="alert alert-block alert-info"><b>A savoir:</b> Cliquez sur le bouton <b>Excécuter</b> pour tester le programme. </div>
%% Cell type:code id: tags:
``` python
fromturtleimport*
shape('turtle')
forward(150)
done()
```
%% Output
%% Cell type:markdown id: tags:
<divclass = "alert alert-block alert-warning">
### Solution
</div>
%% Cell type:code id: tags:
``` python
fromturtleimport*
shape('turtle')
forward(150)
left(90)
forward(150)
backward(300)
forward(150)
right(90)
forward(150)
done()
```
%% Output
%% Cell type:markdown id: tags:
### A retenir
La tortue peut se déplacer et dessiner une trace avec les 4 fonctions:
-`forward(d)` pour avancer d'une distance `d` (en pixels)
-`backward(d)` pour reculer
-`left(a)` pour tourner à gauche d'un angle `a` (en degrés)
-`right(a)` pour tourner à droite
%% Cell type:markdown id: tags:
***
## 1.2 Le canevas
Au départ, la tortue se trouve au centre d'une zone rectangulaire appelée _canevas_. Ce rectangle a les propriétés suivantes :
- l'origine (0, 0) se trouve au centre,
- l'axe horizontal x, s'étend de -300 à +300 (à droite),
- l'axe vertical y, s'étend de -200 à +200 (en haut).
### Exercice 2
Compléter le programme ci-dessous pour mener la tortue tout en bas du canevas. Ensuite, ajoutez une diagonale.
%% Cell type:code id: tags:
``` python
fromturtleimport*
shape('turtle')
forward(300)
backward(600)
forward(300)
left(90)
forward(200)
done()
```
%% Output
%% Cell type:markdown id: tags:
<divclass = "alert alert-block alert-warning">
### Solution
</div>
%% Cell type:code id: tags:
``` python
fromturtleimport*
shape('turtle')
forward(150)
left(90)
forward(150)
backward(300)
forward(150)
right(90)
forward(150)
done()
```
%% Output
%% Cell type:markdown id: tags:
***
## 1.3 Une séquence
Un programme est une séquence d'instructions. Le bloc de 9 instructions ci-dessous indique comment dessiner un carré. La tortue doit avancer, tourner, avancer, tourner, etc.
### Exercise 3
Modifiez ce code pour en faire un rectangle, au lieu d'un carré.
%% Cell type:code id: tags:
``` python
fromturtleimport*
forward(100)
left(90)
forward(100)
left(90)
forward(100)
left(90)
forward(100)
left(90)
done()
```
%% Output
%% Cell type:markdown id: tags:
<divclass = "alert alert-block alert-warning">
### Solution
</div>
%% Cell type:code id: tags:
``` python
fromturtleimport*
forward(200)
left(90)
forward(100)
left(90)
forward(200)
left(90)
forward(100)
left(90)
done()
```
%% Output
%% Cell type:markdown id: tags:
***
## 1.4 Épaisseur de ligne
La fonction `width(d)` (épaisseur en anglais) permet de définir l'épaisseur de la ligne.
Voici un triangle où chaque côté a une épaisseur différente.
### Exercise 4
Explorez différentes épaisseurs de ligne.
%% Cell type:code id: tags:
``` python
fromturtleimport*
forward(200)
left(120)
width(5)
forward(200)
left(120)
width(10)
forward(200)
done()
```
%% Output
%% Cell type:markdown id: tags:
<divclass = "alert alert-block alert-warning">
### Solution
</div>
%% Cell type:code id: tags:
``` python
fromturtleimport*
forward(200)
left(120)
width(5)
forward(200)
left(120)
width(10)
forward(200)
done()
```
%% Output
%% Cell type:markdown id: tags:
***
## 1.5 Maison avec toit
Nous dessinons une maison et marquons le toit par une ligne plus épaisse.
### Exercise 5
Doublez l'épaisseur du toit. Ensuite, doublez la hauteur de la maison.
%% Cell type:code id: tags:
``` python
fromturtleimport*
forward(100)
left(90)
forward(60)
left(45)
width(5)
forward(71)
left(90)
forward(71)
width(1)
left(45)
forward(60)
left(90)
done()
```
%% Output
%% Cell type:markdown id: tags:
<divclass = "alert alert-block alert-warning">
### Solution
</div>
%% Cell type:code id: tags:
``` python
fromturtleimport*
forward(100)
left(90)
forward(120)
left(45)
width(10)
forward(71)
left(90)
forward(71)
width(1)
left(45)
forward(120)
left(90)
done()
```
%% Output
%% Cell type:markdown id: tags:
***
## 1.6 Raquette de ping-pong
L'épaisseur de ligne est très utile dans le dessin.
## Exercise 6
Transformez la raquette de ping-pong en haltères de musculation.
%% Cell type:code id: tags:
``` python
fromturtleimport*
width(20)
forward(100)
width(80)
forward(20)
done()
```
%% Output
%% Cell type:markdown id: tags:
<divclass = "alert alert-block alert-warning">
### Solution
</div>
%% Cell type:code id: tags:
``` python
fromturtleimport*
width(20)
forward(100)
width(80)
forward(10)
width(20)
left(180)
forward(150)
width(80)
forward(10)
done()
```
%% Output
%% Cell type:markdown id: tags:
## 1.7 Lunettes de soleil
Voici encore un exemple où, avec un simple changement d'épaisseur, vous obtenez un effet très intéressant.
### Exercise 7
Ajoutez la première branche qui manque.
%% Cell type:code id: tags:
``` python
fromturtleimport*
width(50)
forward(20)
width(10)
forward(60)
width(50)
forward(20)
width(10)
forward(40)
left(45)
forward(60)
done()
```
%% Cell type:markdown id: tags:
<divclass = "alert alert-block alert-warning">
### Solution
</div>
%% Cell type:code id: tags:
``` python
fromturtleimport*
width(50)
forward(20)
width(10)
forward(60)
width(50)
forward(20)
width(10)
forward(40)
left(45)
forward(60)
left(180)
forward(60)
right(45)
forward(180)
right(135)
forward(60)
done()
```
%% Output
%% Cell type:markdown id: tags:
## 1.8 Commentaire
Le symbole `#` indique un commentaire. Sur PC vous pouvez l'insérer avec **Alt Gr+3** ou **opt+3** sur Mac.
Un commentaire permet d'ajouter une explication pour le lecteur humain. Il n'a aucune influence sur le programme. Python ignore tout simplement tout commentaire.
## Exercise 8
Expliquez dans chaque ligne ce que fait l'instruction.
%% Cell type:code id: tags:
``` python
fromturtleimport*
width(50)# mettre l'épaisseur du trait à 50
forward(20)# avancer de 20 pas
width(10)
forward(60)
width(50)
forward(20)
width(10)
forward(40)
left(45)
forward(60)
done()
```
%% Cell type:markdown id: tags:
<divclass = "alert alert-block alert-warning">
### Solution
</div>
%% Cell type:code id: tags:
``` python
fromturtleimport*
width(50)# mettre l'épaisseur du trait à 50
forward(20)# avancer de 20 pas
width(10)# mettre l'épaisseur du trait à 10
forward(60)# avancer de 60 pas
width(50)# mettre l'épaisseur du trait à 50
forward(20)# avancer de 20 pas
width(10)# mettre l'épaisseur du trait à 10
forward(40)# avancer de 40 pas
left(45)# tourner à gauche de 45°
forward(60)# avancer de 60 pas
done()
```
%% Output
%% Cell type:markdown id: tags:
### À retenir
L'exercice précédent servait à expliciter pour un débutant en programmation la signification des commandes écrites en anglais. Normalement on ne fait pas ça, car un programmeur est censé connaitre la signification des commandes.
Les commentaires servent à expliciter la vraie signification d'une partie du programme.
## Exercise 9
Expliquez cette fois ce que dessine chaque partie du programme (verre, pont, verre, charnière, branche).
%% Cell type:code id: tags:
``` python
fromturtleimport*
# dessiner le premier verre
width(50)
forward(20)
# dessiner le pont (nez)
width(10)
forward(60)
width(50)
forward(20)
width(10)
forward(40)
left(45)
forward(60)
done()
```
%% Cell type:markdown id: tags:
<divclass = "alert alert-block alert-warning">
### Solution
</div>
%% Cell type:code id: tags:
``` python
fromturtleimport*
# dessiner le premier verre
width(50)
forward(20)
# dessiner le pont (nez)
width(10)
forward(60)
# dessiner le second verre
width(50)
forward(20)
# dessiner la monture
width(10)
forward(40)
# dessiner la branche
left(45)
forward(60)
done()
```
%% Output
%% Cell type:markdown id: tags:
## 1.9 Équivalence
La tortue possède 4 fonctions de déplacement, mais à strictement parler, on pourrait s'en sortir avec seulement deux fonctions, `forward()` et `left()`, car :
-`backward(d)` est équivalent à `forward(-d)`
-`right(a)` est équivalent à `left(-a)`
Dans le programme ci-dessous, les 4 lignes du deuxième bloc sont équivalentes aux 4 instructions du premier bloc et donnent un résultat identique.
### Exercice 10
Expliquez avec un commentaire ce que font les 2 dernières instructions avant le `done()`.
%% Cell type:code id: tags:
``` python
fromturtleimport*
forward(160)
left(90)
forward(100)
left(90)
backward(-160)# équivalent à forward(160)
right(-90)# équivalent à left(90)
backward(-100)
right(-90)
done()
```
%% Cell type:markdown id: tags:
<divclass = "alert alert-block alert-warning">
### Solution
</div>
%% Cell type:code id: tags:
``` python
fromturtleimport*
forward(160)
left(90)
forward(100)
left(90)
backward(-160)# équivalent à forward(160)
right(-90)# équivalent à left(90)
backward(-100)# avance de 100
right(-90)# trouner à gauche de 90°
done()
```
%% Output
%% Cell type:markdown id: tags:
## Exercices d'entraînement
%% Cell type:markdown id: tags:
### Exercice 11
Écrivez un programme qui dessine un losange conformément au croquis ci-dessous.

%% Cell type:code id: tags:
``` python
fromturtleimport*
# à compléter...
done()
```
%% Cell type:markdown id: tags:
<divclass = "alert alert-block alert-warning">
### Solution
</div>
%% Cell type:code id: tags:
``` python
fromturtleimport*
left(30)
forward(100)
left(120)
forward(100)
left(60)
forward(100)
left(120)
forward(100)
done()
```
%% Output
%% Cell type:markdown id: tags:
### Exercice 12
Dessinez un hexagone régulier dont la longueur des côtés vaut 100 (voir la figure ci-dessous).
Pour tracer un hexagone, la tortue doit tourner 6 fois. Comme un tour complet représente 360°, à chaque angle la tortue doit tourné de \(\frac{360}{6}=60 \) degrés.
</div>
%% Cell type:code id: tags:
``` python
fromturtleimport*
forward(100)
# à compléter...
done()
```
%% Cell type:markdown id: tags:
<divclass = "alert alert-block alert-warning">
### Solution
</div>
%% Cell type:code id: tags:
``` python
fromturtleimport*
forward(100)
left(60)
forward(100)
left(60)
forward(100)
left(60)
forward(100)
left(60)
forward(100)
left(60)
forward(100)
left(60)
done()
```
%% Output
%% Cell type:markdown id: tags:
### Exercice 13
Dessinez une chaise.
%% Cell type:code id: tags:
``` python
fromturtleimport*
left(90)
forward(100)
# à compléter...
done()
```
%% Cell type:markdown id: tags:
<divclass = "alert alert-block alert-warning">
### Solution
</div>
%% Cell type:code id: tags:
``` python
fromturtleimport*
left(90)
forward(100)
backward(200)
forward(100)
left(90)
forward(100)
left(90)
forward(100)
done()
```
%% Output
%% Cell type:markdown id: tags:
### Exercice 14
Commenter le programme ci-dessous afin d'expliquer le but des différents blocs du code.
%% Cell type:code id: tags:
``` python
fromturtleimport*
# mettre votre commentaire
forward(200)
left(90)
forward(100)
left(90)
forward(200)
left(90)
forward(100)
left(90)
# mettre votre commentaire
forward(30)
# mettre votre commentaire
forward(30)
left(90)
forward(50)
left(90)
forward(30)
left(90)
forward(50)
left(90)
done()
```
%% Cell type:markdown id: tags:
<divclass = "alert alert-block alert-warning">
### Solution
</div>
%% Cell type:code id: tags:
``` python
fromturtleimport*
# dessiner la base de la maison
forward(200)
left(90)
forward(100)
left(90)
forward(200)
left(90)
forward(100)
left(90)
# avancer à la base de la porte
forward(30)
# dessiner la porte
forward(30)
left(90)
forward(50)
left(90)
forward(30)
left(90)
forward(50)
left(90)
done()
```
%% Cell type:markdown id: tags:
### Exercice 15 *
Écrivez un programme qui dessine une maison comme dans le schéma ci-dessous. Elle est formée de plusieurs triangles isocèles rectangles. La longueur des côtés du carré de base est de 185.

*Exercice tiré du livre **L'informatique simplement** de J. Hromkovic et T. Kohn*
%% Cell type:markdown id: tags:
<divclass="alert alert-block alert-info">
<b> Indication</b>
<br>
pour connaître la longueur du toit et des diagonles, utilisez le théorème de Pythagore.
</div>
%% Cell type:code id: tags:
``` python
fromturtleimport*
forward(185)
left(90)
# à compléter...
done()
```
%% Cell type:markdown id: tags:
<divclass = "alert alert-block alert-warning">
### Solution
</div>
%% Cell type:code id: tags:
``` python
fromturtleimport*
forward(185)
left(90)
forward(185)
left(90)
forward(185)
left(90)
forward(185)
left(135)
forward(262)
left(90)
forward(131)
left(90)
forward(131)
left(90)
forward(262)
done()
```
%% Output
%% Cell type:markdown id: tags:
---
#### Remarque générale
Ce document est une adaptation d'un ressource pédagogique tiré du catalogue modulo https://modulo-info.ch/. Il est sous license Creative Commons [BY-NC-SA](https://creativecommons.org/licenses/?lang=fr)