Questions et Réponses d'Entretien Pandas

Introduction

Bienvenue dans ce guide complet conçu pour vous doter des connaissances et de la confiance nécessaires pour exceller lors d'entretiens liés à Pandas. Que vous soyez un analyste de données en herbe, un data scientist expérimenté ou un ingénieur ML, maîtriser Pandas est crucial pour une manipulation et une analyse efficaces des données. Ce document couvre systématiquement un large éventail de sujets, des concepts fondamentaux et des scénarios pratiques de manipulation de données aux techniques avancées, en passant par l'optimisation des performances et les applications réelles dans des environnements de production. Préparez-vous à approfondir votre compréhension et à affiner vos compétences, afin de vous assurer d'être bien préparé à tout défi Pandas qui se présentera à vous.

Concepts Fondamentaux de Pandas

Quelles sont les deux structures de données principales dans Pandas, et en quoi diffèrent-elles ?

Réponse :

Les deux structures de données principales sont la Series et le DataFrame. Une Series est un tableau unidimensionnel étiqueté capable de contenir tout type de données, similaire à une colonne dans une feuille de calcul. Un DataFrame est une structure de données bidimensionnelle étiquetée avec des colonnes de types potentiellement différents, ressemblant à un tableau ou une feuille de calcul.

Expliquez le concept d'« index » dans Pandas. Pourquoi est-il important ?

Réponse :

L'index dans Pandas est une étiquette pour les lignes ou les colonnes, fournissant un moyen d'identifier et d'accéder aux données de manière unique. Il est important pour l'alignement, la sélection et la manipulation efficaces des données, en particulier lors d'opérations telles que la fusion ou la jointure de DataFrames.

Comment créez-vous une Series et un DataFrame Pandas à partir d'un dictionnaire Python ?

Réponse :

Une Series peut être créée à partir d'un dictionnaire où les clés deviennent l'index et les valeurs deviennent les données. Un DataFrame peut être créé à partir d'un dictionnaire où les clés deviennent les noms de colonnes et les valeurs sont des listes/tableaux représentant les données des colonnes. Par exemple : pd.Series({'a': 1}) et pd.DataFrame({'col1': [1, 2]}).

Quelle est la différence entre loc et iloc pour la sélection de données ?

Réponse :

loc est principalement un index basé sur les étiquettes, utilisé pour sélectionner des données par les étiquettes de lignes et de colonnes. iloc est un index basé sur la position entière, utilisé pour sélectionner des données par la position entière des lignes et des colonnes. loc inclut l'étiquette de fin, tandis que iloc exclut l'entier de fin.

Comment gérez-vous les valeurs manquantes (NaN) dans un DataFrame Pandas ?

Réponse :

Les valeurs manquantes peuvent être gérées à l'aide de méthodes telles que isnull() ou isna() pour les détecter, dropna() pour supprimer les lignes/colonnes contenant des NaNs, ou fillna() pour remplacer les NaNs par une valeur spécifiée (par exemple, la moyenne, la médiane ou une constante). Le choix dépend des données et des objectifs de l'analyse.

Expliquez la méthode groupby() dans Pandas.

Réponse :

La méthode groupby() est utilisée pour regrouper les lignes d'un DataFrame en fonction d'une ou plusieurs valeurs de colonnes. Elle renvoie un objet GroupBy, qui peut ensuite être utilisé pour appliquer des fonctions d'agrégation (par exemple, sum(), mean(), count()) à chaque groupe, permettant des opérations de type split-apply-combine.

Quel est le but de apply() dans Pandas ?

Réponse :

La méthode apply() est utilisée pour appliquer une fonction le long d'un axe d'un DataFrame ou d'une Series. Elle est très flexible, vous permettant d'appliquer des fonctions personnalisées ou intégrées élément par élément, ligne par ligne ou colonne par colonne, ce qui est utile pour des transformations complexes non couvertes par les méthodes intégrées.

Comment effectuez-vous une opération de fusion entre deux DataFrames ?

Réponse :

La fonction pd.merge() est utilisée pour combiner deux DataFrames en fonction de colonnes ou d'index communs, similaire aux jointures SQL. Vous spécifiez les DataFrames, les colonnes clés (on ou left_on/right_on) et le type de jointure (how - par exemple, 'inner', 'outer', 'left', 'right').

Quelle est la différence entre copy() et l'affectation directe d'un DataFrame ?

Réponse :

L'affectation directe d'un DataFrame (par exemple, df2 = df1) crée une vue, ce qui signifie que df2 n'est qu'une autre référence aux mêmes données sous-jacentes que df1. Les modifications apportées à df2 affecteront df1. L'utilisation de df2 = df1.copy() crée une copie profonde, faisant de df2 un DataFrame indépendant avec ses propres données, de sorte que les modifications apportées à df2 n'affecteront pas df1.

