Article original : Applied Data Science with Python – Business Intelligence for Developers [Full Book]

Dans le jeu à enjeux élevés de l'entreprise moderne, les données ne sont pas seulement un atout – c'est la puissance dont vous avez besoin pour distancer votre concurrence. Mais en tant que développeur, vous savez que transformer des données brutes en informations exploitables peut être une bataille frustrante.

Imaginez avoir le pouvoir de transformer sans effort des données brutes en une arme compétitive, de prédire le comportement des clients, d'optimiser les opérations et de faire progresser votre entreprise. C'est le pouvoir de la Business Intelligence, et Python est votre clé pour y accéder.

Ce livre ne traite pas seulement de Python – il s'agit de vous donner les moyens de devenir un expert en données, doté des compétences nécessaires pour rationaliser votre flux de travail, acquérir un avantage concurrentiel sur le marché du travail et devenir un atout indispensable pour votre équipe.

Je vais vous aider à acquérir les compétences pratiques et les connaissances nécessaires pour exploiter Python pour une analyse commerciale percutante. Vous commencerez par établir des bases solides dans les éléments fondamentaux de la programmation Python, en apprenant la syntaxe, les types de données, les fonctions et les structures de contrôle nécessaires pour manipuler et analyser efficacement les données.

À partir de là, vous plongerez dans les outils essentiels du métier de la donnée : Pandas, NumPy et Matplotlib. Maîtrisez ces bibliothèques standards de l'industrie pour nettoyer, transformer, analyser et visualiser efficacement les données, déverrouillant ainsi les informations et les modèles cachés dans vos jeux de données.

Mais ce livre va au-delà de la théorie. Vous appliquerez vos nouvelles compétences à des scénarios commerciaux réels grâce à des exercices pratiques et des études de cas, gagnant ainsi en confiance et en expérience pratique.

Vous explorerez les principes fondamentaux de l'analyse de données, en étudiant des techniques allant des statistiques de base et du nettoyage des données aux transformations avancées et à l'analyse exploratoire des données (EDA). Cela vous permettra de tirer des enseignements significatifs même des jeux de données les plus complexes.

Enfin, vous démontrerez votre expertise en abordant un projet complet utilisant des données de ventes réelles. Vous analyserez les segments de clientèle, identifierez les tendances clés et développerez des stratégies basées sur les données qui peuvent directement améliorer les performances de votre organisation.

À la fin de ce voyage, vous posséderez non seulement la maîtrise technique pour travailler avec les données, mais aussi la capacité de communiquer efficacement leur valeur. Vous comprendrez comment interpréter les résultats, fournir du contexte et présenter vos conclusions d'une manière qui résonne auprès des décideurs de votre entreprise.

Que vous commenciez votre carrière dans la donnée ou que vous cherchiez à perfectionner vos compétences, ce livre est votre guide indispensable. Il fournit les connaissances et les outils dont vous avez besoin pour transformer les données en stratégies commerciales exploitables, faisant de vous un atout inestimable pour votre organisation.

Voici ce que nous allons couvrir :

1. Fondamentaux de Python : Les bases pour la maîtrise des données

  • 1.1 Types de données : Vous rencontrerez une variété de types de données – nombres, chaînes de caractères, booléens, et plus encore – et comprendre comment travailler avec eux est fondamental.
  • 1.2 Variables : Les valeurs de données peuvent être stockées et manipulées à l'aide de variables, un concept clé de l'analyse de données.
  • 1.3 Fonctions : Des blocs de code réutilisables, ou fonctions, peuvent être créés pour effectuer des tâches spécifiques, rationalisant ainsi le processus d'analyse.
  • 1.4 Instructions conditionnelles et boucles : Le flux de code peut être contrôlé avec des instructions if, des boucles for et des boucles while.
  • 1.5 Fonctions en Python : Apprenez à regrouper des blocs de code réutilisables, rendant vos programmes plus organisés et efficaces.
  • 1.6 Modules et packages : Exploitez une vaste collection d'outils et de bibliothèques pré-construits qui étendent les capacités de Python pour l'analyse de données et au-delà.
  • 1.7 Gestion des erreurs : Écrivez du code capable de gérer gracieusement les problèmes inattendus, garantissant que vos programmes fonctionnent correctement même quand les choses tournent mal.

2. Bibliothèques essentielles : Votre équipe de rêve pour le Data Wrangling

2.1 Pandas :

2.2 NumPy :

2.3 Matplotlib :

  • 2.3.1 Graphiques de base : Apprenez à créer divers types de graphiques, notamment des graphiques linéaires, des nuages de points, des graphiques à barres et des histogrammes.
  • 2.3.2 Personnalisation : Les couleurs, les étiquettes et les styles peuvent être ajustés pour créer des graphiques informatifs et visuellement attrayants.

