Wie man die Ausgabe beim Python-Drucken ausrichtet

PythonPythonBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

Beim Schreiben von Python-Programmen ist es für die Lesbarkeit des Codes und die Benutzererfahrung von entscheidender Bedeutung, die Ausgabe sauber und organisiert darzustellen. Egal, ob Sie Berichte erstellen, tabellarische Daten anzeigen oder einfach Informationen auf der Konsole ausgeben, die richtige Textausrichtung macht Ihre Ausgabe professioneller und leichter lesbar.

In diesem Lab werden Sie verschiedene Techniken zur Ausrichtung und Formatierung von Textausgaben in Python lernen. Sie werden verschiedene Ausrichtungsmethoden erkunden, Formatierungstechniken üben und gut strukturierte tabellarische Darstellungen erstellen, die in realen Anwendungen eingesetzt werden können.

Grundlegende String-Ausrichtung in Python

In diesem ersten Schritt werden Sie die grundlegenden Konzepte der Textausrichtung in Python kennenlernen und grundlegende Ausrichtungstechniken implementieren.

Was ist Textausrichtung?

Textausrichtung bezieht sich darauf, wie Text innerhalb eines bestimmten Bereichs positioniert wird. Python bietet mehrere Methoden, um die Positionierung von Text beim Ausgeben auf der Konsole zu steuern. Die drei Haupttypen der Ausrichtung sind:

  • Linksbündige Ausrichtung: Der Text beginnt am linken Rand des zugewiesenen Bereichs.
  • Rechtsbündige Ausrichtung: Der Text endet am rechten Rand des zugewiesenen Bereichs.
  • Zentrierte Ausrichtung: Der Text wird innerhalb des zugewiesenen Bereichs zentriert.

Ihr erstes Ausrichtungsprogramm

Erstellen wir ein einfaches Python-Skript, um die grundlegenden Ausrichtungstechniken zu demonstrieren.

  1. Öffnen Sie die WebIDE in Ihrer LabEx-Umgebung.

  2. Erstellen Sie eine neue Datei mit dem Namen basic_alignment.py im Verzeichnis /home/labex/project, indem Sie auf das Symbol "Neue Datei" in der WebIDE klicken.

  3. Fügen Sie der Datei folgenden Code hinzu:

## basic_alignment.py
print("Basic String Alignment Examples")
print("-" * 30)

## Left alignment example
print("Left alignment:")
print("Python".ljust(20) + "|")
print("Programming".ljust(20) + "|")
print("Alignment".ljust(20) + "|")
print()

## Right alignment example
print("Right alignment:")
print("Python".rjust(20) + "|")
print("Programming".rjust(20) + "|")
print("Alignment".rjust(20) + "|")
print()

## Center alignment example
print("Center alignment:")
print("Python".center(20) + "|")
print("Programming".center(20) + "|")
print("Alignment".center(20) + "|")
  1. Speichern Sie die Datei, indem Sie Strg+S drücken oder im Menü "Datei" > "Speichern" auswählen.

  2. Öffnen Sie ein Terminal in der WebIDE (falls es noch nicht geöffnet ist), indem Sie auf das Menü "Terminal" klicken und "Neues Terminal" auswählen.

  3. Führen Sie das Skript mit dem Python-Interpreter aus:

cd ~/project
python3 basic_alignment.py
  1. Sie sollten die folgende Ausgabe sehen:
Basic String Alignment Examples
------------------------------
Left alignment:
Python              |
Programming         |
Alignment           |

Right alignment:
              Python|
         Programming|
           Alignment|

Center alignment:
       Python       |
     Programming    |
      Alignment     |

Verständnis des Codes

Das von Ihnen gerade erstellte Skript demonstriert drei grundlegende String-Ausrichtungsmethoden in Python:

  • ljust(width): Justiert den String linksbündig innerhalb eines Felds der angegebenen Breite.
  • rjust(width): Justiert den String rechtsbündig innerhalb eines Felds der angegebenen Breite.
  • center(width): Zentriert den String innerhalb eines Felds der angegebenen Breite.

