Python Kommandozeilenoptionen: argparse, Click, Typer erklärt [Anfänger]

1. Einführung

Python ist eine flexible und leistungsstarke Programmiersprache, die von vielen Entwicklern genutzt wird. Insbesondere kann die Nutzung von Command-Line-Optionen die Bedienbarkeit von Skripten und Anwendungen verbessern.

In diesem Artikel erklären wir umfassend, wie man Command-Line-Optionen in Python handhabt. Konkret stellen wir drei Bibliotheken vor: die Standardbibliothek argparse, sowie die externen Bibliotheken Click und Typer. Wir erklären auch die Unterschiede und wann man welche verwendet.

2. Was sind Kommandozeilenoptionen in Python?

In Python können Sie durch die Verwendung von Kommandozeilenoptionen Argumente beim Ausführen des Skripts übergeben, um das Verhalten zu steuern. Zum Beispiel betrachten Sie ein Skript wie das Folgende.

python script.py --name Alice --age 25

Durch die Nutzung solcher Optionsargumente kann der Benutzer das Verhalten des Skripts anpassen.

2.1 Warum ist die Optionsanalyse notwendig?

Beim Erstellen von Python-Skripten können Sie Eingaben auch über die Standardeingabe erhalten, aber durch die Nutzung von Kommandozeilenoptionen können Sie eine flexible und intuitive Benutzeroberfläche bereitstellen. Es gibt folgende Vorteile.

• Die Vielseitigkeit des Skripts verbessert sich (kann mit unterschiedlichen Parametern ausgeführt werden)
• Interaktion mit dem Benutzer ohne GUI möglich (geeignet für Terminalbedienung)
• Verhalten ohne Konfigurationsdatei änderbar

In Python gibt es mehrere Bibliotheken, um Kommandozeilenoptionen zu analysieren. Darunter sind besonders die folgenden drei wichtig.

2.2 Vergleich von argparse・Click・Typer

In Python gibt es mehrere Methoden, um Kommandozeilenoptionen zu analysieren, aber ich habe die repräsentativen in einer Tabelle zusammengefasst.

3. Wie man Kommandozeilenoptionen in Python handhabt

Es gibt mehrere Methoden, um Kommandozeilenoptionen in Python zu parsen, aber als repräsentative Bibliotheken werden argparse (Standardbibliothek), Click (externe Bibliothek) und Typer (mit Typ-Hinweisen) genannt.

Hier erklären wir die Merkmale und die grundlegende Verwendung jeder Bibliothek.

3.1 argparse: Implementierung mit der Standardbibliothek

argparse ist eine in Python standardmäßig enthaltene Bibliothek, die ohne zusätzliche Installation verwendet werden kann. Es ermöglicht die grundlegende Analyse von Argumenten und die automatische Generierung von Hilfetexten.

Hauptmerkmale von argparse

• Seit es die Standardbibliothek von Python ist, ist keine zusätzliche Installation erforderlich
• Pflichtargumente und optionale Argumente können einfach konfiguriert werden
• Hilfetext wird automatisch generiert

Beispiel zur Verwendung

Der folgende Code ist ein einfaches Skript, das mit argparse das optionale Argument --name annimmt und ausgibt.

import argparse

# Erstellen des ArgumentParser-Objekts
parser = argparse.ArgumentParser(description="Beispiel für Kommandozeilenargumente in Python")

# Hinzufügen der Kommandozeilenoption
parser.add_argument("--name", type=str, required=True, help="Geben Sie den Namen an")

# Parsen der Argumente
args = parser.parse_args()

# Anzeigen des Ergebnisses
print(f"Hallo, {args.name}!")

Beispiel zur Ausführung

python script.py --name Alice

Ausgabe

Hallo, Alice!

Auf diese Weise kann mit der standardmäßigen argparse von Python optionale Argumente einfach verarbeitet werden.

3.2 Click: Methode zur knapperen Beschreibung

Click ist eine Bibliothek, die mit Dekoratoren Kommandozeilenoptionen intuitiv beschreiben kann. Ähnliche Verarbeitung kann mit knapperem Code als argparse implementiert werden.

Installation von Click

Click ist eine externe Bibliothek, daher muss sie vorab installiert werden.

pip install click

Beispiel zur Verwendung

Das Folgende ist ein Beispiel zur Verarbeitung der --name-Option mit Click.

import click

@click.command()
@click.option("--name", prompt="Wie ist dein Name?", help="Geben Sie den Namen an")
def greet(name):
    click.echo(f"Hallo, {name}!")

