Introduction

En tant qu'analyste de données, il est de notre responsabilité d'assurer l'intégrité des données afin d'obtenir des informations précises et fiables. Le nettoyage des données joue un rôle essentiel dans ce processus, et les valeurs en double sont parmi les problèmes les plus courants rencontrés par les analystes de données. Les valeurs en double peuvent potentiellement fausser les informations. Par conséquent, il est crucial de disposer de méthodes efficaces pour traiter les valeurs en double. Dans cet article, nous apprendrons comment identifier et gérer les valeurs en double, ainsi que les meilleures pratiques pour gérer les doublons.

Identification des valeurs en double

La première étape de la gestion des valeurs en double consiste à les identifier. L'identification des valeurs en double est une étape importante du nettoyage des données. Pandas propose plusieurs méthodes pour identifier les valeurs en double dans une trame de données. Dans cette section, nous aborderons les duplicated() fonction et value_counts() fonction d'identification des valeurs en double.

Usin dupliqué()

La duplicated() La fonction est une fonction de la bibliothèque Pandas qui vérifie les lignes en double dans un DataFrame. La sortie du duplicated() function est une série booléenne de même longueur que le DataFrame d'entrée, où chaque élément indique si la ligne correspondante est ou non un doublon.

Prenons un exemple simple de duplicated() fonction:

import pandas as pd data = { 'StudentName': ['Mark', 'Ali', 'Bob', 'John', 'Johny', 'Mark'], 'Score': [45, 65, 76, 44, 39, 45]
}
df = pd.DataFrame(data) df_duplicates = df.duplicated()
print(df_duplicates)

Sortie :

0 False
1 False
2 False
3 False
4 False
5 True
dtype: bool

Dans l'exemple ci-dessus, nous avons créé un DataFrame contenant les noms des étudiants et leurs scores totaux. Nous avons invoqué duplicated() sur le DataFrame, qui a généré une série booléenne avec False représentant des valeurs uniques et True représentant des valeurs en double.

Dans cet exemple, la première occurrence de la valeur est considérée comme unique. Cependant, que se passe-t-il si nous voulons que la dernière valeur soit considérée comme unique et que nous ne voulons pas prendre en compte toutes les colonnes lors de l'identification des valeurs en double ? Ici, nous pouvons modifier le duplicated() fonction en modifiant les valeurs des paramètres.

Paramètres : Sous-ensemble et Conserver

La duplicated() offre des options de personnalisation via ses paramètres optionnels. Il a deux paramètres, comme décrit ci-dessous :

• subset: Ce paramètre nous permet de spécifier le sous-ensemble de colonnes à considérer lors de la détection des doublons. Le sous-ensemble est défini sur None par défaut, ce qui signifie que chaque colonne du DataFrame est prise en compte. Pour spécifier les noms de colonne, nous pouvons fournir au sous-ensemble une liste de noms de colonne.

  Voici un exemple d'utilisation du paramètre subset :

  
  df_duplicates = df.duplicated(subset=['StudentName'])
  

  Sortie :

  0 False
  1 False
  2 False
  3 False
  4 False
  5 True
  dtype: bool
  

• keep: Cette option nous permet de choisir quelle instance de la ligne dupliquée doit être marquée comme doublon. Les valeurs possibles pour keep sont :

  • "first": Il s'agit de la valeur par défaut du keep option. Il identifie tous les doublons à l'exception de la première occurrence, en considérant que la première valeur est unique.
  • "last": Cette option identifie la dernière occurrence comme une valeur unique. Toutes les autres occurrences seront considérées comme des doublons.
  • False: Cette option marque chaque instance comme une valeur en double.

Voici un exemple d'utilisation du keep paramètre:

df_duplicates = df.duplicated(keep='last')
print(df_duplicates)

Sortie :

0 True
1 False
2 False
3 False
4 False
5 False
dtype: bool

Visualiser les valeurs en double

La value_counts() La fonction est la deuxième approche pour identifier les doublons. Le value_counts() fonction compte le nombre de fois que chaque valeur unique apparaît dans une colonne. En appliquant le value_counts() fonction à une colonne spécifique, la fréquence de chaque valeur peut être visualisée.

Voici un exemple d'utilisation du value_counts() fonction:

import matplotlib.pyplot as plt
import pandas as pd data = { 'StudentName': ['Mark', 'Ali', 'Bob', 'John', 'Johny', 'Mark'], 'Score': [45, 65, 76, 44, 39, 45]
}
df = pd.DataFrame(data) name_counts = df['StudentName'].value_counts()
print(name_counts)

