Python Snake Case Umwandlung

Einführung

In Python ist Snake Case eine Benennungskonvention, bei der Wörter durch Unterstriche getrennt werden. Dieser Benennungsstil wird üblicherweise für Variablen, Funktionen und andere Bezeichner in Python verwendet. Beispielsweise sind calculate_total_price und user_authentication im Snake-Case-Format.

Manchmal können wir Zeichenketten (Strings) in verschiedenen Formaten wie camelCase, PascalCase oder sogar Zeichenketten mit Leerzeichen und Bindestrichen begegnen. In solchen Situationen müssen wir diese Zeichenketten in Snake Case umwandeln, um die Konsistenz in unserem Code zu gewährleisten.

In diesem Lab (Labor) lernst du, wie du eine Python-Funktion schreibst, die Zeichenketten aus verschiedenen Formaten in Snake Case umwandelt.

Skills Graph

Das Problem verstehen

Bevor wir unsere Funktion zur Umwandlung in Snake Case schreiben, verstehen wir zunächst, was wir erreichen müssen:

1. Wir müssen eine Zeichenkette (String) aus einem beliebigen Format in Snake Case umwandeln.
2. Snake Case bedeutet, dass alle Buchstaben klein geschrieben sind und die Wörter durch Unterstriche getrennt werden.
3. Wir müssen verschiedene Eingabeformate verarbeiten:
   • camelCase (z.B. camelCase → camel_case)
   • Zeichenketten mit Leerzeichen (z.B. some text → some_text)
   • Zeichenketten mit gemischtem Format (z.B. Bindestriche, Unterstriche und gemischte Groß - und Kleinschreibung)

Beginnen wir damit, eine neue Python - Datei für unsere Snake - Case - Funktion zu erstellen. Im WebIDE navigieren Sie zum Projektverzeichnis und erstellen Sie eine neue Datei namens snake_case.py:

## This function will convert a string to snake case
def snake(s):
    ## We'll implement this function step by step
    pass  ## Placeholder for now

## Test with a simple example
if __name__ == "__main__":
    test_string = "helloWorld"
    result = snake(test_string)
    print(f"Original: {test_string}")
    print(f"Snake case: {result}")

Speichern Sie diese Datei. Im nächsten Schritt werden wir mit der Implementierung der Funktion beginnen.

Lassen Sie uns zunächst unsere Platzhalterfunktion ausführen, um sicherzustellen, dass unsere Datei korrekt eingerichtet ist. Öffnen Sie ein Terminal und führen Sie aus:

python3 ~/project/snake_case.py

Sie sollten eine Ausgabe wie die folgende sehen:

Original: helloWorld
Snake case: None

Das Ergebnis ist None, weil unsere Funktion derzeit nur den Standard - Python - Wert None zurückgibt. Im nächsten Schritt werden wir die eigentliche Umwandlungslogik hinzufügen.

Verwendung von regulären Ausdrücken (Regular Expressions) für die Mustererkennung

Um Zeichenketten (Strings) in Snake Case umzuwandeln, verwenden wir reguläre Ausdrücke (regex), um Wortgrenzen zu identifizieren. Das re-Modul in Python bietet leistungsstarke Mustererkennungsfunktionen, die wir für diese Aufgabe nutzen können.

Lassen Sie uns unsere Funktion aktualisieren, um camelCase-Zeichenketten zu verarbeiten:

1. Zunächst müssen wir das Muster identifizieren, bei dem ein Kleinbuchstabe von einem Großbuchstaben gefolgt wird (wie in "camelCase").
2. Dann fügen wir einen Leerzeichen zwischen ihnen ein.
3. Schließlich wandeln wir alles in Kleinbuchstaben um und ersetzen die Leerzeichen durch Unterstriche.

Aktualisieren Sie Ihre snake_case.py-Datei mit dieser verbesserten Funktion:

import re

def snake(s):
    ## Replace pattern of a lowercase letter followed by uppercase with lowercase, space, uppercase
    s1 = re.sub('([a-z])([A-Z])', r'\1 \2', s)

    ## Replace spaces with underscores and convert to lowercase
    return s1.lower().replace(' ', '_')

## Test with a simple example
if __name__ == "__main__":
    test_string = "helloWorld"
    result = snake(test_string)
    print(f"Original: {test_string}")
    print(f"Snake case: {result}")