if __name__ == "__main__":
    greet()

Beispiel zur Ausführung

python script.py

Ausgabe

Wie ist dein Name? Alice
Hallo, Alice!

Auf diese Weise kann mit Click auch Eingaben vom Benutzer über Prompts empfangen werden.

3.3 Typer: Intuitive Beschreibung mit Nutzung von Typ-Hinweisen

Typer ist eine auf Click basierende Bibliothek, deren Merkmal es ist, dass mit Python-Typ-Hinweisen intuitiver beschrieben werden kann.

Installation von Typer

Auch Typer ist eine externe Bibliothek und muss vorab installiert werden.

pip install typer

Beispiel zur Verwendung

Das Folgende ist ein Beispiel zur Verarbeitung der --name-Option mit Typer.

import typer

app = typer.Typer()

@app.command()
def greet(name: str):
    print(f"Hallo, {name}!")

if __name__ == "__main__":
    app()

Beispiel zur Ausführung

python script.py greet --name Alice

Ausgabe

Hallo, Alice!

Auf diese Weise kann mit Typer die Funktionsargumente direkt als Kommandozeilenoptionen behandelt werden, was zu intuitiverem Code führt.

Zusammenfassung

4. [Python] Verwendung von argparse

Die Standardbibliothek von Python, argparse, ist ein mächtiges Tool zur Analyse von Kommandozeilenoptionen. In diesem Abschnitt erklären wir detailliert die grundlegende bis zur fortgeschrittenen Verwendung von argparse.

4.1 Was ist argparse?

argparse ist eine in Python standardmäßig integrierte Bibliothek, mit der Sie Argumente bei der Skriptausführung einfach analysieren können. Es ist knapper und lesbarer als die direkte Verarbeitung von sys.argv und bietet Funktionen wie die automatische Generierung von Hilfetexten.

Features von argparse

• Standardbibliothek, daher keine zusätzliche Installation erforderlich
• Einfache Einstellung von optionalen und erforderlichen Argumenten
• Automatische Generierung von Hilfetexten
• Einfache Definition von Argumenten unterschiedlicher Datentypen

4.2 Grundlegende Verwendung

Zunächst betrachten wir die grundlegende Verwendung von argparse.

Beispiel für einfache Argumentanalyse

Im folgenden Code erstellen wir ein Skript, das das Kommandozeilenargument --name annimmt und seinen Wert anzeigt.

import argparse

# Erstellen des ArgumentParser-Objekts
parser = argparse.ArgumentParser(description="Beispiel für Kommandozeilenargumente in Python")

# Definition des Kommandozeilenarguments
parser.add_argument("--name", type=str, required=True, help="Geben Sie den Namen an")

# Parsen der Argumente
args = parser.parse_args()

# Ausgabe des Ergebnisses
print(f"Hallo, {args.name}!")

Ausführungsbeispiel

python script.py --name Alice

Ausgabe

Hallo, Alice!

Dieses Skript macht das Argument --name erforderlich, und wenn es nicht angegeben wird, tritt ein Fehler auf.

4.3 Erforderliche und optionale Argumente

Mit argparse können Sie zwei Arten von Argumenten definieren: erforderliche Argumente (Positionsargumente) und optionale Argumente.

Erforderliche Argumente (Positionsargumente)

Positionsargumente sind Argumente, die ohne spezifischen Optionsnamen übergeben werden.

parser.add_argument("name", type=str, help="Geben Sie den Namen an")

Ausführungsbeispiel

python script.py Alice

Ausgabe

Hallo, Alice!

Optionale Argumente

Optionale Argumente werden mit -- oder - vorangestellt übergeben und sind optional.

parser.add_argument("--age", type=int, help="Geben Sie das Alter an")

Ausführungsbeispiel

python script.py --age 25

Ausgabe

Alter: 25

4.4 Einstellung von Standardwerten

Es ist auch möglich, Standardwerte für den Fall zu setzen, dass ein Argument nicht angegeben wird.

parser.add_argument("--city", type=str, default="Berlin", help="Geben Sie die Stadt an")

Ausführungsbeispiel (ohne Argument)

python script.py

Ausgabe

Stadt: Berlin

4.5 Empfangen mehrerer Argumente

Durch Angabe von nargs="+" können mehrere Werte in Listenform empfangen werden.

parser.add_argument("--fruits", nargs="+", help="Geben Sie Ihre Lieblingsfrüchte an")

Ausführungsbeispiel

python script.py --fruits apple banana orange

