Bild von Autor | Ideogramm
# Einführung
Ich bin sicher, dass die meisten von Ihnen irgendwann eine Befehlshabls verwendet haben. Wenn Sie es nicht getan haben, obwohl es im Vergleich zu einer GUI langweilig aussieht, ist eine Befehlszeilenschnittstelle (CLI) sehr leicht und gibt Ihnen viel mehr Kontrolle. Einige häufige Beispiele sind SQLite, Git und die Python Repl. In diesem Tutorial lernen wir, wie man Python verwendet cmd Modul zum Erstellen unserer eigenen interaktiven Shell ohne externe Abhängigkeiten. Es ist sehr einfach und intuitiv, loszulegen. Wenn Sie an solchen Projekten arbeiten, können Sie verstehen, wie die Dinge unter der Motorhaube funktionieren – Dinge, die Sie normalerweise jeden Tag verwenden, aber nicht viel darüber nachdenken. Es ist auch nützlich, wenn Sie jemals vorhaben, Administratorkonsolen für Ihre Anwendungen zu erstellen.
Wir bauen unsere Shell in kleinen Stücken, beginnend mit einem minimalen Beispiel und fügen dann allmählich Befehle, Hilfe, grundlegende Validierung, Aliase und freundliche Ausgabe hinzu. Die einzige Voraussetzung von Ihrer Seite ist die grundlegende Vertrautheit mit Python -Funktionen und -klassen. Additionally fangen wir an.
# Schritt-für-Schritt-Prozess, um Ihre eigene Python-Shell zu erstellen
Lassen Sie uns einen kurzen Überblick darüber haben cmd Modul, da wir es bereits verwendet haben, aber nicht erklärt haben, was es ist. Es bietet eine Basisklasse (cmd.Cmd) zu bauen zeilenorientierte Befehlsinterpretenwas bedeutet, dass es jeweils einen Befehl verarbeitet. Es kümmert sich auch um das Lesen der Eingaben über eine Eingabeaufforderung, den Befehlsabschnitt (Mapping -Textual content zu Methoden) und das Hilfesystem. Sie implementieren Befehle, indem Sie die benannten Methoden definieren do_<command>. Das Modul behandelt den Relaxation – einfach und einfach.
// Schritt 1: Erstellen der minimalen Schale
Erstellen Sie eine Datei aufgerufen myshell.py:
import cmd
class MyShell(cmd.Cmd):
intro = "Welcome to MyShell! Sort assist or ? to listing instructions.n"
immediate = "(myshell) "
def do_greet(self, arg):
"""Greet the named particular person: greet <title>"""
title = arg.strip() or "stranger"
print(f"Hi there, {title}!")
def do_exit(self, arg):
"""Exit the shell."""
print("Goodbye!")
return True # Returning True tells cmdloop() to exit
if __name__ == "__main__":
MyShell().cmdloop()Führen Sie den Code mit: Ausführen:
Versuchen wir nun ein paar Befehle. cmdloop() Starten Sie die interaktive Schleife und wir können wie unten gezeigt interagieren:
Welcome to MyShell! Sort assist or ? to listing instructions.
(myshell) assist
Documented instructions (sort assist <matter>):
========================================
exit greet assist
(myshell) ?
Documented instructions (sort assist <matter>):
========================================
exit greet assist
(myshell) greet kanwal
Hi there, kanwal!
(myshell) exit
Goodbye!// Schritt 2: Argumente sauber analysieren
Für komplexere Befehle, die mehrere Eingabewerte erfordern – wie beim Hinzufügen oder Multiplizieren – benötigen Sie etwas, um Räume, Zitate usw. zu analysieren. Dafür werden wir verwenden shlex.cut up. Schauen wir uns den Beispielcode an:
import cmd
import shlex
class MyShell(cmd.Cmd):
intro = "Welcome to MyShell! Sort assist or ? to listing instructions.n"
immediate = "(myshell) "
def do_add(self, arg):
"""Add numbers: add 1 2 3"""
strive:
components = shlex.cut up(arg)
nums = (float(p) for p in components)
besides ValueError:
print("Error: all arguments should be numbers.")
return
besides Exception as e:
print(f"Parse error: {e}")
return
whole = sum(nums)
print(f"Sum = {whole}")
def do_exit(self, arg):
"""Exit the shell."""
print("Goodbye!")
return True
if __name__ == "__main__":
MyShell().cmdloop()Probieren wir es jetzt aus:
Welcome to MyShell! Sort assist or ? to listing instructions.
(myshell) ?
Documented instructions (sort assist <matter>):
========================================
add exit assist
(myshell) add 2450 3456 8904 3467
Sum = 18277.0
(myshell) exit
Goodbye!// Schritt 3: Hinzufügen eines Hilfesystems
Wir haben oben bereits einen Hilfebefehl gesehen. Das ist die Standardeinstellung, die die cmd Das Modul erstellt automatisch. Es zeigt die Methode Docstrings. Sie können auch benutzerdefinierte Hilfe für einen Befehl oder ein solches Thema hinzufügen:
class MyShell(cmd.Cmd):
intro = "Welcome to MyShell! Sort assist or ? to listing instructions.n"
immediate = "(myshell) "
def do_greet(self, arg):
"""Greet somebody. Utilization: greet <title>"""
title = arg.strip() or "stranger"
print(f"Hi there, {title}!")
def help_greet(self):
print("greet <title>")
print(" Prints a pleasant greeting.")
print(" Instance: greet Alice")
def do_exit(self, arg):
"""Exit the shell."""
print("Goodbye!")
return True
def do_help(self, arg):
# Maintain default habits, however present a tiny information when no arg
if arg:
return tremendous().do_help(arg)
tremendous().do_help(arg)
print()
print("Fundamentals:")
print(" - Use 'assist' or '?' to listing instructions.")
print(" - Use 'assist <command>' for particulars.")
print(" - Arguments help quotes (through shlex).")Welcome to MyShell! Sort assist or ? to listing instructions.
(myshell) assist
Documented instructions (sort assist <matter>):
========================================
exit greet
Undocumented instructions:
======================
assist
Fundamentals:
- Use 'assist' or '?' to listing instructions.
- Use 'assist <command>' for particulars.
- Arguments help quotes (through shlex).
(myshell) assist greet
greet <title>
Prints a pleasant greeting.
Instance: greet Alice
(myshell) assist exit
Exit the shell.
(myshell) exit
Goodbye!// Schritt 4: Handhabungsfehler und unbekannte Befehle
Wir können das überschreiben default() Methode, um unbekannte Befehle abzufangen. Sie können auch verwenden emptyline() Um zu steuern, was passiert, wenn der Benutzer ohne Eingabe eingeben. Lassen Sie uns die Shell nichts tun, wenn keine Eingabe eingegeben wurde:
class MyShell(cmd.Cmd):
immediate = "(myshell) "
def default(self, line):
print(f"Unknown command: {line!r}. Sort 'assist' to listing instructions.")
def emptyline(self):
# By default, urgent Enter repeats the final command. Override to do nothing.
go
def do_exit(self, arg):
"""Exit the shell."""
print("Goodbye!")
return True(myshell) assist
Documented instructions (sort assist <matter>):
========================================
exit assist
(myshell)
(myshell)
(myshell) exit
Goodbye!// Schritt 5: Hinzufügen von Befehls -Aliase
Aliase sind kurze Namen. Tonnen meiner Freunde haben auch Aliase, insbesondere diejenigen mit den gleichen Namen. In ähnlicher Weise können Sie eine kürzere – und leichter zu erinnern zu erinnern zu erinnern precmd() Verfahren. So können Sie das tun:
import shlex
import cmd
class MyShell(cmd.Cmd):
immediate = "(myshell) "
aliases = {
"give up": "exit",
"q": "exit",
"whats up": "greet",
"sum": "add",
}
def precmd(self, line: str) -> str:
# Normalize/therapeutic massage enter earlier than dispatch
components = line.strip().cut up(maxsplit=1)
if not components:
return line
cmd_name = components(0)
relaxation = components(1) if len(components) > 1 else ""
if cmd_name in self.aliases:
cmd_name = self.aliases(cmd_name)
return f"{cmd_name} {relaxation}".strip()
# Outline instructions used above
def do_greet(self, arg):
"""Greet somebody. Utilization: greet <title>"""
title = arg.strip() or "stranger"
print(f"Hi there, {title}!")
def do_add(self, arg):
"""Add numbers: add 1 2 3"""
strive:
nums = (float(x) for x in shlex.cut up(arg))
besides Exception:
print("Utilization: add <num> (<num> ...)")
return
print(f"Sum = {sum(nums)}")
def do_exit(self, arg):
"""Exit the shell."""
print("Goodbye!")
return True(myshell) ?
Documented instructions (sort assist <matter>):
========================================
add exit greet assist
(myshell) sum 2 3 4
Sum = 9.0
(myshell) add 2 3 4
Sum = 9.0
(myshell) q
Goodbye!// Schritt 6: alles zusammenfügen
import cmd
import shlex
class MyShell(cmd.Cmd):
intro = "Welcome to MyShell! Sort assist or ? to listing instructions."
immediate = "(myshell) "
# Easy aliases
aliases = {"q": "exit", "give up": "exit", "whats up": "greet", "sum": "add"}
# ----- Enter processing -----
def precmd(self, line):
components = line.strip().cut up(maxsplit=1)
if not components:
return line
cmd_name = components(0)
relaxation = components(1) if len(components) > 1 else ""
if cmd_name in self.aliases:
cmd_name = self.aliases(cmd_name)
return f"{cmd_name} {relaxation}".strip()
def emptyline(self):
# Do nothing on empty line
go
def default(self, line):
print(f"Unknown command: {line!r}. Sort 'assist' to listing instructions.")
# ----- Instructions -----
def do_greet(self, arg):
"""Greet somebody. Utilization: greet <title>"""
title = arg.strip() or "stranger"
print(f"Hi there, {title}!")
def help_greet(self):
print("greet <title>")
print(" Prints a pleasant greeting.")
print(" Instance: greet Alice")
def do_add(self, arg):
"""Add numbers: add 1 2 3"""
strive:
nums = (float(x) for x in shlex.cut up(arg))
besides Exception:
print("Utilization: add <num> (<num> ...)")
return
print(f"Sum = {sum(nums)}")
def do_echo(self, arg):
"""Echo again what you sort: echo <textual content>"""
print(arg)
def do_exit(self, arg):
"""Exit the shell."""
print("Goodbye!")
return True
# ----- Assist tweaks -----
def do_help(self, arg):
if arg:
return tremendous().do_help(arg)
tremendous().do_help(arg)
print()
print("Fundamentals:")
print(" - Use 'assist' or '?' to listing instructions.")
print(" - Use 'assist <command>' for particulars.")
print(' - Quotes are supported in arguments (e.g., add "3.5" 2).')
if __name__ == "__main__":
MyShell().cmdloop()Welcome to MyShell! Sort assist or ? to listing instructions.
(myshell) whats up
Hi there, stranger!
(myshell) WRONG COMMAND
Unknown command: 'WRONG COMMAND'. Sort 'assist' to listing instructions.
(myshell) echo KDnuggets is a good website
KDnuggets is a good website
(myshell) exit
Goodbye!# Einpacken
Sie haben gerade gelernt, wie man eine interaktive Hülle mit dem baut cmd Modul ohne externe Abhängigkeiten. Ist das nicht erstaunlich?
Bevor wir fertig sind, lohnt es sich, darauf hinzuweisen ein paar häufige Fallstricke Zu achten auf: Erstens vergessen, zurückzukehren True In Ihrem Ausgangsbefehl verhindern die Shell -Schleife. Zweitens kann es zu Problemen führen, wenn Benutzer auf einfache Whitespace -Aufteilung für Argumente zu Problemen führen, wenn Benutzer den zitierten Textual content eingeben. shlex wird empfohlen. Schließlich nicht mit dem umzugehen emptyline() Methode kann ordnungsgemäß zu unerwartetem Verhalten führen, z. B. das Wiederholen des letzten Befehls, wenn der Benutzer in eine leere Zeile eingegeben wird.
Ich würde gerne Ihre Gedanken zu diesem Artikel im Kommentarbereich sowie alle Ideen hören, die Sie möglicherweise weiter untersuchen möchten.
Kanwal Mehreen ist ein Ingenieur für maschinelles Lernen und technischer Schriftsteller mit einer tiefgreifenden Leidenschaft für die Datenwissenschaft und die Schnittstelle von KI mit Medizin. Sie hat das eBook „Produktivität mit Chatgpt maximieren“. Als Google -Technology -Gelehrte 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie wird auch als Teradata -Vielfalt in Tech Scholar, MITACS Globalink Analysis Scholar und Harvard Wecode Scholar anerkannt. Kanwal ist ein leidenschaftlicher Verfechter der Veränderung, nachdem er Femcodes gegründet hat, um Frauen in STEM -Bereichen zu stärken.