Structure du cours

• 11 cours de 2h: CM et TP
• Évaluation: Projet (pas d'examen) pour 3 ECTS.
• Aucune connaissance préalable en programmation n'est requise.

Projet

• Créer un programme python (qui peut être pour votre recherche, pour des loisirs, pour simplifier des tâches répétitives, etc).
• Doit être approuvé par l'enseignant.
• Réfléchissez-y dès maintenant!
• Le cours sera adapté à vos besoins. Une fois choisi, je vais vous montrer des composantes utiles pour votre projet.

C'est principalement un cours pour vous faire découvrir un outil utile (ou développer vos habiletés à l'utiliser selon le cas).

Apprendre à programmer

Beaucoup de gain pour peu de travail au début (si on réussit à adopter en partie la nouvelle méthode de réflexion).

Ça prends un peu de temps pour s'habituer (au langage et aux outils). Passer un peu de temps à utiliser le langage (pour n'importe quel raison) au début aide beaucoup à apprivoiser le langage. (Normalement, une étape pas très difficile avec le Python.)

Contexte

Au début de chaque cours, je vais vous parler du contexte dans lequel se place la programmation, c'est à dire l'informatique.

Ces informations ne sont pas nécessairement utiles immédiatement dans de but de réaliser un projet de programmation (ou même dans le but d'apprendre à programmer). Mais peut vous aider à comprendre et aussi donner un aperçu des outils de l'informatique qui pourraient vous être utile.

Aujourd'hui je vais vous parler des langages de programmation.

Langage

Ce cours vous introduit au langage de programmation Python. Mais pourquoi avons nous besoin de langages de programmation, différent des langages naturels? Voici une explication possible.

Nous voulons qu'un ordinateur (ou même un humain) suive des instructions précise.

Il y a trop d'ambiguïté dans les langages naturels.

Elle emporte les clefs de la maison au garage.

(Les clef de la maison ou bien emportés de la maison.)

Cela mène à la création de langage adapter à des descriptions et des instructions: les langages de programmation.

Les programmes, ce sont des textes (notamment des fichiers textes) que vous écrivez contenant des instructions.

Ils seront exécutés ligne par ligne (et en ordre des priorités des opérations pour chaque ligne).

Remarque: Le langage est là pour vous aider à vous exprimer. Il a l'avantage d'être lisible par un ordinateur mais n'oubliez pas l'idée que vous voulez exprimer à cause des contraintes du langage (ou des outils)!

(Autre raisons: redondance, facilité d'apprentissage (pour les gens qui connaissent un autre langage (de programmation)). Beaucoup moins de vocabulaire et syntaxe.)

Autre différence entre langage de programmation et langages naturels

Un langage de programmation a typiquement

• Moins de vocabulaire (beaucoup d'expressivité même en connaissant une petite partie du langage).
• Grammaire plus rigide (moins de possibilité pour des phrases structurés différemment).
• Plus de ponctuations.

Python (avantages du langage)

• Un langage interprété
• Misant sur la lisibilité (votre programme sera lu par humain tout autant que des ordinateurs)
• Facile à apprendre pour les débutants.
• Donne la possibilité de programmer avec des styles et « niveaux » différents. (Nous allons surtout couvrir le style dit impératif. « Fait ci! Fait ça! »)
• Langage fortement introspectif. (dir, globals, locals, hasattr, inspect, pdb, etc)
• Grand nombre de fonctions déjà inclus (dans des modules que nous allons voir au 3e cours).

Instructions

But: amener un programme à un état voulu (ce sera plus évident avec des exemples plus complexe).

Comment? Décrire exactement ce qu'il faut faire pour arriver au résultat voulu à partir d'un état de départ (qui est souvent le "vide" ou l'état qui a seulement les données chargées).

La modification de l'état de départ se fait étape par étape.

Une telle description est un programme.

D'abord, regardons des objectifs où il y a une seule étape.

Remarque (avancée): Écrire des instructions étape par étape n'est pas la seule façon de programmer.

Utilisation (console)

Commençons! Lancer l'interpréteur Python (un programme qui comprends le langage Python et exécute les énoncés dans ce langage).

Selon votre système d'exploitation, vous verrez sans doute quelque chose comme suit.

Après un peu de texte, vous êtes accueilli par l'invité de commande

>>>

Vous êtes maintenant dans l'interpréteur.

Vous pouvez taper directement ici pour entrer votre première ligne de python (et tapez entrée après).

>>> print "Hello world"
Hello world
>>>

Vous pouvez taper la prochain ligne et ainsi de suite.

>>> print "Hello world"
Hello world
>>> print 2+3*3
11
>>>

Pour quitter l'interpréteur, appuyez sur ctrl-d (appuyez sur ctrl et sans lâcher ctrl, appuyez sur d). Sous Windows, c'est ctrl-z.

Un point pratique: Python 2 et Python 3

Dans ce cours, nous allons utiliser Python 2 (c'est-à-dire 2.7, 2.6, 2.5, etc) qui diffère légèrement de Python 3.

En Python 2

>>> print "Hello world"
Hello world

En Python 3

>>> print("Hello world")
Hello world

Utilisation (éditeur texte)

Au lieu de lancer l'interpréteur, vous pouvez

• écrire vos lignes directement dans un fichier texte,
• sauvegarder ce fichier (par ex sous le nom test.py) et
• le lancer avec python test.py.

L'interpréteur exécute le contenu de test.py ligne par ligne.

Un exemple de ce que pourrait contenir test.py

print "Hello world"
print 2+3*3

Remplacer test.py par le nom de votre fichier. Il faut d'abord se placer dans le répertoire où vous avez sauvegardé votre fichier (en utilisant cd suivi du nom du répertoire).

test.py est appelé un script Python.

Astuce: Vous pouvez écrire vos ligne dans l'interpréteur et ensuite recopier les lignes que vous voulez garder dans l'éditeur de texte.

Utilisation (combiné)

Au lieu de lancer l'interpréteur, vous pouvez

• écrire vos lignes directement dans un fichier texte,
• sauvegarder ce fichier (par ex sous le nom test.py) et
• le lancer avec python -i test.py. Notez l'ajout du -i!

Cela exécute le contenu de test.py et vous donne un invité de commende

>>>

à l'arrêt (qui arrive soit à la fin de la dernière ligne ou lors d'une erreur).

Erreur

Une des première choses que vous allez rencontrer est une erreur, qui est soit de syntaxe

>>> pas du python
  File "<stdin>", line 1
    pas du python
         ^
SyntaxError: invalid syntax

ou d'exécution.

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

Dans chaque cas, vous avez un peu d'information sur l'endroit et la nature de l'erreur.

Pas de panique. Corrigez et re-essayez.

(Ces exemples sont ici uniquement pour vous aider à distinguer entre les erreurs d'une exécution normale.)

Voir cette liste de problème habituels

Mode d'apprentissage

Quel est le prochain chiffre dans cette suite? 1, 4, 9, 16, 25, ?

Au tout début, il est normalement beaucoup plus rapide d'apprendre par déduction qu'en écoutant une description.

Lancez l'interpréteur et tapez des lignes que vous pensez être valide dans l'interpréteur. Ce n'est pas grave s'il y a beaucoup d'erreurs générés (tant qu'il y a quelques lignes de bonne). En observant ces résultats, vous déduirez le fonctionnement du langage et de l'interpréteur (en partie).

Vous pouvez aussi prendre une ligne correcte (que vous comprenez) et la modifier petit à petit.

Astuce: Vous pouvez appuyer sur les flèches haut et bas pour parcourir l'historique des lignes entrées. Cela vous permet de corriger plus facilement une ligne sans perdre le travail effectué. (Une autre raison pour tenter d'entrer des lignes dont vous êtes incertain au début.)

Les description et grammaires formelles seront mis en annexe, mais le texte principale contiendra seulement des exemples.

Pour tard, vous devrez faire exactement inverse: comprendre sans trop déduire (parce que le fonctionnement que l'on déduit à première vu sera faux).

Opérations arithmétiques

Remarque: L'interpréteur imprime automatiquement la valeur évaluée même sans print (mais cette impression n'arrive pas dans un script).

Vous pouvez utiliser Python pour de longs calculs.

>>> 5*5
25
>>> (3*3) + (4*4)
25

Deuxième exemple: Trouver les racines de 2x^2 - 11x + 3.

>>> (-11)*(-11) - 4*2*3
97
>>> ( -(-11) + 97**0.5 ) / (2.0*2)
5.212214450449026

La principale différence avec la notation mathématique est la multiplication explicite (par *) et le résultat tronqué si on divise deux entier.

Il y a aussi une opération de modulo.

>>> 20 % 3
2

Variables

Dans ce deuxième exemple, on aurait bien voulu avoir des variables comme en mathématiques. On peut.

>>> a = 2
>>> b = -11
>>> c = 3
>>> d = b*b - 4*a*c
>>> ( -b + d**0.5 ) / (2.0*a)
5.212214450449026
>>> ( -b - d**0.5 ) / (2.0*a)
0.28778554955097402

Mais attention, les variables n'ont pas le même sens (d'inconnu) qu'en maths.

• Les variables sont des noms (que vous choisissez) associé à des valeur.
• Écrire son nom dans un expression le remplace par sa valeur à ce moment.
• Associer une deuxième valeur au même nom remplace l'ancienne valeur associée.
• Il y a d'autre façon de modifier des valeurs déjà associées.
• Quelques restrictions s'appliquent aux noms qu'on peut utiliser. (Dans ce cours, nous allons normalement utiliser que les lettres et _ dans les noms.)
• Pour des types plus complexes, la valeur est en fait un emplacement dans la mémoire (mais nous n'avons pas encore vu ce qu'est un type).

L'association (ou l'assignation) se fait avec = par la syntaxe nom = expression.

Nous verrons que les variables ont beaucoup plus d'utilité qu'une simplement fonction de mémoire comme dans une calculatrice.

Plus tard, il faudra aussi faire attention à bien choisir les noms de variables pour représenter leur contenu.

Chargement des données

À chaque nouveau lancement, les assignations sont remis à zéros. Si nous voulons faire les même calculs avec des entrées différentes. Pour cela, vous pouvez utiliser l'instruction input().

Si le fichier exemple_lecture.py contient

a = input("Entrez la valeur de a: ")
b = input("Entrez la valeur de b: ")
c = input("Entrez la valeur de c: ")
d = b*b - 4*a*c
print "Les deux racines sont"
print ( -b + d**0.5 ) / (2.0*a)
print ( -b - d**0.5 ) / (2.0*a)

Au lancement, vous verrez

$ python exemple_lecture.py
Entrez la valeur de a:

Tapez la valeur voulue et appuyez sur entrée.

Entrez la valeur de a: 2
Entrez la valeur de b: -11
Entrez la valeur de c: 3
Les deux racines sont
5.21221445045
0.287785549551

Quelques types

Implicitement nous avons déjà vu les deux types

• int pour des entiers (comme 1, -11 et 3)
• float pour des nombre à virgule (comme 0.5 et 3.141592653589793)

Attention: Les floats ne sont pas des fractions exactes.

>>> 0.1 + 0.1 + 0.1
0.30000000000000004

La fonction type permet d'obtenir le type d'une expression.

>>> type(3)
<type 'int'>
>>> x = 1/2.0
>>> type(x)
<type 'float'>
>>> type(0.1 + 0.1 + 0.1)
<type 'float'>

Cette fonction est peu utilisée hors de l'interpréteur et typiquement utilisée pour examinée le type d'une variable.

Conversion de types

Nous avons déjà vu comment créer des constantes d'un type (par ex 3 et 0.1). Voici une autre façon.

Nous pouvons appeler la fonction du nom du type (comme int et float) pour convertir une valeur en ce type.

Convertir le int 9 en un float et le float 3.2 en un int.

>>> float(9) 
9.0
>>> int(3.2) 
3

C'est aussi une autre façon d'obtenir une valeur de ce type.

>>> x = int()
>>> x
0

Le type booléen bool

Un autre type qui prends seulement deux valeurs différentes est bool.

Les deux valeurs sont True et False (et les constantes bool sont créés ainsi).

Ils sont utilisé pour l'exécution conditionelle d'instructions. Beaucoup d'opérations retournent un bool.

Quelques exemples

>>> 2 > 8
False
>>> 3 == 3
True
>>> x = (5 < 7)
>>> x
True

Il existe plusieurs opération booléennes dont or, and et not.

>>> (2 > 8) or (3 == 3)
True
>>> not (2 > 8)
True
>>> (2 > 8) and x
False
>>> (9 > 24) and inexistant
False

Remarque: Python utiliser une évaluation paresseuse: si le premier élément de and évalue à True alors, il n'évalue pas le deuxième élément. (inexistant est un nom auquel aucune valeur n'est associé et qui aurait donné une erreur si l'évaluation n'est pas paresseuse.)

