Aller au contenu

Variables et types

A propos du chapitre

Objectif :

  • Utiliser une variable pour paramétrer un dessin
  • Comprendre qu'une variable représente une valeur abstraite
  • Associer une valeur à une variable
  • Comprendre l'idée d'intention dans le code.
  • Comprendre le concept de type de valeur
  • Effectuer des calculs basiques en python

Modalités :

  • Programmation (Basthon)
  • De la réflexion autour du code

Prérequis : "Programmation/Séquence et Turtle"

Difficulté : facile mais un peu perché ...

remarque prof : les activités de l'introduction demandent de se chronométrer. Comme les téléphones sont interdits, les faire utiliser un chronomètre sur l'ordi (par 2, un chrono et un code) ou solo en affichant un chrono au tableau.

*FIXME prof : dans le cours on utilise beaucoup "l'utilisateur", faudrait essayer de trouver un truc plus neutre. Peut être "qui vous demande" au lieu de "qui demande à l'utilisateur" ?

Introduction : paramètre ?

Dans l'introduction, j'ai dit que le but du dessin paramétrique était de pouvoir modifier un dessin le plus rapidement et simplement possible.

Mesurons un peu.

Activité : briefing !

Mettez-vous par paires. Il est aussi possible de rester en solo.

Par groupe :

  • Vous aurez besoin de deux ordinateurs.
  • Sur l'un, mettez ce chapitre du cours et Basthon
  • Sur l'autre, ouvrez le chrono en cliquant sur ce lien
  • La personne qui a le chronomètre donne le départ pour résoudre la mission.
  • L'autre doit alors résoudre la mission le plus vite possible.
  • N'hésitez pas à alterner les rôles.

En solo :

  • Vous n'avez besoin que d'un ordinateur.
  • Vous pouvez utiliser le chrono à ce lien
  • Ou alors utiliser le chrono au tableau,
  • Pour plus de simplicité, commencez pile sur une minute.

Déroulement d'une mission :

  • Lisez le sujet de l'activité et le descriptif de la mission sans ouvrir les dépliants.
  • Quand le départ est donné, la personne qui résouds la mission a le droit d'ouvrir les dépliants, et doit résoudre la mission le plus vite possible.
  • Si la mission a une limite de temps, la personne chargée du chrono prévient l'autre quand la limite est atteinte.
  • N'oubliez pas de noter votre score !

Activité : C'est carré !

Votre mission

L'agent Félix nous a envoyé un code Turtle qui dessine le carré suivant.

alt text

Malheureusement, il a été distrait par une pelote de laine, et le carré est trop petit.

Vous devez ABSOLUMENT doubler la taille du carré en moins de 3 minutes !

Vite, le temps presse !

Dépliant avec le code 
from turtle import *

speed(0)

begin_fill()
forward(100)
left(90)
forward(100)
left(90)
forward(100)
end_fill()


done()

Activité : c'esT moiNS carré !

Votre mission

L'agent Félix nous a envoyé une version améliorée du code Turtle !

Il dessine maintenant la figure suivante :

alt text

