Accueil Forum Emploi

D e v e l op pe z .co m ! Rubriques "

Python

Apprendre Python et s'initier à la programmation

Partie 1 : Bases de la programmation

Table des matières

II. Le langage Python
II-A. Python
II-A-1. Hello World!
II-A-1-a. Mode interactif et mode script
II-A-1-b. Calculatrice Python
II-A-1-b-i. Priorité
II-A-1-b-ii. Division entière et son reste
II-B. Variable et type de donnée
II-B-1. Variable
II-B-1-a. Initialisation de variable
II-B-1-a-i. Modification de variable
II-B-1-a-ii. Affectation composée
II-B-1-b. Type de donnée
II-B-1-b-i. Nombre
II-B-1-b-ii. Chaine de caractères
II-B-1-c. Conversion
II-C. Fonction prédéfinie
II-C-1. Fonction print
II-C-1-a. Sortie formatée
II-C-1-b. Fonction input
II-C-1-c. Importation de fonction
II-D. Code source
II-D-1. Règle de nommage des variables
II-D-1-a. Commentaire
II-D-1-b. Style

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 moder ne 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, W indows 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 der nier 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.
:
 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 der niè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 four nit. 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 der niè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!

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 der niè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.

Description Notation

Addition +

Soustraction -

Multiplication *

Division /

Exponentiation **

Division entière //

Reste de la division entière %

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

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
D (appelé dividende) par un autre nombre entier
d (appelé diviseur), on obtient deux résultats : un quotient
q et un reste
r , tels que :
D = q×d+r (avec r < d).
:
 D = q×d+r (avec r < d).

La valeur
q est le résultat de la division entière et la valeur
r celui du reste de cette division. Par exemple, si on divise
17 par
5 , on obtient un quotient de
3 et un reste de
2 puisque
17 = 3 × 5 + 2.

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
1 . Une autre situation où ces opérateurs sont utiles concer ne 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
60. Le quotient sera le nombre de minutes et le reste le nombre de secondes restant. Par exemple,
175 secondes correspond à 175 // 60
= 2 minutes et 175 % 60
= 55 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 ax2 + bx + c , 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
42.

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 x2 + 2x − 4 :

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
1,
2 et
−4 , respectivement dans des variables nommées a, b et c. La quatrième instruction effectue le calcul du discriminant (
b2 − 4ac ) et stocke le résultat dans la variable delta. Enfin, les deux der niè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
b = a signifie que
a et
b représentent la même valeur. Dès lors, lorsqu'on écrit plus loin a = 15 , on pourrait s'attendre à ce que
a et
b valent
15. 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 der niè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 der nière modification de a n'a aucun impact sur la valeur de
b.

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
Connexion Inscription Contacts
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-der nière ligne reprend l'instruction qui a causé l'erreur d'exécution (à savoir print( heigth) dans notre cas). La der nière ligne four nit 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
12 et on remplace ensuite sa valeur par
99 :

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
99 et qu'il n'y a plus aucune trace du
12 :

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 1 , on doit écrire :

Sélectionnez
1.
data = data + 1
La nouvelle valeur à affecter à la variable data est sa valeur actuelle à qui on ajoute 1 . 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
10−308 et
10308 . 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
concer nant 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, 2 j représente le nombre complexe
2i tandis que 2 * j représente le produit de
2 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 (
1,
−4 et
2 ⋅ 102 ). La cinquième instruction calcule le discriminant qui sera un nombre flottant (
∆ = b2 − 4ac ).
−−
Les deux instructions suivantes calculent les racines du trinôme, en faisant notamment appel à la fonction sqrt pour calculer x1,2 = (−b ± √∆ )/2a . 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.

Séquence Description

\\ Backslash

\' Guillemet simple (apostrophe)

\" Guillemet double

:
 \n Saut de ligne

\r Retour chariot

\t Tabulation horizontale

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

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 123, 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('Né en', birthyear, "j'ai", age, 'ans.')

Remarquez l'alter nance 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 der niers, 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('Né 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 four nir 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('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 :

Sélectionnez
1.
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électionnez
1.
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
four nir autant d'expressions que nécessaire à format afin de les remplacer par les valeurs de ces expressions.

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 der nier 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
der nier 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 −4 :

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 concer nant 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.

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.

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 Inter net, 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 ;
concer nant 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.

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.
:
 © 2000-2021 - www.developpez.com
Partenaire : Hébergement Web
: