Como limpar o console do intérprete?

325

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.

Soviut
fonte
Solução IPython aqui: stackoverflow.com/questions/6892191/…
onewhaleid
Estou surpreso que ninguém tenha mencionado. Mas quando você estiver usando ipython desembolsar você pode fazer Ctrl + L, mesmo em janelas
user93

Respostas:

442

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')
Ryan Duffield
fonte
1
Esta resposta está mais próxima do "espírito" do que eu estava pedindo, obrigado.
Soviut 06/02/09
1
+1, boa resposta. Existe uma maneira de consumir o valor de retorno para que ele não seja exibido? Eu recebo um '0' depois de correr limpo.
Technomalogical
15
Defina-o em uma função regular, em vez de lambda, não deve mostrar '0', pois o valor de retorno será Nenhum.
5500 Akbar ibrahim
46
O que há de errado em usar def? Por que usar a lambdaquando a defé mais claro?
S.Lott
17
@Akbaribrahim como None não será impresso tente o seguinte:clear = lambda: os.system('cls') or None
enpenax
193

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()
popcnt
fonte
Ótima maneira de fazer as coisas, combine isso com a sugestão lambda acima para salvar uma linha de código, útil como o inferno! Obrigado! :)
Torxed 30/10/12
import os os.system('cls')
Do Nhu Vy
1
Variável de ambiente TERM não definida.
Jonathan
87

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
Tríptico
fonte
12
Haha, isso é bem engraçado. Não é exatamente o que eu estava procurando, mas uma boa tentativa.
Soviut
4
@ Triptych: c = "\ n" * 100 útil, +1 para isso. Um pequeno comentário que ele limpa e traz para o fundo do shell, eu prefiro começar do topo do shell.
Pythonbeginer
1
Ou, se o seu emulador de terminal interpreta ANSI, melhor fazer:"\x1B[H\x1B[J"
Alba Mendez
8
Apesar das pessoas rindo, imprimindo um monte de novas linhas é exatamente o que os processos externos cleare clsfazer. Esta é a maneira de fazê-lo. (apenas uma impressão, ou uma função com a chamada de impressão, não assigining para uma string "claro", é claro)
jsbueno
4
@jsbueno não, não é. Bem, talvez no Windows (embora eu duvide, ele tem APIs para limpar o console). Em todos os outros sistemas, cleargera uma diretiva que limpa a tela. Sem descartar o buffer de rolagem. No meu sistema, ele exibe essa seqüência de controle: \33[3J\33[H\33[2J. Ou seja: [erase scrollback] [reset cursor position] [erase screen]. O [erase scrollback]pode ser omitido usando clear -x.
spectras 01/09/19
28

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
Martineau
fonte
Esta é provavelmente a melhor resposta - uma combinação de técnicas de outras respostas. PYTHONSTARTUP + repr + os.system ('cls'). Muito agradável.
Triptych
@ Triptych: Um efeito colateral interessante do uso __repr__e / ou __str__dessa maneira é que, se você digitar >>> vars()no console do interpretador, ele executará todos os comandos assim definidos. No meu sistema, por exemplo, limpou a tela e saiu do console. Levei um tempo para descobrir o que diabos estava acontecendo ....
martineau
interessante. Vejo que esse problema também se aplica a locals()e globals(). Um decorador simples em torno dessas funções que exclui o nome e o reatribui após a invocação de função é uma solução possível ...
Triptych
@ Triptych: A ideia do decorador não parece funcionar, pelo menos com minhas próprias tentativas. Encontrar uma alternativa viável está se mostrando surpreendentemente difícil.
27512 martineau
Eu tenho uma solução candidata que simplesmente reduz o resultado das chamadas vars () globals () e locals () temporariamente: gist.github.com/4172781
Triptych
28

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()
Vlad Bezden
fonte
5
Todas essas maneiras são bem ... naff. clssó funcionará no Windows e tornará seu programa difícil de ser multiplataforma, imprimir 100 newlinesé apenas ... eww? E um atalho de teclado não é usado no programa.
Lucas
22

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

É o mesmo para o OS X no terminal.

Alex K
fonte
3
Eu tentei esta solução usando "L" maiúsculo ou minúsculo com a tecla ctrl no Windows 8.1. Isso não funciona para mim. Eu apenas abro e fecho a janela do shell para limpá-la.
Chris22
2
No OS X, Ctrl + L irá preencher o terminal até que a tela fique limpa. Você ainda pode rolar para cima para ver o histórico. Use Cmd + K para limpar o histórico de exibição e impressão. Uma lista mais completa de OS X hotkeys terminais
Andrew Franklin
2
Trabalhar muito bem para mim no Ubuntu Desktop 16
Nam G VU
15

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.

MartinUbuntu
fonte
Você pode querer dizer os.name in ('linux','osx')e também pode querer adicionar 'posix'.
rsanden
@rsanden 'linux' e 'osx' cobrem praticamente todas as pessoas do sistema operacional que realmente usam.
26416 MartinUbuntu
Estou executando o Ubuntu 15.04 e os.name == 'posix'no python 2.7.9 e 3.4.3
rsanden
@rsanden adicionou posix.
MartinUbuntu
9

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()
Pitto
fonte
8

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.
Amol
fonte
2
Eu daria o nome class cls.
martineau
1
Eu nomearia a instância do class Clsser cls. cls = Cls()
Amol
Exceto que polui o espaço para nome inicial com duas coisas, em vez de uma ... duas vezes mais.
27611 martineau
@ Amol Eu usei as técnicas suas e de outras pessoas na minha solução . Você pode fazer class clse então cls=cls().
Alba Mendez
8

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")
Denis Rasulev
fonte
Isso tem a vantagem de também funcionar no Spyder.
Graham G
7

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

import os
os.system('clear')

para Windows

os.system('cls')
yubaraj poudel
fonte
5

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()
Alba Mendez
fonte
5

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

Eu apenas pressione ⌘ + k

Jorge E. Hernández
fonte
4

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.

S.Lott
fonte
como você faz isso no modo ocioso? Apenas feche e reabra?
Andrea Ambu
5
Não, F6não redefine o console ocioso, no entanto CTRL+F6. Infelizmente, isso não limpa a tela. D'oh! (Python Win32 Idle versões 2.6.2, 2.7.1, 3.2).
Ridgerunner #
4

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.

Peter G. Marczis
fonte
Concordo que cls não é o ideal nesse caso, e uma sequência de escape ANSI é melhor. Em particular, usar o os para invocar um novo processo é uma operação bastante cara, em comparação com o envio de alguns bytes para o stdout.
silviot
2

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
AAAfarmclub
fonte
2

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

Larsr
fonte
1
1) Essa string mágica é uma sequência ANSI . \x1b[Hsignifica "mover o cursor para o canto superior esquerdo", \x1b[2Jsignifica "limpar toda a tela". 2) No Windows, o ANSI não é reconhecido; portanto, provavelmente não há nenhuma string mágica.
Alba Mendez
1
Legal! Além disso, para python3 print ('\ x1b [H \ x1b [2J', end = ''); pode ajudar a evitar a nova linha na frente.
DenMark
A string mágica funcionou no console do Microsoft Windows 10 com Python 3.6 para mim. Eu pedi pela sequência de cordas e não pelo uso de open.
DevPlayer 02/02/19
2

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()
usuário final
fonte
Se os.name não é um desses, por que não voltar a imprimir linhas vazias?
Alba Mendez
Se for Jython, eu quero que você saiba que os.name = 'java'
iChux
Parece bom, isso significa que o programa pode se tornar multiplataforma?
Lucas
2

Se estiver no mac, um simples cmd + kdeve fazer o truque.

CoderChai
fonte
2

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

>>> import os
>>> clear = lambda: os.system('clear')
>>> clear()
Bhaskar Mishra
fonte
1

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
Bolota
fonte
1

Que tal isso para uma clara

- os.system('cls')

Isso é o mais curto possível!

Dennis Kean
fonte
sim, mas não multiplataforma, e você deve digitá-lo novamente toda vez que quiser limpar a tela.
Alba Mendez
1

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.

Adriana
fonte
1

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.

Youness
fonte
1

Basta entrar

import os
os.system('cls') # Windows
os.system('clear') # Linux, Unix, Mac OS X
Anônimo
fonte
1

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

Steven Tautonico
fonte
Sim, isso funciona, mas e se você quisesse fazer um comando em seu arquivo python que limpa o console, você não faria apenas com que o usuário digitasse algo e pedisse para que limpassem eles mesmos. você limparia o console através do código.
madladzen
1

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
Victoria Stuart
fonte
0

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.

Andrea Ambu
fonte
0

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!

guest12345
fonte