Trier les libellés lignes par ordre alphabétique dans Slidie

Objectif : Trier les libellés lignes de mon tableau dans Slidie

Méthodologie :
Il n'existe pas d'options automatique de tri des libellés lignes (ou colonnes) dans Slidie. L'astuce consiste à transférer les textes lignes dans le corps du tableau et ensuite d'utiliser le tri standard de Slidie

Étapes :
1 - Script de transfert des libellés lignes dans le corps du tableau :

t = ARG1
#Création d'une colonne vide pour recevoir l'information
t = t.Columns[0, Range(1, t.Rows.Size)]

for  i in Range(1, t.Columns.Size):
 parts = GetRowText(t, i)
 t.Rows[i].Columns[1].Values = Enumerate(parts)

RESULT = t

 2 - Trier la colonne crée en mode "littéral"

3 - Supprimer la colonne crée.

Script d'extraction avec conservation de la dimension.

Objectif : Extraire une liste de lignes / colonnes en conservant de la dimension d'extraction. Les éléments absents générant une ligne / colonne vide.

Script :

Exemple d'extraction des colonnes.

t = ARG1

def  GetIndex(x):
 if x in t.Columns.Texts:
  return '"' + x + '"'
 else:
  return 0


marques = ( "Ensemble","Marque 1","Marque 2" [...] "Marque N" )
t = t.Columns[[GetIndex(x) for x in marques]]

for  i in Range(1, len(marques)):
 SetColumnText(t, i, marques[i - 1].Trim('"'))

RESULT = t

Apparier à partir d'une table de correspondance

Objectif : Concaténer des informations provenant de deux tableaux distincts (magasins / régions) à l'aide d'un tableau de correspondances.

Tableaux en entrée :

1) Un tableau contenant les informations régions.



2) Un tableau contenant les informations magasins.



Attention, les tableaux magasins et régions doivent avoir le même nombre de lignes.

3) Un tableau de correspondance.



Transformation :



Elle consiste à produire un tableau par magasin associé à sa région de référence.

Le tableau final aura pour structure :
- La première colonne correspondant au magasin
- La seconde colonne correspondant à sa région de référence

Script :

01:#Arguments
02:# 1 - Tableau des magasins
03:t1 = ARG1
04:# 2 - Tableau des régions
05:t2 = ARG2
06:# 3 - Tableau des correspondances
07:lk = ARG3
08:#Initialisation de la liste
09:lst = []
10:for i in Range(1, (t1.Columns.Size)):
11:#Reprise du magasin
12: nom_etab = GetColumnText(t1 ,i)
13:#Reprise de la région
14: nom_reg = GetColumnText(t2 ,i)
15:#Recherche de la région concernée dans la table de correspondances
16: codes = ['"' + x + '" ' for x in lk.Rows['"' + nom_etab + '"'].Texts]
17:#Concaténation du magasin et de sa région associée
18: c = MergeColumns(t1.Columns[i],t2.Columns[codes])
19:#Reprise des annotations
20: c.Annotations["NOMMAG"] = nom_etab
21: c.Annotations["NOMREG"] = FirstOf (lk.Rows['"' + nom_etab + '"'].Texts)
22:#Stockage des tableaux
23: lst.Add(c)
25:
26:RESULT = lst

Résultats :

Cette transformation produit autant de tableaux que de magasins présents.
Dans notre cas, elle produira donc 5 tableaux.

Les méthodes d'extractions dans Slidie

Les différentes méthodes d'extractions de modalités dans Slidie :

• 1 2 -> Extrait les deux premières lignes / colonnes / calculs / pages
• "Marque" -> Extrait la ligne / colonne / calcul / page ayant pour texte "Marque"
• -1 -> Extrait le dernier item
• $"Le*" -> Extrait les items débutants par le texte "Le"
• $"*le*" -> Extrait les items contenant le texte "Le". "Elle", "épeler", "lettre" seront conservés.
  
• $"*le" -> Extrait les items finissant par le texte "Le"
• 3..5 -> Extrait les items de 3 à 5
• "Marque".2 -> Extrait le second item du sous-titres "Marque"

Pour tous les extractions textuelles, la casse n'a pas d'importance.

