Mathématice, intégration des Tice dans l'enseignement des mathématiques  
Sommaire > N°80 - mai 2022 > 5 activités visuelles avec le langage Python (...)

5 activités visuelles avec le langage Python portant sur les notions transversales de programmation de seconde
Moteur de recherche
Mis en ligne le 2 mai 2022, par Anne Héam

N.D.L.R : Cet article pourra évidemment inspirer les collègues enseignant en SNT. Mais son ambition est de s’adresser surtout à l’ensemble des élèves de Seconde, au travers des activités transversales de cette classe.

Présentation des activités

Voici 5 activités visuelles de programmation en Python qui couvrent les notions transversales de la classe de seconde générale et technologique.
Deux d’entre elles utilisent le module turtle descendant du langage Logo qui initie depuis les années 60 les enfants à la programmation. Les trois autres s’appuient sur le module pixel, développé par l’université de Lille 3, qui permet d’obtenir des images pixelisées évolutives (une présentation de ce module est proposé en annexe).

Ces activités sont présentées dans l’ordre où je les propose en classe. Seule une partie de mes élèves font les deux dernières.

  • le TP Space invaders est mon premier TP de l’année scolaire de seconde, il introduit de façon détaillée les notions de variable, boucle bornée (boucle for) et de fonction. Une partie de mes élèves voient toutes ces notions dès la première heure, mais deux heures sont nécessaires pour que ce soit le cas d’une majorité d’élèves. Il utilise le module pixel.
  • le TP Fond marin porte également sur les notions de variable, boucle bornée (boucle for) et de fonction. Il peut servir à parler de la notion de modularité qui est plus développée dans le TP immeuble. Il utilise le module turtle en proposant des dessins un peu plus élaborés que les formes géométriques habituellement proposées. Il insiste sur la variable utilisée lorsqu’on utilise une boucle for. En limitant le nombre de lignes de code utilisé, il force à utiliser cette variable au lieu d’en définir une nouvelle et insiste sur les valeurs que prend cette variable à chaque appel. Contrairement à ce que je craignais, mes élèves n’ont pas été gênés par le côté répétitif de cette activité.
  • le TP Rantanplan est un exercice classique qui permet d’obtenir une image du triangle de Sierpinski à partir du dessin de milieux successifx. Cette version utilise le module pixel. Les notions utilisées sont la variable, la boucle et la conditionnelle. Cela permet également d’utiliser la formule des coordonnées du milieu de 2 points.
  • le TP Coquillage tueur est inspiré de l’article d’Accromath : des coquillages aux pelages. Il fait suite a une activité débranchée que l’IREM de Besançon avait proposée lors d’une fête de la science aux classes de primaire et qui avait beaucoup plu. Il est d’ailleurs souvent nécessaire de passer par le papier pour que les élèves comprennent et appliquent correctement l’algorithme proposé. Il utilise le module pixel et porte sur les notions de variable, de boucle for et de conditionnelle. On peut également s’en servir pour parler de la notion de suite (en effet chaque ligne est construite à partir de la précédente).
  • le TP Immeubles est né d’une idée d’Adrien Willm. Il est le pendant du TP Fond marin : dans chaque cas, le programme principal utilise des fonctions définies dans un autre fichier. Dans le cas du TP Fond marin, les élèves écrivent le programme principal et n’ont besoin que de regarder la documentation associée aux fonctions déjà définies. Dans le TP Immeubles, les élèves doivent écrire les fonctions intermédiaires ce qui les obligent à respecter leur spécifications, car sinon les fonctions qui les appellent ne produisent pas le résultat attendu. Ce TP utilise également le module turtle, il porte sur la notion de variable, de boucle, de conditionnelle et de fonction.

De l’inattendu

Après avoir fini l’activité Fond marin, certains élèves ont déploré que les poissons de profil ne sourient pas. "Ils font la tête vos poissons, madame. On peut les changer ?". Voici le résultat qui a provoqué un bon rire collectif.

Prolongation du TP Coquillage tueur

Avec une perforatrice qui découpe des triangles isocèles de 4 cm de base et 4 cm de hauteur, nous avons décoré le mur de fond d’une de nos salles en reprenant le principe de construction du TP Coquillage tueur.

D’autres ont été plus ambitieux :

TP Space invaders

Le but de ce Tp est d’écrire un programme avec le langage Python qui permet de dessiner un ensemble de space invaders colorés.

Présentation du jeu Space Invaders

Space Invaders est un jeu vidéo développé par la société japonaise Taito, sorti en 1978 sur borne d’arcade.

(source Cadeau insolite.fr)

Le principe est de détruire des vagues d’aliens au moyen d’un canon laser en se déplaçant horizontalement sur l’écran. Il fait partie des classiques du jeu vidéo au même titre que Pac-Man et d’autres de ses contemporains. Il contribue à élargir l’industrie du jeu vidéo au niveau mondial. Space Invaders rencontre un énorme succès populaire. Après sa sortie au Japon, il aurait entraîné une pénurie de pièces de 100 yens. En 2007, Taito annonce que le jeu a rapporté 500 millions de dollars de recettes depuis sa parution.

