Python pour les noobs !

Pré-requis : installation des logiciels

Assurez-vous d’avoir les logiciels suivants installés sur votre machine :

• Python >= 3.14 (comment installer Python : https://python-cnrs.netlify.app/edu/init/preliminaries/python, voir les notes relatives à votre OS pour Windows, MacOSX et Linux et WSL)
• Le gestionnaire de paquets UV (Sous Windows, il faut ouvrir un nouveau terminal après l’installation pour qu’UV soit disponible)
• Un éditeur de texte (Notepad++) ou un environnement de développement (IDE) comme Spyder ou VSCode

Vous pouvez vérifier le bon fonctionnement de votre installation avec la procédure suivante :

1. Ouvrir un terminal (PowerShell sous Windows) : appuyer sur la touche avec l’icône Windows de votre clavier, puis taper “PowerShell” et appuyer sur Entrée
2. Dans le terminal : taper python --version puis appuyer sur Entrée
3. Vous devriez voir s’afficher une ligne du type Python 3.X.Y ou 3.X.Y est le numéro de la version de Python installée sur votre machine.

Usage de base

Deux cas de figure sont possibles :

1. Dans un terminal, taper python : l’interpréteur Python se lance et vous permet de taper et d’exécuter des commandes. Dans une terminal PowerShell sous Windows, il peut être nécessaire de remplacer python par py.

Pour fermer l’interpréteur : exit()

foo@bar:~$ python
Python 3.14.4 (main, Apr 14 2026, 14:26:14) [Clang 22.1.3 ] on linux
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print("Hello World!")
Hello World!
>>> exit()
foo@bar:~$

2. Pour plus de praticité : écrire du code Python dans un fichier texte, avec l’extension .py, puis exécuter le programme avec la commande python mon_programme_python.py

foo@bar:~$ python mon_programme_python.py
foo@bar:~$

L’option 2 est à privilégier dès lors qu’il y a nécessité d’exécuter plusieurs fois un même programme, ou si celui-ci dépasse quelques lignes de code.

Travailler en mode projet

Il existe plusieurs versions de Python, et de nombreux modules supplémentaires. C’est une richesse, mais ça peut aussi être source d’ennuis si vous voulez que vos collègues puissent utiliser vos scripts, s’ils ne possèdent pas la même version de Python et de ses modules que vous !

Pour pallier ce problème, on peut utiliser des environnements virtuels : chaque environnement aura sa propre version de Python, et ses propres modules Python. Vous pouvez ainsi documenter les versions utilisées, et transmettre cet environnement à vos collègues.

L’utilisation d’environnements virtuels présente 2 avantages :

• la reproductibilité de vos programmes (science ouverte) : l’environnement virtuel contient une photographie de la configuration utilisée
• la gestion des dépendances : l’installation de multiples modules peut engendrer des conflits de version

Dans cette formation nous avons fait le choix d’utiliser UV. Dans la logique de cet outil, vous pouvez créer un projet UV pour chacun de vos projets : un dossier est alors créé, avec une structure standard qui peut sembler un peu compliquée de prime abord mais reste facilement compréhensible.

Dans ce dossier projet, un environnement virtuel est créé automatiquement : si vous installez un module python dans votre projet, par exemple le module matplotlib pour créer des graphiques, il sera installé uniquement dans cet environnement. L’intérêt est de pouvoir installer différentes versions du même module pour différents projets, selon vos besoins, sans créer de conflits de version.

Afin d’éviter d’occuper trop d’espace sur votre disque, si vous installez la même version d’un module dans 2 projets différents, il ne sera stocké qu’une seule fois sur votre disque, et les 2 projets pointeront vers ce même module.

Il est tout à fait possible de ne pas utiliser ces fonctionnalités et de ne pas créer de projets UV, c’est ce que nous allons faire dans un premier temps. Cela reste néanmoins une bonne pratique et sera abordé un peu plus loin dans les cas d’application.

Présentation générale

Python est un langage de programmation (comme C, C++ ou Java) : un ensemble de termes et de règles permettant de créer des instructions.

Il peut être utilisé dans de nombreux domaines :

• calculatrice avancée : manipulation de nombres, calcul scientifique
• scripts (traitement par lot de fichiers, communication avec des APIs, domotique, webscraping)
• développement logiciel : création de sites web, APIs, gestion de bases de données, etc.
• science des données : apprentissage automatique, visualisation de données, etc.
• et plein d’autres choses encore…

Quelques particularités :

• langage interprété : pas de compilation manuelle du code (comme le make en C)
• indentation : permet d’améliorer la lisibilité du code (moins de symboles)
• typage dynamique : pas besoin de préciser le type de vos variables (mais ça reste possible !)

Syntaxe générale

• Pour commenter une ligne : #
• Pour importer un module (plus de détail sur la définition d’un module ici : https://docs.python.org/fr/3/tutorial/modules.html):
  • import mon_module
  • import mon_module_trop_trop_long as ml pour utiliser un alias
  • from mon_module import sous_module ou import mon_module.sous_module pour importer un sous-module
  • from mon_module import fonction1, fonction2 pour importer directement des fonctions précises
• Créer une variable (i.e. assigner une valeur ou un objet à un nom) :
  • ma_variable = 1
  • ma_variable = 'test'
  • ma_variable = [0, 2, 4]
  • ma_variable = ma_variable_1
• L’interpréteur est sensible à la casse : ma_variable ≠ MA_VARIABLE
• Appeler une fonction : ma_fonction(ma_variable_1, ma_variable_2)
• Tests logiques :
  • ma_variable == 1, ma_variable >= 1, ma_variable != 'foo'
  • a = True, b = False, a or b, a and b, a, not b
  • valeur in [1, 'foo', 3.14]

Indentation :

• l’indentation est utilisée pour délimiter des blocs de code (fonctions, boucles, classes, etc.)
• l’indentation peut se faire au moyen d’espaces ou de tabulations. La PEP8 privilégie l’utilisation des espaces (4).

# blocs de code
ma_variable = 0
for i in range(4):
    ma_variable += 1

if ma_variable == 4:
    print('OK')
else:
    print('NOK')

## OK

Variables

Les variables sont la nourriture favorite des pythons ! Mais qu’est-ce qu’une variable ? C’est simplement un objet ou une valeur auquel on donne un nom, pour pouvoir l’appeler plus facilement.

Par exemple, on peut créer une variable nommée jour à laquelle on donne la valeur ‘jeudi’ :

jour = 'jeudi'

Notez que le nom d’une variable (jour) ne sera jamais entre guillemets ! Sa valeur (‘jeudi’) est entre guillemets car il s’agit d’une chaîne de caractères. Vous pouvez utiliser indifféremment les guillemets simples ou doubles !

jour = "jeudi"

Si on tape le nom de cette variable, sa valeur est renvoyée :

jour

## 'jeudi'

Une variable peut contenir tout type d’objet : chaîne de caractères (string) comme ici, nombre, liste de valeurs, dictionnaire… A noter, le langage Python n’est pas typé : une même variable pourra changer de type.

jour = 4
jour

## 4

Types de variables simples : chaîne de caractères et nombres

"aujourd'hui on est " + "jeudi"

## "aujourd'hui on est jeudi"

'---' * 10

## '------------------------------'

langage = 'python'
langage[0]
## 'p'
langage[2:6] # attention, le dernier index n'est pas inclus !
## 'thon'

langage = 'python'
langage.upper()

## 'PYTHON'

2 + 2 # les espaces servent uniquement pour la lisibilité, ils sont facultatifs

## 4

nombre = 4

nombre**2

## 16

nb = 4
type(nb)

## <class 'int'>

nb = 4.2
type(nb)

## <class 'float'>

nb = 1e6
nb

## 1000000.0

type(nb)

## <class 'float'>

10 > 4

## True

'10' > '4' # les chaînes de caractères sont classées dans l'ordre alphabétique

## False

Structures de données

villes = ['Nantes', 'Rennes', 'Brest']

villes[0]

villes[2] # renvoie la 3ème valeur
## 'Brest'
villes[-1] # renvoie la dernière valeur
## 'Brest'

villes.append('Nouméa')
villes # pour voir le résultat

sorted(villes)
villes # la liste n'a pas été modifiée
villes.sort()
villes # la liste a été modifiée

villes[2] = 'Dublin' # si la liste a été classée, Nouméa est le 3ème élément de la liste (indice 2)
villes

# en appelant l'élément par sa valeur
villes.remove('Dublin')
villes
# on réinitialise la liste
villes = ['Brest', 'Nantes', 'Dublin', 'Rennes']
# en appelant l'élément par son index
villes.pop(2) # cette fonction renvoie la valeur supprimée
villes

pause = {'chouquettes' : 25, 'croissants' : 12, 'pains au chocolat' : 12}

pause['chouquettes']

pause['cafés'] = 15
pause

pause.keys()

del(pause['pains au chocolat'])
pause

pause['cafés'] = 3
pause

print('Actuellement, il reste : ')
for key, value in pause.items():
  print (value, key)

Structures de contrôle

Structure conditionnelle : if, elif, else

a = 12
if a == 0:
    print("Nul !")
elif a < 10:
    print("À revoir")
elif a < 15 and a >= 10:
    print("Correct")
else:
    print("Très bien")

## Correct

À retenir :

• les : à la fin des conditions
• l’indentation pour chaque bloc conditionnel
• les conditions elif et else ne sont pas obligatoires

Structure itérative : for

Syntaxe générique : for item in iterable

Un iterable en Python est un objet dont on peut parcourir les valeurs, exemple : str, tuple, list, dict et set.

Exemple :

villes = ['Nantes', 'Rennes', 'Brest']
for ville in villes:
    print (ville)

## Nantes
## Rennes
## Brest

Dans l’exemple ci-dessus, ville va prendre successivement toutes les valeurs de la liste villes. La boucle for sera donc parcourue 3 fois.

Autre cas : la boucle while

Syntaxe générique :

while condition is not False:
    # Exécution du code qui suit

Exemple :

i = 0
while i < 10:
    i = i + 1
    print(i)

## 1
## 2
## 3
## 4
## 5
## 6
## 7
## 8
## 9
## 10

Exercices d’application sur les structures de contrôle

pause = {'chouquettes' : 25, 'croissants' : 12, 'pains au chocolat' : 12}

Utilisez une boucle if/else qui indique s’il y a plus de croissants, plus de pains au chocolat, ou bien autant de chaque :

if pause['croissants'] > pause['pains au chocolat']:
    print ('plus de croissants que de pains au choc')
elif pause['pains au chocolat'] > pause['croissants']:
    print ('plus de pains au choc que de croissants')
else:
    print ('autant de chaque !')

10 personnes ont chacune mangé une chouquette, un croissant et un pain au chocolat. Mettez à jour le dictionnaire en utilisant une boucle for pour enlever 10 à chacune des valeurs.

for key, value in pause.items():
  pause[key] = value - 10
pause

On crée une nouvelle variable participants (et on réinitialise pause) :

pause = {'chouquettes' : 25, 'cafés' : 15}
participants = ['Alice', 'Bob', 'Carole']

Chacun des participants mange 2 chouquettes et boit un café. Mettez à jour le dictionnaire pause grâce à une boucle for sur la liste participants.

for i in participants:
  #print (i) # décommentez pour afficher i
  pause['chouquettes'] = pause['chouquettes'] - 2
  pause['cafés'] = pause['cafés'] - 1
pause

Utilisez une boucle while pour enlever 1 au nombre de cafés, jusqu’à ce que ce nombre arrive à 0, en affichant à chaque fois le nombre de cafés restant. Quand ce nombre tombe à 0 (= en sortant de la boucle), affichez un message indiquant qu’il ne reste plus de café.

while pause['cafés'] > 0:
  print ('Il reste ' + str(pause['cafés']) + ' café(s)')
  pause['cafés'] = pause['cafés'] - 1
print ('Désolé, plus de café !')

Erreurs

Si l’interpréteur observe une erreur de syntaxe ou un problème quelconque dans l’exécution du code, il lève une exception. Quelques exemples :

• SyntaxError: invalid syntax
• FileNotFoundError: [Errno 2] No such file or directory: 'mes_donnees.csv'
• ZeroDivisionError: division by zero

  File "<stdin>", line 1
    if True print('Hello world')
                ^
SyntaxError: invalid syntax

pause['thé']

cle = 'thé'
try:
    pause[cle]
    print ('oui, il y a bien du ' + cle)
except KeyError:
    print ('désolé, pas de ' + cle)

Modules utiles

Un module Python est un fichier contenant un ensemble de définitions (fonctions, classes) que vous pouvez importer dans votre propre programme. Vous pouvez créer vos propres modules, ou bien utiliser des modules provenant de la communauté (organisés en paquets).

Voici quelques modules fréquemment utiles:

• sys et os pour interagir avec l’interpréteur et le système d’exploitation
• glob pour parcourir des dossiers et lister des fichiers
• math pour des fonctions mathématiques (cos(), sqrt(), pi)
• datetime pour la manipulation de dates, timestamps, etc

Pour manipuler des données :

• csv, json pour manipuler des fichiers excel ou json
• pandas pour manipuler des données tabulaires
• matplotlib, seaborn, plotly (et beaucoup d’autres) pour créer des graphiques

# avec un graphique basique
import matplotlib.pyplot as plt
x = [1, 2, 3]
y = [2, 4, 1]
plt.plot(x, y)

Science des données :

• numpy : calcul numérique, manipulation de matrices
• scipy : calcul scientifique (traitement du signal, statistiques, analyse numérique, etc.)
• scikit-learn : machine learning

Pour la suite de la formation, vous aurez besoin des modules suivants (ils sont déjà installés normalement, vous n’avez plus qu’à les importer) :

import pandas as pd
import numpy as np
import os
import shutil
import plotly.express as px
import plotly.io as pio

Bonnes pratiques !

• Privilégier l’encodage UTF-8 pour vos scripts/programmes
• Documenter votre code (pour vous et pour les autres) : commentaires, métadonnées, README
• Afficher les étapes intermédiaires (print(), logging) pour faciliter le déboggage
• PEP8, conventions pour l’écriture de code Python : https://peps.python.org/pep-0008/

Chercher des informations et/ou de l’aide :

• Dans Python, pour de l’aide sur une fonction ou un module : help(print)…
• …et pour obtenir de l’aide sur une méthode : help('a'.upper) (en savoir plus sur la différence entre fonction et méthode)
• Le web est ton ami : trouver un paquet/module adapté, chercher de la documentation
• StackOverflow : formuler son problème, fournir un exemple

Présentation

Installation

Il vous faudra tout d’abord installer le module pandas. Avec UV, on utilise la commande uv add nom_du_module :

foo@bar:~$ uv add pandas
foo@bar:~$

Cette commande ne doit être exécutée qu’une seule fois si comme ici on ne travaille pas dans un environnement virtuel. Si on installe un module dans un environnement virtuel, comme on va le faire pour les cas d’application, il faudra à nouveau l’installer si on change d’environnement.

Import

Vous avez installé le module pandas, mais il n’est pas activé, ou importé dans la terminologie python. On l’importe habituellement ainsi :

import pandas as pd

Introduction

Pandas repose sur la manipulation de tableaux et listes appelés DataFrame ou Series.

Exemple :

import pandas as pd
df = pd.DataFrame({'nom': ['Bob', 'Alice', 'Paul', 'Sarah', 'Junior'], 
                    'age': [24, 32, 40, 26, 16], 
                    'sexe': ['M', 'F', 'M', 'F', 'M']})
df.head()

##       nom  age sexe
## 0     Bob   24    M
## 1   Alice   32    F
## 2    Paul   40    M
## 3   Sarah   26    F
## 4  Junior   16    M

On peut obtenir le nombre de lignes avec :

df.shape[0] 
# ou encore :
## 5
len(df)
## 5

Et le nombre de colonnes :

df.shape[1]

## 3

Accéder aux valeurs

Par nom de colonne:

• df.nom ou df['nom'] : renvoie un objet de type Series

Par numéro de ligne/colonne:

• df.iloc[0] : renvoie la première ligne
• df.iloc[:, 0] : toutes les lignes, première colonne

Par indice:

• df.loc[0, 'age'] : renvoie la valeur age de la première ligne

Sélection conditionnelle : df.loc[df.age >= 30]

Tri

df.sort_values(by='age', ascending=False)

##       nom  age sexe
## 2    Paul   40    M
## 1   Alice   32    F
## 3   Sarah   26    F
## 0     Bob   24    M
## 4  Junior   16    M

df.sort_values(by=['age', 'nom'])

##       nom  age sexe
## 4  Junior   16    M
## 0     Bob   24    M
## 3   Sarah   26    F
## 1   Alice   32    F
## 2    Paul   40    M

Créer des valeurs

Création d’une nouvelle colonne :

df['majeur'] = True # toutes les lignes auront la même valeur
print (df)

##       nom  age sexe  majeur
## 0     Bob   24    M    True
## 1   Alice   32    F    True
## 2    Paul   40    M    True
## 3   Sarah   26    F    True
## 4  Junior   16    M    True

Création d’une colonne basée sur une condition :

# 2 méthodes :
df['majeur'] = np.where(df['age'] > 18, True, False)
df['majeur'] = df.apply(lambda row: row.age > 18, axis=1)

Opération d’aggrégation

• Nombre de femmes et d’hommes dans l’échantillon :

df.groupby('sexe')['nom'].count()

## sexe
## F    2
## M    3
## Name: nom, dtype: int64

• Âge minimal :

df.groupby('sexe')['age'].min()

## sexe
## F    26
## M    16
## Name: age, dtype: int64

Lire/Écrire des fichiers

Lire un fichier CSV :

data = pd.read_csv("mon_fichier.csv") 

Le séparateur par défaut est la virgule, sinon il faut le préciser avec l’argument sep : pd.read_csv("mon_fichier.csv", sep = ';') par exemple.

Écrire dans un fichier CSV :

df.to_csv("mes_resultats.csv")

Exercice 1 : avec un dataframe simple

pizzas = pd.DataFrame({'nom': ['margarita', '4 saisons', 'napolitaine'], 'nb ingrédients': [1, 4, 5], 'prix': [8, 12, 10]})
pizzas

##            nom  nb ingrédients  prix
## 0    margarita               1     8
## 1    4 saisons               4    12
## 2  napolitaine               5    10

Affichez la colonne prix (en l’appelant par son nom) :

pizzas['prix']
# ou bien : pizzas.prix

Affichez la première colonne (en l’appelant par sa position) :

pizzas.iloc[:, 0]

Affichez la deuxième ligne du tableau :

pizzas.iloc[1]

Affichez le prix d’une pizza napolitaine :

pizzas.loc[pizzas['nom'] == 'napolitaine', 'prix']

Affichez toutes les lignes des pizzas dont le prix est inférieur à 11€ :

pizzas.loc[pizzas['prix'] < 11]

Classez les lignes du tableau par prix croissant :

pizzas.sort_values(by = 'prix')

Exercice 2 : à partir d’un CSV

Pour cet exercice, nous utiliserons un fichier sur le prix des carburants en France au 6 février 2023, téléchargé sur data.economie.gouv

Vous pouvez télécharger le fichier ici (ou bien directement sur le site data.economie.gouv, dans ce cas vous aurez une version plus à jour et des résultats légèrement différents).

Pour lire ce fichier dans un dataframe :

# par défaut, le séparateur est la virgule, ici c'est un point-virgule, il faut donc le spécifier
# il faut aussi adapter le chemin vers le CSV !
carb = pd.read_csv('../Exo_dataframe/prix-carburants-2023-02-06.csv', sep = ';')

Pour voir les noms de colonnes (il y a d’autres méthodes !) :

carb.keys()
# ou de manière plus lisible :
for key in carb.keys():
  print (key)

Et pour voir le nombre de lignes :

len(carb)

Pour voir les valeurs manquantes :

# isna indique pour chaque valeur si elle est manquante (True) ou non (False)
carb.isna()
# c'est plus utile en regardant par exemple le nombre de valeurs manquantes par colonne
carb.isna().sum()

Pour voir les valeurs uniques dans une colonne, par exemple Automate 24-24 (oui/non), avec la méthode unique() :

carb['Automate 24-24 (oui/non)'].unique()
# Ou de manière un peu plus lisible :
for val in carb['Automate 24-24 (oui/non)'].unique():
  print (val)

On peut également compter les occurrences de chaque valeur unique avec value_counts() :

carb['Automate 24-24 (oui/non)'].value_counts()

Pour voir les prix par ordre croissant, en ne gardant que les colonnes commune et département :

carb.loc[:, ['Nom Officiel Commune', 'Nom Officiel Département', 'prix_valeur']].sort_values(by = 'prix_valeur')

En filtrant par code département pour ne garder que les résultats dans le Finistère :

carb.loc[carb['Code Officiel Département'] == '29', ['Nom Officiel Commune', 'Nom Officiel Département', 'prix_valeur']].sort_values(by = 'prix_valeur')

Pour afficher le prix moyen par département :

carb.groupby('Nom Officiel Département')['prix_valeur'].mean()

En classant du moins cher au plus cher :

carb.groupby('Nom Officiel Département')['prix_valeur'].mean().sort_values(ascending = True)

Choix d’un module de visualisation de données

L’objectif sera ici de produire des graphiques à partir d’un jeu de données sur les festivals ayant eu lieu en France en 2019.

Il existe de nombreux modules Python dédiés à la visualisation de données.

matplotlib est probablement le plus connu et le plus utilisé. Il permet de créer des graphiques facilement, mais pour une personnalisation un peu poussée il faudra un certain nombre de lignes de code. Cependant, une fois la logique acquise, tout est possible ! Les graphiques peuvent être exportés au format vectoriel (SVG, PDF) pour être modifiés dans un logiciel de dessin, ou bien au format image (JPG, PNG…).

plotly est une librairie qui existe pour de nombreux langages : R, JavaScript, Julia, Matlab… et bien sûr Python ! On peut l’utiliser pour créer des graphiques interactifs au format HTML, qui pourront être intégrés dans une page internet, ou bien statiques, au format vectoriel ou image. plotly.express est une “surcouche” pour plotly, son objectif étant de pouvoir créer des graphiques de la manière la plus simple possible, et s’interface bien avec pandas. C’est ce que nous allons utiliser ici.

Installation et import

import plotly.express as px

Si le module n’est pas installé, dans un terminal (powershell pour windows) :

uv add plotly

Plotly peut produire des graphiques interactifs ou statiques, à vous de choisir !

import plotly.io as pio
pio.renderers.default = 'svg' # pour ouvrir les figures dans spyder (statique)
pio.renderers.default = 'browser' # pour ouvrir les figures dans le navigateur (interactif)

Pour voir les graphiques dans Spyder, le module kaleido sera également nécessaire. Installez-le si ça n’est pas déjà fait et importez-le :

import kaleido

Lecture des données dans un dataframe

Ce jeu de données est disponible sur data.gouv.fr.

Téléchargez le fichier au format CSV et sauvegardez-le sur votre ordinateur. Lisez-le dans un dataframe pandas avec la fonction pandas read_csv.

Une fois le dataframe créé, la méthode head() doit vous renvoyer ceci :

fest.head() # ici, le dataframe se nomme fest

##                nom_du_festival  ... identifiant_cnm
## 0         Festival Tête en L’R  ...             NaN
## 1  Les journées de l'éloquence  ...             NaN
## 2  Ma ville est un grand livre  ...             NaN
## 3    Albertville jazz festival  ...             NaN
## 4                 Les Odyssées  ...             NaN
## 
## [5 rows x 30 columns]

Et si vous avez oublié…

path = '../Exo_graphiques/festivals-global-festivals-_-pl.csv'
fest = pd.read_csv(path, sep = ';')
fest.head()

Première exploration des données

Regardez la liste des en-tête de colonnes avec la méthode keys(), ainsi que le nombre de lignes avec len() ou shape.

Regardez également le nombre de valeurs manquantes pour chaque colonne en combinant les fonctions isna() et sum().

print ('colonnes : ')
for key in fest.keys():
  print (key)

print ('nb lignes : ')
len(fest)

print ('Nb valeurs manquantes par colonne : ')
fest.isna().sum()

Premier graphique : histogramme des catégories

Nous allons ici nous intéresser à la colonne discipline_dominante pour voir la distribution des différentes disciplines grâce à un graphique.

Pour information, vous pouvez regarder au préalable le nombre d’occurrences de chaque valeur unique dans la colonne discipline_dominante avec la méthode value_counts() :

## discipline_dominante
## Musique                          3228
## Spectacle vivant                 1633
## Livre, littérature                892
## Cinéma, audiovisuel               685
## Pluridisciplinaire                462
## Arts visuels, arts numériques     382
## Name: count, dtype: int64

Comment créer l’histogramme correspondant ?