Como a maioria dos desenvolvedores de Python, normalmente mantenho uma janela do console aberta com o interpretador Python em execução para testar comandos, dir()coisas help() stuffetc.

Como qualquer console, depois de um tempo, a lista de pendências visível de comandos e impressões anteriores fica desorganizada e, às vezes, confusa ao executar o mesmo comando várias vezes. Gostaria de saber se e como limpar o console do interpretador Python.

Ouvi falar de fazer uma chamada de sistema e de ligar clsno Windows ou clearno Linux, mas esperava que houvesse algo que eu pudesse ordenar que o próprio intérprete fizesse.

Nota: Estou executando no Windows, então Ctrl+Lnão funciona.

Como você mencionou, você pode fazer uma chamada do sistema:

Para Windows

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

Para Linux, o lambda se torna

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

aqui algo útil que é um pouco mais multiplataforma

import os

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

# now, to clear the screen
cls()

Bem, aqui está um truque rápido:

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

Ou, para economizar digitação, coloque este arquivo no seu caminho de pesquisa python:

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

wipe = Wipe()

Então você pode fazer isso com o intérprete tudo o que quiser :)

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

Embora essa seja uma pergunta mais antiga, pensei em contribuir com algo que resumisse as melhores respostas e acrescentar minhas próprias rugas, sugerindo que você coloque esses comandos em um arquivo e defina seu PYTHONSTARTUP variável de ambiente para apontar para ele. Como estou no Windows no momento, é um pouco tendencioso dessa maneira, mas pode ser facilmente inclinado em outra direção.

Aqui estão alguns artigos que descrevi como definir variáveis ​​de ambiente no Windows:
    Quando usar sys.path.append e modificar% PYTHONPATH% é suficiente
    Como gerenciar variáveis ​​de ambiente no Windows XP
    Configurando variáveis ​​de ambiente do sistema e do usuário
    Como usar o sistema global Variáveis ​​de ambiente no Windows

Aliás, não coloque aspas no caminho do arquivo, mesmo que ele contenha espaços.

De qualquer forma, aqui está a minha opinião sobre o código para inserir (ou adicionar ao seu script de inicialização Python existente):

# ==== 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, você também pode usar o __repr__ truque do @ Triptych para mudar exit()para just exit(e idem para seu apelido quit):

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

quit = exit = exit()

Por fim, aqui está outra coisa que altera o prompt do intérprete principal de >>>para cwd + >>>:

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

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

Você tem várias maneiras de fazer isso no Windows:

1. Usando o atalho do teclado:

Press CTRL + L

2. Usando o método de chamada do sistema:

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

3. Usando a nova linha de impressão 100 vezes:

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

A maneira mais rápida e fácil, sem dúvida, é Ctrl+ L.

É o mesmo para o OS X no terminal.

minha maneira de fazer isso é escrever uma função assim:

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

depois ligue clear()para limpar a tela. isso funciona no Windows, OSX, Linux, BSD ... todos os sistemas operacionais.

Aqui está um snippet de versão de plataforma cruzada (Windows / Linux / Mac / provavelmente outros que você pode adicionar no if check) que fiz combinando as informações encontradas nesta pergunta:

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

Mesma idéia, mas com uma colher de açúcar sintático:

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

O limpador é legal, o bom é que não preciso digitar '()' ao redor dele. Aqui está uma pequena variação

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

O uso é bastante simples:

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

Essa é a coisa mais simples que você pode fazer e não requer bibliotecas adicionais. Ele limpará a tela e retornará >>>ao canto superior esquerdo.

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

para o usuário mac dentro do tipo de console python

import os
os.system('clear')

para Windows

os.system('cls')

Aqui está a solução definitiva que mescla todas as outras respostas . Recursos:

1. Você pode copiar e colar o código em seu shell ou script.

2. Você pode usá- lo como quiser:

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

3. Você pode importá- lo como um módulo:

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

4. Você pode chamá- lo como um script:

   $ python clear.py

5. É verdadeiramente multiplataforma ; se não conseguir reconhecer seu sistema
   ( ce,nt ,dos ou posix) ele vai cair de volta para imprimir linhas em branco.

Você pode baixar o arquivo [completo] aqui: https://gist.github.com/3130325
Ou se você está apenas procurando o código:

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

