Analysez les données avec Apache Spark

Avant de travailler avec des données dans Fabric, créez un espace de travail avec la version d’essai Fabric activée.

1. Sur la page d’accueil de Microsoft Fabric , sélectionnez Synapse Data Engineering .
2. Dans la barre de menu de gauche, sélectionnez Espaces de travail (l’icône ressemble à 🗇).
3. Créez un nouvel espace de travail avec le nom de votre choix, en sélectionnant un mode de licence qui inclut la capacité Fabric ( Trial , Premium ou Fabric ).
4. Lorsque votre nouvel espace de travail s’ouvre, il devrait être vide.

   

Maintenant que vous disposez d’un espace de travail, il est temps de créer un lac de données pour les fichiers de données que vous allez analyser.

1. Dans la page d’accueil de Synapse Data Engineering , créez un nouveau Lakehouse avec le nom de votre choix.

   Après environ une minute, une nouvelle maison au bord du lac vide sera créée. Vous devez ingérer certaines données dans le data Lakehouse pour analyse. Il existe plusieurs façons de procéder, mais dans cet exercice, vous allez simplement télécharger et extraire un dossier de fichiers texte sur votre ordinateur local (ou sur la machine virtuelle de laboratoire le cas échéant), puis les télécharger sur votre Lakehouse.

2. Téléchargez et extrayez les fichiers de données pour cet exercice à partir de https://github.com/MicrosoftLearning/dp-data/raw/main/orders.zip .
3. Après avoir extrait l’archive compressée, vérifiez que vous disposez d’un dossier nommé commandes contenant des fichiers CSV nommés 2019.csv , 2020.csv et 2021.csv .
4. Revenez à l’onglet du navigateur Web contenant votre Lakehouse et dans le menu … du dossier Fichiers dans le volet Explorateur , sélectionnez Télécharger et Télécharger le dossier , puis téléchargez le dossier des commandes depuis votre ordinateur local (ou la machine virtuelle de laboratoire le cas échéant) vers Lakehouse. .

5. Une fois les fichiers téléchargés, développez Fichiers et sélectionnez le dossier des commandes ; et vérifiez que les fichiers CSV ont été téléchargés, comme indiqué ici :

   

Pour travailler avec des données dans Apache Spark, vous pouvez créer un bloc-notes . Les blocs-notes fournissent un environnement interactif dans lequel vous pouvez écrire et exécuter du code (dans plusieurs langues) et ajouter des notes pour le documenter.

1. Sur la page d’accueil , lors de l’affichage du contenu du dossier des commandes dans votre lac de données, dans le menu Ouvrir le notebook , sélectionnez Nouveau notebook .Après quelques secondes, un nouveau bloc-notes contenant une seule cellule s’ouvrira. Les blocs-notes sont constitués d’une ou plusieurs cellules pouvant contenir du code ou du markdown (texte formaté).
2. Sélectionnez la première cellule (qui est actuellement une cellule de code ), puis dans la barre d’outils dynamique en haut à droite, utilisez le bouton M↓ pour convertir la cellule en cellule de texte formaté .Lorsque la cellule se transforme en cellule de texte formaté, le texte qu’elle contient est rendu.

3. Utilisez le bouton 🖉 (Modifier) ​​pour passer la cellule en mode édition, puis modifiez le comme suit :

   # Sales order data exploration Use the code in this notebook to explore sales order data.

4. Cliquez n’importe où dans le bloc-notes en dehors de la cellule pour arrêter de le modifier et voir le rendu du texte formatté.

« Vous êtes maintenant prêt à exécuter du code qui charge les données dans un dataframe . Les dataframes dans Spark sont similaires aux dataframes Pandas en Python et fournissent une structure commune pour travailler avec des données en lignes et en colonnes.

Remarque : Spark prend en charge plusieurs langages de codage, notamment Scala, Java et autres. Dans cet exercice, nous utiliserons PySpark , qui est une variante de Python optimisée pour Spark. PySpark est l’un des langages les plus couramment utilisés sur Spark et constitue le langage par défaut dans les notebooks Fabric.