Malheureusement, il a été distrait par une souris (d'ordinateur, aucun animal n'a été maltraité pour l'écriture de ce chapitre !), et le carré en haut à gauche est trop grand !

Vous devez ABSOLUMENT DIVISER PAR 2 la taille du carré en haut à gauche en moins de 5 minutes !

VITE, le temps presse !

Dépliant avec le code 
from turtle import *

speed(0)

begin_fill()
forward(100)
left(90)
forward(100)
left(90)
forward(100)
end_fill()

forward(100)
left(90)
forward(100)
left(90)
forward(100)
right(180)

begin_fill()
forward(100)
left(90)
forward(100)
left(90)
forward(100)
end_fill()

forward(100)
left(90)
forward(100)
left(90)
forward(100)

done()

Activité : C'357 P45 C4rr3 !

Votre mission

L'agent Félix nous a envoyé une version encore plus puissante du code Turtle !

Il dessine maintenant la figure suivante :

alt

Malheureusement, il a été distrait par un pointeur laser , et la figure est un peu trop petite !

Vous devez ABSOLUMENT multiplier la taille de la figure par 1.25 en moins de 5 minutes !

VITE, le temps PRESSE !

Dépliant avec le code 
from turtle import *

speed(0)

begin_fill()
forward(100)
left(120)
forward(50)
right(30)
forward(60)
left(60)
forward(100)
left(140)
forward(40)
right(55)
forward(145)
left(70)
forward(40)
right(35)
forward(75)
left(110)
forward(100)
left(88)
forward(40)


end_fill()


done()

Activité : 3'& 🟦 🚹 i 🟦 !

Votre mission

L'agent Félix nous a envoyé la version ULTIME du code Turtle !

Il dessine maintenant la figure suivante :

alt text

Malheureusement, il a été distrait par le rébus de zinzin dans le titre de l'activité1 ! Le carré noir le plus bas dans la colonne de droite est trop petit !

Vous devez ABSOLUMENT multiplier par 1,5 la taille du carré noir le plus bas dans la colonne de droite en moins de 3 minutes !

VITE, LE TEMPS PRESSE !!!

Dépliant avec le code 
from turtle import *

speed(7)

begin_fill()
forward(200)
left(90)
forward(100)
left(90)
forward(400)
right(90)
forward(100)
right(90)
forward(400)
right(90)
forward(400)
right(90)
forward(100)
right(90)
forward(400)
left(90)
forward(100)
left(90)
forward(400)
right(90)
forward(100)
right(90)
forward(400)
left(90)
forward(100)
left(90)
forward(400)
left(90)
forward(400)
left(90)
forward(100)
left(90)
forward(400)
right(90)
forward(100)
right(90)
forward(200)
end_fill()


done()

Bon, bravo agent NOM, PRENOM, la planète n'est pas sauvée 2, mais vous avez fait de votre mieux !

Rejoignez la salle de SNT pour le debriefing !

Activité : debriefing

Vous n'avez peut-être pas réussi à faire les modifications des deux dernières missions dans le temps imparti.

Ne vous inquiétez pas, c'est normal.

Elles illustrent chacune une difficulté que l'on peut rencontrer quand on modifie un programme.

Prenez quelques minutes pour réfléchir à ce que peuvent être ces deux difficultés. (optionel : expliquez pourquoi elles posent un gros problème pour développer des programmes)

N'hésitez pas à échanger avec vos camarades.

Solution

L'avant dernière mission demande un changement qui n'est pas très compliqué à comprendre en principe, mais long parce qu'il faut modifier presques toutes les lignes du code pour un seul petit changement : le code est redondant.

La dernière mission demande un changement qui ne modifie pas énormément de lignes de code, mais qui demande de comprendre un code complexe.

Elles posent un problème dans la programmation : même avec un code de quelques lignes, c'est déjà la galère. A titre de comparaison, voici l'ordre de grandeur de quelques programmes :

Logiciel Usage Ordre de grandeur sloc Principaux langages
OpenFlappyBird Une version Libre de Flappy Bird 600 Java
SuperTux Une version Libre de Super Mario 100K C++
Terasology Une version Libre de Minecraft 130K Java
KDenLive Editeur vidéo non-linéaire 150K C++, C
Audacity Enregistrement et traitement audio 1M Python, C, C++
CPython Interpréteur Python le plus répandu 1.5M Python, C
Blender Modélisation 3D 2.3M C++, C, Python
llvm Suite de compilation pour les langages de la famille du C. 11M C++, C, Python, LLVM IR, ASM, CMake[^cmake], Objective C
Firefox Navigateur Web 25M C++, C, Python, JavaScript, ASM, Rust

Bon, si on peut faire des programmes aussi complexes, c'est qu'il y a une technique.

DES techniques :

  • Dans ce chapitre et le suivant, je vous explique comment résoudre la redondance, avec la généralisation et plus précisément la factorisation.
  • Dans le chapitre encore après, on verra comment résoudre la complexité, avec l'abstraction et le découpage.

Remarque prof

Diriger les élèves sur l'activité suivante (l'intention qui compte) en leur introduisant le problème, puis les laisser répondre et continuer en autonomie.

