Очистить терминал в Python

Существует ли какой-либо стандартный метод "поставляется с батареями", чтобы очистить экран терминала от скрипта Python, или мне нужно проклинать (библиотеки, а не слова)?

ОТВЕТЫ

Ответ 1

Как насчет escape-последовательностей?

print(chr(27) + "[2J")

Ответ 2

Простым и кросс-платформенным решением будет использование либо команды cls в Windows, либо clear в Unix-системах. Используется с os.system, это делает приятный однострочный:

import os
os.system('cls' if os.name == 'nt' else 'clear')

Ответ 3

Почему никто не говорил о простом выполнении Ctrl + L в Windows или Cmd + L в Mac. Наверняка самый простой способ очистки экрана.

Ответ 4

Если вы находитесь в системе Linux/UNIX, тогда печать escape-последовательности ANSI для очистки экрана должна выполнять задание. Вы также хотите переместить курсор в верхнюю часть экрана. Это будет работать на любом терминале, поддерживающем ANSI.

import sys
sys.stderr.write("\x1b[2J\x1b[H")

Это не будет работать в Windows, если поддержка ANSI не включена. Для Windows может быть эквивалентная последовательность управления, но я не знаю.

Ответ 5

Для Windows, Mac и Linux вы можете использовать следующий код:

import subprocess, platform

if platform.system()=="Windows":
    subprocess.Popen("cls", shell=True).communicate() #I like to use this instead of subprocess.call since for multi-word commands you can just type it out, granted this is just cls and subprocess.call should work fine 
else: #Linux and Mac
    print("\033c", end="")

jamesnotjim протестировал print("\033c", end="") для Mac, и я протестировал его на Linux и Windows (он не работает для Windows, поэтому другой код вызывает cls). Я не помню, кто это был, я впервые увидел использование print ("\ 033c") и/или версию printf: subprocess.Popen("printf '\033c'", shell=True).communicate().

Ролика отметил, что end="" не позволит печатать новую строку после этого.

Ответ 6

Что касается меня, самый элегантный вариант:

import os
os.system('cls||clear')

Ответ 7

Вы можете попытаться полагаться на ясный, но он может быть недоступен во всех дистрибутивах Linux. В окнах используйте cls, как вы указали.

import subprocess
import platform

def clear():
    subprocess.Popen( "cls" if platform.system() == "Windows" else "clear", shell=True)

clear()

Примечание. Это может считаться плохой формой для управления экраном терминала. Рассматриваете ли вы вариант? Вероятно, лучше было бы позволить пользователю решить, хочет ли он очистить экран.

Ответ 8

Решение Pure Python.
Не полагается ни на ANSI, ни на внешние команды.
Только ваш терминал должен иметь возможность рассказать вам, сколько строк находится в поле зрения.

from shutil import get_terminal_size
print("\n" * get_terminal_size().lines, end='')

версия Python >= 3.3.0

Ответ 9

Пришло какое-то время назад

def clearscreen(numlines=100):
  """Clear the console.
numlines is an optional argument used only as a fall-back.
"""
# Thanks to Steven D'Aprano, http://www.velocityreviews.com/forums

  if os.name == "posix":
    # Unix/Linux/MacOS/BSD/etc
    os.system('clear')
  elif os.name in ("nt", "dos", "ce"):
    # DOS/Windows
    os.system('CLS')
  else:
    # Fallback for other operating systems.
    print('\n' * numlines)

Затем просто используйте clearscreen()

Ответ 10

Так что просто подумал, что я бросу свои два цента здесь...

Похоже, никто не дал верного ответа на вопрос OP, каждый либо отвечает "НЕ ИСПОЛЬЗУЙТЕ os.system() it evil !!!" без объяснения причин или предоставляет решение, которое опирается на печать новых строк.

Для тех, кому необходимо очистить экран терминала и прокрутить назад, по любой причине, вы можете использовать следующий код:

import os

def clear():
    '''
    Clears the terminal screen and scroll back to present
    the user with a nice clean, new screen. Useful for managing
    menu screens in terminal applications.
    '''
    os.system('cls' if os.name == 'nt' else 'echo -e \\\\033c')

print('A bunch of garbage so we can garble up the screen...')
clear()

# Same effect, less characters...

def clear():
    '''
    Clears the terminal screen and scroll back to present
    the user with a nice clean, new screen. Useful for managing
    menu screens in terminal applications.
    '''
    os.system('cls||echo -e \\\\033c')

Это дает желаемый эффект. Он использует команду os.system(), поэтому, если это зло и кто-то знает способ реализовать это с помощью subprocess.call(), пожалуйста, прокомментируйте, поскольку я также предпочел бы использовать подпроцесс, но совсем не знаком с ним.

