Apprendre Python et s'initier à la programmation

L'exécution d'un programme Python se fait à l'aide d'un interpréteur. Il s'agit d'un programme qui va traduire les instructions écrites en Python en langage machine, afin qu'elles puissent être exécutées directement par l'ordinateur. Cette traduction se fait à la volée, tout comme les interprètes traduisent en temps réel les interventions des différents parlementaires lors des sessions du parlement Européen, par exemple. On dit donc que Python est un langage interprété.

Il y a deux modes d'utilisation de Python. Dans le mode interactif, aussi appelé mode console, l'interpréteur vous permet d'encoder les instructions une à une. Aussitôt une instruction encodée, il suffit d'appuyer sur la touche ENTER pour que l'interpréteur l'exécute.

La figure 2 à la page suivante montre le programme Hello World en mode interactif. Les lignes qui commencent par >>> sont l'invite de commande qui vous propose d'encoder une instruction. Si cette dernière produit un résultat, il est affiché une fois l'instruction exécutée. Voici donc l'instruction qui a été encodée et le résultat qu'elle a produit :

>>> print('Hello World!')
Hello World!

Pour quitter le mode interactif, il suffit d'exécuter l'instruction exit(). Il s'agit de nouveau d'une fonction prédéfinie de Python permettant de quitter l'interpréteur.

Le mode interactif est très pratique pour rapidement tester des instructions et directement voir leurs résultats. Son utilisation reste néanmoins limitée à des programmes de quelques instructions. En effet, devoir à chaque fois retaper toutes les instructions s'avèrera vite pénible.

Il existe également le mode script où vous devez avoir préalablement écrit toutes les instructions de votre programme dans un fichier texte, et l'avoir enregistré sur votre ordinateur. On utilise généralement l'extension de fichier .py pour des fichiers contenant du code Python. Une fois cela fait, l'interpréteur va lire ce fichier et exécuter son contenu, instruction par instruction, comme si vous les aviez tapées l'une après l'autre dans le mode interactif. Les résultats intermédiaires des différentes instructions ne sont par contre pas affichés ; seuls les affichages explicites (avec la fonction print, par exemple) se produisent.

On peut utiliser l'interpréteur Python en mode interactif comme une calculatrice. En effet, si vous y tapez une expression mathématique, cette dernière sera évaluée et son résultat affiché comme résultat intermédiaire. Rappelez-vous que cela ne fonctionne pas avec le mode script. Voici, par exemple, une succession d'instructions encodées en mode interactif, ainsi que les résultats produits :

>>> 42
42
>>> 2 * 12
24
>>> 2 ** 10
1024
>>> ((19.99 * 1.21) - 5) / 4
4.796975

Python propose plusieurs opérateurs arithmétiques repris dans la figure 3. Il y a évidemment les classiques : l'addition (+), la soustraction (-), la multiplication (*) et la division (/). On retrouve également l'exponentiation (**) qui permet d'élever un nombre à une certaine puissance. Enfin, il reste deux autres opérateurs (// et %), destinés au calcul avec des nombres entiers.

II-A-1-b-i. Priorité▲

II-A-1-b-ii. Division entière et son reste▲

Avant de pouvoir accéder au contenu d'une variable, il faut qu'elle soit initialisée, c'est-à-dire qu'elle doit posséder une valeur. Si vous tentez d'utiliser une variable non initialisée, l'exécution du programme va s'arrêter et l'interpréteur Python va produire une erreur d'exécution. Voyons cela avec l'exemple de programme suivant :

height = 178
print('Sa taille est :')
print(heigth)

Le programmeur a fait une malencontreuse faute de frappe à la troisième instruction, et lors de son exécution, l'interpréteur s'arrête et produit une erreur :

Sa taille est :
Traceback (most recent call last):
  File "program.py", line 3, in <module>
    print(heigth)
NameError: name 'heigth' is not defined

