Bestaat er een standaard “wordt geleverd met batterijen”-methode om het terminalscherm van een Python-script te wissen, of moet ik gaan vloeken (de bibliotheken, niet de woorden)?
Antwoord 1, autoriteit 100%
Hoe zit het met ontsnappingsreeksen?
print(chr(27) + "[2J")
Antwoord 2, autoriteit 98%
Een eenvoudige en platformonafhankelijke oplossing zou zijn om ofwel de opdracht clsop Windows te gebruiken, of clearop Unix-systemen. Gebruikt met os.system, dit maakt een mooie oneliner:
import os
os.system('cls' if os.name == 'nt' else 'clear')
Antwoord 3, autoriteit 63%
Waarom heeft niemand het erover gehad om gewoon Ctrl+Lin Windows of Cmd+Lte doen op Mac.
Zeker de eenvoudigste manier om het scherm te wissen.
Antwoord 4, autoriteit 28%
Wat mij betreft, de meest elegante variant:
import os
os.system('cls||clear')
Antwoord 5, autoriteit 26%
Voor Windows, Mac en Linux kunt u de volgende code gebruiken:
import subprocess, platform
if platform.system()=="Windows":
subprocess.Popen("cls", shell=True).communicate() #I like to use this instead of subprocess.call since for multi-word commands you can just type it out, granted this is just cls and subprocess.call should work fine
else: #Linux and Mac
print("\033c", end="")
jamesnotjim heeft print("\033c", end="")getest voor Mac, en ik heb het getest op Linux en Windows (het werkt niet voor Windows, vandaar de andere code die cls). Ik weet niet meer wie ik voor het eerst zag met print(“\033c”) en/of de printf-versie: subprocess.Popen("printf '\033c'", shell=True).communicate().
rolika wees erop dat end=""zal voorkomen dat er daarna een nieuwe regel wordt afgedrukt.
Antwoord 6, autoriteit 25%
Als je een Linux/UNIX-systeem gebruikt, zou het voldoende moeten zijn om de ANSI-escape-reeks af te drukken om het scherm leeg te maken. U wilt ook de cursor naar de bovenkant van het scherm verplaatsen. Dit werkt op elke terminal die ANSI ondersteunt.
import sys
sys.stderr.write("\x1b[2J\x1b[H")
Dit werkt niet op Windows tenzij ANSI-ondersteuning is ingeschakeld. Er is mogelijk een equivalente besturingsreeks voor Windows, maar ik weet het niet.
Antwoord 7, autoriteit 8%
Gebruik gewoon:
print("\033c")
Hiermee wordt het terminalvenster leeggemaakt.
Antwoord 8, autoriteit 6%
Je zou kunnen proberen te vertrouwen op clear, maar het is mogelijk niet beschikbaar op alle Linux-distributies. Gebruik in Windows cls zoals je al zei.
import subprocess
import platform
def clear():
subprocess.Popen( "cls" if platform.system() == "Windows" else "clear", shell=True)
clear()
Opmerking: het kan als een slechte vorm worden beschouwd om de controle over het terminalscherm over te nemen. Overweegt u een optie te gebruiken? Het is waarschijnlijk beter om de gebruiker te laten beslissen of hij het scherm wil wissen.
Antwoord 9, autoriteit 5%
Ik kwam dit enige tijd geleden tegen
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)
Gebruik dan gewoon clearscreen()
Antwoord 10, autoriteit 5%
Dit zal werken in Beide versie Python2 OF Python3
print (u"{}[2J{}[;H".format(chr(27), chr(27)))
Antwoord 11, autoriteit 5%
Een pure Python-oplossing.
Vertrouwt niet op ANSI of externe opdrachten.
Alleen uw terminal moet de mogelijkheid hebben om u te vertellen hoeveel lijnen er in beeld zijn.
from shutil import get_terminal_size
print("\n" * get_terminal_size().lines, end='')
Python-versie >= 3.3.0
Antwoord 12, autoriteit 4%
Dus ik dacht dat ik hier even mijn twee cent in zou gooien…
Niemand heeft een echt antwoord gegeven op de OP-vraag, zo lijkt het, iedereen antwoordt ofwel met ‘NO DONT USE os.system() it’s evil!!!’ zonder uitleg of biedt een oplossing die afhankelijk is van het printen van nieuwe regels.
Voor degenen die het terminalscherm moeten wissen en om welke reden dan ook terug moeten scrollen, kunt u de volgende code gebruiken:
import os
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')
Dit heeft het gewenste effect van het OP. Het gebruikt het OS.System () opdracht, dus als dat het kwaad is en iemand een manier van implementatie van dit gebruiken met behulp van subprocess.call () alsjeblieft commentaar als ik ook liever subproces zou gebruiken, maar helemaal niet bekend is.
Antwoord 13, Autoriteit 2%
Deze functie werkt in Gnome-terminal omdat het standaard ANSI Escape-sequenties herkent. Het geeft u een schone prompt rows_maxAfstand van de bodem van de terminal, maar ook precies van waar het werd genoemd. Geeft u volledige controle over hoeveel te wissen.
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))
Implementatie:
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
Parameters: rowsis het aantal duidelijke tekstrijen dat moet worden toegevoegd tussen de prompt en de onderkant van de terminal, waardoor alles omhoog wordt geduwd. rows_maxis de hoogte van de terminal (of max. clearing height) in tekstrijen, en hoeft maar één keer te worden ingesteld, maar kan op elk moment worden gereset. *,op de derde parameterpositie betekent dat alle volgende parameters alleen trefwoord zijn (bijv. clear(absolute=5)). calling_line=True(standaard) werkt beter in de interactieve modus. calling_line=Falsewerkt beter voor op tekst gebaseerde terminaltoepassingen. absoluteis toegevoegd om te proberen glitchy gap-problemen in de interactieve modus op te lossen na het verkleinen van de terminal, maar kan ook worden gebruikt voor terminaltoepassingen. store_maxis alleen voor geheime, “permanente” opslag van rows_maxwaarde; gebruik deze parameter niet expliciet. (Als er geen argument wordt doorgegeven voor store_max, verandert het wijzigen van de lijstinhoud van store_maxde standaardwaarde van deze parameter. Vandaar permanente opslag.)
Draagbaarheid: Sorry, dit werkt niet in IDLE, maar het werkt >> HEEL KOEL << in Interactieve modus in een terminal (console) die ANSI-escape-reeksen herkent. Ik heb dit alleen getest in Ubuntu 13.10 met Python 3.3 in gnome-terminal. Dus ik kan alleen maar aannemen dat draagbaarheid afhankelijk is van Python 3.3 (voor de functie shutil.get_terminal_size()voor BESTE resultaten) en ANSI-herkenning. De functie print(...)is Python 3. Ik heb dit ook getest met een eenvoudig, op tekst gebaseerd, terminal Tic Tac Toe-spel (applicatie).
Voor gebruik in Interactieve modus:Kopieer en plak eerst de functie copy(...)in Interactieve modus en kijk of het voor u werkt. Als dat zo is, plaats dan de bovenstaande functie in een bestand met de naam clear.py . Start in de terminal python, met ‘python3’. Voer in:
>>> import sys
>>> sys.path
['', '/usr/lib/python3.3', ...
Plaats het clear.py-bestand nu in een van de vermelde path-mappen zodat Python het kan vinden (overschrijf geen bestaande bestanden). Om vanaf nu gemakkelijk te gebruiken:
>>> 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
Voor gebruik in een terminaltoepassing:plaats de functie copy(...)in een bestand met de naam clear.py in dezelfde map als uw hoofd .py-bestand. Hier is een werkend abstract (skelet) voorbeeld van een Tic Tac Toe-speltoepassing (uitvoeren vanaf terminalprompt: 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()
Uitleg: do_print(...)op regel 19 is een versie van print(...)die nodig is om bij te houden hoeveel nieuwe regels er zijn afgedrukt (self.rows). Anders zou u self.rows += 1overal moeten plaatsen waar print(...)wordt aangeroepen in het hele programma. Dus elke keer dat het bord opnieuw wordt getekend door show_board()aan te roepen, wordt het vorige bord leeggemaakt en wordt het nieuwe bord precies afgedrukt waar het zou moeten zijn. Merk op dat self.clear(calling_line=False)op regel 9 in feite alles RELATIEF naar de onderkant van de terminal duwt, maar de oorspronkelijke oproepregel niet wist. In tegenstelling, self.clear(absolute=self.rows)op regel 29 ruimt absoluut alles op self.rowsafstand naar boven, in plaats van alles naar boven te duwen ten opzichte van de onderkant van de terminal.
Ubuntu-gebruikers met Python 3.3: Zet #!/usr/bin/env python3op de allereerste regel van het tictactoe.py-bestand. Klik met de rechtermuisknop op het tictactoe.py-bestand => Eigenschappen => Tabblad Rechten => Vink Uitvoeren aan: Sta uitvoeren van bestand toe als programma. Dubbelklik op het bestand => Klik op de knop Uitvoeren in Terminal. Als de huidige directory van een geopende terminal die van het bestand tictactoe.py is, kunt u het bestand ook starten met ./tictactoe.py.
Antwoord 14, autoriteit 2%
Als u uw terminal wilt wissen wanneer u een python-shell gebruikt. Vervolgens kunt u het volgende doen om het scherm leeg te maken
import os
os.system('clear')
Antwoord 15
Je zou door de terminfo-database kunnen scheuren, maar de functies om dit te doen zijn hoe dan ook in curses.
Antwoord 16
python -c "from os import system; system('clear')"
Antwoord 17
U kunt de functie call()gebruiken om de opdrachten van de terminal uit te voeren:
from subprocess import call
call("clear")
Antwoord 18
In Windows kunt u het volgende gebruiken:
>>> import os
>>> clear = lambda: os.system('cls')
>>> clear()
Antwoord 19
u kunt er zelf een maken. dit is niet afhankelijk van uw terminal of besturingssysteemtype.
def clear(num):
for i in range(num): print
clear(80)
print "hello"
Antwoord 20
Als u alleen het scherm hoeft te wissen, is dit waarschijnlijk voldoende. Het probleem is dat er niet eens een 100% cross-platform manier is om dit voor alle Linux-versies te doen. Het probleem is dat de implementaties van de terminal allemaal iets andere dingen ondersteunen. Ik ben er vrij zeker van dat “clear” overal zal werken. Maar het meer “complete” antwoord is om de xterm-controletekens te gebruiken om de cursor te verplaatsen, maar dat vereist xterm op zich.
Zonder meer van uw probleem te weten, lijkt uw oplossing goed genoeg.
Antwoord 21
Een misschien goedkope manier om het scherm leeg te maken, maar een die werkt op elk platform dat ik ken, is als volgt:
for i in xrange(0,100):
print ""
Antwoord 22
Hiermee worden 25 nieuwe regels gewist:
def clear():
print(' \n' * 25)
clear()
Ik gebruik eclipse met pydev. Ik vind de newline-oplossing beter dan de for num in range. De forlus geeft waarschuwingen, terwijl de print newline dat niet doet.
Als je het aantal nieuwe regels in de duidelijke verklaring wilt specificeren, probeer dan deze variatie.
def clear(j):
print(' \n' * j)
clear(25)
Antwoord 23
Ik zou het op deze manier doen om het meer op bash te laten lijken:
Maak gewoon een bestand met de naam .pythonstartup in de Home-directory en gebruik het antwoord van poke in een functie
Op Linux:
echo "from subprocess import call
def clear(int=None):
call('clear')
if int == 0:
exit()
clear()" >> $HOME/.pythonstartup ; export PYTHONSTARTUP=$HOME/.pythonstartup ; python
Je kunt export PYTHONSTARTUP=$HOME/.pythonstartuptoevoegen aan je ./bashrc-bestand
Omdat waar ik om geef, ruimte is; een aanroep van de functie zal de beschrijving van de python-interpreter niet weergeven bij het opstarten, maar u kunt clear()verwijderen om deze te behouden.
Als je het als een normale functie gebruikt, zou het moeten lukken zonder de afsluitstatus af te drukken:
>>> clear()
Als u het argument 0 doorgeeft aan de functie, wordt het scherm leeggemaakt en met succes afgesloten, zodat u de shell in een schoon scherm kunt blijven gebruiken
>>> clear(0)
Antwoord 24
Voor Windows, alleen op de opdrachtregel van de interpreter (niet de GUI)! Typ eenvoudig:
(Vergeet niet om de juiste inspringing te gebruiken met python):
import os
def clear():
os.system('cls')
Elke keer dat u clear()typt op de shell (opdrachtregel), wordt het scherm op uw shell gewist. Als u de shell verlaat, moet u het bovenstaande opnieuw doen om het opnieuw te doen als u een nieuwe Python-shell (opdrachtregel) opent.
Opmerking: het maakt niet uit welke versie van Python je gebruikt, expliciet (2.5, 2.7, 3.3 & 3.4).
Antwoord 25
Het geaccepteerde antwoordis een goede oplossing. Het probleem ermee is dat het tot nu toe alleen werkt op Windows 10, Linux en Mac. Ja Windows (bekend om het gebrek aan ANSI-ondersteuning)! Deze nieuwe functie is geïmplementeerd op Windows 10 (en hoger) en bevat ANSI-ondersteuning, hoewel u deze moet inschakelen. Dit zal het scherm op een cross-platform manier wissen:
import os
print ('Hello World')
os.system('')
print ("\x1B[2J")
Op alles onder Windows 10 geeft het echter dit terug:
[2J
Dit komt door het ontbreken van ANSI-ondersteuning op eerdere Windows-builds. Dit kan echter worden opgelost met behulp van de module colorama. Dit voegt ondersteuning toe voor ANSI-tekens op Windows:
ANSI-escapetekenreeksen worden al lang gebruikt om gekleurde terminaltekst en cursorpositie op Unix en Macs te produceren. Colorama laat dit ook werken op Windows door stdout in te pakken, gevonden ANSI-reeksen te strippen (die in de uitvoer als gobbledygook zouden verschijnen) en ze om te zetten in de juiste win32-aanroepen om de status van de terminal te wijzigen. Op andere platforms doet Colorama niets.
Dus hier is een cross-platform methode:
import sys
if sys.platform == 'win32':
from colorama import init
init()
print('Hello World')
print("\x1B[2J")
Of print(chr(27) + "[2J")gebruikt in plaats van print("\x1B[2J").
@poke antwoord is erg onveilig op Windows, ja het werkt, maar het is echt een hack. Een bestand met de naam cls.batof cls.exein hetzelfde woordenboek als het script zal conflicteren met de opdracht en het bestand uitvoeren in plaats van de opdracht, waardoor een enorm veiligheidsrisico ontstaat .
Een methode om het risico te minimaliseren zou kunnen zijn om de locatie te wijzigen waar de opdracht clswordt aangeroepen:
import os
os.system('cd C:\\Windows|cls' if os.name == 'nt' else 'clear')
Dit zal de Currant Dictionary veranderen in C:\Window(backslash is hier belangrijk) en vervolgens uitvoeren. C:\Windowsis altijd aanwezig en heeft beheerdersrechten nodig om daar te schrijven, waardoor het goed is om deze opdracht uit te voeren met minimaal risico. Een andere oplossing is om de opdracht via PowerShell uit te voeren in plaats van de opdrachtprompt, omdat deze is beveiligd tegen dergelijke kwetsbaarheden.
Er worden ook andere methoden genoemd in deze vraag: Scherm in shell wissendie ook van pas kunnen komen.
Antwoord 26
Standaard retourneert os.system("clear")/os.system("cls")een int-type als 0.
We kunnen het scherm volledig leegmaken door het toe te wijzen aan een variabele en die te verwijderen.
def clear():
if (os.name == 'nt'):
c = os.system('cls')
else:
c = os.system('clear')
del c # can also omit c totally
#clear()
Antwoord 27
Dit werkt op alle platforms en het werkt ook in Python 2 en 3.
def clear(number):
for i in range(number):
print(" ")
Om te wissen typt u gewoon clear(numberhere).