Apprendre Python et s'initier à la programmation

Partie 1 : Bases de la programmation


précédentsommairesuivant

II. Le langage Python

Pour pouvoir écrire des programmes, il faut d'abord choisir un langage de programmation qui permette de décrire les différentes opérations que le programme développé doit effectuer. Il existe des centaines de langages de programmation différents, chacun ayant ses spécificités propres. Ce cours a choisi Python, un langage récent et moderne utilisable pour coder une grande variété de programmes différents. Ce chapitre présente ce langage et introduit les concepts de base nécessaires à l'écriture d'un premier programme simple.

II-A. Python

Le langage de programmation Python a été créé par Guido van Rossum en 1990 et est rendu disponible sous licence libre. Son développement est aujourd'hui assuré par la Python Software Foundation, fondée en 2001. Il s'agit d'un langage interprété fonctionnant sur la plupart des plateformes informatiques (notamment Linux, Windows et macOS). Il est également très apprécié des pédagogues qui le considèrent comme étant un bon langage pour s'initier aux concepts de base de la programmation.

La figure 1 montre le logo de Python à gauche de son créateur, Guido van Rossum. En 1999, ce dernier a soumis un projet auprès de la DARPA (Defense Advanced Research Projects Agency), une agence du département de la Défense des États-Unis chargée du développement des nouvelles technologies destinées à un usage militaire. Dans sa proposition, appelée « Computer Programming for Everybody » (document original), il définit les buts suivants pour Python :

  • le langage doit être simple et intuitif, et aussi puissant que les principaux concurrents ;
  • il doit être open source, afin que quiconque puisse contribuer à son développement ;
  • le code doit être aussi compréhensible qu'un texte en anglais ;
  • il doit être adapté aux tâches quotidiennes, et permettre des courts délais de développement.
Image non disponible
Figure 1. Le langage Python a été créé par Guido van Rossum en 1990, programmeur néerlandais qui a travaillé pour Google pendant sept ans. Il travaille maintenant pour Dropbox depuis janvier 2013.

Depuis sa création, le succès du langage n'a cessé de croitre, jusqu'à le porter parmi les dix langages de programmation les plus populaires. Il s'agit d'un langage de haut niveau, à usage général. Les dernières versions stables du langage sont la 2.7.12 (25 juin 2016) et la 3.5.2 (27 juin 2016). Ces deux versions, communément appelées Python 2 et Python 3, continuent toutes les deux d'exister, essentiellement pour des raisons de compatibilité. Dans ce cours, nous utiliserons la version 3.

Python est utilisé dans de nombreux projets, de types différents. Il est notamment utilisé comme langage de script pour des applications web. Il est également très présent dans des applications de calculs scientifiques, et est intégré dans de nombreux logiciels de modélisation, comme langage de script. Enfin, il est aussi utilisé dans le développement de jeux vidéo ou dans l'écriture de tâches dans le domaine de l'intelligence artificielle.

II-A-1. Hello World!

Une fois n'est pas coutume, lorsqu'il s'agit de présenter la syntaxe d'un langage de programmation, on utilise comme exemple le programme Hello World. Il s'agit simplement d'un programme qui affiche les deux mots « Hello World » à l'écran, avant de se terminer.

Voici ce que cela donne en Python :

 
Sélectionnez
1.
print('Hello World!')

Quoi de plus simple ? Python inclut une fonction prédéfinie print qui affiche à l'écran la séquence de caractères qu'on lui fournit. Cette unique ligne de code constitue notre premier programme Python.

II-A-1-a. Mode interactif et mode script

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 :

 
Sélectionnez
1.
2.
>>> print('Hello World!')
Hello World!
Image non disponible
Figure 2. Dans le mode interactif, les instructions sont exécutées une à une par l'interpréteur Python, au fur et à mesure que vous les encodez.

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.

II-A-1-b. Calculatrice Python

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 :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
>>> 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.

Figure 3. Python propose sept opérateurs arithmétiques que l'on peut utiliser pour construire des expressions mathématiques.

Description

Notation

Addition

+

Soustraction

-

Multiplication

*

Division

/

Exponentiation

**

Division entière

//

Reste de la division entière

%

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