Comment pouvez-vous changer le type de données d'une colonne dans un DataFrame ?

Réponse :

Vous pouvez changer le type de données d'une colonne en utilisant la méthode astype(). Par exemple, df['column_name'] = df['column_name'].astype('int') convertit la colonne en type entier. Ceci est crucial pour garantir des opérations de données correctes et une efficacité mémoire.

Scénarios de Manipulation et Transformation de Données

Comment gérez-vous les valeurs manquantes (NaN) dans un DataFrame Pandas ?

Réponse :

Les valeurs manquantes peuvent être gérées en utilisant df.dropna() pour supprimer les lignes/colonnes contenant des NaNs, ou df.fillna() pour remplacer les NaNs par une valeur spécifique (par exemple, 0, moyenne, médiane, ou remplissage avant/arrière). Le choix dépend des données et des objectifs de l'analyse.

Expliquez la différence entre loc et iloc pour l'indexation de DataFrame.

Réponse :

loc est principalement une indexation basée sur les étiquettes, ce qui signifie que vous utilisez les étiquettes de lignes/colonnes pour sélectionner les données. iloc est une indexation basée sur la position entière, ce qui signifie que vous utilisez les positions entières (de 0 à longueur-1) pour sélectionner les données. Les deux peuvent être utilisés pour des sélections uniques ou du slicing.

Comment effectuez-vous une opération de type JOIN SQL entre deux DataFrames dans Pandas ?

Réponse :

Les JOINs de type SQL sont effectués à l'aide de la fonction pd.merge(). Vous spécifiez les DataFrames, l'argument on pour les colonnes communes, et l'argument how pour le type de jointure (par exemple, 'inner', 'left', 'right', 'outer').

Décrivez comment grouper des données dans un DataFrame et appliquer une fonction d'agrégation.

Réponse :

Les données sont groupées en utilisant la méthode df.groupby(), en spécifiant la ou les colonnes par lesquelles grouper. Après le groupement, une fonction d'agrégation comme sum(), mean(), count(), min(), ou max() peut être appliquée à l'objet groupé pour résumer les données.

Comment pouvez-vous appliquer une fonction personnalisée à une colonne ou une ligne de DataFrame ?

Réponse :

Pour les opérations par colonne, utilisez df['column'].apply(custom_func). Pour les opérations par ligne ou élément par élément sur plusieurs colonnes, utilisez df.apply(custom_func, axis=1) pour les lignes ou df.apply(custom_func, axis=0) pour les colonnes. Les opérations vectorisées sont généralement préférées pour les performances.

À quoi sert pivot_table, et en quoi diffère-t-il de groupby ?

Réponse :

pivot_table est utilisé pour créer un tableau croisé dynamique de style feuille de calcul sous forme de DataFrame, résumant les données par une ou plusieurs clés de colonnes. Alors que groupby agrège les données en fonction d'une ou plusieurs clés, pivot_table permet également de "désempiler" (unstack) et de remodeler les données dans un nouveau format tabulaire avec des index, des colonnes et des valeurs spécifiés.

Comment changez-vous le type de données d'une colonne dans un DataFrame Pandas ?

Réponse :

Le type de données d'une colonne peut être changé en utilisant la méthode astype(), par exemple df['column'] = df['column'].astype('int') ou df['column'] = pd.to_datetime(df['column']) pour les dates. Ceci est crucial pour une manipulation et une analyse correctes des données.

Expliquez comment supprimer les lignes dupliquées d'un DataFrame.

Réponse :

Les lignes dupliquées peuvent être supprimées en utilisant la méthode df.drop_duplicates(). Par défaut, elle considère toutes les colonnes et conserve la première occurrence. Vous pouvez spécifier un sous-ensemble de colonnes en utilisant l'argument subset et si vous souhaitez conserver les doublons 'first', 'last', ou False (tous).

Comment créeriez-vous de nouvelles colonnes basées sur des colonnes existantes dans un DataFrame ?

Réponse :

De nouvelles colonnes peuvent être créées en effectuant des opérations sur des colonnes existantes, par exemple df['new_col'] = df['col1'] + df['col2']. Pour une logique plus complexe, la méthode apply() avec une fonction lambda ou une fonction définie peut être utilisée, ou np.where() pour les affectations conditionnelles.

Quel est le but de stack() et unstack() dans Pandas ?

Réponse :

