Verwendung von Großbuchstaben in Power Query M

Mit Textdaten zu arbeiten kann manchmal unübersichtlich sein. Beispielsweise könnte der Name der Stadt Redmond in einer Datenbank mit unterschiedlichen Schreibweisen wie "Redmond", "redmond" und "REDMOND" dargestellt werden. Dies kann beim Transformieren der Daten in Power Query zu einem Problem führen, da die Power Query M-Formelsprache zwischen Groß- und Kleinschreibung unterscheidet.

Glücklicherweise bietet Power Query M Funktionen zum Bereinigen und Normalisieren der Schreibweise von Textdaten. Es gibt Funktionen zum Konvertieren von Text in Kleinbuchstaben (abc), Großbuchstabe (ABC) oder Groß-/Kleinschreibung (Abc). Darüber hinaus bietet Power Query M auch mehrere Möglichkeiten, die Groß- und Kleinschreibung gänzlich zu ignorieren.

In diesem Artikel erfahren Sie, wie Sie die Großschreibung von Wörtern in Text, Listen und Tabellen ändern. Außerdem werden verschiedene Methoden zum Ignorieren von Groß-/Kleinschreibung beim Bearbeiten von Daten in Text, Listen und Tabellen beschrieben. Darüber hinaus wird in diesem Artikel erläutert, wie sie nach Fall sortiert werden.

Ändern der Groß-/Kleinschreibung in Text

Es gibt drei Funktionen, mit denen Text in Kleinbuchstaben, Groß- und Kleinschreibung konvertiert wird. Die Funktionen sind Text.Lower, Text.Upperund Text.Proper. Die folgenden einfachen Beispiele veranschaulichen, wie diese Funktionen in Text verwendet werden können.

Konvertiere alle Zeichen im Text in Kleinbuchstaben

Im folgenden Beispiel wird veranschaulicht, wie alle Zeichen in einer Zeichenfolge in Kleinbuchstaben konvertiert werden.

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

Dieser Code erzeugt die folgende Ausgabe:

the quick brown fox jumps over the lazy dog.

Konvertieren aller Zeichen im Text in Großbuchstaben

Im folgenden Beispiel wird veranschaulicht, wie alle Zeichen in einer Textzeichenfolge in Großbuchstaben konvertiert werden.

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

Dieser Code erzeugt die folgende Ausgabe:

THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.

Alle Wörter in Großbuchstaben am Anfang umwandeln

Im folgenden Beispiel wird veranschaulicht, wie alle Wörter im Satz in initiale Großschreibung konvertiert werden.

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

Dieser Code erzeugt die folgende Ausgabe:

The Quick Brown Fox Jumps Over The Lazy Dog.

Ändern der Groß-/Kleinschreibung in Listen

Beim Ändern der Groß-/Kleinschreibung in Listen ist List.Transformdie am häufigsten zu verwendende Funktion . Die folgenden einfachen Beispiele veranschaulichen, wie diese Funktion in Listen verwendet werden kann.

Konvertieren aller Elemente in Kleinbuchstaben

Das folgende Beispiel zeigt, wie sie alle Elemente in einer Liste in Kleinbuchstaben ändern.

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

Dieser Code erzeugt die folgende Ausgabe:

Screenshot der Liste, die von der Listentransformationsfunktion erstellt wurde, die Ergebnisse in Kleinbuchstaben erzeugt.

Konvertieren aller Elemente in Großbuchstaben

Im folgenden Beispiel wird veranschaulicht, wie alle Elemente in einer Liste in Großbuchstaben geändert werden.

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

Dieser Code erzeugt die folgende Ausgabe:

Screenshot der Liste, die von der Listentransformationsfunktion erstellt wurde, die Großbuchstabenergebnisse erzeugt.

Umwandeln aller Elemente in die richtige Groß- und Kleinschreibung

Im folgenden Beispiel wird veranschaulicht, wie Sie alle Elemente in einer Liste in die richtige Schreibweise ändern.

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

Dieser Code erzeugt die folgende Ausgabe:

Screenshot der Liste, die von der Listentransformationsfunktion erstellt wurde, die die richtigen Fallergebnisse erzeugt.

Ändern der Schreibweise in Tabellen

