Como limpar o console intérprete?

Question

Como a maioria dos desenvolvedores de Python, eu normalmente manter uma janela do console aberto com o Python intérprete correndo para comandos de teste, coisas dir(), help() stuff, etc.

Como qualquer console, depois de um tempo o atraso visível de comandos e impressões passadas chega a ser confuso, e às vezes confuso quando re-executar o mesmo comando várias vezes. Eu estou querendo saber se, e como, para limpar o console interpretador Python.

Eu ouvi sobre fazer uma chamada de sistema e quer cls chamando no Windows ou clear no Linux, mas eu estava esperando que houvesse algo que eu poderia comandar o próprio intérprete para fazer.

Nota:. eu estou correndo no Windows, portanto Ctrl+L não funciona

Answer 1

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

Para o Windows

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

Para Linux a lambda torna-se

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

Answer 2

aqui algo prático que é um pouco mais multi-plataforma

import os

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

# now, to clear the screen
cls()

Answer 3

Bem, aqui está um corte rápido:

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

Ou para reduzir a digitação, colocar este arquivo em seu caminho de pesquisa python:

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

wipe = Wipe()

Em seguida, você pode fazer isso a partir do interpretador de tudo que você gosta:)

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

Answer 4

Embora esta seja uma questão mais velho, eu pensei que eu iria contribuir com algo resumindo o que eu acho que foram os melhores das outras respostas e adicionar uma ruga do meu próprio, sugerindo que você colocar estas comando (s) em um arquivo e definir a sua variável de ambiente PYTHONSTARTUP para apontar para ele. Desde que eu estou no Windows, no momento, ele está ligeiramente inclinado dessa forma, mas poderia facilmente ser inclinado alguma outra direção.

Eis alguns artigos que eu encontrei que descrevem como variáveis ??de ambiente definidas no Windows:
Quando usar sys.path.append e ao modificar% PYTHONPATH% é suficiente
Como gerenciar variáveis ??de ambiente no Windows XP
Configuração do Sistema e usuário variáveis ??de ambiente
Como Variáveis ??Uso Global de ambiente do sistema no janelas

BTW, não coloque aspas no caminho para o arquivo mesmo se ele tiver espaços.

De qualquer forma, aqui está a minha opinião sobre o código para colocar em (ou adicionar à sua já existente) script Python arranque:

# ==== 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 @ do Tríptico __repr__ truque para mudança exit() em apenas exit (e idem para a sua quit alias):

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

quit = exit = exit()

Por último, está aqui outra coisa que muda o intérprete principal alerta de >>> a cwd + >>>:

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

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

Answer 5

Você tem várias maneiras fazendo isso no Windows:

1. Usando o atalho de teclado:

Press CTRL + L

2. Usando o sistema de invocação de método:

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

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

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

Answer 6

Mais rápido e mais fácil, sem dúvida, é Ctrl + L .

Este é o mesmo para OS X no terminal.

Answer 7

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

então chamada clear() para limpar a tela. Isso funciona em janelas, a OSX, Linux, BSD ... todos os sistemas operacionais.

Answer 8

Wiper é legal, boa coisa sobre isso é que eu não tenha que digitar '()' em torno dele. Aqui é ligeira variação a ele

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

Answer 9

Aqui está uma multiplataforma (Windows / Linux / Mac / Provavelmente outros que você pode adicionar no caso de verificação) versão trecho fiz combinar informações encontradas nesta pergunta:

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

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

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

Answer 10

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

import os
os.system('clear')

para janelas

os.system('cls')

Answer 11

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

1. Você pode copy-paste o código em seu shell ou script.

2. Você pode uso -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 chamada -lo como um script:

   $ python clear.py
   

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

---

Você pode baixar o arquivo [completa] aqui: https://gist.github.com/3130325
Ou se você está olhando apenas para 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()

Answer 12

Eu uso iTerm eo aplicativo de terminal nativo para Mac OS.

Eu só pressionar ? + k

Answer 13

Use ocioso. Ele tem muitos recursos úteis. Ctrl + F6 , por exemplo, redefine o console. Fechando e abrindo o console são boas maneiras de limpá-la.

Answer 14

