Curses-Programmierung mit Python

Autor:

A.M. Kuchling, Eric S. Raymond

Version:

2.04

Was ist curses?

Die curses-Bibliothek bietet eine terminalunabhängige Funktion zum Malen von Bildschirmen und zur Tastaturbehandlung für textbasierte Terminals; zu solchen Terminals gehören VT100, die Linux-Konsole und das simulierte Terminal, das von verschiedenen Programmen bereitgestellt wird. Anzeigeterminals unterstützen verschiedene Steuercodes für gängige Vorgänge wie das Bewegen des Cursors, das Scrollen des Bildschirms und das Löschen von Bereichen. Verschiedene Terminals verwenden stark unterschiedliche Codes und haben oft ihre eigenen kleinen Eigenheiten.

In einer Welt grafischer Anzeigen könnte man fragen: „Warum sich die Mühe machen?“ Es stimmt zwar, dass zeichenbasierte Displays eine veraltete Technologie sind, aber es gibt Nischen, in denen es immer noch wertvoll ist, ausgefallene Dinge damit tun zu können. Eine Nische sind schlanke oder eingebettete Unix-Systeme, die keinen X-Server ausführen. Eine andere sind Werkzeuge wie OS-Installer und Kernel-Konfiguratoren, die möglicherweise ausgeführt werden müssen, bevor eine grafische Unterstützung verfügbar ist.

Die curses-Bibliothek bietet recht grundlegende Funktionalität, indem sie dem Programmierer eine Abstraktion eines Displays mit mehreren nicht überlappenden Textfenstern bietet. Der Inhalt eines Fensters kann auf verschiedene Weise geändert werden – Hinzufügen von Text, Löschen, Ändern seines Erscheinungsbilds –, und die curses-Bibliothek ermittelt, welche Steuercodes an das Terminal gesendet werden müssen, um die richtige Ausgabe zu erzeugen. curses bietet nicht viele Benutzeroberflächenkonzepte wie Schaltflächen, Kontrollkästchen oder Dialoge; wenn Sie solche Funktionen benötigen, sollten Sie eine Benutzeroberflächenbibliothek wie Urwid in Betracht ziehen.

Die curses-Bibliothek wurde ursprünglich für BSD Unix geschrieben; die späteren System V-Versionen von Unix von AT&T fügten viele Verbesserungen und neue Funktionen hinzu. BSD curses wird nicht mehr gepflegt und wurde durch ncurses ersetzt, eine Open-Source-Implementierung der AT&T-Schnittstelle. Wenn Sie ein Open-Source-Unix wie Linux oder FreeBSD verwenden, verwendet Ihr System mit ziemlicher Sicherheit ncurses. Da die meisten aktuellen kommerziellen Unix-Versionen auf System V-Code basieren, sind wahrscheinlich alle hier beschriebenen Funktionen verfügbar. Die älteren Versionen von curses, die auf einigen proprietären Unix-Systemen mitgeführt werden, unterstützen jedoch möglicherweise nicht alles.

Die Windows-Version von Python enthält nicht das curses-Modul. Eine portierte Version namens UniCurses ist verfügbar.

Das Python-curses-Modul

Das Python-Modul ist ein ziemlich einfacher Wrapper für die von curses bereitgestellten C-Funktionen; wenn Sie bereits mit curses-Programmierung in C vertraut sind, ist es wirklich einfach, dieses Wissen auf Python zu übertragen. Der größte Unterschied besteht darin, dass die Python-Schnittstelle die Dinge vereinfacht, indem sie verschiedene C-Funktionen wie addstr(), mvaddstr() und mvwaddstr() in einer einzigen addstr()-Methode zusammenführt. Dies wird später noch ausführlicher behandelt.

Dieses HOWTO ist eine Einführung in das Schreiben von Textmodus-Programmen mit curses und Python. Es versucht nicht, ein vollständiger Leitfaden zur curses-API zu sein; dazu siehe den Abschnitt über ncurses in der Python-Bibliotheksanleitung und die C-Handbuchseiten für ncurses. Es vermittelt Ihnen jedoch die grundlegenden Ideen.