Ausgabe

Lieblingsfrüchte: ['apple', 'banana', 'orange']

4.6 Flag-Optionen (True/False)

Mit store_true oder store_false können Flag-Optionen definiert werden.

parser.add_argument("--verbose", action="store_true", help="Detaillierte Informationen anzeigen")

Ausführungsbeispiel

python script.py --verbose

Ausgabe

Detaillierte Informationen werden angezeigt

4.7 Automatische Generierung von Hilfetexten

Mit argparse kann durch Angabe von -h oder --help der Hilfetext automatisch generiert werden.Ausführungsbeispiel

python script.py --help

Ausgabe

usage: script.py [-h] --name NAME

Beispiel für Kommandozeilenargumente in Python

optional arguments:
  -h, --help     show this help message and exit
  --name NAME    Geben Sie den Namen an

Zusammenfassung

5. [Python] Verwendung von Click

Die externe Python-Bibliothek Click ist ein mächtiges Tool, das es ermöglicht, Kommandozeilenoberflächen (CLI) einfacher und intuitiver als argparse zu erstellen. In diesem Abschnitt erklären wir detailliert von der grundlegenden Verwendung von Click bis hin zu Anwendungsbeispielen.

5.1 Was ist Click?

Click (Command Line Interface Creation Kit) ist eine Bibliothek zum einfachen Erstellen von CLI-Tools in Python. Im Vergleich zu argparse bietet sie eine dekoratorbasierte intuitive Syntax und ist geeignet zur Verwaltung mehrerer Subcommands.

Features von Click

• Einfache Syntax durch Verwendung von Dekoratoren
• Nested Subcommands können einfach erstellt werden
• Prompt-Funktion (Funktion zum Anfordern von Eingaben) standardmäßig integriert
• Automatische Generierung von Hilfetexten

Durch die Verwendung von Click können CLIs mit intuitiverem und kürzerem Code implementiert werden.

5.2 Installation von Click

Click ist keine Standardbibliothek, daher muss sie vorab installiert werden.

pip install click

5.3 Grundlegende Verwendung von Click

Lassen Sie uns eine einfache CLI-App mit Click erstellen. Der folgende Code ist ein Skript, das die --name-Option entgegennimmt und eine Begrüßung anzeigt.

Grundlegendes Click-Skript

import click

@click.command()
@click.option("--name", prompt="Wie ist dein Name?", help="Geben Sie den Namen an")
def greet(name):
    click.echo(f"Hallo, {name}!")

if __name__ == "__main__":
    greet()

Ausführungsbeispiel

python script.py

Ausgabe

Wie ist dein Name? Alice
Hallo, Alice!

Schlüsselpunkte

• @click.command(): Definiert eine Funktion als CLI-Befehl
• @click.option("--name", prompt="Wie ist dein Name?"): Definiert ein Optionsargument und fordert bei Fehlen per Prompt auf
• click.echo(): Sichere Verarbeitung der Standardausgabe

So kann mit Click eine CLI intuitiver als mit argparse erstellt werden.

5.4 Erforderliche Argumente und Optionsargumente

Click ermöglicht es, Positionalargumente (erforderliche Argumente) und Optionsargumente einfach zu definieren.

Definition von Positionalargumenten (erforderlichen Argumenten)

@click.command()
@click.argument("name")
def greet(name):
    click.echo(f"Hallo, {name}!")

if __name__ == "__main__":
    greet()

Ausführungsbeispiel

python script.py Alice

Ausgabe

Hallo, Alice!

Definition von Optionsargumenten

@click.command()
@click.option("--age", type=int, help="Geben Sie das Alter an")
def show_age(age):
    click.echo(f"Sie sind {age} Jahre alt.")

if __name__ == "__main__":
    show_age()

Ausführungsbeispiel

python script.py --age 25

Ausgabe

Sie sind 25 Jahre alt.

5.5 Flag-Optionen (True/False)

Click ermöglicht es, mit is_flag=True Flag-Optionen für boolesche Werte zu erstellen.

Definition einer Flag-Option

@click.command()
@click.option("--verbose", is_flag=True, help="Detaillierte Informationen anzeigen")
def run(verbose):
    if verbose:
        click.echo("Ausführung im Detailmodus...")
    else:
        click.echo("Ausführung im Normalmodus.")

if __name__ == "__main__":
    run()

Ausführungsbeispiel

python script.py --verbose

Ausgabe

Ausführung im Detailmodus...

5.6 CLI-App mit mehreren Optionen

