Débuter avec Python

La programmation est donc l’art de commander à un ordinateur de faire exactement ce que vous voulez, et Python compte parmi les langages qu’il est capable de comprendre pour recevoir vos ordres.

Calculer avec Python

Python présente la particularité de pouvoir être utilisé de plusieurs manières différentes. Vous allez d’abord l’utiliser en mode interactif, c’est-à-dire de manière à dialoguer avec lui directement depuis le clavier. Cela vous permettra de découvrir très vite un grand nombre de fonctionnalités du langage. Dans un second temps, vous apprendrez comment créer vos premiers programmes (scripts) et les sauvegarder sur disque.

Avec IDLE sous Windows, votre environnement de travail ressemblera à celui-ci :

Avec PyScripter, il ressemblera à celui-ci:

Si on tape l'instruction dans l'interpréteur, on a directement le résultat. Si on tape la commande dans l'éditeur, on lance le programme avec la flèche verte, et on voit le résultat dans l'interpréteur.

Les trois caractères « supérieur à » constituent le signal d’invite, ou prompt principal, lequel vous indique que Python est prêt à exécuter une commande.

Par exemple, vous pouvez tout de suite utiliser l’interpréteur comme une simple calculatrice de bureau. Veuillez donc vous-même tester les commandes ci-dessous:

>>> 5+3

>>> 2 – 9          # les espaces sont optionnels

>>> 7 + 3 * 4      # la hiérarchie des opérations mathématiques

                   # est-elle respectée ?

>>> (7+3)*4

>>> 20 / 3         # attention : ceci fonctionnerait différemment sous Python 2

>>> 20 // 3

Comme vous pouvez le constater, les opérateurs arithmétiques pour l’addition, la soustraction, la multiplication et la division sont respectivement +, -, * et /. Les parenthèses ont la fonction attendue.

Sous Python 3, l’opérateur de division / effectue une division réelle. Si vous souhaitez obtenir une division entière (c’est-à-dire dont le résultat – tronqué – ne peut être qu’un entier), vous devez utiliser l’opérateur //.

>>> 20.5 / 3

>>> 8,7 / 5          # Erreur !

Veuillez remarquer au passage une règle qui vaut dans tous les langages de programmation : les conventions mathématiques de base sont celles qui sont en vigueur dans les pays anglophones. Le séparateur décimal y est donc toujours un point, et non une virgule comme chez nous. Notez aussi que dans le monde de l’informatique, les nombres réels sont souvent désignés comme des nombres « à virgule flottante » (floating point numbers).

Données et variables

L’essentiel du travail effectué par un programme d’ordinateur consiste à manipuler des données. Ces données peuvent être très diverses (tout ce qui est numérisable, en fait), mais dans la mémoire de l’ordinateur elles se ramènent toujours en définitive à une suite finie de nombres binaires.

Pour pouvoir accéder aux données, le programme d’ordinateur fait abondamment usage d’un grand nombre de variables de différents types.

Une variable apparaît dans un langage de programmation sous un nom de variable à peu près quelconque (voir ci-après), mais pour l’ordinateur il s’agit d’une référence désignant une adresse mémoire, c’est-à-dire un emplacement précis dans la mémoire vive.

À cet emplacement est stockée une valeur bien déterminée. C’est la donnée proprement dite, qui est donc stockée sous la forme d’une suite de nombres binaires, mais qui n’est pas nécessairement un nombre aux yeux du langage de programmation utilisé. Cela peut être en fait à peu près n’importe quel « objet » susceptible d’être placé dans la mémoire d’un ordinateur, par exemple : un nombre entier, un nombre réel, un nombre complexe, un vecteur, une chaîne de caractères typographiques, un tableau, une fonction, etc.

Pour distinguer les uns des autres ces divers contenus possibles, le langage de programmation fait usage de différents types de variables (le type entier, le type réel, le type chaîne de caractères, le type liste, etc.). Nous allons expliquer tout cela dans les pages suivantes.

Noms de variables et mots réservés

Les noms de variables sont des noms que vous choisissez vous-même assez librement. Efforcez-vous cependant de bien les choisir : de préférence assez courts, mais aussi explicites que possible, de manière à exprimer clairement ce que la variable est censée contenir. Par exemple, des noms de variables tels que altitude, altit ou alt conviennent mieux que x pour exprimer une altitude.

Un bon programmeur doit veiller à ce que ses lignes d’instructions soient faciles à lire.

Sous Python, les noms de variables doivent en outre obéir à quelques règles simples :

* Un nom de variable est une séquence de lettres (a → z , A → Z) et de chiffres (0 → 9), qui doit toujours commencer par une lettre.

* Seules les lettres ordinaires sont autorisées. Les lettres accentuées, les cédilles, les espaces, les caractères spéciaux tels que $, #, @, etc. sont interdits, à l’exception du caractère _ (souligné).

* La casse est significative (les caractères majuscules et minuscules sont distingués).

Attention : Joseph, joseph, JOSEPH sont donc des variables différentes. Soyez attentifs !