1. Avec le bloc-notes visible, développez la liste Fichiers et sélectionnez le dossier des commandes afin que les fichiers CSV soient répertoriés à côté de l’éditeur de bloc-notes, comme ceci :
2. Dans le menu … pour 2019.csv , sélectionnez Charger les données > Spark . Une nouvelle cellule de code contenant le code suivant doit être ajoutée au notebook :
   CodeCopie

   df = spark.read.format("csv").option("header","true").load("Files/orders/2019.csv")
   # df now is a Spark DataFrame containing CSV data from "Files/orders/2019.csv".
   display(df)
   

   Astuce : Vous pouvez masquer les volets de l’explorateur Lakehouse à gauche en utilisant leurs icônes « . Cela vous aidera à vous concentrer sur le bloc-notes.

3. Utilisez le bouton ▷ Exécuter la cellule à gauche de la cellule pour l’exécuter.
   

   Remarque : Comme c’est la première fois que vous exécutez du code Spark, une session Spark doit être démarrée. Cela signifie que la première exécution de la session peut prendre environ une minute. Les courses suivantes seront plus rapides.

4. Une fois la commande de cellule terminée, examinez le résultat sous la cellule, qui devrait ressembler à ceci :
   

   Indice	SO43701	11	2019-07-01	Christy Zhu	christy12@adventure-works.com	Montagne-100 Argent, 44	16	3399.99	271.9992
   1	SO43704	1	2019-07-01	Julio Ruiz	julio1@adventure-works.com	Montagne-100 Noir, 48	1	3374.99	269.9992
   2	SO43705	1	2019-07-01	Curtis Lu	curtis9@adventure-works.com	Montagne-100 Argent, 38	1	3399.99	271.9992
   …	…	…	…	…	…	…	…	…	…

   La sortie affiche les lignes et les colonnes de données du fichier 2019.csv. Notez cependant que les en-têtes de colonnes ne semblent pas corrects. Le code par défaut utilisé pour charger les données dans une trame de données suppose que le fichier CSV inclut les noms de colonnes dans la première ligne, mais dans ce cas, le fichier CSV inclut simplement les données sans informations d’en-tête.

5. Modifiez le code pour définir l’ option d’en-tête sur false comme suit :
   df = spark.read.format(« csv »).option(« header »,« false »).load(« Files/orders/2019.csv »)
   # df now is a Spark DataFrame containing CSV data from « Files/orders/2019.csv ».
   display(df)
6. Réexécutez la cellule et examinez le résultat, qui devrait ressembler à ceci :
   

   Indice	_c0	_c1	_c2	_c3	_c4	_c5	_c6	_c7	_c8
   1	SO43701	11	2019-07-01	Christy Zhu	christy12@adventure-works.com	Montagne-100 Argent, 44	16	3399.99	271.9992
   2	SO43704	1	2019-07-01	Julio Ruiz	julio1@adventure-works.com	Montagne-100 Noir, 48	1	3374.99	269.9992
   3	SO43705	1	2019-07-01	Curtis Lu	curtis9@adventure-works.com	Montagne-100 Argent, 38	1	3399.99	271.9992
   …	…	…	…	…	…	…	…	…	…

   Désormais, le dataframe inclut correctement la première ligne comme valeurs de données, mais les noms de colonnes sont générés automatiquement et ne sont pas très utiles. Pour donner un sens aux données, vous devez définir explicitement le schéma et le type de données corrects pour les valeurs de données du fichier.

7. Modifiez le code comme suit pour définir un schéma et appliquez-le lors du chargement des données :
   
8. Exécutez la cellule modifiée et examinez le résultat, qui devrait ressembler à ceci :
   

   Indice	Numéro de commande	Numéro de ligne de commande de vente	Date de commande	Nom du client	E-mail	Article	Quantité	Prix ​​unitaire	Impôt
   1	SO43701	11	2019-07-01	Christy Zhu	christy12@adventure-works.com	Montagne-100 Argent, 44	16	3399.99	271.9992
   2	SO43704	1	2019-07-01	Julio Ruiz	julio1@adventure-works.com	Montagne-100 Noir, 48	1	3374.99	269.9992
   3	SO43705	1	2019-07-01	Curtis Lu	curtis9@adventure-works.com	Montagne-100 Argent, 38	1	3399.99	271.9992
   …	…	…	…	…	…	…	…	…	…

   Désormais, le dataframe inclut les noms de colonnes corrects (en plus de Index , qui est une colonne intégrée dans tous les dataframes en fonction de la position ordinale de chaque ligne). Les types de données des colonnes sont spécifiés à l’aide d’un ensemble standard de types définis dans la bibliothèque Spark SQL, qui ont été importés au début de la cellule.