Mit Click können CLI-Apps mit mehreren Optionen einfach erstellt werden.

Beispiel mit kombinierten Optionen

@click.command()
@click.option("--name", default="Gast", help="Geben Sie den Namen an")
@click.option("--count", default=1, type=int, help="Anzahl der Begrüßungen angeben")
def greet(name, count):
    for _ in range(count):
        click.echo(f"Hallo, {name}!")

if __name__ == "__main__":
    greet()

Ausführungsbeispiel

python script.py --name Alice --count 3

Ausgabe

Hallo, Alice!
Hallo, Alice!
Hallo, Alice!

5.7 Implementierung von Subcommands

Mit Click können CLI-Tools mit mehreren Befehlen erstellt werden.

CLI mit Subcommands

@click.group()
def cli():
    pass

@cli.command()
def hello():
    click.echo("Hallo!")

@cli.command()
def bye():
    click.echo("Auf Wiedersehen!")

if __name__ == "__main__":
    cli()

Ausführungsbeispiel

python script.py hello

Ausgabe

Hallo!

Mit @click.group() von Click können CLI-Apps mit mehreren Befehlen aufgebaut werden.

Zusammenfassung

Mit Click wird die Entwicklung von CLI-Tools in Python intuitiver als mit argparse. Insbesondere die Benutzerfreundlichkeit der Prompt-Funktion und Subcommands ist ein großer Vorteil von Click.

6. [Python] Verwendung von Typer

Die externe Python-Bibliothek Typer ist eine Bibliothek zum Erstellen von CLI-Tools, die auf Click basiert, und zeichnet sich dadurch aus, dass sie durch die Nutzung von Typ-Hinweisen intuitiver beschrieben werden kann. In diesem Abschnitt erklären wir detailliert von der grundlegenden Verwendung von Typer bis zu nützlichen Funktionen.

6.1 Was ist Typer?

Typer ist eine Bibliothek, die Typ-Hinweise (type hints) von Python nutzt, um CLI-Tools präziser und lesbarer zu erstellen. Da sie die starken Funktionen von Click erbt und gleichzeitig typsicheren Code ermöglicht, wird eine pythonischere CLI-Entwicklung möglich.

Merkmale von Typer

• Typ-Hinweise nutzen, um Argumente intuitiv zu definieren
• Auf Click basierend, ermöglicht den Bau leistungsstarker CLI-Tools
• IDE-Autovervollständigung wird benutzerfreundlicher
• Standardwerte und Validierungen einfach über Typ-Hinweise implementieren
• Bibliothek, die von den Entwicklern von FastAPI bereitgestellt wird

6.2 Installation von Typer

Da Typer eine externe Bibliothek ist, muss sie vorab installiert werden.

pip install typer

6.3 Grundlegende Verwendung von Typer

Mit Typer können CLI-Tools einfach unter Nutzung von Typ-Hinweisen erstellt werden. Der folgende Code ist ein Skript, das die --name-Option annimmt und eine Begrüßung anzeigt.

Grundlegendes Typer-Skript

import typer

app = typer.Typer()

@app.command()
def greet(name: str = "Gast"):
    print(f"Hallo, {name}!")

if __name__ == "__main__":
    app()

Ausführungsbeispiel

python script.py greet --name Alice

Ausgabe

Hallo, Alice!

Punkte

• app = typer.Typer(): Erstellt den Einstiegspunkt der Anwendung
• @app.command(): Registriert die Funktion als CLI-Befehl
• name: str = "Gast": Typ-Hinweise nutzen, um Standardwerte zu setzen
• print(): Typer verwendet intern click.echo(), daher ist print() sicher

6.4 Erforderliche Argumente und optionale Argumente

Mit Typer können erforderliche Argumente (Positionsargumente) und optionale Argumente einfach über Typ-Hinweise definiert werden.

Definition von erforderlichen Argumenten (Positionsargumenten)

@app.command()
def greet(name: str):
    print(f"Hallo, {name}!")

if __name__ == "__main__":
    app()

Ausführungsbeispiel

python script.py greet Alice

Ausgabe

Hallo, Alice!

Definition von optionalen Argumenten

@app.command()
def show_age(age: int = typer.Option(..., help="Bitte geben Sie das Alter an")):
    print(f"Ihr Alter beträgt {age} Jahre.")

if __name__ == "__main__":
    app()

Ausführungsbeispiel

python script.py show-age --age 25

Ausgabe

Ihr Alter beträgt 25 Jahre.

