Raspberry Pi - Programmer des dessins en langage Python

L'outil de programmation Python 3 IDLE (Integrated Development and learning Environment) fait partie des outils de base présents dans la distribution Linux Raspbian sur Raspberry Pi. Python 3 IDLE est un interpréteur qui permet de créer, ouvrir, exécuter et enregistrer (avec l'extension.py) des fichiers de code source écrits en langage Python.

En langage Python , un module est un ensemble de fonctions qui peuvent être utilisé par un programme source. Python permet de créer ses propres modules et intègre par défaut le module turtle qui permet la programmation de dessins. Le module "tortue" (turtle) de python offre en effet l'ensemble des instructions nécessaires pour la programmation de dessins composés de formes (shapes), de lignes (lines), de courbes (curves) et de points (dots). Dans ce module, la tortue est en fait tout simplement un crayon en forme de petite flèche noire que l'on déplace à l'écran pour dessiner. Pour utiliser un module dans un programme source python, il suffit de commencer ce programme avec l'instruction import nom-du-module Par exemple : import turtle

1) Créer, enregistrer et exécuter un programme python

Pour créer, enregistrer et exécuter un programme python, il suffit d'effectuer les actions suivantes.

1.1) On ouvre Python IDLE

On clique Framboise/programmation/ Python 3

1

1.2) On crée un fichier source

Dans la fenêtre Python 3.5.3 Shell qui s'ouvre, on clique File/New File

2

Dans la fenêtre "Untitled" qui s'ouvre, on saisit le code source, par exemple :
# test01.py
prenom = input("Prénom ?\n")
print("Bonjour, ", prenom)

3

1.3) On enregistre le fichier source

On clique File/Save As pour enregistrer le fichier source (avec le nom test01.py par exemple) dans un répertoire de notre choix.

1.4) On exécute le fichier source

On clique Run/Run Module pour éxécuter le programme

4

Le programme s'exécute alors automatiquement dans la fenêtre de l'interpréteur Python.

4

En faisant File/Open, on peut ensuite ouvrir et exécuter quand on le souhaite le fichier "test01.py" qui est enregistré dans le répertoire de notre choix.

5

2) Tester les fonctions graphiques du module turle

2.1) Fonctions speed(), size(), color() et forward()

# test01.py
import turtle
t = turtle.Pen()
t.speed(3)
t.pensize(1)
t.color(0,0,0)
t.forward(50)

# test01.py est le nom du fichier source placé en commentaire au début du programme (il n'est pas pris en compte par l'interpréteur python).
On importe le module graphique turtle, à l'aide de l'instruction import turtle, puis on définit un crayon t pour le programme à l'aide de l'instruction t = turtle.Pen()
t.speed(3) donne une vitesse de déplacement lente du crayon. Pour un déplacement le plus rapide possible on écrit t.speed(0)
t.pensize(1) donne une épaissuer de crayon de 1 pixel (c'est le minimum). On peut choisir une épaisseur de 2,3,4 pixels ou plus...
t.color(0,0,0) donne une couleur noire au crayon. On peut choisir n'importe quelle couleur r,g,b dans la place 0.0 à 1.0. Par exemple t.color(1,0,0) donr une couleur rouge au crayon
t.forward(50) fait avancer le crayon de 50 pixels (au départ du programme, sauf spécification contraire, le crayon est situé au centre de l'écran (0,0) et est orienté vers la droite)

6

2.2) Fonctions left() right et backward()

La fonction left(angle) avec angle variant de 0 à 360 fait tourner le crayon de l'angle indiqué vers la gauche. Par exemple t.left(90) fait tourner le crayon de 90° vers la gauche. La fonction backward(n) fait reculer le crayon de n pixels. Par exemple t.backward(50) fait reculer le crayon de 50 pixels.
# test01.py
import turtle
t = turtle.Pen()
t.speed(3)
t.pensize(1)
t.color(0,0,0)
t.forward(50)
t.left(90)
t.backward(50)

7

En rajoutant les instructions right et forward, le crayon se dirige vers la droite
t.right(90)
t.forward(50)

8

2.3) Fonctions setpos(), circle(), up() et down()

