Python : les bases

Nous allons voir les bases de la programmation en Python.

Rappel : Il est extrêmement important de pratiquer la programmation pour intégrer les concepts et la syntaxe que nous allons présenter ici. Lors de l'écriture de vos premiers programmes, vous allez très probablement devoir faire des allers retours entre ce cours et votre code, c'est normal, ça fait partie du processus d'apprentissage.

En particulier, REECRIVEZ à la main tous les programmes proposés ici, et executez les !!! Vous pouvez aussi bien sûr vous amuser à les modifier, si vous êtes en avance ou curieux/curieuse. Ce chapitre est un moment un peu ennuyeux, nécessaire pour pouvoir ensuite faire des programmes plus grands, et donc plus intéressants

Les commentaires

Tout langage de programmation supporte l'écriture de commentaires. Ce sont des parties du code que l'interpréteur ignore : on peut modifier notre programme Hello, World! pour y inclure un commentaire, en écrivant une ligne commençant par # (Alt Gr + " sur un clavier Azerty).

Ce programme

#ceci est un commentaire, il sera ignoré à l'execution
print("Hello, World!")

produira

Hello, World!

Les commentaires sont utiles pour donner des précisions sur le code, qui pourront êtres lues par d'autres programmeur.

Instructions, séquence

Les instructions sont les briques de base pour construire des programmes en Python. Une instruction représente une action que l'ordinateur doit effectuer.

Par exemple, dans le premier programme que nous avons écrit, le "Hello World",print("Hello, World !") était une instruction pour dire à Python d'afficher la valeur Hello, World! dans la console.

En Python, on peut faire exécuter plusieurs instructions en les écrivant les unes en dessous des autres. C'est ce que l'on appelle une séquence d'instructions. Elles seront exécutées du haut vers le bas.

Le code suivant :

print("Hello,")
print("World!")

produira :

Hello,
World!

Variable, affectations, valeurs

Pour mémoriser des données, nous utilisons une variable, une boîte identifiée par un identifiant (aussi appelé identificateur) stockée dans la mémoire de l'ordinateur, à laquelle nous pouvons affecter une valeur pour la réutiliser plus tard.

le code suivant

a = 1

affecte à la variable a la valeur 1.

Affecter pour la première fois une valeur à un nouveau nom s'appelle déclarer une variable. Pendant cette opération, l'ordinateur crée une nouvelle boîte avec une étiquette (ici, a).

Une fois qu'une variable est déclarée, elle peut être utilisée plus loin dans le code, en utilisant son nom à la place d'une valeur.

a = "hello"
print(a) #on regarde ici ce qu'il y a dans la boîte de nom 'a'

hello

Erreurs d'interprétation

Si on essaye d'utiliser une variable avant de la déclarer, l'interpréteur Python va nous afficher une erreur :

le programme suivant, écrit dans un ficher erreur.py,

print(a)

affiche quelque chose comme :

Traceback (most recent call last):
  File "/home/felix/erreur.py", line 1, in <module>
    print(a)
NameError: name 'a' is not defined

Ceci est un message d'erreur, pour nous indiquer que notre programme n'a pas pu être exécuté correctement. Analysons le ligne par ligne.

Traceback (most recent call last): : nous pouvons ignorer cette ligne. Nous reviendrons bien plus tard sur sa signification.
File "/home/felix/erreur.py", line 1 : indique le fichier et le numéro de ligne où se trouve l'instruction qui a causé l'erreur. Ignorons , in <module> pour le moment.
print(a) : l'instruction qui a causé l'erreur
NameError: est le nom de l'erreur. Ici, il nous indique que quelque chose cloche avec les identifiants. name 'a' is not defined nous indique que la variable a que nous voulons utiliser n'a pas été déclarée.

Les messages d'erreur peuvent sembler très compliqués à première vue, mais la facilité de lecture viendra rapidement avec la pratique. Ici, on aurait pu insérer un message en gras vous rappelant de bien pratiquer.

Input

Jusqu'à maintenant, les programmes se contentent d'exécuter des instructions sans intéractions. Ce n'est pas très rigolo. On va donc voir comment demander à l'utilisateur d'entrer des valeurs dans le terminal.

Celà se fait avec l'instruction input. Elle s'utilise comme suit :

