Utiliser Pandas et SQL ensemble pour l'analyse des données

Dans ce didacticiel, nous explorerons quand et comment la fonctionnalité SQL peut être intégrée dans le framework Pandas, ainsi que ses limites.

SQL, ou Structured Query Language, est depuis longtemps l'outil incontournable pour la gestion des données, mais il arrive parfois qu'il ne soit pas à la hauteur, nécessitant la puissance et la flexibilité d'un outil tel que Python. Python, un langage de programmation polyvalent et polyvalent, excelle dans l'accès, l'extraction, la gestion et l'exploration des données à partir de bases de données relationnelles. Au sein de Python, la bibliothèque open source Pandas est spécialement conçue pour la manipulation et l'analyse de données.

Dans ce didacticiel, nous explorerons quand et comment la fonctionnalité SQL peut être intégrée dans le framework Pandas, ainsi que ses limites.

La principale question que vous vous posez peut-être en ce moment est...

Pourquoi utiliser les deux ?

La raison réside dans la lisibilité et la familiarité : dans certains cas, notamment dans les workflows complexes, les requêtes SQL peuvent être beaucoup plus claires et plus faciles à lire que le code Pandas équivalent. Cela est particulièrement vrai pour ceux qui ont commencé à travailler avec des données en SQL avant de passer à Pandas.

De plus, comme la plupart des données proviennent de bases de données, SQL — étant le langage natif de ces bases de données — offre un avantage naturel. C'est pourquoi de nombreux professionnels des données, en particulier les data scientists, intègrent souvent SQL et Python (en particulier Pandas) dans le même pipeline de données pour exploiter les atouts de chacun.

Pour voir la lisibilité SQL en action, utilisons le fichier csv pokemon gen1 pokedex suivant.

Imaginez que nous souhaitions trier le DataFrame par la colonne "Total" par ordre croissant et afficher les 5 premiers. Nous pouvons maintenant comparer comment effectuer la même action avec Pandas et SQL.

Utiliser Pandas avec Python :

data[["#", "Name", "Total"]].sort_values(by="Total", ascending=True).head(5)

Utilisation de SQL :

SELECT 
     "#", 
     Name, 
     Total
FROM data
ORDER  BY Total
LIMIT 5

Vous voyez à quel point les deux sont différents, n'est-ce pas ? Mais... comment combiner les deux langages au sein de notre environnement de travail avec Python ?

La solution utilise PandaSQL !

Utiliser PandaSQL

Pandas est une puissante bibliothèque Python d'analyse et de manipulation de données open source. PandaSQL permet d'utiliser la syntaxe SQL pour interroger les Pandas DataFrames. Pour les nouveaux utilisateurs de Pandas, PandaSQL essaie de rendre la manipulation et le nettoyage des données plus familiers. Vous pouvez utiliser PandaSQL pour interroger les Pandas DataFrames à l'aide de la syntaxe SQL.

Jetons un coup d'oeil.

Tout d'abord, nous devons installer PandaSQL :

pip install pandasql

Ensuite (comme toujours), nous importons les packages requis :

from pandasql import sqldf

Ici, nous avons directement importé la fonction sqldf de PandaSQL, qui est essentiellement la fonctionnalité principale de la bibliothèque. Comme son nom l'indique, sqldf vous permet d'interroger des DataFrames en utilisant la syntaxe SQL.

sqldf(query_string, env=None)

Dans ce contexte, query_string est un paramètre obligatoire qui accepte une requête SQL au format chaîne. Le paramètre env, facultatif et rarement utilisé, peut être défini sur locals() ou globals(), activant sqldf pour accéder aux variables de la portée spécifiée dans votre environnement Python.
Au-delà de cette fonction, PandaSQL comprend également deux ensembles de données intégrés de base qui peuvent être chargés avec les fonctions simples : load_births() et load_meat(). De cette façon, vous disposez de données factices avec lesquelles jouer directement.

Alors maintenant, si nous voulons exécuter la requête SQL précédente dans notre notebook Python Jupyter, cela ressemblerait à quelque chose comme ceci :

from pandasql import sqldf
import pandas as pd

sqldf('''
     SELECT "#", Name, Total
     FROM data
     ORDER  BY Total
     LIMIT 5''')

La fonction sqldf renvoie le résultat d'une requête sous forme de Pandas DataFrame.

Quand devrions-nous l'utiliser

La bibliothèque pandasql permet la manipulation de données à l'aide du langage de requête de données (DQL) de SQL, offrant une approche familière basée sur SQL pour interagir avec les données dans Pandas DataFrames.

Avec pandasql, vous pouvez exécuter des requêtes directement sur votre ensemble de données, permettant une récupération, un filtrage, un tri, un regroupement, une jointure et une agrégation efficaces des données.

De plus, il prend en charge l'exécution d'opérations mathématiques et logiques, ce qui en fait un outil puissant pour les utilisateurs avertis en SQL travaillant avec des données en Python.

PandaSQL est limité au sous-ensemble DQL (Data Query Language) de SQL, ce qui signifie qu'il ne prend pas en charge la modification de tables ou de données (actions telles que UPDATE, INSERT ou DELETE ne sont pas disponibles.

De plus, étant donné que PandaSQL s'appuie sur la syntaxe SQL, en particulier SQLite, il est essentiel d'être attentif aux bizarreries spécifiques à SQLite qui peuvent affecter le comportement des requêtes.

Comparaison de PandasSQL et SQL

