Tutaj coś przydatnego, co jest trochę bardziej wieloplatformowe

import os

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

# now, to clear the screen
cls()

Oto szybki hack:

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

Lub aby zapisać typowanie, umieść ten plik w ścieżce wyszukiwania Pythona:

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

wipe = Wipe()

Wtedy możesz to zrobić z tłumacza ile chcesz:)

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

Chociaż jest to starsze pytanie, pomyślałem, że dodam coś podsumowującego to, co myślę, że było najlepsze z innych odpowiedzi i dodam własne zmarszczki, sugerując, że umieściłeś te polecenia w pliku i ustawiłeś zmienną środowiskową PYTHONSTARTUP, aby wskazywała na to. Ponieważ jestem na Windows w tej chwili, to jest nieco stronniczy w ten sposób, ale można łatwo pochylić w innym kierunku.

Oto kilka artykułów, które znalazłem, które opisują, jak ustawić zmienne środowiskowe na Windows:
    Kiedy używać sys./ align = "left" / dodawać i przy modyfikowaniu % PYTHONPATH % wystarczy
    Jak zarządzać zmiennymi środowiskowymi w Windows XP
    Konfiguracja zmiennych środowiskowych Systemu i Użytkownika
     Jak używać globalnych zmiennych systemowych w systemie Windows

BTW, nie umieszczaj cudzysłowów wokół ścieżki do pliku, nawet jeśli zawiera spacje.

