2 - Séquentialité avec Turtle
Dans cette deuxième activité, vous allez apprendre à réaliser de petits dessins en utilisant Python et son module Turtle.
Ce module d'initiation à la programmation se nomme Turtle car on peut utiliser une icône de tortue qui se déplace sur l'écran et qui dessine peu à peu un dessin en exécutant ce qu'on lui demande.
Cette activité vous permettra de comprendre qu'un programme s'exécute ligne par ligne et qu'on ne passe à la ligne suivante que lorsque la ligne actuelle a été entiérement traitée.
Ce principe se nomme la séquentialité.
Logiciel nécessaire pour l'activité : Python 3 : Thonny, IDLE ou le site repl.it ...
Evaluation ✎ : questions 20
Evaluation ✌ : questions 07-12-15-17
Documents de cours : open document ou pdf
Résumé : Version HTML ou imprimable ou ou PDF (couleur ou gris)
1 - Un peu de vocabulaire
Avant de commencer à dessiner, nous allons aborder quelques nouvelles notions que nous allons rencontrer rapidement : les variables, les affectations, et les fonctions.
Chacune des ces notions fera l'objet d'une activité spécifique. Aujourd'hui, on ne fait que les présenter rapidement pour pouvoir les utiliser.
1.1 Notion de VARIABLE
Python est un langage de programmation qui permet de stocker des données dans la mémoire de façon à les réutiliser plus tard.
Dans un premier temps, vous pouvez voir les variables comme des cartons permettant d'y ranger des choses.
Imaginons qu'on veuille stocker 50 pour l'utiliser plus tard.
La syntaxe Python permettant de créer une variable a utilise un nouvel opérateur, l'opérateur =.
>>> a = 50
Sa structure est assez simple en apparence :
- A GAUCHE : le nom de la variable voulue (ce nom ne peut pas contenir d'espace). Ici a.
- AU MILIEU : l'opérateur =
- A DROITE : la valeur qu'on veut associer à notre variable. Ici 50.
Maintenant que cette variable est en mémoire, on peut réutiliser sa valeur associée en utilisant juste son nom :
>>> a * 2
100
>>> a
50
1.2 - Notion de FONCTION
Description
Les fonctions sont des moyens de répondre à des problèmes spécifiques.
- on leur donne des entrées : les données sur lesquelles on veut qu'elles travaillent et
- elles répondent en renvoyant une réponse en sortie.
| ENTREE(S) | ⇒ | Fonction | ⇒ | SORTIE |
Un exemple avec la fonction VALEUR_ABSOLUE qui n'attend qu'une entrée (un nombre) et qui renvoie la valeur absolue du nombre (le même nombre mais sans son signe).
| -12 | ⇒ | Fonction VALEUR ABSOLUE | ⇒ | 12 |
| 12 | ⇒ | Fonction VALEUR ABSOLUE | ⇒ | 12 |
D'autres exemples
| 5; 10; 50; 0; 20 | ⇒ | Fonction MAXIMUM | ⇒ | 50 |
| 5; 10; 50; 0; 20 | ⇒ | Fonction MINIMUM | ⇒ | 0 |
| 5; 10; 50; 0; 20 | ⇒ | Fonction SOMME | ⇒ | 85 |
1.3 - Syntaxe de l'appel d'une fonction
La syntaxe d'utilisation des fonctions en Python est la suivante :
nom_fonction(a, b, c, d...)
- on écrit le nom de la fonction
- on place les deux parenthèses ouverture-fermeture à la suite du nom
- on place les ENTREES dans les parenthèses, en les séparant par des virgules au besoin
Python intégre plusieurs fonctions natives : des fonctions présentes de base dans Python. Dans le cadre de ce site, les fonctions natives sont toujours écrites en vert.
Fonction VALEUR ABSOLUE : cette fonction se nomme abs() en Python.
>>> abs(-12)
12
>>> abs(12)
12
Fonction MAXIMUM : cette fonction se nomme max() en Python.
>>> max(10, 0, 50, 40)
50
01 ✔° Ouvrir Thonny. Aller dans le menu Affichage/Views et sélectionner Variables si l’onglet Variables n’est pas ouvert.
Vous devriez constater qu'une nouvelle fenêtre est désormais disponible dans la partie droite de Thonny :
02 ✔° Dans la zone Console (celle avec 3 chevrons >>>), tapez les instructions (en jaune). Que constate-on dans l'onglet variable de Thonny ?
>>> 50 + 2
Effet ?
>>> a = 50
Effet ?
>>> b = 20
Effet ?
...CORRECTION...
>>> 50 + 2
52
Effet ? Python évalue l'expression 50 + 2 à 52 et l'affiche dans la console
>>> a = 50
Effet ? Affectation de la variable a, référençant 50 (sans affichage dans la console)
>>> b = 20
Effet ? Affectation de la variable b, référençant 20 (sans affichage)
03° A votre avis, que va-t-on maintenant voir dans la console si on tape ceci :
>>> a + b
Effet ?
...CORRECTION...
>>> a + b
70
Effet ? Python évalue a + b à 70 et l'affiche dans la console
04° A votre avis, que va-t-on maintenant voir dans la console si on tape ceci :
>>> c = a + b
Effet ?
...CORRECTION...
>>> c = a + b
Effet ? Python évalue a + b à 70 et place le résultat dans la variable c. Aucun affichage du coup.
05° A votre avis, comment sera évaluée cette expression comportant un appel de fonction ? Vérifiez ensuite votre réponse.
>>> 10 * max(5, 2, 3, 6, 1)
...CORRECTION...
L'interpréteur va commencer par évaluer max(5, 2, 3, 6, 1) à 6.
Ensuite, il suffit de multiplier cela par 10.
On va donc obtenir 60.
>>> 10 * max(5, 2, 3, 6, 1)
60
2 - Module Turtle
La séquentialité est une notion fondamentale : vous devez impérativement comprendre que lorsqu'on fournit un programme comportant plusieurs lignes à un ordinateur, il ne les exécute pas au hasard.
Non, il les exécute ligne par ligne, en commençant par la première et en passant à la suivante uniquement après avoir correctement exécuté la ligne en cours.
Pour travailler sur la séquentialité, le mode interactif de la console est merveilleux : on ne peut rentrer qu'une instruction à la fois.
Aujourd'hui, vous allez dessiner un peu, en expliquant à la machine ce qu'elle doit faire, étape par étape, instruction par instruction.
IMPORTANT : Distinction majuscule - minuscule
Attention aux minuscules et aux minuscules. Python distingue les deux. Cela veut dire que pour l'interpréteur Python, turtle ou Turtle, ce n'est pas la même chose.
Tapez bien exactement ce qui est proposé ci-dessous, sans changer le type majuscule ou minuscule de la lettre.
06-A ✔° Utiliser les instructions suivantes une à une pour visualiser leurs effets.
Encart d'instructions n°1
>>> import turtle as trt
✱ On demande d'importer dans la mémoire de l'interpréteur Python les instructions permettant de dessiner avec la tortue.
✱ Visuellement, il ne se passe rien si ce n'est qu'on voit que trt est apparu dans la zone des variables : nous allons maintenant avoir le droit d'utiliser le module turtle.
Encart d'instructions n°2
>>> crayon = trt.Turtle()
Notez bien la présence d'un T majuscule et d'un t minuscule, ainsi que de parenthèses ().
✱ On crée une variable crayon à partir du module Turtle. Cette variable ne contient pas un nombre mais la référence mémoire du crayon. Vous allez voir qu'on va pouvoir utiliser ce nom pour agir sur le crayon justement.
✱ Visuellement, cela ouvre une fenêtre graphique et y place une flèche orientée vers la droite : la flèche symbolise le crayon.
06-B ✔° Modifier maintenant la disposition des fenêtres d'affichage pour obtenir quelque chose qui ressemble à ceci
- Le site à gauche
- Thonny en haut à droite
- La fenêtre graphique de Turle en bas à droite
06-C ✔° Voici la suite des instructions. Tester chaque instruction dans la console :
Encart d'instructions n°3
>>> crayon.right(90)
✱ Visuellement : la flèche tourne de 90° vers la droite à partir de son orientation actuelle.
>>> crayon.left(90)
✱ Visuellement : idem, on tourne de 90° vers la gauche à partir de son orientation actuelle.
Encart d'instructions n°5
>>> crayon.forward(50)
>>> crayon.forward(100)
>>> crayon.forward(-150)
✱ Visuellement :
- la flèche avance de 50 pixels dans le sens indiqué et trace un trait noir.
- la flèche avance de 100 pixels et trace un trait noir.
- la flèche recule de 150 pixels par rapport au sens indiqué, et trace un trait noir.
>>> crayon.backward(50)
- la flèche recule de 50 pixels. C'est l'équivalent de dire forward(-50).
Encart d'instructions n°5
Notez bien qu'on utilise "red" et pas juste red. Nous verrons bientôt que ces guillemets indiquent qu'on fournit une chaîne de caractères.
>>> crayon.pencolor("red")
✱ On change la couleur du crayon.
>>> crayon.forward(50)
✱ On avance en traçant en rouge
Encart d'instructions n°6
>>> crayon.penup()
✱ On empêche l'objet de tracer des traits (symboliquement, on lève la pointe du crayon virtuel.
>>> crayon.forward(-200)
✱ On recule sans faire de nouvelle trace puisque le crayon est levé
>>> crayon.pendown()
✱ On permet à nouveau à l'objet de tracer des traits (symboliquement, on abaisse la pointe du crayon virtuel sur la feuille.
>>> crayon.forward(200)
✱ On avance en traçant un trait puisque le crayon est abaissé.
Encart d'instructions n°7
>>> crayon.clear()
✱ On fait disparaître les traits créés par l'objet nommé crayon.
Encart d'instructions n°8
>>> crayon.home()
✱ On ramène le crayon au centre et on le replace en orientation vers la droite. Comme le crayon était 'posé', il a dessiné un trait.
Fonction et méthode
Avec l'apparition des parenthèses entre lesquelles on transmet (ou pas) des données, on voit que forward(), pencolor() ou encore penup() sont des fonctions mais dont la syntaxe d'utilisation est un peu étrange.
Ses fonctions particulières qui agissent sur l'objet placé devant elles se nomment des méthodes.
Quelle est cette syntaxe ? On donne le nom d'un objet sur lequel agir, on place un point et on donne ensuite le nom de la méthode et les données sur lesquelles la méthode devra travailler :
objet.methode(données)
✌ 07° Dessiner (après avoir déclaré un crayon) un carré de 200 pixels de côté en utilisant une séquence d'instructions précises et ordonnées.
Les couleurs des côtés devront être "red", "pink", "blue" et "orange".
...CORRECTION...
Si vous n'avez plus de crayon en mémoire, ni même le module Turtle, il faut retaper ceci :
>>> import turtle as trt
>>> crayon = trt.Turtle()
Ensuite, on part sur la création de la forme elle-même/
>>> crayon.clear()
>>> crayon.penup()
>>> crayon.home()
>>> crayon.pendown()
>>> crayon.pencolor('red')
>>> crayon.forward(200)
>>> crayon.right(90)
>>> crayon.pencolor('pink')
>>> crayon.forward(200)
>>> crayon.right(90)
>>> crayon.pencolor('blue')
>>> crayon.forward(200)
>>> crayon.right(90)
>>> crayon.pencolor('orange')
>>> crayon.forward(200)
>>> crayon.right(90)
08° Le dessin serait-il le même si on traçait les instructions dans un ordre aléatoire ?
...CORRECTION...
Non, nous obtiendrions un dessin différent.
09° Si je vous demande de tracer un nouveau carré, qu'allez-vous devoir faire ? Est-ce que ça a l'air sympa comme idée ?
...CORRECTION...
Pour tracer un nouveau carré, il faudra retaper toutes les instructions... A part la première (celle où on crée le crayon) si vous n'avez pas encore relancé Thonny.
Et non, l'idée d'avoir à tout retaper à chaque fois qu'on veut tracer un carré n'a rien de réjouissant !
3 - Programme et Dessin
Si vous êtes ici, vous avez dû vous rendre compte de la séquentialité : à la moindre erreur, pas possible de repartir en arrière. L'interpréteur a exécuté votre ligne, tant pis...
Nous allons maintenant quitter la console et écrire des programmes qui réalisent directement nos dessins.
Nous allons maintenant voir comment programmer et enregistrer plutôt que d'exécuter immédiatement dans la console. Nous allons utiliser une nouvelle zone de Thonny.
Nous allons donc maintenant travailler dans la zone du haut, celle qui permet de créer des scripts.
Nous allons créer au début un petit programme qui ne fait que 2 choses :
- Créer un crayon
- Utiliser le crayon pour dessiner un rectangle
10 ✔° Copier-coller le programme suivant dans la zone du haut de Thonny, celle permettant de créer le script (celle sans les trois chevrons) :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 | import turtle as trt
crayon = trt.Turtle()
crayon.pencolor('red')
crayon.forward(200)
crayon.right(90)
crayon.pencolor('blue')
crayon.forward(200)
crayon.right(90)
crayon.pencolor('red')
crayon.forward(200)
crayon.right(90)
crayon.pencolor('blue')
crayon.forward(200)
crayon.right(90)
|
Attention
Vous saviez déjà qu'il ne faut JAMAIS cliquer sur l'un des fichiers qui apparaissent parfois dans la console lorsqu'une erreur d'exécution apparaît.
Deuxième chose à ne JAMAIS faire : vous allez enregistrer votre programme en lui donnant un nom. N'utilisez pas le nom d'un des modules Python qui existent déjà : turtle, random, math... Sinon, vous ne pourriez plus utiliser le module turtle par exemple. Du moins tant que vous n'aurez pas supprimer votre faux fichier turtle.
11 ✔° Utiliser FILE - SAVE AS ou FICHIER - ENREGISTRER SOUS pour enregistrer le fichier (que vous nommerez acti_turtle.py) dans un dossier que vous parviendrez à retrouver facilement. Le mieux est donc d'ouvrir votre dossier personnel sur le réseau, d'y créer un repertoire NSI, puis un répertoire PYTHON2 et de sauvegarder votre programme dans ce sous-répertoire.
Si vous ne savez pas gérer cela, pensez à demander de l'aide !
Vous devriez voir apparaître ceci :
C'est comme si vous aviez tapé ces instructions dans la console SAUF que, si vous voulez tracer un autre rectangle, il suffit de réappuyer sur la flèche verte pour relancer le script.
✌ 12° Modifier le programme pour tracer un rectangle vert :
13 ✔° Pour être certain que vous ayez compris le principe de l'exécution séquentielle du programme, nous allons demander à l'interpréteur de l'exécuter ligne par ligne.
- Lancer le programme en mode DEBUG : n'appuyer pas sur la flèche verte mais juste à droite, sur le petit insecte (bug).
- L'interpréteur va alors surligner la ligne qu'il va exécuter lorsque vous lui en donnerait l'autorisation.
- Donner l'autorisation d'interpréter et d'exécuter la ligne surlignée (et de passer à la suivante) en appuyant sur le bouton à droite de l'insecte.
A vous de valider progressivement les lignes de façon à tracer la forme en visualisant bien que Python les exécute une à une dans l'ordre prédéfini.
Maintenant que vous savez créer un programme, voyons quelques nouveautés sur Turtle.
14 ✔° Utiliser le programme ci-dessous qui montrent comment utiliser deux nouvelles méthodes de Turtle.
- goto() permet de déplacer le crayon en fournissant les coordonnées x et y à atteindre (en utilisant le repère cartésien).
- write() d'écrire un texte à l'endroit où se trouve la tortue.
Voici le visuel que provoquera ce nouveau programme :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 | import turtle as trt
crayon = trt.Turtle()
crayon.goto(0, 0)
crayon.write("x = 0, y = 0")
crayon.goto(250, 0)
crayon.write("x = 250, y = 0")
crayon.goto(250, 250)
crayon.write("x = 250, y = 250")
crayon.goto(-250, 250)
crayon.write("x = -250, y = 250")
crayon.goto(-250, -250)
crayon.write("x = -250, y = -250")
crayon.goto(0, -50)
crayon.write("x = 0, y = -50")
|
✌ 15° Tracer un triangle isocèle dont les coordonnées sont les suivantes :
- x = 0, y = 0
- x = 200, y = 0
- x = 100, y = 50
On peut donc rajouter ces deux nouvelles séries d'instructions :
Encart d'instructions n°9
>>> crayon.goto(50,100)
✱ On amène le crayon à la position x = 50 et y = 100.
On notera que si le crayon est abaissé, on trace un trait.
Si vous voulez bouger la position sans tracer le trait, il faut agir en 3 temps :
- Lever le crayon avec penup()
- Bouger le crayon avec goto() en lui fournissant les coordonnées entre les parenthèses
- Abaisser le crayon avec pendown()
>>> crayon.penup()
>>> crayon.goto(50,100)
>>> crayon.pendown()
Encart d'instructions n°10
>>> crayon.write("Bonjour")
✱ Ecrit le message Bonjour sur la localisation actuelle de la tortue.
16 ✔° Lire les encarts 11 et 12, lancer le programme pour vérifier que vous comprennez bien pourquoi le dessin est généré de cette façon :
Encart d'instructions n°11
>>> crayon.dot(45, "red")
✱ Affiche un point de 45 pixels de large et de couleur rouge. La tortue reste au centre du point.
Encart d'instructions n°12
>>> crayon.circle(80, 180)
✱ Trace un arc de cercle de 80 pixels de rayon et sur un angle de 180°. Cela revient donc à tracer un demi-cercle puisque :
- Avec 360°, on obtient un cercle entier.
- Avec 180°, on obtient un demi-cercle.
- Avec 90°, on obtient un quart de cercle.
- Avec 45°, on obtient un huitième de cercle.
>>> crayon.circle(80)
✱ Trace un arc de cercle complet de 80 pixels de rayon. On ne donne pas d'indication d'angle. Par défaut, Turtle est configuré pour prendre 360° dans ce cas.
1
2
3
4
5
6 | import turtle as trt
crayon = trt.Turtle()
crayon.pencolor("red")
crayon.dot(50, "green")
crayon.circle(100, 180)
|
✌ 17° Lire l'encart 13 qui explique le rôle de setheading(). Modifier ensuite le programme pour obtenir un visuel proche de celui qui est proposé ici. Pour l'instant, vous n'avez qu'une partie des cercles.
Encart d'instructions n°13
>>> crayon.setheading(45)
✱ Impose que la tortue soit maintenant orientée à 45° par rapport à l'axe vertical. Comprenez bien qu'il ne s'agit pas de tourner de 45° par rapport à l'angle actuel mais de s'orienter vers l'angle 45° quelque soit l'orientation actuelle de la tortue.
Voici un descriptif visuel des différents angles :
Il faut également comprendre que :
- 315° pour s'écrire également -45°
- 270° pour s'écrire également -90°
- 245° pour s'écrire également -135°
- 180° pour s'écrire également -180
1
2
3
4
5
6
7
8
9 | import turtle as trt
crayon = trt.Turtle()
crayon.pencolor("red")
crayon.setheading(0)
crayon.circle(100)
crayon.setheading(45)
crayon.circle(100)
|
L'intérêt fondamental de setheading() est de pouvoir régler la direction de la tortue quelque soit la direction qu'elle avait avant.
On peut ainsi être certain d'orienté la tortue dans la direction voulue.
18 ✔° Lire l'encart 14 qui explique le rôle de pensize(). Utiliser le programme permettant de tester son utilisation.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 | import turtle as trt
crayon = trt.Turtle()
crayon.pencolor("red")
crayon.pensize(3)
crayon.forward(100)
crayon.left(90)
crayon.pensize(6)
crayon.forward(100)
crayon.left(90)
crayon.pensize(9)
crayon.forward(100)
crayon.left(90)
crayon.pensize(12)
crayon.forward(100)
crayon.left(90)
|
Encart d'instructions n°14
>>> crayon.pensize(10)
✱ Fixe la largeur du crayon à 10 pixels.
19 ✔° Pour colorier l'intérieur d'une forme, c'est un peu plus compliqué. Cela se réalise en 4 temps.
- crayon.fillcolor("yellow") : on définit la couleur de remplissage à utiliser.
- crayon.begin_fill() : on demande de surveiller la forme qu'on va lui demander de dessiner : c'est le début de la forme à remplir.
- Ensuite, on dessine notre forme avec une, deux ou plusieurs instructions.
- crayon.end_fill() : on signale qu'on a fini de dessiner la forme et qu'on désire la remplir.
Tester le programme ci-dessous de façon à tracer un carré à fond jaune ayant une bordure rouge puis un cercle à fond orange ayant une bordure bleue.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 | import turtle as trt
crayon = trt.Turtle()
crayon.pencolor("red")
crayon.pensize(10)
crayon.fillcolor("yellow")
crayon.begin_fill()
crayon.forward(100)
crayon.left(90)
crayon.forward(100)
crayon.left(90)
crayon.forward(100)
crayon.left(90)
crayon.forward(100)
crayon.left(90)
crayon.end_fill()
crayon.pencolor("blue")
crayon.fillcolor("orange")
crayon.begin_fill()
crayon.circle(50)
crayon.end_fill()
|
✎ 20° Utilisez le temps qu'il vous reste pour réaliser le dessin le plus sympa possible. La fiche ci-dessous récapitule les actions vues aujourd'hui. Aller voir la partie Frequently Asked Questions (FAQ) pour voir comment personnaliser les couleurs si vous le voulez.
Vous allez être noté sur l'originalité mais également sur l'utilisation des différentes instructions proposées dans les parties précédentes.
- Des carrés, des triangles et/ou des rectangles
- Des cercles
- Plusieurs couleurs et épaisseurs de crayon.
- Plusieurs fonds colorés
- Utilisation de goto() et penup(), pendown().
Mémo Turtle
Création du crayon
N'oubliez pas d'importer au préalable le module Turtle avec import turtle as trt par exemple.
Voici quelques méthodes qu'on peut appliquer aux objets de classe Turtle, qu'on crée à l'aide de
crayon = trt.Turtle().
Commandes de base
Pour avancer : crayon.forward(50) permet d'avancer de 50 pixels.
Pour reculer : crayon.backward(50) permet de reculer de 50 pixels.
Pour tourner à droite : crayon.right(45) permet de tourner de 45° à droite par rapport à l'orientation actuelle.
Pour tourner à gauche : crayon.left(45) permet de tourner de 45° à gauche par rapport à l'orientation actuelle.
Pour orienter le crayon sur un angle de 45° absolu (0° étant la droite horizontale) : crayon.setheading(45)
Pour changer la couleur du crayon : crayon.pencolor("red").
Déplacements aux coordonnées voulues
Pour aller faire un mouvement linéaire jusqu'au point de coordonnées (x=50,y=100), 3 manières de procéder :
- crayon.goto(50, 100)
- crayon.setposition(50, 100).
- crayon.setpos(50, 100)
Dans le cadre de ce site, on utilisera uniquement le goto(). Mais si vous trouvez des programmes sur le Web utilisant les autres, vous savez maintenant que cela réalise la même action.
Pour faire un mouvement horizontal jusqu'à atteindre la valeur donnée en x=50 : crayon.setx(50).
Pour faire un mouvement vertical jusqu'à atteindre la valeur donnée en y=100 : crayon.sety(100).
Pour revenir au point d'origine : crayon.home().
Dessiner des cercles ou d'autres formes encore
Pour dessiner un cercle de rayon x : crayon.circle(x).
Pour dessiner un arc de cercle d'angle 180° et de rayon 60 pixels : crayon.circle(60, 180).
Pour tracer des polygones de "rayon" 60 pixels possèdant 8 côtés : crayon.circle(60, 360, 8).
Pour placer un point de rayon 5 et de couleur rouge : crayon.dot(5, "red").
DESSINER, ARRÊTER DE TRACER OU SUPPRIMER
Pour lever la pointe du crayon : crayon.penup().
Pour abaisser la pointe du crayon : crayon.pendown().
Texte
Pour écrire un texte : crayon.write("bonjour").
Taille et vitesse du crayon
Pour modifier la vitesse x, x variant de 1 à 10 : crayon.speed(3), x=0 veut dire pas d'animation.
Pour augmenter la taille du crayon : crayon.pensize(5).
Cela nous suffira mais vous pouvez aller voir la documentation Python pour voir ce que le module peut faire d'autre : DOCUMENTATION TURTLE PYTHON.
4 - FAQ
Et si on peut avoir un dessin plus compliqué et plus joli ?
Oui, mais on utilisera beaucoup de choses que nous n'avons pas encore vu pour le moment. Un exemple :
1
2
3
4
5
6
7
8
9
10 | |
Et si on veut une couleur particulière ?
Vous n'êtes pas obligé de fournir un nom de couleur.
Vous pouvez également fournir un code RGB donnant l'intensité de Rouge, de Vert et de Bleu.
L'intensité d'une de ces couleurs doit varier de 00 (rien) à FF (intensité maximale).
Pour l'instant, limitez vous à 00 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF.
Dans le code transmis, il faudra rajouter un dièse # avec les 3 séquences RGB.
Exemples :
- "#FF0000" donne , du rouge intense équivalent à "red"
- "#AA0000" donne , du rouge plus foncé
- "#660000" donne , du rouge très foncé
- "#00FF00" donne , du vert intense équivalent à "green"
- "#00AA00" donne , du vert plus foncé
- "#006600" donne , du vert très foncé
- "#0000FF" donne , du bleu intense équivalent à "blue"
- "#0000AA" donne , du bleu plus foncé
- "#000066" donne , du blue très foncé
- "#FFFF00" donne , du jaune intense équivalent à "yellow"
- ...
Activité publiée le 01 11 2020
Dernière modification : 23 06 2022
Auteur : ows. h.