stack() transforme un DataFrame (ou une Series) du format large au format long, en pivotant l'index de colonne le plus interne pour en faire l'index de ligne le plus interne. unstack() effectue l'opération inverse, en pivotant l'index de ligne le plus interne pour en faire l'index de colonne le plus interne, transformant du format long au format large.

Comment triez-vous un DataFrame par une ou plusieurs colonnes ?

Réponse :

Un DataFrame peut être trié en utilisant la méthode df.sort_values(). Vous spécifiez l'argument by avec un nom de colonne ou une liste de noms de colonnes. L'argument ascending (par défaut True) contrôle l'ordre de tri, et inplace=True peut modifier le DataFrame directement.

Quand utiliseriez-vous pd.concat() par rapport à pd.merge() ?

Réponse :

pd.concat() est utilisé pour combiner des DataFrames le long d'un axe (par ligne ou par colonne) lorsqu'ils ont des structures similaires ou que vous souhaitez les empiler. pd.merge() est utilisé pour combiner des DataFrames basés sur des colonnes communes (clés), similaire aux jointures SQL, lorsque vous souhaitez combiner des données liées provenant de différentes sources.

Techniques Avancées et Optimisations Pandas

Comment optimiser l'utilisation de la mémoire dans les DataFrames Pandas, en particulier pour les grands ensembles de données ?

Réponse :

L'optimisation de la mémoire implique l'utilisation de types de données appropriés (par exemple, category pour les chaînes de faible cardinalité, int8/int16 pour les petits entiers), la réduction de la taille des types numériques, et l'évitement des colonnes d'objets inutiles. La méthode df.info(memory_usage='deep') aide à identifier les éléments gourmands en mémoire.

Expliquez la différence entre apply(), map(), et applymap() dans Pandas et quand utiliser chacun.

Réponse :

map() est pour les Series, application élément par élément. apply() est pour les Series ou les DataFrames, appliquant une fonction le long d'un axe (ligne/colonne). applymap() est pour les DataFrames, application élément par élément sur tous les éléments. map() et apply() sont généralement préférés pour les performances par rapport à applymap() lorsque c'est possible.

Quand utiliseriez-vous groupby().transform() par rapport à groupby().apply() ?

Réponse :

transform() renvoie une Series/DataFrame avec le même index que l'original, diffusant le résultat agrégé à la forme originale. apply() est plus flexible, permettant des fonctions arbitraires qui peuvent renvoyer une Series, un DataFrame, ou un scalaire, mais il peut ne pas préserver l'index ou la forme originale.

Décrivez le concept de "chaînage" d'opérations dans Pandas et pourquoi il est généralement déconseillé.

Réponse :

Le chaînage fait référence à l'exécution de plusieurs opérations sur un DataFrame en une seule ligne sans affecter les résultats intermédiaires. Il est déconseillé car il peut entraîner un SettingWithCopyWarning dû à des vues vs copies ambiguës, rendant le code plus difficile à déboguer et produisant potentiellement des résultats incorrects. Les affectations intermédiaires explicites sont plus sûres.

Comment gérez-vous le SettingWithCopyWarning dans Pandas ?

Réponse :

Cet avertissement se produit lorsque Pandas ne peut pas déterminer de manière définitive si une opération porte sur une vue ou une copie. Pour le résoudre, utilisez .loc[] pour l'indexation et l'affectation explicites, en vous assurant que vous opérez sur une copie si une modification est prévue, ou sur une vue si ce n'est pas le cas. Par exemple, df.loc[rows, cols] = value.

Quelles sont quelques méthodes courantes pour accélérer les opérations sur de grands DataFrames au-delà des opérations vectorisées de base ?

Réponse :

Au-delà de la vectorisation, envisagez d'utiliser Numba pour la compilation JIT de fonctions personnalisées, Cython pour écrire des parties critiques en performance en C, ou Dask pour le calcul hors mémoire et parallèle. Pour des tâches spécifiques, les méthodes intégrées de Pandas sont souvent hautement optimisées.

Expliquez le but du type de données pd.Categorical et ses avantages.

Réponse :

pd.Categorical est destiné à représenter des données catégorielles, où les valeurs sont limitées à un ensemble fixe de possibilités. Il économise de la mémoire en stockant des entiers au lieu de chaînes répétées et peut accélérer considérablement les opérations comme groupby() et le tri, en particulier pour les colonnes à faible cardinalité.

Comment lire efficacement de grands fichiers CSV dans Pandas sans manquer de mémoire ?

Réponse :

Utilisez chunksize dans pd.read_csv() pour lire le fichier en parties plus petites, en traitant chaque partie itérativement. Spécifiez dtype pour les colonnes afin d'optimiser l'utilisation de la mémoire dès le départ. Sélectionnez uniquement les colonnes nécessaires à l'aide du paramètre usecols.