Esta é a coisa mais simples que você pode fazer e não requer quaisquer bibliotecas adicionais. Ele irá limpar a tela e voltar >>> para a esquerda canto superior.

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

Answer 15

Eu não tenho certeza se o Windows' "shell" suporta isso, mas no Linux:

print "\033[2J"

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

Na minha opinião chamando cls com os é uma má idéia geral. Imagine se eu conseguir alterar as cls ou comando clara em seu sistema, e você executar o script como administrador ou raiz.

Answer 16

Eu estou usando MinGW / bash no Windows XP, SP3.

(furar isso em .pythonstartup)
# Meu ctrl-l já tipo de funcionou, mas isso pode ajudar alguém
# Folhas rápidas na parte inferior da janela embora ...
importação readline
readline.parse_and_bind ( '\ C-l: tela clear')

# Isto funciona em bash, porque eu tê-lo em .inputrc bem, mas por alguma
# Razão, fica descartada quando eu entro em Python
readline.parse_and_bind ( '\ C-y: mat-todo-line')

---

Eu não poderia estar digitando 'exit ()' mais e ficou encantado com martineau do / truques do Triptych:

Eu medicado ligeiramente-lo embora (enfiou na .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

Answer 17

O clear comando OS em Linux e cls no Windows gera um "string mágica", que você pode simplesmente imprimir. Para obter a seqüência, execute o comando com popen e salvá-lo 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'.

Answer 18

Aqui estão duas maneiras agradáveis ??de se 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()

Answer 19

Como sobre isso por uma clara

- os.system('cls')

Isso é quase tão curto quanto poderia ser!

Answer 20

Eu sou novo para python (realmente nova) e em um dos livros que estou lendo para se familiarizar com a língua que ensinam como criar essa pequena função para limpar o console do backlog visível e comandos passados ??e impressões:

Open shell / Criar novo documento / Criar função da seguinte forma:

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

Save-lo dentro da pasta lib no diretório do python (o meu é C: \ Python33 \ Lib) Da próxima vez que nedd para limpar seu console apenas chamar a função com:

clear()

é isso. PS: você pode nomear-lhe funcionar de qualquer maneira que você quiser. IV' visto pessoas usando 'limpador' 'limpar' e variações.

Answer 21

Eu encontrei a maneira mais simples é apenas para fechar a janela e executar um módulo / script para reabrir o shell.

Answer 22

apenas usar isso ..

print '\n'*1000

Answer 23

Eu estou usando Spyder (Python 2.7) e para limpar o console intérprete eu usar

% claro

que as forças da linha de comando para ir para o topo e não vou ver os comandos antigos anteriores.

ou clico em "opção" sobre o meio ambiente Console e selecione "kernel do Restart" que remove tudo.

Answer 24

I pode ser tarde para a parte mas aqui é uma maneira muito fácil de fazê-lo

Tipo:

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

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

cls()

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

Answer 25

Se for no Mac, então um simples cmd + k deve fazer o truque.

Answer 26

Se você não precisa fazê-lo através de código, basta pressionar CTRL + L

Answer 27

EDIT: Acabei de ler "janelas", isto é para usuários de Linux, desculpe

.

---

Em 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

Salvar como "whatyouwant.sh", chmod + x então executar:

./whatyouwant.sh python

ou algo diferente do python (ocioso, qualquer que seja). Isto irá perguntar se você realmente quer sair, se não ele execute novamente python (ou o comando que deu como parâmetro).

Isto irá limpar tudo, a tela e todas as variáveis ??/ objeto / coisa que você criou / importou em python.

Em python basta digitar exit () quando você quer sair.

Answer 28

Este deve ser plataforma transversal, e também utiliza o subprocess.call preferido em vez de os.system como por os docs os.system . Devem trabalhar 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

Answer 29

OK, então isso é uma resposta muito menos técnico, mas eu estou usando o plugin Python para Notepad ++ e verifica-se que você pode apenas limpar a consola manualmente clicando com o botão direito sobre ele e clicando em "claro". Espero que isso ajude alguém lá fora!

Answer 30

>>> ' '*80*25

Atualizar : 80x25 é improvável que seja o tamanho das janelas do console, de modo a obter as dimensões do console real de uso de funções de módulo pager . Python não fornecer qualquer coisa semelhante de distribuição de núcleo.

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