Tak czy siak, oto moje zdanie na temat kodu do wstawienia (lub Dodaj do istniejącego skryptu startowego Pythona:

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

BTW, możesz też użyć @ tryptyku __repr__ trick to change exit() into just exit (and ditto for its alias quit):

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

quit = exit = exit()

Na koniec jest jeszcze coś, co zmienia główny znak zachęty interpretera z >>> na +>>>:

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

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

Masz wiele sposobów, aby to zrobić w Windows:

1. Użycie skrótu klawiaturowego:

Press CTRL + L

2. Użycie metody wywołania systemu:

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

3. Użycie nowej linii Drukuj 100 razy:

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

Najszybszym i najłatwiejszym sposobem bez wątpienia jest Ctrl+L .

To samo dotyczy OS X na terminalu.

Moim sposobem na to jest napisanie takiej funkcji:

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

Następnie wywołaj clear(), aby wyczyścić ekran. działa to na systemach windows, osx, linux, bsd... wszystkie osy.

Wiper jest fajny, dobrze, że nie muszę wpisywać '()' wokół niego. Oto mała zmiana

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

Użycie jest dość proste:

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

Oto ostateczne rozwiązanie , które łączy wszystkie inne odpowiedzi. Cechy:

1. Możesz skopiować i wkleić kod do powłoki lub skryptu.

2. Możesz używać jak chcesz:

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

3. Możesz zaimportować jako moduł:

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

4. Możesz wywołać jako skrypt:

   $ python clear.py
   

5. Jest prawdziwie wieloplatformowa ; jeśli nie potrafi rozpoznać twojego system
   (ce, nt, dos lub posix) powróci do drukowania pustych linii.

Możesz pobrać [pełny] plik tutaj: https://gist.github.com/3130325
Lub jeśli po prostu szukasz kodu:

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

Użyj bezczynności. Posiada wiele przydatnych funkcji. Ctrl + F6 , na przykład, resetuje konsolę. Zamknięcie i otwarcie konsoli to dobre sposoby na jej wyczyszczenie.

Używam iTerm i natywnej aplikacji terminalowej dla Mac OS.

Wciskam ⌘ + k

Nie jestem pewien, czy "Powłoka" systemu Windows obsługuje to, ale na Linuksie:

print "\033[2J"

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

Moim zdaniem połączenie cls z os jest ogólnie złym pomysłem. Wyobraź sobie, że uda mi się zmienić polecenie cls lub clear w Twoim systemie, a Ty uruchomisz skrypt jako admin lub root.

Używam MINGW / BASH na Windows XP, SP3.

(Włóż to .pythonstartup)
# Mój ctrl-l już działa, ale to może komuś pomóc
# pozostawia znak zachęty na dole okna...
import readline
readline.parse_and_bind ('\C-L: clear-screen')

# to działa w BASH ' u, bo mam go winputrc również, ale dla niektórych
# reason it gets dropped when I go into Python
readline.parse_and_bind ('\c-y: kill-whole-line')

Nie mogłem już znieść wpisywania 'exit ()' i byłem zachwycony trikami martineau/tryptyku:

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

Oto dwa dobre sposoby na to:

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

Oto fragment wersji cross platform (Windows / Linux / Mac / prawdopodobnie inne), który zrobiłem łącząc informacje znalezione w tym pytaniu:

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

Co powiesz na to, żeby było jasne

- os.system('cls')

Polecenie systemu operacyjnego clear w Linuksie i cls W Windows wyświetla "magiczny ciąg", który możesz po prostu wydrukować. Aby uzyskać ciąg znaków, wykonaj polecenie z popen i zapisz go w zmiennej do późniejszego użycia:

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

print clear

Na mojej maszynie ciąg jest '\x1b[H\x1b[2J'.

Jestem nowy w Pythonie (naprawdę naprawdę nowy) i w jednej z książek, które czytam, aby zapoznać się z językiem, którego uczą, jak stworzyć tę małą funkcję, aby wyczyścić konsolę widocznych zaległości i przeszłych poleceń i wydruków:

Otwórz powłokę / Utwórz nowy dokument / Utwórz funkcję w następujący sposób:

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

Zapisz go w folderze lib w Twoim katalogu Pythona (mój jest C:\Python33\Lib) Następnym razem, gdy wyczyścisz konsolę, po prostu wywołaj funkcję z:

clear()

Odkryłem, że najprostszym sposobem jest zamknięcie okna i uruchomienie modułu / skryptu, aby ponownie otworzyć powłokę.

Użyj tego..

print '\n'*1000

Mogę się spóźnić do części, ale tutaj jest bardzo łatwy sposób, aby to zrobić

Typ:

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

Więc co chcesz wyczyścić ekran po prostu wpisz swój kod

cls()

Najlepszy możliwy sposób! (Kredyt: https://www.youtube.com/watch?annotation_id=annotation_3770292585&feature=iv&src_vid=bguKhMnvmb8&v=LtGEp9c6Z-U)

EDIT: Właśnie przeczytałem "windows", To jest dla użytkowników Linuksa, przepraszam.

W 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

Zapisz jako "whatyouwant.sh", chmod +x następnie uruchom:

./whatyouwant.sh python

Lub coś innego niż python (idle, whatever). To zapyta cię, czy rzeczywiście chcesz wyjść, jeśli nie to ponownie uruchom Pythona (lub polecenie, które podałeś jako parametr).

To wyczyści wszystko, ekran i wszystkie zmienne / obiekt / wszystko, co utworzyłeś / zaimportowałeś w Pythonie.

W Pythonie wystarczy wpisać exit() kiedy chcesz wyjść.

Powinno to być cross platform, a także używa preferowanego subprocess.call zamiast os.system zgodnie z os.system docs. Powinno działać w Pythonie >= 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

OK, więc jest to znacznie mniej techniczna odpowiedź, ale używam wtyczki Pythona do Notepad++ i okazuje się, że możesz po prostu wyczyścić konsolę ręcznie, klikając prawym przyciskiem myszy na niej i klikając "Wyczyść". Mam nadzieję, że to komuś pomoże!

>>> ' '*80*25

Aktualizacja: Rozmiar 80x25 jest mało prawdopodobny, więc aby uzyskać rzeczywiste wymiary konsoli, użyj funkcji z modułu pager . Python nie dostarcza niczego podobnego z dystrybucji core.

>>> from pager import getheight
>>> '\n' * getheight()

Magiczne łańcuchy są wymienione powyżej - myślę, że pochodzą z bazy terminfo:

Http://www.google.com/?q=x#q=terminfo

Http://www.google.com/?q=x#q=tput + command + in + unix

$ tput clear / od-T x1z 0000000 1B 5b 48 1B 5b 32 4a >.[H. [2j

Używam Spyder (Python 2.7) i do czyszczenia konsoli interpretera używam albo

%clear

To wymusza przejście linii poleceń do góry i nie będę widział poprzednich starych poleceń.

Lub klikam "option" w środowisku konsoli i wybieram "Restart kernel", który usuwa wszystko.

Wystarczy wpisać

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

Jest to najprostsza rzecz, jaką możesz zrobić i nie wymaga żadnych dodatkowych bibliotek. Oczyści ekran i powróci >>> do lewego górnego rogu.

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

Najprostszy sposób ` > > > import os

Clear = lambda: os.system ("clear") clear`) "