L'avant-dernière ligne reprend l'instruction qui a causé l'erreur d'exécution (à savoir print(heigth) dans notre cas). La dernière ligne fournit une explication sur la cause de l'erreur (celle qui commence par NameError). Dans cet exemple, elle indique que le nom heigth n'est pas défini, c'est-à-dire qu'il ne correspond pas à une variable initialisée.

II-B-1-a-i. Modification de variable▲

data = 12
data = 99
print(data)

99

II-B-1-a-ii. Affectation composée▲

data = data + 1

data += 1

Un programme passe une grande partie de son temps à manipuler des données. On a déjà pu voir plusieurs types de données différents dans les sections précédentes, à savoir des nombres et des mots. Il existe de nombreux types prédéfinis en Python, parmi lesquels les nombres et les chaines de caractères.

II-B-1-b-i. Nombre▲

from cmath import sqrt

a = 1
b = -4
c = 2e2

delta = b ** 2 - 4 * a * c
x1 = (-b + sqrt(delta)) / (2 * a)
x2 = (-b - sqrt(delta)) / (2 * a)

print('Les deux racines sont :')
print(x1)
print(x2)

Les deux racines sont :
(2+14j)
(2-14j)

II-B-1-b-ii. Chaine de caractères▲

address = "Promenade de l'Alma 50"

address = "Promenade de l'Alma 50\n1200 Woluwé-Saint-Lambert"
print(address)

Promenade de l'Alma 50
1200 Woluwé-Saint-Lambert

>>> type(123)
<class 'int'>
>>> type('123')
<class 'str'>

a = 'Hello'
b = " "
c = 'World!'
s = a + b + c

year = 2016
s = 'Nous sommes en ' + year

Traceback (most recent call last):
  File "program.py", line 2, in <module>
    s = 'Nous sommes en ' + year
TypeError: Can't convert 'int' object to str implicitly

Il est possible de convertir explicitement une donnée d'un type vers un autre, en utilisant des fonctions prédéfinies. Les fonctions int, float, complex et str permettent de convertir une donnée vers les types correspondants. Voyons un premier exemple :

a = 12
print(type(a))

b = complex(a)
print(type(b))

La variable a est de type numérique entier. On la convertit ensuite en une donnée de type complexe grâce à la fonction prédéfinie complex, et on stocke le résultat de la conversion dans la variable b. Ceci est confirmé par l'exécution du programme qui affiche :

<class 'int'>
<class 'complex'>

Grâce à ces fonctions de conversion, on peut maintenant corriger l'exemple de la section précédente. Il suffit en effet d'appliquer la fonction str à la variable year avant d'effectuer la concaténation :

year = 2016
s = 'Nous sommes en ' + str(year)

Toutes les conversions ne fonctionnent évidemment pas. Si on tente, par exemple, de convertir une chaine de caractères en un entier, mais qu'elle ne représente pas un nombre entier, on aura une erreur d'exécution :

a = int("Hello")
print(a)

Le message d'erreur obtenu signale que la chaine de caractères 'Hello' n'est pas un entier valable en base 10 :

Traceback (most recent call last):
  File "program.py", line 1, in <module>
    a = int("Hello")
ValueError: invalid literal for int() with base 10: 'Hello'

Au lieu de fournir plusieurs valeurs à la fonction print, on aurait également pu construire la chaine de caractères en utilisant la concaténation. Rappelez-vous néanmoins qu'il faudra convertir toutes les valeurs concaténées en chaines de caractères pour que cela fonctionne. L'exemple précédent peut se réécrire comme suit :

print('Né en ' + str(birthyear) + " j'ai " + str(age) + ' ans.')

En fait, on veut construire une chaine de caractères dans laquelle on incruste, à des endroits précis, les valeurs de variables. Python propose des facilités pour formater une chaine de caractères. Voyons d'abord comment réécrire l'exemple précédent avant de comprendre dans le détail le fonctionnement du formatage d'une chaine de caractères :

print("Né en {} j'ai {} ans".format(birthyear, age))

