动态打印一行

Question

我想做几个给出标准输出的语句，而不会在语句之间看到换行符。

具体来说，假设我有：

for item in range(1,100):
    print item

结果是：

1
2
3
4
.
.
.

如何让它看起来像：

1 2 3 4 5 ...

更妙的是，是否有可能打印在过去数单数，所以只有一个号码在屏幕上在同一时间？

Answer 1

将print item更改为：

• print item,在 Python 2.7 中
• Python 3 中的print(item, end=" ")

如果要动态打印数据，请使用以下语法：

• Python 3 中的print(item, sep=' ', end='', flush=True)

Answer 2

顺便说一句......如何每次刷新它以便在一个地方打印mi只需更改数字即可。

通常，这样做的方法是使用终端控制代码。 这是一个特别简单的情况，您只需要一个特殊字符：U+000D CARRIAGE RETURN，它在 Python（和许多其他语言）中写成'\\r' 。 这是基于您的代码的完整示例：

from sys import stdout
from time import sleep
for i in range(1,20):
    stdout.write("\r%d" % i)
    stdout.flush()
    sleep(1)
stdout.write("\n") # move the cursor to the next line

关于这个的一些事情可能会令人惊讶：

• \\r位于字符串的开头，因此在程序运行时，光标将始终位于数字之后。 这不仅仅是装饰性的：如果你反过来做，一些终端模拟器会变得非常困惑。
• 如果您不包括最后一行，则在程序终止后，您的 shell 将在数字顶部打印其提示。
• stdout.flush在某些系统上是必需的，否则您将不会得到任何输出。 其他系统可能不需要它，但它不会造成任何伤害。

如果您发现这不起作用，您首先应该怀疑您的终端模拟器有问题。 vttest程序可以帮助您测试它​​。

您可以用print语句替换stdout.write ，但我不希望将print与直接使用文件对象混合在一起。

Answer 3

使用print item,使打印语句省略换行符。

在 Python 3 中，它是print(item, end=" ") 。

如果您希望每个数字都显示在同一位置，请使用例如 (Python 2.7)：

to = 20
digits = len(str(to - 1))
delete = "\b" * (digits + 1)
for i in range(to):
    print "{0}{1:{2}}".format(delete, i, digits),

在 Python 3 中，它有点复杂； 在这里，您需要刷新sys.stdout否则在循环完成之前它不会打印任何内容：

import sys
to = 20
digits = len(str(to - 1))
delete = "\b" * (digits)
for i in range(to):
   print("{0}{1:{2}}".format(delete, i, digits), end="")
   sys.stdout.flush()

Answer 4

像其他例子一样，
我使用了类似的方法，但没有花时间计算最后的输出长度等，

我只是使用 ANSI 代码转义移回行的开头，然后在打印当前状态输出之前清除整行。

import sys

class Printer():
    """Print things to stdout on one line dynamically"""
    def __init__(self,data):
        sys.stdout.write("\r\x1b[K"+data.__str__())
        sys.stdout.flush()

要在您的迭代循环中使用，您只需调用以下内容：

x = 1
for f in fileList:
    ProcessFile(f)
    output = "File number %d completed." % x
    Printer(output)
    x += 1   

在这里查看更多

Answer 5

改变

print item

到

print "\033[K", item, "\r",
sys.stdout.flush()

• "\\033[K" 清除到行尾
• \\r, 回到行首
• 刷新语句确保它立即显示，以便您获得实时输出。

Answer 6

您可以在打印语句中添加尾随逗号以在每次迭代中打印一个空格而不是换行符：

print item,

或者，如果您使用的是 Python 2.6 或更高版本，则可以使用新的 print 函数，它允许您指定在打印的每个项目的末尾甚至不应该出现空格（或允许您指定任何结尾）想）：

from __future__ import print_function
...
print(item, end="")

最后，您可以通过从 sys 模块导入来直接写入标准输出，该模块返回一个类似文件的对象：

from sys import stdout
...
stdout.write( str(item) )

Answer 7

这么多复杂的答案。 如果您有 python 3，只需将\\r放在打印的开头，然后添加end='', flush=True到它：

import time

for i in range(10):
    print(f'\r{i} foo bar', end='', flush=True)
    time.sleep(0.5)