9. Confirmez que vos modifications ont été appliquées aux données en affichant le dataframe. 
   Exécutez la cellule suivante :

   display(df)

10. Le dataframe inclut uniquement les données du fichier 2019.csv . Modifiez le code afin que le chemin du fichier utilise un caractère générique * pour lire les données de commande client à partir de tous les fichiers du dossier commandes :

L’objet dataframe comprend un large éventail de fonctions que vous pouvez utiliser pour filtrer, regrouper et manipuler les données qu’il contient.

Filtrer un dataframe

1. Utilisez l’ icône + Code sous la sortie de la cellule pour ajouter une nouvelle cellule de code au bloc-notes et entrez-y le code suivant.

   customers = df['CustomerName', 'Email']
   print(customers.count())
   print(customers.distinct().count())
   display(customers.distinct())
   

2. Exécutez la nouvelle cellule de code et examinez les résultats. Observez les détails suivants :
   • Lorsque vous effectuez une opération sur un dataframe, le résultat est un nouveau dataframe (dans ce cas, un nouveau dataframe client est créée en sélectionnant un sous-ensemble spécifique de colonnes dans le dataframe df )
   • Les dataframes fournissent des fonctions telles que count et distinct qui peuvent être utilisées pour résumer et filtrer les données qu’elles contiennent.
   • La dataframe['Field1', 'Field2', ...]syntaxe est une manière abrégée de définir un sous-ensemble de colonnes. Vous pouvez également utiliser la méthode select , de sorte que la première ligne du code ci-dessus puisse être écrite commecustomers = df.select("CustomerName", "Email")
3. Modifiez le code comme suit :

   customers = df.select("CustomerName", "Email").where(df['Item']=='Road-250 Red, 52')
   print(customers.count())
   print(customers.distinct().count())
   display(customers.distinct())
   

4. Exécutez le code modifié pour afficher les clients qui ont acheté le produit Road-250 Red, 52 . Notez que vous pouvez « enchaîner » plusieurs fonctions ensemble afin que la sortie d’une fonction devienne l’entrée de la suivante. Dans ce cas, le dataframe créée par la méthode select est le dataframe source de la méthode Where utilisée pour appliquer les critères de filtrage. .

Agréger et regrouper les données dans un dataframe

1. Ajoutez une nouvelle cellule de code au bloc-notes et entrez-y le code suivant :

   productSales = df.select("Item", "Quantity").groupBy("Item").sum()
   display(productSales)
   

2. Exécutez la cellule de code que vous avez ajoutée et notez que les résultats affichent la somme des quantités commandées regroupées par produit. La méthode groupBy regroupe les lignes par Item , et la fonction d’agrégation de somme suivante est appliquée à toutes les colonnes numériques restantes (dans ce cas, Quantity )
3. Ajoutez une autre nouvelle cellule de code au bloc-notes et entrez-y le code suivant :

   from pyspark.sql.functions import *
   
   yearlySales = df.select(year(col("OrderDate")).alias("Year")).groupBy("Year").count().orderBy("Year")
   display(yearlySales)
   

4. Exécutez la cellule de code que vous avez ajoutée et notez que les résultats indiquent le nombre de commandes client par an. Notez que la méthode select inclut une fonction SQL year pour extraire le composant année du champ OrderDate (c’est pourquoi le code inclut une instruction import pour importer des fonctions de la bibliothèque Spark SQL). Il utilise ensuite une méthode d’alias pour attribuer un nom de colonne à la valeur de l’année extraite. Les données sont ensuite regroupées par la colonne Année dérivée et le nombre de lignes dans chaque groupe est calculé avant que la méthode orderBy ne soit finalement utilisée pour trier le dataframe résultante.

Une tâche courante des ingénieurs de données consiste à ingérer des données dans un format ou une structure particulière, et à les transformer pour un traitement ou une analyse ultérieure en aval.

Utiliser des méthodes et des fonctions dataframe pour transformer les données

