Structure du langage Python

1. Terminologie

Si vous lisez ce livre, c’est que vous avez un objectif : découvrir la programmation, créer un jeu, apprendre le langage Python, créer une petite application, faire des exercices ou acquérir des connaissances supplémentaires !

Tous ces objectifs vont passer par l’écriture de lignes de code constituant le code source de votre programme. Ces lignes de code sont stockées dans des fichiers texte ayant l’extension py. Ces fichiers sont modifiables dans un éditeur de texte, comme Notepad ou WordPad sous Windows ou encore TextEdit sous Mac.

Le code source au format texte n’est pas directement exécutable par l’ordinateur, il doit passer à travers une étape de conversion effectuée par l’interpréteur Python, qui a la tâche de lire le code source et de l’exécuter.

Le langage Python dispose de sa propre grammaire interne avec ses règles et ses usages. Par exemple, le langage définit une liste de mots-clés réservés qui ne peuvent être choisis par le programmeur pour créer des noms de variables ou des noms de fonctions. Vous connaissez par exemples les mots-clés correspondant aux instructions for, if, then et else. Il existe aussi d’autres mots-clés comme ceux associés aux opérateurs logiques or, and et not ou ceux correspondant aux constantes comme True et False.

Les curieux peuvent consulter la liste des mots-clés dans la documentation officielle du langage Python à l’adresse : https://docs.python.org/fr/3/reference/lexical_analysis.html

Lorsque l’interpréteur Python parcourt le code source, il catégorise chaque élément rencontré en utilisant les règles grammaticales du langage. Pour vous aider à saisir comment l’interpréteur se comporte, voici quelques exemples :

2. Les éléments du langage

Une fois que l’interpréteur a analysé l’ensemble du code source, chaque élément...

1. Usage

Une variable sert à représenter une valeur par un nom. Vous retrouvez ici un concept assez proche de ce que vous connaissez en mathématiques ou en physique. Cependant, il y a quelques différences :

Un nom de variable doit respecter certaines règles :

1. Un nom ne doit pas commencer par un chiffre.

2. Un nom ne doit pas contenir de caractères spéciaux : ! % @ # [ + = \ ( ) [ ] = & : . , ; $..., exception faite de l’underscore _ présent sur la touche [8] du clavier.

Aujourd’hui, un projet informatique peut être mené par des personnes de nationalités différentes à travers le monde. Par conséquent, l’usage veut que l’on utilise les 26 lettres standards et que l’on évite les caractères spéciaux issus de sa propre langue comme é, à ou ç pour le français. Cependant, sachez que l’interpréteur Python accepte ces caractères si vous vouliez les utiliser.

2. Conseil 1 : choisir des noms explicites

Si vous deviez retenir une seule consigne de cet ouvrage, ce serait sûrement celle-ci : choisissez des noms clairs et explicites. Ce réflexe n’est pas automatique car les cours de mathématiques/physique vous ont habitués à utiliser des noms de variable avec une seule lettre : x, y, r ou . C’est très pratique lorsque l’on écrit des calculs longs à la main. La signification de chaque symbole est connue : r désigne un rayon, un angle… En somme, le terrain reste très balisé.

Cependant, l’homo informaticus a connu une autre évolution : il écrit des programmes contenant des millions de lignes. Cette fois, la priorité devient tout autre : lisibilité et structuration. Ce sont les deux maîtres mots de l’informaticien. Il doit à tout prix structurer sa pensée pour organiser son code et le rendre le plus lisible possible. Prenons l’exemple d’une formule écrite de deux manières différentes : en utilisant seulement une lettre pour chaque variable puis en choisissant un nom explicite pour chaque variable :

v = a * (1+t)

ou

PrixTTC =  PrixHT * (1+TVA)

Il semble évident que la seconde formulation se comprend aisément et rapidement et qu’il faudrait écrire tout morceau de code ainsi. Cependant, vous serez sûrement tenté par le côté obscur (la première option), et ceci pour les raisons suivantes :

1. Typage automatique

Lorsque l’interpréteur Python parcourt le code du programme, il détermine automatiquement le type d’une valeur d’après son écriture. La fonction native type() permet de connaître le type associé à un littéral. Voici quelques exemples effectués en mode interactif :

>>> type(10)  
<class 'int'>  
  
>>> type(1.0)  
<class 'float'>  
  
>>> type("Bonjour")  
<class 'str'> 

Le nombre 10 a été écrit sans chiffres après la virgule. La convention veut qu’il soit associé au type entier (integer en anglais ou int en abrégé). La valeur 1.0 désigne cette fois un nombre à virgule. Automatiquement, l’interpréteur Python choisit le type flottant dénommé float pour stocker cette valeur en mémoire. Une chaîne de caractères est associée au type str.

