Mehrere argparse-Argumente hinzufügen: Python-Tutorial

Einführung

Dieses Tutorial untersucht, wie man in Python mit dem Modul argparse mehrere Kommandozeilenargumente hinzufügt und verwaltet. Kommandozeilenargumente ermöglichen es Benutzern, die Ausführung von Programmen anzupassen, ohne den Code selbst zu modifizieren. Das Modul argparse vereinfacht diesen Prozess, indem es Werkzeuge zur Definition, Validierung und zum Parsen dieser Argumente bereitstellt.

Am Ende dieses Tutorials werden Sie verstehen, wie man Python-Skripte erstellt, die verschiedene Eingabeparameter akzeptieren können, wodurch Ihre Anwendungen flexibler und benutzerfreundlicher werden.

Grundlagen von Argparse verstehen

Der erste Schritt bei der Arbeit mit Kommandozeilenargumenten ist das Verständnis der Grundlagen des argparse-Moduls.

Was ist Argparse?

Argparse ist ein integriertes Python-Modul, das es einfach macht, benutzerfreundliche Kommandozeilenschnittstellen zu schreiben. Es generiert automatisch Hilfemeldungen, behandelt Fehler und konvertiert Kommandozeilenargumente in die entsprechenden Datentypen für Ihr Programm.

Erstellen Ihres ersten Skripts mit Argparse

Beginnen wir mit der Erstellung eines einfachen Python-Skripts, das argparse verwendet. Wir erstellen eine Datei namens hello.py, die einen Namen als Kommandozeilenargument akzeptiert.

Öffnen Sie den VSCode-Editor und erstellen Sie eine neue Datei, indem Sie auf "File" > "New File" klicken.
Speichern Sie die Datei als hello.py im Verzeichnis /home/labex/project.
Fügen Sie der Datei den folgenden Code hinzu:

import argparse

## Create the parser
parser = argparse.ArgumentParser(description='A simple greeting program')

## Add an argument
parser.add_argument('--name', type=str, default='World', help='Name to greet')

## Parse the arguments
args = parser.parse_args()

## Use the argument
print(f"Hello, {args.name}!")

Dieses Skript demonstriert die drei Hauptschritte zur Verwendung von argparse:

Erstellen eines ArgumentParser-Objekts
Hinzufügen von Argumenten zum Parser
Parsen der Kommandozeilenargumente

Ausführen Ihres Skripts

Lassen Sie uns das Skript ausführen, um zu sehen, wie es funktioniert:

Öffnen Sie ein Terminal in der VSCode-Oberfläche (Terminal > New Terminal).
Führen Sie das Skript mit dem folgenden Befehl aus:

python3 hello.py

Sie sollten diese Ausgabe sehen:

Hello, World!

Versuchen wir nun, einen Namen zu übergeben:

python3 hello.py --name Alice

Ausgabe:

Hello, Alice!

Hilfemeldungen verstehen

Einer der Vorteile von argparse ist, dass es automatisch Hilfemeldungen generiert. Versuchen Sie, Folgendes auszuführen:

python3 hello.py --help

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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

A simple greeting program

options:
  -h, --help   show this help message and exit
  --name NAME  Name to greet

Diese Hilfemeldung wird automatisch basierend auf der Beschreibung generiert, die wir beim Erstellen des Parsers angegeben haben, und dem Hilfetext, den wir unserem Argument hinzugefügt haben.

Schlüsselkomponenten von Argparse

Betrachten wir die Hauptkomponenten in unserem Skript:

parser = argparse.ArgumentParser(description='...'): Erstellt einen Parser mit einer Beschreibung.
parser.add_argument('--name', ...): Fügt ein Argument mit dem Namen '--name' hinzu.
type=str: Gibt an, dass das Argument ein String sein soll.
default='World': Legt einen Standardwert fest, wenn das Argument nicht angegeben wird.
help='Name to greet': Stellt Hilfetext für das Argument bereit.
args = parser.parse_args(): Parst die Kommandozeilenargumente.
args.name: Greift auf den Wert des Arguments 'name' zu.

Nun verstehen Sie die Grundlagen der Verwendung von argparse zur Handhabung von Kommandozeilenargumenten in Python.

Hinzufügen mehrerer Argumenttypen

