Partager via

Capitalisation dans Power Query M

Le traitement des données textuelles peut parfois être désordonné. Par exemple, le nom de la ville Redmond peut être représenté dans une base de données à l’aide de différentes casses (« Redmond », « redmond » et « REDMOND »). Cela peut entraîner un problème lors de la transformation des données dans Power Query, car le langage de formule Power Query M est sensible à la casse.

Heureusement, Power Query M fournit des fonctions pour nettoyer et normaliser le cas des données texte. Il existe des fonctions permettant de convertir du texte en minuscules (abc), en majuscules (ABC) ou en casse titre (Abc). En outre, Power Query M fournit également plusieurs façons d’ignorer complètement la distinction majuscule/minuscule.

Cet article vous montre comment modifier la mise en majuscule des mots dans du texte, des listes et des tableaux. Il décrit également différentes façons d’ignorer la casse lors de la manipulation de données dans le texte, les listes et les tableaux. En outre, cet article explique comment trier en fonction du cas.

Modification de la casse dans le texte

Il existe trois fonctions qui convertissent le texte en minuscules, en majuscules et en majuscule initiale. Les fonctions sont Text.Lower, Text.Upperet Text.Proper. Les exemples simples suivants montrent comment ces fonctions peuvent être utilisées dans du texte.

Convertir tous les caractères en texte en minuscules

L’exemple suivant montre comment convertir tous les caractères d’une chaîne en minuscules.

let
    Source = Text.Lower("The quick brown fox jumps over the lazy dog.")
in
    Source

Ce code produit la sortie suivante :

the quick brown fox jumps over the lazy dog.

Convertir tous les caractères du texte en majuscules

L’exemple suivant montre comment convertir tous les caractères d’une chaîne de texte en majuscules.

let
    Source = Text.Upper("The quick brown fox jumps over the lazy dog.")
in
    Source

Ce code produit la sortie suivante :

THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.

Convertir tous les mots en majuscules initiales

L’exemple suivant montre comment convertir tous les mots de la phrase en majuscules initiales.

let
    Source = Text.Proper("The quick brown fox jumps over the lazy dog.")
in
    Source

Ce code produit la sortie suivante :

The Quick Brown Fox Jumps Over The Lazy Dog.

Modification du cas dans les listes

Lorsque vous modifiez le cas dans les listes, la fonction la plus courante à utiliser est List.Transform. Les exemples simples suivants montrent comment cette fonction peut être utilisée dans des listes.

Convertir tous les éléments en minuscules

L’exemple suivant montre comment modifier tous les éléments d’une liste en minuscules.

let
    Source = {"Squash", "Pumpkin", "ApPlE", "pear", "orange", "APPLE", "Pear", "pear"},
    #"Lower Case" = List.Transform(Source, Text.Lower)
in
    #"Lower Case"

Ce code produit la sortie suivante :

Capture d’écran de la liste créée par la fonction de transformation de liste qui produit des résultats minuscules.

Convertir tous les éléments en majuscules

L’exemple suivant montre comment modifier tous les éléments d’une liste en majuscules.

let
    Source = {"Squash", "Pumpkin", "ApPlE", "pear", "orange", "APPLE", "Pear", "pear"},
    #"Upper Case" = List.Transform(Source, Text.Upper)
in
    #"Upper Case"

Ce code produit la sortie suivante :

Capture d’écran de la liste créée par la fonction de transformation de liste qui produit des résultats en majuscules.

Convertir tous les éléments en majuscules/minuscules correctes

L’exemple suivant montre comment modifier tous les éléments d’une liste en majuscules.

let
    Source = {"Squash", "Pumpkin", "ApPlE", "pear", "orange", "APPLE", "Pear", "pear"},
    #"Proper Case" = List.Transform(Source, Text.Proper)
in
    #"Proper Case"

Ce code produit la sortie suivante :

Capture d’écran de la liste créée par la fonction de transformation de liste qui produit des résultats de cas appropriés.

Changement de cas dans les tables

Lorsque vous modifiez le cas dans les tables, la fonction la plus courante à utiliser est Table.TransformColumns. Il existe également une fonction que vous pouvez utiliser pour modifier la casse du texte contenu dans une ligne, appelée Table.TransformRows. Toutefois, cette fonction n’est pas utilisée aussi souvent.

