Exercices: usage des boucles

Exercice 1: / simulation de la croissance d’une plante

Aujourd’hui, du chiendent (une plante invasive) occupe \(150 \ m^2\) d’un jardin de \(2000 \ m^2\) . Chaque semaine, on constate que cette surface envahie augmente de \(10 \%\) en raison du développement des rhizomes, mais à ceci s’ajoute \(5 \ m^2\) par dissémination des graines.

a) Vérifier qu’au bout de deux semaines, le chiendent recouvrira exactement \(192 m^2\) du jardin.
b) Écrire une fonction seuil_chiendent()ayant pour paramètre surface_seuil qui permet de déterminer le nombre de semaines à partir duquel la surface envahie par le chiendent sera supérieure, pour la première fois, à la surface_seuil, si cela se produit.

Pour la vérification:

>>> seuil_chiendent(190)
2
>>> seuil_chiendent(195)
3

c) Au bout de combien de semaines le chiendent va t-il recouvrir plus de la moitié de ce jardin ? plus des trois quarts de ce jardin ?

Exercice 2: / il ne peut en rester qu’un …

Sur une île bien inhospitalière règne une compétition à outrance entre trois espèces animales: des crabes, des lézards et des oiseaux.
Chaque matin, chaque crabe tue un lézard. Chaque après-midi, chaque lézard survivant tue un oiseau. Chaque soir, chaque oiseau tue un crabe. Ce cycle de prédation se répéte chaque jour à l’aube.

a) Si à l’aube du premier jour, il y avait 100 crabes, 175 lézards et 132 oiseaux, vérifier qu’au bout de deux jours (à l’aube du 3ème jour), il ne restera plus que 18 crabes, 32 lézards et 25 oiseaux sur cet île.
Vous pourrez évidemment utiliser cette réponse en guise de test dans la fonction à écrire dans la fonction suivante.
b) Écrire une fonction survivants() qui admet comme paramètres, crabes, lezards, oiseaux et nb_jours (respectivement le nombre de crabes, de lézards, d’oiseaux et de jours d’observation) et qui renvoie le tuple (crabes, lezards, oiseaux) (le nombre d’individus de chaque espèce après cette période d’observation).
c) Si à l’aube du premier jour, il y avait 55405 crabes, 97229 lézards et 73396 oiseaux, combien de jours vont s’écouler avec que le nombre de lézards passe sous les 10 individus à l’aube ?
d) À l’aube du 14ème jour, il ne restait plus que 1 crabe, 3 lézards et 2 oiseaux. Combien y avait-il d’individus de chaque espèce à l’aube du premier jour ?

Exercice 3: / de jolis dessins …

Python possède de multiples modules pour réaliser des dessins (des plus simples figures géométriques au plus complexes). On s’intéresse ici au module turtle.

Voici un exemple de construction réalisée avec ce module qui a consisté ici à définir un motif de base (en rouge sur la figure) à répéter 8 fois.

Le code Python qui a permis de l’obtenir est le suivant:

 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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

#!/usr/bin/python3
# -*- coding: utf-8 -*-

"""
:nom: Olivier Hennebelle

Figure 0 réalisée avec le module turtle
"""

from turtle import *

def motif_0(longueur):
    """
    Dessine le motif de base pour réaliser la figure 0

    :param longueur: (int) la longueur désirée
    :return: (None) on ne récupère rien d'utilisable (pas de return)
    :effet de bord: affiche les différents tracés
    """
    width(8)  # définition de l'épaisseur des traits
    color("orange")  # définition de la couleur
    forward(longueur)  # avancer de la longueur donnée
    left(135)  # tourner vers la gauche de 135°
    forward(longueur / 2)
    right(90)
    forward(longueur / 2)
    right(90)

def figure_0(longueur):
    """
    Dessine le la figure 0 par répétition du motif de base

    :param longueur: (int) la longueur désirée
    :return: (None) on ne récupère rien d'utilisable (pas de return)
    :effet de bord: affiche les différents tracés
    """
    c = 0
    while c < 8:  # répétition du motif 8 fois
        motif_0(longueur)
        c = c + 1
    hideturtle()  # si vous souhaitez faire disparaître la tortue (flèche) avant
                  # de sauvegarder l'image
    getcanvas().postscript(file = "figure0.eps")  # si vous souhaitez sauvegarder
                                                  # votre dessin
                                                  
if __name__ == '__main__':

    figure_0(100)  # pour éxécuter votre programme en précisant la longueur choisie

