27 Domanda: Terminale chiaro in Python [duplicato]

domanda creata a Tue, Mar 6, 2018 12:00 AM
    

Questa domanda ha già una risposta qui:

    

Esiste un metodo standard "viene fornito con le batterie" per cancellare lo schermo del terminale da uno script Python, o devo andare a maledire (le librerie, non le parole)?

    
166
  1. Vorrei controllare Windows e usare 'cls' e fare incondizionatamente un clear per tutto, perché sarebbe probabile che coprisse la maggior parte dei casi. Vedi domanda correlata Come eliminare la console dell'interprete python? .
    2011-01-26 20: 30: 39Z
  2. 2016-06-12 17: 11: 25Z
  3. 27 risposte                              27                         

    E riguardo le sequenze di escape?

     
    print(chr(27) + "[2J")
    
        
    96
    2015-01-21 20: 35: 15Z
    1. Nota che questo non è portabile su tutti i tipi di terminale ... non che ti imbatterai in troppi tipi dispari in questi giorni ...
      2010-01-18 07: 44: 56Z
    2. Questa tecnica porta il cursore in basso. Prova Ctrl + L, l'effetto è diverso. Penso che lo script debba riportare la posizione del cursore in cima alla riga.
      2013-02-19 13: 15: 32Z
    3. O ora, in Python3, stampa (chr (27) + "[2J")
      2014-01-18 19: 01: 46Z
    4. print ('\x1b [2J') - funziona anche in py3
      2014-03-10 16: 42: 39Z
    5. Scusate ragazzi ma non ho potuto resistere: imgs.xkcd.com/comics/real_programmers.png
      2018-04-09 08: 37: 17Z

    Una soluzione semplice e multipiattaforma consisterebbe nell'usare il comando cls su Windows o clear su sistemi Unix. Utilizzato con os.system , questo rende un buon one-liner:  

    import os
    os.system('cls' if os.name == 'nt' else 'clear')
    
        
    264
    2014-02-03 14: 43: 02Z
    1. @ allyourcode Il codice nella mia risposta è esplicitamente sicuro dalle iniezioni perché non vi è alcun input dell'utente coinvolto. Tutte le stringhe che potrebbero essere passate a os.system sono corrette.
      2016-03-26 00:10: 22Z
    2. Il codice è esplicitamente sbagliato, perché si esegue un intero processo quando tutto ciò di cui si ha bisogno è di stampare alcune newline (che è ciò che fanno sia clear che cls): print("\n" * 100)
      2016-06-02 05: 23: 15Z
    3. @ jsbueno Al momento non posso parlare di Unix, ma cls su Windows not stampa linee vuote. Cancella esplicitamente il buffer della console, quindi è not equivalente alla stampa di qualsiasi quantità di spazio bianco. Inoltre, il codice funziona sorprendentemente bene per qualcosa che è "esplicitamente sbagliato". Forse non ti piace, ma questo non lo rende sbagliato (per non dire che cls su Windows non è un processo ma una funzionalità dell'host della console, ad esempio cmd.exe o PowerShell).
      2016-06-02 06: 36: 30Z
    4. Quindi, ciò implica che cls e clear sono intrinsecamente diversi - poiché clear è un processo esterno e non cancella il buffer - il che rende la soluzione incoerente oltre a quella inefficiente cls una shell integrata in Windows, ma la chiamata system eseguirà comunque una nuova shell. "La funzione di sistema passa il comando all'interprete dei comandi, che esegue la stringa come comando del sistema operativo, che utilizza le variabili di ambiente COMSPEC e PATH per individuare il file CMD.exe del comando-interprete." # msdn.microsoft.com/en-us/library/277bwbdz.aspx
      2016-06-02 14: 49: 46Z

    Perché nessuno ha parlato semplicemente di fare Ctrl + L in Windows o Cmd + L in Mac. Sicuramente il modo più semplice per cancellare lo schermo.

        
    68
    2018-12-17 16: 31: 04Z
    1. Questa è la migliore risposta finora. Inoltre sai come posso scorrere la mia console Python, perché quando lo schermo si riempie devo scrivere sull'ultima riga e non scorrere verso l'alto.
      2015-06-08 15: 00: 36Z
    2. Sono su Ubuntu e stavo usando os.system('clear') ma penso che la tua risposta sia il modo più semplice. Upvoted! :)
      2015-08-25 12: 42: 33Z
    3. @ ParagGangil Non è la migliore risposta per coloro che vogliono programmaticamente cancellare lo schermo.
      2015-10-01 22: 49: 46Z
    4. In che modo questa risposta non è al top, è di gran lunga il migliore
      2016-06-05 09: 37: 42Z
    5. Non funziona. Basta digitare ^ L in comando (console Python in Windows 10)
      2017-02-07 19: 45: 01Z

    Se si è su un sistema Linux /UNIX, stampare la sequenza di escape ANSI per cancellare lo schermo dovrebbe fare il lavoro. Dovrai anche spostare il cursore nella parte superiore dello schermo. Funzionerà su qualsiasi terminale che supporti ANSI.

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

    Questo non funzionerà su Windows a meno che il supporto ANSI sia stato abilitato. Potrebbe esserci una sequenza di controllo equivalente per Windows, ma non lo so.

        
    35
    2011-02-20 16: 34: 11Z
    1. Poiché la tua risposta implicava che stai usando Python 2.x, e dal 2.x print (senza sintonizzazione softspace e /o sys.stdout.flush()) non puoi sempre lascia il cursore nell'angolo in alto a sinistra dello schermo, ho modificato la tua risposta a qualcosa che può essere usato sia in Python 2.x che in 3.x
      2011-02-20 16: 36: 55Z
    2. Per chiunque si chieda, la stringa è una serie di Codici di escape ANSI . \x1b [è un introduttore di sequenza di controllo (hex 0x1B). Il codice 2J cancella l'intero schermo. Il codice H imposta la posizione del cursore e, senza parametri, imposta l'angolo in alto a sinistra.
      2013-07-28 00: 57: 08Z
    3. Puoi spiegare perché stai scrivendo su stderr invece di stdout, per favore?
      2014-02-11 23: 40: 07Z
    4. Posso confermare che stderr è bufferizzato su mio macchina che esegue Arch Linux, zsh e Python3 all'interno di tmux (su ssh) - richiedendomi per eseguire sys.stderr.flush(). print() funziona davvero altrettanto bene.
      2014-11-06 01: 04: 22Z
    5. import colorama; colorama.init() rende la sequenza "\x1b[2J\x1b[H" anche su Windows.
      2016-03-05 21: 00: 05Z

    Per Windows, Mac e Linux, puoi usare il seguente codice:

     
    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 ha testato print("\033c", end="") per Mac e l'ho testato su Linux e Windows (non funziona per Windows, quindi l'altro codice che chiama cls). Non ricordo chi fosse la prima volta che ho visto usare print ("\033c") e /o la versione printf: subprocess.Popen("printf '\033c'", shell=True).communicate().

    rolika ha sottolineato che end="" gli impedirà di stampare una nuova riga in seguito.

        
    28
    2019-01-23 23: 49: 59Z
    1. Funziona anche per me (usando print ("\033c")) e penso che questa sia la soluzione migliore. Non è necessario importare os durante il confronto con os.system ('clear'). Si cancella anche senza scrollback.
      2015-01-14 23: 06: 54Z
    2. Basta inviare il comando del terminale per cancellare lo schermo come descritto qui è in effetti un ottimo modo per farlo. Se vuoi (molto) materiale terminale più elaborato, puoi usare una libreria come benedizioni
      2016-03-02 18: 02: 03Z
    3. Qualcuno sa che cosa significa \033c?
      2016-04-21 13: 50: 34Z
    4. @ AbyW \033 è il numero ottale per ESC la sequenza di escape in ASCII, equivalente a \x1b in esadecimale. < ESC > c è una sequenza di escape per ripristinare tutte le impostazioni del terminale predefinite.
      2018-01-31 20: 53: 31Z
    5. print("\033c", end="") se non si desidera stampare una nuova riga
      2018-07-08 08: 14: 25Z

    Per quanto mi riguarda, la variante più elegante:

     
    import os
    os.system('cls||clear')
    
        
    23
    2016-04-29 14: 51: 44Z
    1. import os e os.system ('clear') funzionano su OS X.
      2016-08-18 10: 06: 41Z
    2. Questa è davvero una soluzione davvero interessante - non mi ero reso conto che fosse particolarmente possibile ...
      2017-02-15 13: 04: 57Z
    3. @ SirJames, davvero facile. Windows accetta "cls" e ignora le altre funzioni di esecuzione di Unix che sanno ignorare "cls"
      2017-02-15 20: 07: 33Z
    4. Sì, sono a conoscenza della funzionalità che cmd prompt e bash possono fare ... Ma semplicemente non ho fatto clic che potrei farlo in Python proprio come facilmente.
      2017-02-17 11: 52: 36Z
    5. Abbastanza pulito ... simile a pip3 installa clear-screen
      2019-01-27 11: 26: 47Z

    Potresti provare a fare affidamento su clear ma potrebbe non essere disponibile su tutte le distribuzioni Linux. Su Windows usa cls come hai menzionato.

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

    Nota: potrebbe essere considerata una cattiva forma per prendere il controllo dello schermo del terminale. Stai pensando di utilizzare un'opzione? Probabilmente sarebbe meglio lasciare che l'utente decida se vuole cancellare lo schermo.

        
    8
    2011-01-26 18: 28: 48Z
    1. Perché os.system? Qual è il vantaggio qui?
      2011-01-26 18: 01: 03Z
    2. @ TryPyPy Il mio errore. il sottoprocesso è inteso per sostituire os.system, dovrei usarlo invece. OP aveva ragione.
      2011-01-26 18: 13: 41Z
    3. Io userei subprocess.call() per qualcosa di semplice come questa chiamata però.
      2013-10-28 16: 03: 42Z

    Una soluzione Pure Python.
    Non si basa su ANSI o comandi esterni.
    Solo il tuo terminale deve essere in grado di dirti quante linee sono in vista.

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

    Versione di Python > = 3.3.0

        
    7
    2014-06-01 12: 58: 13Z
    1. Non lascia il cursore nella parte inferiore dello schermo?
      2016-08-09 07: 54: 40Z

    È passato attraverso questo tempo fa

     
    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)
    

    Quindi usa solo clearscreen ()

        
    5
    2017-06-24 19: 32: 38Z
    1. Mi piace quanto sia portatile questa soluzione.
      2017-11-04 17: 34: 11Z

    Quindi ho pensato di buttare i miei due centesimi qui ...

    Nessuno ha fornito una risposta vera alla domanda OP, a quanto pare, tutti rispondono con "NO DONT USE os.system () è malvagio !!!" senza spiegazione o fornisce una soluzione che si basa sulla stampa di nuove linee.

    Per coloro che devono cancellare la schermata del terminale e scorrere indietro, per qualsiasi ragione, puoi usare il seguente codice:

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

    Questo ha l'effetto desiderato dell'OP. Usa il comando os.system () quindi se questo è malvagio e qualcuno conosce un modo per implementarlo usando subprocess.call (), per favore commenta come preferirei usare il sottoprocesso ma non ho alcuna familiarità con esso.

        
    4
    2018-08-24 19: 32: 30Z
    1. Questo funziona per me su Raspberry Pi. La risposta di Joril non ripristina il cursore nella parte superiore dello schermo.
      2018-01-05 09: 25: 36Z
    2. 2018-03-06 14: 31: 23Z
    3. @ Simon, il tuo riferimento non è multipiattaforma come richiesto OP ma si rivolge invece ai dispositivi Darwin. Sì 'clear' funziona in alcuni ambienti nix ma non tutti, mentre 'cls' è specifico per Windows e 'echo -e \\\\033c' funziona in tutti gli ambienti Bash
      2018-05-22 01: 21: 23Z
    4. OK, mi dispiace per quello. Devo dire che corro su Windows e talvolta su Ubuntu, quindi non so molto sui diversi ambienti.
      2018-05-22 07: 51: 06Z

    Questo funzionerà sia in versione Python2 che in Python3

     
    print (u"{}[2J{}[;H".format(chr(27), chr(27)))
    
        
    4
    2018-10-23 13: 00: 46Z
    1. print (u"{}[2J{}[;H".format(chr(27), chr(27)), end="") per rimuovere la newline.
      2019-02-06 13: 24: 02Z

    Questa funzione funziona in gnome-terminal perché, per impostazione predefinita, riconosce le sequenze di escape ANSI. Ti dà una distanza di CLEAN PROMPT rows_max dal fondo del terminale, ma anche precisamente da dove è stata chiamata. Ti dà il controllo completo su quanto cancellare.

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

    Implementazione:

     
    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
    

    Parametri: rows è il numero di righe di testo chiare da aggiungere tra il prompt e il terminale inferiore, spingendo tutto in alto. rows_max è l'altezza del terminale (o altezza di cancellazione massima) nelle righe di testo e deve essere impostata solo una volta, ma può essere ripristinata in qualsiasi momento. *, nella terza posizione dei parametri significa che tutti i seguenti parametri sono solo parole chiave (ad esempio, clear (absolute = 5)). calling_line=True (predefinito) funziona meglio in modalità interattiva. calling_line=False funziona meglio per le applicazioni terminali basate su testo. absolute è stato aggiunto per provare a risolvere i problemi di gap glitch in modalità interattiva dopo aver ridotto le dimensioni del terminale, ma può anche essere utilizzato per le applicazioni terminali. store_max è solo per la memorizzazione "permanente" di rows_max valori; non usare esplicitamente questo parametro. (Quando non viene passato un argomento per store_max, la modifica del contenuto dell'elenco di store_max modifica il valore predefinito di questo parametro. Quindi, l'archiviazione persistente.)

    Portabilità: mi spiace, questo non funziona in IDLE, ma funziona > > MOLTO FRESCO < < in modalità interattiva in un terminale (console) che riconosce le sequenze di escape ANSI. L'ho provato solo in Ubuntu 13.10 usando Python 3.3 in gnome-terminal. Quindi posso solo supporre che la portabilità dipenda da Python 3.3 (per la funzione shutil.get_terminal_size() per i risultati BEST) e dal riconoscimento ANSI. La funzione print(...) è Python 3. Ho anche provato questo con un semplice gioco di testo Tic Tac Toe (applicazione).

    Per l'utilizzo in modalità interattiva: prima copia e incolla la funzione copy(...) in modalità interattiva e verifica se funziona correttamente. In tal caso, inserire la funzione sopra in un file denominato clear.py. Nel terminale inizia python, con 'python3'. Invio:

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

    Ora rilascia il file clear.py in una delle path directory elencate in modo che Python possa trovarlo (non sovrascrivere alcun file esistente). Per usare facilmente d'ora in poi:

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

    Per l'uso in un'applicazione terminale: inserisci la funzione copy(...) in un file denominato clear.py nella stessa cartella con il tuo file principale .py. Ecco un esempio di lavoro astratto (scheletro) da un'applicazione di gioco Tic Tac Toe (esegui dal prompt del terminale: 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()
    

    Spiegazione: do_print(...) sulla riga 19 è una versione di print(...) necessaria per tenere traccia di quante nuove righe sono state stampate (self.rows). Altrimenti, dovresti self.rows += 1 dappertutto dove viene chiamato print(...) per l'intero programma. Quindi ogni volta che la scheda viene ridisegnata chiamando show_board(), la scheda precedente viene cancellata e la nuova scheda viene stampata esattamente dove dovrebbe essere. Avviso self.clear(calling_line=False) on line 9 praticamente spinge tutto su RELATIVE fino in fondo al terminale, ma non cancella la linea di chiamata originale. Al contrario, self.clear(absolute=self.rows) sulla linea 29 cancella completamente la distanza self.rows verso l'alto, piuttosto che semplicemente spingendo tutto verso l'alto rispetto al fondo del terminale.

    Utenti di Ubuntu con Python 3.3: Metti #!/usr/bin/env python3 sulla prima riga del file tictactoe.py. Fai clic con il tasto destro sul file tictactoe.py = > Proprietà = > Scheda Autorizzazioni = > Check Execute: Consenti l'esecuzione del file come programma . Fai doppio clic sul file = > Fai clic sul pulsante Esegui nel terminale. Se la directory corrente di un terminale aperto è quella del file tictactoe.py, puoi anche avviare il file con ./tictactoe.py.

        
    3
    2014-02-27 13: 45: 31Z
    1. Mi stai prendendo in giro? Peggiore implementazione di un one-liner che ho visto da un po '. MrGreen Consiglia per la cancellazione.
      2018-10-02 21: 33: 15Z

    Se desideri cancellare il tuo terminale quando usi una shell python. Quindi, puoi fare quanto segue per cancellare lo schermo

     
    import os
    os.system('clear')
    
        
    3
    2018-04-15 12: 17: 37Z

    Basta usare:

     
    print("\033c")
    

    Questo cancellerà la finestra del terminale.

        
    3
    2018-06-19 06: 48: 08Z

    Potresti strappare il database terminfo, ma le funzioni per farlo sono comunque in curses.

        
    2
    2010-01-18 07: 37: 21Z

    È possibile utilizzare la funzione call() per eseguire i comandi del terminale:

     
    from subprocess import call
    call("clear")
    
        
    2
    2018-01-31 20: 30: 39Z

    puoi crearne uno tuo. questo non dipenderà dal terminale o dal tipo di sistema operativo.

     
    def clear(num):
        for i in range(num): print 
    
    clear(80)
    print "hello"
    
        
    1
    2010-01-18 08: 55: 00Z
    1. ... Non hai bisogno della stringa vuota letterale lì. ... Che cosa? Sto cercando di rimanere positivo qui!
      2010-01-18 08: 05: 01Z
    2. sei pedante, ma te lo darò
      2010-01-18 08: 55: 17Z

    Questo cancellerà 25 nuove righe:

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

    Uso eclipse con pydev. La soluzione newline mi piace meglio di per num in range . Il ciclo per genera avvisi, mentre la stampa newline no. Se si desidera specificare il numero di nuove righe nell'istruzione chiara, provare questa variante.

     
    def clear(j):
        print(' \n' * j)
    
    clear(25)
    
        
    1
    2013-04-30 12: 05: 53Z
    1. 25 linee oggi non sono certo uno standard - 70 righe sono più garantite per far scorrere tutte le linee che verranno usate in un terminale serio (i vari remake della shell DOS della finestra non vengonoconsiderato serio, principalmente a causa delle limitazioni dell'interfaccia utente)
      2016-06-02 05: 25: 38Z

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

        
    1
    2013-04-30 12: 24: 20Z
    1. Per favore, no. È terribile.
      2010-01-18 07: 41: 35Z
    2. bene, funziona. Un po 'aggressivo però.
      2010-01-18 07: 43: 09Z
    3. system('clear') è terribile? Non sono d'accordo.
      2010-01-18 07: 43: 25Z
    4. support.microsoft.com/kb/99261 - è meno terribile di win32api:)
      2010-01-18 08: 44: 38Z
    5. @ alllyourcode Non lo suggeriscono tutti nei casi in cui i comandi sono stringhe fisse? Quindi non è consigliabile rimuovere un file in bash con rm file - poiché qualcuno potrebbe fraintenderlo ed eseguire invece rm -rf / come utente root.
      2017-04-12 20: 35: 43Z

    Se tutto ciò che serve è cancellare lo schermo, probabilmente è abbastanza buono. Il problema è che non c'è nemmeno un modo cross platform al 100% di farlo attraverso le versioni di Linux. Il problema è che le implementazioni del terminale supportano cose leggermente diverse. Sono abbastanza sicuro che "clear" funzionerà ovunque. Ma la risposta più "completa" è usare i caratteri di controllo xterm per muovere il cursore, ma questo richiede xterm in sé e per sé.

    Senza conoscere meglio il tuo problema, la tua soluzione sembra abbastanza buona.

        
    0
    2011-01-26 17: 50: 06Z

    Un modo forse scadente per cancellare lo schermo, ma quello che funzionerà su qualsiasi piattaforma che conosco, è il seguente:

     
    for i in xrange(0,100):
        print ""
    
        
    0
    2011-01-26 18: 04: 35Z
    1. Lascia il cursore alla fine della finestra. Lascia anche la possibilità di tornare a ciò che era precedentemente lì. Potrebbe essere una buona cosa o no. Inoltre, potresti voler inserire un numero maggiore dal momento che alcuni utenti potrebbero utilizzare più di 100 linee ...;)
      2011-01-26 18: 32: 20Z
    2. Puoi anche scrivere print ('\n' * 100) che funzionerà in Python 2.xe 3.x pur essendo più veloce.
      2012-05-30 15: 17: 18Z

    Lo farei in questo modo per renderlo più simile a bash:

    Crea semplicemente un file chiamato .pythonstartup nella directory Home e usa la risposta di poke in una funzione

    Su Linux:

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

    È possibile aggiungere export PYTHONSTARTUP=$HOME/.pythonstartup al file ./bashrc

    Poiché ciò che mi interessa è lo spazio; una chiamata alla funzione non visualizzerà la descrizione dell'interprete python all'avvio, ma puoi rimuovere clear() per conservarla.

    Usarlo come una normale funzione dovrebbe fare il trucco senza stampare lo stato di uscita:

     
    >>> clear()
    

    Se si passa l'argomento 0 alla funzione, si cancella lo schermo e si esce correttamente per poter continuare a usare la shell in uno schermo pulito

     
    >>> clear(0)
    
        
    0
    2018-03-06 14: 22: 37Z

    Per Windows, solo sulla riga di comando dell'interprete (non sulla GUI)! Basta digitare: (Ricorda di usare indentazione corretta con python):

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

    Ogni volta che digiti clear() sulla shell (riga di comando), si cancella lo schermo sulla tua shell. Se esci dalla shell, devi ripetere la procedura precedente per farlo di nuovo quando apri una nuova shell Python (riga di comando).

    Nota: non importa quale versione di Python stai usando, esplicitamente (2.5, 2.7, 3.3 e 3.4).

        
    0
    2018-03-06 17: 31: 58Z
    1. Questo modo può essere combinato con platform.system () per ottenere informazioni su "Windows", "Linux" o altre piattaforme di sistema, quindi impostare il comando clear per OS. Ho il mio con cls () nome come segue def cls(): if platform.system() == "Linux": os.system("clear") elif platform.system() == "Windows": os.system("cls")
      2015-08-28 03: 32: 11Z

    La risposta accettata è una buona soluzione. Il problema è che finora funziona solo su Windows 10, Linux e Mac. Sì Windows (noto per la mancanza di supporto ANSI)! Questa nuova funzionalità è stata implementata su Windows 10 (e versioni successive) che include il supporto ANSI, sebbene sia necessario abilitarlo. Ciò cancellerà lo schermo in modo cross platform:

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

    Su qualsiasi cosa sotto Windows 10 tuttavia restituisce questo:

     
    [2J
    

    Ciò è dovuto alla mancanza di supporto ANSI su precedenti build di Windows. Questo può tuttavia essere risolto utilizzando il modulo colorama . Questo aggiunge il supporto per i caratteri ANSI su Windows:

      

    Le sequenze di caratteri di escape ANSI sono state utilizzate da tempo per produrre testo terminale colorato e posizionamento del cursore su Unix e Mac. Colorama rende questo lavoro anche su Windows, avvolgendo lo stdout, eliminando le sequenze ANSI che trova (che appariranno come gobbledygook nell'output) e convertendole nelle opportune chiamate win32 per modificare lo stato del terminale. Su altre piattaforme, Colorama non fa nulla.

    Quindi ecco un metodo multipiattaforma:

     
    import sys
    
    if sys.platform == 'win32':
        from colorama import init
        init()
    
    print('Hello World')
    
    print("\x1B[2J")
    

    O usato print(chr(27) + "[2J") invece di print("\x1B[2J").


    @poke answer è molto insicuro su Windows, sì funziona ma è davvero un hack. Un file chiamato cls.bat o cls.exe nello stesso dizionario dello script entrerà in conflitto con il comando ed eseguirà il file al posto del comando, creando un enorme rischio per la sicurezza.

    Un metodo per minimizzare il rischio potrebbe essere quello di cambiare la posizione in cui viene chiamato il comando cls:

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

    Questo cambierà la C urrant D ictionary a C:\Window (la barra retroversa è importante qui) quindi verrà eseguita. C:\Windows è sempre presente e richiede le autorizzazioni di amministrazione per scrivere lì, rendendolo utile nell'eseguire questo comando con un rischio minimo. Un'altra soluzione è eseguire il comando tramite PowerShell anziché Command Prompt poiché è stato protetto da tali vulnerabilità.

    Esistono anche altri metodi menzionati in questa domanda: Cancella schermo nella shell che potrebbe anche essere utile.

        
    0
    2018-03-06 19: 47: 23Z

    In Windows puoi usare:

     
    >>> import os
    >>> clear = lambda: os.system('cls')
    >>> clear()
    
        
    0
    2018-05-11 14: 59: 26Z

    Per impostazione predefinita, os.system("clear")/os.system("cls") restituirà un tipo int come 0. Possiamo cancellare completamente lo schermo assegnandolo a una variabile e cancellandolo.

     
    def clear():
        if (os.name == 'nt'):    
            c = os.system('cls')
        else:
            c = os.system('clear')
        del c  # can also omit c totally
    
    #clear()
    
        
    - 2
    2013-08-08 15: 17: 32Z
    1. duplicato di risposta dato più di 2 anni fa ... più lungo e meno elegante. Vedi la risposta @poke con più voti per questa domanda
      2013-08-08 15: 20: 28Z

    Funziona su tutte le piattaforme e funziona sia in Python 2 che in 3.

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

    Quindi per cancellare basta digitare clear(numberhere).

        
    - 4
    2018-05-11 14: 49: 59Z
    1. Cattivo. Per i loop sono più lenti di solo print(""*100). Inoltre non è necessario stampare lo spazio.
      2018-08-24 19: 04: 45Z
fonte posta Qui