Starten und Beenden einer curses-Anwendung

Bevor Sie etwas tun können, muss curses initialisiert werden. Dies geschieht durch Aufruf der Funktion initscr(), die den Terminaltyp ermittelt, erforderliche Einrichtungscodes an das Terminal sendet und verschiedene interne Datenstrukturen erstellt. Bei Erfolg gibt initscr() ein Fensterobjekt zurück, das den gesamten Bildschirm repräsentiert; dies wird normalerweise stdscr genannt, nach dem Namen der entsprechenden C-Variable.

import curses
stdscr = curses.initscr()

Normalerweise deaktivieren curses-Anwendungen das automatische Echo von Tasten auf den Bildschirm, um Tasten lesen und sie nur unter bestimmten Umständen anzeigen zu können. Dazu muss die Funktion noecho() aufgerufen werden.

curses.noecho()

Anwendungen müssen auch üblicherweise sofort auf Tasten reagieren, ohne dass die Eingabetaste gedrückt werden muss; dies wird als cbreak-Modus bezeichnet, im Gegensatz zum üblichen gepufferten Eingabemodus.

curses.cbreak()

Terminals geben normalerweise Sondertasten wie die Cursortasten oder Navigationstasten wie Bild auf und Pos1 als mehrstellige Escape-Sequenz zurück. Sie könnten zwar Ihre Anwendung so schreiben, dass sie solche Sequenzen erwartet und entsprechend verarbeitet, aber curses kann dies für Sie übernehmen und gibt einen speziellen Wert wie curses.KEY_LEFT zurück. Damit curses die Arbeit erledigt, müssen Sie den Tastaturmodus (keypad mode) aktivieren.

stdscr.keypad(True)

Das Beenden einer curses-Anwendung ist viel einfacher als das Starten. Sie müssen

curses.nocbreak()
stdscr.keypad(False)
curses.echo()

aufrufen, um die curses-freundlichen Terminaleinstellungen rückgängig zu machen. Rufen Sie dann die Funktion endwin() auf, um das Terminal in seinen ursprünglichen Betriebsmodus zurückzuversetzen.

curses.endwin()

Ein häufiges Problem beim Debuggen einer curses-Anwendung ist, dass das Terminal durcheinander gerät, wenn die Anwendung abstürzt, ohne das Terminal wieder in seinen vorherigen Zustand zu versetzen. In Python geschieht dies häufig, wenn Ihr Code fehlerhaft ist und eine unbehandelte Ausnahme auslöst. Tasten werden beispielsweise nicht mehr auf dem Bildschirm angezeigt, wenn Sie sie eingeben, was die Verwendung der Shell erschwert.

In Python können Sie diese Komplikationen vermeiden und das Debugging erheblich erleichtern, indem Sie die Funktion curses.wrapper() importieren und sie wie folgt verwenden:

from curses import wrapper

def main(stdscr):
    # Clear screen
    stdscr.clear()

    # This raises ZeroDivisionError when i == 10.
    for i in range(0, 11):
        v = i-10
        stdscr.addstr(i, 0, '10 divided by {} is {}'.format(v, 10/v))

        stdscr.refresh()
        stdscr.getkey()

wrapper(main)

Die Funktion wrapper() nimmt ein aufrufbare Objekt entgegen und führt die oben beschriebenen Initialisierungen durch, wobei auch Farben initialisiert werden, falls Farbunterstützung vorhanden ist. wrapper() führt dann Ihr bereitgestelltes aufrufbares Objekt aus. Sobald das aufrufbare Objekt zurückkehrt, stellt wrapper() den ursprünglichen Zustand des Terminals wieder her. Das aufrufbare Objekt wird innerhalb einer try...except-Struktur aufgerufen, die Ausnahmen abfängt, den Zustand des Terminals wiederherstellt und dann die Ausnahme erneut auslöst. Daher wird Ihr Terminal bei einer Ausnahme nicht in einem komischen Zustand hinterlassen und Sie können die Fehlermeldung und den Traceback lesen.