Quelle est la signification du paramètre inplace dans les méthodes Pandas, et pourquoi son utilisation est-elle souvent déconseillée ?

Réponse :

inplace=True modifie le DataFrame directement sans en retourner un nouveau, économisant ainsi de la mémoire. Cependant, cela interrompt le chaînage des méthodes, rend le débogage plus difficile et peut entraîner un comportement inattendu si ce n'est pas géré avec soin. Il est généralement recommandé d'affecter le résultat à une nouvelle variable à la place.

Décrivez comment effectuer un rééchantillonnage et une agrégation de séries temporelles dans Pandas.

Réponse :

Utilisez la méthode .resample() sur un DataFrame avec un DateTimeIndex. Spécifiez la fréquence souhaitée (par exemple, 'D' pour journalier, 'M' pour mensuel). Ensuite, appliquez une fonction d'agrégation comme .mean(), .sum(), ou .ohlc() à l'objet rééchantillonné.

Application Pratique et Résolution de Problèmes

Vous avez un DataFrame avec des données de commandes clients, incluant 'customer_id', 'order_date', et 'total_amount'. Comment trouveriez-vous les 5 meilleurs clients par dépense totale ?

Réponse :

Groupez le DataFrame par 'customer_id', additionnez 'total_amount' pour chaque client, puis triez par ordre décroissant. Enfin, sélectionnez les 5 premières entrées en utilisant .head(5).

Étant donné un DataFrame avec une colonne 'timestamp', comment extrairiez-vous l'année et le mois dans de nouvelles colonnes séparées ?

Réponse :

Tout d'abord, assurez-vous que la colonne 'timestamp' est de type datetime. Ensuite, utilisez l'accesseur .dt pour extraire l'année et le mois : df['year'] = df['timestamp'].dt.year et df['month'] = df['timestamp'].dt.month.

Vous avez un DataFrame avec des valeurs manquantes. Décrivez deux stratégies courantes pour les gérer et quand vous pourriez choisir l'une plutôt que l'autre.

Réponse :

Deux stratégies sont la suppression des lignes/colonnes avec df.dropna() ou le remplissage des valeurs manquantes avec df.fillna(). dropna est adapté lorsque les données manquantes sont minimes ou aléatoires. fillna est préféré lorsque vous pouvez imputer des valeurs (par exemple, moyenne, médiane ou une constante spécifique) sans distordre significativement la distribution des données.

Comment effectueriez-vous une jointure gauche (left join) entre deux DataFrames, df1 (avec 'id' et 'name') et df2 (avec 'id' et 'value'), en conservant toutes les lignes de df1 ?

Réponse :

Utilisez pd.merge(df1, df2, on='id', how='left'). Cela inclura toutes les lignes de df1 et les lignes correspondantes de df2. Si aucune correspondance n'est trouvée dans df2, NaN sera placé dans les colonnes de df2.

Vous avez une colonne 'price' dans votre DataFrame qui est actuellement stockée sous forme de chaîne de caractères (par exemple, '$12.50'). Comment la convertiriez-vous en un type numérique ?

Réponse :

Tout d'abord, supprimez le symbole '' en utilisant la manipulation de chaînes de caractères : `df['price'] = df['price'].str.replace('', ''). Ensuite, convertissez la colonne en un type numérique en utilisant pd.to_numeric(df['price'])`.

Décrivez un scénario où vous utiliseriez pivot_table au lieu de groupby.

Réponse :

pivot_table est idéal pour remodeler les données, créant un tableau croisé dynamique de style feuille de calcul avec une ou plusieurs colonnes comme index, une ou plusieurs colonnes comme colonnes, et une fonction d'agrégation. groupby est plus général pour diviser les données en groupes et appliquer une fonction à chaque groupe, renvoyant une Series ou un DataFrame.

Comment pouvez-vous appliquer efficacement une fonction personnalisée à chaque ligne d'un DataFrame ?

Réponse :

La méthode la plus efficace est souvent d'utiliser df.apply(axis=1) avec une fonction lambda ou une fonction définie. Pour les opérations élément par élément, les opérations vectorisées de Pandas ou les fonctions NumPy sont encore plus rapides si elles sont applicables.

Vous devez identifier et supprimer les lignes dupliquées en vous basant sur un sous-ensemble de colonnes (par exemple, 'customer_id' et 'order_date'). Comment feriez-vous cela ?

Réponse :

Utilisez df.drop_duplicates(subset=['customer_id', 'order_date'], keep='first'). keep='first' conserve la première occurrence de l'ensemble de doublons, tandis que keep='last' conserve la dernière, et keep=False supprime tous les doublons.