une_variable = input("message à afficher avant la saisie")

Par exemple, ce programme :

prenom = input("Quel est ton nom ? ")
#ici, le programme va attendre une entrée de la part de l'utilisateur
print("Hello,")
print(prenom)

va, dans un premier temps, afficher :

Quel est ton nom ?

Puis se mettre en attente, jusqu'à que l'utilisateur entre quelque chose dans le terminal, puis appuie sur la touche Entrée. Admettons qu'on écrive "Felix", qui est un très beau prénom, même sans accent. (Mais vous pouvez aussi utiliser votre nom à vous, il est certainement très beau aussi.), puis qu'on appuie sur Entrée.

Quel est ton nom ? Felix

Le programme va alors continuer, pour executer les instructions suivantes et terminer, il affichera :

Hello, 
Felix

Voici une trace de l'execution complète du programme :

Quel est ton nom ? Felix
Hello,
Felix

On a vu comment sauvegarder des valeurs dans des variables, mais pour le moment notre usage est limité. On aimerai bien pouvoir traiter les données stockées, c'est à dire effectuer des opérations sur celles-ci.

Propreté du code

Mais avant celà, il nous faut parler de la manière d'écrire nos programmes.

Le but premier de presque tout programme dans un langage de programmation, c'est d'être simple à lire et à comprendre. Ces deux objectifs sont contradictoires : - Plus nous explicitons notre programme, et plus il sera long, et donc difficile à lire. - Si notre programme est très concis, sans commentaire, alors il sera très court et facile à lire, mais difficile à comprendre.

Il s'agit de trouver un équilibre entre ces deux objectifs. Nous en reparleront plus en détails au long de ce cours, mais nous allons voir quelques pistes pour aider.

La règle principale, la plus importante à retenir, c'est que votre code doit être cohérent, c'est à dire que vous devez utiliser partout le même style. Il faut aussi que votre code soit cohérent avec les conventions établies par les autres programmeur qui utilisent le langage. La cohérence du code facilite sa lecture. Etre cohérent avec les conventions signifie que n'importe quel programmeur qui maîtrise le langage pourra lire votre code sans trop d'effort.

Nommage des variables

Un identifiant en Python ne peut contenir que des chiffre, des lettres, et des underscores _, et doit obligatoirement commencer par une lettre. En réalité, Python autorise à commencer un identifiant par un underscore, mais c'est plutôt réservé à des cas très spéciaux, donc il vaut mieux éviter.

Dans tous les langages de programmation, il y a des mots clés, ce sont des mots réservés, qu'on ne peut pas utiliser comme identifiant. En voici quelques uns de Python : if elif else while for

La convention en Python demande de formatter les noms de variable dans un style qui s'appelle le snake_case (oui, c'est un rapport à Python). Il consiste à écrire un nom tout en minuscules, et si il est composé de plusieurs mots, de les séparer par un underscore. En première comme en terminal, il vous est demandé de suivre ces conventions.

deux_mots

D'une manière plus générale :

Trouvez les noms le plus court possible pour être compris, mais évitez les noms très très courts. Entre 2 et 12 caractères est une bonne fourchette. Bien entendu, il y a des cas où il est normal de dépasser.
Oubliez les mots de liaisons, et abrégez certains mots dans les noms à plusieurs mots si cette abréviation (ou acronyme) est standard. nb_mots_liaison est mieux que nombre_de_mots_de_liaison.
Décrivez à quoi sert une variable, et non ce qu'elle est (c'est parfois la même chose). Si vous stockez l'age d'un utilisateur, votre variable doit s'appeler age et non pas valeur ou variable.

Utilisation des commentaires

Une autre règle fondamentale pour avoir un code propre, est que ce qui peut être exprimé par le code doit être exprimé par le code. Celà veut dire que les commentaires doivent compléter les informations manquantes dans votre code, et c'est tout. Deux raisons :

L'interpréteur effectue de nombreuses vérifications sur le code, mais ne tient pas compte des commentaires. En s'exprimant dans le code, on donne des informations supplémentaires à l'interpréteur, qui peut donc mieux vérifier notre code.
Les commentaires demandent augmentent la longueur du code, et donc la difficulté à le lire. Avoir des commentaires rendondants avec le code, qui n'apportent pas d'information supplémentaire, c'est en général une perte de temps.

