Как очистить последнюю отпечатанную строку в python 3.6 [duplicate]

Чтобы переписать числа, вы можете сделать что-то вроде этого:

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

Это должно работать до тех пор, пока число будет напечатано в первом столбце.

EDIT: Вот версия, которая будет работать, даже если она не будет напечатана в первом столбце.

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

Следует отметить, что этот код был протестирован и отлично работает в Python 2.5 на Windows, в Консоль WIndows. По мнению некоторых других, для достижения результатов может потребоваться промывка stdout. YMMV.

для Python 2.7

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

для Python 3

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

change

print item

to

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

• "\ 033 [K" очищается до конца строки
• r, возвращается в начало строки
• , оператор flush убеждается, что он отображается немедленно, поэтому вы получаете вывод в реальном времени.

«Кстати ... Как обновлять его каждый раз, чтобы он печатал mi в одном месте, просто меняйте номер».

Это очень сложная тема. Что zack предложил (вывод управляющих кодов консоли) - это один из способов достижения этого.

Вы можете использовать (n) проклятия, но это работает в основном на * 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, но недавно я понял, что по крайней мере половина моей антипатии к ней была вызвана написанием кода WinAPI в C-pythonic bindings намного проще использование.

Все остальные ответы велики и питоничны, но ... Что делать, если я хотел напечатать на предыдущей строке? Или написать многострочный текст, чем очистить его и снова написать те же строки? Мое решение делает это возможным.

Еще один ответ, который я использую в версии 2.7, где я просто распечатываю «.». каждый раз, когда цикл работает (чтобы указать пользователю, что все еще работает), это:

print "\b.",

Он печатает символ «.». символы без пробелов между ними. Он выглядит немного лучше и работает очень хорошо. \ B является символом обратного пространства для тех, кто задается вопросом.

Вы можете добавить конечную запятую в оператор печати для печати пробела вместо новой строки на каждой итерации:

print item,

Кроме того, если вы используете Python 2.6 или новее, вы можете использовать новая функция печати, которая позволит вам указать, что даже не должно появляться пробел в конце каждого напечатанного элемента (или вы можете указать любой желаемый конец):

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

Наконец, вы можете напрямую написать стандартный вывод, импортировав его из модуля sys, который возвращает файл-подобный объект:

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

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

Для Python (2.7)

 l=""                             #empty string variable
    for item in range(1,100):
        item=str(item)            #converting each element to string
        l=l+" "+item              #concating each element
        l.lstrip()                # deleting the space that was created initially 
    print l                      #prining the whole string

Python 3

 l=""
        for item in range(1,100):
            item=str(item)
            l=l+" "+item
            l.lstrip()
        print(l)

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.

Если вы просто хотите напечатать цифры, вы можете избежать цикла.

# 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 взято 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 заняло 491,466823551 мс [/ г2]

Как и в других примерах, я использую подобный подход, но вместо того, чтобы тратить время на вычисление последней выходной длины и т. д.,

Я просто использую escape-коды 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   

. здесь

В 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

Используйте 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()

Лучший способ добиться этого - использовать символ \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

Я думаю, что простое соединение должно работать:

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

Кстати ... Как обновлять его каждый раз, чтобы он печатал mi в одном месте, просто изменяйте число.

В общем, способ сделайте это с помощью управляющих кодов терминала . Это особенно простой случай, для которого вам нужен только один специальный символ: U + 000D CARRIAGE RETURN, который написан '\r' в Python (и многих других языках). Вот полный пример, основанный на вашем коде:

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 идет в начале строки, поэтому что, пока программа запущена, курсор всегда будет после номера. Это не просто косметика: некоторые терминальные эмуляторы очень запутаны, если вы делаете это наоборот.
• Если вы не включили последнюю строку, то после завершения программы ваша оболочка напечатает подсказка сверху номера.
• В некоторых системах требуется stdout.flush, или вы не получите какой-либо вывод. Другие системы могут не требовать этого, но это не наносит вреда.

Если вы обнаружите, что это не сработает, первое, что вы должны подозревать, это то, что ваш эмулятор терминала неисправен , Программа vttest может помочь вам протестировать ее.

Вы можете заменить stdout.write на инструкцию print, но я предпочитаю не смешивать print с прямым использованием файла объекты.