3. Exemples pratiques : De la théorie à l'action

En plus de la théorie, vous acquerrez une expérience pratique :

4. Fondamentaux de l'analyse de données : L'art de donner du sens aux données

5. Introduction au projet

6. Explication du code

7. Analyse des résultats

8. Conclusion et étapes futures

1. Fondamentaux de Python : Les bases pour la maîtrise des données

Avoir une solide maîtrise du langage de programmation Python est le socle sur lequel vos capacités d'analyse de données et de Business Intelligence seront bâties.

Ce chapitre sert de guide sur les éléments essentiels de Python, vous dotant des compétences fondamentales nécessaires pour utiliser les données comme un atout stratégique.

Ce que nous allons couvrir :

  1. Comprendre la syntaxe Python : Nous commencerons par approfondir la syntaxe fondamentale de Python, en démêlant la structure, les règles et les meilleures pratiques du langage. Vous apprendrez à écrire un code propre et lisible qui est non seulement efficace, mais aussi facile à maintenir et à collaborer.
  2. Travailler avec les données : Types et variables : Ensuite, nous explorerons le paysage diversifié des types de données et des variables, les conteneurs essentiels pour les informations avec lesquelles vous travaillerez. Des nombres et chaînes de caractères aux booléens, listes, dictionnaires et ensembles, vous acquerrez une compréhension approfondie de la manière de stocker, manipuler et extraire le sens des données.
  3. Manipuler les données avec des opérateurs : Nous porterons ensuite notre attention sur les puissants opérateurs de Python, les outils qui vous permettent d'effectuer des calculs, des comparaisons et des opérations logiques sur vos données. Vous découvrirez comment exploiter les opérateurs arithmétiques, de comparaison, logiques et d'affectation pour transformer et affiner vos données, les préparant pour une analyse approfondie.
  4. Contrôler le flux du programme : Comprendre le flux de contrôle est crucial pour créer des programmes dynamiques et réactifs. Nous explorerons les instructions conditionnelles et les boucles, les mécanismes qui vous permettent de guider l'exécution de votre code en fonction de conditions spécifiques et d'itérer efficacement sur des collections de données.
  5. Construire du code réutilisable avec des fonctions : Les fonctions sont les briques de base du code réutilisable, et nous approfondirons leur création, leur exécution et leurs applications polyvalentes. Vous apprendrez à définir des fonctions, à passer des arguments, à renvoyer des valeurs et même à créer des fonctions anonymes appelées fonctions lambda, rationalisant ainsi vos flux de travail d'analyse de données.

1.1 Syntaxe de base de Python :

Indentation : La manière unique de Python de structurer le code

En Python, l'indentation n'est pas seulement un choix stylistique – c'est un aspect fondamental de la syntaxe du langage.

Contrairement à des langages comme Java, qui utilisent des accolades {} pour définir des blocs de code, Python s'appuie sur une indentation cohérente pour indiquer le regroupement des instructions.

Pourquoi l'indentation est importante :

  • Lisibilité : L'indentation délimite visuellement les blocs de code, facilitant la compréhension de la structure logique de votre programme.
  • Fonctionnalité : Python utilise l'indentation pour déterminer quelles instructions appartiennent à un bloc particulier, comme celles à l'intérieur d'une boucle ou d'une instruction conditionnelle. Une indentation incohérente peut entraîner des erreurs et un comportement inattendu.

Voici un exemple de code :

Mauvaise indentation :

if x > 5:
    print("x est supérieur à 5")
  y = x * 2   # Indentation incorrecte
     print("y est", y) # Indentation incohérente

Dans cet exemple, les lignes indentées sous l'instruction if forment un bloc de code. Si la condition x > 5 est vraie, toutes les instructions indentées s'exécuteront.

Pourquoi c'est mauvais :

  • Sujet aux erreurs : L'indentation incohérente provoquera une IndentationError lorsque vous essaierez d'exécuter le code. Python ne peut pas déterminer quelles lignes sont censées faire partie du bloc if.
  • Difficile à lire : Même s'il s'exécutait (en corrigeant les erreurs), l'indentation inégale rend difficile la compréhension rapide de la logique du code. Il n'est pas clair d'un coup d'œil quelles actions dépendent de la condition x > 5.

Bonne indentation :

if x > 5:
    print("x est supérieur à 5")
    y = x * 2
    print("y est", y)