Nachdem Sie die Grundlagen verstanden haben, wollen wir uns verschiedene Argumenttypen ansehen, die Ihrer Kommandozeilenschnittstelle hinzugefügt werden können.

Arten von Argumenten

Argparse unterstützt verschiedene Arten von Argumenten:

Positionsargumente (Positional arguments): Erforderliche Argumente, die durch ihre Position identifiziert werden.
Optionale Argumente (Optional arguments): Argumente mit dem Präfix -- (oder -), die Standardwerte haben können.
Flag-Argumente (Flag arguments): Boolesche Argumente, die entweder vorhanden oder abwesend sind.
Argumente mit Auswahlmöglichkeiten (Arguments with choices): Argumente, die auf bestimmte Werte beschränkt sind.

Lassen Sie uns ein neues Skript erstellen, das diese verschiedenen Argumenttypen demonstriert.

Erstellen Sie eine neue Datei namens calculator.py im Verzeichnis /home/labex/project.
Fügen Sie den folgenden Code hinzu:

import argparse

## Create the parser
parser = argparse.ArgumentParser(description='A simple calculator')

## Add a positional argument
parser.add_argument('operation',
                    choices=['add', 'subtract', 'multiply', 'divide'],
                    help='Math operation to perform')

## Add optional arguments
parser.add_argument('--num1', type=float, required=True,
                    help='First number')
parser.add_argument('--num2', type=float, required=True,
                    help='Second number')

## Add a flag argument
parser.add_argument('--verbose', action='store_true',
                    help='Enable verbose output')

## Parse the arguments
args = parser.parse_args()

## Perform the calculation based on the operation
result = 0
if args.operation == 'add':
    result = args.num1 + args.num2
elif args.operation == 'subtract':
    result = args.num1 - args.num2
elif args.operation == 'multiply':
    result = args.num1 * args.num2
elif args.operation == 'divide':
    if args.num2 == 0:
        print("Error: Cannot divide by zero")
        exit(1)
    result = args.num1 / args.num2

## Display the result
if args.verbose:
    print(f"The result of {args.num1} {args.operation} {args.num2} is: {result}")
else:
    print(f"Result: {result}")

Die neuen Argumente verstehen

Betrachten wir die neuen Argumenttypen in diesem Skript:

Positionsargument (Positional argument): operation - muss eines von 'add', 'subtract', 'multiply' oder 'divide' sein

parser.add_argument('operation',
                    choices=['add', 'subtract', 'multiply', 'divide'],
                    help='Math operation to perform')

Optionale Argumente mit required=True: --num1 und --num2 - müssen vom Benutzer angegeben werden

parser.add_argument('--num1', type=float, required=True,
                    help='First number')

Flag-Argument (Flag argument): --verbose - aktiviert bei Vorhandensein eine ausführliche Ausgabe

parser.add_argument('--verbose', action='store_true',
                    help='Enable verbose output')

Testen des Rechners

Führen Sie den Rechner mit verschiedenen Argumenten aus, um zu sehen, wie er funktioniert:

python3 calculator.py add --num1 5 --num2 3

Ausgabe:

Result: 8.0

Versuchen Sie es mit dem verbose-Flag:

python3 calculator.py multiply --num1 4 --num2 7 --verbose

Ausgabe:

The result of 4.0 multiply 7.0 is: 28.0

Versuchen Sie die Divisionsoperation:

python3 calculator.py divide --num1 10 --num2 2

Ausgabe:

Result: 5.0

Wenn Sie ein erforderliches Argument vergessen, zeigt argparse einen Fehler an:

python3 calculator.py add --num1 5

Ausgabe:

usage: calculator.py [-h] [--num1 NUM1] [--num2 NUM2] [--verbose]
                    {add,subtract,multiply,divide}
calculator.py: error: the following arguments are required: --num2

Wichtige Punkte zu Argumenttypen

Positionsargumente (Positional arguments) benötigen kein Präfix und werden durch ihre Position identifiziert.
Der Parameter choices schränkt die gültigen Werte für ein Argument ein.
Der Parameter required=True macht ein optionales Argument obligatorisch.
Der Parameter action='store_true' erstellt ein Flag, das standardmäßig False ist und True, wenn es angegeben wird.
Der Parameter type konvertiert die Eingabe in den angegebenen Typ (float in unserem Beispiel).

Nun verstehen Sie, wie Sie verschiedene Arten von Argumenten mit argparse verwenden können.

