Aller au contenu
Programmation Python pour la science des données · L2

Leçon 1 sur 5

Rappels de Python : types, fonctions et modules

Je sais choisir le bon type de données Python, écrire des fonctions réutilisables et organiser mon code en modules pour préparer une analyse de données.

  • 1 h 15
  • 6 exercices corrigés
  • QCM de 7 questions

À la fin de la leçon, vous saurez :

  • Distinguer les types de base et les conteneurs (liste, tuple, dictionnaire, ensemble) et leur mutabilité
  • Parcourir et transformer des données avec des boucles et des compréhensions
  • Écrire des fonctions avec paramètres par défaut, valeurs de retour et docstring
  • Importer et créer des modules, et installer des bibliothèques dans un environnement virtuel

Avant de commencer : Cours d'algorithmique et de programmation de L1 (variables, conditions, boucles).

1Je découvre

Mariama est en stage chez Kalan Distribution, un grossiste en denrées (riz, huile, sucre) qui possède des dépôts à Conakry, Kindia, Labé, Kankan et N'Zérékoré. Chaque soir, les chefs de dépôt envoient leurs ventes du jour. Jusqu'ici, la comptable recopiait tout dans un tableur et refaisait les additions à la main ; les erreurs de recopie étaient fréquentes.

La directrice demande à Mariama un petit programme qui calcule automatiquement le chiffre d'affaires par dépôt. Mariama a appris Python en L1, mais ses programmes tenaient en un seul fichier, sans fonctions, avec des variables appelées a, b et x. Cette fois, le code sera relu, réutilisé et enrichi tout au long du semestre : il doit être clair et bien organisé.

Quels types, quelles fonctions et quelle organisation en modules faut-il maîtriser pour écrire en Python un code d'analyse de données fiable et réutilisable ?

2Je comprends

1. Les types de base

En Python, toute valeur a un type, que l'on obtient avec type(). Le typage est dynamique : une variable n'a pas de type fixé à l'avance, c'est la valeur qu'elle désigne qui en a un.

TypeExempleUsage en analyse de données
int (entier)120effectifs, nombres de sacs
float (réel)3.5prix moyens, mesures, taux
str (chaîne)"Kindia"noms de villes, de produits
bool (booléen)True, Falserésultat d'une condition, filtres
NoneTypeNoneabsence de valeur

Quelques points à connaître :

  • 7 / 2 donne 3.5 (toujours un float) ; 7 // 2 donne 3 (division entière) ; 7 % 2 donne 1 (reste).
  • Les réels sont stockés en binaire avec une précision limitée : 0.1 + 0.2 == 0.3 vaut False. On compare des réels avec une tolérance : abs(a - b) < 1e-9, ou math.isclose(a, b).
  • Les conversions sont explicites : int("45") donne 45 ; float("3,5") provoque une erreur, car Python attend un point décimal. Il faut d'abord écrire "3,5".replace(",", ".").

2. Les conteneurs et la mutabilité