Intention

Perché !

le but de cette activité est de vous faire comprendre un concept important, mais un peu perché.

Les activités sont donc... un peu perchées également !

Prenez-les au sérieux et exposez toujours votre réponse à votre prof avant de regarder la solution !

Activité : c'est l'intention qui compte

Voici un programme qui ne marche pas : 

from turtle import *

forward(100)
left(90)
forward(100)
left(90)
forward(180)
left(90)
forward(100)

done()

Expliquez ce que vous ne savez pas, et pourquoi ce manque d'information rends ce code difficile, voir impossible à réparer.

Solution

On sait que le programme ne marche pas, mais on n'a aucun moyen de savoir pourquoi : on ne sait pas ce que le code doit faire !

Est-ce qu'il doit dessiner un carré de côté 100 ?

Est-ce qu'il doit dessiner un carré de côté 180 ?

Une figure un peu biscornue ?

Ca, c'est l'intention de notre programme : ce qu'on voudrait qu'il fasse.

Si l'intention de notre programme est bien exprimée, c'est beaucoup plus facile de le comprendre et de le modifier, que ce soit pour corriger une erreur ou pour changer son comportement.

Parfois, l'interpréteur peut même nous aider.

Activité : une solution ?

Disons que le programme proposé à l'activité précédente a bien pour but de dessiner un carré de côté 100.

Exprimez cette intention dans le code, et corrigez-le.

Non, vous j'ai pas complètement craqué, vous avez déjà vu une manière de faire.

Si vous ne vous en rappelez plus, relisez rapidement l'introduction du chapitre précedent, en sautant les activités.

Solution

On peut utiliser un commentaire :

from turtle import *

# ici, on dessine un carré de côté 100
forward(100)
left(90)
forward(100)
left(90)
forward(100)
left(90)
forward(100)

done()

remarque : j'ai corrigé

Activité : c'est bien, mais 🐐 ...

Quand je lui ai montré la solution de l'activité précédente, mon double maléfique, Xilef, a dit :

C'est pas mal, mais ça n'exprime pas que les 4 différents 100 sont en fait une seule et même valeur.

Expliquez ce qu'il voulait dire.

Quelle est cette "valeur" dont il parle ?

Pourquoi c'est important de savoir ça ?

Solution

En fait, les 4 différents 100 sont des valeurs différentes : on peut modifier chacune des valeurs indépendamment dans le code

Mais d'un autre côté, ces 4 différents 100 sont une seule et même valeur : la taille du carré.

C'est important de savoir ça, parce que si on modifie une des valeurs, il faut modifier les trois autres, sans quoi on ne dessinera plus un carré.

Pour exprimer ce dernier aspect, on pourrait utiliser un commentaire. Mais Python nous fournis un bien meilleur outils : les variables.

Variable

Une variable est une valeur abstraite que l'on désigne par un nom, eventuellement associée à une valeur concrète (par exemple 100).

Quand je parle de la taille du carré, c'est une valeur abstraite : je ne précise pas sa valeur concrète (par exemple, 100).

Et bien évidemment, la taille du carré, est le nom de la taille du carré.

Voici ce que ça donne en Python pour le code des activités précédentes : 

from turtle import *

# on définit la valeur abstraite 
#  "taille_carre" : c'est une variable
# et on lui associe la valeur 100
taille_carre = 100

# une fois définie, 
# On peut utiliser une variable dans la suite du code,
# partout où on peut utiliser une valeur numérique
# ici, on remplace 100 par la variable 
forward(taille_carre)
left(90)
forward(taille_carre)
left(90)
forward(taille_carre)
left(90)
forward(taille_carre)

done()

Activité : la magie des variables