Erweiterte Argumentkonfigurationen

Lassen Sie uns nun fortgeschrittenere Konfigurationen für Argumente untersuchen, einschließlich:

Argumente, die mehrere Werte akzeptieren
Argumente mit benutzerdefinierter Validierung
Argumente mit Standardwerten
Argumente mit Kurznamen (einbuchstabige Aliase)

Erstellen eines Skripts zur Dateiverarbeitung

Erstellen wir ein Skript, das diese erweiterten Konfigurationen demonstriert, indem wir ein Dienstprogramm zur Dateiverarbeitung erstellen.

Erstellen Sie eine neue Datei namens file_processor.py im Verzeichnis /home/labex/project.
Fügen Sie den folgenden Code hinzu:

import argparse
import os

def validate_file(filename):
    """Validate that the file exists."""
    if not os.path.exists(filename):
        raise argparse.ArgumentTypeError(f"File {filename} does not exist")
    return filename

## Create the parser
parser = argparse.ArgumentParser(description='Process text files')

## Multiple values
parser.add_argument('-f', '--files',
                    type=validate_file,
                    nargs='+',
                    help='Input files to process')

## Argument with short name
parser.add_argument('-o', '--output',
                    default='output.txt',
                    help='Output file (default: output.txt)')

## Choices with default
parser.add_argument('-m', '--mode',
                    choices=['read', 'count', 'stats'],
                    default='read',
                    help='Processing mode (default: read)')

## Custom validation for a positive integer
def positive_int(value):
    ivalue = int(value)
    if ivalue <= 0:
        raise argparse.ArgumentTypeError(f"{value} is not a positive integer")
    return ivalue

parser.add_argument('-l', '--lines',
                    type=positive_int,
                    default=10,
                    help='Number of lines to process (default: 10)')

## Parse arguments
args = parser.parse_args()

## Process files based on mode
for file in args.files if args.files else []:
    print(f"Processing file: {file}")

    with open(file, 'r') as f:
        content = f.readlines()

        if args.mode == 'read':
            ## Read mode: output first N lines
            print(f"First {args.lines} lines:")
            for i, line in enumerate(content[:args.lines]):
                print(f"{i+1}: {line.strip()}")

        elif args.mode == 'count':
            ## Count mode: count lines, words, chars
            line_count = len(content)
            word_count = sum(len(line.split()) for line in content)
            char_count = sum(len(line) for line in content)

            print(f"Lines: {line_count}")
            print(f"Words: {word_count}")
            print(f"Characters: {char_count}")

        elif args.mode == 'stats':
            ## Stats mode: line length statistics
            if content:
                line_lengths = [len(line.strip()) for line in content]
                avg_length = sum(line_lengths) / len(line_lengths)
                max_length = max(line_lengths)
                min_length = min(line_lengths)

                print(f"Average line length: {avg_length:.2f}")
                print(f"Shortest line: {min_length} characters")
                print(f"Longest line: {max_length} characters")
            else:
                print("File is empty")

    print("-" * 30)

print(f"Results will be saved to: {args.output}")
## Note: In a real application, we would actually write to the output file

Die erweiterten Konfigurationen verstehen

Betrachten wir die erweiterten Argumentkonfigurationen:

Mehrere Werte mit nargs='+':

parser.add_argument('-f', '--files',
                    type=validate_file,
                    nargs='+',
                    help='Input files to process')

Der Parameter nargs='+' ermöglicht es dem Benutzer, ein oder mehrere Dateiarumente anzugeben.

Benutzerdefinierte Validierungsfunktion:

def validate_file(filename):
    if not os.path.exists(filename):
        raise argparse.ArgumentTypeError(f"File {filename} does not exist")
    return filename

Diese Funktion prüft, ob die angegebene Datei existiert, bevor fortgefahren wird.

Kurzaliase mit -o:

parser.add_argument('-o', '--output',
                    default='output.txt',
                    help='Output file (default: output.txt)')

Das -o bietet eine kürzere Möglichkeit, das Argument --output anzugeben.

Auswahlmöglichkeiten mit Standardwert:

parser.add_argument('-m', '--mode',
                    choices=['read', 'count', 'stats'],
                    default='read',
                    help='Processing mode (default: read)')

Dies beschränkt den Modus auf bestimmte Werte und stellt gleichzeitig einen Standardwert bereit.