Pourquoi c'est bon :

  • Structure claire : L'utilisation constante de quatre espaces pour chaque niveau d'indentation crée une hiérarchie visuelle qui reflète la logique du code.
  • Facile à lire : Quiconque lit le code peut immédiatement voir que le calcul de y et son affichage ultérieur dépendent du fait que la valeur de x soit supérieure à 5.
  • Pas d'erreurs : Ce code s'exécutera sans aucun problème lié à l'indentation.

Points clés sur l'indentation :

  • La cohérence est la clé : Utilisez toujours le même nombre d'espaces ou de tabulations pour chaque niveau d'indentation.
  • Suivez le PEP 8 : Le guide de style de Python (PEP 8) recommande d'utiliser quatre espaces par niveau d'indentation. C'est une convention largement acceptée dans la communauté Python.
  • Utilisez les outils de votre éditeur : La plupart des éditeurs de code disposent de fonctionnalités pour indenter automatiquement votre code correctement, vous aidant ainsi à éviter les erreurs.

En suivant ces directives, vous écrirez un code Python non seulement fonctionnel, mais aussi clair, lisible et facile à maintenir.

Meilleures pratiques :

  • Cohérence : Choisissez soit des espaces, soit des tabulations pour l'indentation, et tenez-vous-en à votre choix dans tout votre code. La plupart des développeurs Python préfèrent les espaces.
  • Indentation standard : Le niveau d'indentation recommandé est de quatre espaces par bloc.

Commentaires : Documenter votre code pour plus de clarté