这将在原地写入0 foo bar ，然后是1 foo bar等。

Answer 8

我认为一个简单的连接应该可以工作：

nl = []
for x in range(1,10):nl.append(str(x))
print ' '.join(nl)

Answer 9

我在 2.7 上使用的另一个答案，我只是打印出一个“。” 每次循环运行时（向用户表明事情仍在运行）是这样的：

print "\b.",

它打印“。” 每个字符之间没有空格。 它看起来好一点，而且效果很好。 对于那些想知道的人来说，\\b 是退格字符。

Answer 10

要使数字相互覆盖，您可以执行以下操作：

for i in range(1,100):
    print "\r",i,

只要数字打印在第一列中，这应该有效。

编辑：这是一个即使没有打印在第一列中也能工作的版本。

prev_digits = -1
for i in range(0,1000):
    print("%s%d" % ("\b"*(prev_digits + 1), i)),
    prev_digits = len(str(i))

我应该注意到这段代码已经过测试并且在 Windows 上的 Python 2.5 中运行良好，在 WINdows 控制台中。 根据其他一些人的说法，可能需要刷新 stdout 才能看到结果。 天啊。

Answer 11

“对了……怎么每次都刷新，在一个地方打印mi，改个数字就行了。”

真是个棘手的话题。 zack建议（输出控制台控制代码）是实现这一目标的一种方法。

您可以使用 (n)curses，但这主要适用于 *nixes。

在 Windows（这里有一个有趣的部分）很少提到（我不明白为什么）你可以使用 Python 绑定到 WinAPI（ http://sourceforge.net/projects/pywin32/也默认使用 ActivePython） - 它不是那很难，而且效果很好。 这是一个小例子：

import win32console, time

output_handle = win32console.GetStdHandle(  win32console.STD_OUTPUT_HANDLE )
info = output_handle.GetConsoleScreenBufferInfo()
pos = info["CursorPosition"]

for i in "\\|/-\\|/-":
    output_handle.WriteConsoleOutputCharacter( i, pos )
    time.sleep( 1 )

或者，如果要使用print （语句或函数，没有区别）：

import win32console, time

output_handle = win32console.GetStdHandle(  win32console.STD_OUTPUT_HANDLE )
info = output_handle.GetConsoleScreenBufferInfo()
pos = info["CursorPosition"]

for i in "\\|/-\\|/-":
    print i
    output_handle.SetConsoleCursorPosition( pos )
    time.sleep( 1 )

win32console模块使您可以使用 Windows 控制台做更多有趣的事情......我不是 WinAPI 的忠实粉丝，但最近我意识到我对它的反感至少有一半是由用 C 编写 WinAPI 代码引起的——pythonic 绑定更容易使用。

当然，所有其他答案都很棒且具有 Python 风格，但是...如果我想在前一行打印怎么办？ 或者写多行文本，而不是清除它并再次写相同的行？ 我的解决方案使这成为可能。

Answer 12

用于 Python 2.7

for x in range(0, 3):
    print x,

对于 Python 3

for x in range(0, 3):
    print(x, end=" ")

Answer 13

In [9]: print?
Type:           builtin_function_or_method
Base Class:     <type 'builtin_function_or_method'>
String Form:    <built-in function print>
Namespace:      Python builtin
Docstring:
    print(value, ..., sep=' ', end='\n', file=sys.stdout)

Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep:  string inserted between values, default a space.
end:  string appended after the last value, default a newline.

Answer 14

打印语句末尾的逗号省略了新行。

for i in xrange(1,100):
  print i,

但这不会覆盖。

Answer 15

对于那些像我一样挣扎的人，我想出了以下似乎适用于 python 3.7.4 和 3.5.2 的方法。

我将范围从 100 扩大到 1,000,000，因为它运行速度非常快，您可能看不到输出。 这是因为设置end='\\r'一个副作用是最终循环迭代会清除所有输出。 需要更长的数字来证明它有效。 这种结果可能并非在所有情况下都是可取的，但在我的情况下很好，并且 OP 没有指定一种或另一种方式。 您可以使用 if 语句来规避这个问题，该语句评估正在迭代的数组的长度等。在我的情况下，让它工作的关键是将括号"{}"与.format() 。 否则，它不起作用。