Erstellen von Beispieldateien

Erstellen wir zwei Beispieldateien, um unser Skript zu testen:

Erstellen Sie eine Beispieldatei namens sample1.txt:

echo -e "This is the first line.\nThis is the second line.\nThis is the third line.\nThis is the fourth line.\nThis is the fifth line." > /home/labex/project/sample1.txt

Erstellen Sie eine weitere Beispieldatei namens sample2.txt:

echo -e "Lorem ipsum dolor sit amet.\nConsectetur adipiscing elit.\nSed do eiusmod tempor incididunt.\nUt labore et dolore magna aliqua." > /home/labex/project/sample2.txt

Testen des Dateiprozessors

Führen wir nun das Skript mit verschiedenen Argumenten aus:

Grundlegende Verwendung mit einer Datei:

python3 file_processor.py -f sample1.txt

Ausgabe:

Processing file: sample1.txt
First 10 lines:
1: This is the first line.
2: This is the second line.
3: This is the third line.
4: This is the fourth line.
5: This is the fifth line.
------------------------------
Results will be saved to: output.txt

Verarbeiten mehrerer Dateien:

python3 file_processor.py -f sample1.txt sample2.txt

Ausgabe:

Processing file: sample1.txt
First 10 lines:
1: This is the first line.
2: This is the second line.
3: This is the third line.
4: This is the fourth line.
5: This is the fifth line.
------------------------------
Processing file: sample2.txt
First 10 lines:
1: Lorem ipsum dolor sit amet.
2: Consectetur adipiscing elit.
3: Sed do eiusmod tempor incididunt.
4: Ut labore et dolore magna aliqua.
------------------------------
Results will be saved to: output.txt

Verwenden des Zählmodus:

python3 file_processor.py -f sample1.txt -m count

Ausgabe:

Processing file: sample1.txt
Lines: 5
Words: 25
Characters: 135
------------------------------
Results will be saved to: output.txt

Verwenden des Statistikmodus:

python3 file_processor.py -f sample2.txt -m stats

Ausgabe:

Processing file: sample2.txt
Average line length: 29.25
Shortest line: 22 characters
Longest line: 37 characters
------------------------------
Results will be saved to: output.txt

Begrenzen der Anzahl der Zeilen:

python3 file_processor.py -f sample1.txt -l 2

Ausgabe:

Processing file: sample1.txt
First 2 lines:
1: This is the first line.
2: This is the second line.
------------------------------
Results will be saved to: output.txt

Wichtige Punkte zu erweiterten Konfigurationen

nargs='+' ermöglicht mehrere Argumentwerte.
Benutzerdefinierte Validierungsfunktionen helfen, gültige Eingaben sicherzustellen.
Kurze Argumentnamen (einbuchstabige Aliase) bieten Komfort.
Standardwerte vereinfachen die Verwendung für gängige Szenarien.
Der Parameter choices beschränkt die Eingabe auf gültige Optionen.

Nun haben Sie gelernt, wie Sie erweiterte Argumentoptionen in Ihren Kommandozeilenskripten konfigurieren können.

Erstellen eines vollständigen Kommandozeilen-Tools

In diesem Schritt kombinieren wir alles, was wir gelernt haben, um ein vollständiges Kommandozeilen-Tool zu erstellen. Erstellen wir einen einfachen Task-Manager, mit dem Benutzer Aufgaben mithilfe von Kommandozeilenargumenten hinzufügen, auflisten und löschen können.

Erstellen des Task-Managers

Erstellen Sie eine neue Datei namens task_manager.py im Verzeichnis /home/labex/project.
Fügen Sie den folgenden Code hinzu:

import argparse
import json
import os

## File to store tasks
TASKS_FILE = "/home/labex/project/tasks.json"

def load_tasks():
    """Load tasks from the JSON file."""
    if os.path.exists(TASKS_FILE):
        with open(TASKS_FILE, 'r') as f:
            try:
                return json.load(f)
            except json.JSONDecodeError:
                return []
    return []

def save_tasks(tasks):
    """Save tasks to the JSON file."""
    with open(TASKS_FILE, 'w') as f:
        json.dump(tasks, f, indent=2)