Fenster und Pads

Fenster sind die grundlegende Abstraktion in curses. Ein Fensterobjekt repräsentiert einen rechteckigen Bereich des Bildschirms und unterstützt Methoden zur Anzeige von Text, zum Löschen, zur Eingabe von Zeichenketten durch den Benutzer usw.

Das von der Funktion initscr() zurückgegebene Objekt stdscr ist ein Fensterobjekt, das den gesamten Bildschirm abdeckt. Viele Programme benötigen möglicherweise nur dieses eine Fenster, aber Sie möchten den Bildschirm vielleicht in kleinere Fenster aufteilen, um sie separat neu zu zeichnen oder zu löschen. Die Funktion newwin() erstellt ein neues Fenster einer bestimmten Größe und gibt das neue Fensterobjekt zurück.

begin_x = 20; begin_y = 7
height = 5; width = 40
win = curses.newwin(height, width, begin_y, begin_x)

Beachten Sie, dass das in curses verwendete Koordinatensystem ungewöhnlich ist. Koordinaten werden immer in der Reihenfolge *y,x* übergeben, und die obere linke Ecke eines Fensters ist die Koordinate (0,0). Dies bricht mit der üblichen Konvention für die Behandlung von Koordinaten, bei der die *x*-Koordinate zuerst kommt. Dies ist ein unglücklicher Unterschied zu den meisten anderen Computeranwendungen, aber es war Teil von curses, seit es zum ersten Mal geschrieben wurde, und es ist zu spät, die Dinge jetzt noch zu ändern.

Ihre Anwendung kann die Bildschirmgröße ermitteln, indem sie die Variablen curses.LINES und curses.COLS verwendet, um die *y*- und *x*-Größen zu erhalten. Gültige Koordinaten erstrecken sich dann von (0,0) bis (curses.LINES - 1, curses.COLS - 1).

Wenn Sie eine Methode zum Anzeigen oder Löschen von Text aufrufen, wird der Effekt nicht sofort auf dem Bildschirm sichtbar. Stattdessen müssen Sie die Methode refresh() der Fensterobjekte aufrufen, um den Bildschirm zu aktualisieren.

Dies liegt daran, dass curses ursprünglich für langsame 300-Baud-Terminalverbindungen geschrieben wurde; bei diesen Terminals war die Minimierung der Zeit für das Neufotografieren des Bildschirms sehr wichtig. Stattdessen sammelt curses Änderungen am Bildschirm und zeigt sie auf die effizienteste Weise an, wenn Sie refresh() aufrufen. Wenn Ihr Programm beispielsweise Text in einem Fenster anzeigt und das Fenster dann löscht, muss der ursprüngliche Text nicht gesendet werden, da er nie sichtbar ist.

In der Praxis macht das explizite Anweisen von curses, ein Fenster neu zu zeichnen, die Programmierung mit curses nicht wirklich kompliziert. Die meisten Programme gehen in eine Flut von Aktivitäten über und warten dann auf einen Tastendruck oder eine andere Aktion des Benutzers. Alles, was Sie tun müssen, ist sicherzustellen, dass der Bildschirm neu gezeichnet wurde, bevor Sie auf eine Benutzereingabe warten, indem Sie zuerst stdscr.refresh() oder die Methode refresh() eines anderen relevanten Fensters aufrufen.

Ein Pad ist ein Sonderfall eines Fensters; es kann größer sein als der eigentliche Bildschirm, und nur ein Teil des Pads wird gleichzeitig angezeigt. Das Erstellen eines Pads erfordert die Höhe und Breite des Pads, während das Aktualisieren eines Pads die Angabe der Koordinaten des Bildschirmbereichs erfordert, in dem ein Unterabschnitt des Pads angezeigt wird.

pad = curses.newpad(100, 100)
# These loops fill the pad with letters; addch() is
# explained in the next section
for y in range(0, 99):
    for x in range(0, 99):
        pad.addch(y,x, ord('a') + (x*x+y*y) % 26)

