Importance des Structures des Données pour un Data Analyste

Introduction

Les structures de données sont considérées comme l’un des fondements de la programmation pour un data analyste. Elles permettent de nettoyer, stocker, organiser et manipuler les données de manière efficace. Les structures de données les plus couramment utilisées sont les chaînes de caractères, listes et dictionnaires. Dans certains cas, on aura aussi besoin des sets ou des tuples. Chacune de ces structures présente des avantages et des inconvénients différents, et il est important pour un data analyste de comprendre leur fonctionnement et leur utilisation pour travailler de manière efficace. Dans cette quête, l’objectif est de manipuler ces structures dans un cas pratique. Mais avant tout, je vous propose un résumé de chacune de ces structures.

Objectifs

✅ Comprendre les structures de données

✅ Appliquer les structures de données pour explorer des données brutes

Sommaire

Les chaînes de caractères :

Une chaîne de caractère est une séquence de caractères qui peuvent être de n’importe quel type, tel que des lettres, des chiffres, des symboles. Chaque élément étant défini par sa valeur et son propre indice. Une chaîne de caractères est définie en utilisant des guillemets simples ou doubles. Afin d’appliquer des traitements sur les chaînes de caractères, vous avez différentes méthodes que vous pouvez découvrir au fur et à mesure que vous essayez de résoudre un problème d’algorithmie. Prenons l’exemple de cette chaîne de caractères qu’on veut nettoyer en enlevant les espaces au début et à la fin, pour ceci, on utilisera la méthode strip.

work = " Data Analyst   "  
Work_clean = work.strip()
print(work_clean)

#######
affichage : 
"Data Analyst"

Dans un deuxieme exemple on souhaite enlever le caractére spéciale '-' et rendre la première lettre de chaque mot en majuscule.

work = "data-analyste"
work_clean = work.replace("-", ' ').title()
print(work_clean)

#######
affichage
"Data Analyste"

Les Listes :

Une liste est une structure de données qui peut contenir un nombre quelconque d’éléments, qui peuvent être de n’importe quel type. Chaque élément étant défini par une valeur et un indice. elle est définie en utilisant les crochets. Afin d’appliquer des traitements sur les listes, vous avez différentes méthodes.

Prenons l’exemple d’une liste contenant des quantités vendues d’un produit et que par erreur de saisie des données, il y a eu des str que je veux enlever :

Sales = [1500, 500, 300, 150, "hello", 20]
#je vais parcourir chaque élément de la liste et ne conserver que les nombres

#définir une liste vide dans laquelle on va stocker nos données nettoyées
Sales_clean = []
# parcourir les éléments de la liste
for quantity in Sales :
    # si un élément est numérique
    if str(quantity).isnumeric() :
    # alors je l’ajoute à ma nouvelle liste

        Sales_clean.append(quantity)
print(Sales_clean)

#######
affichage :
[1500, 500, 300, 150, 20]

Un autre exemple est de nettoyer une liste avec des valeurs manquantes.

L_values = [55,92, None, 75, None, 100, 60, None]
L_clean = []
for value in L_values:
    if value is not None : 
        L_clean.append(value)
print(L_clean)

#######
affichage :
[55, 92, 75, 100, 60]

Les Dictionnaires

Un dictionnaire est une structure de données qui associe des clés à des valeurs. Les clés peuvent être de n’importe quel type, mais doivent être uniques dans le dictionnaire. Un dictionnaire est défini en utilisant des accolades. Afin d’appliquer des traitements sur les dictionnaires, vous avez différentes méthodes.

Considérons un exemple où nous avons un dictionnaire permettant d’avoir l’historique des ventes des produits pour chaque ligne de production et nous souhaitons calculer le total de ventes pour chaque catégorie de produits.

dico_sales = {"velo" : [ 150, 220, 310, 15, 36, 50, 80, 450],
              "voitures": [6, 8, 15, 21, 62],
              "motos" : [80, 5,60, 33 ]}
#parcourir les clés de mon dico_sales : 'velo',voitures' ou 'motos'
for k in dico_sales:
    # pour chaque clé je récupère la valeur associées (la liste des quantité vendu)
    list_sales = dico_sales[k] 
    #pour chaque catégorie afficher la somme des ventes associées
    print(f"la quantité totale de ventes pour la catgéorie {k}  est {sum(list_sales)} ")

#######
affichage:
la quantité totale de ventes pour la catgéorie velo  est 1311 
la quantité totale de ventes pour la catgéorie voitures  est 112 
la quantité totale de ventes pour la catgéorie motos  est 178 

Considérons un autre exemple, vous avez un historique des achats des clients pour différents produits et vous souhaitez avoir un dictionnaire récapitulatif contenant pour chaque client la liste des dépenses, vous pouvez éventuellement par la suite calculer le total d’achats par client.

commandes = [{"id": 1,"nom" : "Alexis", "commande": "Livre", "montant": 25.5},
             {"id": 1,"nom" : "Alexis", "commande": "Chaussures", "montant": 55},
             {"id": 2,"nom" : "Charles", "commande": "PC", "montant": 1250},
             {"id":2,"nom" : "Charles", "commande": "smartphone", "montant": 450}
             ]