def main():
    ## Create the main parser
    parser = argparse.ArgumentParser(description='Task Manager CLI')
    subparsers = parser.add_subparsers(dest='command', help='Command to run')

    ## Add command
    add_parser = subparsers.add_parser('add', help='Add a new task')
    add_parser.add_argument('title', help='Task title')
    add_parser.add_argument('-p', '--priority',
                          choices=['low', 'medium', 'high'],
                          default='medium',
                          help='Task priority (default: medium)')
    add_parser.add_argument('-d', '--due',
                          help='Due date (format: YYYY-MM-DD)')

    ## List command
    list_parser = subparsers.add_parser('list', help='List all tasks')
    list_parser.add_argument('-p', '--priority',
                           choices=['low', 'medium', 'high'],
                           help='Filter tasks by priority')
    list_parser.add_argument('-s', '--sort',
                           choices=['priority', 'title'],
                           default='priority',
                           help='Sort tasks by criteria (default: priority)')

    ## Delete command
    delete_parser = subparsers.add_parser('delete', help='Delete a task')
    delete_parser.add_argument('task_id', type=int, help='Task ID to delete')

    ## Parse arguments
    args = parser.parse_args()

    ## Load existing tasks
    tasks = load_tasks()

    ## Handle commands
    if args.command == 'add':
        ## Add a new task
        new_task = {
            'id': len(tasks) + 1,
            'title': args.title,
            'priority': args.priority,
            'due': args.due
        }
        tasks.append(new_task)
        save_tasks(tasks)
        print(f"Task added: {new_task['title']} (ID: {new_task['id']})")

    elif args.command == 'list':
        ## List tasks
        if not tasks:
            print("No tasks found.")
            return

        ## Filter by priority if specified
        if args.priority:
            filtered_tasks = [t for t in tasks if t['priority'] == args.priority]
        else:
            filtered_tasks = tasks

        ## Sort tasks
        if args.sort == 'priority':
            ## Custom priority sorting
            priority_order = {'high': 0, 'medium': 1, 'low': 2}
            sorted_tasks = sorted(filtered_tasks, key=lambda x: priority_order[x['priority']])
        else:
            ## Sort by title
            sorted_tasks = sorted(filtered_tasks, key=lambda x: x['title'])

        ## Display tasks
        print("ID | Title                 | Priority | Due Date")
        print("-" * 50)
        for task in sorted_tasks:
            due_date = task['due'] if task['due'] else 'N/A'
            print(f"{task['id']:2} | {task['title'][:20]:<20} | {task['priority']:<8} | {due_date}")

    elif args.command == 'delete':
        ## Delete a task
        task_id = args.task_id
        task_found = False

        for i, task in enumerate(tasks):
            if task['id'] == task_id:
                del tasks[i]
                task_found = True
                break

        if task_found:
            save_tasks(tasks)
            print(f"Task {task_id} deleted.")
        else:
            print(f"Task {task_id} not found.")

    else:
        ## No command specified
        parser.print_help()

if __name__ == "__main__":
    main()

Den Task-Manager verstehen

Dieses Skript demonstriert mehrere erweiterte Funktionen von argparse:

Subparser (Subparsers) - Erstellen von befehlsspezifischen Argumentsätzen
Befehlsspezifische Argumente (Command-specific arguments) - Verschiedene Argumente für die Befehle add, list und delete
Verschachtelte Validierung (Nested validation) - Prioritätsauswahlen sind auf bestimmte Werte beschränkt
Standardwerte (Default values) - Bereitstellung sinnvoller Standardwerte für optionale Argumente

Testen des Task-Managers

Führen wir das Skript mit verschiedenen Befehlen aus, um zu sehen, wie es funktioniert:

Hinzufügen von Aufgaben:

python3 task_manager.py add "Complete Python tutorial" -p high -d 2023-12-31

Ausgabe:

Task added: Complete Python tutorial (ID: 1)

Fügen Sie ein paar weitere Aufgaben hinzu:

python3 task_manager.py add "Read documentation" -p medium

python3 task_manager.py add "Take a break" -p low -d 2023-12-25

Auflisten von Aufgaben:

python3 task_manager.py list

Ausgabe:

ID | Title                 | Priority | Due Date
--------------------------------------------------
1  | Complete Python tutor | high     | 2023-12-31
2  | Read documentation    | medium   | N/A
3  | Take a break          | low      | 2023-12-25

Auflisten von Aufgaben mit Filtern und Sortierung:

python3 task_manager.py list -s title

