Wyczyść terminal w Pythonie

Prostym i wieloplatformowym rozwiązaniem byłoby użycie komendy {[1] } w systemie Windows lub clear w systemach uniksowych. Używany z os.system, ładnie to wygląda:

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

Dlaczego nikt nie mówił tylko o robieniu Ctrl+L .
Z pewnością najprostszy sposób czyszczenia ekranu.

Jeśli korzystasz z systemu Linux/UNIX, drukowanie sekwencji escape ANSI w celu wyczyszczenia ekranu powinno zadziałać. Będziesz również chciał przesunąć kursor na górę ekranu. Będzie to działać na każdym terminalu obsługującym ANSI.

import sys
sys.stderr.write("\x1b[2J\x1b[H")

To nie będzie działać w systemie Windows, chyba że obsługa ANSI została włączona. Może istnieje równoważna Sekwencja Sterowania Dla Windows, ale nie wiem.

Jako mądra osoba raz wysłana, dla przynajmniej Linuksa, możesz zrobić odpowiednik Pythona, którego możesz użyć w wierszu poleceń. Oczyści ekran bardziej niż polecenie Linuksa clear (tak, że nie możesz przewijać w górę, aby zobaczyć swój tekst):

printf "\033c"

Dla Windows możesz po prostu użyć cls.

Oto Jak to zrobić w Pythonie:

import subprocess
subprocess.call(["printf", "'\033c'"])

Oto inny sposób na to, aby to zrobić w Pythonie (który działa przynajmniej na moim komputerze):

print("\033c")

Nie mam pojęcia czy to działa w Windowsie czy na Mac, iOS, Android itp. chociaż.

Możesz użyć odpowiedzi innych osób, aby znaleźć bardziej wieloplatformowy sposób na wdrożenie tego.

Jak powiedziała rolika w komentarzach, możesz to zrobić, aby zapobiec wydrukowaniu nowej linii:

print("\033c", end="")

Jak dla mnie najbardziej elegancki wariant:

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

Możesz spróbować polegać na clear, ale może nie być on dostępny we wszystkich dystrybucjach Linuksa. W systemie windows użyj cls, jak wspomniano.

import subprocess
import platform

def clear():
    subprocess.Popen( "cls" if platform.system() == "Windows" else "clear", shell=True)

clear()

Uwaga: przejęcie kontroli nad ekranem terminala może być uznane za złą formę. Rozważasz użycie opcji? Prawdopodobnie lepiej byłoby pozwolić użytkownikowi zdecydować, czy chce wyczyścić ekran.

Czyste rozwiązanie Pythona.
Nie opiera się ani na ANSI, ani na zewnętrznych poleceniach.
Tylko twój terminal musi mieć możliwość poinformowania, ile linii jest w widoku.

from shutil import get_terminal_size
print("\n" * get_terminal_size().lines, end='')

Wersja Pythona > = 3.3.0

Natknąłem się na to jakiś czas temu

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)

Następnie po prostu użyj clearscreen ()

Więc pomyślałem, że wrzucę tu moje dwa centy...

Nikt nie podał prawdziwej odpowiedzi na pytanie OP wydaje się, każdy albo odpowiada z " NO DONT USE os.system() it ' s evil!!!"bez wyjaśnień lub zapewnia rozwiązanie polegające na drukowaniu nowych linii.

Dla tych, którzy muszą wyczyścić ekran terminala i przewiń do tyłu, z dowolnego powodu, możesz użyć następującego kodu:

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

To ma pożądany efekt OP. Używa systemu operacyjnego.polecenie system () so jeśli to zło i ktoś zna sposób implementacji tego za pomocą podprocesu.call () proszę o komentarz, ponieważ ja też wolałbym użyć podprocesu, ale w ogóle go nie znam.

Możesz przedzierać się przez bazę danych terminfo, ale funkcje do tego służą i tak są w curses.

python -c "from os import system; system('clear')"

Ta funkcja działa w gnome-terminal, ponieważ domyślnie rozpoznaje sekwencje escape ANSI. Daje czysty znak zachęty rows_max Odległość od dołu terminala, ale także dokładnie od miejsca, w którym został wywołany. Daje Ci pełną kontrolę nad tym, ile trzeba wyczyścić.

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