Les opérateurs arithmétiques possèdent chacun une priorité qui définit dans quel ordre les opérations sont effectuées. Par exemple, lorsqu'on écrit 1 + 2 * 3, la multiplication va se faire avant l'addition. Le calcul qui sera effectué est donc 1 + (2 * 3). Dans l'ordre, l'opérateur d'exponentiation est le premier exécuté, viennent ensuite les opérateurs *, /, // et %, et enfin les opérateurs + et -.

Lorsqu'une expression contient plusieurs opérations de même priorité, ils sont évalués de gauche à droite. Ainsi, lorsqu'on écrit 1 - 2 - 3, le calcul qui sera effectué est (1 - 2) - 3. En cas de doutes, vous pouvez toujours utiliser des parenthèses pour rendre explicite l'ordre d'évaluation de vos expressions arithmétiques.

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

Deux opérations arithmétiques sont exclusivement utilisées pour effectuer des calculs en nombres entiers : la division entière (//) et le reste de la division entière (%). Lorsqu'on divise un nombre entier kitxmlcodeinlinelatexdvpDfinkitxmlcodeinlinelatexdvp (appelé dividende) par un autre nombre entier kitxmlcodeinlinelatexdvpdfinkitxmlcodeinlinelatexdvp (appelé diviseur), on obtient deux résultats : un quotient kitxmlcodeinlinelatexdvpqfinkitxmlcodeinlinelatexdvp et un reste kitxmlcodeinlinelatexdvprfinkitxmlcodeinlinelatexdvp, tels que :

kitxmlcodelatexdvpD = q \times d + r \qquad (\textrm{avec } r < d).finkitxmlcodelatexdvp

La valeur kitxmlcodeinlinelatexdvpqfinkitxmlcodeinlinelatexdvp est le résultat de la division entière et la valeur kitxmlcodeinlinelatexdvprfinkitxmlcodeinlinelatexdvp celui du reste de cette division. Par exemple, si on divise kitxmlcodeinlinelatexdvp17finkitxmlcodeinlinelatexdvp par kitxmlcodeinlinelatexdvp5finkitxmlcodeinlinelatexdvp, on obtient un quotient de kitxmlcodeinlinelatexdvp3finkitxmlcodeinlinelatexdvp et un reste de kitxmlcodeinlinelatexdvp2finkitxmlcodeinlinelatexdvp puisque kitxmlcodeinlinelatexdvp17 = 3 \times 5 + 2finkitxmlcodeinlinelatexdvp.

Ces deux opérateurs sont très utilisés dans plusieurs situations précises. Par exemple, pour déterminer si un nombre entier est pair ou impair, il suffit de regarder le reste de la division entière par deux. Le nombre est pair s'il est nul et est impair s'il vaut kitxmlcodeinlinelatexdvp1finkitxmlcodeinlinelatexdvp. Une autre situation où ces opérateurs sont utiles concerne les calculs de temps. Si on a un nombre de secondes et qu'on souhaite le décomposer en minutes et secondes, il suffit de faire la division par kitxmlcodeinlinelatexdvp60finkitxmlcodeinlinelatexdvp. Le quotient sera le nombre de minutes et le reste le nombre de secondes restant. Par exemple, kitxmlcodeinlinelatexdvp175finkitxmlcodeinlinelatexdvp secondes correspond à 175 // 60kitxmlcodeinlinelatexdvp= 2finkitxmlcodeinlinelatexdvp minutes et 175 % 60kitxmlcodeinlinelatexdvp= 55finkitxmlcodeinlinelatexdvp secondes.

II-B. Variable et type de donnée

On souhaite parfois conserver en mémoire le résultat de l'évaluation d'une expression arithmétique en vue de l'utiliser plus tard, dans un autre calcul, par exemple. Si on reprend l'exemple de la recherche des racines du trinôme kitxmlcodeinlinelatexdvpax^2 + bx + cfinkitxmlcodeinlinelatexdvp, on doit mémoriser la valeur du discriminant pour pouvoir calculer les valeurs des deux racines réelles distinctes, lorsqu'il est strictement positif.

II-B-1. Variable

Une variable peut être vue comme une boite (virtuelle) représentant un emplacement en mémoire qui permet de stocker une valeur, et à qui on a donné un nom afin de facilement l'identifier. La figure 4 illustre ce concept en montrant une variable dont le nom est data et dont la valeur est le nombre entier kitxmlcodeinlinelatexdvp42finkitxmlcodeinlinelatexdvp.

Image non disponible
Figure 4. Une variable est une boite virtuelle, représentant un emplacement mémoire, qui possède un nom et une valeur.

Voyons maintenant un exemple de programme qui utilise plusieurs variables pour calculer le discriminant du trinôme kitxmlcodeinlinelatexdvpx^2 + 2x - 4finkitxmlcodeinlinelatexdvp :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
a = 1
b = 2
c = -4

delta = b ** 2 - 4 * a * c
print('Le discriminant est :')
print(delta)

Les trois premières instructions stockent les coefficients du trinôme, à savoir kitxmlcodeinlinelatexdvp1finkitxmlcodeinlinelatexdvp, kitxmlcodeinlinelatexdvp2finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp-4finkitxmlcodeinlinelatexdvp, respectivement dans des variables nommées a, b et c. La quatrième instruction effectue le calcul du discriminant (kitxmlcodeinlinelatexdvpb^2 - 4acfinkitxmlcodeinlinelatexdvp) et stocke le résultat dans la variable delta. Enfin, les deux dernières instructions affichent à l'écran la phrase « Le discriminant est : », suivie de la valeur de la variable delta.

L'utilisation d'une variable est donc assez immédiate. Deux types d'accès peuvent être réalisés :

  • Pour affecter une valeur à une variable, c'est-à-dire l'initialiser ou modifier sa valeur, on utilise l'opérateur d'affectation (=). À gauche de l'opérateur, on retrouve le nom de la variable et à droite la valeur qu'on souhaite lui affecter.
  • Pour accéder au contenu d'une variable, il suffit d'utiliser son nom. Cet accès peut, par exemple, se faire dans une expression mathématique, ou avec la fonction print.

Le symbole = est à distinguer du signe égal utilisé en mathématiques pour énoncer une égalité. En Python, il permet d'affecter une valeur à une variable. Voyons cela avec l'exemple suivant :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
a = 1
b = a
print(a)
print(b)

a = 15
print(a)
print(b)

En mathématiques, écrire kitxmlcodeinlinelatexdvpb = afinkitxmlcodeinlinelatexdvp signifie que kitxmlcodeinlinelatexdvpafinkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvpbfinkitxmlcodeinlinelatexdvp représentent la même valeur. Dès lors, lorsqu'on écrit plus loin a = 15, on pourrait s'attendre à ce que kitxmlcodeinlinelatexdvpafinkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvpbfinkitxmlcodeinlinelatexdvp valent kitxmlcodeinlinelatexdvp15finkitxmlcodeinlinelatexdvp. En Python, b = a signifie qu'on affecte la valeur de a à la variable b (on fait une copie de la valeur). Après exécution de cette instruction, aucun lien n'est établi entre les deux variables. L'exécution du programme affiche lors de son exécution :

 
Sélectionnez
1
1
15
1

La figure 5 illustre ce qui se passe en mémoire. Elle montre l'état de cette dernière respectivement juste après l'exécution des instructions a = 1, b = a et a = 15. On voit très bien qu'aucun lien n'a été établi entre les variables a et b et que la dernière modification de a n'a aucun impact sur la valeur de b.

Image non disponible
Figure 5. L'opérateur d'affectation permet d'affecter une valeur à une variable. Elle n'établit aucun lien entre deux variables comme on peut le voir avec l'état de la mémoire respectivement après exécution des instructions a = 1, b = a et a = 15.

II-B-1-a. Initialisation de variable

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 :

 
Sélectionnez
1.
2.
3.
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 :

 
Sélectionnez
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

Une fois une variable initialisée, on peut donc modifier sa valeur en utilisant de nouveau l'opérateur d'affectation (=). La valeur actuelle de la variable est remplacée par la nouvelle valeur qu'on lui affecte. Dans l'exemple suivant, on initialise une variable à la valeur kitxmlcodeinlinelatexdvp12finkitxmlcodeinlinelatexdvp et on remplace ensuite sa valeur par kitxmlcodeinlinelatexdvp99finkitxmlcodeinlinelatexdvp :

 
Sélectionnez
1.
2.
3.
data = 12
data = 99
print(data)

On voit bien sûr le résultat de l'exécution que la valeur de la variable data a été remplacée par kitxmlcodeinlinelatexdvp99finkitxmlcodeinlinelatexdvp et qu'il n'y a plus aucune trace du kitxmlcodeinlinelatexdvp12finkitxmlcodeinlinelatexdvp :

 
Sélectionnez
99
II-B-1-a-ii. Affectation composée

Ce que l'on doit parfois faire, c'est mettre à jour une variable par rapport à la valeur qu'elle possède actuellement. Par exemple, si on veut augmenter la valeur d'une variable data de kitxmlcodeinlinelatexdvp1finkitxmlcodeinlinelatexdvp, on doit écrire :

 
Sélectionnez
1.
data = data + 1

La nouvelle valeur à affecter à la variable data est sa valeur actuelle à qui on ajoute kitxmlcodeinlinelatexdvp1finkitxmlcodeinlinelatexdvp. Dans cette instruction, le nom de la variable est répété deux fois. En programmation, une règle de bonne pratique consiste à éviter au maximum la duplication de code. Pour simplifier cette instruction, Python propose l'opérateur += qui fait l'addition suivie de l'affectation en une fois. L'exemple précédent se réécrit donc comme suit :

 
Sélectionnez
1.
data += 1

Un tel opérateur permet de réaliser une affectation composée, c'est-à-dire une opération directement suivie d'une affectation. On peut notamment l'utiliser avec les sept opérateurs arithmétiques que l'on vient de voir.

II-B-1-b. Type de donnée

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

Il y a trois types numériques en Python :

  • Le type entier (int) permet de représenter n'importe quel nombre entier, peu importe sa taille.
  • Le type flottant (float) permet de représenter des nombres comportant une partie décimale, compris entre kitxmlcodeinlinelatexdvp10^{-308}finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp10^{308}finkitxmlcodeinlinelatexdvp. La valeur spéciale math.inf représente l'infini.
  • Le type complexe (complex) permet de représenter des nombres complexes, où le nombre imaginaire se note j.

Il y a deux manières d'introduire de telles données dans un programme. On peut directement écrire le nombre, qu'on appellera littéral entier. On obtient également des données numériques à partir d'expressions mathématiques et de fonctions prédéfinies. Deux points d'attention sont à soulever concernant l'écriture littérale de nombres :

  • On utilise le point comme séparateur décimal lorsqu'on doit écrire des nombres à virgule.
  • On colle directement la partie imaginaire d'un nombre complexe au j sans utiliser un *. En effet, 2j représente le nombre complexe kitxmlcodeinlinelatexdvp2ifinkitxmlcodeinlinelatexdvp tandis que 2 * j représente le produit de kitxmlcodeinlinelatexdvp2finkitxmlcodeinlinelatexdvp par la variable j.

Comme le montre l'exemple suivant, les flottants peuvent être écrits en notation scientifique. Il s'agit d'un programme qui calcule les deux racines complexes d'un trinôme du second degré :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
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)

