Introduction aux modules Python

Un module. Tu ne sais pas ce que c'est ? Et pourtant tu en as déjà utilisé plusieurs. Voyons de quoi il s'agit à travers cette quête

Objectifs

✅ Comprendre l'intérêt des modules ✅ Apprendre à créer des modules

Sommaire

Introduction

En tant que futur data analyst, vous allez souvent travailler avec des données complexes et effectuer des opérations répétitives. Les modules Python sont des outils essentiels qui vous permettront d'optimiser votre travail et d'étendre les capacités de base de Python. Dans ce cours, nous allons explorer ce que sont les modules, pourquoi ils sont utiles, et comment les utiliser efficacement dans vos projets d'analyse de données.

Qu'est-ce qu'un module ?

Un module en Python est simplement un fichier contenant du code Python. Il peut inclure des fonctions, des classes et des variables que vous pouvez utiliser dans vos propres scripts. Par exemple, la fonction print() que vous utilisez fréquemment fait partie du module standard de Python.

Pourquoi utiliser des modules ?

1. Réutilisation du code : Évitez de réécrire le même code en utilisant des fonctions pré-écrites.
2. Organisation : Gardez votre code propre et organisé en séparant les fonctionnalités.
3. Fonctionnalités avancées : Accédez à des fonctionnalités puissantes sans avoir à les coder vous-même.
4. Maintenance facilitée : Mettez à jour une seule fois le code dans le module pour l'actualiser partout.
5. Collaboration : Partagez facilement des fonctionnalités avec d'autres développeurs.

Modules standards vs modules externes

Modules standards

Python vient avec une bibliothèque standard riche en modules prêts à l'emploi. Ces modules sont disponibles dès l'installation de Python et couvrent de nombreuses fonctionnalités de base.

Exemples de modules standards utiles pour les data analysts débutants :

1. Module math :

   python

   import math
   
   # Variables
   print(math.pi)  # 3.141592653589793
   print(math.e)   # 2.718281828459045
   
   # Fonctions
   print(math.sqrt(16))  # 4.0
   print(math.log(100, 10))  # 2.0
   print(math.sin(math.pi/2))  # 1.0
   

2. Module random :

   python

   import random
   
   # Fonctions
   print(random.randint(1, 10))  # Nombre aléatoire entre 1 et 10
   print(random.choice(['pomme', 'banane', 'cerise']))  # Choix aléatoire
   print(random.sample(range(100), 5))  # 5 nombres uniques entre 0 et 99
   

3. Module datetime :

   python

   from datetime import datetime, timedelta
   
   # Variables
   now = datetime.now()
   print(now)  # Date et heure actuelles
   
   # Fonctions
   future_date = now + timedelta(days=7)
   print(future_date)  # Date dans 7 jours
   

4. Module statistics :

   python

   import statistics
   
   data = [1, 2, 2, 3, 3, 3, 4, 4, 5]
   
   # Fonctions
   print(statistics.mean(data))    # 3.0
   print(statistics.median(data))  # 3
   print(statistics.mode(data))    # 3
   print(statistics.stdev(data))   # 1.2247448713915889
   

Modules externes

Ce sont des modules créés par la communauté Python pour des besoins spécifiques. Ils doivent être installés séparément.

Exemples de modules externes populaires (que vous découvrirez plus tard) :

• pandas : manipulation et analyse de données
• numpy : calculs numériques avancés
• matplotlib : création de graphiques

Comment utiliser un module

Pour utiliser un module, vous devez d'abord l'importer dans votre script. Il existe plusieurs façons de le faire :

1. Importer tout le module :

   python

   import math
   
   result = math.sqrt(16)  # Utilise la fonction sqrt du module math
   

2. Importer une fonction spécifique :

   python

   from math import sqrt
   
   result = sqrt(16)  # Utilise directement la fonction sqrt
   

3. Importer tout avec un alias :

   python

   import math as m
   
   result = m.sqrt(16)  # Utilise l'alias m au lieu de math
   

4. Importer plusieurs éléments :

   python

   from math import sqrt, pi, sin
   
   result = sqrt(16)
   angle = sin(pi/2)
   

Création de votre propre module

Créer votre propre module est simple :

1. Créez un fichier Python (par exemple mon_module.py)
2. Écrivez vos fonctions et variables dans ce fichier
3. Importez-le dans votre script principal

Exemple de module personnalisé (mon_module.py) :

# Variables
PI = 3.14159
GRAVITY = 9.81

def carre(x):
    return x ** 2

def cube(x):
    return x ** 3