Sortie :

Mark 2
Ali 1
Bob 1
John 1
Johny 1
Name: StudentName, dtype: int64

Visualisons maintenant les valeurs en double avec un graphique à barres. Nous pouvons visualiser efficacement la fréquence des valeurs en double à l'aide d'un graphique à barres.

name_counts.plot(kind='bar')
plt.xlabel('Student Name')
plt.ylabel('Frequency')
plt.title('Duplicate Name Frequencies')
plt.show()

Gestion des valeurs en double

Après avoir identifié les valeurs en double, il est temps de les traiter. Dans cette section, nous explorerons diverses stratégies pour supprimer et mettre à jour les valeurs en double à l'aide des pandas drop_duplicates() ainsi que replace() les fonctions. De plus, nous discuterons de l'agrégation de données avec des valeurs en double à l'aide de l'outil groupby() la fonction.

Suppression des valeurs en double

L'approche la plus courante pour gérer les doublons consiste à les supprimer du DataFrame. Pour éliminer les enregistrements en double du DataFrame, nous utiliserons le drop_duplicates() fonction. Par défaut, cette fonction conserve la première instance de chaque ligne dupliquée et supprime les occurrences suivantes. Il identifie les valeurs en double en fonction de toutes les valeurs de colonne ; cependant, nous pouvons spécifier la colonne à prendre en compte à l'aide de paramètres de sous-ensemble.

Syntaxe de drop_duplicates() avec des valeurs par défaut dans les paramètres est la suivante :

dataFrame.drop_duplicates(subset=None, keep='first', inplace=False)

La subset ainsi que keep paramètres ont la même explication que dans duplicates(). Si nous définissons le troisième paramètre inplace à True, toutes les modifications seront effectuées directement sur le DataFrame d'origine, ce qui entraînera le retour de la méthode None et le DataFrame d'origine en cours de modification. Par défaut, inplace is False.

Voici un exemple de drop_duplicates() fonction:

df.drop_duplicates(keep='last', inplace=True)
print(df)

Sortie :

 StudentName Score
1 Ali 65
2 Bob 76
3 John 44
4 Johny 39
5 Mark 45

Dans l'exemple ci-dessus, la première entrée a été supprimée puisqu'il s'agissait d'un doublon.

Remplacer ou mettre à jour les valeurs en double

La deuxième méthode de gestion des doublons consiste à remplacer la valeur à l'aide des Pandas replace() fonction. le replace() La fonction nous permet de remplacer des valeurs ou des modèles spécifiques dans un DataFrame par de nouvelles valeurs. Par défaut, il remplace toutes les instances de la valeur. Cependant, en utilisant le paramètre limit, nous pouvons limiter le nombre de remplacements.

Voici un exemple d'utilisation de replace() fonction:

df['StudentName'].replace('Mark', 'Max', limit=1, inplace=True)
print(df)

Sortie :

 StudentName Score
0 Max 45
1 Ali 65
2 Bob 76
3 John 44
4 Johny 39
5 Mark 45

Ici, la limite a été utilisée pour remplacer la première valeur. Et si nous voulons remplacer la dernière occurrence ? Dans ce cas, nous combinerons les duplicated() ainsi que replace() les fonctions. En utilisant duplicated(), nous allons indiquer la dernière instance de chaque valeur en double, obtenir le numéro de ligne à l'aide de la loc fonction, puis remplacez-le à l'aide de la replace() fonction. Voici un exemple d'utilisation duplicated() ainsi que replace() fonctionnent ensemble.

last_occurrences = df.duplicated(subset='StudentName', keep='first') last_occurrences_rows = df[last_occurrences] df.loc[last_occurrences, 'StudentName'] = df.loc[last_occurrences, 'StudentName'].replace('Mark', 'Max') print(df)

Sortie :

 StudentName Score
0 Mark 45
1 Ali 65
2 Bob 76
3 John 44
4 Johny 39
5 Max 45

Fonctions personnalisées pour les remplacements complexes

Dans certains cas, la gestion des valeurs en double nécessite des remplacements plus complexes que la simple suppression ou la mise à jour. Des fonctions personnalisées nous permettent de créer des règles de remplacement spécifiques adaptées à nos besoins. En utilisant les pandas apply() fonction, nous pouvons appliquer la fonction personnalisée à nos données.