Les exemples simples suivants montrent comment la Table.TransformColumns fonction peut être utilisée pour modifier le cas dans les tables.

Convertir tous les éléments d’une colonne de tableau en minuscules

L’exemple suivant montre comment modifier tous les éléments d’une colonne de table en minuscules, dans ce cas, les noms des clients.

let
    Source = #table(type table [CUSTOMER = text, FRUIT = text],
    {
        {"Tulga", "Squash"}, 
        {"suSanna", "Pumpkin"}, 
        {"LESLIE", "ApPlE"}, 
        {"Willis", "pear"}, 
        {"Dilbar", "orange"}, 
        {"ClaudiA", "APPLE"}, 
        {"afonso", "Pear"}, 
        {"SErgio", "pear"}
    }),
    #"Lower Case" = Table.TransformColumns(Source, {"CUSTOMER", Text.Lower})
in
    #"Lower Case"

Ce code produit la sortie suivante :

Capture d’écran de la table créée par la fonction de transformation de colonnes qui produit des résultats en lettres minuscules.

Convertir tous les éléments d’une colonne de tableau en majuscules

L’exemple suivant montre comment modifier tous les éléments d’une colonne de tableau en majuscules, dans ce cas, les noms de fruits.

let
    Source = #table(type table [CUSTOMER = text, FRUIT = text], 
    {
        {"Tulga", "Squash"}, 
        {"suSanna", "Pumpkin"}, 
        {"LESLIE", "ApPlE"}, 
        {"Willis", "pear"}, 
        {"Dilbar", "orange"}, 
        {"ClaudiA", "APPLE"}, 
        {"afonso", "Pear"}, 
        {"SErgio", "pear"}
    }),
    #"Upper Case" = Table.TransformColumns(Source, {"FRUIT", Text.Upper})
in
    #"Upper Case"

Ce code produit la sortie suivante :

Capture d’écran de la table créée par la fonction de transformation des colonnes de table qui produit des résultats en majuscules.

Convertir tous les éléments d’un tableau en cas approprié

L’exemple suivant montre comment modifier tous les éléments des deux colonnes de table en cas approprié.

let
    Source = #table(type table [CUSTOMER = text, FRUIT = text], 
    {
        {"Tulga", "Squash"}, 
        {"suSanna", "Pumpkin"}, 
        {"LESLIE", "ApPlE"}, 
        {"Willis", "pear"}, 
        {"Dilbar", "orange"}, 
        {"ClaudiA", "APPLE"}, 
        {"afonso", "Pear"}, 
        {"SErgio", "pear"}
    }),
    #"Customer Case" = Table.TransformColumns(Source, {"CUSTOMER", Text.Proper}),
    #"Proper Case" = Table.TransformColumns(#"Customer Case", {"FRUIT", Text.Proper})
in
    #"Proper Case"

Ce code produit la sortie suivante :

Capture d’écran de la table créée par la fonction de transformation de colonnes de table qui produit des résultats de cas appropriés dans les deux colonnes.

Ignorer le cas

Dans de nombreux cas lors de la recherche ou du remplacement d’éléments, vous devrez peut-être ignorer le cas de l’élément que vous recherchez. Étant donné que le langage de formule Power Query M respecte la casse, les comparaisons entre les éléments identiques, mais qui ont des cas différents entraînent l’identification des éléments comme étant différents, et non identiques. Une méthode d’ignorer le cas implique l’utilisation de la Comparer.OrdinalIgnoreCase fonction dans les fonctions qui incluent un equationCriteria paramètre ou un comparer paramètre. Une autre méthode d’ignorer le cas implique l’utilisation de l’option IgnoreCase (si disponible) dans les fonctions qui incluent un options paramètre.

Ignorer la casse dans le texte

Les recherches dans le texte nécessitent parfois que vous ignoriez la casse pour trouver toutes les occurrences du texte recherché. Les fonctions de texte utilisent généralement la fonction Comparer.OrdinalIgnoreCase dans le paramètre comparer pour ignorer la casse lorsqu'elles testent l'égalité.