On commence donc par construire la chaine de caractères, dans laquelle on place des balises représentées par {}. Il s'agit d'endroits dans la chaine de caractères qui seront remplacés par des valeurs. Après la chaine de caractères, on va devoir indiquer les valeurs à incruster à l'aide de format. Le tout produira une chaine de caractères qui sera affichée par print. Notez qu'on peut également construire une chaine de caractères ainsi, sans nécessairement vouloir l'afficher. De plus, on n'est pas limité à l'incrustation de valeurs de variables, mais on peut insérer n'importe quelle expression. On peut donc, par exemple, écrire :

s = "Né en {} j'ai {} ans".format(birthyear, 2016 - birthyear)

La figure 7 résume cette construction d'une chaine de caractères formatée. Il suffit (1) de placer des balises dans une chaine de caractères et (2) de fournir autant d'expressions que nécessaire à format afin de les remplacer par les valeurs de ces expressions.

Alors que la fonction print permet à un programme de produire une sortie, on va pouvoir lire une entrée grâce à la fonction input. Cette fonction, une fois appelée, arrête l'exécution du programme et attend que l'utilisateur saisisse un texte. Ce dernier est ensuite rapatrié et peut, par exemple, être stocké dans une variable. Voici un programme qui vous demande votre nom, puis vous souhaite la bienvenue :

firstname = input('Quel est ton prénom ? ')
print('Bonjour', firstname, 'et bienvenue !')

L'exécution de ce programme pourrait, par exemple, produire le résultat suivant, sachant que le mot « Sébastien » a été saisi par l'utilisateur :

Quel est ton prénom ? Sébastien
Bonjour Sébastien et bienvenue !

La fonction input renvoie toujours le texte saisi par l'utilisateur sous forme d'une chaine de caractères. Il faudra donc éventuellement prévoir une conversion, si vous voulez que l'utilisateur saisisse autre chose, comme un nombre entier, par exemple.

La suite du programme d'exemple demande à l'utilisateur quelle est son année de naissance, puis calcule et affiche son âge :

s = input('Quel est ton année de naissance ? ')

year = 2016
birthyear = int(s)
print('Tu as', year - birthyear, 'ans.')

Par contre, si l'utilisateur ne saisit pas un nombre, une erreur se produira lors de l'exécution comme on peut le voir ci-dessous, où l'utilisateur a saisi le texte « deux-mille » :

Quel est ton année de naissance ? deux-mille
Traceback (most recent call last):
  File "program.py", line 4, in <module>
    birthyear = int(s)
ValueError: invalid literal for int() with base 10: 'deux-mille'

On verra plus loin dans le livre comment gérer ce type d'erreur et pouvoir, par exemple, afficher un message à l'utilisateur.

Les deux fonctions que l'on vient de voir font partie intégrante du langage. On s'intéresse maintenant aux fonctions mathématiques qui sont essentiellement rassemblées dans les modules math et cmath, le deuxième étant spécialisé pour les nombres complexes.

Pour utiliser des fonctions faisant partie d'un module, il faut avant tout les importer. Comme on a déjà pu le voir, on utilise pour cela l'instruction from/import à qui on indique le nom du module après le from et la liste des fonctions à importer après le import.

Voici un exemple qui utilise les fonctions sqrt (racine carrée) et sin (sinus) faisant partie du module math :

from math import sqrt, sin

print('Racine carrée de 2 =', sqrt(2))
print('Sinus de 2 = ', sin(2))

Parfois, il est plus facile d'importer tout le contenu d'un module plutôt que de lister toutes les fonctions dont on a besoin. Pour cela, on utilise un astérisque (*) au lieu de la liste de fonctions. Pour importer toutes les fonctions du module math, il suffit donc d'écrire :

from math import *

De manière générale, on essaie d'éviter autant que possible de brutalement tout importer, afin d'éviter d'éventuels conflits. Prenons pour cela un exemple qui utilise les deux modules math et cmath :

from cmath import *
from math import *

print('Racine carrée de -4 =', sqrt(-4))