ConteneurÉcritureOrdonnéModifiableDoublons
liste list[120, 45, 30]ouiouioui
tuple tuple("Labé", 60)ouinonoui
dictionnaire dict{"ville": "Labé", "sacs": 60}oui (ordre d'insertion)ouiclés uniques
ensemble set{"riz", "huile"}nonouinon

Un objet mutable (liste, dictionnaire, ensemble) peut être modifié sur place. Une affectation b = a ne copie pas l'objet : elle crée un second nom pour le même objet.

a = [1, 2, 3]
b = a          # b et a désignent la même liste
b.append(4)
print(a)       # [1, 2, 3, 4]
c = a.copy()   # vraie copie (superficielle)

Pour Kalan Distribution, une vente est naturellement un dictionnaire, et le relevé du jour une liste de dictionnaires (prix d'exemple, en GNF par sac) :

ventes = [
    {"ville": "Conakry", "produit": "riz", "sacs": 120, "prix": 350000},
    {"ville": "Kindia", "produit": "riz", "sacs": 45, "prix": 360000},
    {"ville": "Conakry", "produit": "huile", "sacs": 30, "prix": 410000},
    {"ville": "Labé", "produit": "riz", "sacs": 60, "prix": 375000},
]

3. Parcourir et transformer : boucles et compréhensions

Une compréhension construit un conteneur en une ligne à partir d'un autre :

villes = sorted({v["ville"] for v in ventes})        # ensemble, puis liste triée
gros = [v["ville"] for v in ventes if v["sacs"] >= 50]

villes vaut ['Conakry', 'Kindia', 'Labé'] (sans doublon) et gros vaut ['Conakry', 'Labé'].

Pour cumuler par catégorie, on utilise un dictionnaire et la méthode get, qui renvoie une valeur par défaut si la clé n'existe pas encore :

Exemple

Calculer le chiffre d'affaires par ville.

Étape 1 : montant d'une vente = sacs × prix.

Conakry riz : 120 × 350 000 = 42 000 000 GNF ; Conakry huile : 30 × 410 000 = 12 300 000 GNF.

Kindia : 45 × 360 000 = 16 200 000 GNF ; Labé : 60 × 375 000 = 22 500 000 GNF.

Étape 2 : code.

par_ville = {}

for v in ventes:

par_ville[v["ville"]] = par_ville.get(v["ville"], 0) + v["sacs"] * v["prix"]

Étape 3 : résultat.

{'Conakry': 54300000, 'Kindia': 16200000, 'Labé': 22500000}

Contrôle : 54 300 000 + 16 200 000 + 22 500 000 = 93 000 000 GNF, total général.

4. Écrire des fonctions

Une fonction donne un nom à un traitement, le rend testable et évite de copier-coller du code.

def montant(vente, remise=0.0):
    """Renvoie le montant en GNF d'une vente, après une remise éventuelle (entre 0 et 1)."""
    brut = vente["sacs"] * vente["prix"]
    return round(brut * (1 - remise))
  • remise=0.0 est un paramètre par défaut : montant(v) et montant(v, remise=0.05) sont deux appels valides.
  • La docstring (chaîne entre triples guillemets) documente la fonction ; help(montant) l'affiche.
  • return renvoie le résultat ; une fonction sans return renvoie None.
  • Les variables créées dans la fonction sont locales : elles n'existent pas à l'extérieur.

Une fonction pure (même entrée, même sortie, aucune modification de ses arguments) est plus facile à tester. Le piège classique est la valeur par défaut mutable :

def ajouter(x, liste=[]):   # À ÉVITER
    liste.append(x)
    return liste

La liste par défaut est créée une seule fois, à la définition : ajouter(1) puis ajouter(2) renvoient tous deux [1, 2]. On écrit plutôt liste=None, puis if liste is None: liste = [] dans le corps de la fonction.

Méthode

Écrire une bonne fonction d'analyse :

  1. Lui donner un nom qui dit ce qu'elle calcule (verbe ou nom explicite).
  2. Lister ses entrées (paramètres) et sa sortie (valeur renvoyée).
  3. Écrire la docstring avant le corps.
  4. Ne pas modifier les arguments reçus ; renvoyer un nouveau résultat.
  5. La tester sur un petit cas calculé à la main.

5. Les modules et les bibliothèques

Un module est un fichier .py ; un paquet est un dossier de modules. On les utilise avec import :

import statistics
from math import isclose
import numpy as np          # alias conventionnel (leçon 2)

print(statistics.mean([120, 45, 30, 60]))    # 63.75
print(statistics.median([120, 45, 30, 60]))  # 52.5

Mariama range ses fonctions dans un fichier outils_ventes.py, puis les importe depuis ses autres scripts avec from outils_ventes import montant. Le test suivant, placé en bas du module, n'est exécuté que si l'on lance le fichier directement, pas lorsqu'on l'importe :

if __name__ == "__main__":
    print(montant({"sacs": 2, "prix": 350000}))   # 700000
BibliothèqueRôleLeçon
math, statistics, csv, datetimebibliothèque standard, toujours disponible1
numpycalcul numérique sur des tableaux2
pandastableaux de données étiquetés3 et 4
matplotlibgraphiques5
jupytercarnets interactifs5

Les bibliothèques externes s'installent avec pip, de préférence dans un environnement virtuel propre au projet, pour ne pas mélanger les versions entre projets :

python3 -m venv .venv
source .venv/bin/activate        (sous Windows : .venv\Scripts\activate)
pip install numpy pandas jupyter

3Je retiens

Je retiens

Types de base : int, float, str, bool, None ; on convertit explicitement (int(), float(), str()).

On ne compare jamais deux réels avec == : on utilise une tolérance ou math.isclose.

Liste et dictionnaire sont mutables : b = a ne copie pas, a.copy() copie.

Une liste de dictionnaires représente bien un relevé de données ligne par ligne.

Compréhensions : [expr for x in seq if condition], {…} pour un ensemble ou un dictionnaire.

Une fonction a un nom clair, une docstring, des paramètres et un return.

Jamais de valeur par défaut mutable : utiliser None.

Un module est un fichier .py ; on installe les bibliothèques avec pip dans un environnement virtuel.

4Erreurs fréquentes

  • Écrire float("3,5") : Python attend un point décimal, il faut remplacer la virgule.
  • Croire que b = a copie une liste : les deux noms désignent le même objet.
  • Utiliser une liste [] comme valeur par défaut d'un paramètre : elle est partagée entre les appels.
  • Oublier return : la fonction renvoie None et le calcul suivant échoue.
  • Nommer son fichier pandas.py ou statistics.py : il masque la vraie bibliothèque lors de l'import.
  • Installer les bibliothèques sans environnement virtuel, puis ne plus savoir quelle version le projet utilise.

5Je m’exerce

1Exercice 1

(Questions de cours) a) Donnez le type et la valeur de 7 / 2, 7 // 2 et 7 % 2. b) Citez deux conteneurs mutables et un conteneur non mutable. c) Pourquoi 0.1 + 0.2 == 0.3 vaut-il False ?

Voir le corrigéCacher le corrigé

a) 7 / 2 vaut 3.5 (float) ; 7 // 2 vaut 3 (int, division entière) ; 7 % 2 vaut 1 (int, reste). b) Mutables : liste, dictionnaire (ou ensemble). Non mutable : tuple (ou chaîne). c) 0,1 et 0,2 n'ont pas de représentation binaire exacte ; la somme vaut environ 0,30000000000000004. On compare avec une tolérance.