1. Ajoutez une autre nouvelle cellule de code au bloc-notes et entrez-y le code suivant :

   from pyspark.sql.functions import *
   
   ## Create Year and Month columns
   transformed_df = df.withColumn("Year", year(col("OrderDate"))).withColumn("Month", month(col("OrderDate")))
   
   # Create the new FirstName and LastName fields
   transformed_df = transformed_df.withColumn("FirstName", split(col("CustomerName"), " ").getItem(0)).withColumn("LastName", split(col("CustomerName"), " ").getItem(1))
   
   # Filter and reorder columns
   transformed_df = transformed_df["SalesOrderNumber", "SalesOrderLineNumber", "OrderDate", "Year", "Month", "FirstName", "LastName", "Email", "Item", "Quantity", "UnitPrice", "Tax"]
   
   # Display the first five orders
   display(transformed_df.limit(5))
   

2. Exécutez le code pour créer un nouveau dataframe à partir des données de commande d’origine avec les transformations suivantes :
   • Ajoutez des colonnes Année et Mois en fonction de la colonne OrderDate .
   • Ajoutez des colonnes FirstName et LastName en fonction de la colonne CustomerName .
   • Filtrez et réorganisez les colonnes en supprimant la colonne CustomerName .

3. Examinez le résultat et vérifiez que les transformations ont été apportées aux données.

   Vous pouvez utiliser toute la puissance de la bibliothèque Spark SQL pour transformer les données en filtrant les lignes, en dérivant, en supprimant, en renommant les colonnes et en appliquant toute autre modification de données requise.

   Astuce : Consultez la documentation Spark dataframe pour en savoir plus sur les méthodes de l’objet Dataframe.

Enregistrez les données transformées

1. Ajoutez une nouvelle cellule avec le code suivant pour enregistrer la dataframe transformée au format Parquet (en écrasant les données si elles existent déjà) :

   transformed_df.write.mode("overwrite").parquet('Files/transformed_data/orders')
   print ("Transformed data saved!")
   

   Remarque : Généralement, le format Parquet est préféré pour les fichiers de données que vous utiliserez pour une analyse plus approfondie ou une ingestion dans un magasin analytique. Parquet est un format très efficace pris en charge par la plupart des systèmes d’analyse de données à grande échelle. En fait, parfois, votre exigence de transformation de données peut simplement consister à convertir des données d’un autre format (tel que CSV) en Parquet !

2. Exécutez la cellule et attendez le message indiquant que les données ont été enregistrées. Ensuite, dans le volet Explorateur de gauche, dans le menu … du nœud Fichiers , sélectionnez Actualiser ; et sélectionnez le dossier transformer_orders pour vérifier qu’il contient un nouveau dossier nommé commandes , qui contient à son tour un ou plusieurs fichiers Parquet.

   

3. Ajoutez une nouvelle cellule avec le code suivant pour charger une nouvelle trame de données à partir des fichiers parquet dans le dossier transformer_orders/orders :

   orders_df = spark.read.format("parquet").load("Files/transformed_data/orders")
   display(orders_df)
   

4. Exécutez la cellule et vérifiez que les résultats affichent les données de commande qui ont été chargées à partir des fichiers Parquet.

Enregistrer les données dans des fichiers partitionnés

1. Ajoutez une nouvelle cellule avec le code suivant : qui enregistre la trame de données, en partitionnant les données par année et par mois :

   orders_df.write.partitionBy("Year","Month").mode("overwrite").parquet("Files/partitioned_data")
   print ("Transformed data saved!")
   

2. Exécutez la cellule et attendez le message indiquant que les données ont été enregistrées. Ensuite, dans le volet Explorateur de gauche, dans le menu … du nœud Fichiers , sélectionnez Actualiser ; et développez le dossier partitioned_orders pour vérifier qu’il contient une hiérarchie de dossiers nommés Year= xxxx , chacun contenant des dossiers nommés Month= xxxx . Chaque dossier mensuel contient un dossier parquet avec les commandes de ce mois.

   

   Le partitionnement des fichiers de données est un moyen courant d’optimiser les performances lorsque l’on traite de gros volumes de données. Cette technique peut améliorer considérablement les performances et faciliter le filtrage des données.

3. Ajoutez une nouvelle cellule avec le code suivant pour charger une nouvelle trame de données à partir du fichier commandes.parquet :

   orders_2021_df = spark.read.format("parquet").load("Files/partitioned_data/Year=2021/Month=*")
   display(orders_2021_df)
   

4. Exécutez la cellule et vérifiez que les résultats affichent les données de commande pour les ventes en 2021. Notez que les colonnes de partitionnement spécifiées dans le chemin ( Year et Month ) ne sont pas incluses dans le dataframe.

