Como la mayoría de los desarrolladores de Python, normalmente mantengo una ventana de consola abierta con el intérprete de Python ejecutándose para probar comandos, dir()cosas help() stuff, etc.

Al igual que cualquier consola, después de un tiempo, la acumulación de comandos e impresiones anteriores se ve abarrotada y, a veces, es confusa cuando se vuelve a ejecutar el mismo comando varias veces. Me pregunto si, y cómo, limpiar la consola del intérprete de Python.

Escuché sobre hacer una llamada al sistema y llamar clsa Windows o clearLinux, pero esperaba que hubiera algo que pudiera ordenarle al intérprete que hiciera.

Nota: estoy ejecutando en Windows, por lo Ctrl+Lque no funciona.

Como mencionó, puede hacer una llamada al sistema:

Para ventanas

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

Para Linux, la lambda se convierte

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

aquí algo práctico que es un poco más multiplataforma

import os

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

# now, to clear the screen
cls()

Bueno, aquí hay un truco rápido:

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

O para guardar algo de escritura, coloque este archivo en su ruta de búsqueda de Python:

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

wipe = Wipe()

Entonces puedes hacer esto desde el intérprete todo lo que quieras :)

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

Aunque esta es una pregunta anterior, pensé que contribuiría con un resumen de lo que creo que era la mejor de las otras respuestas y agregaría una arruga propia al sugerir que coloque estos comandos en un archivo y configure su PYTHONSTARTUP variable de entorno para señalarlo. Dado que estoy en Windows en este momento, está ligeramente sesgado de esa manera, pero podría inclinarse fácilmente en otra dirección.

Aquí hay algunos artículos que encontré que describen cómo establecer variables de entorno en Windows:
    cuándo usar sys.path.append y al modificar% PYTHONPATH% es suficiente
    Cómo administrar las variables de entorno en Windows XP
    Configurar el sistema y las variables de entorno del usuario
    Cómo usar el sistema global Variables de entorno en Windows

Por cierto, no ponga comillas alrededor de la ruta del archivo, incluso si tiene espacios en él.

De todos modos, aquí está mi opinión sobre el código para poner (o agregar a su script de inicio de Python existente):

# ==== 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 ====

Por cierto, también puedes usar el __repr__ truco de @ Triptych para cambiar exit()a just exit(y lo mismo para su alias quit):

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

quit = exit = exit()

Por último, de aquí otra cosa que cambia el intérprete principal de la pronta >>>a cwd + >>>:

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

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

Tiene varias formas de hacerlo en Windows:

1. Usando el atajo de teclado:

Press CTRL + L

2. Usando el método de invocación del sistema:

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

3. Usando la nueva línea de impresión 100 veces:

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

La forma más rápida y fácil sin duda es Ctrl+ L.

Esto es lo mismo para OS X en el terminal.

mi forma de hacerlo es escribir una función como esta:

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

luego llame clear()para borrar la pantalla. esto funciona en windows, osx, linux, bsd ... todos los sistemas operativos.

Aquí hay un fragmento de versión multiplataforma (Windows / Linux / Mac / Probablemente otros que puede agregar en el if check) que hice combinando la información encontrada en esta pregunta:

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

La misma idea pero con una cucharada de azúcar sintáctica:

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

El limpiador es genial, lo bueno es que no tengo que escribir '()' alrededor. Aquí hay una ligera variación

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

El uso es bastante simple:

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

Esto es lo más simple que puede hacer y no requiere ninguna biblioteca adicional. Borrará la pantalla y volverá >>>a la esquina superior izquierda.

print("\033[H\033[J")

para el usuario mac dentro del tipo de consola python

import os
os.system('clear')

para ventanas

os.system('cls')

Aquí está la solución definitiva que combina todas las demás respuestas . caracteristicas:

1. Puede copiar y pegar el código en su shell o script.

2. Puedes usarlo como quieras:

   >>> clear()
   >>> -clear
   >>> clear  # <- but this will only work on a shell

3. Puedes importarlo como un módulo:

   >>> from clear import clear
   >>> -clear

4. Puedes llamarlo como un script:

   $ python clear.py

5. Es verdaderamente multiplataforma ; si no puede reconocer a su sistema
   ( ce, nt, doso posix) va a caer de nuevo a la impresión de líneas en blanco.

Puede descargar el archivo [completo] aquí: https://gist.github.com/3130325
O si solo está buscando el código:

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

No estoy seguro de si el "shell" de Windows lo admite, pero en Linux:

print "\033[2J"

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

En mi opinión, llamar clscon oses una mala idea en general. Imagínese si logro cambiar los cls o el comando clear en su sistema, y ​​ejecuta su script como administrador o root.

Uso iTerm y la aplicación de terminal nativa para Mac OS.

Solo presiono ⌘ + k

Usar inactivo. Tiene muchas funciones útiles. Ctrl+F6, por ejemplo, restablece la consola. Cerrar y abrir la consola son buenas maneras de limpiarla.

Estoy usando MINGW / BASH en Windows XP, SP3.

(pegue esto en .pythonstartup)
# Mi ctrl-l ya funcionaba, pero esto podría ayudar a alguien más
# deja un mensaje en la parte inferior de la ventana ...
import readline
readline.parse_and_bind ('\ Cl: clear-screen')

# Esto funciona en BASH porque también lo tengo en .inputrc, pero por alguna
# razón se cae cuando entro en Python
readline.parse_and_bind ('\ Cy: kill-whole-line')

No podía soportar escribir 'exit ()' más y estaba encantado con los trucos de martineau / Triptych:

Aunque lo modifiqué un poco (lo pegué en .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

El comando del sistema operativo clearen Linux y clsen Windows genera una "cadena mágica" que puede imprimir. Para obtener la cadena, ejecute el comando con popen y guárdelo en una variable para su uso posterior:

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

print clear

En mi máquina la cadena es '\x1b[H\x1b[2J'.

Aquí hay dos buenas maneras de hacerlo:

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

Si está en Mac, entonces un simple cmd + kdebería hacer el truco.

La forma más fácil es usar el módulo os

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

Esto debe ser multiplataforma, y ​​también utiliza el preferido en subprocess.calllugar de os.systemsegún los os.systemdocumentos . Debería funcionar en 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

¿Qué tal esto para un claro

- os.system('cls')

¡Eso es lo más corto posible!

Soy nuevo en Python (muy, muy nuevo) y en uno de los libros que estoy leyendo para familiarizarme con el lenguaje que enseñan cómo crear esta pequeña función para limpiar la consola de la cartera de pedidos visible y los comandos e impresiones anteriores:

Abrir shell / Crear nuevo documento / Crear función de la siguiente manera:

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

Guárdelo dentro de la carpeta lib en su directorio de python (el mío es C: \ Python33 \ Lib) La próxima vez que necesite borrar su consola, simplemente llame a la función con:

clear()

Eso es. PD: puedes nombrar tu función como quieras. Iv ha visto personas usando "limpiador", "borrado" y variaciones.

Estoy usando Spyder (Python 2.7) y para limpiar la consola del intérprete uso

%claro

eso obliga a la línea de comando a ir a la parte superior y no veré los comandos anteriores anteriores.

o hago clic en "opción" en el entorno de la Consola y selecciono "Reiniciar kernel" que elimina todo.

Puede que llegue tarde a la parte, pero aquí hay una manera muy fácil de hacerlo

Tipo:

def cls():
    os.system("cls")

Entonces, lo que quiera borrar de la pantalla simplemente escriba su código

cls()

La mejor manera posible! (Crédito: https://www.youtube.com/watch?annotation_id=annotation_3770292585&feature=iv&src_vid=bguKhMnvmb8&v=LtGEp9c6Z-U )

Solo ingresa

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

Si no necesita hacerlo a través del código, simplemente presione CTRL + L

Arch Linux (probado en xfce4-terminalPython 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'")

... añadido a ~/.pythonrc

• clear() borra la pantalla
• wipe() borra todo el búfer terminal

EDITAR: Acabo de leer "Windows", esto es para usuarios de Linux, lo siento.

En bash:

#!/bin/bash

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

Guárdelo como "whatyouwant.sh", chmod + x luego ejecute:

./whatyouwant.sh python

o algo diferente a python (inactivo, lo que sea). Esto le preguntará si realmente desea salir, de lo contrario, volverá a ejecutar python (o el comando que le dio como parámetro).

Esto borrará todo, la pantalla y todas las variables / objeto / cualquier cosa que haya creado / importado en Python.

En python, simplemente escriba exit () cuando desee salir.

De acuerdo, esta es una respuesta mucho menos técnica, pero estoy usando el complemento de Python para Notepad ++ y resulta que puedes borrar la consola manualmente haciendo clic derecho sobre ella y haciendo clic en "borrar". Espero que esto ayude a alguien por ahí!