清除Python中的终端

Question

是否存在任何标准的“自带电池”方法以从Python脚本中清除终端屏幕，或者我是否必须去诅咒（库，而不是单词）？

Answer 1

一个简单的跨平台解决方案是在Windows上使用cls命令，在Unix系统上使用clear。与os.system一起使用，这是一个很好的单行：

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

Answer 2

逃脱序列怎么样？

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

Answer 3

为什么没有人谈到只是在Windows中执行 Ctrl + L 或 Cmd + L 在Mac中。 当然是清除屏幕的最简单方法。

Answer 4

如果您使用的是Linux / UNIX系统，则打印ANSI转义序列以清除屏幕应该可以完成这项工作。您还需要将光标移动到屏幕顶部。这适用于任何支持ANSI的终端。

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

除非已启用ANSI支持，否则这将无法在Windows上运行。 Windows可能有一个等效的控制序列，但我不知道。

Answer 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为Mac测试print("\033c", end="")，我在Linux和Windows上测试过它（它不适用于Windows，因此其他代码调用cls）。我不记得是谁，我第一次看到使用print（“\ 033c”）和/或printf版本：subprocess.Popen("printf '\033c'", shell=True).communicate()。

rolika指出end=""将阻止它在之后打印新行。

Answer 6

至于我，最优雅的变体：

public static class QueryableExtensions
{
    public static IOrderedQueryable<T> ApplyOrdering<T, TProp>(this IQueryable<T> source, Expression<Func<T, TProp>> lambda, bool ascending)
    {
         return ascending ? source.OrderBy(lambda) : source.OrderByDescending(lambda);
     }
}

Answer 7

您可以尝试依赖clear，但可能并非在所有Linux发行版上都可用。在Windows上使用你提到的cls。

import subprocess
import platform

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

clear()

注意：控制终端屏幕可能被视为不良形式。你在考虑使用一个选项吗？让用户决定是否要清除屏幕可能会更好。

Answer 8

纯Python解决方案。
不依赖于ANSI或外部命令 只有您的终端必须能够告诉您有多少行。

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

Python版本＆gt; = 3.3.0

Answer 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（）

Answer 10

这将在两个版本的Python2或Python3中都可用

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

Answer 11

所以我想我会在这里扔两分钱......

似乎没有人提供OP问题的真实答案，每个人都回应“不要使用os.system（）它是邪恶的！”＃39;没有解释或提供依赖于打印新行的解决方案。

对于那些需要清除终端屏幕并向后滚动的用户，无论出于何种原因，您都可以使用以下代码：

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')

这具有OP的预期效果。它确实使用os.system（）命令，所以如果这是邪恶的，有人知道使用subprocess.call（）实现这个的方法请注释，因为我也更喜欢使用子进程，但根本不熟悉它

Answer 12

此函数在gnome-terminal中有效，因为默认情况下它会识别ANSI转义序列。它为您提供距离终端底部的清洁提示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是文本行中终端的高度（或最大清除高度），只需要设置一次，但可以随时重置。第三个参数位置中的*,表示所有后续参数仅为关键字（例如，clear（绝对= 5））。 calling_line=True（默认值）在交互模式下效果更佳。 calling_line=False更适用于基于文本的终端应用程序。添加absolute以尝试在减小终端大小后修复交互模式中的毛刺间隙问题，但也可用于终端应用程序。 store_max仅用于rows_max值的秘密“持久”存储;不要显式使用此参数。 （如果没有为store_max传递参数，则更改store_max的列表内容会更改此参数的默认值。因此，持久存储。）

便携性：对不起，这在IDLE中不起作用，但它可以正常工作＆gt;＆gt;非常酷＆lt;＆lt;在交互模式下，在终端（控制台）中识别ANSI转义序列。我只在Ubuntu 13.10中使用Python 3.3在gnome-terminal中进行了测试。所以我只能假设可移植性依赖于Python 3.3（针对BEST结果的shutil.get_terminal_size()函数）和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(...)函数放入与 main .py文件位于同一文件夹中的名为clear.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()

