ChatGPT解决这个技术问题 Extra ChatGPT

How to clear the interpreter console?

Like most Python developers, I typically keep a console window open with the Python interpreter running to test commands, dir() stuff, help() stuff, etc.

Like any console, after a while the visible backlog of past commands and prints gets to be cluttered, and sometimes confusing when re-running the same command several times. I'm wondering if, and how, to clear the Python interpreter console.

I've heard about doing a system call and either calling cls on Windows or clear on Linux, but I was hoping there was something I could command the interpreter itself to do.

Note: I'm running on Windows, so Ctrl+L doesn't work.


M
Merouane T.

As you mentioned, you can do a system call:

For Windows:

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

For Linux it would be:

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

Define it in a regular function instead of lambda should not show '0' as the return value will be None.
What's wrong with using def? Why use a lambda when a def is clearer?
@Akbaribrahim as None will not be printed try this: clear = lambda: os.system('cls') or None
How to make this persist over instances of python interpreter? thanks in advance.
os.system is deprecated. use subprocess.call instead
r
rubenvb

here something handy that is a little more cross-platform

import os

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

# now, to clear the screen
cls()

Great way of going about things, Combine this with the lambda suggestion above to save a row of code, handy as hell! Thank you! :)
import os os.system('cls')
TERM environment variable not set.
cls = lambda: os.system('cls' if os.name=='nt' else 'clear')
K
Kenan Banks

Well, here's a quick hack:

>>> clear = "\n" * 100
>>> print clear
>>> ...do some other stuff...
>>> print clear

Or to save some typing, put this file in your python search path:

# wiper.py
class Wipe(object):
    def __repr__(self):
        return '\n'*1000

wipe = Wipe()

Then you can do this from the interpreter all you like :)

>>> from wiper import wipe
>>> wipe
>>> wipe
>>> wipe

Haha, that's pretty funny. Not exactly what I was looking for, but nice try.
@Triptych: c = "\n" * 100 usefull, +1 for it. A small comment it clears and brings to the bottom of the shell, i prefer to start from the shell top.
Or, if your terminal emulator interprets ANSI, better do: "\x1B[H\x1B[J"
Despite people laughing, printing a lot of newlines is exactly what the external processes clear and cls do. This is the way to do it. (just a print, or a function with the print call, not assigining to a "clear" string, of course)
@jsbueno no it's not. Well maybe on windows (though I doubt it, it has APIs to clear the console). On all other systems, clear outputs a directive that clears the screen. Without trashing the scrollback buffer. On my system, it outputs this control sequence: \33[3J\33[H\33[2J. That is: [erase scrollback] [reset cursor position] [erase screen]. The [erase scrollback] can be omitted using clear -x.
D
Denis Rasulev

This is the simplest thing you can do and it doesn't require any additional libraries. It clears the screen and returns >>> to the top left corner.

print("\033[H\033[J", end="")

UPDATE 1:

Since this answer gets some attention, you might want to know how it works. The command above prints ANSI escape codes:

\033 stands for ESC (ANSI value 27).