La première instruction importe la fonction prédéfinie sqrt depuis le module cmath, afin de calculer la racine carrée d'un nombre complexe. On initialise ensuite trois variables a, b et c avec des données numériques décrites par un littéral (kitxmlcodeinlinelatexdvp1finkitxmlcodeinlinelatexdvp, kitxmlcodeinlinelatexdvp-4finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp2\cdot10^2finkitxmlcodeinlinelatexdvp). La cinquième instruction calcule le discriminant qui sera un nombre flottant (kitxmlcodeinlinelatexdvp\Delta = b^2 - 4acfinkitxmlcodeinlinelatexdvp).

Les deux instructions suivantes calculent les racines du trinôme, en faisant notamment appel à la fonction sqrt pour calculer kitxmlcodeinlinelatexdvpx_{1,2} = (-b \pm \sqrt{\Delta}) / 2afinkitxmlcodeinlinelatexdvp. Les variables x1 et x2 vont donc contenir des données de type complexe. Comme on peut le voir sur ce qu'affiche l'exécution du programme, c'est bien le cas :

 
Sélectionnez
Les deux racines sont :
(2+14j)
(2-14j)
II-B-1-b-ii. Chaine de caractères

Une chaine de caractères (str) est une séquence de caractères, délimitée par des guillemets dans sa forme littérale (simple ' ou double "). On peut généralement utiliser indifféremment l'un ou l'autre type de guillemets.

Tous les caractères, à quelques exceptions près, sont acceptés pour définir une chaine de caractères. Tout d'abord, il est évident que si vous souhaitez utiliser le caractère ", vous ne pourrez pas l'utiliser pour délimiter la chaine de caractères, mais vous devrez utiliser ', et inversement.

Dans l'exemple suivant, on est obligé d'utiliser des guillemets doubles pour délimiter la chaine de caractères :

 
Sélectionnez
1.
address = "Promenade de l'Alma 50"

Si on veut créer des chaines de caractères contenant à la fois ' et ", il faut utiliser une séquence d'échappement. Une telle séquence commence par un backslash (\) suivi d'un ou plusieurs caractères. Elle permet de représenter un caractère spécial. Par exemple, la séquence \" représente le caractère " et la séquence \n représente un saut de ligne. On peut par exemple écrire :

 
Sélectionnez
1.
2.
address = "Promenade de l'Alma 50\n1200 Woluwé-Saint-Lambert"
print(address)

L'exécution de ce programme affiche deux lignes de texte à l'écran, la séquence d'échappement \n ayant été remplacée par un saut de ligne :

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

La figure 6 ci-dessous reprend les principales séquences d'échappement que propose Python.

Figure 6. Les séquences d'échappement permettent d'insérer des caractères spéciaux dans une chaine de caractères.

Séquence

Description

\\

Backslash

\'

Guillemet simple (apostrophe)

\"

Guillemet double

\n

Saut de ligne

\r

Retour chariot

\t

Tabulation horizontale

Il faut faire bien attention à distinguer les deux littéraux 123 et '123'. Alors que le premier est de type numérique et représente le nombre entier kitxmlcodeinlinelatexdvp123finkitxmlcodeinlinelatexdvp, le second est une chaine de caractères constituée des trois caractères 1, 2 et 3, placés l'un après l'autre.

On peut s'en rendre compte grâce à la fonction prédéfinie type qui permet d'obtenir le type d'une expression. On voit, sur l'exemple suivant, les mentions <class 'int'> et <class 'str'> qui indiquent respectivement le type numérique entier et le type chaine de caractères :

 
Sélectionnez
1.
2.
3.
4.
>>> type(123)
<class 'int'>
>>> type('123')
<class 'str'>

On peut connaitre la longueur d'une chaine de caractères (c'est-à-dire le nombre de caractères qui la composent) en utilisant la fonction prédéfinie len. Enfin, on peut joindre deux chaines de caractères l'une derrière l'autre avec l'opérateur de concaténation (+). Dans l'exemple suivant, la variable s contiendra Hello World! après exécution :

 
Sélectionnez
1.
2.
3.
4.
a = 'Hello'
b = " "
c = 'World!'
s = a + b + c