Si l’on peut utiliser des nombres à virgule, on peut se passer des nombres entiers ! Attention, cette affirmation est inexacte. En effet, les nombres flottants utilisés par l’ordinateur sont imprécis. Ainsi, en écrivant le littéral 12, il se peut que la valeur représentée en mémoire soit plutôt 12.000000001, et ce petit détail est important. Ainsi, pour représenter des compteurs ou des positions dans une liste, il faut travailler avec des nombres entiers qui nous garantissent des résultats exacts.

Opérateurs arithmétiques : +, -, *

Le type du résultat de l’opération correspond au type des nombres traités. Ainsi, l’addition de deux entiers donne un nombre entier. Lorsqu’une opération a lieu entre un nombre entier et un nombre flottant, le résultat sera de type flottant. Voici quelques exemples :...

1. Opérations sur les chaînes de caractères

Concaténation

L’opérateur + permet d’accoler deux chaînes en une.

>>> a = 'Bonjour ' 
>>> b = 'toi' 
>>> c = a + ' ' + b 
 
Bonjour toi 

Pour concaténer des numériques avec des chaînes de caractères, il faut d’abord convertir les nombres en chaînes grâce à la fonction str().

Longueur d’une chaîne

La fonction native len() retourne la longueur d’une chaîne et donc son nombre de caractères :

>>>A = "Bonjour" 
>>>len(A) 
 
  7 

Transformer en majuscules/minuscules

Les fonctions upper() et lower() retournent une chaîne composée respectivement uniquement de majuscules ou de minuscules. On accède à ces fonctions à travers une variable de type chaîne en utilisant la syntaxe LaChaine.upper().

>>> A = "Salut !!"  
>>> A.upper()  
SALUT !! 
>>> A.lower() 
salut !!  

Notez que les fonctions upper() et lower() ne modifient pas la chaîne en cours, elles retournent une nouvelle chaîne. Si vous voulez modifier la variable courante, il faut écrire : A = A.upper().

Le standard Unicode

Le standard Unicode contient plus de 100 000 caractères et autres symboles de diverses écritures. Ainsi, chaque caractère est associé à un numéro unique : la valeur 32 correspond au caractère espace, la plage de valeurs 48 à 57 correspond aux chiffres de 0 à 9, la plage 65 à 90 code les lettres majuscules de A à Z et la plage 97 à 122 correspond aux lettres minuscules. Deux fonctions chr()et ord() permettent de convertir un code en caractère, et inversement :

>>> ord("A") 
65 
>>> ord("B") 
66 
>>> chr(67) 
"C" 

Pour vous amuser, consultez la page https://fr.wikipedia.org/wiki/Table_des_caractères_Unicode/U1F600 codant divers émoticônes.

>>> chr(0x1F600)  
 
>>> chr(0x1F63B) 
 

2. Sous-chaîne

On peut accéder à un caractère d’une chaîne en écrivant son indice entouré d’une paire de crochets. L’indice 0 est associé au premier caractère en partant de la gauche et l’indice 1 désigne le deuxième caractère. Pour désigner le dernier caractère, on peut écrire...

1. Écriture d’une condition

Une condition correspond à une expression utilisant généralement des opérateurs booléens (<, >, ==) et dont le résultat peut prendre la valeur : False pour désigner un résultat faux ou True pour désigner un résultat vrai.

Dans le langage Python, nous trouvons différents opérateurs de comparaison :

Voici quelques exemples d’une condition exprimée en langage naturel suivie de sa version informatique :

Le résultat d’une condition peut être stocké dans une variable :

partieFinie = pointsDeVie <= 0 

Il est possible d’effectuer grâce à l’opérateur not une inversion (ou négation) d’une valeur booléenne. Cet opérateur logique retourne vrai lorsque la valeur qu’il reçoit est fausse, et inversement. Par exemple, pour savoir si la partie continue, nous pouvons écrire la condition suivante :

not partieFinie 

Les comparaisons fonctionnent aussi avec des chaînes de caractères et respectent l’ordre lexicographique utilisé dans un dictionnaire. Voici quelques exemples :

>>> "TATA" < "TONTON"   
True  
>>> "ZOE" < "ZERO"  
False  
>>> "TATI" == "TA" + "TI"  
True 

L’inversion/négation est un des rares opérateurs du langage prenant un seul paramètre en entrée, il est dit unaire. La plupart des opérateurs (ET/OU, +, -, *, /) s’appliquent sur deux valeurs, ce sont des opérateurs binaires. L’expression opérateur binaire est aussi utilisée pour parler des opérateurs bit à bit comme l’opérateur OU binaire, 0b01 | 0b11 donnant 0b11.

2. Branchement if