Comme vous l’avez vu, les méthodes natives de l’objet dataframe vous permettent d’interroger et d’analyser les données d’un fichier de manière assez efficace. Cependant, de nombreux analystes de données sont plus à l’aise avec des tables qu’ils peuvent interroger à l’aide de la syntaxe SQL. Spark fournit un métastore dans lequel vous pouvez définir des tables relationnelles. La bibliothèque Spark SQL qui fournit l’objet dataframe prend également en charge l’utilisation d’instructions SQL pour interroger les tables du métastore. En utilisant ces fonctionnalités de Spark, vous pouvez combiner la flexibilité d’un lac de données avec le schéma de données structurées et les requêtes basées sur SQL d’un entrepôt de données relationnel – d’où le terme « data lakehouse ».

Créer une table

Les tables d’un métastore Spark sont des abstractions relationnelles sur les fichiers du lac de données. les tables peuvent être gérées (auquel cas les fichiers sont gérés par le métastore) ou externes (auquel cas la table référence un emplacement de fichier dans le lac de données que vous gérez indépendamment du métastore).

1. Ajoutez une nouvelle cellule de code au bloc-notes et entrez le code suivant, qui enregistre le dataframe des données de commande client sous forme d’une  table nommé salesorders :

   # Create a new table
   df.write.format("delta").saveAsTable("salesorders")
   
   # Get the table description
   spark.sql("DESCRIBE EXTENDED salesorders").show(truncate=False)
   

   Remarque : Il convient de noter quelques points à propos de cet exemple. Premièrement, aucun chemin explicite n’est fourni, donc les fichiers de la table seront gérés par le métastore. Deuxièmement, le tableau est enregistré au format delta . Vous pouvez créer des tables basées sur plusieurs formats de fichiers (y compris CSV, Parquet, Avro et autres), mais Delta Lake est une technologie Spark qui ajoute des fonctionnalités de base de données relationnelles aux tables ; y compris la prise en charge des transactions, la gestion des versions des lignes et d’autres fonctionnalités utiles. La création de tables au format delta est préférable pour les data lakehouses dans Fabric.

2. Exécutez la cellule de code et examinez le résultat, qui décrit la définition de la nouvelle table.
3. Dans le volet Explorateur , dans le menu … du dossier Tables , sélectionnez Actualiser . Développez ensuite le nœud Tables et vérifiez que la table salesorders a été créée.
4. Dans le menu … de la table des commandes , sélectionnez Charger les données > Spark .Une nouvelle cellule de code contenant du code similaire à l’exemple suivant est ajoutée au bloc-notes :

   df = spark.sql("SELECT * FROM [your_lakehouse].salesorders LIMIT 1000")
   display(df)
   

5. Exécutez le nouveau code, qui utilise la bibliothèque Spark SQL pour intégrer une requête SQL à la table de commande dans le code PySpark et chargez les résultats de la requête dans un dataframe.

Exécuter du code SQL dans une cellule

Bien qu’il soit utile de pouvoir intégrer des instructions SQL dans une cellule contenant du code PySpark, les analystes de données souhaitent souvent simplement travailler directement dans SQL.

1. Ajoutez une nouvelle cellule de code au bloc-notes et entrez-y le code suivant :

   %%sql
   SELECT YEAR(OrderDate) AS OrderYear,
          SUM((UnitPrice * Quantity) + Tax) AS GrossRevenue
   FROM salesorders
   GROUP BY YEAR(OrderDate)
   ORDER BY OrderYear;
   

2. Exécutez la cellule et examinez les résultats. Observe ceci:
   • La %%sqlligne au début de la cellule (appelée magic ) indique que le runtime du langage Spark SQL doit être utilisé pour exécuter le code dans cette cellule au lieu de PySpark.
   • Le code SQL fait référence à la table salesorders que vous avez créée précédemment.
   • La sortie de la requête SQL est automatiquement affichée comme résultat sous la cellule.

Remarque : Pour plus d’informations sur Spark SQL et les dataframes, consultez la documentation Spark SQL .

Une image vaut proverbialement mille mots, et un graphique vaut souvent mieux que mille lignes de données. Bien que les notebooks dans Fabric incluent une vue graphique intégrée pour les données affichées à partir d’une trame de données ou d’une requête Spark SQL, elle n’est pas conçue pour des graphiques complets. Cependant, vous pouvez utiliser des bibliothèques graphiques Python comme matplotlib et seaborn pour créer des graphiques à partir de données dans des dataframes.

