Cách lấy chiều rộng cửa sổ bảng điều khiển Linux bằng Python

Có cách nào trong python để lập trình xác định chiều rộng của giao diện điều khiển không? Tôi có nghĩa là số lượng ký tự phù hợp trong một dòng mà không gói, không phải chiều rộng pixel của cửa sổ.

Biên tập

Tìm kiếm một giải pháp hoạt động trên Linux

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

sử dụng lệnh 'stty size' mà theo một luồng trong danh sách gửi thư python là phổ biến hợp lý trên linux. Nó mở lệnh 'stty size' dưới dạng tệp, 'đọc' từ nó và sử dụng một chuỗi tách đơn giản để tách tọa độ.

Không giống như giá trị os.envir ["COLUMNS"] (mà tôi không thể truy cập mặc dù sử dụng bash làm vỏ tiêu chuẩn của mình), dữ liệu cũng sẽ được cập nhật trong khi tôi tin rằng os.envir ["COLUMNS"] giá trị sẽ chỉ có hiệu lực trong thời gian khởi chạy trình thông dịch python (giả sử người dùng đã thay đổi kích thước cửa sổ kể từ đó).

(Xem câu trả lời của @GringoSuave về cách thực hiện việc này trên python 3.3+)

Không chắc chắn tại sao nó nằm trong mô-đun shutil, nhưng nó đã hạ cánh ở đó trong Python 3.3, Truy vấn kích thước của thiết bị đầu cuối đầu ra :

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

Một triển khai cấp thấp là trong mô-đun os. Cũng hoạt động trong Windows.

Một backport hiện có sẵn cho Python 3.2 trở xuống:

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

sử dụng

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

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

EDIT : oh, tôi xin lỗi. Đó không phải là một lib python tiêu chuẩn, đây là nguồn của console.py (Tôi không biết nó đến từ đâu).

Các mô-đun dường như hoạt động như thế: Nó kiểm tra nếu termcapcó sẵn, khi có. Nó sử dụng điều đó; nếu không, nó sẽ kiểm tra xem thiết bị đầu cuối có hỗ trợ một ioctlcuộc gọi đặc biệt hay không và nó cũng không hoạt động, nó sẽ kiểm tra các biến môi trường mà một số shell xuất cho điều đó. Điều này có lẽ sẽ chỉ hoạt động trên 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])

Mã ở trên không trả về kết quả chính xác trên linux của tôi vì winize-struct có 4 quần short không dấu, không phải 2 quần short có chữ ký:

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 và hp nên chứa chiều rộng và chiều cao pixel, nhưng không.

Tôi đã tìm kiếm xung quanh và tìm thấy một giải pháp cho các cửa sổ tại:

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

và một giải pháp cho linux ở đây.

Vì vậy, đây là phiên bản hoạt động cả trên linux, os x và 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

Đó cũng là:

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

Các shutil chức năng chỉ là một wrapper xung quanh osmột mà bắt một số lỗi và thiết lập một dự phòng, tuy nhiên nó có một ngoại khổng lồ - nó phá vỡ khi đường ống! , đó là một thỏa thuận khá lớn.
Để có được kích thước thiết bị đầu cuối khi sử dụng đường ống os.get_terminal_size(0)thay thế.

Đối số đầu tiên 0là một đối số chỉ ra rằng bộ mô tả tệp stdin nên được sử dụng thay vì thiết bị xuất chuẩn mặc định. Chúng tôi muốn sử dụng stdin vì thiết bị xuất chuẩn sẽ tự tách ra khi nó đang được xử lý trong trường hợp này gây ra lỗi.

Tôi đã cố gắng tìm ra khi nào nên sử dụng thiết bị xuất chuẩn thay vì đối số stdin và không biết tại sao nó lại mặc định ở đây.

Bắt đầu từ Python 3.3, nó rất đơn giản: https://docs.python.org/3/l Library / os.html # querying-the-size-of-a-termminal

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

Có vẻ như có một số vấn đề với mã đó, Johannes:

• getTerminalSize cần phải import os
• là envgì vẻ thích os.environ.

Ngoài ra, tại sao chuyển đổi linesvà colstrước khi trở về? Nếu TIOCGWINSZvà sttycả hai nói linesthìcols , tôi nói hãy để nó như vậy. Điều này làm tôi bối rối trong 10 phút trước khi tôi nhận thấy sự không nhất quán.