Attention, cet opérateur ne fonctionne qu'entre deux données de type chaine de caractères. Si vous tentez de l'utiliser avec un autre type, l'interpréteur Python produira une erreur d'exécution.

Le programme suivant initialise une variable de type entier contenant l'année actuelle et définit ensuite une variable s à laquelle on tente d'affecter la concaténation de la chaine de caractères 'Nous sommes en ' avec la variable de type entier year :

 
Sélectionnez
1.
2.
year = 2016
s = 'Nous sommes en ' + year

L'interpréteur Python va générer une erreur d'exécution qui signale qu'il ne parvient pas à convertir implicitement la donnée de type int en une donnée de type str :

 
Sélectionnez
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

II-B-1-c. Conversion

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 :

 
Sélectionnez
1.
2.
3.
4.
5.
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 :

 
Sélectionnez
<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 :

 
Sélectionnez
1.
2.
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 :

 
Sélectionnez
1.
2.
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 :

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

II-C. Fonction prédéfinie

On a déjà pu rencontrer des fonctions prédéfinies à plusieurs reprises. Ces fonctions proviennent de deux sources différentes ; ce sont :

  • soit des fonctions faisant partie intégrante du langage Python comme print, len et str, par exemple ;
  • soit des fonctions ayant été écrites par d'autres programmeurs et mises à disposition en important le module qui les contient, comme la fonction sqrt du module cmath, par exemple.

