Terminal clair en Python

une solution simple et multiplate-forme consisterait à utiliser soit la commande cls sous Windows, soit la commande clear sous Unix systems. Utilisé avec os.system , ce qui fait une jolie doublure:

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

Pourquoi n'a-t-on pas parlé de tout simplement faire Ctrl + L .

Sûrement la façon la plus simple de nettoyer l'écran.

si vous êtes sur un système Linux/UNIX, alors l'impression de la séquence d'échappement ANSI pour effacer l'écran devrait faire le travail. Vous voudrez aussi pour déplacer le curseur vers le haut de l'écran. Cela fonctionnera sur n'importe quel terminal qui supporte L'ANSI.

import sys
sys.stderr.write("\x1b[2J\x1b[H")

cela ne fonctionnera pas sur Windows à moins que le support ANSI n'ait été activé. Il peut y avoir une séquence de contrôle équivalente pour Windows, mais je ne sais pas.

en tant que personne sage une fois posté, pour au moins Linux, vous pouvez faire l'équivalent Python de ceci, que vous pouvez utiliser sur la ligne de commande. Il va effacer l'écran plus que la commande Linux clear (de sorte que vous ne pouvez pas faire défiler pour voir votre texte):

printf "3c"

Pour Windows vous pouvez juste utiliser cls .

Voici une façon Python de le faire:

import subprocess
subprocess.call(["printf", "'3c'"])

Voici une autre façon Python de le faire (qui fonctionne sur au moins, mon ordinateur):

print("3c")

Je n'ai aucune idée si cela fonctionne sous Windows ou sur Mac, iOS, Android, etc., bien.

vous pouvez utiliser les réponses des autres personnes pour trouver un moyen plus multiplateforme pour mettre en œuvre ceci.

comme l'a dit rolika dans les commentaires, vous pouvez faire cela pour éviter qu'une nouvelle ligne ne soit imprimée:

print("3c", end="")

quant à moi, la variante la plus élégante:

import os
os.system('cls||clear')

vous pouvez essayer de vous fier à clear mais il se peut qu'il ne soit pas disponible sur toutes les distributions Linux. Sur windows, utilisez cls comme vous l'avez mentionné.

import subprocess
import platform

def clear():
    subprocess.Popen( "cls" if platform.system() == "Windows" else "clear", shell=True)

clear()

Note: Il pourrait être considéré comme une mauvaise forme de prendre le contrôle de l'écran terminal. Envisagez-vous d'utiliser une option? Il serait probablement préférable de laisser l'utilisateur décider si il veut effacer l'écran.

une solution Python Pure.

Ne s'appuie ni sur L'ANSI, ni sur des commandes externes.

Seul votre terminal doit avoir la capacité de vous dire combien de lignes sont en vue.

from shutil import get_terminal_size
print("\n" * get_terminal_size().lines, end='')

version Python >= 3.3.0

est tombé sur ce Il ya quelque temps

def clearscreen(numlines=100):
  """Clear the console.
numlines is an optional argument used only as a fall-back.
"""
# Thanks to Steven D'Aprano, http://www.velocityreviews.com/forums

  if os.name == "posix":
    # Unix/Linux/MacOS/BSD/etc
    os.system('clear')
  elif os.name in ("nt", "dos", "ce"):
    # DOS/Windows
    os.system('CLS')
  else:
    # Fallback for other operating systems.
    print('\n' * numlines)

alors il suffit d'utiliser clearscreen ()

alors j'ai pensé jeter mes deux cents ici...

personne n'a donné une vraie réponse à la question de L'OP, il semble, tout le monde répond soit avec 'NO DONT USE os.le système () est diabolique!!!"sans explication ou fournit une solution qui repose sur l'impression de nouvelles lignes.

pour ceux qui doivent effacer l'écran du terminal et faire défiler en arrière, pour quelque raison que ce soit, vous pouvez utiliser le code suivant:

import os

def clear():
    '''
    Clears the terminal screen and scroll back to present
    the user with a nice clean, new screen. Useful for managing
    menu screens in terminal applications.
    '''
    os.system('cls' if os.name == 'nt' else 'echo -e \\033c')

print('A bunch of garbage so we can garble up the screen...')
clear()

# Same effect, less characters...

def clear():
    '''
    Clears the terminal screen and scroll back to present
    the user with a nice clean, new screen. Useful for managing
    menu screens in terminal applications.
    '''
    os.system('cls||echo -e \\033c')

l'effet souhaité de L'opération. Il utilise le système d'exploitation.la commande system() donc si c'est mal et que quelqu'un connaît un moyen de mise en œuvre de cette aide de sous-processus.call() s'il vous plaît commentaire que je préfère également utiliser des sous-processus, mais ne suis pas familier avec elle à tous les.