2Exercice 2

Qu'affiche ce code ? Justifiez.

stock = {"riz": 200, "huile": 80}
copie = stock
copie["riz"] = 150
print(stock["riz"], len(stock))
Voir le corrigéCacher le corrigé

Le code affiche 150 2. copie = stock ne crée pas de nouveau dictionnaire : copie et stock désignent le même objet, donc la modification est visible par les deux noms. Le dictionnaire a toujours 2 clés. Pour garder stock intact, il fallait écrire copie = stock.copy().

3Exercice 3

À partir de la liste ventes du cours, écrivez une compréhension qui renvoie la liste des montants (sacs × prix) des ventes de riz uniquement, puis calculez leur somme.

Voir le corrigéCacher le corrigé
montants_riz = [v["sacs"] * v["prix"] for v in ventes if v["produit"] == "riz"]
total_riz = sum(montants_riz)

montants_riz vaut [42000000, 16200000, 22500000] et total_riz vaut 80 700 000 GNF. Vérification : 42 000 000 + 16 200 000 + 22 500 000 = 80 700 000.

4Exercice 4

Écrivez une fonction nb_sacs_par_produit(ventes) qui renvoie un dictionnaire donnant le nombre total de sacs vendus par produit. Donnez le résultat sur la liste du cours.

Voir le corrigéCacher le corrigé
def nb_sacs_par_produit(ventes):
    """Renvoie un dictionnaire {produit: nombre total de sacs vendus}."""
    totaux = {}
    for v in ventes:
        totaux[v["produit"]] = totaux.get(v["produit"], 0) + v["sacs"]
    return totaux

Résultat : {'riz': 225, 'huile': 30}, car 120 + 45 + 60 = 225 sacs de riz et 30 sacs d'huile.

5Exercice 5

Corrigez la fonction suivante et expliquez le problème.

