Как создать вращающийся курсор командной строки?

Есть ли способ распечатать вращающийся курсор в терминале с помощью Python?

Ответ 1

Примерно так, при условии, что ваш терминал обрабатывает \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')

Ответ 2

Простой в использовании API (он будет запускать спиннер в отдельном потоке):

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

Теперь используйте его в блоке with любом месте кода:

with Spinner():
  # ... some long-running operations
  # time.sleep(3)

Ответ 3

Хорошим pythonic способом является использование 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

Кроме того, вы можете использовать потоки для отображения счетчика во время долгого вызова функции, как в http://www.interclasse.com/scripts/spin.php

Ответ 4

Решение:

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)

Ключ должен использовать символ обратного пробела '\ b' и flush stdout.

Ответ 5

Конечно, это возможно. Это просто вопрос печати символа backspace (\b) между четырьмя символами, которые заставят "курсор" выглядеть как вращающийся (-, \, |, /).

Ответ 6

Для более продвинутых консольных манипуляций в unix вы можете использовать curses python module, а в окнах вы можете использовать WConio, который обеспечивает эквивалентную функциональность библиотеки curses.

Ответ 7

модуль curses. Я бы посмотрел на функции addstr() и addch(). Никогда не использовал его.

Ответ 8

Захватите удивительный модуль progressbar - http://code.google.com/p/python-progressbar/ используйте RotatingMarker.

Ответ 9

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

ПРЕДОСТЕРЕЖЕНИЯ: По моему опыту это не работает во всех терминалах. Более надежный способ сделать это в Unix/Linux будет более сложным - использовать модуль curses, который не работает под Окна. Вероятно, вы хотите немного замедлить его, как с фактической обработкой, происходящей в фоновом режиме.

Ответ 10

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

Это может быть и другое решение с использованием функции с параметром.

Ответ 11

Вот и я - просто и понятно.

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)

Ответ 12

Грубое, но простое решение:

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)

Есть очевидные ограничения, но опять же, грубые.

Ответ 13

Проверьте пакет Halo: https://github.com/manrajgrover/halo

Он реализовал несколько вращающихся курсоров для командной строки.

Ответ 14

Я построил общий Singleton, общий для всего приложения

from itertools import cycle
import threading
import time


class Spinner:
    __default_spinner_symbols_list = ['|-----|', '|#----|', '|-#---|', '|--#--|', '|---#-|', '|----#|']

def __init__(self, spinner_symbols_list: [str] = None):
    spinner_symbols_list = spinner_symbols_list if spinner_symbols_list else Spinner.__default_spinner_symbols_list
    self.__screen_lock = threading.Event()
    self.__spinner = cycle(spinner_symbols_list)
    self.__stop_event = False
    self.__thread = None

def get_spin(self):
    return self.__spinner

def start(self, spinner_message: str):
    self.__stop_event = False
    time.sleep(0.3)

    def run_spinner(message):
        while not self.__stop_event:
            print("\r{message} {spinner}".format(message=message, spinner=next(self.__spinner)), end="")
            time.sleep(0.3)

        self.__screen_lock.set()

    self.__thread = threading.Thread(target=run_spinner, args=(spinner_message,), daemon=True)
    self.__thread.start()

def stop(self):
    self.__stop_event = True
    if self.__screen_lock.is_set():
        self.__screen_lock.wait()
        self.__screen_lock.clear()
        print("\r", end="")

    print("\r", end="")

if __name__ == '__main__':
    import time
    # Testing
    spinner = Spinner()
    spinner.start("Downloading")
    # Make actions
    time.sleep(5) # Simulate a process
    #
    spinner.stop()

Ответ 15

Улучшенная версия от @Victor Мойсеенко в оригинальной версии было мало проблем

оставлял вращающихся персонажей после завершения вращения
и иногда приводят к удалению следующего выходного первого символа тоже
позволяет избежать условия редкой гонки, помещая threading.Lock() в вывод
возвращается к более простому выводу, когда tty недоступен (без вращения)

import sys
import threading
import itertools
import time

class Spinner:

    def __init__(self, message, delay=0.1):
        self.spinner = itertools.cycle(['-', '/', '|', '\\'])
        self.delay = delay
        self.busy = False
        self.spinner_visible = False
        sys.stdout.write(message)

    def write_next(self):
        with self._screen_lock:
            if not self.spinner_visible:
                sys.stdout.write(next(self.spinner))
                self.spinner_visible = True
                sys.stdout.flush()

    def remove_spinner(self, cleanup=False):
        with self._screen_lock:
            if self.spinner_visible:
                sys.stdout.write('\b')
                self.spinner_visible = False
                if cleanup:
                    sys.stdout.write(' ')       # overwrite spinner with blank
                    sys.stdout.write('\r')      # move to next line
                sys.stdout.flush()

    def spinner_task(self):
        while self.busy:
            self.write_next()
            time.sleep(self.delay)
            self.remove_spinner()

    def __enter__(self):
        if sys.stdout.isatty():
            self._screen_lock = threading.Lock()
            self.busy = True
            self.thread = threading.Thread(target=self.spinner_task)
            self.thread.start()

    def __exit__(self, exception, value, tb):
        if sys.stdout.isatty():
            self.busy = False
            self.remove_spinner(cleanup=True)
        else:
            sys.stdout.write('\r')

пример использования класса Spinner выше:


with Spinner("just waiting a bit.. "):

        time.sleep(3)

загруженный код в https://github.com/Tagar/stuff/blob/master/spinner.py