Initiation à la programmation (Atelier)

Version actuelle en date du 26 juin 2008 à 13:46

• Intervenant : Guillaume Libersat (dukez)

Durant cet atelier, les participants découvriront le principe de la programmation, les différents types de langage et apprendront à faire leurs premiers programmes.

Les exemples seront réalisés avec le langage python.

Les points suivants seront abordés :

• À quoi sert la programmation ?
• Qu'est-ce que la programmation ?
• Compilation ?
• Les familles de langages
• Les types de données
• Les structures de contrôle
• L'organisation d'un programme
• Les espaces de nommage
• ...

Tout au long de cet atelier, nous accompagnerons les notions par des exemples et nous terminerons par le classique programme de la tortue :-) (en mode graphique).

Notes sur le cours (Première partie)

A quoi sert la programmation ?

Sert à éviter de faire des choses rébarbatives
pour automatiser des processus difficiles à faire à la main
programmation capable de faire des choses à la place d'un humain

programme
faire suivre une suite de commandes (instructions) qui vont faire une tâche bien spécifique
une suite d'instructions on l'exprime avec une syntaxe

instruction : une ligne de code, une action élémentaire exécutable par la machine

organisation d'un programme sous plusieurs formes possibles
fonction : (comme en math) -> données en entrée/données en sortie
procédure : fonction qui ne renvoie rien

programmation
en général, on ouvre un fichier et on écrit dans ce dernier le code source

pour python, on a un shell interactif dans lequel on peut taper des commandes qui seront exécutées.

 [démo]
 >>> <- on demande d'entrer quelque chose

Familles de programmes

compilés
on prend le code source (le programme écrit en langage évolué), on le passe dans une moulinette qui transforme en langage machine (binaire)
beaucoup plus rapide mais à recompiler à chaque modification du programme
un binaire par architecture -> inconvénient

"réservés" aux gens qui savent bien programmer : plus difficile à comprendre

interprétés
un programme (interpréteur) lit le code source et le comprend instruction par instruction et les exécute une par une
pas besoin de recompiler mais à chaque fois besoin de relire, recomprendre et exécuter -> plus lent
mais plus facile à manipuler -> multi-plateforme (pas besoin de compiler pour chaque architecture)

plus facile car l'interpréteur dit où sont les erreurs

Langages

besoin d'un langage formel créé pour remplir des tâches précises

