Como obter a largura da janela do console Linux em Python

Existe uma maneira em python para determinar programaticamente a largura do console? Quero dizer o número de caracteres que cabe em uma linha sem quebra automática, não a largura de pixel da janela.

Editar

Procurando uma solução que funcione no Linux

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

usa o comando 'stty size' que de acordo com um thread na lista de discussão python é razoavelmente universal no linux. Ele abre o comando 'stty size' como um arquivo, 'lê' a partir dele e usa uma divisão simples de string para separar as coordenadas.

Diferente do valor os.environ ["COLUMNS"] (que não consigo acessar, apesar de usar o bash como meu shell padrão), os dados também estarão atualizados, enquanto acredito que o os.environ ["COLUMNS"] O valor seria válido apenas durante o lançamento do interpretador python (suponha que o usuário redimensione a janela desde então).

(Veja a resposta de @GringoSuave sobre como fazer isso no python 3.3+)

Não sei por que ele está no módulo shutil, mas foi parar no Python 3.3, Consultando o tamanho do terminal de saída :

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

Uma implementação de baixo nível está no módulo os. Também funciona no Windows.

Um backport está agora disponível para Python 3.2 e abaixo:

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

usar

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

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

EDIT : oh, me desculpe. Essa não é uma lib padrão do python, aqui está a fonte do console.py (não sei de onde é).

O módulo parece funcionar assim: verifica se termcapestá disponível, quando sim. Ele usa isso; caso contrário, verifica se o terminal suporta uma ioctlchamada especial e também não funciona, verifica as variáveis ​​de ambiente que alguns shells exportam para isso. Provavelmente isso funcionará apenas no 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])

O código acima não retornou o resultado correto no meu linux porque o winsize-struct possui 4 shorts não assinados, não 2 shorts assinados:

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 devem conter largura e altura de pixel, mas não.

Eu procurei e encontrei uma solução para o Windows em:

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

e uma solução para linux aqui.

Então, aqui está uma versão que funciona tanto em linux, os x quanto 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

Também é:

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

A shutilfunção é apenas um invólucro em torno de osum que detecta alguns erros e configura um fallback, no entanto, possui uma grande ressalva - ela quebra ao canalizar! , o que é um grande negócio.
Para obter o tamanho do terminal ao usar a tubulação os.get_terminal_size(0).

Primeiro argumento 0 é um argumento indicando que o descritor de arquivo stdin deve ser usado em vez do stdout padrão. Queremos usar o stdin porque o stdout se desconecta quando está sendo canalizado, o que nesse caso gera um erro.

Eu tentei descobrir quando faria sentido usar o argumento stdout em vez do argumento stdin e não faço idéia do por que é um padrão aqui.

A partir do Python 3.3, é simples: 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

Parece que há alguns problemas com esse código, Johannes:

• getTerminalSize precisa de import os
• o que é env? parece os.environ.

Além disso, por que mudar linese colsantes de retornar? Se TIOCGWINSZe os sttydois dizem linesentão cols, digo assim. Isso me confundiu por uns bons 10 minutos antes de eu notar a inconsistência.

Sridhar, não recebi esse erro quando canalizei a saída. Tenho certeza de que está sendo capturado corretamente na tentativa, exceto.

pascal, "HHHH"não funciona na minha máquina, mas "hh"funciona. Eu tive problemas para encontrar documentação para essa função. Parece que depende da plataforma.

chochem, incorporado.

Aqui está a minha versão:

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)

Muitas das implementações do Python 2 aqui falharão se não houver um terminal de controle quando você chamar esse script. Você pode verificar sys.stdout.isatty () para determinar se esse é realmente um terminal, mas isso excluirá muitos casos, portanto, acredito que a maneira mais pitônica de descobrir o tamanho do terminal é usar o pacote de maldições embutido.

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

Eu estava tentando a solução daqui que chama stty size:

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

No entanto, isso falhou para mim porque eu estava trabalhando em um script que espera uma entrada redirecionada no stdin e sttyqueixaria-me de que "stdin não é um terminal" nesse caso.

Consegui fazê-lo funcionar assim:

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

Tente "bênçãos"

Eu estava procurando a mesma coisa. É muito fácil de usar e oferece ferramentas para colorir, modelar e posicionar no terminal. O que você precisa é tão fácil quanto:

from blessings import Terminal

t = Terminal()

w = t.width
h = t.height

Funciona como um encanto no Linux. (Não tenho certeza sobre o MacOSX e o Windows)

Download e documentação aqui

ou você pode instalá-lo com o pip:

pip install blessings

A resposta do @ reannual funciona bem, mas há um problema: os.popen agora está obsoleto . O subprocessmódulo deve ser usado, então aqui está uma versão do código do @ reannual que usa subprocesse responde diretamente à pergunta (fornecendo a largura da coluna diretamente como int:

import subprocess

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

Testado no OS X 10.9

Se você estiver usando o Python 3.3 ou superior, recomendo o built-in get_terminal_size()como já recomendado. No entanto, se você está preso a uma versão mais antiga e deseja uma maneira simples e multiplataforma de fazer isso, pode usar asciimatics . Este pacote suporta versões do Python de volta para 2.7 e usa opções semelhantes às sugeridas acima para obter o tamanho atual do terminal / console.

Simplesmente construa sua Screenclasse e use a dimensionspropriedade para obter a altura e a largura. Está provado que funciona no Linux, OSX e Windows.

Ah - e divulgação completa aqui: eu sou o autor, por isso, sinta-se à vontade para abrir uma nova edição, se você tiver algum problema para fazer isso funcionar.

Aqui está uma versão que deve ser compatível com Linux e Solaris. Baseado nos posts e comentários de madchine . Requer o módulo de subprocesso.

def termsize ():
    importar shlex, subprocesso, re
    saída = subprocess.check_output (shlex.split ('/ bin / stty -a'))
    m = re.search ('linhas \ D + (? P \ d +); colunas \ D + (? P \ d +);', saída)
    se m:
        retornar m.group ('linhas'), m.group ('colunas')
    aumentar OSError ('Resposta incorreta:% s'% (saída))

>>> termosize ()
('40', '100')