La fonction t.setpos(x,y) place le crayon au point de coordonnées x,y en pixels
La fonction t.circle(r) dessine un cercle de rayon r en pixels
La fonction t.down() abaisse le crayon afin qu'il trace quand il se déplace (par défaut, le crayon est baissé)
La fonction t.up() lève le crayon afin qu'il ne trace plus quand il se déplace

Le listing suivant trace deux cercles sans que le crayon soit levé quand il est déplacé
# test01.py
import turtle
t = turtle.Pen()
t.speed(3)
t.pensize(1)
t.color(0,0,0)
t.circle(50)
t.setpos(100,100)
t.circle(20)

9

Pour ne pas avoir de tracé entre les deux cercles (lors du déplacement du crayon), il suffit d'encadrer l'instruction t.setpos(100,100) par les instructions t.up() puis t.down()

10

2.4) Fonctions dot(), begin_fill() et end_fill()

La fonction t.dot(n) permet de tracer un point d'un diamètre de n pixels
Un tracé qui est encadré par les fonctions t.begin_fill() et t.end_fill() est automatiquement rempli avec la couleur courante du crayon
# test01.py
import turtle
t = turtle.Pen()
t.speed(3)
t.pensize(1)
t.color(0,0,0)
t.dot(50)
t.up()
t.setpos(100,100)
t.down()
t.begin_fill()
t.circle(25)
t.end_fill()

11

N'importe quel tracé encadré par t.begin_fill() et t.end_fill() est automatiquement rempli, par exemple
# test01.py
import turtle
t = turtle.Pen()
t.speed(3)
t.pensize(1)
t.color(0,0,0)
t.begin_fill()
t.forward(50)
t.left(90)
t.forward(50)
t.end_fill()

12

2.5 fonctions hideturtle() et showturtle()

Les fonctions t.hideturtle() et t.showturtle() permettent de cacher ou d'afficher le crayon
# test01.py
import turtle
t = turtle.Pen()
t.speed(3)
t.pensize(1)
t.color(0,0,0)
t.circle(50)
t.hideturtle()

13

3) Créer son propre module de fonctions

Pour créer un module de fonctions, on crée un fichier source que l'on appelle f.py par exemple (f comme fonctions) et contenant les fonctions souhaitées. Dans le cas présent on définit deux fonctions permettant de dessiner des ellipses, une fonction ellipse_h(r) pour dessiner des ellipses horizontales et une fonction ellipse_v(r) pour dessiner des ellipses verticales. Puis on place ce fichier dans le même répertoire que les fichiers sources qui vont l'utiliser
# f.py
import turtle
def ellipse_h(r):# ellipse horizontale
t = turtle.Pen()
t.speed(3)
t.pensize(1)
t.color(0,0,0)
t.right(45)
for i in range(2): # 2 demi ellipses horizontales
t.circle(r,90) # partie longue d'une demi ellipse
t.circle(r/2,90) # partie courte d'une demi ellipse
t.hideturtle()
def ellipse_v (r): # ellipse verticale
t = turtle.Pen()
t.speed(3)
t.pensize(1)
t.color(0,0,0)
t.left(45)
for i in range(2): # 2 demi ellipses verticales
t.circle(r,90) # partie longue d'une demi ellipse
t.circle(r/2,90) # partie courte d'une demi ellipse
t.hideturtle()

Dans le fichier source test01.py on déclare le module f précédent avec l'instruction import f et on utilise une fonction de ce module en précédant son nom avec f. f.ellipse_h(100) par exemple
# test01.py
import turtle
import ct
t = turtle.Pen()
t.speed(3)
t.pensize(1)
t.color(0,0,0)
f.ellipse_h(100)
t.hideturtle()

14

Mentions légales © 2015