Par exemple, supposons que la colonne "StudentName" contienne des noms en double. Notre objectif est de remplacer les doublons à l'aide d'une fonction personnalisée qui ajoute un nombre à la fin des valeurs en double, les rendant uniques.

def add_number(name, counts): if name in counts: counts[name] += 1 return f'{name}_{counts[name]}' else: counts[name] = 0 return name name_counts = {} df['is_duplicate'] = df.duplicated('StudentName', keep=False)
df['StudentName'] = df.apply(lambda x: add_number(x['StudentName'], name_counts) if x['is_duplicate'] else x['StudentName'], axis=1)
df.drop('is_duplicate', axis=1, inplace=True)
print(df)

Sortie :

 StudentName Score
0 Mark 45
1 Ali 65
2 Bob 76
3 John 44
4 Johny 39
5 Mark_1 45

Agréger des données avec des valeurs en double

Les données contenant des valeurs en double peuvent être agrégées pour résumer et obtenir des informations à partir des données. Les pandas groupby() La fonction vous permet d'agréger des données avec des valeurs en double. En utilisant le groupby() fonction, vous pouvez regrouper une ou plusieurs colonnes et calculer la moyenne, la médiane ou la somme d'une autre colonne pour chaque groupe.

Voici un exemple d'utilisation de groupby() méthode:

grouped = df.groupby(['StudentName']) df_aggregated = grouped.sum()
print(df_aggregated)

Sortie :

 Score
StudentName Ali 65
Bob 76
John 44
Johny 39
Mark 90

Techniques avancées

Pour gérer des scénarios plus complexes et garantir une analyse précise, nous pouvons utiliser certaines techniques avancées. Cette section traite de la gestion des doublons flous, de la duplication dans les données de séries chronologiques et des valeurs d'index en double.

Fuzzy Duplicates

Les doublons approximatifs sont des enregistrements qui ne sont pas des correspondances exactes mais qui sont similaires, et ils peuvent se produire pour diverses raisons, notamment des erreurs de saisie de données, des fautes d'orthographe et des variations de formatage. Nous utiliserons le fuzzywuzzy Bibliothèque Python pour identifier les doublons à l'aide de la correspondance de similarité de chaîne.

Voici un exemple de gestion des valeurs floues :

import pandas as pd
from fuzzywuzzy import fuzz def find_fuzzy_duplicates(dataframe, column, threshold): duplicates = [] for i in range(len(dataframe)): for j in range(i+1, len(dataframe)): similarity = fuzz.ratio(dataframe[column][i], dataframe[column][j]) if similarity >= threshold: duplicates.append(dataframe.iloc[[i, j]]) if duplicates: duplicates_df = pd.concat(duplicates) return duplicates_df else: return pd.DataFrame() data = { 'StudentName': ['Mark', 'Ali', 'Bob', 'John', 'Johny', 'Mark'], 'Score': [45, 65, 76, 44, 39, 45]
}
df = pd.DataFrame(data) threshold = 70 fuzzy_duplicates = find_fuzzy_duplicates(df, 'StudentName', threshold)
print("Fuzzy duplicates:")
print(fuzzy_duplicates.to_string(index=False))

Dans cet exemple, nous créons une fonction personnalisée find_fuzzy_duplicates qui prend un DataFrame, un nom de colonne et un seuil de similarité en entrée. La fonction parcourt chaque ligne du DataFrame et la compare aux lignes suivantes à l'aide de la propriété fuzz.ratio méthode de la fuzzywuzzy bibliothèque. Si le score de similarité est supérieur ou égal au seuil, les lignes en double sont ajoutées à une liste. Enfin, la fonction renvoie un DataFrame contenant les doublons flous.

Sortie :

Fuzzy duplicates:
StudentName Score Mark 45 Mark 45 John 44 Johny 39

Dans l'exemple ci-dessus, les doublons approximatifs sont identifiés dans la colonne "StudentName". La fonction 'find_fuzzy_duplicates' compare chaque paire de chaînes à l'aide de la fuzzywuzzy la bibliothèque fuzz.ratio qui calcule un score de similarité basé sur la distance de Levenshtein. Nous avons fixé le seuil à 70, ce qui signifie que tout nom avec un ratio de correspondance supérieur à 70 sera considéré comme une valeur floue. Après avoir identifié les valeurs floues, nous pouvons les gérer en utilisant la méthode décrite dans la section intitulée "Gestion des doublons".

Gestion des doublons de données de séries chronologiques