Un branchement permet de déclencher l’exécution d’une partie du code lorsque le résultat d’une condition est vrai. La syntaxe est la suivante :

if condition : 

Dans le langage Python, contrairement à la plupart des langages informatiques, il n’est pas nécessaire d’englober la condition avec une paire de parenthèses. Pour définir le bloc de code devant être exécuté si la condition est vraie, on indente les lignes correspondantes en les décalant vers la droite. Si la condition est fausse, le fil d’exécution ignore les lignes contenues dans le bloc et passe directement à la première ligne de code dont l’indentation est la même que l’instruction if :

if note >= 10 :  
   print("Tu...

1. Principe de fonctionnement

Une boucle for permet d’exécuter plusieurs fois un bloc de code. Ce bloc, appelé corps de boucle, commence à la ligne suivant l’instruction for. Il doit avoir une indentation plus importante, et lorsque l’indentation revient au même niveau que celle de l’instruction for, cela signifie que le corps de boucle s’est achevé. En résumé, nous identifions le corps de boucle ainsi :

... 
for ... :                   # Démarrage de la boucle for 
    ...                     #  || Corps de boucle 
    ...                     #  || 
    ...                     #  || 
    ...                     #  \/ Fin du corps de boucle 
...  

La boucle for permet de définir une variable servant d’indice ainsi que la plage de valeurs que cet indice va parcourir. Pour cela, on utilise la fonction native range(k) définissant une plage de valeurs allant de 0 à k-1. Ainsi, en écrivant for i in range(3), la variable i lors de la première exécution du corps de boucle vaut 0. Ensuite, l’interpréteur exécute à nouveau le même bloc, mais cette fois la variable i vaut 1. Puis, pour terminer, l’interpréteur exécute une dernière fois le corps de boucle avec 2 comme valeur pour l’indice i. Après cela, la boucle est terminée.

Mettons nos connaissances en application sur l’exemple suivant :

print("Avant la boucle for") 
for i in range(3) :                   # Mise en place de la boucle 
  print("  Début du corps de boucle") # || Corps 
  print("  i =",i)                    # || 
  print("  Fin du corps de boucle")   # \/   
print("Après la fin de la boucle for ") 

Essayez de deviner les affichages produits par ce code. L’indice de boucle i va démarrer à la valeur 0 et sa dernière valeur sera 2. Voici le résultat obtenu :

>> Avant la boucle for 
>>   Début du corps de boucle 
>>   i = 0 
>>   Fin du corps de boucle 
>>   Début du corps de boucle 
>>   i = 1 
>>   Fin du corps de boucle 
>>   Début du corps de boucle 
>>   i = 2 
>>   Fin...

1. Afficher un mot à l’envers

La correction de cet exercice est disponible en téléchargement depuis l’onglet Compléments. Demandez à l’utilisateur d’entrer un mot au clavier. Ensuite, écrivez-le à l’envers, c’est-à-dire de droite à gauche. Voici quelques conseils :

2. Calculer la valeur du polynôme 3x² + 5x + 1

La correction de cet exercice est disponible en téléchargement depuis l’onglet Compléments. Demandez à l’utilisateur d’entrer un nombre quelconque. Attention, cela peut être un nombre à virgule. Calculez la valeur du polynôme et affichez-la. Redemandez deux autres valeurs et affichez les résultats.

3. Additionner les n premiers entiers

La correction de cet exercice est disponible en téléchargement depuis l’onglet Compléments. L’utilisateur entre un nombre n au clavier. Vous devez calculer la somme des n premiers entiers : 1+ … + n, et l’afficher :

4. L’infiniment petit

La correction de cet exercice est disponible en téléchargement depuis l’onglet Compléments. Vous allez diviser successivement par 2 la valeur 1, ceci 50 fois. À chaque fois, affichez le résultat sous la forme d’un nombre ayant 50 chiffres après la virgule. Pour valider votre résultat, affichez au démarrage la chaîne : "XX0123456789023456789012345678901234567890123456789"....

1. Le jeu du pendu

La correction de ce projet est disponible en téléchargement depuis l’onglet Compléments. Le jeu du pendu consiste à trouver un mot en devinant les lettres qui le composent. Nous vous proposons de mettre en place une version simplifiée, mais relativement complète. Pour rendre le code plus simple, vous ne traiterez que des mots avec des lettres différentes. Cela permet d’éviter la gestion des doublons.

Voici vos objectifs :

Voici quelques conseils :

Voici un exemple de déroulement de partie :

Jeu du pendu !! 
Entrez une lettre suivie d'un appui sur la touche Entrée 
A 
# # # # A #  
C 
C # # # # #  
L 
# # # # # L  
V 
# # # V # #  
T 
# # # # # #  ...