vous pouvez passer à travers la base de données terminfo, mais les fonctions pour le faire sont dans curses de toute façon.

python -c "from os import system; system('clear')"

cette fonction fonctionne dans gnome-terminal parce que, par défaut, elle reconnaît les séquences d'échappement ANSI. Il vous donne une distance D'invite propre rows_max du fond du terminal, mais aussi précisément de l'endroit où il a été appelé. Ça vous donne le contrôle total sur ce qu'il faut nettoyer.

def clear(rows=-1, rows_max=None, *, calling_line=True, absolute=None,
          store_max=[]):
    """clear(rows=-1, rows_max=None)
clear(0, -1) # Restore auto-determining rows_max
clear(calling_line=False) # Don't clear calling line
clear(absolute=5) # Absolutely clear out to 5 rows up"""
    from os import linesep
    if rows_max and rows_max != -1:
        store_max[:] = [rows_max, False]
    elif not store_max or store_max[1] or rows_max == -1 or absolute:
        try:
            from shutil import get_terminal_size
            columns_max, rows_max = get_terminal_size()
        except ImportError:
            columns_max, rows_max = 80, 24
        if absolute is None:
            store_max[:] = [rows_max, True]
    if store_max:
        if rows == -1:
            rows = store_max[0]
        elif isinstance(rows, float):
            rows = round(store_max[0] * rows)
        if rows > store_max[0] - 2:
            rows = store_max[0] - 2
    if absolute is None:
        s = ('3[1A' + ' ' * 30 if calling_line else '') + linesep * rows
    else:
        s = '3[{}A'.format(absolute + 2) + linesep
        if absolute > rows_max - 2:
            absolute = rows_max - 2
        s += (' ' * columns_max + linesep) * absolute + ' ' * columns_max
        rows = absolute
    print(s + '3[{}A'.format(rows + 1))

mise en œuvre:

clear() # Clear all, TRIES to automatically get terminal height
clear(800, 24) # Clear all, set 24 as terminal (max) height
clear(12) # Clear half of terminal below if 24 is its height
clear(1000) # Clear to terminal height - 2 (24 - 2)
clear(0.5) # float factor 0.0 - 1.0 of terminal height (0.5 * 24 = 12)
clear() # Clear to rows_max - 2 of user given rows_max (24 - 2)
clear(0, 14) # Clear line, reset rows_max to half of 24 (14-2)
clear(0) # Just clear the line
clear(0, -1) # Clear line, restore auto-determining rows_max
clear(calling_line=False) # Clear all, don't clear calling line
clear(absolute=5) # Absolutely clear out to 5 rows up

paramètres: rows est le nombre de lignes de texte clair à ajouter entre l'invite et le bas de terminal, poussant tout vers le haut. rows_max est la hauteur du terminal (ou Hauteur max de dégagement) dans les lignes de texte, et ne doit être réglée qu'une fois, mais peut être réinitialisée à tout moment. *, dans la position du troisième paramètre signifie que tous les paramètres suivants sont des mots-clés seulement (par exemple, clair(absolu=5)). calling_line=True (par défaut) fonctionne mieux en mode interactif. calling_line=False fonctionne mieux pour les applications terminales textuelles. absolute a été ajouté pour essayer de corriger les problèmes d'écart glitchy dans Interactive mode après réduction de la taille du terminal, mais peut également être utilisé pour les applications de terminal. store_max est juste pour le stockage secret," persistant "de la valeur rows_max ; n'utilisez pas explicitement ce paramètre. (Lorsqu'un argument n'est pas passé pour store_max , changer le contenu de la liste de store_max change la valeur par défaut de ce paramètre. Par conséquent, stockage persistant.)

portabilité: désolé, cela ne fonctionne pas en mode inactif, mais cela fonctionne > > très COOL << en mode interactif dans un terminal (console) qui reconnaît les séquences d'échappement ANSI. Je ne l'ai testé que dans Ubuntu 13.10 en utilisant Python 3.3 dans gnome-terminal. Je ne peux donc que supposer que la portabilité dépend de Python 3.3 (Pour la fonction shutil.get_terminal_size() pour les meilleurs résultats) et de la reconnaissance ANSI. La fonction print(...) est Python 3. J'ai également testé cela avec un texte simple, basé, jeu de Tic Tac Toe (application).

Pour une utilisation en mode Interactif: de la Première copie et coller la fonction copy(...) en mode interactif et voir si elle fonctionne pour vous. Si c'est le cas, mettez la fonction ci-dessus dans un fichier nommé clear.py . Dans le terminal démarrer python, avec 'python3'. Entrez:

>>> import sys
>>> sys.path
['', '/usr/lib/python3.3', ...

clear.py fichier dans l'un des répertoires path listés de sorte que Python puisse le trouver (n'écrasez aucun fichier existant). À utiliser facilement à partir de maintenant:

>>> from clear import clear
>>> clear()
>>> print(clear.__doc__)
clear(rows=-1, rows_max=None)
clear(0, -1) # Restore auto-determining rows_max
clear(calling_line=False) # Don't clear calling line
clear(absolute=5) # Absolutely clear out to 5 rows up

Pour une utilisation dans un terminal application: mettre la fonction copy(...) dans un fichier nommé clear.py dans le même dossier avec votre main .dossier py. Voici un exemple de résumé de travail (squelette) d'une application de jeu de Tic Tac Toe (exécuter à partir de l'invite de terminal: python3 tictactoe .PY):

from os import linesep

class TicTacToe:    
    def __init__(self):
        # Clear screen, but not calling line
        try:
            from clear import clear
            self.clear = clear
            self.clear(calling_line=False)
        except ImportError:
            self.clear = False
        self.rows = 0    # Track printed lines to clear

        # ...
        self.moves = [' '] * 9

    def do_print(self, *text, end=linesep):
        text = list(text)
        for i, v in enumerate(text[:]):
            text[i] = str(v)
        text = ' '.join(text)
        print(text, end=end)
        self.rows += text.count(linesep) + 1

    def show_board(self):
        if self.clear and self.rows:
            self.clear(absolute=self.rows)
        self.rows = 0
        self.do_print('Tic Tac Toe')
        self.do_print('''   |   |
 {6} | {7} | {8}
   |   |
-----------
   |   |
 {3} | {4} | {5}
   |   |
-----------
   |   |
 {0} | {1} | {2}
   |   |'''.format(*self.moves))

    def start(self):
        self.show_board()
        ok = input("Press <Enter> to continue...")
        self.moves = ['O', 'X'] * 4 + ['O']
        self.show_board()
        ok = input("Press <Enter> to close.")

if __name__ == "__main__":
    TicTacToe().start()

explication: do_print(...) sur la ligne 19 est une version de print(...) nécessaire pour garder une trace de combien de nouvelles lignes ont été imprimées ( self.rows ). Sinon, vous devriez self.rows += 1 partout où print(...) est appelé tout au long du programme. Ainsi chaque fois que la carte est redessinée en appelant show_board() la carte précédente est effacée et la nouvelle carte est imprimée exactement où elle devrait être. L'avis self.clear(calling_line=False) sur la ligne 9 pousse essentiellement tout vers le haut par rapport au bas de l'aérogare, mais n'efface pas la ligne d'appel originale. En revanche, self.clear(absolute=self.rows) sur la ligne 29 se dégage absolument sur tout self.rows distance vers le haut, plutôt que de tout pousser vers le haut par rapport au fond du terminal.

utilisateurs D'Ubuntu avec Python 3.3: mettez #!/usr/bin/env python3 sur la toute première ligne de la tictactoe.py file. Cliquez-droit sur l'tictactoe.py fichier => Propriétés => onglet Autorisations d'accès => Cocher Exécuter: Autoriser l'exécution du fichier comme programme . Double-cliquez sur le fichier => Cliquez sur Exécuter dans le Terminal bouton. Si une borne ouverte actuel répertoire est celui de la tictactoe.py file, vous pouvez également démarrer le fichier avec ./tictactoe.py .

vous pouvez utiliser la fonction call() pour exécuter les commandes du terminal:

from subprocess import call
call("clear")

Si vous souhaitez effacer votre terminal lorsque vous utilisez une interface python. Ensuite, vous pouvez faire ce qui suit pour effacer l'écran

import os
os.system('clear')

vous pouvez faire le vôtre. cela ne dépendra pas de votre terminal, ou du type de système D'exploitation.

def clear(num):
    for i in range(num): print 

clear(80)
print "hello"

cela va effacer 25 nouvelles lignes:

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

clear()

j'utilise eclipse avec pydev. J'aime mieux la solution newline que le pour num dans la gamme . La boucle pour lance des avertissements, alors que la nouvelle ligne d'impression ne le fait pas. Si vous voulez spécifier le nombre de nouvelles lignes dans la déclaration claire essayez cette variation.

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

clear(25)

la réponse acceptée est une bonne solution. Le problème est que Jusqu'à présent il ne fonctionne que sur Windows 10, Linux et Mac. Oui Windows (connu pour son manque de support ANSI)! Cette nouvelle fonctionnalité a été implémentée sur Windows 10 (et au-dessus) qui inclut le support ANSI, même si vous devez l'activer. Cela nettoiera l'écran de manière transversale:

import os

print ('Hello World')
os.system('') 
print ("\x1B[2J")

sur tout ce qui est en dessous de Windows 10 mais il renvoie ceci:

[2J

ceci est dû au manque de support ANSI sur les constructions précédentes de Windows. Ceci peut cependant être résolu en utilisant le module colorama . Cela ajoute la prise en charge des caractères ANSI sur Windows:

les séquences de caractères ANSI escape sont utilisées depuis longtemps pour produire du texte terminal coloré et le positionnement du curseur sur Unix et Macs. Colorama fait ce travail sur Windows, aussi, en enveloppant stdout, stripping ANSI les séquences qu'il trouve (qui apparaîtraient comme gobbledygook dans la sortie), et les convertir en appels win32 appropriés pour modifier l'état du terminal. Sur d'autres plateformes, Colorama ne fait rien.

voici donc une méthode de plateforme croisée:

import sys

if sys.platform == 'win32':
    from colorama import init
    init()

print('Hello World')

print("\x1B[2J")

ou print(chr(27) + "[2J") utilisé au lieu de print("\x1B[2J") .

@réponse de poke est très peu sûr sur Windows, oui, il fonctionne, mais il est vraiment un piratage. Un fichier nommé cls.bat ou cls.exe dans le même dictionnaire que le script entrera en conflit avec la commande et exécutera le fichier à la place de la commande, créant un énorme risque de sécurité.

une méthode pour minimiser le risque pourrait être de changer l'endroit où la commande cls est appelée:

import os
os.system('cd C:\Windows|cls' if os.name == 'nt' else 'clear')

cela changera le c urrant D ictionary to C:\Window (backslash est important ici) puis exécutez. C:\Windows est toujours présent et nécessite des permissions d'administration pour y écrire ce qui en fait un bon pour exécuter cette commande avec un risque minimal. Une autre solution consiste à exécuter la commande via PowerShell au lieu de L'invite de commande puisqu'elle est sécurisée contre de telles vulnérabilités.

Il ya aussi d'autres méthodes mentionnées dans cette question: écran clair dans l'enveloppe qui peut également être d'utilisation.

Si vous avez besoin d'effacer l'écran, c'est probablement suffisant. Le problème est qu'il n'y a même pas une façon 100% multiplateforme de faire cela à travers les versions linux. Le problème est que les implémentations du terminal prennent toutes en charge des choses légèrement différentes. Je suis assez sûr que "clair" marchera partout. Mais la réponse la plus "complète" est d'utiliser les caractères de contrôle xterm pour déplacer le curseur, mais cela nécessite xterm en soi.

sans savoir plus de votre problème, votre solution semble assez bon.

une façon peut-être ringarde de nettoyer l'écran, mais qui fonctionnera sur n'importe quelle plate-forme que je connais, est la suivante:

for i in xrange(0,100):
    print ""

je le ferais de cette façon pour qu'il ressemble plus à bash:

il suffit de créer un fichier nommé .pythonstartup at home directory et utiliser la réponse de poke dans une fonction

Sur Linux:

echo "from subprocess import call
def clear(int=None):  
    call('clear')
    if int == 0:
       exit()
clear()" >> $HOME/.pythonstartup ; export PYTHONSTARTUP=$HOME/.pythonstartup ; python

vous pouvez ajouter export PYTHONSTARTUP=$HOME/.pythonstartup à votre ./bashrc fichier

Car ce qui m'intéresse, c'est l'espace; un appel à la fonction n'affiche pas l'interpréteur python description au démarrage, mais vous pouvez supprimer clear() pour le conserver.

L'utiliser comme une fonction normale devrait faire l'affaire sans imprimer le statut de sortie:

>>> clear()

si vous passez l'argument 0 à la fonction il va effacer l'écran et sortir avec succès de sorte que vous pouvez continuer à utiliser le shell dans un écran propre

>>> clear(0)

Pour Windows, sur l'interpréteur de ligne de commande uniquement (pas l'interface graphique)! Il suffit de taper: (Rappelez-vous d'utiliser l'indentation appropriée avec python):

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

Chaque fois que vous tapez clear() sur le shell (ligne de commande), il va effacer l'écran de votre shell. Si vous quittez le shell, vous devez refaire ce qui précède pour le refaire en ouvrant un nouveau shell Python (ligne de commande).

Note: peu importe la version de Python que vous utilisez, explicitement (2.5, 2.7, 3.3 & 3.4).

sous Windows vous pouvez utiliser:

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

il suffit d'utiliser:

print("3c")

cela va effacer la fenêtre du terminal.

par défaut, os.system("clear") / os.system("cls") renverra un type int comme 0. On peut complètement effacer l'écran en l'affectant à une variable et de le supprimer.

def clear():
    if (os.name == 'nt'):    
        c = os.system('cls')
    else:
        c = os.system('clear')
    del c  # can also omit c totally

#clear()

cela fonctionne sur toutes les plateformes et cela fonctionne en Python 2 et 3.

def clear(number):
    for i in range(number):
        print(" ")

alors pour effacer tapez juste clear(numberhere) .