Clear console python linux

Clear screen in shell

It works for all shells e.g. Python, Bash, MySQL, MATLAB, etc.

import os os.system('cls') # For Windows os.system('clear') # For Linux/OS X 

Also, os.system(‘clear’) for Mac OS X terminals (confirmed to work with the default shell, bash , and also for csh ).

You can also define a function to run this, like: def cls(): os.system(‘cls’) (hit enter twice). Then you can just type cls() to clear the screen.

@KyleDelaney while inefficient, it works in the shell. Also many people found this useful because that’s what they were looking for.

For macOS/OS X, you can use the subprocess module and call ‘cls’ from the shell:

import subprocess as sp sp.call('cls', shell=True) 

To prevent ‘0’ from showing on top of the window, replace the 2nd line with:

For Linux, you must replace cls command with clear

tmp = sp.call('clear', shell=True) 

I am using Mac OS X, and I tried this import subprocess as sp sp.call(‘clear’,shell=True) which works, except there is a 0 at the top of the terminal window.

0 is the return value of the ‘cls’ command call from shell. i edited the answer to get rid of that as well, by simply storing that value in a variable.

Thanks for the solution, I was missing shell=True. to prevent the 0 from showing up you can also add a semicolon to the end of the statement. sp.call(‘cls’, shell=True);

Here are some options that you can use on Windows

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

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

Third option if you are in Python REPL window:

The sort of thing that you are looking for is to be found in the curses module.

import curses # Get the module stdscr = curses.initscr() # initialise it stdscr.clear() # Clear the screen 

Important Note

The important thing to remember is before any exit, you need to reset the terminal to a normal mode, this can be done with the following lines:

curses.nocbreak() stdscr.keypad(0) curses.echo() curses.endwin() 

If you don’t you will get all sort of strange behaviour. To ensure that this is always done I would suggest using the atexit module, something like:

import atexit @atexit.register def goodbye(): """ Reset terminal from curses mode on exit """ curses.nocbreak() if stdscr: stdscr.keypad(0) curses.echo() curses.endwin() 

I’m running Mac OS X 10.7.5 and iTerm 2 for my terminal. Using Python2.7, the stdscr = curses.initscr() works to clear the screen, and the stdscr.clear() does nothing. Using Python3.4, the stdscr = curses.initscr() does clear the screen, but takes away the terminal’s ability to process newlines. When I press enter repeatedly, it gives the following: >>> >>> >>> >>> and so on. I can still type commands, but they don’t show up. Also, this behavior persists even when I exit() Python. AVOID USE!

@jvriesem the curses module has been in use for a long time and has been used by a lot of people — I would suggest that you see if you can replicate the behaviour in a short, (20 lines or so), example and either post it as a stack overflow question or on the developer mailing list.

Good idea — that’s a better response than my «AVOID USE!» statement. The first two lines of this answer were the two lines that replicate the problem for me. Do you know if there’s any reason the curses module might have compatibility issues (Windows vs. Mac vs. Linux)? I can confirm that this issue happens on two different Mac terminals, at least. The behavior persists in BASH but not CSH. Hmm. Do you think I should contact the curses developer, the shell developer, or just ask the SO community? Thanks again!

@jvriesem — I have updated my answer to include how to reset your terminal to standard mode once you have finished, including on any exit.

In addition to being an all-around great CLI library, click also provides a platform-agnostic clear() function:

This function works in any OS (Unix, Linux, macOS, and Windows)
Python 2 and Python 3

import platform # For getting the operating system name import subprocess # For executing a shell command def clear_screen(): """ Clears the terminal screen. """ # Clear command as function of OS command = "cls" if platform.system().lower()=="windows" else "clear" # Action return subprocess.call(command) == 0 

In windows the command is cls , in unix-like systems the command is clear .
platform.system() returns the platform name. Ex. ‘Darwin’ for macOS.
subprocess.call() performs a system call. Ex. subprocess.call([‘ls’,’-l’])

An easier way to clear a screen while in python is to use Ctrl + L though it works for the shell as well as other programs.

If you are using linux terminal to access python, then cntrl+l is the best solution to clear screen

I am using a class that just uses one of the above methods behind the scenes. I noticed it works on Windows and Linux. I like using it though because it’s easier to type clear() instead of system(‘clear’) or os.system(‘clear’)

pip3 install clear-screen from clear_screen import clear 

and then when you want to clear the shell:

using windows 10 and pyhton3.5 i have tested many codes and nothing helped me more than this:

First define a simple function, this funtion will print 50 newlines;(the number 50 will depend on how many lines you can see on your screen, so you can change this number)

then just call it as many times as you want or need

Rather than importing all of curses or shelling out just to get one control character, you can simply use (on Linux/macOS):

Subprocess allows you to call «cls» for Shell.

import subprocess cls = subprocess.call('cls',shell=True) 

That’s as simple as I can make it. Hope it works for you!

Command+K works fine in OSX to clear screen.