# Displays a section of the pad in the middle of the screen.
# (0,0) : coordinate of upper-left corner of pad area to display.
# (5,5) : coordinate of upper-left corner of window area to be filled
#         with pad content.
# (20, 75) : coordinate of lower-right corner of window area to be
#          : filled with pad content.
pad.refresh( 0,0, 5,5, 20,75)

Der Aufruf refresh() zeigt einen Abschnitt des Pads im Rechteck von Koordinate (5,5) bis Koordinate (20,75) auf dem Bildschirm an; die obere linke Ecke des angezeigten Abschnitts ist Koordinate (0,0) auf dem Pad. Abgesehen von diesem Unterschied sind Pads genau wie normale Fenster und unterstützen dieselben Methoden.

Wenn Sie mehrere Fenster und Pads auf dem Bildschirm haben, gibt es eine effizientere Möglichkeit, den Bildschirm zu aktualisieren und störendes Bildschirmflimmern zu vermeiden, da jeder Teil des Bildschirms aktualisiert wird. refresh() führt tatsächlich zwei Dinge aus:

  1. Ruft die Methode noutrefresh() jedes Fensters auf, um eine zugrundeliegende Datenstruktur zu aktualisieren, die den gewünschten Zustand des Bildschirms darstellt.

  2. Ruft die Funktion doupdate() auf, um den physischen Bildschirm an den gewünschten Zustand in der Datenstruktur anzupassen.

Stattdessen können Sie noutrefresh() für eine Reihe von Fenstern aufrufen, um die Datenstruktur zu aktualisieren, und dann doupdate() aufrufen, um den Bildschirm zu aktualisieren.

Text anzeigen

Aus Sicht eines C-Programmierers kann curses manchmal wie ein verwinkelter Irrgarten von Funktionen aussehen, die sich alle subtil unterscheiden. Zum Beispiel zeigt addstr() einen String an der aktuellen Cursorposition im Fenster stdscr an, während mvaddstr() zuerst zu einer gegebenen y,x-Koordinate wechselt, bevor der String angezeigt wird. waddstr() ist wie addstr(), aber es erlaubt die Angabe eines Fensters anstelle des Standardfensters stdscr. mvwaddstr() erlaubt die Angabe sowohl eines Fensters als auch einer Koordinate.

Glücklicherweise versteckt die Python-Schnittstelle all diese Details. stdscr ist ein Fensterobjekt wie jedes andere, und Methoden wie addstr() akzeptieren mehrere Argumentformen. Normalerweise gibt es vier verschiedene Formen.

Form

Beschreibung

str oder ch

Zeigt den String str oder das Zeichen ch an der aktuellen Position an.

str oder ch, attr

Zeigt den String str oder das Zeichen ch mit dem Attribut attr an der aktuellen Position an.

y, x, str oder ch

Wechselt zur Position y,x im Fenster und zeigt str oder ch an.

y, x, str oder ch, attr

Wechselt zur Position y,x im Fenster und zeigt str oder ch mit dem Attribut attr an.

Attribute erlauben die Anzeige von Text in hervorgehobenen Formen wie Fett, Unterstrichen, Umkehrung oder Farbe. Sie werden im nächsten Unterabschnitt näher erläutert.

Die Methode addstr() nimmt eine Python-Zeichenkette oder Bytestring als anzuzeigenden Wert an. Der Inhalt von Bytestrings wird unverändert an das Terminal gesendet. Zeichenketten werden mit dem Wert des Attributs encoding des Fensters in Bytes kodiert; dies ist standardmäßig die Standardkodierung des Systems, wie sie von locale.getencoding() zurückgegeben wird.

Die Methode addch() nimmt ein Zeichen entgegen, das entweder eine Zeichenkette der Länge 1, ein Bytestring der Länge 1 oder eine Ganzzahl sein kann.

Für Erweiterungszeichen werden Konstanten bereitgestellt; diese Konstanten sind Ganzzahlen größer als 255. Zum Beispiel ist ACS_PLMINUS ein +/- Symbol und ACS_ULCORNER ist die obere linke Ecke eines Rahmens (nützlich zum Zeichnen von Rahmen). Sie können auch das entsprechende Unicode-Zeichen verwenden.

