如何创建旋转命令行光标？

Question

有没有办法使用Python在终端中打印旋转光标？

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

Answer 2

一种不错的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

Answer 3

易于使用的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) 

Answer 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'并刷新标准输出。

Answer 5

为了完整起见，我想添加优质的软件包halo。它提供了许多预设微调器和更高级别的自定义选项。

从他们的自述文件中提取

from halo import Halo

spinner = Halo(text='Loading', spinner='dots')
spinner.start()

# Run time consuming work here
# You can also change properties for spinner as and when you want

spinner.stop()

或者，您可以将halo与Python的with语句一起使用：

from halo import Halo

with Halo(text='Loading', spinner='dots'):
    # Run time consuming work here

最后，您可以使用光晕作为装饰器：

from halo import Halo

@Halo(text='Loading', spinner='dots')
def long_running_function():
    # Run time consuming work here
    pass

long_running_function()

Answer 6

当然，这是可能的。这只是在四个字符之间打印退格字符（\b）的问题，这会使“光标”看起来像是在旋转（-，\，| ，/）。

Answer 7

好，简单，干净...

gsub

Answer 8

对于更高级的控制台操作，在unix上你可以使用curses python module，在Windows上，你可以使用WConio来提供与curses库相同的功能。

Answer 9

curses module.我看一下addstr（）和addch（）函数。从来没有用过它。

Answer 10

抓住令人敬畏的progressbar模块 - http://code.google.com/p/python-progressbar/ 使用RotatingMarker。

Answer 11

@Victor Moyseenko的改进版本 因为原始版本几乎没有问题

1. 旋转完成后，离开旋转器的角色
2. 有时还会导致删除以下输出的第一个字符
3. 通过在输出中放置threading.Lock（）避免罕见的竞争状况
4. 在没有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

Answer 12

我在GitHub上找到了py-spin软件包。它具有许多不错的旋转样式。以下是一些有关如何使用的示例，Spin1是\-/样式：

from __future__ import print_function

import time

from pyspin.spin import make_spin, Spin1

# Choose a spin style and the words when showing the spin.
@make_spin(Spin1, "Downloading...")
def download_video():
    time.sleep(10)

if __name__ == '__main__':
    print("I'm going to download a video, and it'll cost much time.")
    download_video()
    print("Done!")
    time.sleep(0.1)

也可以手动控制旋转：

from __future__ import print_function

import sys
import time

from pyspin.spin import Spin1, Spinner

# Choose a spin style.
spin = Spinner(Spin1)
# Spin it now.
for i in range(50):
    print(u"\r{0}".format(spin.next()), end="")
    sys.stdout.flush()
    time.sleep(0.1)

以下gif中的其他样式。

Answer 13

粗略而简单的解决方案：

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)

有明显的局限性，但又很粗糙。

Answer 14

大约一周前我刚开始使用 python 并发现了这篇文章。我将我在这里找到的一些内容与我在其他地方学到的关于线程和队列的内容结合起来，以提供我认为更好的实现。在我的解决方案中，写入屏幕是由检查内容队列的线程处理的。如果该队列有内容，游标旋转线程知道停止。另一方面，游标旋转线程使用队列作为锁，因此打印线程知道在旋转器代码的完整传递完成之前不会打印。这可以防止竞争条件和人们用来保持控制台清洁的大量多余代码。

见下文：

import threading, queue, itertools, sys, time # all required for my version of spinner
import datetime #not required for spinning cursor solution, only my example

console_queue = queue.Queue() # this queue should be initialized before functions
screenlock = queue.Queue()    # this queue too...


def main():
    threading.Thread(target=spinner).start()
    threading.Thread(target=consoleprint).start()

    while True:
        # instead of invoking print or stdout.write, we just add items to the console_queue
        # The next three lines are an example of my code in practice.
        time.sleep(.5) # wait half a second
        currenttime = "[" + datetime.datetime.now().strftime("%d/%m/%Y %H:%M:%S") + "] "
        console_queue.put(currenttime) # The most important part.  Substitute your print and stdout functions with this.