Comment calculeriez-vous une moyenne mobile sur 7 jours d'une colonne 'sales' dans un DataFrame de séries temporelles ?

Réponse :

Tout d'abord, assurez-vous que le DataFrame est trié par date. Ensuite, utilisez la méthode .rolling() : df['sales_rolling_avg'] = df['sales'].rolling(window=7).mean(). Cela calcule la moyenne de la valeur actuelle et des 6 valeurs précédentes.

Vous avez un DataFrame avec une colonne 'category'. Comment compteriez-vous les occurrences de chaque catégorie unique ?

Réponse :

Utilisez la méthode value_counts() sur la colonne 'category' : df['category'].value_counts(). Cela renvoie une Series avec les valeurs uniques comme index et leurs comptes comme valeurs, triées par ordre décroissant.

Optimisation des Performances et Bonnes Pratiques

Quelles sont les raisons courantes des opérations Pandas lentes ?

Réponse :

Les raisons courantes incluent l'itération sur les DataFrames ligne par ligne, les types de données inefficaces (par exemple, 'object' pour les nombres), une utilisation excessive de la mémoire entraînant du swapping, et les opérations non vectorisées. Les grands ensembles de données prennent également naturellement plus de temps à traiter.

Comment éviter les boucles explicites (par exemple, les boucles for) lorsque vous travaillez avec des DataFrames Pandas ?

Réponse :

Évitez les boucles explicites en utilisant les opérations vectorisées fournies par Pandas (par exemple, df['col'] * 2), les méthodes intégrées (.apply(), .map(), .transform()), et les fonctions NumPy. Ces opérations sont implémentées en C et sont significativement plus rapides.

Expliquez la différence entre .apply(), .map(), et .applymap() en termes de performance et de cas d'utilisation.

Réponse :

.map() est pour les opérations élément par élément au niveau de la Series. .apply() peut opérer ligne par ligne, colonne par colonne, ou sur une Series. .applymap() est pour les opérations élément par élément sur l'ensemble du DataFrame. Généralement, les opérations vectorisées sont plus rapides que les trois, mais .map() est souvent plus rapide que .apply() pour les Series.

Quand devriez-vous envisager d'utiliser Numba ou Cython avec Pandas ?

Réponse :

Envisagez Numba ou Cython lorsque vous avez des opérations complexes et non vectorisables qui constituent des goulots d'étranglement de performance. Ils compilent le code Python en code machine, offrant des accélérations significatives pour les algorithmes numériques, en particulier lorsqu'ils sont utilisés avec .apply() ou des fonctions personnalisées.

Comment pouvez-vous optimiser l'utilisation de la mémoire dans les DataFrames Pandas ?

Réponse :

Optimisez la mémoire en utilisant des types de données appropriés (par exemple, int8, float32, category pour les chaînes de faible cardinalité), en supprimant les colonnes inutiles, et en traitant les données par morceaux si l'ensemble de données est trop volumineux pour tenir en mémoire. La méthode .info(memory_usage='deep') aide à identifier les éléments gourmands en mémoire.

Quel est l'avantage d'utiliser le dtype category pour les colonnes de chaînes de caractères ?

Réponse :

L'utilisation du dtype category réduit considérablement l'utilisation de la mémoire pour les colonnes de chaînes de caractères avec un nombre limité de valeurs uniques (faible cardinalité). Il stocke les chaînes sous forme de codes entiers et d'une table de correspondance, rendant les opérations comme le regroupement et le tri beaucoup plus rapides.

Comment lire efficacement de grands fichiers CSV dans Pandas ?

Réponse :

Lisez efficacement de grands fichiers CSV en spécifiant dtype pour les colonnes, en utilisant chunksize pour lire par itérations, en sélectionnant uniquement les colonnes nécessaires avec usecols, et en définissant nrows pour l'échantillonnage. Cela évite de charger l'intégralité du fichier en mémoire en une seule fois.

Décrivez l'importance de inplace=True et ses pièges potentiels.

Réponse :

inplace=True modifie le DataFrame directement sans en retourner un nouveau, économisant potentiellement de la mémoire. Cependant, cela peut rendre le chaînage des opérations difficile et moins lisible, et est généralement déconseillé dans Pandas moderne pour plus de clarté et pour éviter des effets secondaires inattendus.

Lors de l'exécution d'opérations groupby, quelles sont les considérations de performance ?

Réponse :

Les considérations de performance pour groupby incluent le nombre de groupes, la complexité de la fonction d'agrégation et les types de données des clés de regroupement. L'utilisation du dtype category pour les clés de regroupement peut considérablement accélérer les opérations. Évitez les fonctions Python personnalisées si des alternatives vectorisées existent.

