Aller au contenu

Exercices d'entraînement☘

Ces exercices doivent être utilisés pour vous entraîner à programmer. Ils sont généralement accompagnés de pistes et de leur solution pour vous permettre de progresser.

Avant de vous précipiter sur ces solutions dès la première difficulté, n'oubliez pas les conseils suivants :

  • Avez-vous bien fait un schéma au brouillon pour visualiser le problème posé ?
  • Avez-vous essayé de rédiger un algorithme en français, avec vos propres mots, avant de vous lancer dans la programmation sur machine ?
  • Avez-vous utilisé des affichages intermédiaires, des print(), pour visualiser au fur et à mesure le contenu des variables ?
  • Avez-vous testé le programme avec les propositions de tests données dans l'exercice ?
  • Avez-vous testé le programme avec de nouveaux tests, différents de ceux proposés ?

Rappels

  • Chaque programme Python doit être sauvegardé sous forme de fichier texte avec l'extension .py.
    Enregistrez ce fichier dans le dossier [F01-Module Turtle] avec le nom donné à l'exercice : ProgF01.61.py, ProgF01.62.py, etc...
  • Pour exécuter ce programme, il suffit de le sauvegarder puis d'appuyer sur la touche [F5].

ProgF02.61☘

  1. Définir la fonction carre() qui permet de dessiner un carré. 

    1
2
3
4
5
6
    def carre(t, lg_cote):
    """
    t - une tortue
    lg_cote - int, longueur d'un côté du carré
    Sortie: None - la tortue trace un carré de côté lg_cote pixels
    """

    Un code possible
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
    from turtle import *

def carre(t, lg_cote):
    """
    t - une tortue
    lg_cote - int, longueur d'un côté du carré
    Sortie: None - la tortue trace un carré de côté lg_cote pixels
    """
    for i in range(4):
        t.forward(lg_cote)
        t.left(90)

  2. A l'aide de cette fonction, reproduire la figure suivante à l'aide d'instructions judicieusement placées dans le « main » :

Cahier des charges :

  • Les carrés ont des cotés de longueur 50 pixels ;
  • La distance entre deux carrés est de 75 pixels ;
  • On commencera le dessin à (-300, 0) ;

  • La couleur des carrés sera prise aléatoirement dans la liste : 

    1
    ChoixCouleur = ["red", "green", "blue", "orange", "purple", "pink", "yellow", "black"]

    Une piste

    Vous pouvez importer la fonction choice() incluse dans le module random qui renvoie un élément choisi aléatoirement dans le tableau passé en paramètre.

    Une autre piste - Un code à compléter
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
    from turtle import *

def carre(t, lg_cote):
    """
    t - une tortue
    lg_cote - int, longueur d'un côté du carré
    Sortie: None - la tortue trace un carré de côté lg_cote pixels
    """
    pass


if __name__ == '__main__':
    TurtleScreen._RUNNING = True
    sophie = Turtle()       # le nom de la tortue

    sophie.hideturtle()
    sophie.up()
    sophie.goto(-300,0)
    sophie.down()
    sophie.speed(0)

    # À compléter

    exitonclick()
    Une solution possible
     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
    from turtle import *
from random import choice

def couleur():
    """
    renvoie une couleur au hasard dans la liste
    """
    ChoixCouleur = ["red", "green", "blue", "orange", "purple", "pink", "yellow", "black"]
    return choice(ChoixCouleur)


def carre(t, lg_cote):
    """
    t - une tortue
    lg_cote - int, longueur d'un côté du carré
    Sortie: None - la tortue trace un carré de côté lg_cote pixels
    """
    for i in range(4):
        t.forward(lg_cote)
        t.left(90)

if __name__ == '__main__':
    TurtleScreen._RUNNING = True
    sophie = Turtle()       # le nom de la tortue

    sophie.hideturtle()
    sophie.up()
    sophie.goto(-300,0)
    sophie.down()
    sophie.speed(0)

    for i in  range (8):
        sophie.color(couleur())
        sophie.begin_fill()
        carre(sophie, 50)
        sophie.end_fill()
        sophie.up()
        sophie.forward(75)
        sophie.down()

    exitonclick()

ProgF02.62☘

La rosace ci-contre a été dessinée en utilisant un tableau de crayons. Chaque « pétale » a été tracé par un crayon différent. Voici quelques pistes pour reproduire cette figure :

  1. Définir une fonction petale() qui permet de tracer un petale : 

    1
2
3
4
5
    def petale(crayon, longueur, angle):
    """
    crayon - une tortue
    Sortie: None - Le crayon trace un pétale
    """
    Un pétale est une succession de déplacements de 15 pixels, entrecoupés d'une rotation dont l'angle va de 0 à 16 degrés puis revient à 0 degrés avec un pas de 1.

  2. Définir un tableau vide qui contiendra les futurs crayons.

  3. En utilisant une boucle, créer un nouveau crayon, définir ses caractéristiques (épaisseur, couleur, orientation initiale, etc...) puis ajouter ce crayon au tableau précédent.
  4. Tracer la rosace.

Pour les couleurs, utiliser une liste de couleurs nommées pré-définies.
Par exemple : couleurs = ['blue', 'orange', 'green', 'red', 'brown', 'pink', 'black', 'purple'].

Une piste

Chaque nouveau crayon inséré dans la liste doit avoir une orientation différente des crayons précédents. On rappelle qu'un plan est partagé en 360 degrés : papier, crayon et mathématiques seront nécessaires !

Une solution
 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
##----- Importation des Modules -----##
from turtle import *


##----- Définition des Fonctions -----##
def petale(crayon):
    """
    crayon - une tortue
    Sortie: None - Le crayon trace un pétale
    """
    for angle in range(16):
        crayon.forward(15)
        crayon.left(angle)
    for angle in range(16, -2, -1):
        crayon.forward(15)
        crayon.left(angle)


##----- Programme principal -----##
if __name__ == '__main__':
    couleurs = ['blue', 'orange', 'green', 'red', 'brown', 'pink', 'black', 'purple']
    nb_couleurs = len(couleurs)
    nb_crayons = 10
    liste_crayons = []

    angle = 360/nb_crayons                             # Ecart angulaire entre chaque crayon
    orientation = 0                                    # Orientation du 1er crayon


    # Création de la liste de crayons
    TurtleScreen._RUNNING = True

    for i in range(nb_crayons):
        crayon = Turtle()                              # Un crayon quelconque
        crayon.setheading(orientation)                   # On oriente
        crayon.width(2)                                # Un peu d'épaisseur
        crayon.pencolor(couleurs[i%nb_couleurs])           # Un peu d'arithmétique
        crayon.speed(0)                                # Vitesse maximale
        liste_crayons.append(crayon)
        orientation += angle


    # Tracé de la rosace

    for crayon in liste_crayons:
        petale(crayon)
        crayon.hideturtle()

    exitonclick()