In jedem Beispiel haben wir am Ende jeder Zeile eine senkrechte Linie (|) hinzugefügt, um die Grenze des zugewiesenen Bereichs deutlich zu zeigen. Beachten Sie, wie sich der Text in jedem Fall unterschiedlich ausrichtet, während die Gesamtbreite von 20 Zeichen beibehalten wird.

String-Ausrichtung mit verschiedenen Zeichen

Die String-Justierungsmethoden können auch einen zweiten Parameter akzeptieren, um das Füllzeichen anzugeben, das für die Auffüllung verwendet wird. Ändern wir unser Skript, um dies in Aktion zu sehen.

  1. Erstellen Sie eine neue Datei mit dem Namen alignment_with_chars.py im Verzeichnis /home/labex/project.

  2. Fügen Sie der Datei folgenden Code hinzu:

## alignment_with_chars.py
print("String Alignment With Custom Characters")
print("-" * 40)

## Using different padding characters
print("Left alignment with dots:")
print("Python".ljust(20, '.') + "|")
print("Programming".ljust(20, '.') + "|")
print()

print("Right alignment with asterisks:")
print("Python".rjust(20, '*') + "|")
print("Programming".rjust(20, '*') + "|")
print()

print("Center alignment with hyphens:")
print("Python".center(20, '-') + "|")
print("Programming".center(20, '-') + "|")
  1. Speichern Sie die Datei und führen Sie sie aus:
python3 ~/project/alignment_with_chars.py
  1. Sie sollten eine Ausgabe wie diese sehen:
String Alignment With Custom Characters
----------------------------------------
Left alignment with dots:
Python..............|
Programming.........|

Right alignment with asterisks:
**************Python|
*********Programming|

Center alignment with hyphens:
-------Python------|
----Programming----|

Diese Beispiele zeigen, wie Sie das Erscheinungsbild Ihres ausgerichteten Texts durch die Verwendung verschiedener Füllzeichen anpassen können.

Erweiterte Formatierungsmethoden für die Ausrichtung

Im vorherigen Schritt haben Sie die grundlegende Ausrichtung von Zeichenketten mit den Methoden ljust(), rjust() und center() kennengelernt. Nun wollen wir leistungsfähigere und flexiblere Formatierungsmethoden in Python erkunden.

Zeichenkettenformatierungsmethoden in Python

Python bietet verschiedene Möglichkeiten zur Formatierung von Zeichenketten:

  1. Alte Formatierung (mit dem Operator %)
  2. Die Methode str.format()
  3. F-Strings (formatierte Zeichenkettenliterale, verfügbar ab Python 3.6)

Jede Methode bietet Möglichkeiten zur Ausrichtung von Text und zur Formatierung verschiedener Datentypen. Lassen Sie uns diese nacheinander untersuchen.

1. Alte Formatierung (%-Operator)

Dies ist die älteste Methode zur Zeichenkettenformatierung in Python, ähnlich der printf()-Funktion von C.

  1. Erstellen Sie eine neue Datei mit dem Namen old_style_formatting.py im Verzeichnis /home/labex/project:
## old_style_formatting.py
print("Alte Zeichenkettenformatierung")
print("-" * 30)

## Linksausrichtung mit % Formatierung
print("Linksausrichtung:")
print("%-15s | %-10s" % ("Python", "Sprache"))
print("%-15s | %-10s" % ("JavaScript", "Web"))
print()

## Rechtsausrichtung mit % Formatierung
print("Rechtsausrichtung:")
print("%15s | %10s" % ("Python", "Sprache"))
print("%15s | %10s" % ("JavaScript", "Web"))
print()

## Zahlenformatierung
preis = 125.5
steuersatz = 0.21
print("Preis: $%8.2f" % preis)
print("Steuersatz: %6.1f%%" % (steuersatz * 100))
print("Steuerbetrag: $%6.2f" % (preis * steuersatz))
print("Gesamt: $%8.2f" % (preis * (1 + steuersatz)))
  1. Speichern Sie die Datei und führen Sie sie aus:
python3 ~/project/old_style_formatting.py
  1. Sie sollten eine Ausgabe ähnlich der folgenden erhalten:
Alte Zeichenkettenformatierung
------------------------------
Linksausrichtung:
Python          | Sprache
JavaScript      | Web

Rechtsausrichtung:
         Python |  Sprache
     JavaScript |       Web

Zahlenformatierung:
Preis: $   125.50
Steuersatz:   21.0%
Steuerbetrag: $ 26.36
Gesamt: $   151.86

2. Die Methode str.format()

Die Methode str.format() bietet eine vielseitigere Möglichkeit zur Formatierung von Zeichenketten und wurde eingeführt, um einige Einschränkungen des %-Operators zu beheben.

  1. Erstellen Sie eine neue Datei mit dem Namen format_method.py im Verzeichnis /home/labex/project:
## format_method.py
print("Zeichenkettenformatierung mit str.format()")
print("-" * 35)

## Grundlegende Ausrichtung mit format
print("Grundlegende Ausrichtung:")
print("{:<15} | {:<10}".format("Python", "Sprache"))
print("{:>15} | {:>10}".format("Python", "Sprache"))
print("{:^15} | {:^10}".format("Python", "Sprache"))
print()

## Ausrichtung mit benutzerdefiniertem Füllzeichen
print("Benutzerdefiniertes Füllzeichen:")
print("{:*<15} | {:.>10}".format("Python", "Sprache"))
print("{:#^15} | {:=^10}".format("Python", "Sprache"))
print()

## Ausrichtung mit Feldnamen
print("Feldnamen verwenden:")
print("{name:<15} | {type:<10}".format(name="JavaScript", type="Web"))
print("{name:>15} | {type:>10}".format(name="Python", type="Sprache"))
print()

## Zahlenformatierung
preis = 125.5
steuersatz = 0.21
print("Zahlenformatierung:")
print("Preis: ${:8.2f}".format(preis))
print("Steuersatz: {:6.1f}%".format(steuersatz * 100))
print("Steuerbetrag: ${:6.2f}".format(preis * steuersatz))
print("Gesamt: ${:8.2f}".format(preis * (1 + steuersatz)))
  1. Speichern Sie die Datei und führen Sie sie aus:
python3 ~/project/format_method.py
  1. Sie sollten eine Ausgabe ähnlich der folgenden erhalten:
Zeichenkettenformatierung mit str.format()
-----------------------------------
Grundlegende Ausrichtung:
Python          | Sprache
         Python |   Sprache
    Python      |  Sprache

Benutzerdefiniertes Füllzeichen:
Python********* | Sprache...
#####Python##### | ==Sprache==

Feldnamen verwenden:
JavaScript      | Web
         Python |  Sprache

Zahlenformatierung:
Preis: $  125.50
Steuersatz:   21.0%
Steuerbetrag: $ 26.36
Gesamt: $  151.86

3. F-Strings (Python 3.6+)

F-Strings bieten eine prägnante und bequeme Möglichkeit, Ausdrücke in Zeichenkettenliterale einzubetten. Sie werden mit dem Buchstaben 'f' vorangestellt und verwenden geschweifte Klammern {}, um Ausdrücke einzuschließen.

  1. Erstellen Sie eine neue Datei mit dem Namen f_strings.py im Verzeichnis /home/labex/project:
## f_strings.py
print("Zeichenkettenformatierung mit F-Strings")
print("-" * 35)

sprache = "Python"
kategorie = "Sprache"
version = 3.10
jahr = 2022

## Grundlegende Ausrichtung mit F-Strings
print("Grundlegende Ausrichtung:")
print(f"{sprache:<15} | {kategorie:<10}")
print(f"{sprache:>15} | {kategorie:>10}")
print(f"{sprache:^15} | {kategorie:^10}")
print()

## Dynamische Breitenangabe
breite1 = 15
breite2 = 10
print("Dynamische Breite:")
print(f"{sprache:<{breite1}} | {kategorie:<{breite2}}")
print(f"{sprache:>{breite1}} | {kategorie:>{breite2}}")
print()