Les commentaires sont des lignes de texte non exécutables que vous ajoutez à votre code Python pour expliquer son but, sa logique ou toute autre information pertinente. Bien que l'interprète Python ignore les commentaires, ils sont inestimables pour :

  • Comprendre : Vous aider (ou aider d'autres personnes) à comprendre la fonctionnalité du code plus tard.
  • Débogage : Désactiver temporairement des parties de votre code pendant le dépannage.

Types de commentaires :

  • Commentaires sur une seule ligne : Commencent par un symbole dièse (#) et continuent jusqu'à la fin de la ligne.
  • Commentaires multi-lignes : Enclosent le texte du commentaire dans des triples guillemets (''' ou """).

Exemple de code :

# Ceci est un commentaire sur une seule ligne expliquant le calcul
result = x + y  

'''
Ceci est un commentaire multi-lignes qui fournit une explication détaillée 
du but de la fonction, de ses arguments et de sa valeur de retour.
'''
def calculate_average(numbers):
    ...

Erreurs courantes et débogage : Dépannage de votre code Python

Au début de votre parcours Python, rencontrer des erreurs est inévitable. Heureusement, Python fournit des messages d'erreur informatifs pour vous guider vers des solutions.

Erreurs courantes :

  • Erreurs de syntaxe (Syntax Errors) : Surviennent lorsque votre code viole les règles grammaticales de Python (par exemple, oublier un deux-points, parenthèses mal assorties).
  • Erreurs d'indentation (Indentation Errors) : Résultent d'une indentation incorrecte ou incohérente.
  • Erreurs de nom (Name Errors) : Arrivent lorsque vous utilisez un nom de variable ou de fonction qui n'a pas été défini.
  • Erreurs de type (Type Errors) : Surviennent lorsque vous effectuez une opération sur des types de données incompatibles (par exemple, ajouter une chaîne de caractères et un nombre).

Conseils de débogage :

  • Lisez attentivement les messages d'erreur : Ils indiquent souvent le type d'erreur et son emplacement dans votre code.
  • Instructions d'affichage : Utilisez des instructions print() pour vérifier les valeurs des variables à différents points de votre code.
  • Débogage interactif : Utilisez des outils comme pdb (Python Debugger) pour parcourir votre code ligne par ligne et inspecter les variables.
  • Ressources en ligne : Recherchez sur des forums ou des communautés en ligne pour obtenir de l'aide sur des erreurs spécifiques.

Points clés à retenir :

  • Indentation : Maîtriser l'indentation est crucial pour écrire un code Python correct et lisible.
  • Commentaires : Documentez votre code de manière approfondie avec des commentaires pour le rendre plus facile à comprendre et à maintenir.
  • Débogage : N'ayez pas peur des erreurs ! Utilisez-les comme des opportunités d'apprentissage pour améliorer vos compétences en programmation.

1.2 Types de données et variables :

Comprendre les types de données

En Python, tout est un objet, et chaque objet possède un type de données spécifique. Les types de données déterminent le type de valeurs qu'une variable peut contenir et les opérations que vous pouvez effectuer sur elles.

Explorons les types de données fondamentaux que vous rencontrerez dans votre parcours d'analyse de données :

1. Nombres :

  • Entiers (int) : Représentent des nombres entiers (comme -3, 0, 12).
  • Nombres à virgule flottante (float) : Représentent des nombres avec des points décimaux (comme 3.14, -0.5, 1e6).
age = 30  # entier
price = 19.99  # float

2. Chaînes de caractères (str) : Séquences de caractères encloses dans des guillemets simples ou doubles (par exemple, "Bonjour", 'Python').

name = "Alice"
message = 'Bienvenue sur Python !'

3. Booléens (bool) : Représentent des valeurs logiques, soit True (Vrai) ou False (Faux).

is_student = True
is_valid = False

Travailler avec des collections : Listes, dictionnaires, tuples et ensembles

Python propose des structures de données puissantes pour gérer des collections d'éléments :

1. Listes (list) : Collections ordonnées et modifiables d'éléments.

numbers = [1, 2, 3, 4]
names = ["Alice", "Bob", "Charlie"]

2. Dictionnaires (dict) : Collections non ordonnées de paires clé-valeur, où les clés sont uniques.

student = {"nom": "Alice", "age": 25, "notes": [90, 85, 92]}

3. Tuples (tuple) : Collections ordonnées et immuables d'éléments.

coordinates = (10, 20)

4. Ensembles (set) : Collections non ordonnées d'éléments uniques.

unique_numbers = {1, 2, 3, 3, 4}  # Stockera {1, 2, 3, 4}

Variables : Stocker et manipuler des données

Les variables sont des conteneurs nommés pour stocker des valeurs de données. En Python, vous créez une variable en lui assignant une valeur à l'aide de l'opérateur d'affectation (=).

Exemple :

x = 10      # x est une variable entière
name = "John"  # name est une variable chaîne de caractères

Règles de nommage des variables :

  • Doit commencer par une lettre (a-z, A-Z) ou un trait de soulignement (_).
  • Peut contenir des lettres, des chiffres et des traits de soulignement.
  • Sensible à la casse (maVar et mavar sont des variables différentes).
  • Évitez d'utiliser des mots-clés réservés (par exemple, if, for, while).

Conversions de type : Adapter les données pour différentes opérations

Vous pouvez convertir des valeurs d'un type de données à un autre en utilisant des fonctions de conversion de type comme int(), float(), str(), bool(), list(), tuple(), set() et dict().

Exemple :

x = 10       # entier
y = float(x)  # convertir x en float
print(y)     # Sortie : 10.0

Points clés à retenir :

  • Comprendre les types de données de Python est essentiel pour une manipulation et une analyse efficaces des données.
  • Utilisez les structures de données appropriées (listes, dictionnaires, tuples, ensembles) pour organiser vos données.
  • Les variables sont vos outils pour stocker et manipuler les valeurs de données.
  • Les conversions de type vous permettent d'adapter les données pour des opérations spécifiques.

Avec une solide compréhension de ces concepts, vous serez bien équipé pour relever les défis de l'analyse de données réelles à l'aide de Python. La section suivante vous présentera les opérateurs de Python, fournissant les moyens d'effectuer des calculs et de manipuler davantage vos données.

1.3 Opérateurs : Manipulation et comparaison de données

Les opérateurs sont des symboles ou des caractères spéciaux qui effectuent des opérations spécifiques sur des valeurs ou des variables. En Python, nous utilisons des opérateurs pour manipuler et comparer les données.

Il existe quatre principaux types d'opérateurs que nous couvrirons dans cette section :

Opérateurs arithmétiques : Effectuer des calculs mathématiques

Les opérateurs arithmétiques sont utilisés pour effectuer des opérations mathématiques de base :

OpérateurSignificationExempleRésultat
+Addition5 + 38
-Soustraction5 - 32
Multiplication5 315
/Division5 / 31.666
//Division entière5 // 31
%Modulo5 % 32
Exposant5 3125

Exemple en Python :

x = 10
y = 3

somme = x + y          # Addition
difference = x - y      # Soustraction
produit = x * y        # Multiplication
quotient = x / y       # Division
div_entiere = x // y    # Division entière
reste = x % y          # Modulo
puissance = x ** y      # Exposant

Opérateurs de comparaison : Évaluer les relations entre les valeurs

Les opérateurs de comparaison sont utilisés pour comparer deux valeurs et renvoient un résultat booléen (True ou False).

OpérateurSignificationExempleRésultat
==Égal à5 == 3False
!=Différent de5 != 3True
>Supérieur à5 > 3True
<Inférieur à5 < 3False
>=Supérieur ou égal à5 >= 3True
<=Inférieur ou égal à5 <= 3False

Exemple en Python :

x = 10
y = 3

est_egal = x == y           # Égal à
est_different = x != y       # Différent de
est_superieur = x > y        # Supérieur à
est_inferieur = x < y        # Inférieur à
est_sup_ou_egal = x >= y     # Supérieur ou égal à
est_inf_ou_egal = x <= y     # Inférieur ou égal à

Opérateurs logiques : Combiner des expressions booléennes

Les opérateurs logiques sont utilisés pour combiner plusieurs expressions booléennes.

OpérateurSignificationExempleRésultat
andVrai si les deux opérandes sont vrais(5 > 3) and (10 < 20)True
orVrai si au moins un opérande est vrai(5 > 3) or (10 > 20)True
notVrai si l'opérande est fauxnot (5 > 3)False

Exemple en Python :

x = 10
y = 3
z = 20

result1 = (x > y) and (z > y)    # True
result2 = (x < y) or (z > x)     # True
result3 = not (x == y)           # True

Opérateurs d'affectation : Assigner des valeurs aux variables

Les opérateurs d'affectation sont utilisés pour assigner des valeurs aux variables.

OpérateurSignificationExempleÉquivalent à
=Assigner une valeurx = 5x = 5
+=Ajouter et assignerx += 3x = x + 3
-=Soustraire et assignerx -= 3x = x - 3
=Multiplier et assignerx = 3x = x 3
/=Diviser et assignerx /= 3x = x / 3
//=Diviser entier et assignerx //= 3x = x // 3
%=Modulo et assignerx %= 3x = x % 3
=Puissance et assignerx = 3x = x * 3

Exemple en Python :

x = 10
x += 5   # x est maintenant 15
x *= 2   # x est maintenant 30

Voici un code plus complet montrant la combinaison des opérateurs arithmétiques, de comparaison, logiques et d'affectation.

# Initialiser des variables avec différents types de données
x = 15       # Entier
y = 5.5      # Nombre à virgule flottante
name = "Alice"  # Chaîne de caractères
is_student = True  # Booléen

# Opérations arithmétiques
sum_result = x + y         # Addition d'un entier et d'un float
difference = x - int(y)    # Soustraction (conversion du float en entier)
product = x * y            # Multiplication
division = x / y           # Division (le résultat sera un float)
floor_division = x // y    # Division entière (renvoie la partie entière du quotient)
remainder = x % y          # Modulo (renvoie le reste de la division)
power = x ** 2             # Exposant (x élevé à la puissance 2)

# Opérations de comparaison
is_equal = x == y          # Vérifier si x est égal à y (False)
is_greater = x > y         # Vérifier si x est supérieur à y (True)
is_less_or_equal = x <= y  # Vérifier si x est inférieur ou égal à y (False)

# Opérations logiques
both_conditions = (x > 10) and (is_student)  
# True si les deux conditions sont remplies
either_condition = (x < 5) or (y > 6)       
# True si au moins une condition est remplie
not_student = not is_student                
# True si is_student est False

# Opérations d'affectation
x += 3  # Équivalent à x = x + 3 (x est maintenant 18)
y -= 2.5 # Équivalent à y = y - 2.5 (y est maintenant 3.0)

# Impression des résultats avec des commentaires descriptifs
print("Somme :", sum_result)                    
# Sortie : Somme : 20.5
print("Différence :", difference)           
# Sortie : Différence : 10
print("Produit :", product)                 
# Sortie : Produit : 82.5
print("Division :", division)                 
# Sortie : Division : 2.7272727272727275
print("Division entière :", floor_division)      
# Sortie : Division entière : 2
print("Reste :", remainder)             
# Sortie : Reste : 4.0
print("Puissance :", power)                     
# Sortie : Puissance : 225

print("Est-ce que x est égal à y ?", is_equal)          
# Sortie : Est-ce que x est égal à y ? False
print("Est-ce que x est supérieur à y ?", is_greater)      
# Sortie : Est-ce que x est supérieur à y ? True
print("Est-ce que x est inférieur ou égal à y ?", is_less_or_equal) 
# Sortie : Est-ce que x est inférieur ou égal à y ? False

print("Les deux conditions sont-elles vraies ?", both_conditions) 
# Sortie : Les deux conditions sont-elles vraies ? True
print("L'une des conditions est-elle vraie ?", either_condition)  
# Sortie : L'une des conditions est-elle vraie ? False
print("N'est pas étudiant ?", not_student)           
# Sortie : N'est pas étudiant ? False
print("Nouvelle valeur de x :", x)                    
# Sortie : Nouvelle valeur de x : 18
print("Nouvelle valeur de y :", y)                    
# Sortie : Nouvelle valeur de y : 3.0

1.4 Flux de contrôle

Dans cette section, nous approfondirons les mécanismes essentiels pour contrôler le flux de vos programmes Python. Cela vous permet de créer une logique dynamique et adaptable qui répond à diverses conditions et scénarios de données.

Instructions conditionnelles : Prendre des décisions dans votre code

Les instructions conditionnelles sont le pilier de la prise de décision en programmation. Elles vous permettent d'exécuter des blocs de code spécifiques uniquement si certaines conditions sont remplies. Python propose trois principaux types d'instructions conditionnelles :

1. Instruction if :

  • L'instruction conditionnelle la plus simple.
  • Exécute un bloc de code si une condition spécifiée est évaluée à True.
x = 10
if x > 5:
    # Cela affiche "x est supérieur à 5" car 10 > 5
    print("x est supérieur à 5")

2. Instruction if...else :

  • Fournit un bloc de code alternatif à exécuter si la condition if est False.
x = 3
if x > 5:
    print("x est supérieur à 5")
else:
    print("x n'est pas supérieur à 5")

3. Instruction if...elif...else :

  • Permet de tester plusieurs conditions en séquence.
  • La première condition évaluée à True déclenchera son bloc de code correspondant.
score = 85
if score >= 90:
    print("Note : A")
elif score >= 80:
    print("Note : B")
elif score >= 70:
    print("Note : C")
else:
    print("Note : F")

Boucles : Répéter des actions efficacement

Les boucles sont utilisées pour exécuter de manière répétée un bloc de code tant qu'une condition est remplie. Python propose deux types principaux de boucles :

1. Boucle for :

La boucle for est idéale pour itérer sur des séquences (comme des listes, des tuples, des chaînes de caractères) ou d'autres objets itérables. Elle exécute un bloc de code pour chaque élément de la séquence, offrant un moyen concis de traiter des collections de données.

Itérer sur une séquence :

fruits = ["pomme", "banane", "orange"]
for fruit in fruits:
    print(fruit)  # Sortie : pomme, banane, orange

Utiliser la fonction range() :

La fonction range() génère une séquence de nombres, ce qui la rend parfaite pour les situations où vous devez répéter une action un nombre spécifique de fois.

for i in range(5):  # Plage de 0 à 4 (inclus)
    print(i)        # Sortie : 0, 1, 2, 3, 4

Vous pouvez personnaliser la fonction range() pour commencer et finir à des valeurs spécifiques ou incrémenter par un pas différent.

for i in range(2, 10, 2):  # Commence à 2, s'arrête avant 10, incrémente de 2
    print(i)                # Sortie : 2, 4, 6, 8

2. Boucle while :

  • Continue d'exécuter un bloc de code tant qu'une condition reste True.
count = 0
while count < 5:
    print(count)
    count += 1  # Sortie : 0, 1, 2, 3, 4

Instructions break et continue : Contrôler l'exécution de la boucle

  • break : Termine immédiatement l'exécution de la boucle, même si la condition de la boucle est toujours True.
  • continue : Ignore le reste de l'itération actuelle et passe à l'itération suivante.

Exemple en Python :

for num in [1, 2, 3, 4, 5]:
    if num == 3:
        break          # Sort de la boucle quand num vaut 3
    print(num)         # Sortie : 1, 2

for num in [1, 2, 3, 4, 5]:
    if num % 2 == 0:
        continue       # Ignore les nombres pairs
    print(num)         # Sortie : 1, 3, 5

Points clés à retenir

  • Les instructions conditionnelles permettent à votre code de prendre des décisions basées sur des conditions variables.
  • Les boucles automatisent les tâches répétitives, améliorant l'efficacité du code.
  • Utilisez break et continue pour contrôler précisément le flux de vos boucles.

En maîtrisant le flux de contrôle, vous gagnez la capacité de créer des programmes polyvalents et adaptables capables de gérer divers scénarios de données. Ces connaissances seront inestimables à mesure que vous aborderez des tâches d'analyse de données de plus en plus complexes dans les chapitres suivants.

Exemple de code

Ce code montre comment les outils de flux de contrôle de Python – boucles (for, while) et instructions conditionnelles (if...else) – peuvent être utilisés pour analyser des données client structurées.

# Scénario : Analyse des données clients

# Échantillon de données clients (liste de dictionnaires)
customers = [
    {"name": "Alice", "age": 35, "is_member": True, "purchases": [50, 80, 120]},
    {"name": "Bob", "age": 28, "is_member": False, "purchases": [25, 40]},
    {"name": "Charlie", "age": 42, "is_member": True, "purchases": [15, 65, 90, 110]},
]

total_spent = 0  # Initialiser la variable pour suivre les dépenses totales
member_count = 0  # Initialiser la variable pour compter les membres

# Itérer à travers les clients à l'aide d'une boucle for
for customer in customers:
    name = customer["name"]
    age = customer["age"]
    is_member = customer["is_member"]
    purchases = customer["purchases"]

    # Instruction conditionnelle pour vérifier le statut de membre
    if is_member:
        print(f"{name} est membre et a dépensé :")
        member_count += 1 
    else:
        print(f"{name} n'est pas membre et a dépensé :")

    # Calculer le montant total dépensé pour chaque client à l'aide d'une boucle while
    purchase_index = 0
    while purchase_index < len(purchases):
        purchase = purchases[purchase_index]
        total_spent += purchase
        print(f"  - {purchase} $")  # Afficher les montants d'achat individuels
        purchase_index += 1         # Incrémenter l'index

    # Instruction continue pour ignorer le reste de la boucle pour les non-membres
    if not is_member:
        continue  # Ignorer le calcul de la moyenne pour les non-membres

    # Calculer la dépense moyenne pour les membres
    average_spent = sum(purchases) / len(purchases)
    print(f"  Dépense moyenne : {average_spent:.2f} $\n")

# Calculer la dépense moyenne globale pour les membres
if member_count > 0:
    print(f"Dépense totale des membres : {total_spent} $")

1.5 Fonctions en Python

Les fonctions Python sont des outils fondamentaux pour l'organisation, la réutilisabilité et la lisibilité du code. Elles agissent comme des mini-programmes autonomes, chacun conçu pour effectuer une tâche spécifique au sein de votre programme plus large.

En encapsulant le code dans des fonctions, vous pouvez éviter de répéter les mêmes blocs de code tout au long de votre projet. Cela rend votre code plus propre, plus modulaire et plus facile à maintenir.

Imaginez une fonction comme un outil spécialisé dans votre boîte à outils. Au lieu d'écrire les instructions pour une tâche chaque fois que vous en avez besoin, vous créez une fonction une seule fois et l'appelez chaque fois que vous devez effectuer cette tâche. Cela vous fait non seulement gagner du temps, mais rend également votre code plus organisé et plus facile à comprendre.

Dans cette section, nous explorerons l'anatomie des fonctions Python, y compris comment les définir, les appeler et leur transmettre des données. Nous couvrirons différents types d'arguments, les valeurs de retour et le concept de fonctions lambda, qui sont des expressions concises pour créer des fonctions simples à la volée.

Anatomie d'une fonction Python

Une fonction Python est une unité de code autonome conçue pour effectuer une tâche spécifique. Disséquons sa structure :

def greet(name):
    """Cette fonction affiche une salutation personnalisée."""
    print(f"Bonjour, {name} !")
  1. Mot-clé def : Ce mot-clé signale le début d'une définition de fonction.
  2. Nom de la fonction : Choisissez un nom descriptif (par exemple, calculate_average, process_data).
  3. Paramètres (Optionnels) : Les paramètres agissent comme des espaces réservés pour les valeurs (arguments) que vous passez à la fonction.
  4. Docstring (Optionnel mais fortement recommandé) : Un littéral de chaîne pour documenter le but de la fonction.
  5. Corps de la fonction : Le bloc de code indenté qui définit le comportement de la fonction.
  6. Instruction return (Optionnelle) : Utilisée pour renvoyer une valeur au code appelant.

Appeler des fonctions

Pour exécuter le code d'une fonction, vous l'appelez par son nom suivi de parenthèses :

greet("Alice")  # Appelle la fonction greet et passe "Alice" comme argument

Arguments et paramètres de fonction

1. Arguments positionnels : Leur sens est déterminé par leur position.

def describe_pet(animal, name):
    print(f"J'ai un {animal} nommé {name}.")

describe_pet("chien", "Fido")

2. Arguments mots-clés : Vous spécifiez explicitement le nom du paramètre.

describe_pet(name="Whiskers", animal="chat")

3. Arguments par défaut : Valeurs automatiquement assignées si aucun argument n'est fourni.

def greet(name="tout le monde"):
    print(f"Bonjour, {name} !")

Valeurs de retour

L'instruction return est la façon dont votre fonction redonne quelque chose au code qui l'a appelée.

def add_numbers(a, b):
    result = a + b
    return result

somme = add_numbers(5, 3) # somme vaut maintenant 8

Fonctions Lambda

Les fonctions lambda sont des fonctions anonymes définies à l'aide du mot-clé lambda. Elles sont idéales pour des opérations simples et rapides.

# Syntaxe : lambda arguments : expression
doubler = lambda x: x * 2
print(doubler(5)) # Sortie : 10

1.6 Modules et packages :

La véritable puissance de Python ne réside pas seulement dans son langage de base, mais aussi dans son vaste écosystème de modules et de packages pré-construits. Voyez-les comme des boîtes à outils spécialisées.

Importer des modules :

import math
print(math.sqrt(16))  # Sortie : 4.0

Travailler avec des packages externes :

Pour la science des données, deux des packages les plus essentiels sont :

  • Pandas : Pour la manipulation et l'analyse des données.
  • NumPy : Pour le calcul numérique et les tableaux.
import pandas as pd
import numpy as np

1.7 Gestion des erreurs :

Python fournit des mécanismes pour gérer gracieusement les erreurs afin d'éviter que vos programmes ne s'arrêtent brusquement.

Blocs Try-Except :

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Erreur : La division par zéro n'est pas autorisée.")

2. Bibliothèques Python essentielles pour le Data Wrangling

Bienvenue dans la boîte à outils qui va révolutionner votre façon de manipuler, d'analyser et de tirer des enseignements des données. Dans ce chapitre, je vais vous présenter le trio dynamique qui constitue l'épine dorsale des prouesses de Python en science des données : Pandas, NumPy et Matplotlib.

2.1 Pandas

Pandas est un pilier fondamental, réputé pour ses capacités polyvalentes dans la gestion des données structurées. Ses structures de base, Series (une colonne) et DataFrames (un tableau), facilitent le travail sur les données tabulaires.

Manipulation des données avec Pandas :

  • Filtrage : Sélectionner des lignes spécifiques.
  • Tri : Ordonner les données.
  • Agrégation : Combiner les données avec sum, mean, etc.
# Exemple de filtrage
clients_riches = df[df["Revenu"] > 100000]

2.2 NumPy

NumPy fournit la puissance de calcul pour gérer les tâches analytiques exigeantes grâce à ses tableaux ndarray haute performance.

import numpy as np
data = np.array([1, 2, 3, 4, 5])
double = data * 2 # Opération vectorisée rapide

2.3 Matplotlib

Matplotlib est l'outil de visualisation qui permet de donner vie aux chiffres grâce à des graphiques.

  • Graphiques linéaires pour les tendances.
  • Nuages de points pour les relations.
  • Histogrammes pour la distribution.

3. Exemples pratiques : De la théorie à l'action

3.1 Chargement et nettoyage des données

Les données réelles sont rarement parfaites. Voici comment les nettoyer avec Pandas :

import pandas as pd
df = pd.read_csv('sales_data.csv')

# Gérer les valeurs manquantes
df['Sales'].fillna(df['Sales'].mean(), inplace=True)

# Convertir les types de données
df['Order Date'] = pd.to_datetime(df['Order Date'])

3.2 Exploration des données avec Pandas

# Résumé statistique
print(df.describe())

# Ventes par segment
ventes_par_segment = df.groupby('Segment')['Sales'].sum()

4. Fondamentaux de l'analyse de données : L'art de donner du sens aux données

4.1 Types et structures de données

Il existe deux catégories principales :

  1. Données catégorielles : Informations qualitatives (segments, régions).
  2. Données numériques : Informations quantitatives (chiffre d'affaires, âge).

4.2 Statistiques descriptives

  • Moyenne (Mean) : La valeur moyenne.
  • Médiane (Median) : La valeur centrale.
  • Mode : La valeur la plus fréquente.
  • Écart-type (Standard Deviation) : Mesure de la dispersion des données.

5. Projet de science des données appliquée

Ce projet utilise le jeu de données SuperStore pour effectuer une analyse complète, de la segmentation de la clientèle à la cartographie géographique.

5.1 Introduction au projet

Nous allons utiliser Python, Pandas et Plotly pour transformer des données de vente brutes en décisions stratégiques.

Code Walkthrough (Explication du code)

Chargement et préparation des données :

import pandas as pd
df = pd.read_csv("train.csv")
df.head() # Aperçu des premières lignes

Gestion des données manquantes :

# Remplissage des codes postaux manquants par 0
df["Postal Code"].fillna(0, inplace = True)

Analyse des résultats

Segmentation de la clientèle

Notre analyse montre que les clients se divisent en trois segments : Grand public (Consumer) (52,1 %), Entreprise (Corporate) (30,1 %) et Bureau à domicile (Home Office) (17,8 %).

Cartographie géographique

Le jeu de données révèle que la Californie, New York et le Texas sont les États générant le plus de revenus.

Conclusion

L'analyse du jeu de données SuperStore démontre qu'une approche basée sur les données permet d'optimiser les stratégies marketing et d'améliorer la rentabilité globale. En comprenant les segments de clientèle et les tendances de vente, une entreprise peut prendre des décisions proactives pour assurer sa croissance.

À propos de l'auteur

Ici Vahe Aslanyan, à l'intersection de l'informatique, de la science des données et de l'IA. Mon expérience fait le pont entre le développement full-stack et l'optimisation de produits IA.

Me contacter :