Cette section montre comment PandaSQL et Pandas peuvent tous deux être utilisés pour obtenir des résultats similaires, en proposant des comparaisons côte à côte pour mettre en évidence leurs approches respectives.

Générer plusieurs tables

Générons des sous-ensembles de données à partir d'un ensemble de données plus vaste, en créant des tableaux tels que des types, des légendaires, des générations et des fonctionnalités. Grâce à PandaSQL, nous pouvons spécifier des requêtes SQL pour sélectionner des colonnes spécifiques, ce qui facilite l'extraction des données exactes souhaitées.

Utilisation de PandaSQL :

types = sqldf('''
     SELECT "#", Name, "Type 1", "Type 2"
     FROM data''')

legendaries = sqldf('''
     SELECT "#", Name, Legendary
     FROM data''')

generations = sqldf('''
     SELECT "#", Name, Generation
     FROM data''')

features = sqldf('''
     SELECT "#", Name, Total, HP, Attack, Defense, "Sp. Atk", "Sp. Def","Speed"
     FROM data''')

Ici, PandaSQL permet une syntaxe de sélection propre, basée sur SQL, qui peut sembler intuitive aux utilisateurs familiarisés avec les bases de données relationnelles. Ceci est particulièrement utile si la sélection de données implique des conditions complexes ou des fonctions SQL.

En utilisant du Python pur :

# Selecting columns for types
types = data[['#', 'Name', 'Type 1', 'Type 2']]

# Selecting columns for legendaries
legendaries = data[['#','Name', 'Legendary']]

# Selecting columns for generations
generations = data[['#','Name', 'Generation']]

# Selecting columns for features
features = data[['#','Name', 'Total', 'HP', 'Attack', 'Defense', 'Sp. Atk', 'Sp. Def', 'Speed']]

En Python pur, nous obtenons le même résultat en spécifiant simplement les noms de colonnes entre crochets. Bien que cela soit efficace pour une sélection simple de colonnes, cela peut devenir moins lisible avec des conditions de filtrage ou de regroupement plus complexes, où la syntaxe de style SQL peut être plus naturelle.

Effectuer des JOIN

Les jointures sont un moyen puissant de combiner des données provenant de plusieurs sources en fonction de colonnes communes, et PandaSQL et Pandas le prennent en charge.

Tout d'abord, PandaSQL :

types_features = sqldf('''
     SELECT
       t1.*,
       t2.Total,
       t2.HP,
       t2.Attack,
       t2.Defense,
       t2."Sp. Atk",
       t2."Sp. Def",
       t2."Speed"
     FROM types AS t1
     LEFT JOIN features AS t2
       ON  t1."#" = t2."#"
       AND t1.Name = t2.Name
''')

En utilisant SQL, ce LEFT JOIN combine des types et des fonctionnalités en fonction des valeurs correspondantes dans les colonnes # et Name. Cette approche est simple pour les utilisateurs SQL, avec une syntaxe claire pour sélectionner des colonnes spécifiques et combiner les données de plusieurs tables.

En Python pur :

# Performing a left join between `types` and `features` on the columns "#" and "Name"
types_features = types.merge(
   features,
   on=['#', 'Name'],
   how='left'
)

types_features

En Python pur, nous obtenons le même résultat en utilisant la fonction merge(), en spécifiant on pour les colonnes correspondantes et how='left' pour effectuer une jointure à gauche. Pandas facilite la fusion sur plusieurs colonnes et offre une flexibilité dans la spécification des types de jointure. Cependant, la syntaxe de jointure de style SQL peut être plus lisible lorsque vous travaillez avec des tables plus volumineuses ou lorsque vous effectuez des jointures plus complexes.

Requête personnalisée

Dans cet exemple, nous récupérons les 5 premiers enregistrements basés sur « Défense », triés par ordre décroissant.

PandaSQL :

top_5_defense = sqldf('''
     SELECT
       Name, Defense
     FROM features
     ORDER BY Defense DESC
     LIMIT 5
''')

La requête SQL trie les fonctionnalités par colonne Défense par ordre décroissant et limite le résultat aux 5 premières entrées. Cette approche est directe, en particulier pour les utilisateurs de SQL, avec les mots-clés ORDER BY et LIMIT indiquant clairement ce que fait la requête.

Et en Python pur :

top_5_defense = features[['Name', 'Defense']].sort_values(by='Defense', ascending=False).head(5)

En utilisant uniquement Python, nous obtenons le même résultat en utilisant sort_values() pour trier par Défense puis head(5) pour limiter la sortie. Pandas fournit une syntaxe flexible et intuitive pour trier et sélectionner les enregistrements, même si l'approche SQL est peut-être encore plus familière à ceux qui travaillent régulièrement avec des bases de données.

Conclusion

Dans ce didacticiel, nous avons examiné comment et quand la combinaison des fonctionnalités SQL avec Pandas peut aider à produire un code plus propre et plus efficace. Nous avons couvert la configuration et l'utilisation de la bibliothèque PandaSQL, ainsi que ses limites, et avons parcouru des exemples populaires pour comparer le code PandaSQL avec le code Pandas Python équivalent.

En comparant ces approches, vous pouvez voir que PandaSQL est utile pour les utilisateurs SQL natifs ou les scénarios avec des requêtes complexes, tandis que le code Pandas natif peut être plus pythonique et intégré pour ceux habitués à travailler en Python.

Vous pouvez vérifier tout le code affiché ici dans le bloc-notes Jupyter suivant