L’exemple suivant montre comment ignorer la casse lorsque vous déterminez si une phrase contient un mot spécifique, quel que soit le cas.

let
    Source = Text.Contains(
        "The rain in spain falls mainly on the plain.", 
        "Spain", 
        Comparer.OrdinalIgnoreCase
    )
in
    Source

Ce code produit la sortie suivante :

true

L’exemple suivant montre comment récupérer la position initiale de la dernière occurrence du mot « the » dans la phrase, quel que soit le cas.

let
    Source = Text.PositionOf(
        "THE RAIN IN SPAIN FALLS MAINLY ON THE PLAIN.", 
        "the", 
        Occurrence.Last, 
        Comparer.OrdinalIgnoreCase
    )
in
    Source

Ce code produit la sortie suivante :

34

Ignorer le cas dans les listes

Toute fonction de liste qui contient un paramètre facultatif equationCriteria peut utiliser la fonction pour ignorer le Comparer.OrdinalIgnoreCase cas dans la liste.

L’exemple suivant vérifie si une liste contient un élément spécifique, tout en ignorant le cas. Dans cet exemple, List.Contains ne peut comparer qu’un seul élément de la liste, vous ne pouvez pas comparer une liste à une liste. Pour cela, vous devez utiliser List.ContainsAny.

let
    Source = List.Contains(
        {"Squash", "Pumpkin", "ApPlE", "pear", "orange", "APPLE", "Pear", "pear"},
        "apple",
        Comparer.OrdinalIgnoreCase
    )
in
    Source

Ce code produit la sortie suivante :

true

Les exemples suivants vérifient si une liste contient tous les éléments spécifiés dans le deuxième paramètre (value), tout en ignorant la casse. Si un élément n’est pas contenu dans la liste, par cucumber exemple dans le deuxième exemple, la fonction retourne FALSE.

let
    Source = List.ContainsAll(
        {"Squash", "Pumpkin", "ApPlE", "pear", "orange", "APPLE", "Pear", "pear"},
        {"apple", "pear", "squash", "pumpkin"},
        Comparer.OrdinalIgnoreCase
    )
in
    Source

Ce code produit la sortie suivante :

true

let
    Source = List.ContainsAll(
        {"Squash", "Pumpkin", "ApPlE", "pear", "orange", "APPLE", "Pear", "pear"},
        {"apple", "pear", "squash", "pumpkin", "cucumber"},
        Comparer.OrdinalIgnoreCase
    )
in
    Source

Ce code produit la sortie suivante :

false

L’exemple suivant vérifie si l’un des éléments de la liste est des pommes ou des poires, tout en ignorant le cas.

let
    Source = List.ContainsAny(
        {"Squash", "Pumpkin", "ApPlE", "PEAR", "orange", "APPLE", "Pear", "peaR"},
        {"apple","pear"},
        Comparer.OrdinalIgnoreCase
    )
in
    Source

Ce code produit la sortie suivante :

true

L’exemple suivant conserve uniquement les éléments uniques, tout en ignorant la casse.

let
    Source = List.Distinct(
        {"Squash", "Pumpkin", "ApPlE", "PEAR", "orange", "APPLE", "Pear", "peaR"},
        Comparer.OrdinalIgnoreCase
    )
in
    Source

Ce code produit la sortie suivante :

Capture d’écran de la liste créée par la fonction distincte de liste tout en ignorant le cas.

Dans l’exemple précédent, la sortie affiche le cas du premier élément unique trouvé dans la liste. Ainsi, bien qu’il y ait deux pommes (ApPlE et APPLE), seul le premier exemple trouvé est affiché.

Dans l’exemple suivant, seuls les éléments uniques sont conservés tout en ignorant la casse, mais tous les résultats sont également renvoyés en minuscules.

let
    Source = List.Distinct(
        {"Squash", "Pumpkin", "ApPlE", "PEAR", "orange", "APPLE", "Pear", "peaR"},
        Comparer.OrdinalIgnoreCase
    ),
    #"Lower Case" = List.Transform(Source, Text.Lower)
in
    #"Lower Case"

Ce code produit la sortie suivante :