## Ausdrücke in F-Strings
print("Ausdrücke in F-Strings:")
print(f"{sprache + str(version):<15} | {jahr - 1991:>10} Jahre alt")
print()

## Zahlenformatierung
preis = 125.5
steuersatz = 0.21
print("Zahlenformatierung:")
print(f"Preis: ${preis:8.2f}")
print(f"Steuersatz: {steuersatz * 100:6.1f}%")
print(f"Steuerbetrag: ${preis * steuersatz:6.2f}")
print(f"Gesamt: ${preis * (1 + steuersatz):8.2f}")
  1. Speichern Sie die Datei und führen Sie sie aus:
python3 ~/project/f_strings.py
  1. Sie sollten eine Ausgabe ähnlich der folgenden erhalten:
Zeichenkettenformatierung mit F-Strings
-----------------------------------
Grundlegende Ausrichtung:
Python          | Sprache
         Python |  Sprache
    Python      | Sprache

Dynamische Breite:
Python          | Sprache
         Python |  Sprache

Ausdrücke in F-Strings:
Python 3.1      |         31 Jahre alt

Zahlenformatierung:
Preis: $  125.50
Steuersatz:   21.0%
Steuerbetrag: $ 26.36
Gesamt: $  151.86

Vergleich der Formatierungsmethoden

Jede Formatierungsmethode hat ihre Vorteile. Hier ist, wann welche Methode verwendet werden sollte:

  • %-Operator: Verwenden Sie ihn in veraltetem Code oder wenn die Kompatibilität mit älteren Python-Versionen erforderlich ist.
  • str.format(): Leistungsfähiger als die %-Formatierung, insbesondere bei komplexen Formatierungsanforderungen.
  • F-Strings: Die prägnanteste und lesbarste Option, empfohlen für alle neuen Python-Codes (Python 3.6+).

Der moderne Trend in Python ist es, F-Strings nach Möglichkeit zu verwenden, aufgrund ihrer Lesbarkeit und Leistung.

Tabellen mit formatierten Spalten in Python erstellen

Nachdem Sie nun verschiedene Ausrichtungstechniken kennengelernt haben, wenden wir sie an, um gut formatierte Tabellen zu erstellen. Tabellen sind eine gängige Methode, um strukturierte Daten in einem lesbaren Format darzustellen, und eine korrekte Ausrichtung ist entscheidend für die effektive Präsentation tabellarischer Informationen.

Einfache Tabelle mit Spalten fester Breite

Beginnen wir mit der Erstellung einer einfachen Tabelle mit Spalten fester Breite.

  1. Erstellen Sie eine neue Datei mit dem Namen simple_table.py im Verzeichnis /home/labex/project:
## simple_table.py
print("Einfache Tabelle fester Breite")
print("-" * 50)

## Daten definieren
header = ["Name", "Alter", "Stadt", "Beruf"]
data = [
    ["John Smith", 34, "New York", "Arzt"],
    ["Sarah Johnson", 28, "San Francisco", "Ingenieurin"],
    ["Michael Brown", 42, "Chicago", "Lehrer"],
    ["Emily Davis", 31, "Boston", "Wissenschaftlerin"]
]

## Kopfzeile ausgeben
print(f"{header[0]:<20} {header[1]:<8} {header[2]:<15} {header[3]:<15}")
print("-" * 60)

## Zeilen ausgeben
for row in data:
    print(f"{row[0]:<20} {row[1]:<8} {row[2]:<15} {row[3]:<15}")
  1. Speichern Sie die Datei und führen Sie sie aus:
python3 ~/project/simple_table.py
  1. Sie sollten eine gut formatierte Tabelle wie diese sehen:
Einfache Tabelle fester Breite
--------------------------------------------------
Name                 Alter      Stadt            Beruf
------------------------------------------------------------
John Smith           34       New York        Arzt
Sarah Johnson        28       San Francisco   Ingenieurin
Michael Brown        42       Chicago         Lehrer
Emily Davis          31       Boston          Wissenschaftlerin

Dynamische Tabelle mit verschiedenen Ausrichtungstypen

