pantalla limpiar clrscr clear_output windows console clear python

windows - limpiar - os cls python



¿Cómo borrar la consola de intérprete? (30)

¿Qué tal esto para una clara

- os.system(''cls'')

¡Eso es lo más corto que podría ser!

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, cosas de dir (), cosas de help (), etc.

Al igual que con cualquier otra consola, después de un tiempo, la acumulación visible de comandos e impresiones pasadas se llena, y algunas veces se confunde cuando se vuelve a ejecutar el mismo comando varias veces. Me pregunto si, y cómo, para borrar la consola del intérprete de Python.

He oído hablar sobre hacer una llamada al sistema y llamar cls en Windows o clear en Linux, pero esperaba que hubiera algo que pudiera ordenar al intérprete.

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

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

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 su sistema
    ( ce , nt , dos o posix ) volverá a imprimir líneas en blanco.

Puede descargar el archivo [completo] aquí: https://gist.github.com/3130325
O si solo estás 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()

Aquí hay una versión multiplataforma (Windows / Linux / Mac / Probablemente otras que puede agregar en el fragmento de versión 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()

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

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

Aunque esta es una pregunta más antigua, pensé que podría aportar algo que resume lo que creo que fueron las mejores respuestas y agregaría mi propia arruga al sugerir que coloques estos comandos en un archivo y configures tu PYTHONSTARTUP Variable de entorno para señalarlo. Ya que estoy en Windows en este momento, está ligeramente sesgado de esa manera, pero podría ser fácilmente inclinado 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 variables de entorno en Windows XP
Configurando las variables del sistema y del entorno del usuario
Cómo utilizar las variables de entorno del sistema global 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 incluir (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 Triptych''s truco __repr__ @ __repr__ para cambiar exit() por solo 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, aquí hay algo más que cambia el indicador del intérprete principal de >>> a cwd + >>> :

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

Bien, 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í!

Bueno, aquí hay un truco rápido:

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

O para guardar algo de escritura, ponga 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

Como mencionaste, puedes hacer una llamada al sistema:

Para ventanas

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

Para Linux la lambda se convierte en

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

Descubrí que la forma más sencilla es cerrar la ventana y ejecutar un módulo / script para volver a abrir el shell.

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 y luego ejecute:

./whatyouwant.sh python

o algo más que python (inactivo, lo que sea). Esto le preguntará si realmente quiere salir, si no, vuelva a ejecutar python (o el comando que dio como parámetro).

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

En Python solo escribe exit () cuando quieras salir.

El comando del sistema operativo clear en Linux y cls en 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'' .

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

# 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 debería ser multiplataforma y también utiliza el subprocess.call preferido en lugar de os.system según los documentos de os.system . 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

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

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

Estoy usando MINGW / BASH en Windows XP, SP3.

(pega esto en .pythonstartup)
# Mi ctrl-l ya funcionó, pero esto podría ayudar a otra persona
# deja aviso en la parte inferior de la ventana aunque ...
importar readline
readline.parse_and_bind (''/ Cl: clear-screen'')

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

Ya no podía soportar escribir ''exit ()'' y estaba encantado con los trucos de martineau / Triptych:

Sin embargo, lo he manipulado ligeramente (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

Estoy usando Spyder (Python 2.7) y para limpiar la consola de intérpretes, yo uso cualquiera

%claro

eso obliga a la línea de comandos 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 el kernel" que elimina todo.

La forma más fácil `>>> importar os

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

La forma más rápida y sencilla sin lugar a dudas es Ctrl + L.

Esto es lo mismo para OS X en el terminal.

Mi forma de hacer esto es escribir una función así:

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 a clear() para borrar la pantalla. esto funciona en windows, osx, linux, bsd ... todos los sistemas operativos.

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 a cls con os es una mala idea en general. Imagínese si logro cambiar los cls o el comando clear en su sistema y usted ejecuta su script como administrador o root.

Solo entra

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

Soy nuevo en Python (realmente realmente nuevo) y en uno de los libros que leo para familiarizarme con el lenguaje que enseñan cómo crear esta pequeña función para borrar la consola del trabajo acumulado visible y los comandos y las impresiones pasadas:

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 nombrarte función que desees. He visto personas usando "limpiador", "limpia" y variaciones.

Tienes 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 nueva línea de impresión 100 veces:

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

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

Solo presiono ⌘ + k

Utilizar inactivo Tiene muchas características útiles. Ctrl + F6 , por ejemplo, restablece la consola. Cerrar y abrir la consola son buenas maneras de borrarla.

solo usa esto ..

print ''/n''*1000

Aquí hay dos buenas maneras de hacer eso:

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

>>> '' ''*80*25

ACTUALIZACIÓN : es poco probable que 80x25 sea del tamaño de las ventanas de la consola, por lo que para obtener las dimensiones reales de la consola, use las funciones del módulo de pager . Python no proporciona nada similar de la distribución del núcleo.

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