Reprenez le code ci-dessus, et modifiez plusieurs fois la taille du carré.

Constatez que c'est très rapide une fois que vous avez compris le principe.

N'oubliez pas d'exécuter votre code pour vérifier que tout marche

Solution

On modifie juste la valeur concrête associée à la variable : 

from turtle import *


taille_carre = 200 #ici

forward(taille_carre)
left(90)
forward(taille_carre)
left(90)
forward(taille_carre)
left(90)
forward(taille_carre)

done()

Et puis ... c'est tout !

Activité : Mission 3, edition magique

Vous vous rappelez de votre score à la mission 3 ?

Vous avez mis quoi... une minute au moins ?

Vous trouverez dans le dépliant ci-dessous son code, mais modifié avec un coup de variable magique3.

Chronometrez le temps que vous mettez à faire la modification (multiplier la taille de la figure par 1,25) sur cette version. Constatez la puissance de la magie !

Dépliant avec le code 
from turtle import *

taille_figure = 100

speed(0)

begin_fill()
forward(100)
left(120)
forward(50 * taille_figure / 100)
right(30)
forward(60 * taille_figure / 100)
left(60)
forward(100 * taille_figure / 100)
left(140)
forward(40 * taille_figure / 100)
right(55)
forward(145 * taille_figure / 100)
left(70)
forward(40 * taille_figure / 100)
right(35)
forward(75 * taille_figure / 100)
left(110)
forward(100 * taille_figure / 100)
left(88)
forward(40 * taille_figure / 100)


end_fill()


done()

C'était tellement rapide et simple que vous n'avez pas eu à vous poser de question sur le reste du code. C'est ça la puissance de l'expressivité des variables !

Activité : triangle equilateral

Ecrivez le code d'un triangle équilatéral.

Utilisez une variable pour sa taille.

Solution 
from turtle import *

# On utilise une variable pour la taille du triangle
taille_triangle = 100

forward(taille_triangle)
left(120)
forward(taille_triangle)
left(120)
forward(taille_triangle)

done()

Activité : rectangle

Ecrivez le code d'un rectangle.

Utilisez des variables pour qu'on puisse modifier sa longueur et sa largeur.

Solution 
from turtle import *

#deux variables, une pour la largeur, une pour la longueur
largeur_rectangle = 100
longueur_rectangle = 200

#et on alterne les deux.
forward(largeur_rectangle)
left(90)
forward(longueur_rectangle)
left(90)
forward(largeur_rectangle)
left(90)
forward(longueur_rectangle)


done()

Couleur, input

Et ... on peut mettre de la couleur dans une variable ?

Tout à fait !

Activité : couleur paramétrique

Reprenez le code du rectangle de l'activité précédente, et ajoutez-lui une couleur (la même pour le trait et pour le remplissage).

utilisez une variable pour la couleur, histoire de pouvoir facilement la modifier.

Solution 
from turtle import *

largeur_rectangle = 100
longueur_rectangle = 200
couleur_rectangle = "blue" #variable de couleur.
# on oublie pas les ""

#on utilise la couleur pour le trait ET le remplissage
#sans guillements cette fois
color(couleur_rectangle)
fillcolor(couleur_rectangle)

begin_fill() 
forward(largeur_rectangle)
left(90)
forward(longueur_rectangle)
left(90)
forward(largeur_rectangle)
left(90)
forward(longueur_rectangle)
end_fill()

done()

Vous savez ce qui serait sympa ? De pouvoir rentrer la couleur au moment de lancer le programme, sans éditer le code.

Et ça tombe bien, Python nous fournis une instruction pour ça : input

instruction description exemple
input( MESSAGE ) affiche le message et demande une saisie à l'utilisateur. Retourne la valeur saisie. input("couleur ? ")

Activité : input

Voici un petit programme qui illustre le principe : 

# On utilise input, et on stocke le résultat dans une variable
couleur = input("Couleur ? ")