Prenez l’habitude d’écrire l’essentiel des noms de variables en caractères minuscules (y compris la première lettre). Il s’agit d’une simple convention, mais elle est largement respectée. N’utilisez les majuscules qu’à l’intérieur même du nom, pour en augmenter éventuellement la lisibilité, comme dans tableDesMatieres.

En plus de ces règles, il faut encore ajouter que vous ne pouvez pas utiliser comme nom de variables les 33 « mots réservés » ci-dessous (ils sont utilisés par le langage lui-même) :

Affectation (ou assignation)

Les termes « affecter une valeur » ou « assigner une valeur » à une variable sont équivalents. Ils désignent l’opération par laquelle on établit un lien entre le nom de la variable et sa valeur (son contenu).

En Python comme dans de nombreux autres langages, l’opération d’affectation est représentée par le signe égal :

>>> n = 7                     # définir la variable n et lui donner la valeur 7

>>> msg = "Quoi de neuf ?"    # affecter la valeur "Quoi de neuf ?" à msg

>>> pi = 3.14159              # assigner sa valeur à la variable pi

Les exemples ci-dessus illustrent des instructions d’affectation Python tout à fait classiques. Après qu’on les ait exécutées, il existe dans la mémoire de l’ordinateur, à des endroits différents :

* trois noms de variables, à savoir n, msg et pi ;

* trois séquences d’octets, où sont encodées le nombre entier 7, la chaîne de caractères Quoi de neuf ? et le nombre réel 3,14159.

Les trois instructions d’affectation ci-dessus ont eu pour effet chacune de réaliser plusieurs opérations dans la mémoire de l’ordinateur :

* créer et mémoriser un nom de variable ;

* lui attribuer un type bien déterminé (ce point sera explicité à la page suivante) ;

* créer et mémoriser une valeur particulière ;

* établir un lien (par un système interne de pointeurs) entre le nom de la variable et l’emplacement mémoire de la valeur correspondante.

Les trois noms de variables sont des références, mémorisées dans une zone particulière de la mémoire que l’on appelle espace de noms, alors que les valeurs correspondantes sont situées ailleurs, dans des emplacements parfois fort éloignés les uns des autres.

Afficher la valeur d’une variable

À la suite de l’exercice ci-dessus, nous disposons donc des trois variables n, msg et pi.

Pour afficher leur valeur à l’écran, il existe deux possibilités. La première consiste à entrer au clavier le nom de la variable, puis <Enter>. Python répond en affichant la valeur correspondante :

>>> n

7

>>> msg

'Quoi de neuf ?'

>>> pi

3.14159

Il s’agit cependant là d’une fonctionnalité secondaire de l’interpréteur, qui est destinée à vous faciliter la vie lorsque vous faites de simples exercices à la ligne de commande. À l’intérieur d’un programme, vous utiliserez toujours la fonction print() :

>>> print(msg)

Quoi de neuf ?

>>> print(n)

7

Remarquez la subtile différence dans les affichages obtenus avec chacune des deux méthodes. La fonction print() n’affiche strictement que la valeur de la variable, telle qu’elle a été encodée, alors que l’autre méthode (celle qui consiste à entrer seulement le nom de la variable) affiche aussi des apostrophes afin de vous rappeler que la variable traitée est du type « chaîne de caractères ».

Typage des variables

Sous Python, il n’est pas nécessaire d’écrire des lignes de programme spécifiques pour définir le type des variables avant de pouvoir les utiliser. Il vous suffit en effet d’assigner une valeur à un nom de variable pour que celle-ci soit automatiquement créée avec le type qui correspond au mieux à la valeur fournie.

On dira à ce sujet que le typage des variables sous Python est un typage dynamique, par opposition au typage statique qui est de règle par exemple en C++ ou en Java. Dans ces langages, il faut toujours – par des instructions distinctes – d’abord déclarer (définir) le nom et le type des variables, et ensuite seulement leur assigner un contenu, lequel doit bien entendu être compatible avec le type déclaré.

Affectations multiples

Sous Python, on peut assigner une valeur à plusieurs variables simultanément. Exemple :

>>> x = y = 7

>>> x

7

>>> y

7

On peut aussi effectuer des affectations parallèles à l’aide d’un seul opérateur :

>>> a, b = 4, 8.33

>>> a

4

>>> b

8.33

Dans cet exemple, les variables a et b prennent simultanément les nouvelles valeurs 4 et 8,33.

Les francophones que nous sommes avons pour habitude d’utiliser la virgule comme séparateur décimal, alors que les langages de programmation utilisent toujours la convention en vigueur dans les pays de langue anglaise, c’est-à-dire le point décimal. La virgule, quant à elle, est très généralement utilisée pour séparer différents éléments (arguments, etc.) comme on le voit dans notre exemple, pour les variables elles-mêmes ainsi que pour les valeurs qu’on leur attribue.

Opérateurs et expressions

On manipule les valeurs et les variables qui les référencent en les combinant avec des opérateurs pour former des expressions. Exemple :

a, b = 7.3, 12

y = 3*a + b/5

Dans cet exemple, nous commençons par affecter aux variables a et b les valeurs 7,3 et 12.

Comme déjà expliqué précédemment, Python assigne automatiquement le type « réel » à la variable a, et le type « entier » à la variable b.