Fenster speichern die Cursorposition nach der letzten Operation, sodass, wenn Sie die Koordinaten y,x weglassen, der String oder das Zeichen dort angezeigt wird, wo die letzte Operation den Cursor hinterlassen hat. Sie können den Cursor auch mit der Methode move(y,x) bewegen. Da einige Terminals immer einen blinkenden Cursor anzeigen, möchten Sie vielleicht sicherstellen, dass der Cursor an einer Stelle positioniert ist, an der er nicht ablenkt; es kann verwirrend sein, wenn der Cursor an einer scheinbar zufälligen Stelle blinkt.

Wenn Ihre Anwendung überhaupt keinen blinkenden Cursor benötigt, können Sie curs_set(False) aufrufen, um ihn unsichtbar zu machen. Zur Kompatibilität mit älteren curses-Versionen gibt es eine Funktion leaveok(bool), die ein Synonym für curs_set() ist. Wenn bool true ist, versucht die curses-Bibliothek, den blinkenden Cursor zu unterdrücken, und Sie müssen sich keine Gedanken darüber machen, ihn an seltsamen Stellen zu belassen.

Attribute und Farbe

Zeichen können auf verschiedene Weise angezeigt werden. Statuszeilen in einer textbasierten Anwendung werden üblicherweise in umgekehrter Videodarstellung angezeigt, oder ein Textbetrachter muss bestimmte Wörter hervorheben. curses unterstützt dies, indem es Ihnen erlaubt, jedem Feld auf dem Bildschirm ein Attribut zuzuweisen.

Ein Attribut ist eine Ganzzahl, wobei jedes Bit ein anderes Attribut darstellt. Sie können versuchen, Text mit mehreren gesetzten Attributbits anzuzeigen, aber curses garantiert nicht, dass alle möglichen Kombinationen verfügbar sind oder dass sie visuell unterscheidbar sind. Dies hängt von den Fähigkeiten des verwendeten Terminals ab, daher ist es am sichersten, sich an die am häufigsten verfügbaren Attribute zu halten, die hier aufgelistet sind.

Attribut

Beschreibung

A_BLINK

Blinkender Text

A_BOLD

Extra heller oder fette Text

A_DIM

Halb heller Text

A_REVERSE

Umgekehrter Videotext

A_STANDOUT

Der beste verfügbare Hervorhebungsmodus

A_UNDERLINE

Unterstrichener Text

Um eine Statuszeile mit umgekehrtem Video in der obersten Zeile des Bildschirms anzuzeigen, könnten Sie dies so codieren:

stdscr.addstr(0, 0, "Current mode: Typing mode",
              curses.A_REVERSE)
stdscr.refresh()

Die curses-Bibliothek unterstützt auch Farbe auf Terminals, die dies bieten. Das häufigste solche Terminal ist wahrscheinlich die Linux-Konsole, gefolgt von Farb-Xterms.

Um Farbe zu verwenden, müssen Sie die Funktion start_color() kurz nach dem Aufruf von initscr() aufrufen, um den Standardfarbsatz zu initialisieren (die Funktion curses.wrapper() tut dies automatisch). Sobald dies geschehen ist, gibt die Funktion has_colors() TRUE zurück, wenn das verwendete Terminal tatsächlich Farbe anzeigen kann. (Hinweis: curses verwendet die amerikanische Schreibweise „color“ anstelle der kanadischen/britischen Schreibweise „colour“. Wenn Sie die britische Schreibweise gewohnt sind, müssen Sie sich damit abfinden, sie für diese Funktionen falsch zu schreiben.)

Die curses-Bibliothek verwaltet eine endliche Anzahl von Farbpaaren, die eine Vordergrundfarbe (oder Textfarbe) und eine Hintergrundfarbe enthalten. Sie können den Attributwert erhalten, der einem Farbpaar entspricht, mit der Funktion color_pair(); dies kann mit anderen Attributen wie A_REVERSE per bitweisem OR verknüpft werden, aber auch hier sind solche Kombinationen nicht garantiert, dass sie auf allen Terminals funktionieren.