Comment pouvez-vous profiler le code Pandas pour identifier les goulots d'étranglement de performance ?

Réponse :

Profilez le code Pandas en utilisant des outils comme cProfile ou line_profiler pour identifier quelles parties de votre code consomment le plus de temps. Les commandes magiques %timeit et %prun de Jupyter sont également très utiles pour un profilage rapide de lignes ou de cellules spécifiques.

Troubleshooting and Debugging Pandas Code

How do you typically start debugging a Pandas DataFrame that is not behaving as expected?

Answer:

I usually start by inspecting the DataFrame's info(), head(), tail(), and dtypes to understand its structure and data types. Checking df.shape and df.isnull().sum() also helps identify missing values or unexpected dimensions early on.

You're getting a SettingWithCopyWarning. What does it mean, and how do you resolve it?

Answer:

This warning indicates that you might be operating on a view of a DataFrame slice, and your modifications might not be reflected in the original DataFrame. To resolve it, explicitly use .loc or .iloc for chained indexing to ensure you're working on a copy or the original DataFrame directly, e.g., df.loc[rows, cols] = value.

How would you debug slow Pandas operations, especially when dealing with large datasets?

Answer:

For slow operations, I'd use %%timeit in Jupyter notebooks or Python's time module to benchmark specific code blocks. Profilers like cProfile can pinpoint bottlenecks. Often, vectorizing operations instead of using explicit loops, or optimizing data types, significantly improves performance.

You're trying to perform an operation, but Pandas raises a TypeError. What's your first step to diagnose it?

Answer:

A TypeError often indicates a mismatch in data types for an operation. My first step is to check the dtypes of the relevant columns using df.dtypes. I'd then ensure all involved columns have compatible types, converting them if necessary using astype().

Describe a common scenario where NaN values can cause unexpected behavior, and how you'd handle it.

Answer:

NaN values can cause issues in aggregations (e.g., sum() might ignore them, mean() might be skewed) or when performing mathematical operations. I'd use df.isnull().sum() to identify them, then decide whether to fillna() with a suitable value (mean, median, zero) or dropna() based on the context and data integrity requirements.

How do you check for and handle duplicate rows or values in a specific column?

Answer:

To check for duplicate rows, I use df.duplicated().sum(). To identify duplicates based on specific columns, I'd use df.duplicated(subset=['col1', 'col2']).sum(). To remove them, I'd use df.drop_duplicates() or df.drop_duplicates(subset=['col1']).

You're merging two DataFrames, and the resulting DataFrame has fewer rows than expected. What could be the issue?

Answer:

This usually indicates an issue with the merge key(s) or the how parameter of the merge operation. I'd check for mismatches in the key columns (e.g., different spellings, leading/trailing spaces, data types) and ensure the how parameter (e.g., 'inner', 'left', 'right', 'outer') aligns with the desired outcome.

What is the purpose of pd.set_option() in debugging, and when would you use it?

Answer:

pd.set_option() allows you to modify Pandas display options, which is crucial for debugging. I'd use it to display more rows (display.max_rows), columns (display.max_columns), or to prevent truncation of column content (display.max_colwidth) when inspecting large DataFrames or specific values.

You're getting a KeyError when trying to access a column. What's the most likely reason and how do you confirm it?

Answer:

A KeyError typically means the column name you're trying to access does not exist in the DataFrame. I'd confirm this by printing df.columns to see the exact column names and check for typos, case sensitivity issues, or leading/trailing spaces in the column name I'm using.

Dépannage et débogage du code Pandas

Comment commencez-vous généralement à déboguer un DataFrame Pandas qui ne se comporte pas comme prévu ?

Réponse :

Je commence généralement par inspecter les méthodes info(), head(), tail() et dtypes du DataFrame pour comprendre sa structure et ses types de données. La vérification de df.shape et df.isnull().sum() aide également à identifier tôt les valeurs manquantes ou les dimensions inattendues.

Vous recevez un SettingWithCopyWarning. Que signifie-t-il et comment le résoudre ?

Réponse :

Cet avertissement indique que vous travaillez peut-être sur une vue d'une tranche de DataFrame, et que vos modifications pourraient ne pas être reflétées dans le DataFrame d'origine. Pour le résoudre, utilisez explicitement .loc ou .iloc pour l'indexation chaînée afin de vous assurer que vous travaillez sur une copie ou directement sur le DataFrame d'origine, par exemple, df.loc[rows, cols] = value.

Comment débogueriez-vous les opérations Pandas lentes, en particulier lorsque vous traitez de grands ensembles de données ?