La seconde ligne de l’exemple consiste à affecter à une nouvelle variable y le résultat d’une expression qui combine les opérateurs * , + et / avec les opérandes a, b, 3 et 5. Les opérateurs sont les symboles spéciaux utilisés pour représenter des opérations mathématiques simples, telles l’addition ou la multiplication. Les opérandes sont les valeurs combinées à l’aide des opérateurs.

Python évalue chaque expression qu’on lui soumet, aussi compliquée soit-elle, et le résultat de cette évaluation est toujours lui-même une valeur. À cette valeur, il attribue automatiquement un type, lequel dépend de ce qu’il y a dans l’expression. Dans l’exemple ci-dessus, y sera du type réel, parce que l’expression évaluée pour déterminer sa valeur contient elle-même au moins un réel.

Les opérateurs Python ne sont pas seulement les quatre opérateurs mathématiques de base. Nous avons déjà signalé l’existence de l’opérateur de division entière //. Il faut encore ajouter l’opérateur ** pour l’exponentiation, ainsi qu’un certain nombre d’opérateurs logiques, des opérateurs agissant sur les chaînes de caractères, des opérateurs effectuant des tests d’identité ou d’appartenance, etc. Nous reparlerons de tout cela au fil des pages suivantes.

Signalons au passage la disponibilité de l’opérateur modulo, représenté par le caractère typographique %. Cet opérateur fournit le reste de la division entière d’un nombre par un autre. Essayez par exemple :

>>> 10 % 3                   # (et prenez note de ce qui se passe !)

>>> 10 % 5

Cet opérateur vous sera très utile plus loin, notamment pour tester si un nombre a est divisible par un nombre b. Il suffira en effet de vérifier que a % b donne un résultat égal à zéro.

Priorité des opérations

Lorsqu’il y a plus d’un opérateur dans une expression, l’ordre dans lequel les opérations doivent être effectuées dépend de règles de priorité. Sous Python, les règles de priorité sont les mêmes que celles qui vous ont été enseignées au cours de mathématique. Vous pouvez les mémoriser aisément à l’aide d’un « truc » mnémotechnique, l’acronyme PEMDAS :

* P pour parenthèses. Ce sont elles qui ont la plus haute priorité. Elles vous permettent donc de « forcer » l’évaluation d’une expression dans l’ordre que vous voulez.

Ainsi 2*(3-1) = 4 , et (1+1)**(5-2) = 8.

* E pour exposants. Les exposants sont évalués ensuite, avant les autres opérations.

Ainsi 2**1+1 = 3 (et non 4), et 3*1**10 = 3 (et non 59049 !).

* M et D pour multiplication et division, qui ont la même priorité. Elles sont évaluées avant l’addition A et la soustraction S, lesquelles sont donc effectuées en dernier lieu.

Ainsi 2*3-1 = 5 (plutôt que 4), et 2/3-1 = -0.3333... (plutôt que 1.0).

* Si deux opérateurs ont la même priorité, l’évaluation est effectuée de gauche à droite.

Ainsi dans l’expression 59*100//60, la multiplication est effectuée en premier, et la machine doit donc ensuite effectuer 5900//60, ce qui donne 98. Si la division était effectuée en premier, le résultat serait 59 (rappelez-vous ici que l’opérateur // effectue une division entière, et vérifiez en effectuant 59*(100//60)).

Composition

Jusqu’ici nous avons examiné les différents éléments d’un langage de programmation, à savoir : les variables, les expressions et les instructions, mais sans traiter de la manière dont nous pouvons les combiner les unes avec les autres.

Or l’une des grandes forces d’un langage de programmation de haut niveau est qu’il permet de construire des instructions complexes par assemblage de fragments divers. Ainsi par exemple, si vous savez comment additionner deux nombres et comment afficher une valeur, vous pouvez combiner ces deux instructions en une seule :

>>> print(17 + 3)

>>> 20

Cela n’a l’air de rien, mais cette fonctionnalité qui paraît si évidente va vous permettre de programmer des algorithmes complexes de façon claire et concise. Exemple :

>>> h, m, s = 15, 27, 34

>>> print("nombre de secondes écoulées depuis minuit = ", h*3600 + m*60 + s)

Attention, cependant : il y a une limite à ce que vous pouvez combiner ainsi :

Dans une expression, ce que vous placez à la gauche du signe égale doit toujours être une variable, et non une expression. Cela provient du fait que le signe égale n’a pas ici la même signification qu’en mathématique : comme nous l’avons déjà signalé, il s’agit d’un symbole d’affectation (nous plaçons un certain contenu dans une variable) et non un symbole d’égalité. Le symbole d’égalité (dans un test conditionnel, par exemple) sera évoqué un peu plus loin.

Ainsi par exemple, l’instruction m + 1 = b est tout à fait illégale.

Par contre, écrire a = a + 1 est inacceptable en mathématique, alors que cette forme d’écriture est très fréquente en programmation. L’instruction a = a + 1 signifie en l’occurrence « augmenter la valeur de la variable a d’une unité » (ou encore : « incrémenter a »).