Beim Ändern der Groß-/Kleinschreibung in Tabellen ist Table.TransformColumnsdie am häufigsten zu verwendende Funktion . Es gibt auch eine Funktion, die Table.TransformRows genannt wird, mit der Sie die Schriftart von Text ändern können, der in einer Zeile enthalten ist. Diese Funktion wird jedoch nicht so oft verwendet.

Die folgenden einfachen Beispiele veranschaulichen, wie die Table.TransformColumns Funktion verwendet werden kann, um den Fall in Tabellen zu ändern.

Konvertieren aller Elemente in einer Tabellenspalte in Kleinbuchstaben

Im folgenden Beispiel wird veranschaulicht, wie alle Elemente in einer Tabellenspalte in Kleinbuchstaben geändert werden, in diesem Fall die Kundennamen.

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"

Dieser Code erzeugt die folgende Ausgabe:

Screenshot der Tabelle, die von der Funktion zur Spaltentransformation erstellt wurde, die Kleinbuchstabenergebnisse erzeugt.

Konvertieren aller Elemente in einer Tabellenspalte in Großbuchstaben

Im folgenden Beispiel wird veranschaulicht, wie alle Elemente in einer Tabellenspalte in Großbuchstaben geändert werden, in diesem Fall die Obstnamen.

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"

Dieser Code erzeugt die folgende Ausgabe:

Screenshot der Tabelle, die mit der Funktion

Konvertieren aller Elemente in einer Tabelle in die richtige Groß-/Kleinschreibung

Im folgenden Beispiel wird veranschaulicht, wie Sie alle Elemente in beiden Tabellenspalten in die korrekte Groß-/Kleinschreibung ändern.

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"

Dieser Code erzeugt die folgende Ausgabe:

Screenshot der Tabelle, die durch die Funktion zur Spaltentransformation erstellt wurde und in beiden Spalten korrekte Groß- und Kleinschreibungsergebnisse liefert.

Groß-/Kleinschreibung ignorieren

In vielen Fällen müssen Sie beim Suchen oder Ersetzen von Elementen möglicherweise den Fall des gesuchten Elements ignorieren. Da die Power Query M-Formelsprache groß- und kleinschreibungssensitiv ist, führen Vergleiche zwischen identischen Elementen, die sich nur in der Groß- und Kleinschreibung unterscheiden, dazu, dass die Elemente als unterschiedlich und nicht als identisch erkannt werden. Eine Methode zum Ignorieren des Falls umfasst die Verwendung der Funktion in Funktionen, die Comparer.OrdinalIgnoreCase entweder einen equationCriteria Parameter oder einen comparer Parameter enthalten. Eine andere Methode zum Ignorieren des Falls umfasst die Verwendung der IgnoreCase Option (sofern verfügbar) in Funktionen, die einen options Parameter enthalten.

Groß-/Kleinschreibung im Text ignorieren

Bei Suchvorgängen in Text müssen Sie manchmal die Groß-/Kleinschreibung ignorieren, um alle Instanzen des gesuchten Texts zu finden. Textfunktionen verwenden in der Comparer.OrdinalIgnoreCase-Funktion die comparer-Funktion im Parameter, um die Groß-/Kleinschreibung beim Testen auf Gleichheit zu ignorieren.

Das folgende Beispiel zeigt, wie Die Groß-/Kleinschreibung ignoriert wird, wenn ermittelt wird, ob ein Satz ein bestimmtes Wort enthält, unabhängig von der Groß-/Kleinschreibung.

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

Dieser Code erzeugt die folgende Ausgabe:

true

Im folgenden Beispiel wird gezeigt, wie Die anfangsposition des letzten Vorkommens des Worts "the" im Satz unabhängig vom Fall abgerufen wird.

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

Dieser Code erzeugt die folgende Ausgabe:

34

Ignorieren von Groß-/Kleinschreibung in Listen

Jede Listenfunktion, die einen optionalen equationCriteria-Parameter enthält, kann die Comparer.OrdinalIgnoreCase-Funktion verwenden, um die Groß- und Kleinschreibung in der Liste zu ignorieren.

Im folgenden Beispiel wird überprüft, ob eine Liste ein bestimmtes Element enthält, während die Groß-/Kleinschreibung ignoriert wird. In diesem Beispiel List.Contains kann nur ein Element in der Liste verglichen werden, Sie können eine Liste nicht mit einer Liste vergleichen. Dazu müssen Sie List.ContainsAny verwenden.

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

Dieser Code erzeugt die folgende Ausgabe:

true

In den folgenden Beispielen wird überprüft, ob eine Liste alle angegebenen Elemente im zweiten Parameter (value) enthält, während die Groß-/Kleinschreibung ignoriert wird. Wenn ein Element nicht in der Liste enthalten ist, z cucumber . B. im zweiten Beispiel, gibt die Funktion FALSE zurück.

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

Dieser Code erzeugt die folgende Ausgabe:

true

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

Dieser Code erzeugt die folgende Ausgabe:

false

Im folgenden Beispiel wird überprüft, ob es sich bei einem der Elemente in der Liste um Äpfel oder Birnen handelt, während der Fall ignoriert wird.

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

Dieser Code erzeugt die folgende Ausgabe:

true

Im folgenden Beispiel werden nur eindeutige Elemente beibehalten, wobei die Groß-/Kleinschreibung ignoriert wird.

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

Dieser Code erzeugt die folgende Ausgabe:

Screenshot der Liste, die von der Funktion

Im vorherigen Beispiel zeigt die Ausgabe den Fall des ersten eindeutigen Elements in der Liste an. Obwohl es zwei Äpfel (ApPlE und APPLE) gibt, wird nur das erste gefundene Beispiel angezeigt.

Im folgenden Beispiel werden nur eindeutige Elemente beibehalten, wobei die Groß-/Kleinschreibung ignoriert wird. Alle Ergebnisse werden jedoch in Kleinbuchstaben ausgegeben.

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

Dieser Code erzeugt die folgende Ausgabe:

Screenshot der Liste, die von der Funktion

Groß-/Kleinschreibung in Tabellen ignorieren

Tabellen haben mehrere Möglichkeiten, groß-/kleinschreibung zu ignorieren. Tabellenfunktionen wie Table.Contains, Table.Distinctund Table.PositionOf alle enthalten equationCriteria Parameter. Diese Parameter können die Funktion verwenden, um die Comparer.OrdinalIgnoreCase Groß-/Kleinschreibung in Tabellen zu ignorieren, ähnlich wie die Listen in den vorherigen Abschnitten. Tabellenfunktionen, wie Table.MatchesAnyRows, die einen condition-Parameter enthalten, können auch Comparer.OrdinalIgnoreCase verwenden, das in andere Tabellenfunktionen eingebettet ist, um die Groß-/Kleinschreibung zu ignorieren. Andere Tabellenfunktionen, speziell für Fuzzyabgleich, können die IgnoreCase Option verwenden.

Im folgenden Beispiel wird veranschaulicht, wie spezifische Zeilen ausgewählt werden, die das Wort "Birne" enthalten, ohne Berücksichtigung der Groß-/Kleinschreibung. In diesem Beispiel wird der condition Parameter " Table.SelectRows with" Text.Contains als bedingte Parameter verwendet, um die Vergleiche während des Ignorierens des Falls vorzunehmen.

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"

Dieser Code erzeugt die folgende Ausgabe:

Screenshot der Tabelle, die mit der Funktion zum Auswählen von Tabelleneinträgen erstellt wurde, bei der die Groß-/Kleinschreibung ignoriert wird.

Das folgende Beispiel zeigt, wie Sie ermitteln können, ob eine der Zeilen in einer Tabelle eine pear in der FRUIT Spalte enthalten. In diesem Beispiel wird Comparer.OrdinalIgnoreCase in einer Text.Contains-Funktion unter Verwendung des condition-Parameters der Table.MatchesAnyRows-Funktion verwendet.

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"

Dieser Code erzeugt die folgende Ausgabe:

true

Im folgenden Beispiel wird gezeigt, wie eine Tabelle mit Werten, die von Benutzern eingegeben wurden, und einer Spalte mit ihren Lieblingsfrüchten ohne festgelegtes Format aussieht. Diese Spalte wird zunächst mithilfe von Fuzzy-Matching verwendet, um die Namen ihrer Lieblingsfrucht zu extrahieren, die dann in einer eigenen Spalte mit dem Namen Cluster angezeigt werden. Anschließend wird die Clusterspalte untersucht, um die verschiedenen unterschiedlichen Früchte zu bestimmen, die sich in der Spalte befinden. Sobald die einzigartigen Früchte bestimmt sind, besteht ein letzter Schritt darin, alle Fruchtnamen in Kleinbuchstaben zu ändern.

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"