# ensuite, on peut utiliser la variable.
# Par exemple pour l'afficher dans la console.
print("Vous avez choisi la couleur :")
print(couleur)

Copiez-collez le code ci-dessus dans Basthon.

Executez le.

Allez dans la vue console :

vue console

Vous devriez voir s'afficher couleur ? avec un curseur qui clignote.

entrez couleur

Ecrivez dans la console le nom d'une couleur, sans les guillements :

couleur entree

Puis, appuyez sur la touche ENTREE.

Vous devriez voir la bonne couleur s'afficher :

couleur choisie

Activité : forme input

Ecrivez un programme qui:

  • Demande une couleur à l'utilisateur
  • Dessine une forme de la couleur choisie
Solution 
from turtle import *

# Je reprends le rectangle d'une activité précédente
# on demande la couleur
couleur_rectangle = input("couleur du rectangle ? ")

largeur_rectangle = 100
longueur_rectangle = 200

# on utilise la couleur
color(couleur_rectangle)
fillcolor(couleur_rectangle)

begin_fill() 
forward(largeur_rectangle)
left(90)
forward(longueur_rectangle)
left(90)
forward(largeur_rectangle)
left(90)
forward(longueur_rectangle)
end_fill()

done()

Et pour la taille ?

Activité : erreur !

Le code suivant demande une largeur à l'utilisateur, et dessine un rectangle de cette largeur.

from turtle import *

largeur_rectangle = input("largeur du rectangle ? ")

longueur_rectangle = 200

couleur_rectangle = "blue"

color(couleur_rectangle)
fillcolor(couleur_rectangle)

begin_fill() 
forward(largeur_rectangle)
left(90)
forward(longueur_rectangle)
left(90)
forward(largeur_rectangle)
left(90)
forward(longueur_rectangle)
end_fill()

done()

Executez-le, donnez lui une largeur quand il vous la demande.

Essayez de décortiquer le message d'erreur pour vous faire une vague idée du problème

Solution

Le message d'erreur est un TypeError. Une "erreur de typage" ?

L'erreur ne semble pas venir de notre code.

"Il est impossible de multiplier une séquence par un non-entier de type float" ???

Pour comprendre ce message, et corriger le programme, il faut qu'on aborde une notion : les types.

Types de valeurs

Un type de valeurs, c'est une manière de classer les valeurs, en fonction de leur sens, et surtout des opérations qu'on peut leur appliquer.

Pour le moment, vous avez vu deux types :

  • Les entiers : 100, 200, 123, ...
  • Les chaines de caractères : "blue", "pink". En gros, c'est du texte.

Il existe d'autres types en Python, entre autres :

  • Les flottants, qui sont des nombres décimaux : 1.30, 23.5, 2.0, ... (remarquez que c'est un point, et pas une virgule : c'est la notation anglaise qui est utilisée dans Python).

Voici un petit tableau qui récapitule :

Nom du type en francais Nom du type en Python exemples
Entiers int 100, 200, -42, 31
Chaînes de caractères (texte) str (prononcé "STR" ou "string") "Never" "Gonna", "give", "you", "up"4
Nombre décimaux (flottants) float 1.25, 2.0, -45.3230

Activité : quel type ?

On peut connaître le type d'une valeur avec l'instruction type:

# on crée une valeur
valeur = "bonjour"

# on récupère le type de la valeur
type_de_valeur = type(valeur)

# on l'affiche
print("la valeur est de type :")
print(type_de_valeur)

Executez ce programme et vérifiez que ce qu'il affiche en console est cohérent avec le tableau présenté plus haut.

Solution

C'est cohérent. Le programme affiche :

<class 'str'>

On retrouve bien le str qui corresponds à une chaine de caractères.

Activité : type de retour de input ?

Ecrivez un programme qui permet de connaître sous quel type input renvoie la saisie de l'utilisateur.

Testez-le avec différentes saisies : tata, 100 , ...

Solution

on peut reprendre le programme de l'activité précédente et le modifier