Mise en forme conditionnelle d'un tableau par rapport à une colonne de référence

Objectif : Appliquer des couleurs de fonds de cellules d'un tableau selon un calcul de différence de pourcentages par rapport à une colonne de référence.

Tableau en entrée :



La colonne de référence est la colonne "Ensemble".
L'objectif est de coloriser les fonds de cellules en rouge / vert quand la différence est inférieure / supérieure de 15% à la colonne ensemble.

Première étape : Script de calcul

# Récupération du tableau
t = ARG1

# Seuil de comparaison par rapport (0.15 car les nombres sont au format pourcentage)
SEUILCOMP = 0.15

# Récupération de la première colonne de référence
Base = t.Columns[1].Calculations["CALC1"]

# Récupération des autres colonnes à tester contre la colonne de référence
Crit = t.Columns.Remove(1).Calculations["CALC1"]

# Calcul de la différence entre le critère et la base
delta = Crit - Base

#Fonction de transformation du delta
def ApplyThreshold(x, s):
if x >= s:
return "Pos"
elif x <= -s:
return "Neg"
return ""

#Application de la fonction valeurs par valeurs
delta.ChangeValues(lambda x: ApplyThreshold(x, SEUILCOMP))

# Résultat final avec stockage d'un nouveau calcul résultat : "DELTA"
t = MergeCalculations (t.Calculations["CALC1"],MergeColumns (Base,delta))
SetCalculationText (t, 2, "DELTA")

RESULT = t

Seconde étape : Mise en forme



Cette étape se décompose en 3 blocs :

• Mise en forme des calculs (%)


• Mise en forme des valeurs


• Suppression du calcul "DELTA"

Détails de la mise en forme des valeurs :



Résultat :

Trier un tableau avec deux clés de tris

Objectif : Trier un tableau selon le "total ++" et, en cas d'égalité, sur le "total ++"

Tableau d'entrée :




Script de transformation :

# Récupération du tableau
t = ARG1

# Liste des valeurs de la première colonne de tri
col1 = list(t.Columns[1].Values)

# Liste des valeurs de la seconde colonne de tri
col2 = list(t.Columns[2].Values)

# Liste des positions de 1 au nombre de lignes
positions = list(Range(1, t.Rows.Size))

# Tri de la liste des positions selon les deux clés de tri
positions.sort(key = lambda x: (col1[x-1], col2[x-1]), reverse = True)

# Récapitulatif du nouvelle ordre des postions
log.Info(positions)

# Extraction du tableau selon le vecteur de positions ordonnées par le tri.
RESULT = t.Rows[positions]

Résultat :

Mise en forme du mini / maxi dans une colonne de tableau

Objectif : Mise en couleur du minimum (rouge) et du maximum (vert) des colonnes d'un tableau.

Par exemple, le tableau suivant en entrée :



Etape 1 : Calcul du mini / maxi de chaque colonne dans un nouveau calcul via un script Python.

# Reprise du tableau
t = ARG1

# Consolidation du premier calcul
# Cette étape permet de fixer le premier calcul tel quel
n = t.Calculations[1].Consolidate()

# Calcul du mini et du maxi par ligne
mini = n.Rows.Min
maxi = n.Rows.Max

# Localisation du minimum et du maximum dans le tableau initial
mini = (n <= mini) * -1
maxi = (n >= maxi) * 1

# Concaténation des minimums et des maximums
# -1 pour la ou les valeur(s) minimum
# 1 pour la ou les valeur(s) maximum
# 0 pour les autres valeurs
n = mini + maxi

# Rajout du nouveau calcul au tableau initial
SetCalculationText(n, 1, "BORNES")

# Stockage du tableau
RESULT = MergeCalculations(t, n)

Etape 2 : Mise en forme des valeurs minimum et maximum:

• Les valeurs minimum en rouge


• Les valeurs maximum en vert

La propagation est nécessaire sur l'ensemble des calculs.
Les minimums seront identifiés en rouge et gras.
Les maximums seront identifiés en vert et gras.

Etape 3 : Suppression du calcul de minimums et maximums nommé '2' ou "BORNES".

Résultat :