La représentation par des pixels des aliens dans le jeu devient une icône médiatique pour symboliser le monde des jeux vidéo.

Dessiner un pixel

À faire : Téléchargez l’archive spaceinvaders.zip et décompressez-la dans votre espace personnel.

spaceinvaders.zip

Vous ne devez jamais modifier les fichiers pixel.py et pixelSP.py.

À faire : Ouvrez le fichier spaceinvader.py dans un éditeur Python et exécutez-le, vous devez voir une fenêtre s’ouvrir sur laquelle il n’y a qu’un pixel vert.

À faire : Essayez de modifier la couleur de ce pixel, voici les couleurs qui sont prédéfinies : vert, bleu, rose, jaune, violat, turquoise, rouge, vertjaune, orange

À faire : Dessiner un pixel sur la même ligne à droite du pixel déjà présent dans la fenêtre.

Si vous n’arrivez pas à faire cette partie, regardez la vidéo d’aide

Montrez-moi votre travail.

Dessiner ligne à ligne un space invader

Choisissez un space invader et une couleur parmi ces modèles

À faire : Commencer à dessiner les 3 premières lignes de votre space invader en commençant par la première ligne, puis la seconde, puis la troisième :

Par exemple

C’est un peu répétitif, il est possible d’aller plus vite.

Les instructions pour dessiner la deuxième ligne sont :

dessine_pixel(2,2)
dessine_pixel(3,2)
dessine_pixel(4,2)
dessine_pixel(5,2)
dessine_pixel(6,2)

On remarque que seul le premier chiffre (qui représente la colonne) change d’une instruction à l’autre. Il varie en prenant successivement les valeurs 2, 3 , 4, 5 et 6. On va le remplacer par une variable k, on a alors l’instruction :
dessine_pixel(k,2)

Il faut maintenant indiquer comment varie la variable k, elle varie en prenant successivement les valeurs 2, 3 , 4, 5 et 6. On l’indique à l’ordinateur de la façon suivante :

for k in [2,3,4,5,6] :
   dessine_pixel(k,2)

Ces deux lignes de code remplacent les 5 lignes de code précédentes. Entre les crochets, il faut bien indiquer toutes les valeurs prises successivement par k. Il faut bien décaler la seconde ligne par rapport à la première.

Dans mon exemple, la première ligne du space invader peut être dessinée par le code suivant :

for k in [3,5] :
   dessine_pixel(k,1)

Et la troisième par :

for k in [1,2,3,4,5,6,7] :
   dessine_pixel(k,3)

À faire : Dessiner toutes les lignes de votre space invader en utilisant des instructions for. Pour que le dessin soit plus rapide remplacez toutes les fonctions dessine_pixel par dessine_pixel_rapide.

Si vous n’arrivez pas à faire cette partie, regardez la vidéo d’aide

Montrez-moi votre travail.

Dessiner un second space invader

À faire : Dessiner un second space invader identique au premier, décalé de 15 pixels sur la droite.

Si on considère la seconde ligne de mon space invader :

for k in [2,3,4,5,6] :
   dessine_pixel(k,2)

Il y a deux méthodes principales pour dessiner cette même ligne 15 pixels sur la droite :

  • ajouter 15 à toutes les valeurs de la liste des valeurs de k
    for k in [17,18,19,20,21] :
       dessine_pixel(k,2)
  • ajouter directement 15 à k dans l’instruction qui permet de dessiner un pixel
    for k in [2,3,4,5,6] :
       dessine_pixel(k+15,2)

    La seconde est la plus rapide, c’est celle que nous utiliserons par la suite. Les trois premières lignes de mon space invader sont donc codés par :

    for k in [3,5] :
       dessine_pixel(k+15,1)
    for k in [2,3,4,5,6] :
       dessine_pixel(k+15,2)
    for k in [1,2,3,4,5,6,7] :
       dessine_pixel(k+15,3)