L’objectif est de réaliser les figures suivantes:

  • ex3_calque1.gif (45 ko)
  • ex3_calque2.gif (51 ko)
  • ex3_calque3.gif (50 ko)
  • ex3_turtle1.py (1 ko)
  • ex3_turtle2.py (1 ko)
  • ex3_turtle3.py (1 ko)

    • Pour se faire:

    a) Télécharger les calques qui vont aideront à tester vos constructions.
    b) Télécharger les scripts à compléter. Il sont à placer dans le même dossier que les calques.
    c) Compléter ou réaliser les algorithmes qui permettent d’obtenir les figures.

    Exercice 4: / quelques manipulations de fichiers

    Dans cet exercice, vous devrez vous inspirer de l’exemple vu dans l’exposé de cours sur la boucle TantQue impliquant des manipulations de fichiers.

  • ex4_fichier_modifie.txt (1 ko)
  • ex4_fichier_test.txt (0 ko)
  • ex4_fichier_test_copie.txt (0 ko)

    • Placer les fichiers précédents et le script contenant les fonctions suivantes dans un même dossier

    a) Écrire un prédicat sont_identiques() qui prend en paramètres deux fichiers afin de vérifier s’ils sont identiques ou non (au niveau de leur contenu).

    Jeu de tests: 

    >>> sont_identiques("ex4_fichier_test.txt", "ex4_fichier_test_copie.txt")
True
>>> sont_identiques("ex4_fichier_test.txt", "ex4_fichier_modifie.txt")
False

    b) Écrire une fonction decompter qui permet de dénombrer le nombre de fois qu’un caractère donné en paramètre est présent dans un fichier lui aussi donné en paramètre.

    Jeu de tests: 

    >>> decompter("ex4_fichier_test.txt", "u")
119

    c) Écrire une fonction modifier() qui permet de copier partiellement un fichier en remplaçant un caratère choisi par un autre voire par une chaîne de caractères. Elle prendra en paramètres deux fichiers source et destination et deux autres paramètres a_remplacer (que l’on cherche à remplacer) et a_placer (le caractère qui remplacera a_remplacer dans le fichier destination).

    Jeu de tests: 

    >>> modifier("ex4_fichier_test.txt", "ex4_fichier_test_modifie.txt", "u", "Pizza!")
>>> sont_identiques("ex4_fichier_test_modifie.txt", "ex4_fichier_modifie.txt")
True

    À vous de tester divers remplacements. Par exemple, tester et observer la modification réalisée dans le fichier à la fin. 

    >>> modifier("ex4_fichier_test.txt", "ex4_fichier_test_remodifie.txt", ". ", ".\n")

    Notez que le résultat n’est pas parfait: présence pas forcément désiré d’espaces résiduels en début de ligne. Il faudra faire appel à des fonctions spécifiques (méthodes) aux strings. Il faudra vous montrer patient !

    Exercice 5: du côté des images …

    À l’aide de module spécialement conçu dans cet objectif, il est possible de travailler avec des images.

    Est-il possible d’estimer l’ampleur de l’évolution des glaces dans l’Artique, l’évolution de la forêt amazonienne sur une certaine période grâce aux images satellitaires de la Terre ?

    Interessons nous au module PIL. Voici quelques fonctions qui utilisent ce module.

     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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

    #!/usr/bin/python3
# -*- coding: utf-8 -*-

"""
:nom: Christophe Mieszczak, un collègue

Premières manipulations d'images RVB (rouge, vert, bleu)
"""

from PIL import Image


def ouvrir(chemin):
    """
    Renvoie l'image lue dans le fichier de nom "chemin".

    :param chemin: (file) chemin pointant vers l'image
    :return: (ImageFile) fichier image

    Exemple de chemin: "C:\Documents\Images\photo.jpg"
    """
    return Image.open(chemin)


def afficher(image):
    """
    Ouvre une fenêtre et affiche l'image.

    :param image: (ImageFile) fichier image
    :return: (None)
    :effet de bord: affiche l'image
    """
    image.show()


def sauver(image, chemin):
    """
    Sauvegarde l'image donnée dans le fichier de nom "chemin".

    :param image: (ImageFile) fichier image
    :param chemin: (file) chemin où l'on souhaite sauver l'image
    :return: (None)
    :effet de bord: sauve l'image dans un fichier

    Exemple de chemin: "C:\Documents\Images\photo1.jpg"
    """
    image.save(chemin)


def dimensions(image):
    """
    Renvoie les dimensions de l'image

    :param image: (ImageFile) fichier image
    :return (longueur, largeur): (Tuple) un tuple donnant la longueur et \
    la hauteur de l'image
    """
    longueur, largeur = image.size
    return longueur, largeur


