如何在Python中获取Linux控制台窗口宽度

python中有没有办法以编程方式确定控制台的宽度？我的意思是不换行就适合一行的字符数，而不是窗口的像素宽度。

编辑

寻找适用于Linux的解决方案

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

使用“ stty size”命令，该命令根据python邮件列表上的线程在linux上相当普遍。它以文件形式打开“ stty size”命令，并从中“读取”，并使用简单的字符串拆分来分隔坐标。

与os.environ [“ COLUMNS”]值（尽管使用bash作为我的标准Shell不能访问）不同，数据也将是最新的，而我相信os.environ [“ COLUMNS”]该值仅在python解释器启动时有效（假设从那时起用户调整了窗口的大小）。

（有关如何在python 3.3+上执行此操作，请参见@GringoSuave的回答）

不知道为什么它在模块中shutil，但是它在Python 3.3中降落在那里，查询输出终端的大小：

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

os模块中有一个底层实现。在Windows中也可以使用。

反向移植现在可用于Python 3.2及以下版本：

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

用

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

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

编辑：哦，对不起。那不是python标准库，这是console.py的来源（我不知道它来自哪里）。

该模块似乎像这样工作：检查是否termcap可用，何时可用。它使用它；如果不是，它将检查终端是否支持特殊ioctl调用，并且该调用也不起作用，它将检查某些shell为此导出的环境变量。这可能仅适用于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])

上面的代码未在我的Linux上返回正确的结果，因为winsize-struct有4条未签名的短裤，而不是2条已签名的短裤：

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和hp应该包含像素的宽度和高度，但不包含。

我四处搜寻，找到了Windows的解决方案：

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

以及适用于Linux的解决方案。

所以这是一个可以在linux，os x和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

要么是：

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

该shutil函数只是一个包装器，os可以捕获一些错误并设置后备功能，但是它有一个巨大的警告- 在管道传输时会中断！，这是一笔不小的数目。
要获得配管时的端子尺寸，请os.get_terminal_size(0)改用。

第一个参数0是指示应使用stdin文件描述符而不是默认stdout的参数。我们要使用stdin，因为stdout在被管道传输时会自行分离，在这种情况下会引发错误。

我试图弄清楚什么时候使用stdout代替stdin参数有意义，并且不知道为什么它是默认值。

从Python 3.3开始，它很简单：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

该代码Johannes似乎有一些问题：

• getTerminalSize 需要 import os
• 是什么env？看起来像os.environ。

另外，为什么要切换lines和cols返回之前？如果TIOCGWINSZ并且stty都说lines那么cols，我说就这样吧。在我注意到不一致之前，这使我困惑了10分钟。

Sridhar，通过管道输出时没有出现该错误。我很确定它会被try-except正确捕获。

pascal，"HHHH"在我的机器上"hh"不起作用，但是可以。我在查找该功能的文档时遇到了麻烦。看起来它与平台有关。

chochem，注册成立。

这是我的版本：

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)

如果在调用此脚本时没有控制终端，则此处的许多Python 2实现将失败。您可以检查sys.stdout.isatty（）来确定这是否实际上是一个终端，但这将排除一堆情况，因此我认为找出终端大小的最有效方法是使用内置的curses包。

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

我正在尝试从此处调用的解决方案stty size：

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

但是，这对我来说失败了，因为我正在处理一个脚本，该脚本期望stdin上的重定向输入，并且stty在这种情况下会抱怨“ stdin不是终端”。

我能够使它像这样工作：

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

@reannual的答案很好用，但是有一个问题：os.popen 现在已弃用。该subprocess模块应改为使用，所以这里的@ reannual的代码，使用一个版本subprocess，直接回答了这个问题（通过直接向列宽为int：

import subprocess

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

在OS X 10.9上测试

尝试“祝福”

我一直在寻找同样的东西。它非常易于使用，并提供用于在终端上进行着色，样式和定位的工具。您所需要的很简单：

from blessings import Terminal

t = Terminal()

w = t.width
h = t.height

在Linux中像灵符一样工作。（我不确定MacOSX和Windows）

在此处下载和文档

或者您可以使用pip安装它：

pip install blessings

如果您使用的是Python 3.3或更高版本，建议您get_terminal_size()按照已推荐的内置方法进行操作。但是，如果您坚持使用较旧的版本，并希望通过一种简单的跨平台方法来执行此操作，则可以使用asciimatics。该软件包支持Python 2.7之前的版本，并使用与上面建议的选项类似的选项来获取当前的终端/控制台大小。

只需构造您的Screen类并使用该dimensions属性即可获取高度和宽度。它已被证明可以在Linux，OSX和Windows上运行。

哦，这里有完整的披露：我是作者，因此，如果您有任何疑问，请随时打开一个新期刊。

这是应该与Linux和Solaris兼容的版本。基于madchine的帖子和评论。需要子流程模块。

def termsize（）：
    导入shlex，子流程，重新
    输出= subprocess.check_output（shlex.split（'/ bin / stty -a'））
    m = re.search（'rows \ D +（？P \ d +）; column \ D +（？P \ d +）;'，输出）
    如果m：
        返回m.group（'rows'），m.group（'columns'）
    引发OSError（'错误响应：％s'％（输出））

>>> termize（）
（“ 40”，“ 100”）