consola - limpiar pantalla en python
Borrar terminal en Python (25)
¿Existe algún método estándar "viene con baterías" para borrar la pantalla del terminal de un script Python, o tengo que ir maldiciones (las bibliotecas, no las palabras)?
¿Por qué nadie ha hablado simplemente haciendo Ctrl + L ?
Sin duda, la forma más sencilla de borrar la pantalla.
¿Qué hay de las secuencias de escape?
print(chr(27) + "[2J")
Así que solo pensé en arrojar mis dos centavos aquí ...
Nadie ha proporcionado una respuesta verdadera a la pregunta de OP, parece que todos responden con ''NO DONT USE os.system () ¡es malo!'' sin explicación o proporciona una solución que se basa en la impresión de nuevas líneas.
Para aquellos que necesitan borrar la pantalla de la terminal y desplazarse hacia atrás, por cualquier razón, puede usar lo siguiente
import sys
def clear():
''''''
Clears the terminal screen and scroll back to present
the user with a nice clean, new screen. Useful for managing
menu screens in terminal applications.
''''''
os.system(''cls'' if os.name == ''nt'' else ''echo -e ////033c'')
print(''A bunch of garbage so we can garble up the screen...'')
clear()
# Same effect, less characters...
def clear():
''''''
Clears the terminal screen and scroll back to present
the user with a nice clean, new screen. Useful for managing
menu screens in terminal applications.
''''''
os.system(''cls||echo -e ////033c'')
Esto tiene el efecto deseado de OP. Utiliza el comando os.system () así que si eso es malo y alguien conoce una forma de implementar esto usando subprocess.call () por favor coméntelo ya que también preferiría usar el subproceso pero no estoy familiarizado con él en absoluto.
Como una persona sabia una vez publicada, al menos para Linux, puede hacer el equivalente de Python de esto, que puede usar en la línea de comandos. Limpiará la pantalla más que el comando clear Linux (por ejemplo, no puede desplazarse hacia arriba para ver su texto):
printf "/033c"
Para Windows puedes usar cls .
Aquí hay una forma de Python para hacerlo:
import subprocess
subprocess.call(["printf", "''/033c''"])
Aquí hay otra forma de Python para hacerlo (que funciona al menos en mi computadora):
print("/033c")
No tengo idea si eso funciona en Windows o en Mac, iOS, Android, etc.
Puede usar las respuestas de otras personas para descubrir una forma más multiplataforma de implementar esto.
En Windows puedes usar:
>>> import os
>>> clear = lambda: os.system(''cls'')
>>> clear()
En cuanto a mí, la variante más elegante:
import os
os.system(''cls||clear'')
Esta función funciona en gnome-terminal porque, de forma predeterminada, reconoce secuencias de escape ANSI. Le da una LIMPIA PROMPT rows_max distancia de la parte inferior de la terminal, pero también precisamente desde donde se llamó. Te da un control completo sobre cuánto borrar.
def clear(rows=-1, rows_max=None, *, calling_line=True, absolute=None,
store_max=[]):
"""clear(rows=-1, rows_max=None)
clear(0, -1) # Restore auto-determining rows_max
clear(calling_line=False) # Don''t clear calling line
clear(absolute=5) # Absolutely clear out to 5 rows up"""
from os import linesep
if rows_max and rows_max != -1:
store_max[:] = [rows_max, False]
elif not store_max or store_max[1] or rows_max == -1 or absolute:
try:
from shutil import get_terminal_size
columns_max, rows_max = get_terminal_size()
except ImportError:
columns_max, rows_max = 80, 24
if absolute is None:
store_max[:] = [rows_max, True]
if store_max:
if rows == -1:
rows = store_max[0]
elif isinstance(rows, float):
rows = round(store_max[0] * rows)
if rows > store_max[0] - 2:
rows = store_max[0] - 2
if absolute is None:
s = (''/033[1A'' + '' '' * 30 if calling_line else '''') + linesep * rows
else:
s = ''/033[{}A''.format(absolute + 2) + linesep
if absolute > rows_max - 2:
absolute = rows_max - 2
s += ('' '' * columns_max + linesep) * absolute + '' '' * columns_max
rows = absolute
print(s + ''/033[{}A''.format(rows + 1))
Implementación:
clear() # Clear all, TRIES to automatically get terminal height
clear(800, 24) # Clear all, set 24 as terminal (max) height
clear(12) # Clear half of terminal below if 24 is its height
clear(1000) # Clear to terminal height - 2 (24 - 2)
clear(0.5) # float factor 0.0 - 1.0 of terminal height (0.5 * 24 = 12)
clear() # Clear to rows_max - 2 of user given rows_max (24 - 2)
clear(0, 14) # Clear line, reset rows_max to half of 24 (14-2)
clear(0) # Just clear the line
clear(0, -1) # Clear line, restore auto-determining rows_max
clear(calling_line=False) # Clear all, don''t clear calling line
clear(absolute=5) # Absolutely clear out to 5 rows up
Parámetros: rows es la cantidad de filas de texto sin formato para agregar entre el indicador y la parte inferior del terminal, empujando todo hacia arriba. rows_max es la altura del terminal (o la altura máxima de borrado) en las filas de texto, y solo necesita establecerse una vez, pero se puede restablecer en cualquier momento. *, en la posición del tercer parámetro significa que todos los parámetros siguientes son palabras clave solamente (p. ej., borrar (absoluto = 5)). calling_line=True (predeterminado) funciona mejor en modo Interactivo. calling_line=False funciona mejor para aplicaciones de terminal basadas en texto. Se agregó absolute para tratar de solucionar problemas de brecha en el modo Interactivo después de reducir el tamaño del terminal, pero también se puede usar para aplicaciones de terminal. store_max es solo para el almacenamiento secreto, "persistente" del valor de rows_max ; no use explícitamente este parámetro. (Cuando no se pasa un argumento para store_max , cambiar el contenido de la lista de store_max cambia el valor predeterminado de este parámetro. Por lo tanto, el almacenamiento persistente).
Portabilidad: Perdón, esto no funciona en IDLE, pero funciona >> MUY FRÍO << en modo interactivo en un terminal (consola) que reconoce las secuencias de escape de ANSI. Solo probé esto en Ubuntu 13.10 usando Python 3.3 en gnome-terminal. Así que solo puedo asumir que la portabilidad depende de Python 3.3 (para la función shutil.get_terminal_size() para MEJORES resultados) y el reconocimiento ANSI. La función de print(...) es Python 3. También probé esto con un juego Tic Tac Toe (aplicación) terminal, simple y basado en texto.
Para usar en el modo Interactivo: Primero copie y pegue la función de copy(...) en el modo Interactivo y vea si le funciona. Si es así, coloque la función anterior en un archivo llamado clear.py. En el terminal, inicie python, con ''python3''. Entrar:
>>> import sys
>>> sys.path
['''', ''/usr/lib/python3.3'', ...
Ahora suelte el archivo clear.py en uno de los directorios de path listados para que Python pueda encontrarlo (no sobrescriba ningún archivo existente). Para usar fácilmente a partir de ahora:
>>> from clear import clear
>>> clear()
>>> print(clear.__doc__)
clear(rows=-1, rows_max=None)
clear(0, -1) # Restore auto-determining rows_max
clear(calling_line=False) # Don''t clear calling line
clear(absolute=5) # Absolutely clear out to 5 rows up
Para usar en una aplicación de terminal: coloque la función de copy(...) en un archivo llamado clear.py en la misma carpeta con su archivo .py principal . Aquí hay un ejemplo de trabajo abstracto (esqueleto) de una aplicación de juego Tic Tac Toe (ejecute desde el prompt del terminal: python3 tictactoe .py):
from os import linesep
class TicTacToe:
def __init__(self):
# Clear screen, but not calling line
try:
from clear import clear
self.clear = clear
self.clear(calling_line=False)
except ImportError:
self.clear = False
self.rows = 0 # Track printed lines to clear
# ...
self.moves = ['' ''] * 9
def do_print(self, *text, end=linesep):
text = list(text)
for i, v in enumerate(text[:]):
text[i] = str(v)
text = '' ''.join(text)
print(text, end=end)
self.rows += text.count(linesep) + 1
def show_board(self):
if self.clear and self.rows:
self.clear(absolute=self.rows)
self.rows = 0
self.do_print(''Tic Tac Toe'')
self.do_print('''''' | |
{6} | {7} | {8}
| |
-----------
| |
{3} | {4} | {5}
| |
-----------
| |
{0} | {1} | {2}
| |''''''.format(*self.moves))
def start(self):
self.show_board()
ok = input("Press <Enter> to continue...")
self.moves = [''O'', ''X''] * 4 + [''O'']
self.show_board()
ok = input("Press <Enter> to close.")
if __name__ == "__main__":
TicTacToe().start()
Explicación: do_print(...) en la línea 19 es una versión de print(...) necesaria para realizar un seguimiento de cuántas líneas nuevas se han impreso ( self.rows ). De lo contrario, tendría que self.rows += 1 todo el lugar donde se llama print(...) lo largo de todo el programa. Por lo tanto, cada vez que se vuelve a dibujar la placa llamando a show_board() la placa anterior se borra y la nueva placa se imprime exactamente donde debería estar. Observe que self.clear(calling_line=False) en la línea 9 básicamente empuja todo hacia arriba RELATIVE a la parte inferior de la terminal, pero no borra la línea de llamada original. Por el contrario, self.clear(absolute=self.rows) en la línea 29 borra absolutamente todo lo uno mismo. self.rows distancia hacia arriba, en lugar de simplemente empujar todo hacia arriba en relación con la parte inferior de la terminal.
Usuarios de Ubuntu con Python 3.3: Ponga #!/usr/bin/env python3 en la primera línea del archivo tictactoe.py. Haga clic derecho en el archivo tictactoe.py => Propiedades => pestaña Permisos => Comprobar ejecución: Permitir la ejecución del archivo como programa . Haga doble clic en el archivo => Haga clic en Ejecutar en el botón Terminal. Si el directorio actual de un terminal abierto es el del archivo tictactoe.py, también puede iniciar el archivo con ./tictactoe.py .
Esto borrará 25 nuevas líneas:
def clear():
print('' /n'' * 25)
clear()
Yo uso eclipse con pydev. Me gusta la solución de nueva línea mejor que la de num rango . El bucle for arroja advertencias, mientras que la nueva línea de impresión no lo hace. Si desea especificar el número de nuevas líneas en la declaración clara, pruebe esta variación.
def clear(j):
print('' /n'' * j)
clear(25)
Esto funciona en todas las plataformas y funciona en Python 2 y 3.
def clear(number):
for i in range(number):
print(" ")
Luego, para borrar simplemente escriba clear(numberhere) .
Lo haría de esta manera para que se vea más como bash:
Solo crea un archivo llamado .pythonstartup en el directorio Home y usa la respuesta de poke en una función
En Linux:
echo "from subprocess import call
def clear(int=None):
call(''clear'')
if int == 0:
exit()
clear()" >> $HOME/.pythonstartup ; export PYTHONSTARTUP=$HOME/.pythonstartup ; python
Puede agregar export PYTHONSTARTUP=$HOME/.pythonstartup a su archivo ./bashrc
Dado que lo que me importa es el espacio; una llamada a la función no mostrará la descripción del intérprete de python al inicio, pero puede eliminar clear() para retenerla.
Usarlo como una función normal debería hacer el truco sin imprimir el estado de salida:
>>> clear()
Si pasa el argumento 0 a la función, borrará la pantalla y saldrá con éxito para que pueda continuar utilizando el shell en una pantalla limpia
>>> clear(0)
Para Windows, solo en la línea de comandos del intérprete (¡no en la GUI)! Simplemente escriba: (Recuerde usar la sangría adecuada con python):
import os
def clear():
os.system(''cls'')
Cada vez que escriba clear() en el shell (línea de comando), borrará la pantalla de su caparazón. Si sale del shell, debe volver a hacer lo anterior para volver a hacerlo al abrir un nuevo shell de Python (línea de comando).
Nota: no importa qué versión de Python esté usando, explícitamente (2.5, 2.7, 3.3 y 3.4).
Podría intentar confiar en Clear pero podría no estar disponible en todas las distribuciones de Linux. En windows usa cls como mencionaste.
import subprocess
import platform
def clear():
subprocess.Popen( "cls" if platform.system() == "Windows" else "clear", shell=True)
clear()
Nota: Podría considerarse una mala forma tomar el control de la pantalla del terminal. ¿Estás considerando usar una opción? Probablemente sea mejor dejar que el usuario decida si quiere borrar la pantalla.
Podría recorrer la base de datos terminfo, pero las funciones para hacerlo están en curses todos modos.
Por defecto, os.system("clear") / os.system("cls") devolverá un tipo int como 0. Podemos borrar completamente la pantalla asignándola a una variable y eliminándola.
def clear():
if (os.name == ''nt''):
c = os.system(''cls'')
else:
c = os.system(''clear'')
del c # can also omit c totally
#clear()
Puede usar la función call() para ejecutar los comandos del terminal:
from subprocess import call
call("clear")
Puedes hacer el tuyo. esto no dependerá de su terminal o tipo de sistema operativo.
def clear(num):
for i in range(num): print
clear(80)
print "hello"
Se encontró con esto hace algún tiempo
def clearscreen(numlines=100):
"""Clear the console.
numlines is an optional argument used only as a fall-back.
"""
# Thanks to Steven D''Aprano, http://www.velocityreviews.com/forums
if os.name == "posix":
# Unix/Linux/MacOS/BSD/etc
os.system(''clear'')
elif os.name in ("nt", "dos", "ce"):
# DOS/Windows
os.system(''CLS'')
else:
# Fallback for other operating systems.
print(''/n'' * numlines)
Entonces solo usa clearscreen ()
Si desea borrar su terminal cuando está usando un shell de python. Luego, puede hacer lo siguiente para borrar la pantalla
import os
os.system(''clear'')
Si está en un sistema Linux / UNIX, imprimir la secuencia de escape de ANSI para borrar la pantalla debería hacer el trabajo. También querrás mover el cursor a la parte superior de la pantalla. Esto funcionará en cualquier terminal que admita ANSI.
import sys
sys.stderr.write("/x1b[2J/x1b[H")
Esto no funcionará en Windows a menos que se haya habilitado la compatibilidad con ANSI. Puede haber una secuencia de control equivalente para Windows, pero no sé.
Si todo lo que necesita es borrar la pantalla, esto es probablemente lo suficientemente bueno. El problema es que ni siquiera hay una forma de plataforma cruzada 100% para hacer esto en las versiones de Linux. El problema es que las implementaciones de la terminal admiten cosas ligeramente diferentes. Estoy bastante seguro de que "claro" funcionará en todas partes. Pero la respuesta más "completa" es usar los caracteres de control de xterm para mover el cursor, pero eso requiere xterm en y de sí mismo.
Sin saber más de su problema, su solución parece lo suficientemente buena.
Una forma quizás cursi de borrar la pantalla, pero que funcionará en cualquier plataforma que conozca, es la siguiente:
for i in xrange(0,100):
print ""
Una solución Pure Python.
No depende de ANSI ni de comandos externos.
Solo su terminal debe tener la capacidad de decirle cuántas líneas están a la vista.
from shutil import get_terminal_size
print("/n" * get_terminal_size().lines, end='''')
Versión de Python> = 3.3.0
Una solución simple y multiplataforma sería usar el comando cls en Windows, o clear en sistemas Unix. Usado con os.system , esto hace un buen one-liner:
import os
os.system(''cls'' if os.name == ''nt'' else ''clear'')
La respuesta aceptada es una buena solución. El problema es que hasta ahora solo funciona en Windows 10, Linux y Mac. ¡Sí Windows (conocido por su falta de soporte ANSI)! Esta nueva característica se implementó en Windows 10 (y versiones posteriores) que incluye soporte ANSI, aunque debe habilitarlo. Esto borrará la pantalla de forma cruzada:
import os
print (''Hello World'')
os.system('''')
print ("/x1B[2J")
En cualquier cosa debajo de Windows 10, sin embargo, devuelve esto:
[2J
Esto se debe a la falta de compatibilidad con ANSI en versiones anteriores de Windows. Sin embargo, esto puede resolverse utilizando el módulo colorama . Esto agrega soporte para caracteres ANSI en Windows:
Las secuencias de caracteres de escape ANSI se han utilizado durante mucho tiempo para producir texto de terminal coloreado y posicionamiento del cursor en Unix y Mac. Colorama hace que esto también funcione en Windows, envolviendo stdout, eliminando las secuencias ANSI que encuentra (que aparecerían como un galimatías en la salida), y convirtiéndolas en las llamadas win32 apropiadas para modificar el estado de la terminal. En otras plataformas, Colorama no hace nada.
Así que aquí hay un método de plataforma cruzada:
import sys
if sys.platform == ''win32'':
from colorama import init
init()
print(''Hello World'')
print("/x1B[2J")
O print(chr(27) + "[2J") usado en lugar de print("/x1B[2J") .
La respuesta de @poke es muy insegura en Windows, sí funciona, pero realmente es un truco. Un archivo llamado cls.bat o cls.exe en el mismo diccionario que la secuencia de comandos entrará en conflicto con el comando y ejecutará el archivo en lugar del comando, creando un gran riesgo de seguridad.
Un método para minimizar el riesgo podría ser cambiar la ubicación de donde se llama el comando cls :
import os
os.system(''cd C://Windows|cls'' if os.name == ''nt'' else ''clear'')
Esto cambiará el D iccionario de C urantes a C:/Window (la barra invertida es importante aquí) y luego se ejecutará. C:/Windows siempre está presente y necesita permisos de administración para escribir, por lo que es bueno para ejecutar este comando con un riesgo mínimo. Otra solución es ejecutar el comando a través de PowerShell en lugar de Símbolo del sistema, ya que se ha protegido contra dichas vulnerabilidades.
También hay otros métodos mencionados en esta pregunta: Borrar la pantalla en el caparazón que también puede ser de utilidad.
python -c "from os import system; system(''clear'')"