Realizacja:

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: rows to liczba wierszy tekstu do dodania między znakiem zachęty a spodem terminala, przesuwając wszystko w górę. rows_max jest wysokością terminala (lub max wysokość wyczyszczenia) w wierszach tekstowych i musi być ustawiona tylko raz, ale można ją zresetować w dowolnym momencie. *, w pozycji trzeciego parametru oznacza, że wszystkie poniższe parametry są tylko słowami kluczowymi(np. clear (absolute=5)). calling_line=True (domyślnie) działa lepiej w trybie interaktywnym. calling_line=False działa lepiej dla aplikacji tekstowych, terminali. absolute został dodany, aby spróbować naprawić problemy z glitchy gap w trybie interaktywnym po zmniejszeniu rozmiaru terminala, ale może być również używany do aplikacji terminalowych. store_max jest tylko dla tajemnicy, "persistent" storage of rows_max value; nie używaj jawnie tego parametru. (Gdy argument nie jest przekazany dla store_max, zmiana zawartości listy store_max zmienia domyślną wartość tego parametru. Stąd trwałe przechowywanie.)

Przenośność: niestety, to nie działa w trybie bezczynności, ale działa > > bardzo fajne shutil.get_terminal_size() dla najlepszych wyników) i rozpoznawania ANSI. Funkcja print(...) to Python 3. Przetestowałem to również za pomocą prostej, tekstowej, terminalowej gry Tic Tac Toe (aplikacja).

Do użytku w trybie interaktywnym: najpierw skopiuj i wklej funkcję copy(...) w trybie interaktywnym i sprawdź, czy działa dla Ciebie. Jeśli tak, to Umieść powyższą funkcję w pliku o nazwie clear.py . W terminalu uruchom Pythona, z 'python3'. Wejść:

>>> import sys
>>> sys.path
['', '/usr/lib/python3.3', ...

Teraz drop the clear.py plik do jednego z katalogów path wymienionych tak, aby Python mógł go znaleźć (nie nadpisuj żadnych istniejących plików). Do łatwego użycia od teraz:

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

Do użycia w aplikacji terminalowej: umieść funkcję copy(...) w pliku o nazwie clear.py w tym samym folderze z plikiem main . py. Oto roboczy streszczenie (szkielet) przykład z aplikacji do gry Tic Tac Toe (uruchamianej z wiersza terminala: 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()

Explanation: do_print(...) on line 19 is a version of print(...) needed to be track of how many new lines have been printed (self.rows). W przeciwnym razie musiałbyś self.rows += 1 wszędzie tam, gdzie print(...) jest wywoływany przez cały program. Więc za każdym razem, gdy plansza jest przerysowana przez wywołanie show_board() poprzednia plansza jest usuwana, a nowa jest drukowana dokładnie tam, gdzie powinna być. Notice self.clear(calling_line=False) on line 9 W zasadzie wypycha wszystko w stosunku do dolnej części terminala, ale nie czyści oryginalnej linii wywołującej. W przeciwieństwie do tego, self.clear(absolute=self.rows) on line 29 absolutnie usuwa wszystko self.rows odległość w górę, a nie tylko pchanie wszystkiego w górę w stosunku do dna terminala.

Użytkownicy Ubuntu z Pythonem 3.3: umieść #!/usr/bin/env python3 na pierwszej linii tictactoe.py plik. Kliknij prawym przyciskiem myszy na tictactoe.py file = > Properties => Permissions tab = > Check Execute: Allow executing file as program. Kliknij dwukrotnie na plik = > kliknij przycisk Uruchom w Terminalu. Jeśli katalog bieżący otwartego terminala jest katalogiem tictactoe.py plik, możesz również uruchomić plik za pomocą ./tictactoe.py.

Możesz użyć funkcji call() do wykonania poleceń terminala:

from subprocess import call
call("clear")

Jeśli chcesz wyczyścić terminal, gdy używasz powłoki Pythona. Następnie możesz wykonać następujące czynności, aby wyczyścić ekran

import os
os.system('clear')

Możesz zrobić własne. nie będzie to zależne od typu terminala lub systemu operacyjnego.

def clear(num):
    for i in range(num): print 

clear(80)
print "hello"

To wyczyści 25 nowych linii:

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

clear()

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

clear(25)

Przyjęta odpowiedź jest dobrym rozwiązaniem. Problem polega na tym, że do tej pory działa tylko na Windows 10, Linux i Mac. Tak Windows(znany z braku wsparcia ANSI)! Ta nowa funkcja została zaimplementowana w systemie Windows 10 (i nowszym), który obejmuje obsługę ANSI, chociaż musisz ją włączyć. To spowoduje wyczyszczenie ekranu w sposób wieloplatformowy:

import os

print ('Hello World')
os.system('') 
print ("\x1B[2J")

Na czymkolwiek poniżej Windows 10 zwraca jednak to:

[2J

Wynika to z braku ANSI wsparcie dla poprzednich kompilacji systemu Windows. Można to jednak rozwiązać za pomocą modułu colorama. To dodaje obsługę znaków ANSI w systemie Windows:

Sekwencje znaków specjalnych ANSI są od dawna używane do tworzenia kolorowego tekstu terminala i pozycjonowania kursora w systemach Unix i Mac. Colorama sprawia, że działa to również w systemie Windows, owijając stdout, usuwając znalezione sekwencje ANSI( które pojawiałyby się jako gobbledygook w wyjściu) i konwertując je do odpowiedniego win32 wywołania modyfikujące stan terminala. Na innych platformach Colorama nic nie robi.

Oto metoda wieloplatformowa:

import sys

if sys.platform == 'win32':
    from colorama import init
    init()

print('Hello World')

print("\x1B[2J")

Lub print(chr(27) + "[2J") używane zamiast print("\x1B[2J").

@poke odpowiedź jest bardzo niepewna w systemie Windows, tak to działa, ale to naprawdę hack. Plik o nazwie cls.bat lub cls.exe w tym samym słowniku co skrypt będzie w konflikcie z poleceniem i uruchomi plik zamiast polecenia, tworząc ogromne zagrożenie bezpieczeństwa.

Jedna metoda do cls polecenie:

import os
os.system('cd C:\\Windows|cls' if os.name == 'nt' else 'clear')

To zmieni Currant D ictionary na C:\Window (ważny jest odwrotny ukośnik), a następnie wykonaj. {[10] } jest zawsze obecny i wymaga uprawnień administracyjnych, aby tam pisać, co czyni go dobrym do wykonywania tego polecenia przy minimalnym ryzyku. Innym rozwiązaniem jest uruchomienie polecenia przez PowerShell zamiast wiersza polecenia, ponieważ zostało ono zabezpieczone przed takim słabe punkty.

Istnieją również inne metody wymienione w tym pytaniu: Clear screen in shell , które również mogą być przydatne.

Jeśli potrzebujesz tylko wyczyścić ekran, to prawdopodobnie wystarczy. Problem w tym, że nie ma nawet 100% wieloplatformowego sposobu na zrobienie tego we wszystkich wersjach Linuksa. Problem polega na tym, że implementacje terminala obsługują nieco inne rzeczy. Jestem całkiem pewien, że" jasne " będzie działać wszędzie. Ale bardziej "kompletną" odpowiedzią jest użycie znaków sterujących xterm do przesuwania kursora, ale wymaga to samego xterm.

Nie wiedząc więcej o swoim problemie, Twój rozwiązanie wydaje się wystarczające.

Być może tandetny sposób na wyczyszczenie ekranu, ale taki, który będzie działał na każdej platformie, którą znam, jest następujący:

for i in xrange(0,100):
    print ""

Zrobiłbym to w ten sposób, aby wyglądało bardziej jak bash:

Po prostu utwórz plik o nazwie .pythonstartup w katalogu domowym i używać odpowiedzi poke ' a w funkcji

Na Linuksie:

echo "from subprocess import call
def clear(int=None):  
    call('clear')
    if int == 0:
       exit()
clear()" >> $HOME/.pythonstartup ; export PYTHONSTARTUP=$HOME/.pythonstartup ; python

Możesz dodać export PYTHONSTARTUP=$HOME/.pythonstartup do swojego pliku ./bashrc

Ponieważ zależy mi na przestrzeni; wywołanie funkcji nie wyświetli opisu interpretera Pythona podczas uruchamiania, ale możesz usunąć clear(), aby go zachować.

Używanie go jak normalnej funkcji powinno załatwić sprawę bez drukowania status wyjścia:

>>> clear()

Jeśli przekażesz argument 0 do funkcji, wyczyści ekran i zakończy się pomyślnie, abyś mógł kontynuować używanie powłoki na czystym ekranie

>>> clear(0)

Dla Windows, tylko w wierszu poleceń interpretera (nie GUI)! Po prostu wpisz: (Pamiętaj, aby użyć właściwego wcięcia w Pythonie):

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

Za każdym razem, gdy wpiszesz clear() w powłokę (wiersz poleceń), oczyści ona ekran powłoki. Jeśli opuścisz powłokę, musisz powtórzyć powyższe, aby zrobić to ponownie podczas otwierania nowej powłoki Pythona (linia poleceń).

Uwaga: nie ma znaczenia, jakiej wersji Pythona używasz, jawnie (2.5, 2.7, 3.3 & 3.4).

W Windows możesz użyć:

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

Po prostu użyj:

print("\033c")

Spowoduje to wyczyszczenie okna terminala.

Domyślnie, os.system("clear")/os.system("cls") zwróci typ int jako 0. Możemy całkowicie wyczyścić ekran przypisując go do zmiennej i usuwając go.

def clear():
    if (os.name == 'nt'):    
        c = os.system('cls')
    else:
        c = os.system('clear')
    del c  # can also omit c totally

#clear()

To działa na wszystkich platformach i działa zarówno w Pythonie 2 jak i 3.

def clear(number):
    for i in range(number):
        print(" ")

Następnie aby wyczyścić wystarczy wpisać clear(numberhere).