Il faut garder nos commentaires concis, et bien s'assurer qu'ils apportent bien une information supplémentaire que nous ne pourrions pas exprimer directement par le code.

Nous verrons tout au long de ce cours comment on peut utiliser la syntaxe et la sémantique du langage pour éviter d'écrire des commentaires. Le choix des noms de variable fait partie de cette démarche, voilà donc une illustration du principe.

Ce code a des commentaires redondants :

#on demande le nom à l'utilisateur
n = input("Quel est votre nom ?")
#on demande l'age à l'utilisateur
a = input("Quel est votre age ?")

Il devrait s'écrire :

nom = input("Quel est votre nom ?")
age = input("Quel est votre age ?")

Position des commentaires

En général, les commentaires :

Qui occupent une ligne entière donnent des informations sur les lignes de codes qui se situent en dessous.
Placés à la fin d'une ligne donnent des informations sur la ligne elle-même.

# ce commentaire explicite la ligne input, et eventuellement les lignes suivantes
a = input("a ? ")

print("a") # ce commentaire décrit la ligne print

Commentaires pédagogiques

Tout au long de ce cours, je vais parfois utiliser des commentaires pour expliquer le code en détail. Ces commentaires ne devraient pas être présents dans le code hors d'une situation d'apprentissage, vu qu'ils peuvent être redondants avec le code.

Pour pouvoir différencier les commentaires pédagogiques, qui servent à expliquer dans le cadre de ce cours, et les vrais commentaires, que l'on attendrait dans un code hors du cours, je marquerai les commentaires pédagogiques avec un double #.

## Ceci est un commentaire pédagogique, il ne sert qu'à donner des explications supplémentaires dans le cadre de ce cours

## Le commentaire ci dessous est un commentaire classique, il fait donc partie de la solution
# Ceci est un commentaire classique, il fait partie de la solution

Expressions

Une expression est un petit bout de programme qui "produit" une valeur qui peut être réutilisée dans le programme, par exemple en étant affectée à une variable.

Le programme :

a = 10 + 2
print(a)

produit :

Ici, 12 + 2 est une expression, qui combine les valeurs 10 et 2 avec l'opérateur +, qui dans notre cas est une opération d'addition, et "produit" la valeur 14. Plutôt que de dire qu'une expression "produit" une valeur, on dit qu'elle est evaluée à la valeur. Par exemple, 12 + 2 est évaluée à 14.

On peut utiliser des variables dans une expression.

Le programme :

a = 12
b = a + 2
print(b)

produit :

Essayons de faire un petit programme qui demande un nombre à l'utilisateur, lui ajoute 1, et affiche le résultat.

a = input("a : ")
res = a + 1
print(res)

Ce programme renvoie une erreur :

a : 3
Traceback (most recent call last):
  File "/home/felix/erreur.py", line 2, in <module>
    res = a + 1
TypeError: can only concatenate str (not "int") to str

Le nom de cette erreur est TypeError, c'est une erreur de typage. Voyons plus en détail ce qu'elle veut dire.

Le typage

Chaque valeur a un type, qui définit le sens de la valeur (ce qu'elle représente), et aussi les opérations que l'on peut faire dessus.

Nous avons déjà vu deux types :

les entiers (en anglais, integer, souvent abrégé int), qui sont les valeurs numériques, par exemple 10, 2034. Les entiers peuvent être négatifs en Python, par exemple -5.
les chaînes de caractères (en anglais string, souvent abrégé str), qui représentent un texte, et sont crées en utilisant des guillements "chaine de caractère".

Le typage permet à l'interpréteur de détecter des erreurs potentielles dans notre code, de manière automatique.

Par exemple, dans notre dernier programme :

a = input("a : ")
res = a + 1
print(res)

input produit une valeur de type str. C'est logique, puisque dans le terminal, nous entrons du texte.

Quand nous ecrivons a + 1, nous essayons donc d'"ajouter" un entier et du texte, ce qui n'a pas de sens (c'est à dire qu'aucun résultat n'est défini pour cette opération), et est donc très probablement une erreur.

Dans le chapitre suivant, nous détailleront quelques types que Python nous permet de manipuler, et nous verrons comment résoudre l'erreur de typage dans notre programme.