Ausgabe:

ID | Title                 | Priority | Due Date
--------------------------------------------------
1  | Complete Python tutor | high     | 2023-12-31
2  | Read documentation    | medium   | N/A
3  | Take a break          | low      | 2023-12-25

Filtern nach Priorität:

python3 task_manager.py list -p high

Ausgabe:

ID | Title                 | Priority | Due Date
--------------------------------------------------
1  | Complete Python tutor | high     | 2023-12-31

Löschen einer Aufgabe:

python3 task_manager.py delete 2

Ausgabe:

Task 2 deleted.

Überprüfen Sie, ob die Aufgabe gelöscht wurde:

python3 task_manager.py list

Ausgabe:

ID | Title                 | Priority | Due Date
--------------------------------------------------
1  | Complete Python tutor | high     | 2023-12-31
3  | Take a break          | low      | 2023-12-25

Hilfe für Unterbefehle abrufen

Argparse generiert automatisch Hilfe für jeden Unterbefehl:

python3 task_manager.py add --help

Ausgabe:

usage: task_manager.py add [-h] [-p {low,medium,high}] [-d DUE] title

positional arguments:
  title                 Task title

options:
  -h, --help            show this help message and exit
  -p {low,medium,high}, --priority {low,medium,high}
                        Task priority (default: medium)
  -d DUE, --due DUE     Due date (format: YYYY-MM-DD)

Wichtige Punkte zu Subparsers

Subparser erstellen befehlsspezifische Argumentsätze.
Jeder Subparser kann seine eigenen Argumente haben.
Der Parameter dest gibt an, wo der Befehlsname gespeichert wird.
Hilfemeldungen werden automatisch für jeden Unterbefehl generiert.
Sie können Positions- und optionale Argumente in Subparsers mischen.

Sie haben jetzt ein voll funktionsfähiges Kommandozeilen-Tool, das die Leistungsfähigkeit und Flexibilität von argparse für die Handhabung komplexer Argumentszenarien demonstriert.

Zusammenfassung

In diesem Tutorial haben Sie gelernt, wie Sie das Python-Modul argparse verwenden, um Kommandozeilenargumente effektiv zu verarbeiten. Sie haben Folgendes untersucht:

Grundlegende argparse-Funktionalität und Erstellen einfacher Skripte
Verschiedene Arten von Argumenten: positionsgebunden, optional, Flags und Auswahlmöglichkeiten
Erweiterte Argumentkonfigurationen wie mehrere Werte und benutzerdefinierte Validierung
Erstellen eines vollständigen Kommandozeilen-Tools mit Unterbefehlen

Mit diesen Fähigkeiten können Sie flexiblere und benutzerfreundlichere Python-Anwendungen erstellen, die über Kommandozeilenargumente konfiguriert werden können, ohne den Code zu ändern.

Das Parsen von Kommandozeilenargumenten ist eine wesentliche Fähigkeit für Python-Entwickler, die Tools und Dienstprogramme in professioneller Qualität erstellen möchten. Das argparse-Modul bietet eine robuste und standardisierte Möglichkeit, diese Funktionalität in Ihren Skripten zu implementieren.

Nun können Sie diese Techniken auf Ihre eigenen Python-Projekte anwenden, um sie vielseitiger und für Benutzer zugänglicher zu machen.

Wie man mehrere argparse-Argumente hinzufügt

Einführung

Grundlagen von Argparse verstehen

Was ist Argparse?

Erstellen Ihres ersten Skripts mit Argparse

Ausführen Ihres Skripts

Hilfemeldungen verstehen

Schlüsselkomponenten von Argparse

Hinzufügen mehrerer Argumenttypen

Arten von Argumenten

Die neuen Argumente verstehen

Testen des Rechners

Wichtige Punkte zu Argumenttypen

Erweiterte Argumentkonfigurationen

Erstellen eines Skripts zur Dateiverarbeitung

Die erweiterten Konfigurationen verstehen

Erstellen von Beispieldateien

Testen des Dateiprozessors

Wichtige Punkte zu erweiterten Konfigurationen

Erstellen eines vollständigen Kommandozeilen-Tools

Erstellen des Task-Managers

Den Task-Manager verstehen

Testen des Task-Managers

Hilfe für Unterbefehle abrufen

Wichtige Punkte zu Subparsers

Zusammenfassung