# on récupère la valeur entrée par l'utilisateur
valeur = input("entrez une valeur : ")

# on récupère le type de la valeur
type_de_valeur = type(valeur)

# on l'affiche
print("la valeur est de type :")
print(type_de_valeur)

Vous pouvez remarquer que le type est TOUJOURS str.

Même quand on entre 100 dans la console, la valeur de retour est de type str. C'est donc "100" et pas 100.

Les différentes instructions Python attendent souvent un type en particulier. Par exemple : 

forward ( DISTANCE ) #ici, DISTANCE doit être une valeur de type int (ou float).

Ça permet de détecter des incohérence dans le code : utiliser un texte comme valeur de distance n'a AUCUN SENS. Si ça arrive, c'est probablement une erreur de programmation. Et donc l'interpréteur lève une TypeError pour nous prévenir.

Activité : contre exemple

Donnez un exemple de texte qui pourrait faire sens comme valeur de distance

Solution

Un exemple est... "100", ou n'importe quelle str qui représente un nombre.

Dans le cas de telles valeurs, on peut convertir une valeur d'un type vers un autre, avec une opération qui s'appelle le transtypage.

Voici un exemple :

str_102 = "102"

# pour transtyper une valeur, 
# on utilise l'instruction :
# NOM_DU_TYPE(LA_VALEUR)
int_102 = int(str_102)

Attention, le transtypage ne marche que si la valeur peut être convertie. Ainsi int("toto") lève une erreur, puisque "toto" ne représente pas un entier.

Activité : enfin la largeur !

Vous avez maintenant tous les éléments pour corriger le code de l'activité qui créait une erreur de type : 

from turtle import *

largeur_rectangle = input("largeur du rectangle ? ")

longueur_rectangle = 200

couleur_rectangle = "blue"

color(couleur_rectangle)
fillcolor(couleur_rectangle)

begin_fill() 
forward(largeur_rectangle)
left(90)
forward(longueur_rectangle)
left(90)
forward(largeur_rectangle)
left(90)
forward(longueur_rectangle)
end_fill()

done()

Alors corrigez-le

Solution 
from turtle import *
#on transtype simplement la largeur du rectangle en int
largeur_rectangle_str = input("largeur du rectangle ? ")
largeur_rectangle = int(largeur_rectangle_str)

longueur_rectangle = 200

couleur_rectangle = "blue"

color(couleur_rectangle)
fillcolor(couleur_rectangle)

begin_fill() 
forward(largeur_rectangle)
left(90)
forward(longueur_rectangle)
left(90)
forward(largeur_rectangle)
left(90)
forward(longueur_rectangle)
end_fill()

done()

On aurait aussi pu faire la transformation en une seule ligne :

#on transtype simplement la largeur du rectangle en int
largeur_rectangle= int(input("largeur du rectangle ? "))

Activité : full param

Ecrivez un programme qui demande à l'utilisateur :

  • Une largeur
  • Une longueur
  • Une couleur

Et dessine le rectangle correspondant.

n'hésitez pas à partir d'un code existant

YEN A MARRE DES RECTANGLES !!!!

Je vous comprends un peu. Courage. Vous êtes bientôt au bout du chapitre.

Le prochain chapitre, c'est le décollage : on va commencer à voir des outils python pour dessiner beaucoup et très rapidement !

Solution 
from turtle import *
#on transtype simplement la largeur du rectangle en int
largeur_rectangle = int(input("largeur du rectangle ? "))
longueur_rectangle = int(input("longueur du rectangle ? "))

couleur_rectangle = input("couleur du rectangle ? ")

color(couleur_rectangle)
fillcolor(couleur_rectangle)

begin_fill() 
forward(largeur_rectangle)
left(90)
forward(longueur_rectangle)
left(90)
forward(largeur_rectangle)
left(90)
forward(longueur_rectangle)
end_fill()

done()

Un peu de calcul

En Python, on peut effectuer des calculs sur des int et des floats, avec les opérateurs suivants :

