Einführung

Python ist weithin für seine Vielseitigkeit und Benutzerfreundlichkeit bekannt, insbesondere beim Erstellen von Command-Line Interface (CLI)-Anwendungen. Ganz gleich, ob Sie alltägliche Aufgaben automatisieren, Entwicklertools erstellen oder flexible Skripte erstellen möchten, das umfangreiche Ökosystem von Python bietet verschiedene Bibliotheken für die effiziente Handhabung von CLI.

In diesem Blogbeitrag werden wir uns eingehend mit der Arbeit mit CLIs in Python befassen und dabei Folgendes behandeln:

• Warum eine CLI erstellen?
• Python-Module zum Erstellen von CLIs
• Die Grundlagen von Befehlszeilenargumenten
• Erweiterte Funktionen mit argparse
• CLI-Tools per Klick erstellen
• Fehlerbehandlung in CLI-Tools
• CLI-Tools für die Verteilung packen

Am Ende dieses Beitrags sind Sie in der Lage, robuste und benutzerfreundliche Befehlszeilenanwendungen zu erstellen.

Warum eine CLI erstellen?

CLIs werden häufig in der Systemadministration, Datenverarbeitung und Softwareentwicklung verwendet, weil sie Folgendes bieten:

1. Automatisierung: Erstellen Sie Skripts für sich wiederholende Aufgaben, um Zeit zu sparen und Fehler zu reduzieren.
2. Einfachheit: Führen Sie komplexe Befehle mit wenigen Tastendrücken aus.
3. Portabilität: Ein gut entwickeltes CLI-Tool kann auf jedem Computer ohne GUI verwendet werden.
4. Entwicklertools: Viele Entwicklungstools (wie Git, Npm und Pip) sind CLI-basiert.

Python-Module für die CLI-Entwicklung

Python bietet mehrere Bibliotheken zum Erstellen von CLI-Tools:

1. sys.argv: Direkter Zugriff auf Befehlszeilenargumente, geeignet für kleine, einfache Skripte.
2. argparse: Integriertes Modul zur Verarbeitung von Befehlszeilenargumenten mit automatischer Hilfegenerierung.
3. click: Eine leistungsstarke und flexible Bibliothek zum Erstellen komplexer CLI-Anwendungen.
4. typer: Eine moderne, auf Click basierende Bibliothek, die Python-Typhinweise zur Benutzerfreundlichkeit verwendet.

Arbeiten mit sys.argv

sys.argv ist eine grundlegende Möglichkeit, auf Befehlszeilenargumente zuzugreifen. Es speichert die Befehlszeilenargumente als Liste, wobei das erste Element immer der Skriptname ist.

import sys

# Command-line arguments
print(f"Script Name: {sys.argv[0]}")
print(f"Arguments: {sys.argv[1:]}")

Das Skript wird ausgeführt:

$ python script.py arg1 arg2 arg3
Script Name: script.py
Arguments: ['arg1', 'arg2', 'arg3']

Einschränkungen von sys.argv:

• Keine Typprüfung: Alle Eingaben werden als Strings behandelt.
• Keine integrierte Hilfemeldung: Sie müssen Eingaben manuell validieren und Nutzungsinformationen anzeigen.

CLIs mit argparse erstellen

Das argparse-Modul ist Pythons Standardbibliothek zum Erstellen von CLIs. Es bietet mehr Kontrolle als sys.argv und generiert automatisch Hilfemeldungen und Fehlerbehandlung.

Grundlegendes Beispiel:

import argparse

parser = argparse.ArgumentParser(description="A simple CLI tool")
parser.add_argument("name", help="Your name")
parser.add_argument("--greet", help="Custom greeting", default="Hello")

args = parser.parse_args()

print(f"{args.greet}, {args.name}!")

Das Skript wird ausgeführt:

$ python script.py Alice
Hello, Alice!

$ python script.py Alice --greet Hi
Hi, Alice!

Hauptfunktionen von argparse:

1. Positions- und optionale Argumente: Definieren Sie einfach erforderliche und optionale Parameter.
2. Typprüfung: Stellen Sie sicher, dass der Benutzer den richtigen Datentyp angibt.
3. Auswahlmöglichkeiten: Beschränken Sie Eingaben mithilfe des Auswahlparameters auf bestimmte Werte.
4. Hilfemeldungen: Generieren Sie automatisch Hilfe mit dem Flag -h oder --help.

Beispiel mit Typprüfung und Auswahlmöglichkeiten:

parser.add_argument("age", type=int, help="Your age")
parser.add_argument("--format", choices=["json", "xml"], help="Output format")

Das Skript wird ausgeführt:

$ python script.py Alice 30 --format json

Erweiterte CLI-Tools mit Klick

click ist eine erweiterte Bibliothek zum Erstellen von Befehlszeilenschnittstellen. Es bietet einen auf Dekoratoren basierenden Ansatz zum Definieren von Befehlen, Unterbefehlen und Optionen.

Warum Click verwenden?

• Bessere Lesbarkeit: Eine pythonischere, auf Dekoratoren basierende Syntax.
• Automatische Argumentvalidierung: Stellt sicher, dass Argumente ordnungsgemäß validiert werden.
• Wiederverwendbare Komponenten: Befehle, Optionen und Argumente können problemlos in verschiedenen Teilen Ihrer Anwendung wiederverwendet werden.