total_customer = {}
#parcourir chaque element (un dictionnaire d'achat) de ma liste
for commande in commandes:
    #stocker les valeurs concernant le nom et le montant dans des variables :
    nom = commande["nom"]
    montant = commande["montant"]
    #si le nom du client n'existe pas en tant que clé dans total_customer 
    if nom not in total_customer:
        # je rajoute le nom du client avec le montant dépensé
        total_customer[nom] = [montant]
    else :
        #si le client existe, on lui rajoute la nouvelle dépense
        total_customer[nom].append(montant)
print(total_customer)

#######
affichage :
{'Alexis': [25.5, 55], 'Charles': [1250, 450]}

#si vous voulez afficher un total des dépenses pour chaque client
for k,v in total_customer.items():
    #items() est une méthode des dictionnaires 
    #qui permet de récupérer un tuple de clé valeurs d'un dictionnaire
    print(f"pour le client {k} il a dépensé {sum(v)}")

#######
affichage :
pour le client Alexis il a dépensé 80.5
pour le client Charles il a dépensé 1700

Autres structures : Set, Tuple

Les ensembles (set) sont très utiles pour éliminer les doublons ce qui peut être très intéressant pour chercher les valeurs uniques dans une liste. Ils sont aussi très utilisés lorsqu’on souhaite appliquer des opérations de comparaison entre deux listes telles que : trouver les éléments différents entre deux listes, trouver les éléments en commun entre deux listes… Vous pouvez explorer les méthodes des ensembles sur ce lien.

Les éléments stockés dans un set ont aussi la particularité d'être non indexés, c’est-à-dire qu’il n y a pas de notion d’ordre des données.

Considérons deux listes de produits vendus par une entreprise, une première pour un magasin à Paris et une deuxième pour un magasin à Lille. Je souhaite trouver l’ensemble des données unique vendu entre Paris et Lille.

Paris_product = ["Pc", "Livre", "Chaussures", "Telephone"]

Lille_product = ["Pc", "Bonbon", "Livre"]

#concat des deux listes
L_finale = Paris_product  +  Lille_product 
#Produits unique
Unique_prod = set(L_finale)
print(Unique_prod)

#######
affichage :
{'Telephone', 'Chaussures', 'Pc', 'Livre', 'Bonbon'}

Et si on voulait connaitre les produit qui sont vendu à Paris mais non pas à Lille

paris_set = set(Paris_product)
lille_set = set(Lille_product)

diff_paris_lille = paris_set.difference(lille_set)
print(diff_paris_lille)

#######
affichage :
{'Telephone', 'Chaussures'}

On peut aussi trouver les produits vendus sur Paris et sur Lille

same_paris_lille = paris_set.intersection(lille_set)
print(same_paris_lille)

#######
affichage :
{'Pc', 'Livre'}

Les tuples sont très semblables aux listes avec quelques différences près :

• Elles sont définies en utilisant les parenthèses au lieu des crochets.
• Une fois défini, un tuple ne peut pas être modifié (ce qui n’est pas le cas pour les listes). Ceci peut être utile si vous désirez stocker des données qui restent inchangées.
• Ils sont plus rapides et performants que des listes sur des grandes quantités de données.

#définir un tuple
my_tuple = (12, 15, 20, 40)

#pas possible de changer un élément : ceci donnera une erreur
my_tuple[0] =  15

Avantages et inconvénients des structures des données :

Liste :

Avantages :

• Facile à utiliser et à comprendre
• Permet de stocker des éléments de n’import quel type
• Elles peuvent être modifiées

Inconvénients :

• Elles sont un peu lentes pour effectuer des opérations de recherche sur des grandes quantités de données

Dictionnaire :

Avantages :

• Très rapide pour des opérations de recherche des données
• Très flexible pour le stockage des données grâce à la notion de clés valeurs
• Facilement modifiable

Inconvénient :

• Il n'est pas triés par défaut
• Pour des données complexes, peut devenir difficile à explorer

Chaîne de caractères :

Avantages :

• Très facile à manipuler pour des opérations de concaténation et d’extraction de sous-chaîne
• Pratique pour stocker des données textuelles

Inconvénients :

• Peuvent être lente pour des opérations de recherche complexe
• Difficile à modifier pour des données complexes

Ressources

si tu souhaites t'exrecer plus sur une des stuructures de données, tu peux explorer cette liste de vidéos. Sinon tu peux attaquer directement le challenge.

Challenge

Durant ce challenge, vous allez être amené à réaliser une analyse sur une liste contenant les films les plus populaires. Au départ d’un fichier de données brut, nous allons utiliser les structures de données pour ressortir des informations pertinentes. Crée une copie du notebook ci-après et réalise les missions qui s'y trouvent : Python Data Structures

Une fois réalisé, poste le lien vers ton notebook en commentaire pour validation, sans oublier de le rendre accessible en lecture pour toute personne disposant du lien.

Critères de validation

• Le fichier en lien est consultable
• Toutes les questions sont résolues