Capture d’écran de la liste créée par la fonction distincte de liste tout en ignorant le cas, mais en mettant également en minuscules.

Ignorer le cas dans les tables

Les tables ont plusieurs façons d’ignorer le cas. Les fonctions de table telles que Table.Contains, Table.Distinctet Table.PositionOf toutes contiennent des equationCriteria paramètres. Ces paramètres peuvent utiliser la fonction pour ignorer le Comparer.OrdinalIgnoreCase cas dans les tables, de la même façon que les listes des sections précédentes. Les fonctions de table, telles que celles qui contiennent un condition paramètre, peuvent également utiliser Comparer.OrdinalIgnoreCase intégré dans d’autres fonctions de table pour ignorer la casse. D’autres fonctions de table, spécifiquement pour la correspondance approximative, peuvent utiliser l’option IgnoreCase .

L’exemple suivant montre comment sélectionner des lignes spécifiques qui contiennent le mot « poire » tout en ignorant la casse. Cet exemple utilise le paramètre condition de Table.SelectRows avec Text.Contains comme condition pour effectuer les comparaisons, tout en ignorant la casse.

let
    Source = #table(type table[CUSTOMER = text, FRUIT = text],
    {
        {"Tulga", "Squash"}, 
        {"suSanna", "Pumpkin"}, 
        {"LESLIE", "ApPlE"}, 
        {"Willis", "pear"}, 
        {"Dilbar", "orange"}, 
        {"ClaudiA", "APPLE"}, 
        {"afonso", "Pear"}, 
        {"SErgio", "pear"}
    }),
    #"Select Rows" = Table.SelectRows(
        Source, each Text.Contains([FRUIT], "pear", Comparer.OrdinalIgnoreCase))
in
    #"Select Rows"

Ce code produit la sortie suivante :

Capture d’écran de la table créée par la fonction de sélection de lignes tout en ignorant la casse.

L'exemple suivant montre comment déterminer si l'une des lignes d'une table contient un pear dans la colonne FRUIT. Cet exemple utilise Comparer.OrdinalIgnoreCase dans une Text.Contains fonction à l’aide du condition paramètre de la Table.MatchesAnyRows fonction.

let
    Source = #table(type table [CUSTOMER = text, FRUIT = text], 
    {
        {"Tulga", "Squash"}, 
        {"suSanna", "Pumpkin"}, 
        {"LESLIE", "ApPlE"}, 
        {"Willis", "PEAR"}, 
        {"Dilbar", "orange"}, 
        {"ClaudiA", "APPLE"}, 
        {"afonso", "Pear"}, 
        {"SErgio", "peAR"}
        }),
    #"Select Rows" = Table.MatchesAnyRows(Source,
        each Text.Contains([FRUIT], "pear", Comparer.OrdinalIgnoreCase))
in
    #"Select Rows"

Ce code produit la sortie suivante :

true

L’exemple suivant montre comment prendre une table avec des valeurs entrées par les utilisateurs qui contiennent une colonne répertoriant leurs fruits favoris, sans format défini. Cette colonne est d’abord comparée par méthode de rapprochement flou afin d'extraire les noms de leurs fruits préférés, puis ceux-ci sont affichés dans une nouvelle colonne, nommée Cluster. Ensuite, la colonne Cluster est examinée pour déterminer les différents fruits distincts qui se trouvent dans la colonne. Une fois les fruits uniques déterminés, une dernière étape consiste à changer tous les noms de fruits en minuscules.

let
    // Load a table of user's favorite fruits into Source
    Source = #table(type table [Fruit = text], {{"blueberries"}, 
        {"Blue berries are simply the best"}, {"strawberries"}, {"Strawberries = <3"}, 
        {"Apples"}, {"'sples"}, {"4ppl3s"}, {"Bananas"}, {"fav fruit is bananas"}, 
        {"Banas"}, {"My favorite fruit, by far, is Apples. I simply love them!"}}
    ),
    // Create a Cluster column and fuzzy match the fruits into that column
    #"Cluster fuzzy match" = Table.AddFuzzyClusterColumn(
        Source, "Fruit", "Cluster", 
        [IgnoreCase = true, IgnoreSpace = true, Threshold = 0.5]
    ),
    // Find the distinct fruits from the Cluster column
    #"Ignore cluster case" = Table.Distinct(
        Table.SelectColumns(#"Cluster fuzzy match", "Cluster"), 
        Comparer.OrdinalIgnoreCase
    ),
    // Set all of the distinct fruit names to lower case
    #"Set lower case" = Table.TransformColumns(#"Ignore cluster case",
        {"Cluster", Text.Lower}
    )