Grundlegendes Beispiel für die Verwendung von click:

import click

@click.command()
@click.option('--name', prompt='Your name', help='The person to greet.')
@click.option('--greet', default="Hello", help='Greeting to use.')
def greet(name, greet):
    """Simple program that greets NAME with a GREET."""
    click.echo(f'{greet}, {name}!')

if __name__ == '__main__':
    greet()

Das Skript wird ausgeführt:

$ python greet.py --name Alice --greet Hi
Hi, Alice!

Unterbefehle mit Klick:

Sie können komplexere CLI-Tools mit mehreren Unterbefehlen erstellen.

import click

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

@cli.command()
def start():
    click.echo("Starting the application...")

@cli.command()
def stop():
    click.echo("Stopping the application...")

if __name__ == '__main__':
    cli()

Das Skript wird ausgeführt:

$ python app.py start
Starting the application...

$ python app.py stop
Stopping the application...

Fehlerbehandlung in CLI-Tools

Unabhängig davon, welche Bibliothek Sie verwenden, ist die Fehlerbehandlung für eine reibungslose Benutzererfahrung von entscheidender Bedeutung.

Beispiel in argparse:

Wenn ein erforderliches Argument fehlt, gibt argparse einen Fehler aus und zeigt Verwendungsanweisungen an:

$ python script.py
usage: script.py [-h] name
script.py: error: the following arguments are required: name

Fehlerbehandlung im Klick:

In Click können Sie benutzerdefinierte Ausnahmen auslösen und Fehler mithilfe von Dekoratoren elegant behandeln.

@click.command()
@click.option('--count', type=int, help='Number of repetitions')
def repeat(count):
    if count is None or count 





  
  
  Argparse und Click mit anderen Bibliotheken kombinieren


Um die CLI-Funktionalität zu erweitern, können Sie argparse oder click mit anderen Bibliotheken wie Betriebssystemen, Unterprozessen oder sogar benutzerdefinierten Bibliotheken kombinieren.


  
  
  Beispiel: Kombination von argparse mit os




import os
import argparse

parser = argparse.ArgumentParser(description="File operations CLI")
parser.add_argument("filename", help="Name of the file to check")
parser.add_argument("--create", action="store_true", help="Create the file if it does not exist")

args = parser.parse_args()

if os.path.exists(args.filename):
    print(f"{args.filename} already exists.")
else:
    if args.create:
        with open(args.filename, 'w') as f:
            f.write("New file created.")
        print(f"{args.filename} created.")
    else:
        print(f"{args.filename} does not exist.")




Das Skript wird ausgeführt:


$ python filecli.py example.txt --create
example.txt created.






  
  
  Verpacken Ihres CLI-Tools


Um Ihr CLI-Tool zu verteilen, können Sie es mit setuptools paketieren und global auf jedem System zugänglich machen.


  
  
  Schritt 1: Erstellen Sie eine setup.py-Datei




from setuptools import setup

setup(
    name='greet-cli',
    version='0.1',
    py_modules=['greet'],
    install_requires=[
        'click',
    ],
    entry_points='''
        [console_scripts]
        greet=greet:greet
    ''',
)





  
  
  Schritt 2: Installieren Sie Ihre CLI lokal




$ pip install --editable .




Jetzt ist der Greet-Befehl global verfügbar:


$ greet --name Alice
Hello, Alice!





  
  
  Auf PyPI verteilen


Um Ihr Tool öffentlich zu verteilen, erstellen Sie ein PyPI-Konto und befolgen Sie die Schritte zum Hochladen Ihres Pakets:

Erstellen Sie das Paket:

   python setup.py sdist bdist_wheel




Laden Sie das Paket hoch:

   twine upload dist/*






  
  
  Best Practices für die Erstellung von CLIs



Stellen Sie klare Hilfemeldungen bereit: Fügen Sie immer --help ein, um Benutzer anzuleiten.

Eingaben validieren: Typprüfung verwenden und Ausnahmen ordnungsgemäß behandeln.

Entwerfen Sie intuitive Befehle: Stellen Sie sicher, dass Ihre Befehlsstruktur logisch und einfach zu verwenden ist.

Testen mit Randfällen: Stellen Sie sicher, dass sich Ihr CLI-Tool auch bei ungültigen Eingaben korrekt verhält.

Modularisieren Sie Ihren Code: Halten Sie Ihre Befehlszeilenlogik von Ihrer Kernfunktionalität getrennt, um Tests und Wartung zu erleichtern.

  
  
  Abschluss


Python bietet ein hervorragendes Toolkit zum Erstellen von Command-Line Interface (CLI)-Anwendungen. Unabhängig davon, ob Sie das integrierte argparse-Modul oder das funktionsreichere Click verwenden, können Sie leistungsstarke, benutzerfreundliche Tools erstellen, die Arbeitsabläufe automatisieren, Daten verarbeiten und die Produktivität steigern können.

Da Sie nun die Grundlagen und erweiterten Funktionen der Arbeit mit CLI in Python kennengelernt haben, ist es an der Zeit, sie in die Praxis umzusetzen. Erstellen Sie Ihr eigenes Tool, teilen Sie es oder vertreiben Sie es sogar weltweit!


Bei Fragen oder Vorschlägen können Sie sich gerne an uns wenden:

• LinkedIn
• GitHub