\033[ is a special escape sequence called Control Sequence Introducer (CSI).

\033[H command moves the cursor to the top left corner of the screen.

\033[J clears the screen from the cursor to the end of the screen.

Optional parameter end="" avoids printing newline character after executing these commands, so >>> stays in the topmost row.

UPDATE 2:

You may want to extend the above command with one additional parameter - x (before J):

print("\033[H\033[xJ", end="")

If x is 1, it will clear from cursor to beginning of the screen.

If x is 2, it will clear entire screen and move cursor to upper left.

If x is 3, it will clear entire screen and delete all lines saved in the scrollback buffer.

So, this command will clear everything, including buffer:

print("\033[H\033[3J", end="")

COMMAND LINE:

To clear screen in a shell (console / terminal) you can use the same command. To clear entire screen and delete all lines saved in the scrollback buffer put 3 before J:

printf "\033[H\033[3J"

or create an alias:

alias cls='printf "\033[H\033[3J"'

This has the advantage that it also works in Spyder.
May I ask what is this?
Oh I wasn't clear. I meant print("\033[H\033[J") how does this method work, what is it its name!?
This one was really the best solution. Simple and multi-platform.
This is the only real solution to the problem
V
Vlad Bezden

You have number of ways doing it on Windows:

1. Using Keyboard shortcut:

Press CTRL + L

2. Using system invoke method:

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

3. Using new line print 100 times:

cls = lambda: print('\n'*100)
cls()

All these ways are pretty... naff. cls will only work on windows and make your program hard to be cross platform, printing 100 newlines is just... eww? And a keyboard shortcut is not used in the program.
C
Community

Although this is an older question, I thought I'd contribute something summing up what I think were the best of the other answers and add a wrinkle of my own by suggesting that you put these command(s) into a file and set your PYTHONSTARTUP environment variable to point to it. Since I'm on Windows at the moment, it's slightly biased that way, but could easily be slanted some other direction.

Here's some articles I found that describe how to set environment variables on Windows:
    When to use sys.path.append and when modifying %PYTHONPATH% is enough
    How To Manage Environment Variables in Windows XP
    Configuring System and User Environment Variables
    How to Use Global System Environment Variables in Windows

BTW, don't put quotes around the path to the file even if it has spaces in it.

Anyway, here's my take on the code to put in (or add to your existing) Python startup script:

# ==== pythonstartup.py ====

# add something to clear the screen
class cls(object):
    def __repr__(self):
        import os
        os.system('cls' if os.name == 'nt' else 'clear')
        return ''

cls = cls()

# ==== end pythonstartup.py ====

BTW, you can also use @Triptych's __repr__ trick to change exit() into just exit (and ditto for its alias quit):

class exit(object):
    exit = exit # original object
    def __repr__(self):
        self.exit() # call original
        return ''

quit = exit = exit()

Lastly, here's something else that changes the primary interpreter prompt from >>> to cwd+>>>:

class Prompt:
    def __str__(self):
        import os
        return '%s >>> ' % os.getcwd()

import sys
sys.ps1 = Prompt()
del sys
del Prompt

This is probably the best answer - a combination of techniques from other answers. PYTHONSTARTUP + repr + os.system('cls'). Very nice.
@Triptych: One interesting side-effect of using __repr__ and/or __str__ this way is that if you type >>> vars() at the interpreter console, it will execute all the commands thusly defined. On my system, for example, it cleared the screen and then exited the console. Took me a while to figure out what the heck was going on....
interesting. I see this problem also applies to locals() and globals(). A simple decorator around these functions that deletes the name and reassigns it after function invocation is a possible solution...
@Triptych: The decorator idea doesn't seem to work, at least with my own attempts. Coming up with an viable alternative is proving to surprising difficult.
I have a candidate solution that simply munges the result of vars() globals() and locals() calls temporarily: gist.github.com/4172781
A
Alex K

Quickest and easiest way without a doubt is Ctrl+L.

This is the same for OS X on the terminal.


I tried this solution using upper or lowercase "L" with the ctrl key on windows 8.1. It doesn't work for me. I just open and close the shell window to clear it.
On OS X, Ctrl+L will pad the terminal until the display is clear. You can still scroll up to see the history. Use Cmd+K to clear the display and printout history. A more complete list of OS X terminal hotkeys
E
EgMusic

my way of doing this is to write a function like so:

import os
import subprocess

def clear():
    if os.name in ('nt','dos'):
        subprocess.call("cls")
    elif os.name in ('linux','osx','posix'):
        subprocess.call("clear")
    else:
        print("\n") * 120

then call clear() to clear the screen. this works on windows, osx, linux, bsd... all OSes.


You might mean os.name in ('linux','osx'), and might also want to add 'posix' as well.
@rsanden 'linux' and 'osx' covers pretty much all the OS's people ACTUALLY use.
I am running Ubuntu 15.04, and os.name == 'posix' in both python 2.7.9 and 3.4.3
@rsanden added posix.
M
Mario Palumbo

The perfect cls, also compatible with Python2 (in .pythonrc file):

from __future__ import print_function
cls = lambda: print("\033c", end='')

and can be called from the terminal in this way:

cls()

Or directly:

print("\033c", end='')

\033[H\033[J only clears the visible screen, exactly the same as the clear command up to Ubuntu 18.10. It doesn't clear the scrollback buffer. Scrolling up will reveal the history.

To simulate this behavior, insert some terminal lines, then press Ctrl+L and insert more. After executing print("\033[H\033[J", end=""), only the screen lines inserted after pressing "Ctrl + L" will be deleted.

\033c clears everything.

\x1bc may not give the same result as \033c as the hex escape is not clearly length limited.


This should be the accepted and most upvote answer - firstly, it's an overkill IMO to import os and run an external command just to get the screen clear, and secondly, it's much faster (this, of course, only matters if you have to do it a zillion times in a row)
Why are you using lambda here?
Some info on ESC-c: "Triggers a full reset of the terminal to its original state.[20] This may include (if applicable): reset graphic rendition, clear tabulation stops, reset to default font, and more."
@not2qubit It is a quick way to implement a function, this short way is not mandatory, the standard one is also excellent.
Hex escapes with \x are by definition always two hex digits long. \x1b is perfectly equivalent to \033.
P
Pitto

Here's a cross platform (Windows / Linux / Mac / Probably others that you can add in the if check) version snippet I made combining information found in this question:

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

Same idea but with a spoon of syntactic sugar:

import subprocess   
clear = lambda: subprocess.call('cls||clear', shell=True)
clear()

A
Amol

Wiper is cool, good thing about it is I don't have to type '()' around it. Here is slight variation to it

# wiper.py
import os
class Cls(object):
    def __repr__(self):
        os.system('cls')
        return ''

The usage is quite simple:

>>> cls = Cls()
>>> cls # this will clear console.

I'd name the instance of the class Cls to be cls. cls = Cls()
Except that pollutes the initial namespace with two things instead of one...twice as much.
@Amol I've used yours and others' techniques in my solution. You can do class cls and then cls=cls().
B
BuZz

I'm not sure if Windows' "shell" supports this, but on Linux:

print "\033[2J"

https://en.wikipedia.org/wiki/ANSI_escape_code#CSI_codes

In my opinion calling cls with os is a bad idea generally. Imagine if I manage to change the cls or clear command on your system, and you run your script as admin or root.


I agree cls is not ideal in this case, and an ANSI escape sequence is better. In particular using os to invoke a new process is quite a pricy operation, compared to pushing a few bytes to stdout.
A
Alba Mendez

Here's the definitive solution that merges all other answers. Features:

You can copy-paste the code into your shell or script. You can use it as you like: >>> clear() >>> -clear >>> clear # <- but this will only work on a shell You can import it as a module: >>> from clear import clear >>> -clear You can call it as a script: $ python clear.py It is truly multiplatform; if it can't recognize your system (ce, nt, dos or posix) it will fall back to printing blank lines.

You can download the [full] file here: https://gist.github.com/3130325
Or if you are just looking for the code:

class clear:
 def __call__(self):
  import os
  if os.name==('ce','nt','dos'): os.system('cls')
  elif os.name=='posix': os.system('clear')
  else: print('\n'*120)
 def __neg__(self): self()
 def __repr__(self):
  self();return ''

clear=clear()

A
AndyG

Use idle. It has many handy features. Ctrl+F6, for example, resets the console. Closing and opening the console are good ways to clear it.


how do you do that on idle? Just close and reopen?
No, F6 does not reset the Idle console, however CTRL+F6 does. Unfortunately this does not clear the screen. D'oh! (Python Win32 Idle versions 2.6.2, 2.7.1, 3.2).
A
AAAfarmclub

I'm using MINGW/BASH on Windows XP, SP3.

(stick this in .pythonstartup) # My ctrl-l already kind of worked, but this might help someone else # leaves prompt at bottom of the window though... import readline readline.parse_and_bind('\C-l: clear-screen')

# This works in BASH because I have it in .inputrc as well, but for some # reason it gets dropped when I go into Python readline.parse_and_bind('\C-y: kill-whole-line')

I couldn't stand typing 'exit()' anymore and was delighted with martineau's/Triptych's tricks:

I slightly doctored it though (stuck it in .pythonstartup)

class exxxit():
    """Shortcut for exit() function, use 'x' now"""
    quit_now = exit # original object
    def __repr__(self):
        self.quit_now() # call original
x = exxxit()

Py2.7.1>help(x)
Help on instance of exxxit in module __main__:

class exxxit
 |  Shortcut for exit() function, use 'x' now
 |
 |  Methods defined here:
 |
 |  __repr__(self)
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  quit_now = Use exit() or Ctrl-Z plus Return to exit

l
larsr

The OS command clear in Linux and cls in Windows outputs a "magic string" which you can just print. To get the string, execute the command with popen and save it in a variable for later use:

from os import popen
with popen('clear') as f:
    clear = f.read()

print clear

On my machine the string is '\x1b[H\x1b[2J'.


1) That magic string is an ANSI sequence. \x1b[H means "move the cursor to the top-left corner", \x1b[2J means "clear all the screen". 2) In windows, ANSI is not recognized so probably there isn't any magic string.
Cool! Also, for python3 print('\x1b[H\x1b[2J', end=''); can help avoid the new line in front.
The magic string worked on Microsoft Windows 10 console with Python 3.6 for me. I plussed for the string sequence not the use of with open.
K
Kirk

I'm new to python (really really new) and in one of the books I'm reading to get acquainted with the language they teach how to create this little function to clear the console of the visible backlog and past commands and prints:

Open shell / Create new document / Create function as follows:

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

Save it inside the lib folder in you python directory (mine is C:\Python33\Lib) Next time you nedd to clear your console just call the function with:

clear()

that's it. PS: you can name you function anyway you want. Iv' seen people using "wiper" "wipe" and variations.


a
anatoly techtonik
>>> ' '*80*25

UPDATE: 80x25 is unlikely to be the size of console windows, so to get the real console dimensions, use functions from pager module. Python doesn't provide anything similar from core distribution.

>>> from pager import getheight
>>> '\n' * getheight()

That rule is there to avoid simply posting code. It tries to make people explain his answer, not just giving code.
It's not a good answer anyway - it's just printing a string of 80*25 spaces... which only works if the console is 2000 characters or smaller (such as 80x25, or 100x20... but the console often winds up 120x50 on my machine.
Use pypi.python.org/pypi/pager getwidth/getheight to detect console parameters.
u
user1474157

just use this..

print '\n'*1000


J
James Jithin

Here are two nice ways of doing that:

1.

import os

# Clear Windows command prompt.
if (os.name in ('ce', 'nt', 'dos')):
    os.system('cls')

# Clear the Linux terminal.
elif ('posix' in os.name):
    os.system('clear')

2.

import os

def clear():
    if os.name == 'posix':
        os.system('clear')

    elif os.name in ('ce', 'nt', 'dos'):
        os.system('cls')


clear()

If os.name is none of these, why not fall back to printing empty lines?
If it's Jython then I want you to know that os.name = 'java'
Looks good, does this mean that the program can become cross platform?
J
Jagoda Gorus

If it is on mac, then a simple cmd + k should do the trick.


V
Victoria Stuart

Arch Linux (tested in xfce4-terminal with Python 3):

# Clear or wipe console (terminal):
# Use: clear() or wipe()

import os

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

def wipe():
    os.system("clear && printf '\e[3J'")

... added to ~/.pythonrc

clear() clears screen

wipe() wipes entire terminal buffer


A
Acorn

This should be cross platform, and also uses the preferred subprocess.call instead of os.system as per the os.system docs. Should work in Python >= 2.4.

import subprocess
import os

if os.name == 'nt':
    def clearscreen():
        subprocess.call("cls", shell=True)
        return
else:
    def clearscreen():
        subprocess.call("clear", shell=True)
        return

B
Bo Persson

How about this for a clear

- os.system('cls')

That is about as short as could be!


yes, but not multiplatform and you have to retype it every time you want to clear the screen.
What about Linux? It throws "cls command not found"
g
guest12345

OK, so this is a much less technical answer, but I'm using the Python plugin for Notepad++ and it turns out you can just clear the console manually by right-clicking on it and clicking "clear". Hope this helps someone out there!


S
Seymour

I found the simplest way is just to close the window and run a module/script to reopen the shell.


Y
Youness

I am using Spyder (Python 2.7) and to clean the interpreter console I use either

%clear

that forces the command line to go to the top and I will not see the previous old commands.

or I click "option" on the Console environment and select "Restart kernel" that removes everything.


S
Someone_who_likes_SE

Magic strings are mentioned above - I believe they come from the terminfo database:

http://www.google.com/?q=x#q=terminfo

http://www.google.com/?q=x#q=tput+command+in+unix

$ tput clear| od -t x1z
0000000 1b 5b 48 1b 5b 32 4a                             >.[H.[2J<
0000007

t
tripleee

EDIT: I've just read "windows", this is for linux users, sorry.

In bash:

#!/bin/bash

while true; do
    clear
    "$@"
    while [ "$input" == "" ]; do
        read -p "Do you want to quit? (y/n): " -n 1 -e input
        if [ "$input" == "y" ]; then
            exit 1
        elif [ "$input" == "n" ]; then
            echo "Ok, keep working ;)"
        fi
    done
    input=""
done

Save it as "whatyouwant.sh", chmod +x it then run:

./whatyouwant.sh python

or something other than python (idle, whatever). This will ask you if you actually want to exit, if not it rerun python (or the command you gave as parameter).

This will clear all, the screen and all the variables/object/anything you created/imported in python.

In python just type exit() when you want to exit.


S
Spartan

If you use vim keybindings in your .inputrc:

set editing-mode vi

It's:

ESC Ctrl-L