Bases de programmation et du langage python

Nous montrerons dans ce cours les bases du codage en utilisant le langage de programmation python dont le site est : https://www.python.org/

Nous verrons comment est structuré un langage informatique et comment écrire puis exécuter du code.

Ce n'est pas un cours d'informatique proprement dit, nous ne ferons quasiment pas d'algorithmie par exemple et il n'y a aucun prérequis informatique à avoir. Le but est de pouvoir exécuter (de la façon la plus optimale possible) des lignes de code pour obtenir un résultat concret (qui n'aura souvent rien à voir avec de l'informatique).

Partie I : principes

Avant d'écrire des programmes en python, on commence par s'intéresser à ses mécanismes internes en comprenant ce qu'est une instruction python et ce que'on peut faire avec.

Écrire directement à l'interpréteur comme on l'a fait jusqu'à présent est faisable lorsque l'on a besoin de n'écrire qu'une ligne de python à la fois, mais lorsque l'on veut faire des choses plus compliquées comme créer des tests ou effectuer des boucles, il faut des outils plus perfectionnés.

Nous allons montrer deux outils pour faire cela : les notebooks et Spyder. Ce sont des solutions pratiques lorsque l'on veut exécuter rapidement un petit bout de code ou une série de bouts de codes plus ou moins indépendant : lorsque l'on utilise l'outil informatique pour faire des maths ou de la physique par exemple ; ou encore lorsque l'on fait de la data science.

Notebooks

C'est une manière plus conviviale que la console d'accéder à l'interpréteur python. L'utilisation des Notebooks est particulièrement adaptée pour rédiger et partager des comptes-rendus.

Spyder

Spyder est un éditeur lié à un interpréteur python. L'application est très utilisée lorsque l'on commence à apprendre la programmation. Et permet d'écrire des programmes tout en conservant un unique interpréteur accessible par une console.

TBD : un petit tuto.

Utiliser le module matplotlib

Installé avec la plupart des environnements fournissant un interpréteur, le module matplotlib est devenu un standard de fait (pour le meilleur et surtout le pire) pour représenter des graphiques.

Si vous avez le choix, je conseille plutôt d'utiliser le module seaborn pour dessiner vos graphique. Mais comme ce module est basé sur matplotlib, une connaissance minimale de matplotlib, comme le donne le tutoriel précédent est tout de même nécessaire.

Partie II : coder en python

Nous avons pour l'instant utilisé python pour exécuter des instructions ou des fonctions. Ceci permet déjà d'utiliser python mais va se révéler rapidement limitant lorsque l'on voudra effectuer des tâches plus complexes ou tout simplement non prévue par les modules.

Coder en python (ou en tout autre langage) ce cependant nécessiter des connaissances (un peu) plus poussées et des outils dédiées au code. Nous irons plus loin plus tard.

Installer et utiliser un interpréteur

Commençons par installer un interpréteur indépendant de l'application utilisée pour coder. Selon le système d'exploitation, la méthode d'installation est un peu différente :

sudo apt install python3-pip

sudo apt install python3-tk

sudo apt install python-is-python3

brew install python-tk

echo "alias python=python3" >> ~/.zshrc

Une fois l'interpréteur installé, on va l'utiliser via un IDE. Il existe plusieurs choix possible, mais le plus utilisé actuellement est vscode :

Un interpréteur tout neuf vient presque nu. Il ne possède aucun des modules mis à disposition d'environnement tels que anaconda ou Spyder. Mais ce n'est pas grave, nous allons les installer nous même !

Structurer du code

Lorsque l'on veut plus que juste utiliser des méthodes et fonctions déjà existante, il faut structurer son code en parties utilisables indépendamment, que ce soit sous la forme de code (bloc, fonctions, modules).

Partie III : Conteneurs

Liste, ensembles et dictionnaire

Les conteneurs sont des objets contenant d'autres objets. Ils permettent de structurer ses données.

Mutable et non mutable

Les 5 type d'objets de base (int, float, complex, bool et str) sont non modifiables (python dira non mutables). Ceci signifie que les méthodes et opérations sur ces objets ne peuvent les modifier :

• si i contient un entier, i = i + 1 créera un nouvel entier qui sera associé à la variable i
• "coucou".replace{"c", "b"} créera une nouvelle chaîne de caractères

Les listes, ensembles et dictionnaires sont eux modifiables (python dira mutables), c'est à dire que leurs méthodes peuvent les modifier :

• l.append("x") modifiera la liste l
• d["un"] = 1 modifiera le dictionnaire d en lui ajoutant une clé
• e.add("un") modifiera l'ensemble e en lui ajoutant un élément

Il est crucial de comprendre cela car les variables ne sont que des associations à des objets, et plusieurs variables différentes peuvent être associée à un même objet. Vérifions cela avec la fonction id.

Si on crée deux listes, elles seront différentes, donc leur id le sera aussi, même si leur contenu est identique :

>>> x = [1, 2]
>>> y = [1, 2]
>>> id(x)
4381752640
>>> id(y)
4381751744

L'id sera certainement différent chez vous, mais les deux id seront différents.

En revanche, associer une liste à une variable ne change pas la liste :

>>> x = [1, 2]
>>> id(x)
4381803264
>>> y = x
>>> id(y)
4381803264

L'id sera certainement différent chez vous, mais il sera identique. Les variables x et y sont associées à la même liste :

>>> x.append('?')
>>> print(x)
[1, 2, '?']
>>> print(y)
[1, 2, '?']

En conclusion, il faut faire très attention lorsque l'on passe des listes en paramètres de fonction.

>>> x = 1
>>> y = 1
>>> id(x)
4378755312
>>> id(y)
4378755312

La remarque précédente montre tout l'intérêt d'utiliser des objets non mutables. Il 'y aura jamais d'effet de bords lors de passage de paramètres. En revanche, à chaque modification, il faudra recréer un objet, ce qui peut être long. C'est un compromis à avoir : la sécurité vs la rapidité. C'est pourquoi par défaut :

• une chaîne de caractère est non modifiables (elles sont souvent crées une fois pour toute dans un programme)
• une liste est modifiable. L'utilisation des listes dans un programme nécessite souvent de la modifier.

Il existe des objets non modifiable pouvant être utilisé à la place des listes et des ensembles :

• un tuple pour une liste. Elle se crée en remplaçant les [] d'une liste par des () : (1, 2, 3) crée un tuple à 3 éléments. Il pourra être utilisé comme une liste mais on ne pourra jamais lui ajouter ou modifier ses éléments.
• un frozenset sera le pendant non mutable d'un ensemble. On place les éléments directement à la création et ils ne peuvent plus être modifiés ensuite.

On peut alors utiliser des tuples et des frozenset comme éléments d'un ensemble ou comme clé de dictionnaires.

Par exemple l'ensemble de tous les sous-ensemble de ${1, 2}$ s'écrira :

>>> x = {frozenset(), frozenset([1]), frozenset([2]), frozenset([1, 2])}
>>> x
{frozenset(), frozenset({2}), frozenset({1}), frozenset({1, 2})}