opérateur description exemples
A + B Additionne A et B 10 + 10, 5.5 + 2.3, -3 + 2.1
A * B Multiplie A et B 10 * 10, 5.5 * 2.3, -3 * 2.1
A - B Soustrait B à A 10 - 10, 5.5 - 2.3, -3 - 2.1
A / B Divise A par B 10 / 10, 5.5 / 2.3, -3 / 2.1

Pour ce qui est des types :

  • Une opération entre deux int donne toujours un int
  • Une opération entre deux float donne toujours un float
  • Une opération entre un int et un float donne toujours un float.

Activité : ratio

Ecrivez un programme qui demande à l'utilisateur une largeur, et dessine un rectangle de cette largeur, et avec une longueur qui fait le double de la largeur.

Solution 
from turtle import *

largeur_rectangle = int(input("largeur du rectangle ? "))
#ici, on calcule au lieu de demander une valeur
longueur_rectangle = largeur_rectangle * 2

couleur_rectangle = "blue"

color(couleur_rectangle)
fillcolor(couleur_rectangle)

begin_fill() 
forward(largeur_rectangle)
left(90)
forward(longueur_rectangle)
left(90)
forward(largeur_rectangle)
left(90)
forward(longueur_rectangle)
end_fill()

done()

Activité : carré centré