Les deux modules contiennent une fonction sqrt. Dès lors, laquelle sera utilisée à la troisième instruction ? Python va simplement prendre celle du dernier module importé, c'est-à-dire celle du module math. Par conséquent, une erreur d'exécution se produira puisqu'il faut la version complexe pour calculer la racine carrée de kitxmlcodeinlinelatexdvp-4finkitxmlcodeinlinelatexdvp :

Traceback (most recent call last):
  File "program.py", line 4, in <module>
    print('Racine carrée de -4 =', sqrt(-4))
ValueError: math domain error

Pour résoudre ce problème, Python permet de juste importer un module avec l'instruction import suivie du nom du module à importer. Ensuite, lorsqu'on voudra utiliser une fonction du module, il faudra faire précéder son nom de celui du module et de l'opérateur d'accès (.) :

import cmath
import math

print('Racine carrée de -4 =', cmath.sqrt(-4))

Il est maintenant explicite que la fonction sqrt appelée est celle provenant du module cmath, et il n'y aura donc plus d'erreurs d'exécution.

Lorsqu'on écrit un programme, il est parfois utile d'y ajouter des informations textuelles à destination des êtres humains. Ce genre d'information est appelé commentaire et on en ajoute dans un code source à l'aide du caractère #. Tout ce qui suit ce caractère, jusque la fin de la ligne, sera ignoré par l'interpréteur Python.

Le but d'un bon commentaire est d'apporter une information additionnelle au code. Il peut s'agir d'informations liées au problème résolu par le programme ou d'informations sur le programme (auteurs, version, etc.). On pourrait par exemple réécrire le programme qui cherche les racines d'un trinôme du second degré comme suit :

# Programme de calcul des racines d'un trinôme du second degré
# de la forme ax^2 + bx + c
# Auteur : Sébastien Combéfis
# Version : 7 aout 2015

from cmath import sqrt

# Coefficients du trinôme
a = 1
b = -4
c = 2e2

# Calcul du discriminant
delta = b ** 2 - 4 * a * c

# Calcul des deux racines
x1 = (-b + sqrt(delta)) / (2 * a)
x2 = (-b - sqrt(delta)) / (2 * a)

print('Les deux racines sont :', x1, 'et', x2)

Lorsqu'on utilise un langage de programmation, il est très important de suivre les conventions et constructions spécifiques du langage. Cela permet de facilement partager du code avec la communauté, et également de facilement comprendre du code écrit par d'autres.

En un mot, vous devez apprendre à écrire avec un style pythonique. On peut trouver de nombreuses références à ce propos sur Internet, le point de départ étant le PEP 0008 — Style Guide for Python code (document officiel) écrit par Guido van Rossum.

Voici les règles du PEP 0008 que l'on peut déjà comprendre :

• la longueur des lignes de code ne devrait pas excéder 79 caractères ;
• on peut utiliser des lignes vides pour séparer des blocs logiques de code, mais avec parcimonie ;
• les fichiers .py devraient être enregistrés en UTF-8 ;
• il faudrait utiliser une instruction import par module ;

• concernant les espaces :

  • on évite de placer des espaces après une parenthèse ouvrante, avant une parenthèse fermante, avant la parenthèse ouvrante d'un appel de fonction ;
  • il faut insérer une espace avant et après l'opérateur d'affectation, et également autour des opérateurs arithmétiques, sauf éventuellement pour faire ressortir les priorités des opérateurs (on écrit par exemple x*x + y*y) ;
  • on ne met pas d'espaces autour du = des paramètres nommés lors d'un appel de fonction ;
• les commentaires devraient être des phrases complètes, commençant donc par une majuscule et finissant par un point, et suivre Strunk and White (Strunk, W., Jr.; White, E.B. (1999). The Elements of Style. Longman. ISBN 978-0-205-30902-3) lorsqu'ils sont en anglais ;
• il faut éviter les lettres l (L minuscule), O (O majuscule) et I (i majuscule) pour nommer ses variables.