Come ottenere la larghezza della finestra della console Linux in Python

Esiste un modo in Python per determinare a livello di programmazione la larghezza della console? Intendo il numero di caratteri che si inserisce in una riga senza avvolgimento, non la larghezza in pixel della finestra.

modificare

Alla ricerca di una soluzione che funziona su Linux

import os
rows, columns = os.popen('stty size', 'r').read().split()

usa il comando 'stty size' che secondo un thread sulla mailing list di Python è ragionevolmente universale su Linux. Apre il comando 'stty size' come file, 'legge' da esso e utilizza una semplice suddivisione in stringhe per separare le coordinate.

A differenza del valore os.environ ["COLUMNS"] (a cui non posso accedere nonostante l'utilizzo di bash come shell standard), anche i dati saranno aggiornati, mentre credo che os.environ ["COLUMNS"] il valore sarebbe valido solo per il momento del lancio dell'interprete python (supponiamo che l'utente abbia ridimensionato la finestra da allora).

(Vedi la risposta di @GringoSuave su come eseguire questa operazione su Python 3.3+)

Non sono sicuro del motivo per cui si trova nel modulo shutil, ma è arrivato lì in Python 3.3, Interrogando le dimensioni del terminale di output :

>>> import shutil
>>> shutil.get_terminal_size((80, 20))  # pass fallback
os.terminal_size(columns=87, lines=23)  # returns a named-tuple

Un'implementazione di basso livello è nel modulo os. Funziona anche in Windows.

Un backport è ora disponibile per Python 3.2 e versioni precedenti:

• https://pypi.python.org/pypi/backports.shutil_get_terminal_size

uso

import console
(width, height) = console.getTerminalSize()

print "Your terminal's width is: %d" % width

EDIT : oh, mi dispiace. Non è un lib lib standard di Python, ecco la fonte di console.py (non so da dove provenga).

Il modulo sembra funzionare in questo modo: controlla se termcapè disponibile, quando sì. Lo usa; se no controlla se il terminale supporta una ioctlchiamata speciale e anche se non funziona, controlla le variabili d'ambiente che alcune shell esportano per quello. Questo probabilmente funzionerà solo su UNIX.

def getTerminalSize():
    import os
    env = os.environ
    def ioctl_GWINSZ(fd):
        try:
            import fcntl, termios, struct, os
            cr = struct.unpack('hh', fcntl.ioctl(fd, termios.TIOCGWINSZ,
        '1234'))
        except:
            return
        return cr
    cr = ioctl_GWINSZ(0) or ioctl_GWINSZ(1) or ioctl_GWINSZ(2)
    if not cr:
        try:
            fd = os.open(os.ctermid(), os.O_RDONLY)
            cr = ioctl_GWINSZ(fd)
            os.close(fd)
        except:
            pass
    if not cr:
        cr = (env.get('LINES', 25), env.get('COLUMNS', 80))

        ### Use get(key[, default]) instead of a try/catch
        #try:
        #    cr = (env['LINES'], env['COLUMNS'])
        #except:
        #    cr = (25, 80)
    return int(cr[1]), int(cr[0])

Il codice sopra non ha restituito il risultato corretto sul mio Linux perché winsize-struct ha 4 short senza segno, non 2 short con segno:

def terminal_size():
    import fcntl, termios, struct
    h, w, hp, wp = struct.unpack('HHHH',
        fcntl.ioctl(0, termios.TIOCGWINSZ,
        struct.pack('HHHH', 0, 0, 0, 0)))
    return w, h

hp e hp dovrebbero contenere la larghezza e l'altezza dei pixel, ma non lo fanno.

Ho cercato e trovato una soluzione per Windows su:

http://code.activestate.com/recipes/440694-determine-size-of-console-window-on-windows/

e una soluzione per Linux qui.

Quindi ecco una versione che funziona sia su Linux, OS X sia su Windows / Cygwin:

""" getTerminalSize()
 - get width and height of console
 - works on linux,os x,windows,cygwin(windows)
"""

__all__=['getTerminalSize']


def getTerminalSize():
   import platform
   current_os = platform.system()
   tuple_xy=None
   if current_os == 'Windows':
       tuple_xy = _getTerminalSize_windows()
       if tuple_xy is None:
          tuple_xy = _getTerminalSize_tput()
          # needed for window's python in cygwin's xterm!
   if current_os == 'Linux' or current_os == 'Darwin' or  current_os.startswith('CYGWIN'):
       tuple_xy = _getTerminalSize_linux()
   if tuple_xy is None:
       print "default"
       tuple_xy = (80, 25)      # default value
   return tuple_xy

def _getTerminalSize_windows():
    res=None
    try:
        from ctypes import windll, create_string_buffer

        # stdin handle is -10
        # stdout handle is -11
        # stderr handle is -12

        h = windll.kernel32.GetStdHandle(-12)
        csbi = create_string_buffer(22)
        res = windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
    except:
        return None
    if res:
        import struct
        (bufx, bufy, curx, cury, wattr,
         left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
        sizex = right - left + 1
        sizey = bottom - top + 1
        return sizex, sizey
    else:
        return None

def _getTerminalSize_tput():
    # get terminal width
    # src: http://stackoverflow.com/questions/263890/how-do-i-find-the-width-height-of-a-terminal-window
    try:
       import subprocess
       proc=subprocess.Popen(["tput", "cols"],stdin=subprocess.PIPE,stdout=subprocess.PIPE)
       output=proc.communicate(input=None)
       cols=int(output[0])
       proc=subprocess.Popen(["tput", "lines"],stdin=subprocess.PIPE,stdout=subprocess.PIPE)
       output=proc.communicate(input=None)
       rows=int(output[0])
       return (cols,rows)
    except:
       return None


def _getTerminalSize_linux():
    def ioctl_GWINSZ(fd):
        try:
            import fcntl, termios, struct, os
            cr = struct.unpack('hh', fcntl.ioctl(fd, termios.TIOCGWINSZ,'1234'))
        except:
            return None
        return cr
    cr = ioctl_GWINSZ(0) or ioctl_GWINSZ(1) or ioctl_GWINSZ(2)
    if not cr:
        try:
            fd = os.open(os.ctermid(), os.O_RDONLY)
            cr = ioctl_GWINSZ(fd)
            os.close(fd)
        except:
            pass
    if not cr:
        try:
            cr = (env['LINES'], env['COLUMNS'])
        except:
            return None
    return int(cr[1]), int(cr[0])

if __name__ == "__main__":
    sizex,sizey=getTerminalSize()
    print  'width =',sizex,'height =',sizey

O è:

import os
columns, rows = os.get_terminal_size(0)
# or
import shutil
columns, rows = shutil.get_terminal_size()

La shutilfunzione è solo un wrapper attorno a osuno che rileva alcuni errori e imposta un fallback, tuttavia ha un enorme avvertimento: si rompe durante il piping! , che è un affare abbastanza grande.
Per ottenere invece le dimensioni del terminale quando si utilizzano le tubazioni os.get_terminal_size(0).

Il primo argomento 0è un argomento che indica che è necessario utilizzare il descrittore di file stdin anziché lo stdout predefinito. Vogliamo usare stdin perché stdout si stacca da solo quando viene convogliato, il che in questo caso genera un errore.

Ho provato a capire quando avrebbe senso usare stdout invece dell'argomento stdin e non ho idea del perché sia ​​un valore predefinito qui.

A partire da Python 3.3 è semplice: https://docs.python.org/3/library/os.html#querying-the-size-of-a-terminal

>>> import os
>>> ts = os.get_terminal_size()
>>> ts.lines
24
>>> ts.columns
80

Sembra che ci siano alcuni problemi con quel codice, Johannes:

• getTerminalSize deve import os
• che cos'è env? sembra os.environ.

Inoltre, perché cambiare linese colsprima di tornare? Se TIOCGWINSZed sttyentrambi dicono linesallora cols, io dico di lasciarlo così. Questo mi ha confuso per ben 10 minuti prima di notare l'incoerenza.

Sridhar, non ho riscontrato quell'errore quando ho inviato l'output. Sono abbastanza sicuro che sia stato catturato correttamente nel tentativo-tranne.

Pascal, "HHHH"non funziona sulla mia macchina, ma "hh"funziona. Ho avuto difficoltà a trovare la documentazione per quella funzione. Sembra che dipende dalla piattaforma.

chochem, incorporato.

Ecco la mia versione:

def getTerminalSize():
    """
    returns (lines:int, cols:int)
    """
    import os, struct
    def ioctl_GWINSZ(fd):
        import fcntl, termios
        return struct.unpack("hh", fcntl.ioctl(fd, termios.TIOCGWINSZ, "1234"))
    # try stdin, stdout, stderr
    for fd in (0, 1, 2):
        try:
            return ioctl_GWINSZ(fd)
        except:
            pass
    # try os.ctermid()
    try:
        fd = os.open(os.ctermid(), os.O_RDONLY)
        try:
            return ioctl_GWINSZ(fd)
        finally:
            os.close(fd)
    except:
        pass
    # try `stty size`
    try:
        return tuple(int(x) for x in os.popen("stty size", "r").read().split())
    except:
        pass
    # try environment variables
    try:
        return tuple(int(os.getenv(var)) for var in ("LINES", "COLUMNS"))
    except:
        pass
    # i give up. return default.
    return (25, 80)

Molte delle implementazioni di Python 2 qui falliranno se non c'è un terminale di controllo quando si chiama questo script. Puoi controllare sys.stdout.isatty () per determinare se si tratta effettivamente di un terminale, ma ciò escluderà un sacco di casi, quindi credo che il modo più pitonico per capire la dimensione del terminale sia usare il pacchetto curses incorporato.

import curses
w = curses.initscr()
height, width = w.getmaxyx()

Stavo provando la soluzione da qui che chiama stty size:

columns = int(subprocess.check_output(['stty', 'size']).split()[1])

Tuttavia, ciò non è riuscito per me perché stavo lavorando a uno script che prevede input reindirizzati su stdin e sttyin questo caso si lamenterebbe che "stdin non è un terminale".

Sono stato in grado di farlo funzionare in questo modo:

with open('/dev/tty') as tty:
    height, width = subprocess.check_output(['stty', 'size'], stdin=tty).split()

Prova le "benedizioni"

Stavo cercando la stessa cosa. È molto facile da usare e offre strumenti per colorare, disegnare e posizionare nel terminale. Quello di cui hai bisogno è facile come:

from blessings import Terminal

t = Terminal()

w = t.width
h = t.height

Funziona come un fascino in Linux. (Non sono sicuro di MacOSX e Windows)

Scarica e documentazione qui

oppure puoi installarlo con pip:

pip install blessings

La risposta di @ reannual funziona bene, ma c'è un problema: os.popen è ora obsoleta . Il subprocessmodulo dovrebbe essere usato invece, quindi ecco una versione del codice di @ reannual che usa subprocesse risponde direttamente alla domanda (dando la larghezza della colonna direttamente come int:

import subprocess

columns = int(subprocess.check_output(['stty', 'size']).split()[1])

Testato su OS X 10.9

Se stai usando Python 3.3 o versioni successive, consiglierei il built-in get_terminal_size()come già raccomandato. Tuttavia, se sei bloccato con una versione precedente e desideri un modo semplice e multipiattaforma per farlo, potresti usare asciimatics . Questo pacchetto supporta le versioni di Python fino alla 2.7 e utilizza opzioni simili a quelle suggerite sopra per ottenere le dimensioni correnti del terminale / console.

Costruisci semplicemente la tua Screenclasse e usa la dimensionsproprietà per ottenere l'altezza e la larghezza. Questo ha dimostrato di funzionare su Linux, OSX e Windows.

Oh, e completa divulgazione qui: io sono l'autore, quindi non esitare ad aprire un nuovo numero se hai problemi a farlo funzionare.

Ecco una versione che dovrebbe essere compatibile con Linux e Solaris. Sulla base di messaggi e commenti da madchine . Richiede il modulo di sottoprocesso.

def termsize ():
    import shlex, subprocess, re
    output = subprocess.check_output (shlex.split ('/ bin / stty -a'))
    m = re.search ('righe \ D + (? P \ d +); colonne \ D + (? P \ d +);', output)
    se m:
        return m.group ('file'), m.group ('colonne')
    aumentare OSError ('Risposta errata:% s'% (output))

>>> termsize ()
('40', '100')