Comment créer une filature de ligne de commande de curseur?

Est-il un moyen d'imprimer un filature du curseur dans un terminal à l'aide de Python?

InformationsquelleAutor Nathan | 2011-02-14
  1. 63

    Quelque chose comme cela, en supposant que votre terminal gère \b

    import sys
import time

def spinning_cursor():
    while True:
        for cursor in '|/-\\':
            yield cursor

spinner = spinning_cursor()
for _ in range(50):
    sys.stdout.write(next(spinner))
    sys.stdout.flush()
    time.sleep(0.1)
    sys.stdout.write('\b')
    InformationsquelleAutor nos
  2. 33

    Une belle pythonic façon est d'utiliser des itertools.cycle:

    import itertools, sys
spinner = itertools.cycle(['-', '/', '|', '\\'])
while True:
    sys.stdout.write(spinner.next())  # write the next character
    sys.stdout.flush()                # flush stdout buffer (actual character display)
    sys.stdout.write('\b')            # erase the last written char

    Aussi, vous pourriez vouloir utiliser filetage de l'affichage de la toupie au cours d'un long appel de fonction, comme dans http://www.interclasse.com/scripts/spin.php

    • Comme par CODE-Lire le commentaire dans l'autre réponse, en python 3, utilisation next(spinner) au lieu de spinner.next()
    • Plus concis pour utiliser simplement spinner = itertools.cycle('-/|\\').
    InformationsquelleAutor Damien
  3. 32

    Facile à utiliser l'API (cela va faire tourner la toupie dans un thread séparé):

    import sys
import time
import threading

class Spinner:
    busy = False
    delay = 0.1

    @staticmethod
    def spinning_cursor():
        while 1: 
            for cursor in '|/-\\': yield cursor

    def __init__(self, delay=None):
        self.spinner_generator = self.spinning_cursor()
        if delay and float(delay): self.delay = delay

    def spinner_task(self):
        while self.busy:
            sys.stdout.write(next(self.spinner_generator))
            sys.stdout.flush()
            time.sleep(self.delay)
            sys.stdout.write('\b')
            sys.stdout.flush()

    def __enter__(self):
        self.busy = True
        threading.Thread(target=self.spinner_task).start()

    def __exit__(self, exception, value, tb):
        self.busy = False
        time.sleep(self.delay)
        if exception is not None:
            return False

    Maintenant l'utiliser dans un with bloquer n'importe où dans le code:

    with Spinner():
  # ... some long-running operations
  # time.sleep(3)
    • c'est vraiment sympa, jusqu'à ce que vous frappez une erreur dans votre code n'est pas traitée. Ensuite, vous ne pouvez pas le forcer à s'arrêter.
    • Plus un pour y compris le filetage. Merci pour cette!
    • float(delay) va augmenter si flottent pas, devrait être isinstance(delay, Number), avec Number de numbers.
    InformationsquelleAutor Victor Moyseenko
  4. 10

    Une solution:

    import sys
import time

print "processing...\\",
syms = ['\\', '|', '/', '-']
bs = '\b'

for _ in range(10):
    for sym in syms:
        sys.stdout.write("\b%s" % sym)
        sys.stdout.flush()
        time.sleep(.5)

    La clé est d'utiliser le caractère de retour arrière '\b' et flush stdout.

    InformationsquelleAutor Nathan
  5. 3

    Oui, c'est possible. C'est juste une question d'impression du caractère de retour arrière (\b) entre les quatre personnages qui feraient le "curseur" regardez comme elle tourne ( -, \, |, /).

    InformationsquelleAutor Klaus Byskov Pedersen
  6. 1

    les malédictions du module. j'aurais un coup d'oeil à la addstr() et addch() les fonctions. N'a jamais été utilisé.

    InformationsquelleAutor MattiaG
  7. 1

    Pour plus avancé de la console de manipulations, sous unix, vous pouvez utiliser le malédictions module python, et sur windows, vous pouvez utiliser WConio qui fournit des fonctionnalités équivalentes de la bibliothèque curses.

    InformationsquelleAutor David
  8. 1

    Saisir le génial progressbar module http://code.google.com/p/python-progressbar/
    utilisation RotatingMarker.

    InformationsquelleAutor Beni Cherniavsky-Paskin
  9. 0
    #!/usr/bin/env python

import sys

chars = '|/-\\'

for i in xrange(1,1000):
    for c in chars:
        sys.stdout.write(c)
        sys.stdout.write('\b')
        sys.stdout.flush()

    Mises en garde:
    Dans mon expérience, cela ne fonctionne pas dans tous les terminaux. D'une façon plus robuste de le faire sous Unix/Linux, il est plus compliqué est d'utiliser le les malédictions module qui ne fonctionne pas sous Windows.
    Vous voulez probablement ralentir certains comment avec traitement réel ce qui se passe en arrière-plan.

    InformationsquelleAutor
  10. 0
    import sys
def DrowWaitCursor(self, counter):
    if counter % 4 == 0:
        print("/",end = "")
    elif counter % 4 == 1:
        print("-",end = "")
    elif counter % 4 == 2:
        print("\\",end = "")
    elif counter % 4 == 3:
        print("|",end = "")
    sys.stdout.flush()
    sys.stdout.write('\b')

    Cela peut être également une solution à l'aide d'une fonction avec un paramètre.

    InformationsquelleAutor user3297919
  11. 0

    Ici ya go - simple et clair.

    import sys
import time

idx = 0
cursor = ['|','/','-','\\'] #frames of an animated cursor

while True:
    sys.stdout.write(cursor[idx])
    sys.stdout.write('\b')
    idx = idx + 1

    if idx > 3:
        idx = 0

    time.sleep(.1)
    InformationsquelleAutor David Philipe Gil
  12. 0

    Brut, mais la solution la plus simple:

    import sys
import time
cursor = ['|','/','-','\\']
for count in range(0,1000):
  sys.stdout.write('\b{}'.format(cursor[count%4]))
  sys.stdout.flush()
  # replace time.sleep() with some logic
  time.sleep(.1)

    Il y a des limites évidentes, mais encore une fois, brut.

    InformationsquelleAutor mbunch