Ein Beispiel, das eine Textzeile mit Farbpaar 1 anzeigt

stdscr.addstr("Pretty text", curses.color_pair(1))
stdscr.refresh()

Wie bereits erwähnt, besteht ein Farbpaar aus einer Vordergrund- und einer Hintergrundfarbe. Die Funktion init_pair(n, f, b) ändert die Definition von Farbpaar *n* auf Vordergrundfarbe *f* und Hintergrundfarbe *b*. Farbpaar 0 ist fest auf Weiß auf Schwarz voreingestellt und kann nicht geändert werden.

Farben sind nummeriert, und start_color() initialisiert 8 Grundfarben, wenn es den Farbmodus aktiviert. Sie sind: 0:schwarz, 1:rot, 2:grün, 3:gelb, 4:blau, 5:magenta, 6:cyan und 7:weiß. Das Modul curses definiert benannte Konstanten für jede dieser Farben: curses.COLOR_BLACK, curses.COLOR_RED und so weiter.

Fassen wir das alles zusammen. Um Farbe 1 auf roten Text auf weißem Hintergrund zu ändern, rufen Sie auf:

curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)

Wenn Sie ein Farbpaar ändern, ändert sich jeder Text, der bereits mit diesem Farbpaar angezeigt wurde, zu den neuen Farben. Sie können auch neuen Text in dieser Farbe anzeigen mit:

stdscr.addstr(0,0, "RED ALERT!", curses.color_pair(1))

Sehr ausgefallene Terminals können die Definitionen der tatsächlichen Farben auf einen gegebenen RGB-Wert ändern. Dies ermöglicht es Ihnen, Farbe 1, die normalerweise rot ist, in lila oder blau oder jede andere gewünschte Farbe zu ändern. Leider unterstützt die Linux-Konsole dies nicht, daher kann ich keine Beispiele geben. Sie können prüfen, ob Ihr Terminal dies kann, indem Sie can_change_color() aufrufen, das True zurückgibt, wenn die Fähigkeit vorhanden ist. Wenn Sie Glück haben und ein solch talentiertes Terminal besitzen, konsultieren Sie die Handbuchseiten Ihres Systems für weitere Informationen.

Benutzereingaben

Die C curses-Bibliothek bietet nur sehr einfache Eingabemechanismen. Das Python-Modul curses fügt ein grundlegendes Text-Eingabefeld hinzu. (Andere Bibliotheken wie Urwid haben umfangreichere Sammlungen von Widgets.)

Es gibt zwei Methoden, um Eingaben von einem Fenster zu erhalten:

  • getch() aktualisiert den Bildschirm und wartet dann darauf, dass der Benutzer eine Taste drückt. Die Taste wird angezeigt, wenn echo() zuvor aufgerufen wurde. Sie können optional eine Koordinate angeben, zu der der Cursor vor dem Anhalten bewegt werden soll.

  • getkey() tut dasselbe, konvertiert die Ganzzahl aber in eine Zeichenkette. Einzelne Zeichen werden als 1-Zeichen-Strings zurückgegeben, und Sondertasten wie Funktionstasten geben längere Strings mit einem Tastennamen wie KEY_UP oder ^G zurück.

Es ist möglich, nicht auf den Benutzer zu warten, indem die Fenster-Methode nodelay() verwendet wird. Nach nodelay(True) werden getch() und getkey() für das Fenster nicht-blockierend. Um anzuzeigen, dass keine Eingabe bereitsteht, gibt getch() curses.ERR (ein Wert von -1) zurück und getkey() löst eine Ausnahme aus. Es gibt auch eine Funktion halfdelay(), die verwendet werden kann, um (effektiv) einen Timer für jeden getch() zu setzen; wenn innerhalb einer angegebenen Verzögerung (gemessen in Zehntelsekunden) keine Eingabe verfügbar ist, löst curses eine Ausnahme aus.