langage
ensemble de commandes (d'instructions) pour exprimer quelque chose dans un langage formel
permet la manipulation de données (ex : déclaration et affectation de variables etc) et structures de contrôle de flot (ex : si, sinon, boucles)

langage objet
plus récent
modélisation du programme par rapport à la réalité
(ex: un écran, on programme suivant l'écran)

python
syntaxe simple et rapide à exécuter
langage interprété

ici c'est python qui va transcrire à la volée et exécuter le programme prévu à la base pour les scientifiques on peut à peu près tout faire (du hello world au jeu 3D) même si le langage est interprété, c'est relativement rapide (ex : bien adapté pr interfaces graphiques) simple niveau syntaxe, le plus clair possible, simple à apprendre en 1-2h de pratique très explicite (pas comme perl hein ! :p) une personne qui ne programme pas est capable de comprendre le code

mi chemin entre Ada et C

C
langage qui commence à dater mais toujours à jour car on peut programmer des choses qu'on ne peut pas faire dans d'autres langages
(ex: coder directement un driver pour une carte réseau)

Ada
vieux langage créé à la demande des militaires états-uniens
langage compréhensible en le lisant, proche du langage naturel (celui utilisé pour parler)

La programmation concrètement

La notion de variable

boîte dans laquelle on met quelque chose
(valeur numérique, chaîne de caractères, bout binaire etc.)

langages typés
les boîtes sont typées
ex: pour une boîte chaîne de caractères on ne peut mettre que des chaines de caractères

python non typé

rappel :
entier : 1 2 3 ...
flottant : décimal 1,2 1.7 ...

identificateur
nom donné à une boîte (ex : port est un symbole)
on peut donc mémoriser des choses en mémoire
(ex : on assigne 3 à port, dans port on aura 3)

constante
symbole qui représente une valeur de manière fixée (ex: 2)

[exemple]
>>> 2
2
--> ok 2 est reconnu
 
>>>2+2
4
--> évalué, l'instruction vaut 4

on va enrichir le langage avec des instructions plus compliquées

spécificité des ordinateurs

[exemple]  
>>>5/2
2
--> 5 type entier et 2 type entier.
    donc division entre deux nombres de type entier donne un entier
 
>>>5.0/2.0
2.5
--> float/float donne float
 
donc ATTENTION
 
>>>5.0/2
2.5
>>>5/2.0
2.5
--> quand on mélange entier et float, le float prend le pas

ATTENTION les processeurs dans les machines font des arrondis donc 1.45632 - 1.45632 peut ne pas donner 0

ATTENTION la division par 0 n'est pas permise -> il faut donc penser à gérer le cas
les langages plantent à cause de ça : quand c'est du C, ça plante direct
En python, on a un avertissement car l'interpréteur vérifie à notre place

>>>5/0
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ZeroDivisionError: integer division or modulo by zero

[exemple de manipulation de variables]
>>>a
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: name 'a' is not defined
--> ne connait pas le symbole a

>>>a=2
>>>a
2
--> symbole connu et mémorisé à 2

>>> 10/a
5
--> a symbole valant 2 donc on a 5

[exercice]
enoncé : faire en sorte que b/a donne 2
>>>a=2
>>>b=4
>>>b/a
2

pourquoi a/b donne 0
--> parce que c'est une division de nombres entiers donc le résultat est aussi une valeur entière donc 0

Les chaînes de caractères

Chaînes de caractères ou string
entourée entre guillemets doubles ou simples

[exemple]
>>>"bonjour"
'bonjour'

[exercice]
énoncé : assigner "hello" dans la variable bonjour et afficher bonjour]
>>>bonjour="hello"
>>>bonjour
'hello'

>>>a
2
>>>a="porte"
>>>a
'porte'
--> les boîtes peuvent contenir n'importe quoi
    le type de données contenu dans la variable a peut donc changer

Les opérateurs

[exercice]
énoncé : 
  mettre a à 10
         b à 3 
         c à a+b
>>>a=10
>>>b=3
>>>c=a+b
>>>c
13

[exercice]
énoncé : 
  mettre a à "bonjour" et b à votre prénom
  mettre "bonjour le_prénom" dans c

concaténer
prendre une chaîne ch1 et venir accoler une autre chaîne ch2 à ch1
en python, l'opérateur de concaténation est +

[exemple]
>>> a="bonjour"
>>> b="john"
>>> c=a+b
>>> c
'bonjourjohn'

>>>a="bonjour "
>>>c
'bonjourjohn'

si on modifie a entre tps, c ne sera pas réévaluée

>>>c=a+b
>>>c
'bonjour john'

[exercice]
énoncé :
  mettre "bonjour le_prenom" sans mettre d'espace dans a
  d'abord commencer par une variable intermédiaire
>>>d=" "
>>>c=a+d+b
>>>c
'bonjour john'

énoncé : ensuite passer que par a et b sans les modifier (valeur immédiate)
>>> a="bonjour"
>>> c=a+" "+b
>>> c
'bonjour john'

--> on a aussi le droit de mettre une constante littérale (ex : une chaîne de caracères) sans l'assigner à une variable
    l'interpréteur ne fait que remplacer le symbole de la variable par la valeur

on peut donc mélanger variables et constantes
on a pu concaténer les variables car elle étaient de même type

[exercice]
énoncé : on veut afficher "nous sommes le11"
>>>a="nous sommes le"
>>>b=11
>>>a+b
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: cannot concatenate 'str' and 'int' objects

--> impossible parce qu'ils ne sont pas du même type

cast : le fait de passer d'un type à l'autre
en général en python, on entoure la variable qu'on veut changer par le type que l'on veut

>>>float(2)
2.0

[exercice] 
énoncé : transformer le type de b qui est entier en type chaîne de caractères

>>>str(b)
'11'
>>>a+" "+str(b)
'nous sommes le 11'

énoncé : transformer b qui est de type entier en chaîne de caractères
>>>b=str(b)
>>a+" "+b
'nous sommes le 11'

[exercice]
énoncé :
  déclarer 3 variables : jour, moi et annee
  mettre respectivement les valeurs numériques : 11, 03 et 2006
  afficher 11/03/2006
  (on pourra mettre "/" dans une variable ou en valeur immédiate)

>>>jour=11
>>>moi=03
>>>annee=2006
>>> str(jour)+"/"+str(moi)+"/"+str(annee)
'11/3/2006'

OU

>>>slash="/"
>>> str(jour)+slash+str(moi)+slash+str(annee)
'11/3/2006'

[exercice sur le cast]
énoncé :
  mettre 42 en chaîne de caractères dans a
  convertir a en valeur numérique

>>>a="42"
>>>a
'42'
>>>a/2
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: unsupported operand type(s) for /: 'str' and 'int'
>>>a=int(a)
>>>a
42
>>>a/2
21

[exercice]
énoncé :
  convertir "42" en entier qu'on reconvertit en chaîne de caractères
  en une seule instruction !
>>>str(int("42"))
'42' 

la fonction type : type(variable ou valeur)
permet d'obtenir le type de la variable ou de la valeur

>>> a="42"
>>> type(a)
<type 'str'>
>>> type(int(a))
<type 'int'>

Les structures de contrôle

mots-clef permettant de prendre un embranchement ou pas selon une condition
permet de savoir quelle direction prendre quand on se pose une question

ex : si la porte est ouverte alors on rentre, sinon on l'ouvre

mot clef if si l'expression est vraie alors on prend un embranchement

en informatique, quelque chose de vrai est quelque chose qui ne vaut pas 0

syntaxe (python) :

  if expr:
     instr1
  instr2

si l'expression expr est vraie, on execute le bloc d'instructions instr1 puis instr2. Sinon on exécute directement instr2.
Pour résumer, si expr est vraie alors on exécute instr1 sinon non. Et dans tous les cas on exécute instr2.

une évaluation doit donner oui ou non, l'ordinateur ne peut faire autrement.
exemple:
est-ce que 1 est supérieur à 2
est-ce que 1 est égal à 2

[exemple]
>>> 2>3
False

ATTENTION comme l'assignation est exprimée avec le signe égal (=) pour faire la comparaison d'égalité il faut doubler le égal donc ==

>>> 2=2
SyntaxError: can't assign to literal
>>> 2==2
True

[exemple de même avec des variables]
>>> a=2
>>> b=1
>>> a<b
False
>>> b<a
True
>>> b==a
False

quand on demande un if, le shell intéractif python se transforme en ...
cela indique qu'on attend le bloc d'instructions du if

en python, une ligne se finissant par : indique que l'on rentre dans un bloc. Les lignes faisant partie de ce bloc doivent etre indentées (faire une tabulation pour chaque ligne de ce bloc).

python est sensible à l'indentation (les tabulations)

[démo]
>>> if 2>3:
...     a=2
...
>>>

>>> a=0
>>> a
0
>>> if 5<10:
...     a=5
...
>>> a
5

else : sinon en anglais

syntaxe (python) :

  if expr:
       isntr1
  else:
       instr2
  instr3

[exercice]
énoncé : 
  dans le cas où 2 est supérieur à 3 alors a=2
  sinon a=3

>>> a=0
>>> if 2>3:
...     a=2
... else:
...     a=3
...
>>> a
3

Les fichiers

ouvrir un fichier exo.py

le fichier est vide
execution : python le_fichier

[exemple]
$ python exo.py
$

print x : affiche x

[exercice]
énoncé :
 a=2
 b=10
 dans le cas où b moins a est supérieur à a, afficher "oui"
 sinon afficher "non"

contenu du fichier :
a=2
b=10

if  (b-a) > 1:
   print "oui"
else:
   print "non"

exécution :
$ python exo.py
oui
$

commentaires : # les commentaires

[exercice]
 si a est supérieur à 5 alors
   si b est supérieur à 3 alors 
     afficher "1"
   sinon 
     afficher "2"
 sinon
   afficher "3"

 Puis trouver les différentes valeurs de a et b pour afficher chaque message

contenu du fichier :
a=6
b=4

if a>5:
    if b>3:
        print "1" # a=6 et b=4
    else:
        print "2" # a=6 et b=2
else:
    print "3" # a=4

exécution :
avec a=6 et b=4
$ python exo.py
1 

avec a=6 et b=2
$ python exo.py
2

avec a=4
$ python exo.py
3 

on peut imbriquer autant de if qu'on veut, il faut juste faire les bonnes indentations

bloc d'instructions
plusieurs instructions à la suite
un bloc est défini en fonction de la tabulation

[exemple]
if a > 5:
  print a                  |
  print "est supérieur à"  | ==> bloc d'instructions
  print 5                  |
  

boucle
le fait d'exécuter un bloc d'instructions plusieurs fois à la suite tant qu'une condition n'est pas remplie
(ex : vérifier la température jusqu'à ce que la température soit de 20°)

2 opérateurs :

• while : tant que en anglais, tant qu'une expr est pas remplie
• for : une boucle faisant varier un indice d'une valeur à une autre

syntaxe (python) :

  while expr:
     instr

tant que expr est vrai, on execute le bloc instr et dès que c'est plus vrai on passe à la suite

ATTENTION le piège est de rester coincé dans la boucle

[exercice]
énoncé :
  a=1
  tant que a est inférieur à 10, on va afficher a et incrimenter a de 1 

incrémenter : ajouter 1 à a c'est-à-dire a=a+1

contenu du fichier :
a=1

while a<10:
    print a
    a=a+1 

--> il faut bien penser à incrémenter a de 1 car sinon la condition ne sera jamais vraie et on restera coincé dans la boucle

exécution :
$ python exo.py
1
2
3
4
5
6
7
8
9
$

[exercice]
énoncé :
  faire un prog qui calcule le nombre de fois qu'un nombre peut etre divisé
  par 2 de manière successive
  (moins de 10 lignes de code)

[à faire pour la prochaine fois]

Notes sur le cours (Deuxième partie)

[correction de l'exercice à faire]
contenu du fichier :
a=100
nb=0

while a>0: OU while a != 0:
    a=a/2
    nb=nb+1
print str(nb)+" fois" 

exécution :
$ python exo.py
7 fois
$

!= : négation de égal (=)

Les fonctions

sert à éviter de recopier à chaque fois le même code

on décompose un programme en sous programmes (les fonctions)
permet de mieux organiser le programme principal et ainsi de le rendre plus propre
(ex : une fonction qui prend en entrée une voiture et qui en sortie retourne sa consommation)

concrètement, c'est un bout de programme qui prend des données en entrée et retourne un résultat en sortie

procédure
une procédure est une fonction qui ne retourne rien
utile par exemple pour afficher ou encore pour agir sur des variables qu'on aura passé

en python, il n'y a pas de distinction entre fonction et procédure. Ainsi, on appellera tout fonction

une fonction peut prendre des paramètres en entrée (arguments) ou non

déclaration d'une fonction sans arguments (en python) :

def nom_fonction:
   instr

def ne fait que déclarer la fonction mais ne l'appelle pas

return val : placée à la fin du bloc d'instruction de la fonction, cette instruction retourne val

[exercice]
énoncé :
  écrire une procédure qui affiche bonjour

code :
def aff_bonjour():
    print "bonjour"

aff_bonjour()

exécution :
$ python exo.py
bonjour
$

-> ici, c'est une procédure car elle ne renvoie rien qu'on puisse utiliser par la suite

[exercice]
énoncé :
  transformer la procédure ci-dessus en fonction qui retourne la chaîne de caractères "bonjour"
  au lieu de l'afficher

code :
def bonjour():
   return "bonjour"

bonjour()

exécution :
$ python exo.py
$

-> il ne se passe rien. La fonction est appelée et renvoie quelque chose mais on ne l'a pas récupéré.

[exercice]
énoncé :
  récupérer le résultat de la fonction bonjour dans une variable a et l'afficher

code :
def bonjour():
   return "bonjour"

a = bonjour()
print a

exécution :
$ python exo.py
bonjour
$

-> a est donc égal au résultat de la fonction.

[exercice]
énoncé :
  même exercice que précédemment mais ne pas stocker le résultat dans une variable.
  Afficher directement le résultat.

code :
def bonjour():
   return "bonjour"

print bonjour()

exécution :
$ python exo.py
bonjour
$

Dans un programme, on peut avoir autant de fonctions que l'on veut.

Une fonction peut recevoit quelque chose en entrée : des arguments.

Déclaration d'une fonction avec arguments (en python) :

def nom_fonction(arg1, arg2, ...):
   instr

où arg1 est la valeur du premier l'argument, arg2 est la valeur du second etc.

[exercice]
énoncé :
  écrire une fonction qui fait une addition entre deux nombres a et b passés en paramètres 
  et qui l'affiche.

code :
def addition(a, b):
   print a+b

addition(2, 3)

exécution :
$ python exo.py
5
$

-> la fonction va recevoir a et b. Elle va ensuite pouvoir les utiliser.

[exercice]
énoncé :
  transformer la procédure en une fonction qui retourne le résultat de l'addition de a+b
  afficher le résultat retourner

code :
def addition(a, b):
   return a+b

print addition(2, 3)

exécution :
$ python exo.py
5
$

[exercice]
énoncé :
  reprendre le dernier exercice de la première partie, exercice qui était à faire, et en faire une fonction
  but : écrire l'exercice dans une fonction et appeler cette dernière

code :
def nb_div(a):
   nb = 0
   while a>0:
       a = a/2
       nb = nb+1
   return nb

print str(nb_div(100))+" fois"

exécution :
$ python exo.py
7 fois
$

Un peu de graphique

Nous allons utiliser le module turtle.

turtle est une tortue sur une plage (ok, il faut avoir pas mal d'imagination).
Un pointeur représente la tortue et ce dernier se déplace.
But : diriger la tortue.

Prérequis :
Avant d'utiliser le module turtle, il faut toujours l'importer

import turtle
  OU plutôt...
from turtle import *

On va utiliser des fonctions (plutôt des procédures) qui vont diriger la tortue.

Quelques fonctions :

• forward(distance) : fait avancer la tortue de distance pixels
• right(angle) : fait tourner la tortue vers la droite de angle degrés
• left(angle) : idem mais vers la gauche
• reset() : remet la tortue au milieu de la plage

À chaque utilisation de la tortue, il serait bien de la réinitialiser.

[exercice]
énoncé :
  écrire un petit script qui fait dessiner un carré à la tortue

code :
from turtle import *

reset()
# premier côté
forward(50)
right(90)

# deuxième côté
forward(50)
right(90)

# troisième côté
forward(50)
right(90)

# quatrième côté
forward(50)
right(90)

résultat :

Encore d'autres fonctions :

• color(nom_coul) : change de couleur. nom_coul est une chaîne de caractères (ex : "red", "green", "blue", "brown" etc.)
• setx(xpos) : déplace le pointeur à l'abscisse xpos.
• sety(ypos) : déplace le pointeur à l'ordonnée ypos.
• up() : soulève le pointeur du papier.
• down() : remet le pointeur sur le papier.

L'origine est le centre de la fenêtre.

[exercice]
énoncé :
  écrire une fonction rect_plein qui dessine ligne par ligne (comme une ancienne machine à écrire)
  un rectangle de dimensions wxh aux coordonnées (x,y)
prototype : rect_plein(w, h, x, y)

-- à faire pour la prochaine fois --

résultat :

[exercice]
énoncé :
  dessiner le drapeau français avec son manche
  le dessin est composé de 3 rectangles pleins : 1 bleu, 1 rouge et 1 marron, ainsi que d'un rectangle
  vide noir pour réaliser le tour du drapeau

-- à faire pour la prochaine fois --

résulat :