À faire : Modifier le code de votre second space invader en utilisant la seconde méthode : dessine_pixel(k+15,...

Si vous n’arrivez pas à faire cette partie, regardez la vidéo d’aide

Dessiner une ligne de space invaders

Afin de dessiner une ligne de space invaders, on diminue la taille des pixels dans la fenêtre pour pouvoir en mettre plus.

À faire : Remplacer la ligne ouverture_fenetre() . Par initialiser(120, 80, 10). Vos space invaders apparaîtront plus petits.

Si au lieu de demander de décaler le deuxième space invader de 15 pixels sur la droite, je demande de ne le décaler que de 14 pixels puis de 16 pixels, vous allez devoir remplacer tous les +15 par de +14, puis par +16 ce qui est un peu fastidieux. Il y a plus simple :

On utilise une variable decalage pour indiquer à l’ordinateur le décalage voulu et on remplace les +15 par de +decalage, donc dans le cas des trois premières lignes de mon space invader :

decalage=15
for k in [3,5] :
   dessine_pixel(k+decalage,1)
for k in [2,3,4,5,6] :
   dessine_pixel(k+decalage,2)
for k in [1,2,3,4,5,6,7] :
   dessine_pixel(k+decalage,3)

À faire : Effacez les lignes de codes de votre premier space invader, ne gardez que celles du second. Ajouter la ligne decalage=15 et modifier le code de votre second space invader en utilisant decalage. Exécutez plusieurs fois votre programme en modifiant la valeur de dacalage dans l’instruction decalage=15.

Vous avez du remarquer qu’à chaque valeur de decalage est associée un space invader placé différemment sur la droite dans la fenêtre. Le fait d’associer à une valeur, un élément (ici un dessin de space invader) est le rôle des fonctions. On va donc définir une fonction bestiole qui prend comme argument le decalage vers la droite et associe un dessin de space invader plus ou moins décalé vers la droite.

Voici la définition de ma fonction bestiole qui ne dessine que les trois premières lignes du space invader que j’ai choisi :

def bestiole(decalage):
   for k in [3,5] :
       dessine_pixel(k+decalage,1)
   for k in [2,3,4,5,6] :
       dessine_pixel(k+decalage,2)
   for k in [1,2,3,4,5,6,7] :
       dessine_pixel(k+decalage,3)

Cette définition de la fonction bestiole n’est qu’une définition : il ne se produit rien si on l’écrit dans un programme. Il faut l’appeler avec une valeur pour decalage pour qu’un space invader soit dessiné :
bestiole(15)

Il y a autant de space invaders dessinés qu’il y a d’appels à la fonction bestiole. Ainsi :

bestiole(15)
bestiole(30)

permet de dessiner deux space invaders.

bestiole(15)
bestiole(30)
bestiole(45)

trois space invaders.

À faire : Définissez une fonction bestiole qui dessiner votre space invader. Pour cela il y a peu de modification à faire par rapport au code que vous avez déjà écrit mais il faut bien respecter des décalages entre les lignes.
Dessinez une ligne de space invader.

Si vous n’arrivez pas à faire cette partie, regardez la vidéo d’aide

Si ce n’est pas déjà fait, utilisez une boucle for après avoir repérer quelle est la seule valeur qui varie dans les instructions que vous avez écrites.

Montrez-moi votre travail.

Dessiner un quadrillage de space invaders

À faire : Dessiner un quadrillage de space invaders en réutilisant les idées déjà présentées dans les questions précédentes

Couleurs RVB

Python utilise le code couleur RVB pour définir les couleurs. Ce système de couleurs a été créé en 1931 par la commission internationale de l’éclairage, il est utilisé pour les écrans d’ordinateur.
Un écran est composé de pixels, chaque pixel intègre 3 diodes une rouge, une verte et une bleue.
En modulant l’intensité lumineuse de chaque diode, on peut afficher n’importe quelle couleur visible, on parle de synthèse additive : le mélange de la lumière des 3 diodes créé la couleur.
Le nombre de niveaux possibles pour chaque composante est de 256, soit 256 × 256 × 256 = 16 millions de couleurs.

(source inconnue)

En suivant ce lien, vous verrez le code couleur RVB de très nombreuses couleurs classées par nuances.
Attention le module pixel que nous utilisons donne à chaque composante une couleur entre 0 et 1 au lieu de 0 255, il faut donc diviser les valeurs précédents par 255 pour obtenir le bon codage.

Un dégradé de space invaders

À faire : Remplacer le choix de la couleur (vert() dans le fichier initial) par couleur(1,0.8,0.7).

À faire : Dessiner un quadrillage de spaces invaders ayant des couleurs différentes suivant les colonnes comme dans l’exemple suivant :

À faire : Dessiner un quadrillage de spaces invaders ayant des couleurs différentes suivant les colonnes et les lignes comme dans l’exemple suivant :

Montrez-moi votre travail.
Fin

TP Fond marin

Le but de ce TP est de reproduire le fond marin suivant

en travaillant :

  • sur les boucles for et notamment les variables introduites par ces boucles,
  • les appels de fonction et notamment leurs arguments qui sont décrits dans leurs prototypes

et en limitant le nombre de lignes du programme.

Dans ce TP vous ne devez rajoutez aucune instruction setposition, goto, setx, sety, setheading.

I Présentation des fichiers de ce TP

Fond_marin.zip

Téléchargez Fond_marin.zip, puis décompressez-le dans votre dossier personnel. Un dossier Fond_marin apparaît dans lequel il y a 4 fichiers.
Vous ne modifierez et n’exécuterez que progprinc.py.
Exécutez progprinc.py, vous devez voir :

II Le programme principal

Afin que la tortue dessine plus vite, n’hésitez pas à commenter les parties du programme sur lesquelles vous ne travaillez pas.

Le sable

Repérez le commentaire #sable dans les derniers lignes du fichier progprinc.py, vous pouvez lire en dessous les 3 lignes.

goto(-475,-400)
demi_cercle_haut(30,(1,1,0.6))
forward(60)

La première ligne permet de placer la tortue au bon endroit, vous ne devez pas la modifier.
Pour savoir ce que fait la deuxième ligne vous pouvez utiliser la fonction help dans l’interpréteur :

>>> help(demi_cercle_haut)
Help on function demi_cercle_haut in module formes:

demi_cercle_haut(rayon, col)
   dessine un demi-cercle bombé vers le haut de rayon rayon
   et de couleur col

Ce petit bout de programme dessine le demi-cercle jaune en bas à gauche de l’image, modifiez-le pour avoir la ligne de 15 demi-cercles jaunes de l’image finale. Vous ne devez pas avoir plus de 4 lignes de code à la place des 3 lignes initiales.

Les méduses

Repérez le commentaire #meduses dans les premières lignes du fichier progprinc.py, vous pouvez lire en dessous les 7 lignes.

goto(-400,320)
meduse(25,bleuclair,bleu)
forward(150)
descendre(20)
meduse(25,bleuclair,bleu)
forward(150)
monter(20)

La première ligne permet de placer la tortue au bon endroit, vous ne devez pas la modifier. Ce petit bout de programme dessine les méduses du haut de l’image, modifiez-le pour avoir les 6 méduses de l’image finale. Vous ne devez pas avoir plus de 8 lignes de code à la place des 7 lignes initiales.

Le premier banc de poissons

Repérez le commentaire # premier banc de poissons, les 4 lignes qui suivent servent à dessiner le banc de poissons à gauche en partie derrière la plante de gauche. La taille et la couleur des poissons sont aléatoires. Vous ne devez pas modifier l’appel à poisson5 mais faire les changements nécessaires pour afficher le banc de poissons en entier. Vous ne devez pas avoir plus de 5 lignes de code à la place des 4 lignes initiales.

Le troisième banc de poissons

Repérez le commentaire #troisième banc de poissons, les 7 lignes qui suivent servent à dessiner le banc de poissons en dessous des méduses. Il alterne des poissons de deux formes aux couleurs aléatoires. Vous ne devez pas modifier les appels à poisson1 et poisson4 mais faire les changements nécessaires pour afficher le banc de poissons en entier. Vous ne devez pas avoir plus de 8 lignes de code à la place des 7 lignes initiales.

Le deuxième banc de poissons

Repérez le commentaire #deuxième banc de poissons, les 3 lignes qui suivent servent à dessiner le banc de poissons verts. La taille des poissons varient et les poissons orientés vers la droite sont obtenus avec la fonction poisson2. Faites les changements nécessaires pour afficher le banc de poissons en entier. Vous ne devez pas avoir plus de 8 lignes de code à la place des 3 lignes initiales.

La plante de gauche

Repérez le commentaire #plante de gauche, les 5 lignes qui suivent servent à dessiner la plante à gauche de l’image.

goto(-445,-400)
left(90)
branche("green","green","droite","gauche")
up()
setheading(0)

Les 2 premières et les 2 dernières lignes doivent rester inchangées. Faites les changements nécessaires pour avoir une plante dont les feuilles sont tantôt à gauche, tantôt à droite et qui en partant du bas sauf la dernier qui est vers le haut. Il y a 3 branches orientées vers la droite puis 5 orientées vers la gauche, la dernière orientée vers la gauche a une feuille vers le haut. Vous ne devez pas avoir plus de 7 lignes de code à la place de la ligne du milieu (3e ligne).

Je rappelle qu’écrire l’instruction help(branche) dans l’interpréteur permet d’avoir la documentation de la fonction branche.

La plante de droite

Repérez le commentaire #plante de droite, les 5 lignes qui suivent servent à dessiner la plante à droite de l’image. Elle a 4 branches orientées vers la gauche, 8 branches orientées vers la droite, 4 orientées vers la gauche, puis une dernière branche orientée vers la gauche avec une feuille vers le haut. De plus la couleur de ses feuilles varie régulièrement en suivant des dégradés. Vous ne devez pas avoir plus de 10 lignes de code à la place de la ligne du milieu (3e ligne).

Les étoiles de mer

Repérez le commentaire #etoile de mers vers le bas du fichier, les 4 lignes qui suivent servent à dessiner les étoiles de mer. Elles ont des tailles qui diminuent régulièrement et les déplacements évoluent aussi régulièrement. Modifiez le code pour dessiner les 5 étoiles de mer. Vous ne devez pas avoir plus de 5 lignes de code à la place des 4 lignes initiales.

Les rochers

Il ne manque plus que les rochers. Repérez le commentaire #rochers vers le haut du fichier, les 3 lignes qui suivent servent à dessiner les rochers. Ils ont des tailles qui augmentent régulièrement avant de diminuer régulièrement. Leurs couleurs également varient mais son symétriques par rapport au milieu de l’image. Modifiez le code pour dessiner tous les rochers. Vous ne devez pas avoir plus de 7 lignes de code à la place des 3 lignes initiales.

TP Rantaplan

Le but de ce TP est de dessiner une figure géométrique étonnante en suivant une règle de construction très simple.

Introduction

Pendant qu’Averell finit de manger, les trois autres Dalton prennent l’air dans un champ. Rantanplan traîne aussi dans le champ.

Les trois Dalton appellent simultanément le chien qui se dirige aléatoirement vers l’un d’eux.


Trahi par sa mémoire défaillante, il s’arrête au milieu de son trajet et creuse un trou.

Les trois Dalton le rappellent, il repart au hasard vers l’un d’eux , s’arrête à mi-chemin, creuse un trou et ainsi de suite.

Le but de ce tp est de visualiser la figure représentant l’ensemble des trous faits par Rantanplan.

Prérequis

Pour réaliser ce TP nous avons besoin de 3 éléments :

  • savoir choisir un nombre au hasard
  • pouvoir faire un choix
  • calculer le milieu de 2 points

a. Choisir un nombre au hasard

La fonction randint prend deux nombres en arguments a et b et renvoie un nombre entre a et b tous les deux compris.
Pour utiliser la fonction randint on a besoin de la bibliothèque random. Pour indiquer que le programme se sert de cette bibliothèque, on écrit en tête du programme :
from random import *
Le programme suivant affiche le résultat produit par 10 exécutions différentes de randint(2,9).

À faire : Exécutez-le, puis modifiez-le pour tirer au hasard un nombre entre 10 et 78, 20 fois.

from random import *

for i in range(10):
   print(randint(2,9))
Montrez-moi votre travail.

b. Faire un choix

La fonction choix tire au hasard un nombre n et renvoie ce nombre et une couleur qui dépend de la valeur de n. Le programme suivant affiche le résultat produit par 10 exécutions différentes de choix().

À faire : Modifiez la fonction choix pour que la couleur renvoyée soit jaune pour les valeurs comprises entre 1 et 7, bleu entre 8 et 15 et rose entre 16 et 20.

from random import *

def choix():
   n=randint(1,20)
   if n < 6:
       return n,"rouge"
   elif n < 11:
       return n,"vert"
   elif n < 16:
       return n,"orange"
   else :
       return n,"violet"
   
for i in range(10):
   print(choix())

À faire : Modifiez la fonction choix pour qu’elle n’affiche plus n mais uniquement la couleur renvoyée.

Montrez-moi votre travail.

c. Le milieu de 2 points

Le milieu de deux points a comme abscisse la moyenne des abscisses des deux points et comme ordonnée la moyenne des ordonnées des deux points.

Dans cet exercice, on a besoin d’avoir des coordonnées entières donc on utilisera la division entière // pour faire la moyenne.

Situation de départ

On considère que le champ est de forme rectangulaire et mesure 101 pixels de large par 88 de hauteur.

À faire : Téléchargez l’archive rantanplan.zip et décompressez-la dans votre espace personnel.

rantanplan.zip

Vous ne devez pas jamais modifier les fichiers pixel.py et pixelRantanplan.py.

À faire : Complétez la figure obtenue en exécutant rantanplan.py sachant que Jack en rouge (1,86) et William en bleu (99,86). De plus Rantanplan en noir s’est placé entre Jack et William.
Vous devez obtenir :

Premier déplacement de Rantanplan

À faire : Modifiez le fichier rantanplan.py pour faire apparaître le premier déplacement de Rantanplan. Comme il se dirige aléatoirement vers Joe, Jack ou William, son premier trou varie d’une exécution à l’autre. En exécutant plusieurs fois votre programme, vous devez obtenir au moins une fois chacune des figures suivantes :


Réalisation de la figure

À faire : Modifiez votre programme pour dessiner de plus en plus de trous. Une figure régulière doit apparaître.

Montrez-moi votre travail.

Figure plus fine

Pour faire une figure plus fine, on choisit maintenant un champs de 1001 pixels de large par 867 de hauteur. Joe est alors placé au point (500,1), Jack (1,865) et William (999,865).

Pour avoir une figure avec plus de pixels remplacé l’instruction ouverture_fenetre() par ouverture_grande_fenetre(). Puis faites les modifications pour l’emplacement de Joe, Jack, William et Rantanplan.

Montrez-moi votre travail.

La figure ainsi obtenue ressemble au triangle de Sierpinski qui est une figure géométrique fractale.

TP Coquillage tueur

Certains coquillages de la famille des conus ont des motifs très étonnants

qui rappellent la fractale appelée triangle de Sierpinski

Le but de ce Tp est d’essayer de simuler à l’aide du langage Python les motifs de ces coquillages.

Règles de la pigmentation des coquillages

Le coquillage croît par son bord, en ajoutant des rangées successives aux rangées déjà formées. Ces croissances successives forment des lignes sur la coquille de l’animal.

Les scientifiques ne comprennent pas bien les mécanismes derrière les phénomènes de pigmentation de ces coquillages. Un modèle, d’origine chimique, a été proposé par Alan Turing en 1952 dans un article célèbre, « The chemical basis of morphogenesis ». Il fait intervenir deux substances chimiques ou morphogènes, l’une appelée activateur, et l’autre inhibiteur, qui réagissent l’une avec l’autre, et qui diffusent au travers des cellules. On parle donc de réaction-diffusion. (source : C. ROUSSEAU, Des coquilles aux pelages, Accromath Vol. 7, Hiver-Printemps 2012.)

Si on considère qu’un coquillage est coloré avec deux couleurs : le noir et le blanc. Un modèle pour connaître la couleur d’un point d’une ligne en connaissant la coloration de la ligne précédente est la suivante : le point est blanc si les deux carrés en diagonale au dessus sont de la même couleur, sinon il est noir.

 :

À faire : Sur une feuille quadrillée, colorez quelques carrés de la ligne du haut puis appliquez la règle ci-dessus, pour colorer les lignes suivantes l’une après l’autre.

Modélisation avec le langage Python

On commence par dessiner les motifs d’un coquillage dont la coquille fait 55 carrés de couleur de largeur sur 29 lignes en connaissant la couleur de chaque carré de la première ligne.
La première et la dernière colonne de ce motif seront toujours blanches.

À faire : Téléchargez l’archive Coquillage.zip et décompressez-la dans votre espace personnel.

Coquillage.zip

Lors de l’exécution du fichier coquillage.py, on obtient la figure suivante où seule la première ligne est colorée :

Vous ne devez pas jamais modifier les fichiers pixel.py et pixelCoquillage.py.

À faire : Colorez les carrés de la deuxième ligne sur un papier en suivant les règles de coloration énoncées précédemment.

Montrez-moi votre travail.

Sachant que :

  • la fonction petite_fenetre ouvre une fenêtre de 30 lignes et 55 colonnes
  • la fonction dessine_pixel(a,b) marque un pixel noir à la colonne a et la ligne b
  • la fonction lire(a,b) renvoie la valeur 0 si le pixel de la colonne a et de la ligne b est noir et renvoie 1 sinon.

À faire :Modifiez le fichier coquillage.py pour faire apparaître tous les carrés noirs de la deuxième ligne. Votre programme doit toujours être correct même si on modifie l’emplacement des carrés noirs de la première ligne.

Montrez-moi votre travail.

À faire : Modifiez le fichier coquillage.py pour faire apparaître tous les carrés noirs de toutes les lignes.

Pour avoir une modélisation plus importante, on peut utiliser une fenêtre plus grande : 500 colonnes et 250 lignes en utilisant la fonction grande_fenetre au lieu de petite_fenetre.
Jouez sur l’emplacement des carrés noirs de la première ligne pour obtenir différents motifs.

Le triangle de Sierpinski

Quand on ne place qu’un carré central sur la première ligne, on obtient un triangle qui ressemble un peu au triangle de Sierpinski mais on obtient un meilleur résultat en modifiant la règle de coloriage : on laisse un carré blanc si les trois carrés au dessus de lui sont de la même couleur, sinon on le colorie en noir.

Faites les modifications pour obtenir ce triangle.

Quelles différences voyez-vous par rapport au triangle obtenu avec le TP Rantanplan ?

Des coquillages tueurs

En plus d’avoir des motifs surprenants, certains coquillages de la famille des conus sont venimeux et dangereux pour l’homme.

Conus geographus est le coquillage venimeux le plus dangereux connu.

Le jeu de la vie

Les programmes que nous venons d’écrire sont proche de la famille des programmes du jeu de la vie.

Complément sur Alan Turing

Alan Mathison Turing, né le 23 juin 1912 à Londres et mort le 7 juin 1954 à Wilmslow, est un mathématicien et cryptologue britannique, auteur de travaux qui fondent scientifiquement l’informatique.

Pour résoudre le problème fondamental de la décidabilité en arithmétique, il présente en 1936 une expérience de pensée que l’on nommera ensuite machine de Turing et des concepts de programme et de programmation, qui prendront tout leur sens avec la diffusion des ordinateurs, dans la seconde moitié du XXe siècle. Son modèle a contribué à établir la thèse de Church, qui définit le concept mathématique intuitif de fonction calculable.

Durant la Seconde Guerre mondiale, il joue un rôle majeur dans la cryptanalyse de la machine Enigma utilisée par les armées allemandes. Ce travail secret ne sera connu du public que dans les années 1970. Après la guerre, il travaille sur un des tout premiers ordinateurs, puis contribue au débat sur la possibilité de l’intelligence artificielle, en proposant le test de Turing. Vers la fin de sa vie, il s’intéresse à des modèles de morphogenèse du vivant conduisant aux « structures de Turing ».

Poursuivi en justice en 1952 pour homosexualité, il choisit, pour éviter la prison, la castration chimique par prise d’œstrogènes. Il est retrouvé mort par empoisonnement au cyanure le 8 juin 1954 dans la chambre de sa maison à Wilmslow. La reine Élisabeth II le reconnaît comme héros de guerre et le gracie à titre posthume en 2013.

(source wikipédia)

TP Immeubles

Le but de ce Tp est de dessiner des rues avec le module turtle.

Pour cela, on va utiliser de nombreuses fonctions définies dans différents fichiers.

Présentation des fichiers et des fonctions de ce TP

Téléchargez Immeuble.zip, placez-le dans votre dossier NSI, puis décompressez-le.

immeuble.zip

Un dossier Immeuble apparaît dans lequel il y a 4 fichiers.

  • porte_fenetre.py est le premier de ces fichiers. C’est dans ce fichier que sont définis les dessins de départ :
    • carre qui est déjà définie
    • rectangle que vous allez définir au cours de ce tp
    • fenetre que vous allez définir au cours de ce tp
    • porte que vous allez définir au cours de ce tp
    • porte2 qui est déjà définie
    • balcon qui est déjà définie
    • porte_fenetre que vous allez définir au cours de ce tp
  • etage.py utilise les fonctions définies dans porte_fenetre.py. C’est dans ce fichier que sont définis :
    • rez_de_chaussee que vous allez définir au cours de ce tp
    • etage que vous allez définir au cours de ce tp
    • toit qui est déjà définie
    • toit2 qui est déjà définie
    • descendre qui est déjà définie
  • rue.py utilise les fonctions définies dans etage.py. Ce fichier ne sera jamais modifié.
    C’est dans ce fichier que sont définis :
    • maison1 qui est déjà définie
    • maison2 qui est déjà définie
    • rue1 qui est déjà définie
    • rue2 qui est déjà définie
    • rue3 qui est déjà définie
    • rue4 qui est déjà définie
  • progprincipal.py utilise les fonctions définies dans rue.py. C’est le fichier qui est exécuté.

Utilisation des fichiers

Comme écrit précédemment, on ne va exécuter que le fichier progprincipal.py.

a. Premier test

Exécutez le fichier progprincipal.py. Un toit apparaît :

Il s’agit du résultat obtenu quand on appelle la fonction maison1 qui pour l’instant n’affiche qu’un résultat partiel.

b. Deuxième test

On va maintenant tester la fonction carre.

Lisez la description de cette fonction qui est indiquée entre guillemets en utilisant l’instruction help(carre) dans l’interpréteur. Puis, dans le fichier progprincipal.py, commentez la ligne maison1() en ajoutant # devant pour que cette fonction ne soit plus exécutée et écrivez à la ligne suivante carre(15,"blue"), vous appelez ainsi la fonction carre qui est définie dans le porte_fenetre.py.

Comme attendu à l’exécution de progprincipal.py, un carrée bleu de 15 pixels de côté apparaît.

Rappel : pour utiliser une fonction il faut deux choses

  • avoir défini la fonction. Cette définition commence par le mot chef def puis le nom de la fonction.
  • appeler cette fonction en écrivant son nom puis des parenthèses contenant une valeur pour chacun des arguments de cette fonction.

Complétons les fonctions
Remarque générale : pour tous les motifs sauf l’étage, la position de la tortue au début et à la fin du dessin, ainsi que son orientation (vers la droite) est exactement la même. La tortue revient donc à son point de départ.

Étape 1 : le rectangle et le rez de chaussée

En vous inspirant de la fonction carre, définissez la fonction rectangle.
Testez alors avec progprincipal.py, rectangle(50,100,"pink"). Vous devez voir un rectangle rose apparaître.

Complétez ensuite la fonction rez_de_chaussee pour faire apparaître un rectangle de la couleur choisie de 140 pixels de large et 60 de long.
Testez alors avec progprincipal.py, maison1(), puis, maison2() vous devez obtenir :

puis

Étape 2 : l’étage

Complétez ensuite la fonction etage. La souris doit d’abord monter de 60 pixels avant de dessiner un rectangle de la couleur choisie de 140 pixels de large et 60 de long.
Testez avec progprincipal.py, maison1() puis maison2(), vous devez obtenir :

puis

Étape 3 : les portes arrondies

La fonction porte2 dessine une porte arrondie, elle est déjà définie.
Complétez la fonction rez_de_chaussee pour placer une porte arrondie à gauche à 15 pixels du mur. N’oubliez pas de revenir à la place initiale (en bas à gauche du rectangle).
Testez avec progprincipal.py, maison1() et maison2(), vous devez obtenir :

puis

Étape 4 : les portes simples

Complétez la fonction porte qui dessine une porte rectangulaire de la couleur choisie.
Modifiez la fonction rez_de_chaussee pour placer une porte rectangulaire à gauche à 15 pixels du mur.
Testez avec progprincipal.py, maison1() puis maison2(), vous devez obtenir :

puis

Étape 5 : le choix de la porte

On remplace maintenant l’instruction qui dessine la porte dans rez_de_chaussee par :


if choixporte :
porte(couleurporte)
else :
porte2(couleurporte)

On a alors

puis

Regardez les définitions des deux maisons. Lors de l’appel de arguments de rez_de_chaussee le second paramètre est True pour la première maison et False pour la seconde.
Le mot clef if teste cette valeur :

  • Si elle vaut True alors on exécute uniquement ce qui est décalé juste en dessous autrement dit porte(couleurporte) et pas ce qu’il y a après le mot clef else.
  • Si elle vaut False alors on n’exécute pas uniquement ce qui est décalé juste en dessous mais on exécute ce qu’il y a après le mot clef else, autrement dit porte2(couleurporte).

Étape 6 : les fenêtres

Complétez la fonction fenetre puis modifiez la fonction rez_de_chaussee pour placer une fenêtre au milieu (10 pixels entre la porte et la fenêtre) et une fenêtre à droite (10 pixels entre les deux fenêtres).
Complétez aussi la fonction etage pour placer 3 fenêtres avec les mêmes espacements.
Testez avec progprincipal.py, maison1() et maison2(), vous devez obtenir :

puis

Testez avec progprincipal.py, rue2(), vous devez obtenir :

Étape 7 : les portes-fenêtres

En utilisant la fonction déjà défnie balcon définissez la fonction porte_fenetre et placez une porte_fenêtre à droite des étages à la place de la dernière fenêtre.
Testez avec progprincipal.py, rue1(), vous devez obtenir :

Étape 8 : les fenêtres et portes-fenêtres au bon endroit

Utilisez des tests if et les arguments, choix1, choix2 et choix3 de etage pour placer les portes-fenêtres au bon endroit.
Testez avec progprincipal.py, rue4(), vous devez obtenir :

Dernière étape : placer la porte au bon endroit

On va maintenant tester où il faut placer la porte d’entrée. Si choixplaceporte vaut 1 ce qui s’écrit choixplaceporte == 1, alors la porte est à gauche, si c’est 2, elle est au milieu et si c’est 3 elle est à droite.
On obtient alors les 4 rues :




Facultatif

  • Dessiner une rue de 4 bâtiments aléatoires.
  • Rajouter des éléments architecturaux de votre choix (moulin, école,etc...).

Annexe : Présentation du module pixel.py

Le module pixel.py a été développé par l’université de Lille 3. Il permet d’obtenir des images pixelisées évolutives.

Voici une vidéo présentant les principales fonctions de ce module que nous utiliserons dans nos programmes

Tout d’abord pour utiliser le module pixel.py, on écrit :

from pixel import *

au début du fichier qui appelle des fonctions de pixel.py.

Les fonctions appelées sont :

  • initialiser permet d’ouvrir une fenêtre contenant de gros pixels, elle a 3 arguments : le nombre de colonnes de gros pixels de la fenêtre, le nombre de lignes de gros pixels de la fenêtre, le nombre de pixels de l’écran sur un côté d’un gros pixel
  • marquer qui permet a l’ordinateur de mémoriser un gros pixel à dessiner ultérieurement. Il a besoin de 2 arguments : la colonne où sera dessiner le gros pixel, la ligne où sera dessiner le gros pixel. Il peut prendre un dernier argument facultatif l’intensité de la couleur du gros pixel. C’est flottant compris entre 0 et 1. Par défaut cette intensité vaut 0 et donc le pixel apparaîtra noir quand il sera affiché.
  • afficher qui affiche tous les pixels en attente dans la couleur courante (noire par défaut) à la place enregistrée (colonne, ligne) et l’intensité enregistrée. Si cette intensité est 1 le pixel sera clair (blanc par défaut). Afficher peut prendre un argument qui indique le temps d’attente avant que l’ordinateur exécute l’instruction suivante. Une fois les pixels affichés ils n’attendent plus de l’être.
  • couleur qui modifie la couleur courante en lui donnant la valeur correspondant à ses trois arguments qui sont des flottants entre 0 et 1, le premier correspondant au rouge, le deuxième au vert et le troisième au bleu dans le codage RVB des couleurs.
  • lire qui renvoie l’intensité du gros pixel affiché dont la colonne et la ligne ont été passées en argument à cette fonction.

Exemple de programme :

from pixel import *

initialiser(15,10,20)
marquer(5,3,0.8)
marquer(5,2,0.8)
couleur(1,0,0)
print(lire(5,2))
afficher(0)
print(lire(5,2))
marquer(0,0,1)
couleur(0,1,0)
afficher(0)
marquer(10,10)
afficher(0)
print(lire(10,10))

ouvre la fenêtre suivante et produit les affichages suivants :


Réagir à cet article
Vous souhaitez compléter cet article pour un numéro futur, réagir à son contenu, demander des précisions à l'auteur ou au comité de rédaction...
À lire aussi ici
MathémaTICE est un projet
en collaboration avec
Suivre la vie du site Flux RSS 2.0  |  Espace de rédaction  |  Nous contacter  |  Site réalisé avec: SPIP  |  N° ISSN 2109-9197