II-C-1. Fonction print

La fonction print permet d'afficher une donnée, peu importe son type. En réalité, la fonction affiche une représentation de la donnée sous forme d'une chaine de caractères. En plus, elle ajoute automatiquement un retour à la ligne, ainsi, deux appels successifs à la fonction print résulteront en l'affichage de deux lignes.

La forme générale de la fonction print permet d'afficher un nombre quelconque de valeurs, que l'on doit séparer par des virgules. Par défaut, les différentes valeurs seront séparées par une espace (lorsqu'il désigne le caractère d'espacement blanc, le nom espace est féminin).

L'exemple suivant affiche la phrase « Né en 1961 j'ai 55 ans. » :

 
Sélectionnez
1.
2.
3.
4.
5.
year = 2016
birthyear = 1961
age = year - birthyear

print(' en', birthyear, "j'ai", age, 'ans.')

Remarquez l'alternance entre guillemets simples et doubles pour délimiter les chaines de caractères, contrainte par le fait que la deuxième chaine de caractères contient un guillemet simple. On aurait également pu utiliser des guillemets doubles partout, évidemment.

Par défaut, la fonction print ajoute donc un retour à la ligne après ce qu'elle doit afficher, et elle sépare les différentes valeurs à afficher avec une espace. On peut changer cette configuration par défaut à l'aide des paramètres nommésend et sep. Avec ces derniers, on peut spécifier les chaines de caractères à afficher respectivement après le contenu et entre les valeurs.

