Come la maggior parte degli sviluppatori Python, in genere tengo aperta una finestra della console con l'interprete Python in esecuzione per testare comandi, dir()cose help() stuff, ecc.

Come ogni console, dopo un po 'il backlog visibile dei comandi e delle stampe precedenti diventa confuso e talvolta confuso quando si esegue nuovamente lo stesso comando più volte. Mi chiedo se e come cancellare la console dell'interprete Python.

Ho sentito parlare di una chiamata di sistema e di una chiamata clssu Windows o clearsu Linux, ma speravo ci fosse qualcosa che avrei potuto comandare all'interprete stesso.

Nota: sto funzionando su Windows, quindi Ctrl+Lnon funziona.

Come hai già detto, puoi fare una chiamata di sistema:

Per Windows

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

Per Linux la lambda diventa

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

qui qualcosa di utile che è un po 'più multipiattaforma

import os

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

# now, to clear the screen
cls()

Bene, ecco un trucco rapido:

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

O per salvare un po 'di battitura, inserisci questo file nel percorso di ricerca di Python:

# wiper.py
class Wipe(object):
    def __repr__(self):
        return '\n'*1000

wipe = Wipe()

Quindi puoi farlo dall'interprete tutto ciò che ti piace :)

>>> from wiper import wipe
>>> wipe
>>> wipe
>>> wipe

Anche se questa è una domanda più vecchia, ho pensato di contribuire con qualcosa che riassumesse ciò che penso fosse la migliore delle altre risposte e aggiungere una mia ruga suggerendo che hai messo questi comandi in un file e impostato PYTHONSTARTUP variabile d'ambiente per puntare ad essa. Dal momento che sono su Windows al momento, è leggermente distorto in quel modo, ma potrebbe facilmente essere inclinato in un'altra direzione.

Ecco alcuni articoli che ho trovato che descrivono come impostare le variabili di ambiente su Windows:
    Quando usare sys.path.append e quando si modifica% PYTHONPATH% è sufficiente
    Come gestire le variabili di ambiente in Windows XP
    Configurare le variabili di ambiente di sistema e utente
    Come usare il sistema globale Variabili d'ambiente in Windows

A proposito, non mettere le virgolette attorno al percorso del file anche se contiene spazi.

Ad ogni modo, ecco la mia opinione sul codice per inserire (o aggiungere al tuo script di avvio Python esistente):

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

A proposito, puoi anche usare il __repr__ trucco di @ Triptych per cambiare exit()in solo exit(e idem per il suo alias quit):

class exit(object):
    exit = exit # original object
    def __repr__(self):
        self.exit() # call original
        return ''

quit = exit = exit()

Infine, ecco qualcos'altro che cambia il prompt dell'interprete principale da >>>a cwd + >>>:

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

import sys
sys.ps1 = Prompt()
del sys
del Prompt

Hai diversi modi per farlo su Windows:

1. Usando la scorciatoia da tastiera:

Press CTRL + L

2. Utilizzando il metodo di invocazione del sistema:

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

3. Utilizzando la nuova linea di stampa 100 volte:

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

Il modo più rapido e semplice è senza dubbio Ctrl+ L.

Questo è lo stesso per OS X sul terminale.

il mio modo di farlo è scrivere una funzione in questo modo:

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

quindi chiama clear()per cancellare lo schermo. funziona su windows, osx, linux, bsd ... tutti i sistemi operativi.

Ecco uno snippet di versione multipiattaforma (Windows / Linux / Mac / probabilmente altri che puoi aggiungere nella if check) che ho creato combinando le informazioni trovate in questa domanda:

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

Stessa idea ma con un cucchiaio di zucchero sintattico:

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

Wiper è bello, il bello è che non devo digitare '()' attorno ad esso. Ecco una leggera variazione ad esso

# wiper.py
import os
class Cls(object):
    def __repr__(self):
        os.system('cls')
        return ''

L'utilizzo è abbastanza semplice:

>>> cls = Cls()
>>> cls # this will clear console.

Questa è la cosa più semplice che puoi fare e non richiede librerie aggiuntive. Cancella lo schermo e torna >>>all'angolo in alto a sinistra.

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

per l'utente mac all'interno del tipo di console python

import os
os.system('clear')

per windows

os.system('cls')

Ecco la soluzione definitiva che unisce tutte le altre risposte . Caratteristiche:

1. È possibile copiare e incollare il codice nella shell o nello script.

2. Puoi usarlo come preferisci:

   >>> clear()
   >>> -clear
   >>> clear  # <- but this will only work on a shell

3. Puoi importarlo come modulo:

   >>> from clear import clear
   >>> -clear

4. Puoi chiamarlo come uno script:

   $ python clear.py

5. È veramente multipiattaforma ; se non in grado di riconoscere il vostro sistema
   ( ce, nt, doso posix) cadrà di nuovo alla stampa di righe vuote.