Dieser Code erzeugt die folgende Ausgabe:

Screenshot der Tabelle, die durch unscharfes Abgleichen erstellt wurde, wobei die Groß-/Kleinschreibung ignoriert wird.

Groß- und Kleinschreibung und Sortierung

Listen und Tabellen können jeweils entweder mit List.Sort oder Table.Sort sortiert werden. Das Sortieren von Text hängt jedoch von der Groß-/Kleinschreibung der zugeordneten Elemente in der Liste oder Tabelle ab, um die tatsächliche Sortierreihenfolge (entweder aufsteigend oder absteigend) zu bestimmen.

Die am häufigsten verwendete Sortierungsform verwendet Text, bei dem entweder alles in Kleinbuchstaben, alles in Großbuchstaben oder alles in korrekter Groß-/Kleinschreibung geschrieben ist. Wenn eine Mischung aus diesen Fällen besteht, lautet die aufsteigende Sortierreihenfolge wie folgt:

  1. Jeder Text in der Liste oder Tabellenspalte, der mit einem Großbuchstaben beginnt, ist zuerst.
  2. Wenn es identischen Text gibt, aber einer in Eigennamen-Schreibung und der andere in Großbuchstaben ist, kommt die Version in Großbuchstaben zuerst.
  3. Kleinschreibung wird dann sortiert.

Bei absteigender Reihenfolge werden die zuvor aufgeführten Schritte umgekehrt verarbeitet.

Das folgende Beispiel enthält eine Mischung aus vollständig klein geschriebenem Text, vollständig groß geschriebenem Text und Text in korrekter Großschreibung, der in aufsteigender Reihenfolge sortiert werden soll.

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

Dieser Code erzeugt die folgende Ausgabe:

Screenshot der Liste, die durch Sortieren von Text mit nur in Kleinbuchstaben, nur in Großbuchstaben und richtiger Groß- und Kleinschreibung erstellt wurde.

Obwohl es nicht üblich ist, können Sie eine Mischung aus Groß- und Kleinbuchstaben im Text zum Sortieren haben. Die aufsteigende Sortierreihenfolge in diesem Fall lautet:

  1. Jeder Text in der Liste oder Tabellenspalte, der mit einem Großbuchstaben beginnt, ist zuerst.
  2. Wenn übereinstimmender Text vorhanden ist, wird der Text mit der höchsten Anzahl an Großbuchstaben als nächstes bearbeitet.
  3. Die Kleinbuchstaben werden dann sortiert, wobei die maximale Anzahl von Großbuchstaben zuerst nach rechts verschoben wird.

In jedem Fall ist es praktischer, den Text in einen konsistenten Fall zu konvertieren, bevor er sortiert wird.

Power BI Desktop-Normalisierung

Bei Power Query M wird die Groß-/Kleinschreibung beachtet und zwischen unterschiedlichen Schreibweisen desselben Texts unterschieden. Beispielsweise werden "Foo", "foo" und "FOO" als unterschiedlich behandelt. Wenn die Daten jedoch in Power BI Desktop geladen werden, werden die Textwerte normalisiert, was bedeutet, dass Power BI Desktop sie unabhängig von der Großschreibung als denselben Wert behandelt. Daher sollten Sie, wenn Sie Daten transformieren müssen und die Groß- und Kleinschreibung in Ihren Daten beibehalten möchten, die Datentransformation in Power Query durchführen, bevor Sie die Daten in Power BI Desktop laden.

In der folgenden Tabelle in Power Query werden beispielsweise in jeder Zeile der Tabelle unterschiedliche Fälle angezeigt.

Screenshot einer Tabelle mit dem Text foo und too in verschiedenen Schreibweisen.

Wenn diese Tabelle in Power BI Desktop geladen wird, werden die Textwerte normalisiert, was zu der folgenden Tabelle führt.

Screenshot der gleichen Tabelle, die in Power BI Desktop geladen wurde, wobei die Schreibweise jedes Wortes vereinheitlicht ist.

Die erste Instanz von "foo" und die erste Instanz von "too" bestimmen die Schreibweise von "foo" und "too" in den restlichen Zeilen der Power BI Desktop-Tabelle. In diesem Beispiel werden alle Vorkommen von "foo" auf den Wert "Foo" normalisiert und alle Vorkommen von "too" auf den Wert "TOO" normalisiert.

  • Last updated on