L'exemple suivant modifie ces deux valeurs par défaut :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
day = 4
month = 8
year = 1961

print(' le :', end=' ')
print(day, month, year, sep='/')

Le premier appel à la fonction print va donc afficher la chaine de caractères « Né le : » et terminera par une espace, au lieu d'un retour à la ligne. Le second appel affichera la valeur des trois variables, mais en les séparant par le caractère / au lieu d'une espace :

 
Sélectionnez
Né le : 4/8/1961

On peut évidemment spécifier les deux paramètres nommés end et sep dans le même appel à la fonction print.

II-C-1-a. Sortie formatée

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 :

 
Sélectionnez
1.
print(' 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 :

 
Sélectionnez
1.
print(" 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électionnez
1.
s = " 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.

Image non disponible
Figure 7. On peut construire une chaine de caractères en y incrustant des valeurs à la place de balises en utilisant format.

II-C-1-b. Fonction input

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 :

 
Sélectionnez
1.
2.
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 :

 
Sélectionnez
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électionnez
1.
2.
3.
4.
5.
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 » :

 
Sélectionnez
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.

II-C-1-c. Importation de fonction

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 :

 
Sélectionnez
1.
2.
3.
4.
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 :

 
Sélectionnez
1.
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 :

 
Sélectionnez
1.
2.
3.
4.
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 :

 
Sélectionnez
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 (.) :

 
Sélectionnez
1.
2.
3.
4.
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.

II-D. Code source

Maintenant que l'on a pu découvrir nos premiers programmes écrits en Python, il est temps de prendre un peu de recul en analysant la rédaction d'un code source. En effet, tout comme on n'écrit pas n'importe comment un texte en français, il y a des règles de bonne pratique pour rédiger un code source correct et de qualité.

II-D-1. Règle de nommage des variables

On a vu qu'il fallait choisir un nom pour toute variable, et il y a des règles concernant les noms valides. Tout d'abord, on ne peut pas utiliser certains mots appelés mots réservés. Il s'agit de mots qui ont une signification particulière en Python, repris à la figure 8.

Image non disponible
Figure 8. Il y a en tout 33 mots réservés qui ont une signification particulière en Python et qui ne peuvent donc pas être utilisés comme nom de variable.

Ensuite, le premier caractère doit être une lettre minuscule (a-z), une lettre majuscule (A-Z) ou un tiret de soulignement (_). Pour les autres caractères, on autorise en plus les chiffres (0-9). On peut définir des noms aussi longs que l'on veut (même si c'est recommandé de rester concis), et Python est sensible à la casse, c'est-à-dire qu'il fait la différence entre minuscules et majuscules. Comme le montre la figure 9, on peut également utiliser une série de caractères Unicode depuis Python 3.

Image non disponible
Figure 9. Depuis Python 3, on peut également utiliser des caractères Unicode dans les noms de variable, comme des idéogrammes chinois, par exemple.

II-D-1-a. Commentaire

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 :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
# 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)

II-D-1-b. Style

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.

précédentsommairesuivant

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Copyright © 2018 UKO. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.