Réponse :

Pour les opérations lentes, j'utiliserais %%timeit dans les notebooks Jupyter ou le module time de Python pour évaluer des blocs de code spécifiques. Les profileurs comme cProfile peuvent identifier les goulots d'étranglement. Souvent, la vectorisation des opérations au lieu de l'utilisation de boucles explicites, ou l'optimisation des types de données, améliore considérablement les performances.

Vous essayez d'effectuer une opération, mais Pandas lève une TypeError. Quelle est votre première étape pour la diagnostiquer ?

Réponse :

Une TypeError indique souvent une incompatibilité de types de données pour une opération. Ma première étape consiste à vérifier les dtypes des colonnes pertinentes à l'aide de df.dtypes. Je m'assurerais ensuite que toutes les colonnes impliquées ont des types compatibles, en les convertissant si nécessaire à l'aide de astype().

Décrivez un scénario courant où les valeurs NaN peuvent causer un comportement inattendu, et comment vous le géreriez.

Réponse :

Les valeurs NaN peuvent causer des problèmes dans les agrégations (par exemple, sum() pourrait les ignorer, mean() pourrait être biaisé) ou lors de l'exécution d'opérations mathématiques. J'utiliserais df.isnull().sum() pour les identifier, puis je déciderais de fillna() avec une valeur appropriée (moyenne, médiane, zéro) ou de dropna() en fonction du contexte et des exigences d'intégrité des données.

Comment vérifiez-vous et gérez-vous les lignes ou valeurs dupliquées dans une colonne spécifique ?

Réponse :

Pour vérifier les lignes dupliquées, j'utilise df.duplicated().sum(). Pour identifier les doublons basés sur des colonnes spécifiques, j'utiliserais df.duplicated(subset=['col1', 'col2']).sum(). Pour les supprimer, j'utiliserais df.drop_duplicates() ou df.drop_duplicates(subset=['col1']).

Vous fusionnez deux DataFrames, et le DataFrame résultant a moins de lignes que prévu. Quel pourrait être le problème ?

Réponse :

Cela indique généralement un problème avec la ou les clés de fusion ou le paramètre how de l'opération merge. Je vérifierais les incompatibilités dans les colonnes clés (par exemple, orthographes différentes, espaces en début/fin, types de données) et je m'assurerais que le paramètre how (par exemple, 'inner', 'left', 'right', 'outer') correspond au résultat souhaité.

Quel est le but de pd.set_option() dans le débogage, et quand l'utiliseriez-vous ?

Réponse :

pd.set_option() vous permet de modifier les options d'affichage de Pandas, ce qui est crucial pour le débogage. Je l'utiliserais pour afficher plus de lignes (display.max_rows), de colonnes (display.max_columns), ou pour empêcher la troncature du contenu des colonnes (display.max_colwidth) lors de l'inspection de grands DataFrames ou de valeurs spécifiques.

Vous recevez une KeyError en essayant d'accéder à une colonne. Quelle est la raison la plus probable et comment la confirmer ?

Réponse :

Une KeyError signifie généralement que le nom de colonne auquel vous essayez d'accéder n'existe pas dans le DataFrame. Je le confirmerais en imprimant df.columns pour voir les noms de colonnes exacts et vérifier les fautes de frappe, les problèmes de sensibilité à la casse ou les espaces en début/fin dans le nom de colonne que j'utilise.

Applications Pandas spécifiques aux rôles (par exemple, Analyste de données, Data Scientist, Ingénieur ML)

En tant qu'Analyste de données, vous recevez un CSV avec des données clients. Comment utiliseriez-vous Pandas pour identifier et résumer rapidement les valeurs manquantes dans des colonnes clés comme 'email' et 'phone_number' ?

Réponse :

J'utiliserais df[['email', 'phone_number']].isnull().sum() pour compter les valeurs manquantes par colonne. Pour un pourcentage, je diviserais par len(df). Cela met rapidement en évidence les problèmes de qualité des données pour le reporting.

Pour un Data Scientist, vous préparez un ensemble de données pour l'apprentissage automatique. Décrivez comment vous utiliseriez Pandas pour effectuer un encodage one-hot sur une colonne catégorielle comme 'product_category', puis le fusionner dans le DataFrame d'origine.

Réponse :

J'utiliserais pd.get_dummies(df['product_category'], prefix='category') pour créer le DataFrame encodé en one-hot. Ensuite, j'utiliserais pd.concat([df, one_hot_df], axis=1) et supprimerais la colonne d'origine 'product_category' pour l'intégrer.