Lassen Sie uns analysieren, was diese Funktion tut:

• re.sub('([a-z])([A-Z])', r'\1 \2', s) sucht nach Mustern, bei denen ein Kleinbuchstabe ([a-z]) von einem Großbuchstaben ([A-Z]) gefolgt wird. Es ersetzt dann dieses Muster durch dieselben Buchstaben, fügt aber mithilfe von \1 und \2, die auf die erfassten Gruppen verweisen, einen Leerzeichen zwischen sie ein.
• Dann wandeln wir alles mit lower() in Kleinbuchstaben um und ersetzen die Leerzeichen durch Unterstriche.

Führen Sie Ihr Skript erneut aus, um zu sehen, ob es für camelCase funktioniert:

python3 ~/project/snake_case.py

Die Ausgabe sollte jetzt wie folgt aussehen:

Original: helloWorld
Snake case: hello_world

Toll! Unsere Funktion kann jetzt camelCase-Zeichenketten verarbeiten. Im nächsten Schritt werden wir sie erweitern, um komplexere Fälle zu behandeln.

Umgang mit komplexeren Mustern

Unsere aktuelle Funktion funktioniert für camelCase, aber wir müssen sie erweitern, um zusätzliche Muster wie die folgenden zu verarbeiten:

1. PascalCase (z.B. HelloWorld)
2. Zeichenketten mit Bindestrichen (z.B. hello-world)
3. Zeichenketten, die bereits Unterstriche enthalten (z.B. hello_world)

Lassen Sie uns unsere Funktion aktualisieren, um diese Fälle zu behandeln:

import re

def snake(s):
    ## Replace hyphens with spaces
    s = s.replace('-', ' ')

    ## Handle PascalCase pattern (sequences of uppercase letters)
    s = re.sub('([A-Z]+)', r' \1', s)

    ## Handle camelCase pattern (lowercase followed by uppercase)
    s = re.sub('([a-z])([A-Z])', r'\1 \2', s)

    ## Split by spaces, join with underscores, and convert to lowercase
    return '_'.join(s.split()).lower()

## Test with multiple examples
if __name__ == "__main__":
    test_strings = [
        "helloWorld",
        "HelloWorld",
        "hello-world",
        "hello_world",
        "some text"
    ]

    for test in test_strings:
        result = snake(test)
        print(f"Original: {test}")
        print(f"Snake case: {result}")
        print("-" * 20)

Die Verbesserungen, die wir vorgenommen haben:

1. Zunächst ersetzen wir alle Bindestriche durch Leerzeichen.
2. Der neue reguläre Ausdruck re.sub('([A-Z]+)', r' \1', s) fügt vor jeder Folge von Großbuchstaben einen Leerzeichen ein, was bei PascalCase hilft.
3. Wir behalten unseren regulären Ausdruck zur Verarbeitung von camelCase bei.
4. Schließlich teilen wir die Zeichenkette anhand von Leerzeichen auf, verbinden sie mit Unterstrichen und wandeln sie in Kleinbuchstaben um, was alle verbleibenden Leerzeichen behandelt und eine konsistente Ausgabe gewährleistet.

Führen Sie Ihr Skript aus, um es mit verschiedenen Eingabeformaten zu testen:

python3 ~/project/snake_case.py

Sie sollten eine Ausgabe wie die folgende sehen:

Original: helloWorld
Snake case: hello_world
--------------------
Original: HelloWorld
Snake case: hello_world
--------------------
Original: hello-world
Snake case: hello_world
--------------------
Original: hello_world
Snake case: hello_world
--------------------
Original: some text
Snake case: some_text
--------------------

Unsere Funktion ist jetzt robuster und kann verschiedene Eingabeformate verarbeiten. Im nächsten Schritt werden wir die letzten Verbesserungen vornehmen und gegen die vollständige Testsuite testen.

Finale Implementierung und Tests

Jetzt vervollständigen wir unsere Implementierung, um alle erforderlichen Fälle zu behandeln, und überprüfen, ob sie alle Testfälle besteht.

Aktualisieren Sie Ihre snake_case.py-Datei mit der finalen Implementierung:

import re