Des doublons peuvent se produire lorsque plusieurs observations sont enregistrées au même horodatage. Ces valeurs peuvent conduire à des résultats biaisés si elles ne sont pas correctement gérées. Voici quelques façons de gérer les valeurs en double dans les données de séries chronologiques.

• Suppression des doublons exacts: Dans cette méthode, nous supprimons les lignes identiques à l'aide de la drop_duplicates fonction dans Pandas.
• Horodatages en double avec des valeurs différentes: Si nous avons le même horodatage mais des valeurs différentes, nous pouvons agréger les données et obtenir plus d'informations en utilisant groupby(), ou nous pouvons sélectionner la valeur la plus récente et supprimer les autres en utilisant drop_duplicates() les keep paramètre défini sur 'dernier'.

Gestion des valeurs d'index en double

Avant de traiter les valeurs d'index en double, définissons d'abord ce qu'est un index dans Pandas. Un index est un identifiant unique attribué à chaque ligne du DataFrame. Pandas attribue un index numérique commençant à zéro par défaut. Cependant, un index peut être affecté à n'importe quelle colonne ou combinaison de colonnes. Pour identifier les doublons dans la colonne Index, nous pouvons utiliser le duplicated() ainsi que drop_duplicates() fonctions, respectivement. Dans cette section, nous allons explorer comment gérer les doublons dans la colonne Index en utilisant reset_index().

Comme son nom l'indique, le reset_index() La fonction dans Pandas est utilisée pour réinitialiser l'index d'un DataFrame. Lors de l'application de la reset_index() fonction, l'index actuel est automatiquement rejeté, ce qui signifie que les valeurs d'index initiales sont perdues. En précisant le drop paramètre comme False dans l' reset_index() fonction, nous pouvons conserver la valeur d'index d'origine tout en réinitialisant l'index.

Voici un exemple d'utilisation reset_index():

import pandas as pd data = { 'Score': [45, 65, 76, 44, 39, 45]
}
df = pd.DataFrame(data, index=['Mark', 'Ali', 'Bob', 'John', 'Johny', 'Mark']) df.reset_index(inplace=True)
print(df)

Sortie :

 index Score
0 Mark 45
1 Ali 65
2 Bob 76
3 John 44
4 Johny 39
5 Mark 45

Pratiques d'excellence

• Comprendre la nature des données en double: Avant d'entreprendre toute action, il est crucial de comprendre pourquoi les valeurs en double existent et ce qu'elles représentent. Identifiez la cause profonde, puis déterminez les étapes appropriées pour les gérer.

• Sélectionner une méthode appropriée pour gérer les doublons: Comme indiqué dans les sections précédentes, il existe plusieurs façons de gérer les doublons. La méthode que vous choisissez dépend de la nature des données et de l'analyse que vous souhaitez effectuer.

• Documenter l'approche: Il est essentiel de documenter le processus de détection des valeurs en double et de les traiter, permettant aux autres de comprendre le processus de réflexion.

• Faire preuve de prudence: Chaque fois que nous supprimons ou modifions des données, nous devons nous assurer que l'élimination des doublons n'introduit pas d'erreurs ou de biais dans l'analyse. Effectuez des tests de santé mentale et validez les résultats de chaque action.

• Conserver les données d'origine: Avant d'effectuer toute opération sur les données, créez une copie de sauvegarde des données d'origine.

• Empêcher les doublons futurs: Mettez en œuvre des mesures pour empêcher les doublons de se produire à l'avenir. Cela peut inclure la validation des données lors de la saisie des données, des routines de nettoyage des données ou des contraintes de base de données pour renforcer l'unicité.

Réflexions finales

Dans l'analyse des données, le traitement des valeurs en double est une étape cruciale. Les valeurs en double peuvent entraîner des résultats inexacts. En identifiant et en gérant efficacement les valeurs en double, les analystes de données peuvent obtenir des informations précises et significatives. La mise en œuvre des techniques mentionnées et le respect des meilleures pratiques permettront aux analystes de préserver l'intégrité de leurs données et d'en extraire des informations précieuses.

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• Financement EVM. Interface unifiée pour la finance décentralisée. Accéder ici.
• Groupe de médias quantiques. IR/PR amplifié. Accéder ici.
• PlatoAiStream. Intelligence des données Web3. Connaissance Amplifiée. Accéder ici.
• La source: https://stackabuse.com/handling-duplicate-values-in-a-pandas-dataframe/