"source": "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.\n\nAllons de l’avant (forward) avec la programmation. Nous allons voir que :\n\n- l’expression `from turtle import *` met à disposition les fonctions de dessin,\n\n- les instructions `forward()`, `backward()` permettent de tracer une ligne,\n\n- les instructions `left()`, `right()` permettent de changer de direction.\n\n- l'instruction `done()` permet de finaliser. Elle lance le tracage de la figure.\n\n\n"
"source": "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.\n\n\n<blockquote class=\"alert alert-info\" style=\"background-color:rgb(220,240,255); margin:10px 10%;\">\n <p><span style=\"font-size:1.5em\">❔</span> C'est quoi une programme? la programmation? Exécutez la cellule ci-dessous pour voir une petite introduction sur la notion de boucle</p>\n</blockquote>\n\n<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/ZuxcqHVxW5I?si=oEohgGJjaZyMVi_h\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen></iframe>\n\nAllons de l’avant (forward) avec la programmation. Nous allons voir que :\n\n- l’expression `from turtle import *` met à disposition les fonctions de dessin,\n\n- les instructions `forward()`, `backward()` permettent de tracer une ligne,\n\n- les instructions `left()`, `right()` permettent de changer de direction.\n\n- l'instruction `done()` permet de finaliser. Elle lance le tracage de la figure.\n\n\n"
},
{
"cell_type": "markdown",
...
...
%% Cell type:markdown id: tags:
<divclass = "alert alert-danger">
Attention: **veillez à bien sauvegarder votre travail** dans le bon dossier du disque réseau (dossier document) avec le bon nom (et l'extension *.ipynb*), **sinon toutes les modifications seront perdues!**
Pour reprendre votre travail, il suffit d'ouvrir le fichier .ipynb en cliquant sur *Fichier ouvrir*
</div>
%% Cell type:markdown id: tags:
# 1. Premier programme, premières instructions
%% Cell type:markdown id: tags:
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.
<p><spanstyle="font-size:1.5em">❔</span> C'est quoi une programme? la programmation? Exécutez la cellule ci-dessous pour voir une petite introduction sur la notion de boucle</p>
</blockquote>
<iframewidth="560"height="315"src="https://www.youtube.com/embed/ZuxcqHVxW5I?si=oEohgGJjaZyMVi_h"title="YouTube video player"frameborder="0"allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"referrerpolicy="strict-origin-when-cross-origin"allowfullscreen></iframe>
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()
```
%% 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()
```
%% Cell type:markdown id: tags:
***
## 1.3 Une séquence
Un programme est une séquence d'instructions. Le bloc de 8 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()
```
%% 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()
```
%% 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()
```
%% 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()
```
%% 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:
## 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:markdown id: tags:
<divclass="alert alert-block alert-info"><b>Astuce :</b> Utiliser les raccourcis <b>Ctrl + c</b> pour copier du texte et <b>Ctrl + v</b> pour coller le texte copié. </div>
%% 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:
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:
## 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:
## 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:
### Exercice 12
Dessinez un hexagone régulier dont la longueur des côtés vaut 100 (voir la figure ci-dessous).
*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 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:
### Exercice 13
Dessinez une chaise.
%% Cell type:code id: tags:
``` python
fromturtleimport*
left(90)
forward(100)
# à compléter...
done()
```
%% 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:
### 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:
---
#### 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)
"source": "<div class = \"alert alert-danger\"> \n \nAttention: **veillez à bien sauvegarder votre travail** dans le bon dossier du disque réseau (dossier document) avec le bon nom (et l'extension *.ipynb*), **sinon toutes les modifications seront perdues!**\n\nPour reprendre votre travail, il suffit d'ouvrir le fichier .ipynb en cliquant sur *Fichier ouvrir*\n</div>"
"source": "<div style=\"padding:20px;background-color:papayawhip;\" > \n<h3 style=\"color:chocolate\"> <i class=\"fa fa-info\" aria-hidden=\"true\"> </i> Remarque introductive <i class=\"fa fa-info\" aria-hidden=\"true\"></h3> \n<p> Ce fichier est fait pour être lu sur le site <a href=\"https://notebook.basthon.fr/\"><img src='https://notebook.basthon.fr/assets/efede5218c9087496f16.png' style=\"border: 0; display:inline; margin: 0 5px; height:30px\" alt=\"Basthon\"/></a>. <br>\n \nSi vous l'avez ouvert avec un autre programme, comme Jupyter notebook, vous riquez de rencontrer quelques bugs. <br>\nVeuillez cliquez sur <a href=\"https://notebook.basthon.fr/\">ce lien</a> et y charger ce fichier à l'aide du bouton \"Ouvrir\" <i class=\"fa fa-folder\" aria-hidden=\"true\"> </i>\n</p> </div> "
},
{
"cell_type": "markdown",
...
...
@@ -13,7 +13,7 @@
{
"cell_type": "markdown",
"metadata": {},
"source": "# 2. Répéter - `for`\n\nDans ce chapitre, nous découvrons comment utiliser une boucle `for` pour répéter un bloc d'instructions un certain nombre de fois. Nous allons voir que :\n\n* la boucle `for` permet de répéter des instructions,\n* la structure `for _ in range(n):` permet de répéter un bloc un nombre `n` fois,\n* les instructions, qui sont répétées, sont celles qui suivent le `:` et qui sont indentées (décalées à droite). En effet, le langage python, n'a pas de end for pour indiquer la fin de la boucle. Le langage utilise l'indentation pour signifier qu'une suite d'instruction fait partie de la boucle.\n\n"
"source": "# 2. Les boucles `for`\n\nDans ce chapitre, nous découvrons comment utiliser une boucle `for` pour répéter un bloc d'instructions un certain nombre de fois. Nous allons voir que :\n\n* la boucle `for` permet de répéter des instructions,\n* la structure `for _ in range(n):` permet de répéter un bloc un nombre `n` fois,\n* les instructions, qui sont répétées, sont celles qui suivent le `:` et qui sont indentées (décalées à droite). En effet, le langage python, n'a pas de end for pour indiquer la fin de la boucle. Le langage utilise l'indentation pour signifier qu'une suite d'instruction fait partie de la boucle.\n\n<blockquote class=\"alert alert-info\" style=\"background-color:rgb(220,240,255); margin:10px 10%;\">\n <p><span style=\"font-size:1.5em\">❔</span> C'est quoi une boucle? Exécutez la cellule ci-dessous pour voir une petite introduction sur la notion de boucle</p>\n</blockquote>\n\n<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/IBAv89hky8g?si=_te3mGANDxT82Dov\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen></iframe>"
"source": "from turtle import *\n\nfor _ in range(4):\n forward(100)\n left(90)\n\ndone()"
...
...
@@ -92,7 +92,7 @@
"cell_type": "code",
"execution_count": null,
"metadata": {
"trusted": true
"trusted": false
},
"outputs": [],
"source": "# Dans cette exemple l'instruction B ne fait pas partie de la boucle.\n\nfor _ in range(5):\n print(\"Hello\")\n print(\"----------\")\nprint(\"Au revoir\")"
<p> Ce fichier est fait pour être lu sur le site <ahref="https://notebook.basthon.fr/"><imgsrc='https://notebook.basthon.fr/assets/efede5218c9087496f16.png'style="border: 0; display:inline; margin: 0 5px; height:30px"alt="Basthon"/></a>. <br>
Attention: **veillez à bien sauvegarder votre travail** dans le bon dossier du disque réseau (dossier document) avec le bon nom (et l'extension *.ipynb*), **sinon toutes les modifications seront perdues!**
Pour reprendre votre travail, il suffit d'ouvrir le fichier .ipynb en cliquant sur *Fichier ouvrir*
</div>
Si vous l'avez ouvert avec un autre programme, comme Jupyter notebook, vous riquez de rencontrer quelques bugs. <br>
Veuillez cliquez sur <ahref="https://notebook.basthon.fr/">ce lien</a> et y charger ce fichier à l'aide du bouton "Ouvrir" <iclass="fa fa-folder"aria-hidden="true"></i>
</p></div>
%% Cell type:markdown id: tags:
Rappel de quelques fonction de Turtle avec des exemples qui pourront vous servir
| Fonction |Exemple|Commentaire|
|:-------- |:------|:----------|
|forward(x)|forward(150)|Trace un trait de 150 points|
|backward(x)|backward(150)|Trace un trait “à reculons” de 150 points|
|left(n)|left(60)|Tourne sur place la tortue de 60° à gauche|
|right(n)|right(60)|Tourne sur place la tortue de 60° à droite|
|width(x)|width(5)|Change l’épaisseur à 5 points|
|color("c")|color("yellow")|Change la couleur du trait (mais aucun trait n’est tracé à ce moment). Notez les guillemets !|
|penup()|penup()|Lève la tortue (permet de se déplacer sans dessiner)|
|pendown()|pendown()|Baisse le stylo|
%% Cell type:markdown id: tags:
# 2. Répéter - `for`
# 2. Les boucles `for`
Dans ce chapitre, nous découvrons comment utiliser une boucle `for` pour répéter un bloc d'instructions un certain nombre de fois. Nous allons voir que :
* la boucle `for` permet de répéter des instructions,
* la structure `for _ in range(n):` permet de répéter un bloc un nombre `n` fois,
* les instructions, qui sont répétées, sont celles qui suivent le `:` et qui sont indentées (décalées à droite). En effet, le langage python, n'a pas de end for pour indiquer la fin de la boucle. Le langage utilise l'indentation pour signifier qu'une suite d'instruction fait partie de la boucle.
<p><spanstyle="font-size:1.5em">❔</span> C'est quoi une boucle? Exécutez la cellule ci-dessous pour voir une petite introduction sur la notion de boucle</p>
</blockquote>
<iframewidth="560"height="315"src="https://www.youtube.com/embed/IBAv89hky8g?si=_te3mGANDxT82Dov"title="YouTube video player"frameborder="0"allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"referrerpolicy="strict-origin-when-cross-origin"allowfullscreen></iframe>
Pour distinguer les instructions qui seront répétées de celles qui ne le seront pas, on <b>indente</b> le code, c'est-à-dire que toutes les instructions qui suivent le `for` qui commencent par un espacement seront répétées le nombre de fois explicité dans le `range`. Après les répétitions le programme exécutera la permière instruction qui n'est pas indentée.
NB: Vous être libre de choisir l'espace d'indentation mais soyez rigoureux avec votre choix et garder la même valeur pour tout votre programme. Nous utilisons en général un espace de 4 caractères ou la <b>touche Tabulation</b> pour rendre les codes plus lisibles.
Compléter le programme ci-dessous pour tracer un octogone. Un octogone régulier (mêmes longueur de côtés, mmêmes angles) est un polygone à huit sommets, donc huit côtés.
Le programme doit faire moins de 5 lignes.
%% Cell type:code id: tags:
``` python
fromturtleimport*
# à compléter
done()
```
%% Cell type:markdown id: tags:
### Escalier
Pour dessiner un escalier, il faut simplement répéter dans une boucle le dessin pour une seule marche.
%% Cell type:code id: tags:
``` python
fromturtleimport*
for_inrange(5):
forward(20)
left(90)
forward(20)
right(90)
forward(100)
done()
```
%% Cell type:markdown id: tags:
Pour dessiner des dents de scie, il faut simplement répéter dans une boucle le dessin pour une seule dent.
Compléter la boucle for pour dessiner trois cercles rouge de rayon 50 collés les uns aux autres comme sur le dessin:
%% Cell type:markdown id: tags:
##### Rappels:
- La fonction `circle(R, A)` permet de dessiner un arc de cercle de rayon `R` et d'angle `A`.
Exemple: `circle(100, 360)` dessine un cercle de rayon 100.
- Les fonctions `penup()` et `pendown()` permettent de lever, respectivement baisser, le stylo.
%% Cell type:code id: tags:
``` python
fromturtleimport*
color('red')
for_inrange(3):
# a compléter
done()
```
%% Cell type:markdown id: tags:
## 2.4 Explorer "La tortue"
Voici quelques fonctions de la tortue.
%% Cell type:markdown id: tags:
### Estampe
Vous pouvez laisser une impression de la tortue à sa position actuelle avec la fonction `stamp()`.
%% Cell type:code id: tags:
``` python
fromturtleimport*
shape('turtle')
for_inrange(6):
forward(100)
left(60)
stamp()
done()
```
%% Cell type:markdown id: tags:
### Forme
Vous pouvez changer la forme de votre tortue avec la fonction `shape()`.
%% Cell type:markdown id: tags:
<h3style="color:teal;background-color:azure;"><iclass="fa fa-pencil"aria-hidden="true"></i> Exercice 9 </h3>Essayez les formes 'triangle', 'arrow', 'circle' et 'square'.
%% Cell type:code id: tags:
``` python
fromturtleimport*
shape('turtle')
for_inrange(6):
forward(100)
left(60)
stamp()
done()
```
%% Cell type:markdown id: tags:
## 2.5 Les erreurs
Il est important de bien lire et comprendre les messages d'erreur.
Dans cette section, vous allez découvrir les différentes catégories d'erreur et comment les corriger.
%% Cell type:markdown id: tags:
### ImportError
Cette erreur survient lorsque vous essayez d'importer un module qui n'existe pas.
2. Testez le programme pour vérifier qu'il fonctionne.
%% Cell type:code id: tags:
``` python
fromturtlimport*
foriinrange(3):
forward(100)
left(120)
done()
```
%% Cell type:markdown id: tags:
### <font color='red'>SyntaxError</font>
Cette erreur survient lorsque vous écrivez mal un mot-clé, ou si vous oubliez une ponctuation. Dans ce cas, le mot-clé mal écrit n'est pas reconnu et il n'est pas colorié correctement dans votre code.
%% Cell type:markdown id: tags:
<h3style="color:teal;background-color:azure;"><iclass="fa fa-pencil"aria-hidden="true"></i> Exercice 11 </h3>Corrigez les trois erreurs de syntaxe et remarquez les éventuelles différences de stylisation.
%% Cell type:code id: tags:
``` python
froturtleimport*
foreiinrange(3)
forward(100)
left(120)
done()
```
%% Cell type:markdown id: tags:
### <font color='red'>NameError</font>
Cette erreur survient lorsque vous écrivez mal le nom d'une variable ou fonction.
%% Cell type:markdown id: tags:
<h3style="color:teal;background-color:azure;"><iclass="fa fa-pencil"aria-hidden="true"></i> Exercice 12 </h3>Corrigez les trois erreurs de nom.
%% Cell type:code id: tags:
``` python
fromturtleimport*
for_inrange():
forwarde(100)
lefft(120)
done()
```
%% Cell type:markdown id: tags:
### <font color='red'>TypeError</font>
Cette erreur survient lorsque vous ne mettez pas le nombre d'arguments corrects pour une fonction.
%% Cell type:markdown id: tags:
<h3style="color:teal;background-color:azure;"><iclass="fa fa-pencil"aria-hidden="true"></i> Exercice 13 </h3>Corrigez les trois erreurs de type.
Utiliser votre identifiant EEL et le mot de passe *Sismondi2024* pour faire les exercices de la **série B** de la plateforme [AlgoPython](https://www.algopython.fr/login). [](https://www.algopython.fr/login)
%% 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)