Bei optionalen Argumenten kann typer.Option(...) verwendet werden, und durch Hinzufügen von help="Beschreibung" wird die Hilfsnachricht automatisch generiert.

6.5 Flag-Optionen (True/False)

Mit Typer können Flag-Optionen für boolesche Werte durch Setzen von is_flag=True erstellt werden.

Definition einer Flag-Option

@app.command()
def run(verbose: bool = typer.Option(False, "--verbose", help="Detaillierte Informationen anzeigen")):
    if verbose:
        print("Ausführung im Detailmodus...")
    else:
        print("Ausführung im Normalmodus.")

if __name__ == "__main__":
    app()

Ausführungsbeispiel

python script.py run --verbose

Ausgabe

Ausführung im Detailmodus...

6.6 CLI-App mit mehreren Optionen

Mit Typer können CLI-Apps mit mehreren Optionen einfach erstellt werden.

Beispiel mit kombinierten mehreren Optionen

@app.command()
def greet(name: str = "Gast", count: int = 1):
    for _ in range(count):
        print(f"Hallo, {name}!")

if __name__ == "__main__":
    app()

Ausführungsbeispiel

python script.py greet --name Alice --count 3

Ausgabe

Hallo, Alice!
Hallo, Alice!
Hallo, Alice!

6.7 Implementierung von Subbefehlen

Mit Typer können CLI-Tools mit mehreren Befehlen erstellt werden.

CLI mit Subbefehlen

@app.command()
def hello():
    print("Hallo!")

@app.command()
def bye():
    print("Auf Wiedersehen!")

if __name__ == "__main__":
    app()

Ausführungsbeispiel

python script.py hello

Ausgabe

Hallo!

Mit Typer können mehrere Befehle einfach durch mehrfache Definition von @app.command() verwaltet werden.

Zusammenfassung

Mit Typer wird die Entwicklung von CLI-Tools in Python intuitiver als mit argparse oder Click. Besonders der Punkt, dass Beschreibungen mit Typ-Hinweisen möglich sind, ist ein großer Vorteil von Typer.

7. Welche Bibliothek sollte man wählen?

Als Methode zur Analyse von Kommandozeilenoptionen in Python haben wir drei vorgestellt: argparse, Click, Typer.
Jede Bibliothek hat ihre eigenen Merkmale, und die geeignete Wahl hängt vom zu verwendenden Projekt ab.

In diesem Abschnitt überprüfen wir die Merkmale jeder Bibliothek erneut und erläutern, welche Bibliothek man wählen sollte.

7.1 Vergleichstabelle von argparse・Click・Typer

7.2 Empfohlene Bibliotheken nach Anwendungszweck

✅ Für kleine Skripte: argparse

• Python-Standardbibliothek, daher keine zusätzliche Installation erforderlich
• Einfache CLI-Tools können schnell erstellt werden
• Optionen und Argumente können detailliert gesteuert werden
• Beispiel: Einfache Log-Analyse-Skripte, Batch-Verarbeitungstools

✅ Wenn man CLI-Tools intuitiv erstellen möchte: Click

• Verwendung von Dekoratoren für intuitive Beschreibung möglich
• Subcommands und Flag-Optionen können einfach hinzugefügt werden
• Prompt-Funktion (click.prompt()) ist standardmäßig integriert
• Beispiel: Anwendungen, die im Terminal laufen, Datenverarbeitungsskripte

✅ Für typsicheren und lesbaren Code: Typer

• Verwendung von Type Hints zur Verbesserung der IDE-Autovervollständigung
• Basiert auf Click und ermöglicht den einfachen Aufbau leistungsstarker CLIs
• Hohe Code-Lesbarkeit, die Funktionsdefinition wird direkt zur CLI-Spezifikation
• Beispiel: Tools für Datenanalyse, CLI für Machine-Learning-Modelle, CLI für API-Entwicklung

7.3 Auswahlkriterien für jede Bibliothek

7.4 Praktische Auswahlbeispiele für argparse・Click・Typer

7.5 Schlussfolgerung: Welche sollte man wählen?

Jede Bibliothek hat Vor- und Nachteile, und die angemessene Wahl je nach Anwendung ist wichtig.

Zusammenfassung

• argparse ist die Python-Standardbibliothek und eignet sich für kleine Skripte
• Click nutzt Dekoratoren für einfaches Schreiben und eignet sich für großskalige CLI-Tools
• Typer nutzt Type Hints für intuitive und typsichere CLI-Erstellung
• Es ist wichtig, die passende Bibliothek je nach Projektgröße und gewünschten Funktionen zu wählen