def couleur(image, x, y):
    """
    Renvoie la couleur du pixel de coordonnées x, y de l'image donnée

    :param image: (ImageFile) fichier image
    :param x: (int) l'abscisse du pixel
    :param y: (int) l'ordonnée du pixel
    :return color: (Tuple) un tuple donnant la couleur du pixel en RVB (rouge, vert, bleu)

    Exemples de couleur:
    (0, 0, 0) correspond à la couleur noire
    (250, 125, 0) correspond à une couleur orangée rougeoyante \
                  (mélange de rouge et de vert avec deux fois de rouge que de vert)
    (255, 255, 255) correspond à la couleur blanche
    """
    color = image.getpixel((x, y))
    return color

    [Mise à jour du 09/11]

    Pour répondre aux questions suivantes, vous pouvez faire usage de l’IDE en ligne repl.it à la place de Thonny. Vous pouvez procéder comme suit.

    S'inscrire sur repl.it

    Créer une nouvelle session (repl)

    Copier et coller le script principal

    Charger un fichier

    Exécuter une fonction dans la console

    Télécharger l'ensemble des fichiers

    a) Tester ces fonctions avec les images ci-jointes:

  • ex5_amazonie_2000.jpg (945 ko)
  • ex5_amazonie_2010.jpg (1195 ko)
  • ex5_artique_mars2000.jpg (114 ko)
  • ex5_artique_mars2017.jpg (113 ko)
  • ex5_photo.jpg (255 ko)

    • Source: images de la Terre fournies par la [Nasa](https://svs.gsfc.nasa.gov/)

    Vous pourrez, par exemple vérifier que:

    >>> img = ouvrir("ex5_photo.jpg")
>>> couleur(img, 150, 200)
(52, 52, 52)

    Cela signifie que le pixel en position (150, 200) de ex5_photo.jpg a pour couleur gris foncé (un peu de mélange à quantité égale de rouge, de vert et de bleu).

    b) Écrire un prédicat seuil_couleur() ayant pour paramètres image, x, y (les coordonnées du pixel considéré), seuil_rouge, seuil_vert, seuil_bleu (des entiers entre 0 et 255) qui renvoie True dans le cas où chacune des composantes de la couleur du pixel dépasse le seuil associé.

    Jeu de tests (déjà connu puisque l’on connait la couleur du pixel en (150, 200) dans ex5_photo.jpg): 

    >>> img = ouvrir("ex5_photo.jpg")
>>> seuil_couleur(img, 150, 200, 40, 50, 60)
False
>>> seuil_couleur(img, 150, 200, 52, 52, 52)
True

    c) Écrire une fonction compter() ayant pour paramètres image, seuil_rouge, seuil_vert, seuil_bleu (des entiers entre 0 et 255) qui renvoie le nombre de pixels de l’image dont chacune des composantes de sa couleur dépasse le seuil associé.

    Jeu de tests: 

    >>> img = ouvrir("ex5_photo.jpg")
>>> compter(img, 255, 255, 255)
118

    Dans cet exemple, on peut lire que ex5_photo.jpg a exactement 118 pixels blancs (255, 255, 255).

    d) Écrire une ou des fonctions qui permet(tent) de tirer le taux d’évolution dans l’étude des glaces en Artique ou de la parcelle de forêt amazonienne. Vous pouvez, si vous le souhaitez écrire les résultats dans un fichier en vous inspirant du travail réalisé dans l’exercice précédent.

    Choisir comme seuils:

    • pour l’Artique, seuil_rouge = 0, seuil_vert = 0 et seuil_bleu = 170 (seuil d’environ \(25 %\) de concentration de glace dans l’eau d’après la légende jointe aux images voir site

    • pour l’Amazonie: seuil_rouge = 70, seuil_vert = 0 et seuil_bleu = 0.

    Ces seuils ont été obtenus avec l’usage d’un logiciel capable de lire la couleur d’un pixel désiré. Exemple de tel logiciel: GIMP. Il en existe beaucoup d’autres.

    Exercice 6: / des élèves turbulents …

    Un immeuble dispose d’un certain nombre d’étages numérotés à partir de 1. Des enfants de cet immeuble passablement turbulents montent les étages en appuyant sur un interrupteur pour allumer ou éteindre les lumières des étages de la façon suivante:

    • Le premier appuie sur tous les interrupteurs.

    • À la suite , le second appuie sur les interrupteurs des étages 2, 4, 6, 8, …

    • Ensuite, le troisième appuie sur les interrupteurs des étages 3, 6, 9, …

    Cela se répète jusqu’au dernier enfant.

    En supposant que tous les étages étaient éteints au début, combien d’étages seront allumés après leur passage ?

    Répondre à la question en écrivant des fonctions.

    Une aide ?