Shift+Command+K to clear only the scrollback buffer.

import curses stdscr = curses.initscr() stdscr.clear() 

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

import subprocess as sp x=sp.call('cls',shell=True) 

os.system(‘cls’) works fine when I open them. It opens in cmd style.

Here’s how to make your very own cls or clear command that will work without explicitly calling any function!

We’ll take advantage of the fact that the python console calls repr() to display objects on screen. This is especially useful if you have your own customized python shell (with the -i option for example) and you have a pre-loading script for it. This is what you need:

import os class ScreenCleaner: def __repr__(self): os.system('cls') # This actually clears the screen return '' # Because that's what repr() likes cls = ScreenCleaner() 

Use clear instead of cls if you’re on linux (in both the os command and the variable name)!

Now if you just write cls or clear in the console — it will clear it! Not even cls() or clear() — just the raw variable. This is because python will call repr(cls) to print it out, which will in turn trigger our __repr__ function.

>>> df;sag Traceback (most recent call last): File "", line 1, in NameError: name 'df' is not defined >>> sglknas Traceback (most recent call last): File "", line 1, in NameError: name 'sglknas' is not defined >>> lksnldn Traceback (most recent call last): File "", line 1, in NameError: name 'lksnldn' is not defined >>> cls 

To clarify — the code above needs to either be imported in the console like this

Or pre load directly with something like:

python -i my_pre_loaded_classes.py 

Источник

How to Clear Console in Python

This tutorial helps How to Clear the Console in Python. There is a number of ways to clear the console based on the operating system. You can also clear the interpreter programmatically.

There are several methods for clearing the console in Python, depending on the operating system you are using.

Here, we’ll go over the most popular Python techniques for clearing the console in this article. We’ll use os the library, which is a built-in library that comes with Python3 installations.

You can also checkout other python tutorials:

Method 1: Using the os module

Import the os module and use its os.system() function to wipe the console in Python.

Let’s import os module:

Clear Console in Linux system

We’ll use the os.system(‘clear’) command to clear the console.

The Sample code:

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

The screen will be cleared if the above command is entered into your console.

Clear Console in Windows system

For the Windows system, We’ll use the os.system(‘cls’) command to clear the console.

The Sample code:

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

Run the above command in your terminal to clear the screen.

Method 2: Using the subprocess module

The subprocess module provides a way to run shell commands from within your Python code. To clear the console in Python.

import subprocess # For Windows subprocess.call('cls', shell=True) # For Linux/Unix subprocess.call('clear', shell=True)

Method 3: Using ANSI escape codes

You can also clear the console using the ANSI escape codes, The ANSI escape codes are sequences of characters that control formatting, color, and other visual effects in the console.

The majority of terminals, including the Windows Command Prompt, Git Bash, and terminal emulators for Linux and macOS, are compatible with this method.

Lambda Function To Clear Console in Python

You can also use the lambda function to clear the python console.

import os def clear_console(): return os.system('clear') clear_console()

The screen will be cleared if the above code will run.

Conclusion

We have learned different ways to clear the console in python. Clearing the console in Python is a simple task that can be done using the os module, the subprocess module, or ANSI escape codes .

Источник

4 Different Ways to Clear Console in Python

You must import the os module and use its os.system() method to clear the console programmatically in Python. The os is a built-in library that comes with Python3 installations.

I am using Mac, so I need to write Linux-related commands.

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

If you run the above command in your console, it will clear the screen.

For the Windows user, use the following code.

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

You can use the lambda function if you don’t want to use the full function.

import os def clear_console(): return os.system('clear') clear_console()

And it will clear the console.

That’s pretty much it for clearing the console in Python.

Method 2: Using the subprocess.call() function

You can use the subprocess.call() function in the subprocess module that allows you to spawn new processes, connect to their input/output/error pipes and clear the console in Python.

Example

import subprocess import os subprocess.call('clear' if os.name =='posix' else 'cls', shell=True)

If you run the above code, it will clear the console.

Method 3: Using the ANSI escape codes

ANSI escape codes are sequences of characters that can be included in a string to specify various types of formatting for terminal output, such as changing the color or cursor position or clearing the console.

Example

It will clear the Python console.

The “\033” is the escape character, and c is the code to reset the terminal.

The “end” argument is set to an empty string to ensure no extra line break is added after the escape code.

Method 4: Using the ipykernel package in Jupyter notebooks

In Jupyter notebooks, you can clear the output of a cell by using the ipykernel package.

The ipykernel package provides an API for controlling the Jupyter kernel, including the ability to clear the output of a cell, or in our case, it is console programmatically.

Example

from IPython.display import clear_output clear_output()

The clear_output() function from the IPython.display module can be used to clear the output of a cell in a Jupyter notebook.

Conclusion

In Python, you can clear the console by using the following methods based on the platform you are using:

For Windows

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

For Linux/Unix

The os.system() method takes different parameters based on your platform because the os.system() function is platform-dependent and may not work on all systems.

Источник