Ответ 11

Просто используйте:

print("\033c")

Это очистит окно терминала.

Ответ 12

Это будет работать в обеих версиях Python2 ИЛИ Python3

print (u"{}[2J{}[;H".format(chr(27), chr(27)))

Ответ 13

Эта функция работает в gnome-terminal, потому что по умолчанию она распознает escape-последовательности ANSI. Это дает вам расстояние CLEAN PROMPT rows_max от нижней части терминала, но также точно от того, где оно было вызвано. Дает вам полный контроль над тем, как очистить.

def clear(rows=-1, rows_max=None, *, calling_line=True, absolute=None,
          store_max=[]):
    """clear(rows=-1, rows_max=None)
clear(0, -1) # Restore auto-determining rows_max
clear(calling_line=False) # Don't clear calling line
clear(absolute=5) # Absolutely clear out to 5 rows up"""
    from os import linesep
    if rows_max and rows_max != -1:
        store_max[:] = [rows_max, False]
    elif not store_max or store_max[1] or rows_max == -1 or absolute:
        try:
            from shutil import get_terminal_size
            columns_max, rows_max = get_terminal_size()
        except ImportError:
            columns_max, rows_max = 80, 24
        if absolute is None:
            store_max[:] = [rows_max, True]
    if store_max:
        if rows == -1:
            rows = store_max[0]
        elif isinstance(rows, float):
            rows = round(store_max[0] * rows)
        if rows > store_max[0] - 2:
            rows = store_max[0] - 2
    if absolute is None:
        s = ('\033[1A' + ' ' * 30 if calling_line else '') + linesep * rows
    else:
        s = '\033[{}A'.format(absolute + 2) + linesep
        if absolute > rows_max - 2:
            absolute = rows_max - 2
        s += (' ' * columns_max + linesep) * absolute + ' ' * columns_max
        rows = absolute
    print(s + '\033[{}A'.format(rows + 1))

Реализация:

clear() # Clear all, TRIES to automatically get terminal height
clear(800, 24) # Clear all, set 24 as terminal (max) height
clear(12) # Clear half of terminal below if 24 is its height
clear(1000) # Clear to terminal height - 2 (24 - 2)
clear(0.5) # float factor 0.0 - 1.0 of terminal height (0.5 * 24 = 12)
clear() # Clear to rows_max - 2 of user given rows_max (24 - 2)
clear(0, 14) # Clear line, reset rows_max to half of 24 (14-2)
clear(0) # Just clear the line
clear(0, -1) # Clear line, restore auto-determining rows_max
clear(calling_line=False) # Clear all, don't clear calling line
clear(absolute=5) # Absolutely clear out to 5 rows up

Параметры: rows - количество строк четкого текста, которые можно добавить между подсказкой и нижней частью терминала, подталкивая все. rows_max - высота терминала (или максимальная высота выравнивания) в текстовых строках и должна быть установлена ​​только один раз, но может быть reset в любое время. *, в третьей позиции параметра означает, что все следующие параметры имеют только ключевое слово (например, clear (absolute = 5)). calling_line=True (по умолчанию) работает лучше в интерактивном режиме. calling_line=False работает лучше для текстовых, терминальных приложений. absolute был добавлен, чтобы попытаться исправить проблемы с зазором в режиме Interactive после уменьшения размера терминала, но также можно использовать для терминальных приложений. store_max предназначен только для секретного, "постоянного" хранения значения rows_max; явно не используйте этот параметр. (Если аргумент не передан для store_max, изменение содержимого списка store_max изменяет значение этого параметра по умолчанию. Следовательно, постоянное хранилище.)

Переносимость: Извините, это не работает в IDLE, но работает → VERY COOL < < в интерактивном режиме в терминале (консоли), который распознает escape-последовательности ANSI. Я тестировал это только в Ubuntu 13.10, используя Python 3.3 в gnome-terminal. Поэтому я могу предположить, что переносимость зависит от Python 3.3 (для функции shutil.get_terminal_size() для результатов BEST) и распознавания ANSI. Функция print(...) - это Python 3. Я также проверил это с помощью простой текстовой платформы Tic Tac Toe (приложение).

Для использования в интерактивном режиме: Сначала скопируйте и вставьте функцию copy(...) в интерактивный режим и посмотрите, работает ли она для вас. Если это так, добавьте указанную выше функцию в файл с именем clear.py. В терминале запускается python, с 'python3'. Введите:

>>> import sys
>>> sys.path
['', '/usr/lib/python3.3', ...

Теперь отпустите файл clear.py в один из перечисленных ниже каталогов path, чтобы Python мог его найти (не перезаписывайте существующие файлы). Чтобы легко использовать с этого момента:

>>> from clear import clear
>>> clear()
>>> print(clear.__doc__)
clear(rows=-1, rows_max=None)
clear(0, -1) # Restore auto-determining rows_max
clear(calling_line=False) # Don't clear calling line
clear(absolute=5) # Absolutely clear out to 5 rows up

Для использования в терминальном приложении: Поместите функцию copy(...) в файл с именем clear.py в той же папке с вашим файлом main.py. Вот пример работы с абстрактным (скелетом) из приложения игры Tic Tac Toe (запуск из командной строки: python3 tictactoe.py):

from os import linesep

class TicTacToe:    
    def __init__(self):
        # Clear screen, but not calling line
        try:
            from clear import clear
            self.clear = clear
            self.clear(calling_line=False)
        except ImportError:
            self.clear = False
        self.rows = 0    # Track printed lines to clear

        # ...
        self.moves = [' '] * 9

    def do_print(self, *text, end=linesep):
        text = list(text)
        for i, v in enumerate(text[:]):
            text[i] = str(v)
        text = ' '.join(text)
        print(text, end=end)
        self.rows += text.count(linesep) + 1

    def show_board(self):
        if self.clear and self.rows:
            self.clear(absolute=self.rows)
        self.rows = 0
        self.do_print('Tic Tac Toe')
        self.do_print('''   |   |
 {6} | {7} | {8}
   |   |
-----------
   |   |
 {3} | {4} | {5}
   |   |
-----------
   |   |
 {0} | {1} | {2}
   |   |'''.format(*self.moves))

    def start(self):
        self.show_board()
        ok = input("Press <Enter> to continue...")
        self.moves = ['O', 'X'] * 4 + ['O']
        self.show_board()
        ok = input("Press <Enter> to close.")

if __name__ == "__main__":
    TicTacToe().start()

Объяснение: do_print(...) в строке 19 представлена ​​версия print(...), необходимая для отслеживания количества новых строк (self.rows). В противном случае вам придется self.rows += 1 повсюду, где print(...) вызывается во всей программе. Поэтому каждый раз, когда плата перерисовывается, вызывая show_board(), предыдущая плата очищается, и новая доска печатается точно там, где она должна быть. Уведомление self.clear(calling_line=False) в строке 9 в основном подталкивает все до RELATIVE в нижней части терминала, но не очищает исходную линию вызова. Напротив, self.clear(absolute=self.rows) в строке 29 полностью очищает все self.rows расстояние вверх, а не просто подталкивает все вверх относительно нижней части терминала.

Пользователи Ubuntu с Python 3.3: Поместите #!/usr/bin/env python3 в первую строку файла tictactoe.py. Щелкните правой кнопкой мыши файл tictactoe.py = > Свойства = > Вкладка "Разрешения" = > "Проверить выполнение": разрешить выполнение файла как программы. Дважды щелкните файл = > Нажмите кнопку "Выполнить в терминале". Если текущим каталогом с открытым терминалом является файл tictactoe.py, вы также можете запустить файл с помощью ./tictactoe.py.

Ответ 14

Если вы хотите очистить свой терминал, когда вы используете оболочку Python. Затем вы можете сделать следующее, чтобы очистить экран

import os
os.system('clear')

Ответ 15

Вы можете прорваться через базу данных terminfo, но функции для этого в любом случае находятся в curses.

Ответ 16

python -c "from os import system; system('clear')"

Ответ 17

Вы можете использовать функцию call() для выполнения команд терминала:

from subprocess import call
call("clear")

Ответ 18

вы можете сделать свой собственный. это не зависит от вашего терминала или типа ОС.

def clear(num):
    for i in range(num): print 

clear(80)
print "hello"

Ответ 19

Это очистит 25 новых строк:

def clear():
    print(' \n' * 25)

clear()

Я использую eclipse с pydev. Мне нравится решение новой строки лучше, чем для num в диапазоне. Цикл для генерирует предупреждения, в то время как новая строка печати - нет. Если вы хотите указать количество строк в явном выражении, попробуйте это изменение.

def clear(j):
    print(' \n' * j)

clear(25)

Ответ 20

Если вам нужно только очистить экран, это, вероятно, достаточно хорошо. Проблема заключается даже в 100% кросс-платформенном способе делать это в версиях Linux. Проблема заключается в том, что реализации терминала все поддерживают несколько разные вещи. Я уверен, что "ясное" будет работать везде. Но более "полным" ответом является использование управляющих символов xterm для перемещения курсора, но для этого требуется xterm сам по себе.

Не зная больше о вашей проблеме, ваше решение кажется достаточно хорошим.

Ответ 21

Возможно, дрянной способ очистить экран, но тот, который будет работать на любой платформе, о которой я знаю, выглядит следующим образом:

for i in xrange(0,100):
    print ""

Ответ 22

Для Windows только в командной строке интерпретатора (не в графическом интерфейсе)! Просто введите: (Не забудьте использовать правильные отступы с Python):

import os
def clear():
    os.system('cls')

Каждый раз, когда вы вводите clear() в оболочке (командной строке), она очищает экран вашей оболочки. Если вы выходите из оболочки, то вы должны повторить вышеописанное, чтобы сделать это снова при открытии новой оболочки Python (командной строки).

Примечание: не имеет значения, какую версию Python вы используете, явно (2.5, 2.7, 3.3 и 3.4).

Ответ 23

Я бы сделал это таким образом, чтобы он выглядел больше как bash:

Просто создайте файл с именем.pythonstartup в домашнем каталоге и используйте poke answer в функции

В Linux:

echo "from subprocess import call
def clear(int=None):  
    call('clear')
    if int == 0:
       exit()
clear()" >> $HOME/.pythonstartup ; export PYTHONSTARTUP=$HOME/.pythonstartup ; python

Вы можете добавить export PYTHONSTARTUP=$HOME/.pythonstartup в ваш файл ./bashrc

Так как меня волнует пространство; вызов функции не будет отображать описание интерпретатора python при запуске, но вы можете удалить clear() чтобы сохранить его.

Использование этой функции, как обычной функции, должно помочь, не печатая состояние выхода:

>>> clear()

Если вы передадите аргумент 0 функции, она очистит экран и успешно завершит работу, чтобы вы могли продолжить использовать оболочку на чистом экране.

>>> clear(0)

Ответ 24

Принятый ответ - хорошее решение. Проблема в том, что пока он работает только на Windows 10, Linux и Mac. Да, Windows (известная как отсутствие поддержки ANSI)! Эта новая функция была реализована в Windows 10 (и выше), которая включает поддержку ANSI, хотя вы должны включить ее. Это очистит экран кроссплатформенным способом:

import os

print ('Hello World')
os.system('') 
print ("\x1B[2J")

В любом случае ниже Windows 10, однако, он возвращает это:

[2J

Это связано с отсутствием поддержки ANSI в предыдущих сборках Windows. Это может быть решено с помощью модуля colorama. Это добавляет поддержку символов ANSI в Windows:

Последовательности escape-символов ANSI уже давно используются для создания цветного терминального текста и позиционирования курсора в Unix и Mac. Colorama также выполняет эту работу в Windows, оборачивая стандартный вывод, удаляя найденные последовательности ANSI (которые будут отображаться в виде gobbledygook на выходе), и преобразовывая их в соответствующие вызовы win32 для изменения состояния терминала. На других платформах Colorama ничего не делает.

Итак, вот кроссплатформенный метод:

import sys

if sys.platform == 'win32':
    from colorama import init
    init()

print('Hello World')

print("\x1B[2J")

Или print(chr(27) + "[2J") используется вместо print("\x1B[2J").

Ответ @poke очень ненадежен в Windows, да, он работает, но это действительно взлом. Файл с именем cls.bat или cls.exe в том же словаре, что и сценарий, будет конфликтовать с командой и выполнять файл вместо команды, создавая огромную угрозу безопасности.

Одним из способов минимизации риска может быть изменение местоположения, где вызывается команда cls:

import os
os.system('cd C:\\Windows|cls' if os.name == 'nt' else 'clear')

Это изменит urrant D ictionary C в C:\Window (обратная косая черта важна здесь), а затем выполнить. C:\Windows всегда присутствует, и для ее записи необходимы разрешения администратора, что делает ее пригодной для выполнения этой команды с минимальным риском. Другое решение - запустить команду через PowerShell вместо командной строки, поскольку она защищена от таких уязвимостей.

В этом вопросе упоминаются и другие методы: Очистить экран в оболочке, который также может быть полезен.

Ответ 25

В Windows вы можете использовать:

>>> import os
>>> clear = lambda: os.system('cls')
>>> clear()

Ответ 26

По умолчанию os.system("clear")/os.system("cls") вернет тип int как 0. Мы можем полностью очистить экран, назначив его переменной и удалив ее.

def clear():
    if (os.name == 'nt'):    
        c = os.system('cls')
    else:
        c = os.system('clear')
    del c  # can also omit c totally

#clear()

Ответ 27

Это работает на всех платформах и работает как в Python 2, так и в 3.

def clear(number):
    for i in range(number):
        print(" ")

Затем для очистки просто наберите clear(numberhere).