Afficher les résultats sous forme de graphique

1. Ajoutez une nouvelle cellule de code au bloc-notes et entrez-y le code suivant :

   %%sql
   SELECT * FROM salesorders
   

2. Exécutez le code et observez qu’il renvoie les données de la vue commandes clients que vous avez créée précédemment.
3. Dans la section des résultats sous la cellule, modifiez l’ option Afficher de Tableau à Graphique .
4. Utilisez le bouton Afficher les options en haut à droite du graphique pour afficher le volet d’options du graphique. Définissez ensuite les options comme suit et sélectionnez Appliquer :
   • Type de graphique : Graphique à barres
   • Clé : Objet
   • Valeurs : Quantité
   • Groupe de séries : laisser vide
   • Agrégation : Somme
   • Empilé : non sélectionné

5. Vérifiez que le graphique ressemble à ceci :

   

Commencez avec matplotlib

1. Ajoutez une nouvelle cellule de code au bloc-notes et entrez-y le code suivant :

   sqlQuery = "SELECT CAST(YEAR(OrderDate) AS CHAR(4)) AS OrderYear, \
                   SUM((UnitPrice * Quantity) + Tax) AS GrossRevenue \
               FROM salesorders \
               GROUP BY CAST(YEAR(OrderDate) AS CHAR(4)) \
               ORDER BY OrderYear"
   df_spark = spark.sql(sqlQuery)
   df_spark.show()
   

2. Exécutez le code et observez qu’il renvoie une trame de données Spark contenant les revenus annuels.

   Pour visualiser les données sous forme de graphique, nous allons commencer par utiliser la bibliothèque Python matplotlib . Cette bibliothèque est la bibliothèque de traçage principale sur laquelle de nombreuses autres sont basées et offre une grande flexibilité dans la création de graphiques.

3. Ajoutez une nouvelle cellule de code au bloc-notes et ajoutez-y le code suivant :

   from matplotlib import pyplot as plt
   
   # matplotlib requires a Pandas dataframe, not a Spark one
   df_sales = df_spark.toPandas()
   
   # Create a bar plot of revenue by year
   plt.bar(x=df_sales['OrderYear'], height=df_sales['GrossRevenue'])
   
   # Display the plot
   plt.show()
   

4. Exécutez la cellule et examinez les résultats, qui consistent en un histogramme avec le revenu brut total pour chaque année. Notez les caractéristiques suivantes du code utilisé pour produire ce graphique :
   • La bibliothèque matplotlib nécessite une trame de données Pandas , vous devez donc convertir la trame de données Spark renvoyée par la requête Spark SQL dans ce format.
   • Au cœur de la bibliothèque matplotlib se trouve l’ objet pyplot . C’est la base de la plupart des fonctionnalités de traçage.
   • Les paramètres par défaut génèrent un graphique utilisable, mais il existe une possibilité considérable de le personnaliser

5. Modifiez le code pour tracer le graphique comme suit :

   from matplotlib import pyplot as plt
   
   # Clear the plot area
   plt.clf()
   
   # Create a bar plot of revenue by year
   plt.bar(x=df_sales['OrderYear'], height=df_sales['GrossRevenue'], color='orange')
   
   # Customize the chart
   plt.title('Revenue by Year')
   plt.xlabel('Year')
   plt.ylabel('Revenue')
   plt.grid(color='#95a5a6', linestyle='--', linewidth=2, axis='y', alpha=0.7)
   plt.xticks(rotation=45)
   
   # Show the figure
   plt.show()
   

6. Réexécutez la cellule de code et affichez les résultats. Le graphique comprend désormais un peu plus d’informations.

   Un tracé est techniquement contenu avec un Figure . Dans les exemples précédents, la figure a été créée implicitement pour vous ; mais vous pouvez le créer explicitement.

7. Modifiez le code pour tracer le graphique comme suit :

   from matplotlib import pyplot as plt
   
   # Clear the plot area
   plt.clf()
   
   # Create a Figure
   fig = plt.figure(figsize=(8,3))
   
   # Create a bar plot of revenue by year
   plt.bar(x=df_sales['OrderYear'], height=df_sales['GrossRevenue'], color='orange')
   
   # Customize the chart
   plt.title('Revenue by Year')
   plt.xlabel('Year')
   plt.ylabel('Revenue')
   plt.grid(color='#95a5a6', linestyle='--', linewidth=2, axis='y', alpha=0.7)
   plt.xticks(rotation=45)
   
   # Show the figure
   plt.show()
   