8. Häufig gestellte Fragen (FAQ)

Bibliotheken für Kommandozeilenoptionen in Python (argparse, Click, Typer) – hier haben wir häufig gestellte Fragen zusammengefasst. Dies ergänzt den bisherigen Inhalt und erklärt detailliert Punkte, die bei der tatsächlichen Nutzung verwirrend sein können.

8.1 Was ist der Unterschied zwischen argparse und optparse?

Q: Was ist der Unterschied zwischen argparse und optparse? Welche sollte man verwenden?A:

• optparse war eine Bibliothek, die in der Python-2-Ära verwendet wurde, und ab Python 3.2 ist sie veraltet.
• argparse ist der Nachfolger von optparse und ermöglicht flexiblere Optionenverarbeitung.
• Heutzutage wird die Verwendung von argparse empfohlen.

Beispiel:argparse ermöglicht es, Standardwerte, Subcommands und die Anpassung von Hilfetexten einfach zu handhaben.

import argparse

parser = argparse.ArgumentParser(description="Beispielskript")
parser.add_argument("--name", type=str, help="Geben Sie den Namen an")
args = parser.parse_args()
print(f"Hallo, {args.name}!")

8.2 Welche sollte man zwischen Click und Typer wählen?

Q: Welche sollte man zwischen Click und Typer wählen?A:

• Click ist ideal für die Entwicklung allgemeiner CLI-Tools und ermöglicht es, mit der eigenen Dekorator-Syntax von Click einfach CLI-Apps zu erstellen.
• Die Stärke von Typer ist, dass es auf Click basiert und Type Hints nutzen kann. Es eignet sich für Fälle, in denen man typsicheren Code schreiben oder die Autovervollständigung der IDE nutzen möchte.

8.3 Sollte man auch für kleine Skripte Click oder Typer verwenden?

Q: Sollte man auch für kleine Skripte Click oder Typer verwenden? Ist argparse unzureichend?A:

• Für einfache Skripte reicht argparse aus. Da es eine Standardbibliothek ist, ist keine zusätzliche Installation erforderlich und die Implementierung ist einfach.
• Allerdings, wenn die Optionen zunehmen und es komplexer wird, sollte man Click oder Typer in Betracht ziehen.

Auswahlkriterien

8.4 Wie erstellt man Subcommands mit argparse?

Q: Wie erstellt man Subcommands mit argparse, ähnlich wie bei git?A: Mit argparse kann man subparsers verwenden, um Subcommands zu erstellen.

Beispiel: Erstellung eines CLI-Tools ähnlich wie git

import argparse

parser = argparse.ArgumentParser(description="Beispiel für Subcommands")
subparsers = parser.add_subparsers(dest="command")

# hello-Befehl
hello_parser = subparsers.add_parser("hello", help="Begrüßung ausgeben")
hello_parser.add_argument("name", type=str, help="Geben Sie den Namen an")

# Ausführung
args = parser.parse_args()
if args.command == "hello":
    print(f"Hallo, {args.name}!")

Ausführungsbeispiel

python script.py hello Alice

Ausgabe

Hallo, Alice!

Wenn Subcommands häufig verwendet werden, ist Click intuitiver zu schreiben, wählen Sie daher je nach Situation.

8.5 Was sind die Vorteile der Verwendung von Typer?

Q: Was ist der größte Vorteil der Verwendung von Typer?A: Der größte Vorteil von Typer ist die Nutzung von Type Hints.

• Bei argparse oder Click muss der Typ der Optionen explizit angegeben werden, aber Typer kann die Python-Type-Hints direkt nutzen, wodurch der Code einfacher wird.
• Die Autovervollständigung der IDE wird verbessert und die Entwicklungs effizienz steigt.

Beispiel: Nutzung von Type Hints mit Typer

import typer

app = typer.Typer()

@app.command()
def greet(name: str):
    print(f"Hallo, {name}!")

if __name__ == "__main__":
    app()

In diesem Code wird durch die Angabe des Type Hints name: str die CLI-Option automatisch typgeprüft.

Zusammenfassung

• argparse ist eine Standardbibliothek und eignet sich für einfache CLI-Skripte.
• Click nutzt Dekoratoren, um den Code lesbarer zu machen, und eignet sich für große CLI-Tools.
• Typer nutzt Type Hints für eine lesbare CLI-Entwicklung.

Wählen Sie die passende Bibliothek und entwickeln Sie effizientere CLI-Tools!