Pourquoi et commenter intégrer Python dans Power BI – partie 2 ?

Par Khaoula BENYAHYA, Data Analyst

 

Cas d’illustration :

Dans cette partie, nous allons illustrer l’intérêt d’utiliser Python dans Power BI en réalisant des visuels qui n’existent pas dans l’outil. Nous nous sommes basés sur un jeu de données qui contient le détail des commandes avec des données sur les produits achetés ou vendus ainsi que les données relatives aux clients et aux vendeurs. Nous avons 3 catégories de produits : Accessories, Bikes et Clothing.

Pour les graphiques réalisés, nous avons utilisé la librairie matplotlib. C’est une librairie très riche qui permet de customizer presque tous les paramètres d’un graphique Python.

  • 1er exemple

Dans un premier temps, nous voulons afficher la répartition mensuelle des quantités commandées de chaque catégorie, ainsi que le total de ces quantités. Nous allons illustrer cela sous forme d’histogrammes.

Ce qui donne :

Le graphique est dynamique si nous filtrons sur les catégories. Nous affichons la répartition de chaque catégorie sélectionnée ainsi qu’un histogramme global qui illustre la somme des catégories choisies. C’est la boucle for qui permet cette dynamique. Par exemple :

Le code qui permet de réaliser cela est :

   # import libraries
    import matplotlib.pyplot as plt
    # color pallet
    colors = ['#12239E','#118DFF','#E66C37','#751E73']
    # get number of categories
    nb_cat = len(dataset['Category'].unique())+1
    # declare constraints
    const = 1
    cpt = 1
    color_choice = 0
    # for loop to plot histograms for each category chosen
    for category in dataset['Category'].unique():
    # get number of the subplot
    subplot=int(str(nb_cat)+str(const)+str(cpt))
    # choose the subplot where to plot the histogram
    plt.subplot(subplot)
    # get data of the category to plot
    cat=dataset[dataset.Category==category].drop('Category',axis=1)
    # plot the graph
    plt.bar(cat['Mois'],cat['OrderQty'],color=colors[color_choice],width=0.5)
    # set x axis to invisible
    plt.gca().get_xaxis().set_visible(False)
    plt.title(category)
    cpt=cpt+1
    color_choice=color_choice+1
    # calculate and plot the sum of order quantities by month
    total_simple =
    dataset.groupby('Mois').agg('sum').reset_index().sort_values(by='Month
    Num')
    subplot_total=int(str(nb_cat)+str(const)+str(cpt))
    plt.subplot(subplot_total)
    plt.bar(total_simple['Mois'],total_simple['OrderQty'],color='#6B007B',width=0.5)
    plt.title('Total')
    plt.xlabel('Période') # label of axis x
    plt.xticks(rotation=35) # rotate axis x labels
    # visualizing the plot
    plt.show()

Grâce à la bibliothèque Matplotlib, une seule ligne de code est nécessaire pour spécifier les colonnes sur lesquelles vous souhaitez faire rapport pour créer ce graphique. Le reste du code permet de customizer celui-ci et le rendre plus dynamique. Cela montre à quel point Python est simple pour créer des graphiques, ce qui permet donc de créer des rapports Power BI plus avancés.

  • 2e exemple

Dans l’exemple suivant, nous souhaitons afficher l’évolution des quantités commandés ainsi que les montants commandés des sous-catégories.

Les courbes réagissent bien avec le filtre « SubCategory » en n’affichant que les sous-catégories sélectionnées sur l’axe x.

Ce graphique à 2 axes y permet d’analyser la relation entre la quantité commandée et le montant commandé. Cependant, si vous n'avez besoin que de simples graphiques linéaires ou à barres, je vous suggère d'utiliser plutôt les graphiques intégrés de Power BI, faciles à configurer et à modifier, sans nécessité de code. De plus, le chargement des visuels Python prend plus de temps que les graphiques intégrés, il est donc plus logique d'allouer le temps de chargement plus long à des graphiques plus complexes que nous ne pouvons pas réaliser avec Power BI.

Le code qui permet de réaliser ce graphique est le suivant :

    import matplotlib.pyplot as plt
    # create figure and axis objects with subplots() and defining the figure
    size
    fig,ax = plt.subplots(figsize=(10,6))
    # make a plot
    ax.plot(dataset.SubCategory,dataset.OrderQty,color="#12239E")
    ax.set_ylabel("Quantité de commandes",color="#12239E",fontsize=14)
    # get rid of the frame
    for spine in plt.gca().spines.values():
    spine.set_visible(False)
    # twin object for two different y-axis on the sample plot
    ax2=ax.twinx()
    # make a plot with different y-axis using second axis object
    ax2.plot(dataset.SubCategory,dataset.LineTotal,color="#D64550")
    ax2.set_ylabel("Montant commandé",color="#D64550",fontsize=14)
    fig.autofmt_xdate(rotation=45)
    # get rid of the frame of the twin object
    for spine in plt.gca().spines.values():
    spine.set_visible(False)
    ax.grid('on')
    plt.rcParams["figure.dpi"] = 100
    plt.show()

 

  • 3e exemple

Dans l’exemple suivant, nous souhaitons réaliser des ventilations petits multiples par mesure et non par axe uniquement, en changeant le type de graphique par mesure.

Un histogramme pour la mesure Order Quantity, une courbe linéaire pour Line Total, et un nuage de points pour Unit Price. Les 3 graphiques ont un axe x commun qui représente les mois.

Le code :

  import matplotlib.pyplot as plt
    # set the size of the figure
    figure = plt.figure(figsize=(10,6))
    # subplot the figure into 3 plots and configure the 1st plot
    plt.subplot(311)
    plt.bar(dataset.Mois,dataset.OrderQty,color='r',width=0.5)
    # set axis x to invisible
    for spine in plt.gca().spines.values():
    spine.set_visible(False)
    plt.grid('on')
    ax=plt.gca()
    ax.get_xaxis().set_visible(False)
    # set label for axis y
    plt.ylabel('Order quantity')
    # configure the 2nd plot
    plt.subplot(312)
    plt.plot(dataset['Mois'],dataset.LineTotal,color='b')
    # set axis x to invisible
    for spine in plt.gca().spines.values():
    spine.set_visible(False)
    plt.grid('on')
    # set grid of axis x to invisible
    ax=plt.gca()
    ax.get_xaxis().set_visible(False)
    plt.ylabel('Line Total')
    # configure the 3rd plot
    plt.subplot(313)
    # set axis x to invisible
    for spine in plt.gca().spines.values():
    spine.set_visible(False)
    plt.grid('on')
    #unit=dataset.groupby(['Mois']).UnitPrice.mean()
    plt.scatter(dataset['Mois'],dataset['UnitPrice'],color='g') # plot scatter
    for Unit Price by months
    plt.ylabel('Unit Price')
    plt.xlabel('Période',fontsize=14)
    figure.autofmt_xdate(rotation=35) # rotate axis x labels
    plt.show() # visualizing the plot

 

  • 4e exemple

Dans ce dernier exemple, nous voulons afficher la performance en pourcentage d’un individu, sous forme d’une jauge, avec la possibilité d’afficher la valeur de l’objectif à atteindre pour l’année N ainsi que la performance de l’année N-1. Pour cet exemple, nous avons utilisé un 2 e jeu de données qui contient les données de performance d’un individu selon les années.

L’axe x présente la performance en %
Nous obtenons le résultat suivant pour l’année 2020 :

Pour 2016 :

Le code utilisé est le suivant :

 import pandas as pd
    import matplotlib.pyplot as plt
    import numpy as np
    label='Performance' # bar label
    # positions of horizontal lines
    positions = [dataset["Objectif"],dataset["Réalisé N-1"]]
    line_colors = ['#E66C37','#744EC2'] # color palet
    line_styles = ['solid','dashed'] # style of lines
    # define the size of the figure
    fig, ax = plt.subplots(figsize=(8, 2.5))
    # define the limits of x axis
    plt.xlim(0, 100)
    # change the scale of x axis
    plt.xticks(np.arange(0, 110, 10))
    # plot the horizontal bar
    plt.barh(label,width=dataset["Réalisé"],height=0.8,color='#118DFF',linestyle='solid',hatch='/',linewidth=5)
    # get rid of the frame
    for spine in plt.gca().spines.values():
    spine.set_visible(False)
    # plot the horizontal lines
    for i in range(2):
    plt.vlines(x=positions[i], ymin=-1.5, ymax=1.5, color=line_colors[i],
    linestyle=line_styles[i])
    # plot the legend
    ax.legend(['Objectif','Réalisé n-1','Réalisé'],ncol=3, bbox_to_anchor=(0,
    1), loc='lower left')
    # visualizing the plot
    plt.show()

NB :
la librairie NumPy est la bibliothèque Python la plus populaire de calcul numérique.

Conclusion :

Dans cet article, nous avons vu ce que Python peut faire dans Power BI à l'aide de quelques exemples simples. Python libère un grand potentiel en termes d'obtention de données et de création de graphiques personnalisés plus compliqués. Cependant, il existe certaines limitations des visuels Python. Comme nous l'avons mentionné précédemment, Python peut ralentir les performances et ne peut récupérer que 150 000 enregistrements. Je peux imaginer que cela soit problématique pour les grands projets de business intelligence.

Mais cela n'est que le début de l’exploration des faisabilités de Python dans Power BI. J'aurai peut-être d'autres idées à partager à l'avenir !

Laisser un commentaire