def enregistrer(vente, journal=[]):
    journal.append(vente)
    return journal
Voir le corrigéCacher le corrigé

La liste par défaut est créée une seule fois, quand Python lit la définition ; tous les appels sans second argument ajoutent donc dans la même liste, et le journal d'un appel contient les ventes des appels précédents. Correction :

def enregistrer(vente, journal=None):
    if journal is None:
        journal = []
    journal.append(vente)
    return journal

6Exercice 6

(Type examen) Kalan Distribution reçoit les prix d'un dépôt sous forme de textes : `prix = ["350000", "360 000", "", "375000"]` (une valeur manquante).

a) Écrivez une fonction convertir(texte) qui supprime les espaces et renvoie un entier, ou None si le texte est vide.

b) Appliquez-la à toute la liste avec une compréhension.

c) Écrivez une fonction moyenne_connue(valeurs) qui calcule la moyenne en ignorant les None, et donnez le résultat.

d) Indiquez dans quel module vous rangeriez ces fonctions et comment les importer depuis un autre script.

Voir le corrigéCacher le corrigé

a)

def convertir(texte):
    """Convertit un prix écrit en texte en entier ; renvoie None si vide."""
    texte = texte.replace(" ", "")
    if texte == "":
        return None
    return int(texte)

b) prix_entiers = [convertir(p) for p in prix] donne [350000, 360000, None, 375000].

c)

def moyenne_connue(valeurs):
    """Moyenne des valeurs non manquantes ; None si aucune valeur connue."""
    connues = [x for x in valeurs if x is not None]
    if not connues:
        return None
    return sum(connues) / len(connues)

Résultat : 350 000 + 360 000 + 375 0003 = 1 085 0003 ≈ 361 666,67 GNF. On teste x is not None et non if x, car une valeur 0 serait sinon ignorée à tort.

d) Dans un module outils_ventes.py, placé dans le dossier du projet. Depuis un autre script du même dossier : from outils_ventes import convertir, moyenne_connue.

Cherchez d’abord seul, sur votre cahier, puis ouvrez le corrigé pour comparer.

6Je vérifie

Choisissez une réponse pour chaque question : la correction s’affiche aussitôt.

1Que vaut type(7 / 2) ?
Voir la réponse

Réponse B : float. L'opérateur / renvoie toujours un réel ; // donne la division entière.

2Lequel de ces conteneurs n'est PAS modifiable ?
Voir la réponse

Réponse C : le tuple. Un tuple ne peut plus être modifié après sa création.

3Après a = [1, 2], b = a, b.append(3), que vaut a ?
Voir la réponse

Réponse B : [1, 2, 3]. a et b désignent la même liste.

4Quel conteneur supprime automatiquement les doublons ?
Voir la réponse

Réponse C : l'ensemble (set). Un ensemble ne contient chaque élément qu'une seule fois.

5Que renvoie une fonction qui ne contient pas d'instruction return ?
Voir la réponse

Réponse B : None. Par défaut, une fonction Python renvoie None.

6À quoi sert le test if __name__ == "__main__": ?
Voir la réponse

Réponse B : à n'exécuter un bloc que lorsque le fichier est lancé directement. À l'import, __name__ vaut le nom du module : le bloc n'est pas exécuté.

7Pourquoi travailler dans un environnement virtuel ?
Voir la réponse

Réponse B : pour isoler les bibliothèques et leurs versions propres à chaque projet. Chaque projet garde ses propres versions sans perturber les autres.

Karamö, votre enseignant

Il a lu cette leçon. Posez-lui votre question : il vous répond ici.

Connectez-vous pour poser vos questions à Karamö.

Vous avez fini la leçon ?

Avec un compte Kharandi gratuit, vous cochez les leçons terminées et vous suivez votre progression, cours par cours.

Karamö
Un point pas clair ? Dites à Karamö ce qui vous bloque dans cette leçon : il vous l’explique autrement, pas à pas, sans faire le travail à votre place. Demander à Karamö
Signaler une erreur dans cette leçon

Toutes les leçons de Programmation Python pour la science des données

Pose ta question à Karamö