Puoi scaricare il file [completo] qui: https://gist.github.com/3130325
O se stai solo cercando il codice:

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

Non sono sicuro che la "shell" di Windows supporti questo, ma su Linux:

print "\033[2J"

https://en.wikipedia.org/wiki/ANSI_escape_code#CSI_codes

A mio avviso, chiamare clscon osè generalmente una cattiva idea. Immagina se riesco a modificare il cls o a cancellare il comando sul tuo sistema e esegui lo script come admin o root.

Io uso iTerm e l'app terminale nativa per Mac OS.

Ho appena premuto ⌘ + k

Usa inattivo. Ha molte funzioni utili. Ctrl+F6, ad esempio, ripristina la console. Chiudere e aprire la console sono buoni modi per cancellarla.

Sto usando MINGW / BASH su Windows XP, SP3.

(inserisci questo in .pythonstartup)
# Il mio ctrl-l ha già funzionato, ma questo potrebbe aiutare qualcun altro
# lascia prompt nella parte inferiore della finestra però ...
import readline
readline.parse_and_bind ('\ Cl: clear-screen')

# Funziona in BASH perché ce l'ho anche in .inputrc, ma per qualche
motivo # viene eliminato quando vado in Python
readline.parse_and_bind ('\ Cy: kill-whole-line')

Non sopportavo più di digitare 'exit ()' ed ero felice dei trucchi di martineau / Triptych:

L'ho leggermente documentato (bloccato in .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

Il comando OS clearin Linux e clsin Windows genera una "stringa magica" che puoi semplicemente stampare. Per ottenere la stringa, eseguire il comando con popen e salvarlo in una variabile per un uso successivo:

from os import popen
with popen('clear') as f:
    clear = f.read()

print clear

Sulla mia macchina la stringa è '\x1b[H\x1b[2J'.

Ecco due bei modi per farlo:

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

Se è su Mac, allora un semplice cmd + kdovrebbe fare il trucco.

Il modo più semplice è usare il modulo os

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

Questo dovrebbe essere multipiattaforma e utilizza anche il preferito subprocess.callanziché os.systemsecondo i os.systemdocumenti . Dovrebbe funzionare in 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

Che ne dici di questo per un chiaro

- os.system('cls')

Questo è il più breve possibile!

Sono nuovo di Python (davvero molto nuovo) e in uno dei libri che sto leggendo per fare conoscenza con la lingua che insegnano come creare questa piccola funzione per cancellare la console del backlog visibile e i comandi e le stampe precedenti:

Apri shell / Crea nuovo documento / Crea funzione come segue:

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

Salvalo nella cartella lib nella tua directory python (la mia è C: \ Python33 \ Lib) La prossima volta che hai bisogno di cancellare la tua console, chiama la funzione con:

clear()

questo è tutto. PS: puoi nominare la tua funzione come preferisci. Iv ha visto persone che usano "tergicristallo", "wipe" e variazioni.

Sto usando Spyder (Python 2.7) e per pulire la console dell'interprete che uso entrambi

%chiaro

ciò costringe la riga di comando ad andare in cima e non vedrò i precedenti comandi precedenti.

oppure faccio clic su "opzione" nell'ambiente Console e seleziono "Riavvia kernel" che rimuove tutto.

Potrei arrivare in ritardo alla parte, ma qui è un modo molto semplice per farlo

Genere:

def cls():
    os.system("cls")

Quindi, qualunque cosa tu voglia cancellare lo schermo, digita semplicemente il tuo codice

cls()

Il modo migliore possibile! (Credito: https://www.youtube.com/watch?annotation_id=annotation_3770292585&feature=iv&src_vid=bguKhMnvmb8&v=LtGEp9c6Z-U )

Basta entrare

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

Se non è necessario farlo tramite il codice, premere CTRL + L

Arch Linux (testato xfce4-terminalcon Python 3):

# Clear or wipe console (terminal):
# Use: clear() or wipe()

import os

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

def wipe():
    os.system("clear && printf '\e[3J'")

... aggiunto a ~/.pythonrc

• clear() cancella lo schermo
• wipe() cancella l'intero buffer dei terminali

EDIT: Ho appena letto "Windows", questo è per gli utenti Linux, mi dispiace.

In 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

Salvalo come "whatyouwant.sh", chmod + x quindi esegui:

./whatyouwant.sh python

o qualcosa di diverso da Python (inattivo, qualunque cosa). Questo ti chiederà se vuoi veramente uscire, se non rieseguire Python (o il comando che hai dato come parametro).

Questo cancellerà tutto, lo schermo e tutte le variabili / oggetto / tutto ciò che hai creato / importato in Python.

In python basta digitare exit () quando si desidera uscire.

OK, quindi questa è una risposta molto meno tecnica, ma sto usando il plugin Python per Notepad ++ e si scopre che puoi semplicemente cancellare manualmente la console facendo clic con il tasto destro su di essa e facendo clic su "cancella". Spero che questo aiuti qualcuno là fuori!