8. Réexécutez la cellule de code et affichez les résultats. La figure détermine la forme et la taille de la parcelle.

   Une figure peut contenir plusieurs sous-traces, chacune sur son propre axe .

9. Modifiez le code pour tracer le graphique comme suit :

   from matplotlib import pyplot as plt
   
   # Clear the plot area
   plt.clf()
   
   # Create a figure for 2 subplots (1 row, 2 columns)
   fig, ax = plt.subplots(1, 2, figsize = (10,4))
   
   # Create a bar plot of revenue by year on the first axis
   ax[0].bar(x=df_sales['OrderYear'], height=df_sales['GrossRevenue'], color='orange')
   ax[0].set_title('Revenue by Year')
   
   # Create a pie chart of yearly order counts on the second axis
   yearly_counts = df_sales['OrderYear'].value_counts()
   ax[1].pie(yearly_counts)
   ax[1].set_title('Orders per Year')
   ax[1].legend(yearly_counts.keys().tolist())
   
   # Add a title to the Figure
   fig.suptitle('Sales Data')
   
   # Show the figure
   plt.show()
   

10. Réexécutez la cellule de code et affichez les résultats. La figure contient les sous-intrigues spécifiées dans le code.

Remarque : Pour en savoir plus sur le traçage avec matplotlib, consultez la documentation matplotlib .

Utilisez la bibliothèque Seaborn

Bien que matplotlib vous permette de créer des graphiques complexes de plusieurs types, cela peut nécessiter du code complexe pour obtenir les meilleurs résultats. Pour cette raison, au fil des années, de nombreuses nouvelles bibliothèques ont été construites sur la base de matplotlib pour abstraire sa complexité et améliorer ses capacités. L’une de ces bibliothèques est Seaborn .

1. Ajoutez une nouvelle cellule de code au bloc-notes et entrez-y le code suivant :

   import seaborn as sns
   
   # Clear the plot area
   plt.clf()
   
   # Create a bar chart
   ax = sns.barplot(x="OrderYear", y="GrossRevenue", data=df_sales)
   plt.show()
   

2. Exécutez le code et observez qu’il affiche un graphique à barres à l’aide de la bibliothèque Seaborn.

3. Modifiez le code comme suit :

   import seaborn as sns
   
   # Clear the plot area
   plt.clf()
   
   # Set the visual theme for seaborn
   sns.set_theme(style="whitegrid")
   
   # Create a bar chart
   ax = sns.barplot(x="OrderYear", y="GrossRevenue", data=df_sales)
   plt.show()
   

4. Exécutez le code modifié et notez que seaborn vous permet de définir un thème de couleur cohérent pour vos tracés.

5. Modifiez à nouveau le code comme suit :

   import seaborn as sns
   
   # Clear the plot area
   plt.clf()
   
   # Create a line chart
   ax = sns.lineplot(x="OrderYear", y="GrossRevenue", data=df_sales)
   plt.show()
   

6. Exécutez le code modifié pour afficher les revenus annuels sous forme de graphique linéaire.

Remarque : Pour en savoir plus sur le traçage avec seaborn, consultez la documentation seaborn

Maintenant que vous avez fini de travailler avec les données, vous pouvez enregistrer le bloc-notes sous un nom significatif et mettre fin à la session Spark.

1. Dans la barre de menus du bloc-notes, utilisez l’icône ⚙️ Paramètres pour afficher les paramètres du bloc-notes.
2. Définissez le Nom du bloc-notes sur Explorer les commandes client , puis fermez le volet des paramètres.
3. Dans le menu du bloc-notes, sélectionnez Arrêter la session pour mettre fin à la session Spark.

Dans cet exercice, vous avez appris à utiliser Spark pour travailler avec des données dans Microsoft Fabric.

Si vous avez fini d’explorer votre Lakehouse, vous pouvez supprimer l’espace de travail que vous avez créé pour cet exercice.

1. Dans la barre de gauche, sélectionnez l’icône de votre espace de travail pour afficher tous les éléments qu’il contient.
2. Dans le menu … de la barre d’outils, sélectionnez Paramètres de l’espace de travail .
3. Dans la section Autre , sélectionnez Supprimer cet espace de travail .