>>> inexistant
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'inexistant' is not defined

À quoi servent les bools? Nous allons le voir maintenant.

Contrôle du flux des instructions

L'interpréteur Python exécute les instructions ligne par ligne. Mais nous allons maintenant voir des instructions qui peut guider son exécution. Notamment en sautant des instructions ou en répétant des lignes.

>>> x = 3
>>> if x < 0:
...     print "x est négatif"
... 
>>> x = -1
>>> if x < 0:
...     print "x est négatif"
... 
x est négatif
>>>

La ligne print "x est négatif" est exécutée seulement si x < 0 évalue à True.

elif et else permettent une organisation de plusieurs tests successifs (on passe au prochain test lorsque ceux d'avant sont évalués à False).

if x <= 0:
    print "x est négatif"
elif x % 2 == 1:
    print "x est positif et impair"
else:
    print "x n’est pas négatif et est pair"

Vous pouvez visualiser les lignes exécutés ici.

Essayez de changer la valeur de x sur la première ligne.

Concrètement, on utilise if, then et else lorsque les lignes que l'on veut exécuter sont différentes selon la valeur des variables.

x_neg = (x <= 0)
if x_neg:
    print "x est négatif"

Remarque (avancée): Des variables de type différent de bool peuvent aussi être mis comme condition. Ils sont normalement considérés comme False lorsqu'ils sont vides (et True sinon).

Blocs d'instruction

Nous venons de voir notre premier exemple de bloc indenté. C'est une particularité du Python.

Les instructions avec la même indentation (nombre d'espace en début de ligne) appartiennent au même bloc.

Les blocs peuvent être emboîtés autant qu'on veut. Nous verrons des exemples bientôt.

Boucle while

Pour re-exécuter les mêmes lignes plusieurs fois, nous pouvons utiliser l'instruction while.

>>> x = 257
>>> compte = 0
>>> while x > 1:
...     x = x / 2
...     compte = compte + 1
... 
>>> compte
8

Cet exemple calcul le log en base 2 de x arrondi vers le bas.

Les deux lignes du bloc indenté sont exécutés tant que x > 1 évalue à True.

Visualisation ici

Ces lignes sont exécutés tant que la condition de la boucle est satisfaite.

Remarque: À la ligne x = x / 2 nous avons un exemple d'une assignation à x d'une valeur obtenue de la valeur de x avant l'assignation.

Interrompre une boucle

Nous pouvons aussi sortir d'une boucle avec l'instruction break.

>>> x = 257
>>> compte = 0
>>> while True:
...     x = x / 2
...     compte = compte + 1
...     if x <= 1:
...         break
...
>>> compte
8

Cette version est presque équivalent à la boucle précédente. Qu'arrive-t-il si on met x = 257 en première ligne?

Les chaînes de caractères str

Un autre type que nous avons d'ailleurs déjà utilisé sont les chaînes de caractères.

>>> print "Hello world"
Hello world
>>> type("Hello world")
<type 'str'>
>>> "Hello world"
'Hello world'

"Hello world" est une chaîne de longueur 11.

>>> len("Hello world")
11

Comme son nom l'indique, ce sont les caractères suivants les unes après les autres 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'.

Les chaînes de caractères sont un peu plus complexe que les int, float et bool déjà vu pour cette raison.

Voici trois syntaxes différentes pour créer des chaînes de caractères.

>>> s1 = "Hello world"
>>> s2 = 'Hello world'
>>> s3 = """Hello world"""

Caractère d'échappement

À priori, nous voulons être capable de représenter tout caractère. Comment peut-on créer une chaîne avec un seul caractère: " ?

>>> '"'
'"'
>>> "\""
'"'

\ est un caractère d'échappement. Le caractère qui vient après est interprété différament.

(Réfléchissez à comment est-ce que vous aurez conçu un système pour représenter toute chaîne de caractère sans ambiguïté. Selon votre solution, les caractères d'échappement et les différentes syntaxe peuvent s'expliquer en soi.)

Quelques combinaisons courantes sont

• \\ donne \

• \n donne une fin de ligne

  print "Ligne 1\nLigne 2\nLigne 3" Ligne 1 Ligne 2 Ligne 3

La syntaxe à trois guillemets permet aussi d'obtenir des chaînes multi-lignes.

>>> s = """Ligne 1
... Ligne 2
... Ligne 3"""
>>> s
'Ligne 1\nLigne 2\nLigne 3'
>>> print s
Ligne 1
Ligne 2
Ligne 3

Opérations courantes

• Concaténation

  >>> s + s
  'Ligne 1\nLigne 2\nLigne 3Ligne 1\nLigne 2\nLigne 3'
  

• Répétition

  >>> "oysters "*3 + "eat "*3
  'oysters oysters oysters eat eat eat '
  

• Élimination d'espaces blancs (espace, fin de ligne, etc)

  >>> "    ab cd  \n".strip()
  'ab cd'
  

• Séparation et recombinaison (interaction avec le type list, à voir au prochain cours). Très utile pour charger des données.

  >>> s = "Des mots separes d'espaces"
  >>> liste_de_mots = s.split()
  >>> liste_de_mots
  ['Des', 'mots', 'separes', "d'espaces"]
  >>> s_virgule = ",".join(liste_de_mots)
  >>> s_virgule
  

• Remplacement

  >>> s_virgule.replace("d'espaces", "de,virgules")
  'Des,mots,separes,de,virgules'
  

• Tests

  >>> s_virgule.startswith("Des,")
  True
  >>> s_virgule.endswith("x")
  False
  

• Sous-chaîne (nous verrons la syntaxe plus en détails lors de la discussion des list)

  >>> s_virgule[2:21]
  "s,mots,separes,d'es"
  

Ici nous voyons aussi un premier exemple d'appel de fonctions.

• len(s) (appel nom_de_fonction(parametre1, parametre2, ...))
• s.replace("a", "b") (appel variable.nom_de_fonction(parametre1, parametre2, ...))

C'est une syntaxe que nous allons souvent revoir.

Sortie et chaînes formatées

Nous avons déjà utilisé plusieurs fois l'instruction print. Voici quelques (autres) forme de son utilisation.

>>> a = 2
>>> b = 5
>>> print "La somme de", a, "et", b, "est", a + b

On passe ici une liste de 6 arguments à print (séparés de virgules):

• "La somme de"
• a
• "et"
• b
• "est"
• a + b

Deux alternatives plus "modernes".

print "La somme de %s et %s est %s" % (a, b, a + b)
print "La somme de {} et {} est {}".format(a, b, a + b)

% est un autre caractère d'échappement pour les chaînes de caractères.

Commentaires

Rappel: Vos programmes seront constamment lu par des humains, incluant vous même lors de sa modification.

Les commentaires sont des morceaux de texte qui ne sont pas exécutés. Ils permettent d'ajouter de l'information supplémentaire lorsque le fonctionnement n'est pas évident.

>>> x = 3 # Ceci est un commentaire
>>> # Ceci est un autre commentaire

Tout ce qui est après # sur une ligne est ignoré par l'interpréteur.

Les chaînes de caractères multi-lignes servent aussi de commentaires. Rappel qu'ils ne sont pas affichés s'ils sont exécuté à l'intérieur d'un script.

""" Ceci est
un commentaire sur
plusieurs lignes
"""