Unterschiedliche Datentypen sehen oft mit verschiedenen Ausrichtungsstilen besser aus. Beispielsweise werden Texte häufig linksbündig und Zahlen rechtsbündig ausgerichtet. Erstellen wir nun eine komplexere Tabelle mit gemischten Ausrichtungen.

  1. Erstellen Sie eine neue Datei mit dem Namen dynamic_table.py im Verzeichnis /home/labex/project:
## dynamic_table.py
print("Dynamische Tabelle mit gemischter Ausrichtung")
print("-" * 50)

## Daten definieren
header = ["Produkt", "Preis", "Menge", "Gesamt"]
produkte = [
    ["Laptop", 1299.99, 3, 3899.97],
    ["Maus", 24.50, 10, 245.00],
    ["Monitor", 349.95, 2, 699.90],
    ["Tastatur", 49.99, 5, 249.95],
    ["Kopfhörer", 89.95, 4, 359.80]
]

## Spaltenbreiten basierend auf Inhalten berechnen
spaltenbreiten = [
    max(len(str(header[0])), max(len(str(zeile[0])) for zeile in produkte)) + 2,
    max(len(str(header[1])), max(len(f"${zeile[1]:.2f}") for zeile in produkte)) + 2,
    max(len(str(header[2])), max(len(str(zeile[2])) for zeile in produkte)) + 2,
    max(len(str(header[3])), max(len(f"${zeile[3]:.2f}") for zeile in produkte)) + 2
]

## Kopfzeile ausgeben
print(f"{header[0]:<{spaltenbreiten[0]}}"
      f"{header[1]:>{spaltenbreiten[1]}}"
      f"{header[2]:>{spaltenbreiten[2]}}"
      f"{header[3]:>{spaltenbreiten[3]}}")
print("-" * sum(spaltenbreiten))

## Zeilen mit der entsprechenden Ausrichtung ausgeben
for produkt in produkte:
    print(f"{produkt[0]:<{spaltenbreiten[0]}}",
          f"${produkt[1]:.2f}".rjust(spaltenbreiten[1]),
          f"{produkt[2]}".rjust(spaltenbreiten[2]),
          f"${produkt[3]:.2f}".rjust(spaltenbreiten[3]))

## Zusammenfassung ausgeben
gesamtmenge = sum(produkt[2] for produkt in produkte)
gesamtbetrag = sum(produkt[3] for produkt in produkte)
print("-" * sum(spaltenbreiten))
print(f"{'GESAMT':<{spaltenbreiten[0]}}",
      f"".rjust(spaltenbreiten[1]),
      f"{gesamtmenge}".rjust(spaltenbreiten[2]),
      f"${gesamtbetrag:.2f}".rjust(spaltenbreiten[3]))

... (restliche Code-Abschnitte)

Zusammenfassung

In diesem Lab haben Sie verschiedene Techniken zum Ausrichten und Formatieren von Textausgaben in Python gelernt:

  • Grundlegende String-Ausrichtungsmethoden: ljust(), rjust() und center()
  • Verschiedene String-Formatierungsansätze: %-Operator, str.format() und F-Strings
  • Wie man gut strukturierte Tabellen mit Spalten fester Breite erstellt
  • Wie man verschiedene Ausrichtungsstile basierend auf Datentypen anwendet
  • Wie man reale Anwendungen wie Finanzberichte mit korrekter Formatierung erstellt

Diese Fähigkeiten zur Textausrichtung sind für die Erstellung von lesbaren, professionellen Ausgaben in vielen Anwendungen unerlässlich, von einfachen Befehlszeilen-Utilities bis hin zu komplexen Datenverarbeitungssystemen. Durch das Beherrschen der Textausrichtung in Python können Sie die Benutzererfahrung und die Lesbarkeit Ihrer Programme erheblich verbessern.

Wenn Sie Ihre Python-Reise fortsetzen, denken Sie daran, dass saubere, gut formatierte Ausgaben oft genauso wichtig sind wie die Rechenlogik Ihrer Programme. Die in diesem Lab gelernten Techniken werden Ihnen helfen, Ihre Daten so darzustellen, dass sie sowohl funktional als auch optisch ansprechend sind.