Ecrivez un programme qui dessine un carré en utilisant une variable pour sa taille (Donnée par l'utilisateur ou directement définie dans le code.).

Le carré doit être centré dans la zone de dessin, et doit rester centré si on modifie sa taille !

TODO prof : ajouter capture ?

Solution : forward

Il y a plusieurs manières de faire. Je vous en présente une ici.

On se décale vers le haut à gauche de la moitié de la taille du carré, puis on trace un carré qui s'étends vers le bas à droite.

from turtle import *

taille_carre = 200

speed(7)

# déplacement vers le haut à gauche, sans dessiner.
penup()
right(180)
forward(taille_carre / 2)
right(90)
forward(taille_carre / 2)
right(90)
pendown()

# on trace le carré
forward(taille_carre)
right(90)
forward(taille_carre)
right(90)
forward(taille_carre)
right(90)
forward(taille_carre)

done()
Solution : goto

Cette solution est un peu plus calculatoire, mais peut être plus "propre" à lire si vous êtes à l'aise en maths.

On calcule les coordonnées et 4 points du carré et on les rejoins avec des goto

from turtle import *

taille_carre = 200

t = taille_carre / 2 #t est la moitié de la taille du carré

speed(7)

penup()
goto(-t, -t) #on rejoint un coin sans dessiner
pendown()

#on dessine les quatre coins. Attention l'ordre a une importance !
goto(-t, t)
goto(t, t)
goto(t, -t)
goto(-t, -t)

done()

Activité : Triangle centré

TODO continuer ici

Extensions

Maison pokémon

En cours d'écriture. Me demander si vous voulez le faire.

TODO prof : a ajouter

Mission 4 : la "revanche"

A propos de l'extension

Objectif :

  • Vous retourner le cerveau avec un défi dont vous sortirez avec beaucoup de fierté (ou de déception...)
  • Transformer la mission 4 en dessin paramétrique pour pouvoir modifier la taille du carré à votre guise.

Modalités :

  • Programmation (Basthon)
  • De la réflexion autour du code.
  • Du calcul
  • (Peut être quelques larmes aussi)

Prérequis : Avoir vu le chapitre en entier

Difficulté : Cataclysmique

Activité : bon courage !

Dessinez la figure de la mission 4 de manière paramétrique en utilisant une variable, pour pouvoir modifier facilement la taille du carré cible (le carré noir en bas dans la colonne la plus à droite.)

Les colorations doivent être préservées, ainsi que la taille et le contact entre les carrés. Le carré en bas à droite doit être "tiré" ou "poussé" pour toujours être collé au carré cible.

Au cas où, voici le code de la mission dans le dépliant.

Dépliant avec le code 
from turtle import *

speed(7)

begin_fill()
forward(200)
left(90)
forward(100)
left(90)
forward(400)
right(90)
forward(100)
right(90)
forward(400)
right(90)
forward(400)
right(90)
forward(100)
right(90)
forward(400)
left(90)
forward(100)
left(90)
forward(400)
right(90)
forward(100)
right(90)
forward(400)
left(90)
forward(100)
left(90)
forward(400)
left(90)
forward(400)
left(90)
forward(100)
left(90)
forward(400)
right(90)
forward(100)
right(90)
forward(200)
end_fill()


done()

Mais vous pouvez aussi repartir de 0 si vous préférez.

Solution

Un peu de RAP

En cours de construction

Cette extension est en cours de construction.

Si vous vous y lancez, vous ne pourrez pas aller jusqu'au bout.

A propos de l'extension

Objectif :

  • Comprendre la différence entre rime et assonance.
  • Comprendre l'idée de rythme dans une poésie/un rap.
  • Ecrire quelques lignes de rap

Modalités :

  • juste de la lecture

Prérequis : aucun.

Difficulté : facile

Le mot paramètre est assez intéressant pour faire quelques lignes de rap.

Le rap, c'est pas seulement des rimes, c'est de la musicalité dans le texte.

Paramètre contient beaucoup de sons durs (pa, ra, tre).

Pour donner de la musicalité, on peut faire quelques rimes

Deux mots riment quand ils se terminent par le même son. Par exemple manger et dang**er.

Activité : rimes

Trouvez quelques mots qui riment avec paramètre. Notez-les éventuellement sur un papier.

Solution

En voici quelques uns :

  • maître
  • mètre
  • hètre
  • diamètre
  • connaître

Maintenant, on peut utiliser ces rimes pour faire quelques lignes.

les lignes doivent avoir le même nombre de syllabes, (11)

afin que la chanson soit bien musicale (11)

Activité : quelques lignes

Ecrivez maintenant 4 ligne ou plus en les terminant par les mots que vous avez trouvé. (et paramètre, aussi !) Pas besoin que ça ait un sens profond, l'important c'est qu'on comprenne.

Et surtout, essayez d'avoir le même nombre de syllabes dans chaque ligne.

Solution

Je fais une sieste au pieds d'un hêtre

Avec un tronc de grand diamètre !

je suis curieux j'aimerai connaitre

L'univers et ses paramètres

Bon, c'est pas mal, mais ya pas de quoi en faire un rap !

C'est parce que des structures trop simple sont répétitives, et ennuyeuses. Le rap se base donc souvent sur d'autres structures, comme les assonances.

Deux mots sont assonants si ils présentent des sonorités similaires. Ca se joue surtout sur des voyelles similaires, mais aussi sur les consonnes. D'ailleurs, ça peut aussi être des groupes de mots.

Par exemple :

  • parametre
  • parallele

ou encore :

  • paramene
  • jl'a ramene

Les assonances ont aussi un gros avantages : elle permettent de faire des transitions dans les sonorités : en allant de proche en proche, on peut atteindre des sonorités différentes après 5-6 lignes. Et donc, de rendre le son moins ennuyeux.

Activité : assonances

Trouvez quelques assonances avec paramètre.

Vous pouvez vous aider du site rimesolides

Ou même demander à une IA !

Solution

J'en ai trouvé quelques autres

TODO continuer ici

  1. "C'est carrément horrible !". 3ème lettre de l'alphabet, C. ' inchangé. & esperluette, utilisé pour dire "et". 🟦 : carré. 🚹 toilettes hommes, hommes en anglais : mens. : heure. i inchangé. 🟦 bleu. ↩

  2. sauf si vous avez vraiment réussi à faire le dernier en moins de 3 minutes, dans ce cas là bravo, perso j'ai même pas essayé, LOL. ↩

  3. A la place d'une baguette. Une variguette ? Une baguiable ? ↩

  4. Je pense que ça compte comme un rickroll ↩