说明：第19行的do_print(...)是print(...)版本，需要跟踪已打印的新行数（self.rows）。否则，您必须在整个程序中调用self.rows += 1的地方print(...)。因此，每次通过调用show_board()重新绘制电路板时，前一个电路板都会被清除，并且新电路板将准确地打印到它应该的位置。第9行的注意事项self.clear(calling_line=False)基本上将RELATIVE的所有内容推送到终端的底部，但不清除原始的主叫线路。相比之下，第29行的self.clear(absolute=self.rows)绝对清除了所有self.rows距离向上的距离，而不是仅仅将所有内容相对于终端的底部向上推。

使用Python 3.3的Ubuntu用户：将#!/usr/bin/env python3放在tictactoe.py文件的第一行。右键单击tictactoe.py文件=＆gt;属性=＆gt;权限标签=＆gt;检查执行：允许执行文件作为程序。双击文件=＆gt;单击终端按钮中的运行。如果打开终端的当前目录是tictactoe.py文件的目录，您也可以使用./tictactoe.py启动该文件。

Answer 13

如果您希望在使用python shell时清除终端。然后，您可以执行以下操作来清除屏幕

import os
os.system('clear')

Answer 14

只需使用：

print("\033c")

这将清除终端窗口。

Answer 15

您可以使用call()功能执行终端的命令：

from subprocess import call
call("clear")

Answer 16

您可以撕掉terminfo数据库，但无论如何，这样做的功能都在curses。

Answer 17

这将清除25条新线：

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

clear()

我使用eclipse和pydev。我更喜欢换行解决方案，而不是 for num in range 。 for 循环会抛出警告，而打印换行则不会。 如果要在clear语句中指定换行符的数量，请尝试此变体。

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

clear(25)

Answer 18

你可以自己做。这将不依赖于您的终端或操作系统类型。

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

clear(80)
print "hello"

Answer 19

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

Answer 20

对于Windows，仅在解释器命令行上（不是GUI）！只需输入： （记得使用python进行适当的缩进）：

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

每次在shell（命令行）上键入clear()时，它都会清除shell上的屏幕。如果退出shell，那么在打开新的Python（命令行）shell时，必须重做上面的内容再次执行它。

注意：无论你使用什么版本的Python都是明确的（2.5,2.7,3.3和3.4）。

Answer 21

我会这样做，让它看起来更像bash：

只需在主目录创建名为.pythonstartup的文件，并在函数中使用poke的答案

在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传递给函数，它将清除屏幕并成功退出，以便您可以在干净的屏幕中继续使用shell

>>> clear(0)

Answer 22

清除屏幕的一种可能是俗气的方式，但是可以在我所知道的任何平台上运行的方式如下：

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

Answer 23

如果只需清除屏幕，这可能就足够了。问题是在Linux版本中甚至没有100％的跨平台方式。问题是终端的实现都支持略有不同的东西。我很确定“清晰”会随处可见。但更完整的答案是使用xterm控制字符来移动光标，但这需要xterm本身。

在不了解您的问题的情况下，您的解决方案似乎已经足够了。

Answer 24

The accepted answer是一个很好的解决方案。它的问题是到目前为止它只适用于Windows 10，Linux和Mac。是Windows（因缺乏ANSI支持而闻名）！此新功能是在Windows 10（及更高版本）上实现的，其中包括ANSI支持，但您必须启用它。这将以跨平台的方式清除屏幕：

import os

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

在Windows 10以下的任何内容中，它会返回：

[2J

这是由于以前的Windows版本缺乏ANSI支持。但是，可以使用colorama模块解决此问题。这增加了对Windows上ANSI字符的支持：

  

ANSI转义字符序列长期以来一直用于在Unix和Mac上生成彩色终端文本和光标定位。 Colorama也通过包装stdout，剥离它找到的ANSI序列（在输出中显示为gobbledygook），并将它们转换为适当的win32调用来修改终端的状态，从而在Windows上运行。在其他平台上，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')

这会将 C urrant D ictionary改为C:\Window（反斜杠在这里很重要）然后执行。 C:\Windows始终存在，并且需要管理权限才能在此处写入，从而使执行此命令的风险最小。另一种解决方案是通过PowerShell而不是命令提示符运行命令，因为它已经抵御了这些漏洞。

此问题中还提到了其他方法：Clear screen in shell也可能有用。

Answer 25

在Windows中，您可以使用：

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

Answer 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()

Answer 27

这适用于所有平台，它在Python 2和3中都有效。

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

然后清除只需输入clear(numberhere)。