Die Methode getch() gibt eine Ganzzahl zurück. Wenn sie zwischen 0 und 255 liegt, repräsentiert sie den ASCII-Code der gedrückten Taste. Werte größer als 255 sind Sondertasten wie Bild auf, Pos1 oder die Cursortasten. Sie können den zurückgegebenen Wert mit Konstanten wie curses.KEY_PPAGE, curses.KEY_HOME oder curses.KEY_LEFT vergleichen. Die Hauptschleife Ihres Programms könnte etwa so aussehen:

while True:
    c = stdscr.getch()
    if c == ord('p'):
        PrintDocument()
    elif c == ord('q'):
        break  # Exit the while loop
    elif c == curses.KEY_HOME:
        x = y = 0

Das Modul curses.ascii stellt ASCII-Klassenmitgliedsfunktionen bereit, die entweder Ganzzahl- oder 1-Zeichen-String-Argumente akzeptieren; diese können nützlich sein, um solche Schleifen lesbarer zu gestalten. Es stellt auch Konvertierungsfunktionen bereit, die entweder Ganzzahl- oder 1-Zeichen-String-Argumente akzeptieren und denselben Typ zurückgeben. Zum Beispiel gibt curses.ascii.ctrl() das Steuerzeichen zurück, das seinem Argument entspricht.

Es gibt auch eine Methode zum Abrufen eines gesamten Strings, getstr(). Sie wird nicht sehr oft verwendet, da ihre Funktionalität ziemlich begrenzt ist; die einzigen verfügbaren Bearbeitungstasten sind die Rücklöschtaste und die Eingabetaste, die den String beendet. Sie kann optional auf eine feste Anzahl von Zeichen beschränkt werden.

curses.echo()            # Enable echoing of characters

# Get a 15-character string, with the cursor on the top line
s = stdscr.getstr(0,0, 15)

Das Modul curses.textpad stellt eine Textbox bereit, die eine Emacs-ähnliche Tastenbelegung unterstützt. Verschiedene Methoden der Klasse Textbox unterstützen die Bearbeitung mit Eingabevalidierung und das Sammeln der Bearbeitungsergebnisse entweder mit oder ohne nachgestellte Leerzeichen. Hier ist ein Beispiel:

import curses
from curses.textpad import Textbox, rectangle

def main(stdscr):
    stdscr.addstr(0, 0, "Enter IM message: (hit Ctrl-G to send)")

    editwin = curses.newwin(5,30, 2,1)
    rectangle(stdscr, 1,0, 1+5+1, 1+30+1)
    stdscr.refresh()

    box = Textbox(editwin)

    # Let the user edit until Ctrl-G is struck.
    box.edit()

    # Get resulting contents
    message = box.gather()

Weitere Details finden Sie in der Bibliotheksdokumentation zu curses.textpad.

Für weitere Informationen

Dieses HOWTO behandelt keine fortgeschrittenen Themen wie das Lesen des Bildschirminhalts oder das Erfassen von Mausereignissen von einer xterm-Instanz, aber die Python-Bibliotheksseite für das Modul curses ist nun einigermaßen vollständig. Sie sollten sie als Nächstes durchsuchen.

Wenn Sie sich über das detaillierte Verhalten der curses-Funktionen im Unklaren sind, konsultieren Sie die Handbuchseiten für Ihre curses-Implementierung, sei es ncurses oder ein proprietärer Unix-Anbieter. Die Handbuchseiten dokumentieren alle Eigenheiten und bieten vollständige Listen aller Ihnen zur Verfügung stehenden Funktionen, Attribute und ACS_* Zeichen.

Da die curses-API so umfangreich ist, werden einige Funktionen in der Python-Schnittstelle nicht unterstützt. Oft liegt dies nicht daran, dass sie schwer zu implementieren sind, sondern weil sie bisher noch niemand benötigt hat. Außerdem unterstützt Python die mit ncurses verbundene Menübibliothek noch nicht. Patches, die Unterstützung für diese hinzufügen, sind willkommen. Lesen Sie den Python Developer’s Guide, um mehr über das Einreichen von Patches bei Python zu erfahren.