下面应该按原样工作：

#!/usr/bin/env python3

for item in range(1,1000000):
    print("{}".format(item), end='\r', flush=True)

Answer 16

或者更简单：

import time
a = 0
while True:
    print (a, end="\r")
    a += 1
    time.sleep(0.1)

end="\\r"将从第一次打印的开头 [0:] 开始覆盖。

Answer 17

完成此操作的最佳方法是使用\\r字符

试试下面的代码：

import time
for n in range(500):
  print(n, end='\r')
  time.sleep(0.01)
print()  # start new line so most recently printed number stays

Answer 18

如果您只想打印数字，则可以避免循环：

# python 3
import time

startnumber = 1
endnumber = 100

# solution A without a for loop
start_time = time.clock()
m = map(str, range(startnumber, endnumber + 1))
print(' '.join(m))
end_time = time.clock()
timetaken = (end_time - start_time) * 1000
print('took {0}ms\n'.format(timetaken))

# solution B: with a for loop
start_time = time.clock()
for i in range(startnumber, endnumber + 1):
    print(i, end=' ')
end_time = time.clock()
timetaken = (end_time - start_time) * 1000
print('\ntook {0}ms\n'.format(timetaken))

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
took 21.1986929975ms

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 
took 491.466823551ms

Answer 19

在 Python 3 中，你可以这样做：

for item in range(1,10):
    print(item, end =" ")

输出：

1 2 3 4 5 6 7 8 9 

元组：你可以用元组做同样的事情：

tup = (1,2,3,4,5)

for n in tup:
    print(n, end = " - ")

输出：

1 - 2 - 3 - 4 - 5 - 

另一个例子：

list_of_tuples = [(1,2),('A','B'), (3,4), ('Cat', 'Dog')]
for item in list_of_tuples:
    print(item)

输出：

(1, 2)
('A', 'B')
(3, 4)
('Cat', 'Dog')

你甚至可以像这样解压你的元组：

list_of_tuples = [(1,2),('A','B'), (3,4), ('Cat', 'Dog')]

# Tuple unpacking so that you can deal with elements inside of the tuple individually
for (item1, item2) in list_of_tuples:
    print(item1, item2)   

输出：

1 2
A B
3 4
Cat Dog

另一种变体：

list_of_tuples = [(1,2),('A','B'), (3,4), ('Cat', 'Dog')]
for (item1, item2) in list_of_tuples:
    print(item1)
    print(item2)
    print('\n')

输出：

1
2


A
B


3
4


Cat
Dog

Answer 20

for item in range(1,100):
    if item==99:
        print(item,end='')
    else:
        print (item,end=',')

输出：1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24, 25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49, 50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74, 75、76、77、78、79、80、81、82、83、84、85、86、87、88、89、90、91、92、93、94、95、96、97、98、99

Answer 21

注意：我指出了这个解决方案，因为如果下一个打印的长度小于上一个的长度，我见过的大多数其他解决方案都不起作用。

如果您知道要删除的内容，并且可以负担一个全局变量，则可以简单地用空格覆盖最后一行。

1. 在打印之前，将字符串的长度存储为“n”。
2. 打印它，但以 '\\r' 结尾（它返回到行的开头）。
3. 下次，在打印消息之前，在该行上打印 'n' 个空格。

_last_print_len = 0
def reprint(msg, finish=False):
    global _last_print_len
    
    # Ovewrites line with spaces.
    print(' '*_last_print_len, end='\r')
    
    if finish:
        end = '\n'
        # If we're finishing the line, we won't need to overwrite it in the next print.
        _last_print_len = 0
    else:
        end = '\r'
        # Store len for the next print.
        _last_print_len = len(msg)
    
    # Printing message.
    print(msg, end=end)

例子：

for i in range(10):
    reprint('Loading.')
    time.sleep(1)
    reprint('Loading..')
    time.sleep(1)
    reprint('Loading...')
    time.sleep(1)

for i in range(10):
    reprint('Loading.')
    time.sleep(1)
    reprint('Loading..')
    time.sleep(1)
    reprint('Loading...', finish=True)
    time.sleep(1)

Answer 22

如果你想要它作为一个字符串，你可以使用

number_string = ""
for i in range(1, 100):
  number_string += str(i)
print(number_string)