def spinner(console_queue = console_queue, screenlock = screenlock):
    spinnerlist = itertools.cycle(['|', '/', '-', '\\'])
    while True:
        if console_queue.empty():
            screenlock.put("locked")
            sys.stdout.write(next(spinnerlist)) 
            sys.stdout.flush()  
            sys.stdout.write('\b')
            sys.stdout.flush()   
            screenlock.get()
            time.sleep(.1)


def consoleprint(console_queue = console_queue, screenlock = screenlock):
    while True:
        if not console_queue.empty():
            while screenlock.empty() == False:
                time.sleep(.1)
            sys.stdout.flush()
            print(console_queue.get())
            sys.stdout.flush()


if __name__ == "__main__":
    main()

说了我说的，写了我写的，我只做python的东西一个星期了。如果有更简洁的方法可以做到这一点，或者我错过了一些我很想学习的最佳实践。谢谢。

Answer 15

您可以写'\r\033[K'清除当前行。以下是从@nos修改而来的示例。

import sys
import time

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

spinner = spinning_cursor()

for _ in range(1, 10):
    content = f'\r{next(spinner)} Downloading...'
    print(content, end="")
    time.sleep(0.1)
    print('\r\033[K', end="")

对于任何对nodejs感兴趣的人，我还要写一个nodejs示例。

function* makeSpinner(start = 0, end = 100, step = 1) {
  let iterationCount = 0;
  while (true) {
    for (const char of '|/-\\') {
      yield char;
    }
  }
  return iterationCount;
}

async function sleep(seconds) {
  return new Promise((resolve) => {
    setTimeout(resolve, seconds * 1000);
  });
}

(async () => {
  const spinner = makeSpinner();
  for (let i = 0; i < 10; i++) {
    content = `\r${spinner.next().value} Downloading...`;
    process.stdout.write(content);
    await sleep(0.1);
    process.stdout.write('\r\033[K');
  }
})();

Answer 16

import requests
import time
import sys

weathercity = input("What city are you in? ")
weather = requests.get('http://api.openweathermap.org/data/2.5/weather?q='+weathercity+'&appid=886705b4c1182eb1c69f28eb8c520e20')
url = ('http://api.openweathermap.org/data/2.5/weather?q='+weathercity+'&appid=886705b4c1182eb1c69f28eb8c520e20')




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


data = weather.json()

temp = data['main']['temp']
description = data['weather'][0]['description']
weatherprint ="In {}, it is currently {}°C with {}."
spinner = spinning_cursor()
for _ in range(25):
    sys.stdout.write(next(spinner))
    sys.stdout.flush()
    time.sleep(0.1)
    sys.stdout.write('\b')

convert = int(temp - 273.15)
print(weatherprint.format(weathercity, convert, description))

Answer 17

我提出了使用装饰器的解决方案

from itertools import cycle
import functools
import threading
import time


def spinner(message, spinner_symbols: list = None):
    spinner_symbols = spinner_symbols or list("|/-\\")
    spinner_symbols = cycle(spinner_symbols)
    global spinner_event
    spinner_event = True

    def start():
        global spinner_event
        while spinner_event:
            symbol = next(spinner_symbols)
            print("\r{message} {symbol}".format(message=message, symbol=symbol), end="")
            time.sleep(0.3)

    def stop():
        global spinner_event
        spinner_event = False
        print("\r", end="")

    def external(fct):
        @functools.wraps(fct)
        def wrapper(*args):
            spinner_thread = threading.Thread(target=start, daemon=True)
            spinner_thread.start()
            result = fct(*args)
            stop()
            spinner_thread.join()

            return result

        return wrapper

    return external

简单用法

@spinner("Downloading")
def f():
    time.sleep(10)

Answer 18

我建立了一个通用的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()

Answer 19

在这里 - 简单明了。

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)

Answer 20

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

这也可以是使用带参数的函数的另一种解决方案。

Answer 21

#!/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模块更复杂，该模块在Windows下不起作用。 你可能想要减慢它在后台进行实际处理的速度。

Answer 22

你好，这里是最简单的 Python 加载微调器。

导入时间

Spin=["正在加载......", "|", "/","-", "\"]

对于旋转中的 i： Print("\b"+i, end="") Time.sleep (0.2)

输出： 正在加载...... |