Un ingénieur ML doit charger un grand ensemble de données (plus de 10 Go) pour l'entraînement de modèles. Comment utiliseriez-vous Pandas pour charger efficacement et potentiellement échantillonner ces données, en tenant compte des contraintes de mémoire ?

Réponse :

Pour les fichiers volumineux, j'utiliserais pd.read_csv(..., chunksize=...) pour traiter par morceaux, ou je spécifierais dtype pour optimiser la mémoire. Pour l'échantillonnage, j'utiliserais df.sample(frac=0.1) ou df.sample(n=100000) après avoir chargé un sous-ensemble ou par morceaux.

En tant qu'Analyste de données, vous devez calculer les tendances de ventes mensuelles à partir d'un DataFrame de ventes quotidiennes. Comment y parviendriez-vous en utilisant Pandas, en supposant une colonne 'sale_date' et une colonne 'revenue' ?

Réponse :

Je m'assurerais d'abord que 'sale_date' est de type datetime en utilisant pd.to_datetime(). Ensuite, je définirais 'sale_date' comme index et utiliserais df['revenue'].resample('M').sum() pour agréger les revenus par mois.

Un Data Scientist effectue de l'ingénierie de caractéristiques (feature engineering). Comment utiliseriez-vous Pandas pour créer une nouvelle caractéristique 'age_group' à partir d'une colonne 'age', en catégorisant les clients en '0-18', '19-35', '36-60', '60+' ?

Réponse :

J'utiliserais pd.cut(df['age'], bins=[0, 18, 35, 60, np.inf], labels=['0-18', '19-35', '36-60', '60+'], right=True). Cela permet de regrouper efficacement les données numériques en catégories spécifiées.

Un ingénieur ML doit diviser un DataFrame Pandas en ensembles d'entraînement, de validation et de test tout en assurant la stratification sur une variable cible 'is_fraud'. Comment aborderiez-vous cela en utilisant Pandas et scikit-learn ?

Réponse :

J'utiliserais train_test_split de scikit-learn, en passant stratify=df['is_fraud'] pour assurer l'équilibre des classes. Je l'appellerais deux fois : une fois pour train/temp, puis temp pour validation/test.

En tant qu'Analyste de données, vous devez fusionner deux DataFrames : customers (avec 'customer_id') et orders (avec 'customer_id' et 'order_id'). Comment effectueriez-vous une jointure interne (inner join) pour voir uniquement les clients qui ont passé des commandes ?

Réponse :

J'utiliserais pd.merge(customers_df, orders_df, on='customer_id', how='inner'). Cela combine efficacement les DataFrames sur la colonne commune 'customer_id', en ne conservant que les lignes correspondantes.

Un Data Scientist travaille avec des données de séries temporelles et doit calculer une moyenne mobile sur 7 jours d'une colonne 'temperature'. Comment feriez-vous cela dans Pandas ?

Réponse :

En supposant un index de type datetime, j'utiliserais df['temperature'].rolling(window='7D').mean(). Si ce n'est pas indexé, je définirais d'abord la colonne datetime comme index.

Un ingénieur ML déploie un modèle qui nécessite un ordre de colonnes et des types de données spécifiques. Comment utiliseriez-vous Pandas pour imposer cette structure aux données d'inférence entrantes avant de les passer au modèle ?

Réponse :

Je réindexerai d'abord le DataFrame en utilisant df = df[expected_column_order] pour imposer l'ordre des colonnes. Ensuite, j'utiliserais df = df.astype(expected_dtypes) pour convertir les colonnes vers leurs types de données requis.

En tant qu'Analyste de données, vous devez pivoter un DataFrame pour résumer les 'sales' par 'region' et 'product_type'. Comment utiliseriez-vous pivot_table pour cela ?

Réponse :

J'utiliserais pd.pivot_table(df, values='sales', index='region', columns='product_type', aggfunc='sum'). Cela crée un tableau récapitulatif avec les régions comme lignes, les types de produits comme colonnes et les ventes totales comme valeurs.

Résumé

Maîtriser Pandas pour les entretiens en science des données est un parcours qui récompense la préparation et la persévérance. En examinant diligemment ces questions et en comprenant les concepts sous-jacents, vous vous êtes doté des connaissances nécessaires pour aborder avec confiance les défis courants et démontrer votre maîtrise de la manipulation et de l'analyse des données.

N'oubliez pas que le paysage de la science des données est en constante évolution. Continuez à explorer de nouvelles fonctionnalités, à pratiquer avec des ensembles de données variés et à interagir avec la communauté Pandas. Votre engagement envers l'apprentissage continu améliorera non seulement vos performances en entretien, mais renforcera également votre expertise en tant que professionnel des données. Bonne chance !