python – How to clear the interpreter console?

The Question :

358 people think this question is useful

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.

The Question Comments :

The Answer 1

486 people think this answer is useful

As you mentioned, you can do a system call:

For Windows

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

For Linux the lambda becomes

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

The Answer 2

217 people think this answer is useful

here something handy that is a little more cross-platform

import os

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

# now, to clear the screen

The Answer 3

89 people think this answer is useful

Well, here’s a quick hack:

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

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

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

The Answer 4

29 people think this answer is useful

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:

# ==== ====

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

cls = cls()

# ==== end ====

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

The Answer 5

28 people think this answer is useful

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

3. Using new line print 100 times:

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

The Answer 6

22 people think this answer is useful

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

This is the same for OS X on the terminal.

The Answer 7

17 people think this answer is useful

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

import os
import subprocess

def clear():
    if in ('nt','dos'):"cls")
    elif in ('linux','osx','posix'):"clear")
        print("\n") * 120

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

The Answer 8

13 people think this answer is useful

This is the simplest thing you can do and it doesn’t require any additional libraries. It will clear the screen and return >>> to the top left corner.


The Answer 9

10 people think this answer is useful

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'nt' else 'clear')

Same idea but with a spoon of syntactic sugar:

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

The Answer 10

8 people think this answer is useful

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

import os
class Cls(object):
    def __repr__(self):
        return ''

The usage is quite simple:

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

The Answer 11

8 people think this answer is useful

for the mac user inside the python console type

import os

for windows


The Answer 12

6 people think this answer is useful

I’m not sure if Windows’ “shell” supports this, but on Linux:

print "\033[2J"

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.

The Answer 13

5 people think this answer is useful

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

  1. You can copy-paste the code into your shell or script.
  2. You can use it as you like:

    >>> clear()
    >>> -clear
    >>> clear  # <- but this will only work on a shell
  3. You can import it as a module:

    >>> from clear import clear
    >>> -clear
  4. You can call it as a script:

    $ python
  5. 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:
Or if you are just looking for the code:

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


The Answer 14

5 people think this answer is useful

I use iTerm and the native terminal app for Mac OS.

I just press ⌘ + k

The Answer 15

4 people think this answer is useful

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.

The Answer 16

3 people think this answer is useful

The easiest way is to use os module

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

The Answer 17

2 people think this answer is useful

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

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

The Answer 18

2 people think this answer is useful

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 =

print clear

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

The Answer 19

2 people think this answer is useful

Here are two nice ways of doing that:


import os

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

# Clear the Linux terminal.
elif ('posix' in


import os

def clear():
    if == 'posix':

    elif in ('ce', 'nt', 'dos'):


The Answer 20

2 people think this answer is useful

Just enter

import os
os.system('cls') # Windows
os.system('clear') # Linux, Unix, Mac OS X

The Answer 21

2 people think this answer is useful

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

The Answer 22

2 people think this answer is useful

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

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

import os

def clear():

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

… added to ~/.pythonrc

  • clear() clears screen
  • wipe() wipes entire terminal buffer

The Answer 23

2 people think this answer is useful

The perfect cls:

cls = lambda: print("\033c\033[3J", end='')

Or directly:

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

The Answer 24

1 people think this answer is useful

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

import subprocess
import os

if == 'nt':
    def clearscreen():"cls", shell=True)
    def clearscreen():"clear", shell=True)

The Answer 25

1 people think this answer is useful

How about this for a clear

- os.system('cls')

That is about as short as could be!

The Answer 26

1 people think this answer is useful

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:


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

The Answer 27

1 people think this answer is useful

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


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.

The Answer 28

1 people think this answer is useful

I might be late to the part but here is a very easy way to do it


def cls():

So what ever you want to clear the screen just type in your code


Best way possible! (Credit :

The Answer 29

1 people think this answer is useful

If you don’t need to do it through code, just press CTRL+L

The Answer 30

0 people think this answer is useful

EDIT: I’ve just read “windows”, this is for linux users, sorry.

In bash:


while [ "0" == "0" ]; do
    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 ;)"

Save it as “”, chmod +x it then run:

./ 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.

Add a Comment