Sridhar, tôi đã không nhận được lỗi đó khi tôi đầu ra. Tôi khá chắc chắn rằng nó đã bị bắt đúng cách trong thử - ngoại trừ.

pascal, "HHHH"không hoạt động trên máy của tôi, nhưng"hh" không. Tôi gặp khó khăn khi tìm tài liệu cho chức năng đó. Có vẻ như nó phụ thuộc vào nền tảng.

choool, kết hợp.

Đây là phiên bản của tôi:

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)

Nhiều triển khai Python 2 ở đây sẽ thất bại nếu không có thiết bị đầu cuối kiểm soát khi bạn gọi tập lệnh này. Bạn có thể kiểm tra sys.stdout.isatty () để xác định xem đây có thực sự là một thiết bị đầu cuối hay không, nhưng điều đó sẽ loại trừ một loạt các trường hợp, vì vậy tôi tin rằng cách pythonic nhất để tìm ra kích thước thiết bị đầu cuối là sử dụng gói lời nguyền dựng sẵn.

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

Tôi đã thử giải pháp từ đây mà gọi stty size:

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

Tuy nhiên điều này không thành công đối với tôi vì tôi đang làm việc với một kịch bản mong đợi đầu vào được chuyển hướng trên stdin và stty sẽ phàn nàn rằng "stdin không phải là thiết bị đầu cuối" trong trường hợp đó.

Tôi đã có thể làm cho nó hoạt động như thế này:

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

Hãy thử "phước lành"

Tôi đã tìm kiếm điều tương tự. Nó rất dễ sử dụng và cung cấp các công cụ để tô màu, tạo kiểu và định vị trong thiết bị đầu cuối. Những gì bạn cần là dễ dàng như:

from blessings import Terminal

t = Terminal()

w = t.width
h = t.height

Hoạt động như một cơ duyên trong Linux. (Tôi không chắc chắn về MacOSX và Windows)

Tải về và tài liệu tại đây

hoặc bạn có thể cài đặt nó với pip:

pip install blessings

Câu trả lời của @ reannual hoạt động tốt, nhưng có một vấn đề với nó: os.popen hiện không được chấp nhận . Các subprocessmô-đun nên được sử dụng thay vào đó, vì vậy đây là một phiên bản của mã @ reannual rằng sử dụng subprocessvà trực tiếp trả lời câu hỏi (bằng cách cho chiều rộng cột trực tiếp như một int:

import subprocess

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

Đã thử nghiệm trên OS X 10.9

Nếu bạn đang sử dụng Python 3.3 trở lên, tôi khuyên bạn nên tích hợp sẵn get_terminal_size()như đã đề xuất. Tuy nhiên, nếu bạn bị mắc kẹt với một phiên bản cũ hơn và muốn một cách đơn giản, đa nền tảng để làm điều này, bạn có thể sử dụng asciimatics . Gói này hỗ trợ các phiên bản Python trở lại 2.7 và sử dụng các tùy chọn tương tự như các tùy chọn được đề xuất ở trên để có được kích thước thiết bị đầu cuối / bảng điều khiển hiện tại.

Đơn giản chỉ cần xây dựng của bạn Screen lớp và sử dụng thuộc dimensionstính để có được chiều cao và chiều rộng. Điều này đã được chứng minh là hoạt động trên Linux, OSX và Windows.

Ồ - và tiết lộ đầy đủ ở đây: Tôi là tác giả, vì vậy xin vui lòng mở một vấn đề mới nếu bạn có bất kỳ vấn đề nào để làm việc này.

Đây là một phiên bản nên tương thích với Linux và Solaris. Dựa trên các bài viết và cam kết từ madchine . Yêu cầu mô đun quy trình con.

def thuật ngữ ():
    nhập shlex, quy trình con, tái
    đầu ra = sub process.checkDefput (shlex.split ('/ bin / stty -a'))
    m = re.search ('hàng \ D + (? P \ d +); cột \ D + (? P \ d +);', đầu ra)
    nếu m:
        trả về m.group ('hàng'), m.group ('cột')
    nâng OSError ('Phản hồi xấu:% s'% (đầu ra))

>>> điều khoản ()
('40 ',' 100 ')