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

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

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

一个不错的 Pythonic 方法是使用 itertools.cycle：

import itertools, sys
spinner = itertools.cycle(['-', '/', '|', '\\'])
while True:
    sys.stdout.write(next(spinner))   # 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 4

为了完整起见，我想添加很棒的包 光环。它提供了大量预设旋转器和更高级别的自定义选项。

从他们的自述文件中摘录

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

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

from halo import Halo

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

long_running_function()

Answer 5

解决方案：

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 6

来自 @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 7

不错，简单，干净……

while True:
    for i in '|\\-/':
        print('\b' + i, end='')

Answer 8

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

Answer 9

我在 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 10

获取出色的 progressbar 模块 - http://code.google.com /p/python-进度条/
使用旋转标记。

Answer 11

我构建了一个通用的单例，由整个应用程序共享

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 12

您可以编写 '\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 13

curses 模块。 我会看看 addstr() 和 addch( ) 函数。虽然从未使用过它。

Answer 14

对于更高级的控制台操作，在 unix 上，您可以使用 curses python 模块 ，在 Windows 上，您可以使用 WConio 它提供了与 curses 库等效的功能。

Answer 15

#!/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 16

开始吧——简单明了。

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 17

粗略但简单的解决方案：

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 18

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

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 19

import sys
def DrowWaitCursor(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 20

大约一周前，我刚刚开始使用 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 21

超级简单的事情：
如果您知道最终指标，那么这也会打印进度和 eta。

from datetime import datetime

import itertools

def progress(title: str, total):

    moon = itertools.cycle(["

Answer 22

我们开始吧，更简单、更概念化：

import sys, time
pattern= ['-','/','|','\\'] # list for cursor graphics

for j in range(0, 101):
      for i in pattern:
          time.sleep(0.1)
          L = "     Loading... " + str(j) + "%" + str(i)
          sys.stdout.write(L+ "\r")

在文件中执行代码，否则它将无法工作（不要尝试在 Python 终端中执行代码）

输出：

Loading...65%/

1. 调整 time.sleep () 用于加载时间。
2. 调整不同图形的pattern列表。

示例：

pattern = ['❤', '

Answer 23

alive-progress 库有很多选项。

您可以通过从终端运行以下命令来尝试实时演示：

python -m alive_progress.tools.demo

Answer 24

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 25

如果你想要 python 文本旋转器，你可以看图片

简单：

print_spinner("Hayatta en hakiki mürşit ilimdir.")

Answer 26

这是最简单的 python 加载旋转器：

import  time           
spin=["loading...... ", "|", "/","-", "\"]   
for i in spin:
  print("\b"+i, end=" ") 
  time.sleep (0.2)               

输出：

loading...... |