in
    #"Set lower case"

Ce code produit la sortie suivante :

Capture d’écran de la table créée par correspondance floue ignorant la casse.

Classement et tri

Les listes et les tables peuvent être triées à l’aide de l’une ou l’autre List.Sort ou Table.Sort, respectivement. Toutefois, le tri du texte dépend du cas des éléments associés dans la liste ou le tableau pour déterminer l’ordre de tri réel (croissant ou décroissant).

La forme la plus courante de tri utilise du texte qui est soit tout en minuscules, tout en majuscules, soit en capitales. S’il existe un mélange de ces cas, l’ordre de tri croissant est le suivant :

  1. Tout texte de la liste ou de la colonne de tableau qui commence par une lettre majuscule arrive en premier.
  2. S'il existe un texte correspondant, mais que l'un est en lettres capitales tandis que l'autre est en lettres minuscules, la version en lettres capitales est prioritaire.
  3. Le minuscule est ensuite trié.

Pour l’ordre décroissant, les étapes répertoriées précédemment sont traitées en inverse.

Par exemple, l’exemple suivant comporte un mélange de toutes les lettres minuscules, toutes les lettres majuscules et des textes avec casse correcte à trier dans l’ordre alphabétique.

let
    Source = { "Alpha", "Beta", "Zulu", "ALPHA", "gamma", "alpha", 
        "beta", "Gamma", "Sierra", "zulu", "GAMMA", "ZULU" },
    SortedList = List.Sort(Source, Order.Ascending)
in
    SortedList

Ce code produit la sortie suivante :

Capture d’écran de la liste créée en triant le texte avec toutes les minuscules, toutes les majuscules et une majuscule initiale.

Bien qu’il ne soit pas courant, vous pouvez avoir un mélange de lettres majuscules et minuscules dans le texte à trier. L’ordre de tri croissant dans ce cas est :

  1. Tout texte se trouvant dans la liste ou dans la colonne du tableau et commençant par une lettre majuscule se trouve en première position.
  2. S’il existe un texte correspondant, celui qui est à gauche et qui contient le plus de lettres majuscules est traité ensuite.
  3. Les lettres minuscules sont ensuite triées, en commençant par déplacer le nombre maximal de lettres majuscules à droite.

Dans tous les cas, il peut être plus pratique de convertir le texte en un format cohérent avant le tri.

Normalisation Power BI Desktop

Power Query M est sensible à la casse et fait la distinction entre différents types de capitalisation du même texte. Par exemple, « Foo », « foo » et « FOO » sont considérés comme différents. Toutefois, lorsque les données sont chargées dans Power BI Desktop, les valeurs de texte sont normalisées, ce qui signifie que Power BI Desktop les traite comme la même valeur, quelle que soit leur mise en majuscule. Par conséquent, si vous devez gérer la transformation des données dans Power Query tout en conservant la sensibilité à la casse, faites-le avant de charger les données dans Power BI Desktop.

Par exemple, le tableau suivant dans Power Query présente différents cas dans chaque ligne de la table.

Capture d’écran d’un tableau contenant le texte foo et too avec différentes capitalisations.

Lorsque ce tableau est chargé dans Power BI Desktop, les valeurs de texte deviennent normalisées, ce qui entraîne le tableau suivant.

Capture d’écran du même tableau chargé dans Power BI Desktop, avec le cas de chaque mot normalisé.

La première instance de « foo » et la première instance de « too » déterminent le cas de « foo » et « too » dans le reste des lignes de la table Power BI Desktop. Dans cet exemple, toutes les instances de « foo » sont normalisées à la valeur « Foo » et toutes les instances de « too » sont normalisées à la valeur « TOO ».