def factorielle(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorielle(n-1)

def aire_cercle(rayon):
    return PI * rayon ** 2

def energie_cinetique(masse, vitesse):
    return 0.5 * masse * vitesse ** 2

Utilisation dans votre script principal :

import mon_module

print(mon_module.PI)  # 3.14159
print(mon_module.carre(5))  # 25
print(mon_module.aire_cercle(3))  # 28.27431
print(mon_module.energie_cinetique(2, 10))  # 100.0

Exemples étendus de fonctions et variables pour les data analysts

Voici des exemples plus complets de fonctions et variables que vous pourriez inclure dans votre propre module pour l'analyse de données :

# Variables globales utiles
JOURS_SEMAINE = ['Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi', 'Dimanche']
MOIS_ANNEE = ['Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin', 'Juillet', 'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre']

def moyenne(liste):
    return sum(liste) / len(liste)

def mediane(liste):
    liste_triee = sorted(liste)
    n = len(liste_triee)
    if n % 2 == 0:
        return (liste_triee[n//2 - 1] + liste_triee[n//2]) / 2
    else:
        return liste_triee[n//2]

def ecart_type(liste):
    moy = moyenne(liste)
    variance = sum((x - moy) ** 2 for x in liste) / len(liste)
    return variance ** 0.5

def nettoyer_donnees(liste):
    return [x for x in liste if x is not None and x != ""]

def compter_occurrences(liste):
    return {x: liste.count(x) for x in set(liste)}

def normaliser(liste):
    min_val = min(liste)
    max_val = max(liste)
    return [(x - min_val) / (max_val - min_val) for x in liste]

def taux_croissance(valeur_initiale, valeur_finale):
    return (valeur_finale - valeur_initiale) / valeur_initiale * 100

def frequence_relative(liste):
    occurrences = compter_occurrences(liste)
    total = len(liste)
    return {k: v / total for k, v in occurrences.items()}

def outliers_zscore(liste, seuil=3):
    moy = moyenne(liste)
    ec = ecart_type(liste)
    return [x for x in liste if abs((x - moy) / ec) > seuil]

def trouver_mode(liste):
    occurrences = compter_occurrences(liste)
    return max(occurrences, key=occurrences.get)

def arrondir_liste(liste, decimales=2):
    return [round(x, decimales) for x in liste]

Exemples d'utilisation de ces fonctions :

# Imaginons que nous avons des données de ventes mensuelles
ventes = [1000, 1200, 950, 1100, 1300, 1050, 1150, 1250, 1100, 1200, 1300, 1400]

print(f"Ventes moyennes : {moyenne(ventes)}")
print(f"Ventes médianes : {mediane(ventes)}")
print(f"Écart-type des ventes : {ecart_type(ventes)}")

ventes_normalisees = normaliser(ventes)
print(f"Ventes normalisées : {arrondir_liste(ventes_normalisees)}")

croissance_annuelle = taux_croissance(ventes[0], ventes[-1])
print(f"Taux de croissance annuel : {croissance_annuelle:.2f}%")

mois_plus_ventes = MOIS_ANNEE[ventes.index(max(ventes))]
print(f"Mois avec le plus de ventes : {mois_plus_ventes}")

# Imaginons des données avec des valeurs manquantes
donnees_brutes = [100, None, 150, "", 200, 180, None, 220]
donnees_nettoyees = nettoyer_donnees(donnees_brutes)
print(f"Données nettoyées : {donnees_nettoyees}")

# Analyse de fréquence
categories = ['A', 'B', 'A', 'C', 'B', 'A', 'A', 'C', 'B', 'A']
freq = frequence_relative(categories)
print(f"Fréquence relative des catégories : {freq}")
print(f"Catégorie la plus fréquente : {trouver_mode(categories)}")

Chargement de fichiers dans Google Colab

Pour travailler avec vos propres modules dans Google Colab, vous pouvez suivre ces étapes :

1. Importez le module files de Google Colab :

   python

   from google.colab import files
   

2. Utilisez la fonction upload() pour charger votre fichier :

   python

   uploaded = files.upload()
   

3. Une fois le fichier chargé, vous pouvez l'importer comme un module normal :

   python

   import mon_module
   

Ou alors, vous pouvez charger votre Google Drive et y avoir accès directement.

Challenge

Clique sur le lien ci-dessous et réalise les exercices. N'oublie pas de faire une copie du google colab sur ton propre Drive avant de commencer les exercices Introduction aux modules Python

Critères de validation

• Le fichier en lien est consultable et en lecture
• Toutes les missions sont codées correctement et testées

Une solution ici