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

Question

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

Answer 1

类似这样的事情，假设你的终端可以处理

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

example

为了完整起见，我想添加很棒的包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

最后，你可以使用 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)

关键是使用退格字符“ ”并刷新标准输出。

Answer 6

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

旋转完成后离开旋转者的角色
有时也会导致删除以下输出的第一个字符
通过在输出上放置 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

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-progressbar/ 使用

RotatingMarker

。

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(["🌑", "🌒", "🌓", "🌔", "🌕", "🌖", "🌗", "🌘"])
    start_time = datetime.now()

def show(current):
    curr_time = datetime.now()
    time_taken = curr_time - start_time
    print("  ", next(moon), title, current, "/", total,
          " progress: ", round((100.0 * current) / total, 2), "%",
          " eta: ", (time_taken * (total - current)) / current, end="\r ")

    return show

Answer 22

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 23

简单：

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

Answer 24

这是最简单的 python 加载微调器：

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

输出：

loading...... |

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

问题描述投票：0回答：24

24个回答

摘自他们的自述文件

最新问题

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

问题描述 投票：0回答：24

24个回答

摘自他们的自述文件

最新问题

问题描述投票：0回答：24