def snake(s):
    ## Replace hyphens with spaces
    s = s.replace('-', ' ')

    ## Handle PascalCase pattern
    s = re.sub('([A-Z][a-z]+)', r' \1', s)

    ## Handle sequences of uppercase letters
    s = re.sub('([A-Z]+)', r' \1', s)

    ## Split by whitespace and join with underscores
    return '_'.join(s.split()).lower()

## Test with a complex example
if __name__ == "__main__":
    test_string = "some-mixed_string With spaces_underscores-and-hyphens"
    result = snake(test_string)
    print(f"Original: {test_string}")
    print(f"Snake case: {result}")

Diese finale Implementierung:

1. Ersetzt Bindestriche durch Leerzeichen
2. Fügt mithilfe von re.sub('([A-Z][a-z]+)', r' \1', s) einen Leerzeichen vor Mustern wie "Word" ein
3. Fügt mithilfe von re.sub('([A-Z]+)', r' \1', s) einen Leerzeichen vor Folgen von Großbuchstaben ein
4. Teilt die Zeichenkette anhand von Leerzeichen auf, verbindet sie mit Unterstrichen und wandelt sie in Kleinbuchstaben um

Jetzt führen wir unsere Funktion gegen die Testsuite aus, die im Einrichtungsschritt erstellt wurde:

cd /tmp && python3 test_snake.py

Wenn Ihre Implementierung korrekt ist, sollten Sie sehen:

All tests passed! Your snake case function works correctly.

Herzlichen Glückwunsch! Sie haben erfolgreich eine robuste Funktion zur Umwandlung in Snake Case implementiert, die verschiedene Eingabeformate verarbeiten kann.

Stellen wir sicher, dass unsere Funktion die Spezifikation genau einhält, indem wir sie mit den Beispielen aus dem ursprünglichen Problem testen:

## Add this to the end of your snake_case.py file:
if __name__ == "__main__":
    examples = [
        'camelCase',
        'some text',
        'some-mixed_string With spaces_underscores-and-hyphens',
        'AllThe-small Things'
    ]

    for ex in examples:
        result = snake(ex)
        print(f"Original: {ex}")
        print(f"Snake case: {result}")
        print("-" * 20)

Führen Sie Ihr aktualisiertes Skript aus:

python3 ~/project/snake_case.py

Sie sollten sehen, dass alle Beispiele korrekt in Snake Case umgewandelt werden:

Original: some-mixed_string With spaces_underscores-and-hyphens
Snake case: some_mixed_string_with_spaces_underscores_and_hyphens
Original: camelCase
Snake case: camel_case
--------------------
Original: some text
Snake case: some_text
--------------------
Original: some-mixed_string With spaces_underscores-and-hyphens
Snake case: some_mixed_string_with_spaces_underscores_and_hyphens
--------------------
Original: AllThe-small Things
Snake case: all_the_small_things
--------------------

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie eine Python-Funktion erstellen können, die Zeichenketten aus verschiedenen Formaten in Snake Case umwandelt. Hier ist, was Sie erreicht haben:

1. Sie haben gelernt, wie reguläre Ausdrücke für Mustererkennung und Zeichenkettenumwandlung verwendet werden können.
2. Sie haben eine Funktion implementiert, die verschiedene Eingabeformate verarbeiten kann:
   • camelCase (z.B. camelCase → camel_case)
   • PascalCase (z.B. HelloWorld → hello_world)
   • Zeichenketten mit Leerzeichen (z.B. some text → some_text)
   • Zeichenketten mit Bindestrichen (z.B. hello-world → hello_world)
   • Gemischte Formate mit verschiedenen Trennzeichen und Groß-/Kleinschreibung

Die Schlüsseltechniken, die Sie verwendet haben:

• Reguläre Ausdrücke mit Capture Groups (Gruppenerkennung) mithilfe von re.sub()
• Zeichenkettenmethoden wie replace(), lower(), split() und join()
• Mustererkennung für verschiedene Benennungskonventionen

Diese Fähigkeiten sind wertvoll für die Datenbereinigung, die Verarbeitung von Texteingaben und die Einhaltung konsistenter Codierungsstandards. Die Fähigkeit, zwischen verschiedenen Schreibweisen umzuwandeln, ist besonders nützlich, wenn Sie mit APIs oder Bibliotheken arbeiten, die unterschiedliche Benennungskonventionen verwenden.