Eu uso o iTerm e o aplicativo de terminal nativo para Mac OS.

Eu apenas pressione ⌘ + k

Use ocioso. Possui muitos recursos úteis. Ctrl+F6, por exemplo, redefine o console. Fechar e abrir o console são boas maneiras de limpá-lo.

Não tenho certeza se o "shell" do Windows suporta isso, mas no Linux:

print "\033[2J"

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

Na minha opinião, ligar clscom osé uma má ideia em geral. Imagine se eu conseguir alterar o comando cls ou clear no seu sistema e você executar o script como administrador ou root.

Estou usando o MINGW / BASH no Windows XP, SP3.

(coloque isso em .pythonstartup)
# Meu ctrl-l já funcionou, mas isso pode ajudar alguém
# # deixa o prompt na parte inferior da janela ...
import readline
readline.parse_and_bind ('\ Cl: clear-screen')

# Isso funciona no BASH porque eu também o tenho no .inputrc, mas, por algum
motivo, # é descartado quando entro no Python
readline.parse_and_bind ('\ Cy: kill-whole-line')

Eu não aguentava mais digitar 'exit ()' e fiquei encantada com os truques de martineau / Triptych:

Eu o levantei levemente (coloquei no .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

O comando do SO clearno Linux e clsno Windows gera uma "string mágica" que você pode imprimir. Para obter a string, execute o comando com popen e salve-o em uma variável para uso posterior:

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

print clear

Na minha máquina, a corda é '\x1b[H\x1b[2J'.

Aqui estão duas maneiras legais de fazer isso:

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 estiver no mac, um simples cmd + kdeve fazer o truque.

A maneira mais fácil é usar o módulo OS

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

Deve ser multiplataforma e também usa o preferido, em subprocess.callvez de os.systemconforme os os.systemdocumentos . Deve funcionar em 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

Que tal isso para uma clara

- os.system('cls')

Isso é o mais curto possível!

Eu sou novo no python (realmente muito novo) e em um dos livros que estou lendo para me familiarizar com a linguagem que eles ensinam como criar essa pequena função para limpar o console do backlog visível e dos comandos e impressões anteriores:

Abrir shell / Criar novo documento / Criar função da seguinte maneira:

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

Salve-o dentro da pasta lib no diretório python (o meu é C: \ Python33 \ Lib) Da próxima vez que você precisar limpar o console, chame a função com:

clear()

é isso aí. PS: você pode nomear sua função da maneira que quiser. Vi pessoas usando "limpador", "limpador" e variações.

Estou usando o Spyder (Python 2.7) e, para limpar o console do intérprete,

%Claro

isso força a linha de comando a ir para o topo e não verei os comandos antigos anteriores.

ou clique em "opção" no ambiente do console e selecione "Reiniciar o kernel" que remove tudo.

Eu posso estar atrasado para a parte, mas aqui está uma maneira muito fácil de fazer isso

Tipo:

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

Então, o que você quiser limpar a tela, basta digitar seu código

cls()

Melhor maneira possível! (Crédito: https://www.youtube.com/watch?annotation_id=annotation_3770292585&feature=iv&src_vid=bguKhMnvmb8&v=LtGEp9c6Z-U )

Basta entrar

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

Se você não precisar fazer isso através do código, basta pressionar CTRL + L

Arch Linux (testado xfce4-terminalcom 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'")

... Adicionado a ~/.pythonrc

• clear() limpa a tela
• wipe() limpa todo o buffer do terminal

EDIT: Acabei de ler "windows", isto é para usuários linux, desculpe.

Na festança:

#!/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

Salve-o como "whatyouwant.sh", chmod + x e execute:

./whatyouwant.sh python

ou algo diferente de python (ocioso, qualquer que seja). Isso perguntará se você realmente deseja sair; caso contrário, execute novamente o python (ou o comando que você deu como parâmetro).

Isso limpará tudo, a tela e todas as variáveis ​​/ objeto / qualquer coisa que você tenha criado / importado em python.

Em python, basta digitar exit () quando quiser sair.

OK, essa é uma resposta muito menos técnica, mas estou usando o plug-in Python para o Notepad ++ e você pode simplesmente limpar o console manualmente clicando com o botão direito do mouse e clicando em "limpar". Espero que isto seja útil a alguém!