Функция (оператор) \(print()\) выводит на экран данные.
Общий вид
\(print\) (<выражение \(1\)>, <выражение \(2\)>… <выражение \(n\)>)
Внутри круглых скобок записываются выражения, которые нужно вывести на экран.
Рассмотрим два варианта вывода
\(c=15\)
\(print (c)\)
\(print («c=»)\)
В результате на экране появится результат:
\(15\)
\(c=\)
В чём причина?
Первая запись \(print (c)\) выводит значение \(15\), а вторая запись \(print («c=»)\) переносит на экран содержимое «».
Как записать правильно?
\(c=15\)
\(print(«c=»,c)\)
Программа напечатает
\(c = 15\)
Если внимательно посмотреть, то перед \(15\) стоит пробел, это потому, что по умолчанию \(print()\) вставляет перед выводимыми значениями пробел (его называют разделитель (сепаратор) от анг. separator). Его можно исключить, сделав такую запись:
\(с=15\)
\(print(«c=»,c, sep=»»)\) #внутри кавычек пусто, т. е. даём команду — удалить разделитель.
Разделитель можно удалить или наоборот, поставить между выводимыми значениями, например, запятую.
\(x=8\)
\(y=9\)
\(print(x,y,sep=»,») \)
Результат вывода
\(8, 9\)
Форматный вывод данных
При работе с вещественными числами возникает необходимость уменьшить размер дробной части (ограничить количество цифр после запятой), тогда необходимо воспользоваться форматным выводом.
Рассмотрим такую программу
\(s=158\)
\(d=87\)
\(k=s/d\)
\(print(«k=»,k)\)
На экране появится результат
\(k = 1,8160919540229885\).
Знаков после запятой очень много, с помощью \(format\) оставим \(3\).
Для этого добавить в строку вывода
\(print(«k=»,»\){\(:7.3f\)}\(«.format(k))\)
На экране будет результат
\(k = 1.816\).
Что означает эта запись:
1) фигурные скобки — место для вывода очередного элемента, т. е. числа;
2) после двоеточия — количество позиций для вывода числа (их в нашей записи \(7\));
3) после точки указано количество знаков после запятой, т. е. \(3\);
4) буква \(f\) означает, что выводимое число вещественное (если бы было целое, то нужно было бы поставить \(d\));
5) внутри \(format\) записано, значение какой переменной появится на экране, в нашем случае это \(k\).
Рис. \(1\). Вывод данных
Источники:
Рис. 1. Вывод данных. © ЯКласс.
Ввод и вывод данных
Назад в начало
Переменные и типы данных
Переменной в программировании называется именованный контейнер для некоторого значения. Представьте себе ящик с наклееным на него стикером. Вы кладете что-нибудь в ящик и пишете на стикере короткое имя без пробелов и знаков препинания, начинающееся с буквы английского алфавита, примерно так же работает переменная в программировании.
a = 10
A = 20
a и А — это разные переменные, регистр ввода имеет значение
Типы данных
Информация получаемая нами с помощью различных органов чувств делится на зрительную, слуховую, обонятельную, осязательную и другие. В программировании так же есть свое разделение, разделение на типы данных. Примитивных типов данных в Python 4:
int — целочисленный тип (1, 192, 781287)
float — вещественный (дробный) (1.12312, 1231.12378718)
str — строковый тип (обязательно пишется в кавычках) (‘Hello world’)
bool — булевый тип (имеет всего два значения: True и False)
Приведение типов
Приведением типов данных называется преобразование одного типа в другой, например, строку в число, число в строку, число в булеву переменную, строку в дробь и так далее.
a = 10
b = str(a) # b — это строка
с = int(b) # c — это снова число
d = 10.78
e = int(d) # e равно 10
Функция print
Функция print выводит переданные в неё аргументы в стандартный поток вывода. Что же такое стандартный поток вывода? Standart output или stdout называется потоком вывода, местом, куда мы выводим наш текстовый контент. По умолчанию стандартный поток вывода равен sys.stdout и поэтому вывод осуществляется в консоль.
Функция print все переданные в неё аргументы в стандартный поток вывода. Например:
print(1)
print(‘Hello world!’)
print(False)
print(1.5, 2.0, 10, True, ‘username’)
print(‘Hello’ + ‘ ‘ + ‘world’ + ‘!’)
# 1
# Hello world!
# False
# 1.5 2.0 10 True username
# Hello world!
На этом тривиальном примере мы видим две вещи. Во-первых, каждый print переносит поток вывода на новую строчку. Во-вторых, аргументы, переданные в функцию print выводятся через пробел.
# Во-первых:
print(1)
print(2)
# 1
# 2
# Во-вторых:
print(‘Hello’, ‘world’)
# Hello world
В обоих случаях мы можем изменить стандартное поведение. Рассмотрим первый параметр функции print — end, в него передается строка, которая напечатается после всех аргументов функции print.
print(1, end=‘ ‘)
print(2, end=‘ ‘)
print(3, end=‘ ‘)
# 1 2 3
print(1, end=»—»)
print(2, end=‘-‘)
print(3, end=»—»)
# 1-2-3-
print(1, end=‘-я выведусь после первого print-‘)
print(2, end=‘-a я после второго-‘)
print(3, end=‘-я выведусь после третьего-‘)
# 1-я выведусь после первого print-2-a я после второго-3-я выведусь после третьего-
Рассмотрим второй параметр функции print — sep, sep от английского separator (разделитель). По умолчанию параметр sep равен ‘ ‘. Время для экспериментов ╰(▔∀▔)╯.
print(1, 2, 3, 4)
print(1, 2, 3, 4, sep=‘+++’)
print(1, 2, 3, 4, sep=‘разделитель’)
print(1, 2, 3, 4, sep=‘(◕‿◕)’)
print(1, 2, 3, 4, sep=‘(ノ◕ヮ◕)ノ*:・゚✧’)
# 1 2 3 4
# 1+++2+++3+++4
# 1разделитель2разделитель3разделитель4
# 1(◕‿◕)2(◕‿◕)3(◕‿◕)4
# 1(ノ◕ヮ◕)ノ*:・゚✧2(ノ◕ヮ◕)ノ*:・゚✧3(ノ◕ヮ◕)ノ*:・゚✧4
Функция input
Функция input является функцией стандартного ввода (stdin). Ее главная задача — это передача введенных пользователем данных в функцию.
name = input()
print(‘Hello, ‘ + name)
Функция input может принимать всего лишь один аргумент — строку, которая выведется перед кареткой ввода
name = input(‘Enter your name: ‘)
print(‘Hello, ‘ + name)
Функция input возвращает строковый тип данных
Строки можно складывать друг с другом — это называется конкатенацией или объединением
number = input()
print(type(number))
#
Поэтому если мы напишем такой код, то он будет работать некорректно:
number1 = input()
number2 = input()
print(number1 + number2)
# Ввод:
# 1
# 2
# Вывод:
# 12
Поэтому необходимо преобразовать строковый тип в целочисленный (str в int)
number1 = int(input())
number2 = int(input())
print(number1 + number2)
# Ввод:
# 1
# 2
# Вывод:
# 3
Всегда проверяйте тип полученных данных, это поможет вам избежать большого количества ошибок. К слову, если вы что-то напутали с типами переменных, то Python выдаст ошибку TypeError (ошибка типа)
Решение задач
1. Поэкспериментируйте с переводом в различные типы данных
2. Пользователь вводит свое имя и фамилию. Выведите:
Hello, имя фамилия
# На месте слов с % должны быть введенные данные
3. Посчитайте сумму трех введенных целых чисел
4. Посчитайте сумму трех введенных дробных чисел. Подумайте в какой тип данных нужно преобразовать значение, возвращенное функцией input
5. Дано число, выведите предыдущее и следущее за ним числа в таком формате:
# Число равно 10
Число предшествующее числу 10 равно 9
Число следующее за числом 10 равно 11
6. Вводятся имя и возраст. Выведите, где введенное имя = Максим, а возраст = 20
Привет, Максим! Ваш возраст равен 20!
Ответ:
print(20+3)=23
print(20 — — 3)=23
print(8%2)=0
print(9%2)=1
print(21//4)=5
Ответ:
print(20 + 3) = 23 # + сумма
print(20 — — 3) = 23 # минус на минус = плюс, поэтому сумма
Если там ошибка и один знак минус, то вывод 20
print(8 % 2) = 0 # % — остаток от деления; т.к. 8 — чётное число, то вывод 0
print(9 % 2) = 1 # % — остаток от деления; т.к. 9 — нечётное число, то вывод 1
print(21 // 4) = 5 # // — целая часть от деления; 21 цело не делится на 4, а 20 — делится.
Открыть все ответы
Ответ:
//PascalABC.NET 3.2 сборка 1318
var
n, m, max, k, i: integer;
ar: array of integer;
function CountOfDel(n: integer): integer;
var
i, k: integer;
begin
if n>0 then
begin
for i := 1 to n do
if n mod i = 0 then inc(k);
end
else
for i:= n to -1 do
if n mod i = 0 then
inc(k);
CountofDel := k;
if n=0 then
CountofDel:=0;
end;
begin
readln(n, m);
k := 0;
max := 0;
for i := n to m do
begin
if CountOfDel(i)=0 then
begin
writeln(‘0’);
exit;
end;
if CountOfDel(i) > max then
begin
k := 1;
setlength(ar, k);
ar[k — 1] := i;
max := CountOfDel(i);
end
else
if CountOfDel(i) = max then
begin
inc(k);
setlength(ar, k);
ar[k — 1] := i;
end;
end;
for i := 0 to k — 1 do
write(ar[i]:4);
end.
Пример ввода:
1 10
Пример вывода:
6 8 10
Ответ:
задача 1
значит так: у племени 24 буквы и 8 цифр — всего 32 символа в их алфавите.
вес одного символа определяется из формулы: N=2^i (где i — вес одного символа алфавита. подставим 32 в эту формулу и получим
32=2^i представим 32 как двойку в 5 степени и получим верное равенство 2^5=2^i, отсюда i=5 бит
задача 2
запишем условие: N=64, K (количество символов в тексте)=20 найти I
решение: из формулы мощности алфавита найдем вес одного символа
64=2^i, 64 представим как двойку в 6 степени и получим верное равенство 2^6=2^i, отсюда i=6 бит
для вычисления информационного объема воспользуемся формулой I=K*i=20*6=120 бит это и есть ответ
задача3
запишем условие: N=16, I=1/16 Мб, К-?
решение: из формулы мощности алфавита найдем вес одного символа
16=2^i, 16 представим как двойку в 4 степени и получим верное равенство 2^4=2^i, отсюда i=4 бит
выразим информационный объем текста в битах. для этого 1/16Мб*1024*1024*8=524288 бит
для вычисления количества символов в тексте информационного объема воспользуемся формулой I=K*i отсюда К=I/i=522288/4= 131072 символа это и есть ответ
На примерах узнайте, какие возможности предлагает функция print в Python.
Многие из вас при чтении этого руководства наверняка подумают, что в этой простой функции нет ничего нераскрытого, потому что именно с print многие начинают свое знакомство с Python, выводя на экран заветную фразу Hello, World!. Это естественно не только для Python, но и для любого языка, что функция print является базовой и одним из первых шагов при изучении как программирования в целом, так и конкретного синтаксиса. Однако со временем многие переходят к более продвинутым темам, забывая о возможностях простых на первый взгляд функций.
Это руководство целиком посвящено функции print в Python — из него вы узнаете о том, насколько она недооценена.
Начнем с вывода фразы Hello, World!.
print("Hello, World!")
Hello, World!
Если в Python 2 скобки можно не использовать, то в Python3 они обязательны. Если их не указать, то будет вызвана синтаксическая ошибка.
print("Hello, World!")
File "<ipython-input-6-a1fcabcd869c>", line 1
print "Hello, World!"
^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print("Hello, World!")?
Из текста выше можно сделать вывод, что в Python 3 print() — это не инструкция, а функция.
Чтобы убедиться, проверим type/class функции print().
type(print)
builtin_function_or_method
Возвращается builtin_function_or_method. Это значит, что это ранее определенная или встроенная функция Python.
Предположим, что нужно добавить перенос строки или вертикальный отступ между двумя выводами. Для этого достаточно вызвать print(), не передавая аргументов.
print("Hello, World!");print("Hello, World!")
Hello, World!
Hello, World!
print("Hello, World!")
print()
print("Hello, World!")
Hello, World!
Hello, World!
Рассмотрим синтаксис функции print().
print(value, ..., sep='', end='\n', file=sys.stdout, flush=False)
Как вы знаете, функция print выводит значения в поток данных или в sys.stdout по умолчанию. sys.stdout или стандартный вывод системы означают, что функция print выведет значение на экран. Его можно поменять на stdin или stderr.
Необязательные аргументы:
- sep — это может быть строка, которую необходимо вставлять между значениями, по умолчанию — пробел.
Вставим список слов в
printи разделим их с помощью символа новой строки. Еще раз: по умолчанию разделитель добавляет пробел между каждым словом.print('туториал', 'по', 'функции', 'print()')туториал по функции print()# \n перенесет каждое слово на новую строку print('туториал', 'по', 'функции', 'print()', sep='\n')туториал по функции print()Также можно разделить слова запятыми или добавить два символа новой строки (
\n), что приведет к появлению пустой строки между каждой строкой с текстом или, например, знак плюс (+).print('туториал', 'по', 'функции', 'print()', sep=',')туториал,по,функции,print()print('туториал', 'по', 'функции', 'print()', sep='\n\n')туториал по функции print()print('туториал', 'по', 'функции', 'print()', sep=',+')туториал,+по,+функции,+print()Прежде чем переходить к следующему аргументу,
end, стоит напомнить, что в функцию можно передать и переменную. Например, определим список целых чисел и вставим его в функциюpass. Это список и будет выведен.int_list = [1,2,3,4,5,6] print(int_list)[1, 2, 3, 4, 5, 6] - end — это строка, которая добавляется после последнего значения. По умолчанию — это перенос на новую строку (
\n). С помощью аргументаendпрограммист может самостоятельно определить окончание выраженияprint.Предположим, есть две строки, а задача состоит в том, чтобы объединить их, оставив пробел. Для этого нужно в первой функции
printуказать первую строку,str1и аргументendс кавычками. В таком случае на экран выведутся две строки с пробелом между ними.str1 = 'туториал по' str2 = 'функции print()' print(str1) print(str2)туториал по функции print()print(str1, end=' ') print(str2)туториал по функции print()Возьмем другой пример, где есть функция, которая должна выводить значения списка на одной строке. Этого можно добиться с помощью такого значения аргумента
end:def value(items): for item in items: print(item, end=' ') value([1,2,3,4])1 2 3 4 - file — файлоподобный объект (поток). По умолчанию — это
sys.stdout. Здесь можно указать файл, в который нужно записать или добавить данные из функцииprint.Таким образом вывод функции можно сохранять в файлы форматов
.csvили.txt. Рассмотрим это на примере с перебором всех элементов списка. Он сохраняется в текстовом файле. В первую очередь файл нужно открыть в режимеappend. Далее определяется функция, чей вывод будет добавляться внутрь текстового файла.file = open('print.txt','a+') def value(items): for item in items: print(item, file=file) file.close() # закройте файл после работы с ним. value([1,2,3,4,5,6,7,8,9,10])Когда исполнение будет завершено, появится файл
print.txtв текущей папке.Теперь очевидно, что вывод можно сохранять в файлы, а не только выводить на экран.
- flush — определяет, нужно ли принудительно очищать поток. По умолчанию значение равно
False.Как правило, вывод в файл или консоль буферизируется как минимум до тех пор, пока не будет напечатан символ новой строки. Буфер значит, что вывод хранится в определенном регистре до тех пор, пока файл не будет готов к сохранению значения или не окажется закрыт. Задача
flush— убедиться в том что, буферизированный вывод благополучно добрался до точки назначения.import time print('Пожалуйста, введите ваш электронный адрес : ', end=' ') # print('Пожалуйста, введите ваш электронный адрес : ', end=' ', flush=True) # запустите код выше, чтобы увидеть разницу. time.sleep(5)Пожалуйста, введите ваш электронный адрес :Если запустить написанный выше код, вы заметите, что строка с запросом на ввод не появится до тех пор, пока таймер не закончится, а программа не закроется. Но если добавить аргумент
flush=True, то строка отобразится сразу, но нужно будет подождать 5 секунд, чтобы программа закрылась.Каким-то образом Jupyter Notebook или Jupyter Lab иначе разбираются с этой особенностью и все равно показывают текст перед 5-секундным таймером, поэтому если хочется проверить эту особенность
print, то функцию необходимо запускать в командной строке, а не в Jupyter.
А теперь посмотрим, как можно использовать функцию print для получения ввода от пользователя в Jupyter Notebook. Для этого используется встроенная функция input().
tutorial_topic = input()
print("Тема сегодняшнего урока: ", end='')
print(tutorial_topic)
функция print()
Тема сегодняшнего урока: функция print()
Здесь указан опциональный аргумент end, который объединяет статическую инструкцию в print и ввод пользователя.
Рассмотрим другие интересные способы вывода значений переменных в функции print.
- Для отображения значения переменной вместе с определенной строкой, нужно лишь добавить запятые между ними. В этом случае положение строки и переменной не имеет значения.
a = 2 b = "PythonRU" print(a,"— целое число, а",b,"— строка.")2 — целое число, а PythonRU — строка. - Можно использовать метод
format, передавая ему любые значения переменных для вывода. При их передаче нужно указывать номера индексов (в том порядке, в котором они размещаются в аргументе) в строке. В таком случае функцияprintбудет выступать шаблоном.Также важно запомнить, что номера индексов указываются в фигурных скобках
{}, которые выступают заполнителями.Разберем это на примере:
a = 2 b = "PythonRU" print("{0} — целое число, а {1} — строка.".format(a,b))2 — целое число, а PythonRU — строка.Если поставить одинаковый номер индекса в обоих местах, то при выводе на этих позициях будут одни и те же значения.
a = 2 b = "PythonRU" print("{1} — целое число, а {1} — строка.".format(a,b))PythonRU — целое число, а PythonRU — строка. - Вместо аргумента
formatможно использовать знак процента (%) для вывода значений переменных.Этот способ тоже работает по принципу заполнителей. Но здесь не нужно указывать номера индексов, а только обозначить тип данных, которые получит функция.
%d— это заполнитель для числовых или десятичных значений.%s— заполнитель для строк.
a = 2 b = "PythonRU" print("%d — целое число, а %s — строка."%(a,b))2 — целое число, а PythonRU — строка.Посмотрим, что произойдет, если указать
%sдля переменнойa, которая является целым числом.print("%s — целое число, а %s — строка."%(a,b))2 — целое число, а PythonRU — строка.Как видно, все работает. Причина в том, что функция
printнеявно выполняетtypecastingи конвертирует целое число в строку. Но в обратном порядке это работать не будет. Функция не сможет конвертировать строку в целое число, а вместо этого выведетсяTypeError.print("%d — целое число, а %d — строка."%(a,b))--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-121-68c55041ecfe> in <module> ----> 1 print("%d — целое число, а %d — строка."%(a,b)) TypeError: %d format: a number is required, not str
Вывод
Это руководство — отличная отправная точка для новичков, желающих добиться высокого уровня мастерства в Python. Поиграйте с функций print еще и разберитесь с другими возможностями, которые не были рассмотрены здесь.
- Синтаксис
- Параметры
- Пример использования функции print
- Кодировка
- Буферизация ввода-вывода
-
Блочная буферизация (block-buffered)
-
Линейная буферизация (line-buffered)
-
Небуферизированный вывод (unbuffered)
- Стилизированный print
-
pprint
-
reprlib
-
json.dumps
- Цвет (управляющие коды ANSI)
- Анимация (прелоадеры)
-
Вращающееся колесо
-
Progress Bar
- Best practice
Каждый, кто изучает язык программирования Python, начинает с функции print(), выводя с ее помощью на экран первое сообщение — «Привет, мир!». Ее можно использовать для вывода текстовых сообщений, однако ошибочно полагать, что это все, что нужно знать о print() в Python.
Функция print() в языке Питон предназначена для вывода заданных объектов на стандартное устройство вывода — обычно экран, также может отправлять их в файл.
Синтаксис
Рассмотрим синтаксис этой функции. Самый простой пример:
>>> print()
Даже если функция не получает никаких аргументов, все равно необходимо вставлять после названия пустые скобки, что значит для интерпретатора выполнить функцию, а не просто ссылаться на нее.
В результате этого будет выведен неотображаемый символ пустой строки, она появиться на экране, не нужно путать это с пустой строкой, в которой вообще нет никаких символов.
Но чаще всего нужно передать какое-то сообщение пользователю, к примеру:
>>> print('Your message here')
Параметры
Как было сказано, print() можно вызывать без всяких аргументов при необходимости создать пустую строку, или указывать один аргумент для вывода сообщения. Кроме того, функция может принимать любое количество позиционных аргументов, разделяя их запятой, что очень удобно при необходимости объединения нескольких элементов.
Полная версия print выглядит так:
print(object1, object2, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
- *objects — объект/объекты которые необходимо вывести;
- sep — разделитель между объектами. В качестве своего значения можно передавать строку или None (по умолчанию пробел » «);
- end — символ в конце строки (по умолчанию перенос строки \n);
- file — file-like объект [поток] (по умолчанию sys.stdout);
- flush — принудительный сброс потока [работает с версии Python 3.3] (по умолчанию False).
Пример использования функции print
Самый простой пример:
>>> print('Hello world')
Следующий пример – вывод строкового значения из переменной:
>>> message = 'Hello world'
>>> print(message)
Выведем разные типы:
>>> print('one', 'two', 'three') # str
one two three
>>> print(42) # int
42
>>> print(3.14) # float
3.14
>>> print(True) # bool
True
>>> print([1, 2, 3]) # list
[1, 2, 3]
>>> print({'red', 'green', 'blue'}) # set
{'red', 'green', 'blue'}
>>> print({'name': 'Alice', 'age': 42}) # dict
{'name': 'Alice', 'age': 42}
>>> print((1, 2, 3)) # tuple
(1, 2, 3)
Ниже — пример использования параметра sep:
>>> print('hello', 'world', sep=None)
hello world
>>> print('hello', 'world', sep=' ')
hello world
>>> print('hello', 'world')
hello world
Если функция должна выводить аргументы в виде отдельных строк, можно передать символ экранирования:
>>> print('hello', 'world', sep='\n')
hello
world
Более полезный пример — вывод аргументов в виде пути к файлу:
>>> print('home', 'user', 'documents', sep='/')
home/user/documents
Второй необязательный параметр — end. Он позволяет предотвратить разрыв строки, когда выведенное сообщение не должно заканчиваться символом новой строки. Для этого передается пустая строка:
print('Checking file integrity...', end='')
print('ok')
Checking file integrity...ok
Как и в случае с sep, end можно использовать для объединения отдельных фрагментов в один большой. При этом вместо объединения аргументов текст из каждого вызова функции будет располагаться в одной строке:
>>> print('The first sentence', end='. ')
>>> print('The second sentence', end='. ')
>>> print('The last sentence.')
The first sentence. The second sentence. The last sentence.
При необходимости можно указывать одновременно два ключевых аргумента:
print('Mercury', 'Venus', 'Earth', sep=', ', end='!')
Mercury, Venus, Earth!
Еще одни параметры print() — file и flush. В примере ниже реализована запись логов в файл порциями. С помощью параметра file данные выводятся не на экран, а в файл. Flush незамедлительно сбрасывает накопленный буфер в файл каждые 10 итераций.
import time
source_file = open('parse.txt', 'w')
for i in range(0, 30):
if i % 10 == 0 and i > 0:
print(f"iteration #{i}", file=source_file, flush=True)
else:
print(f"iteration #{i}", file=source_file)
time.sleep(1)
source_file.close()
Кодировка
Функция print() в Python 3 и выше никак не контролирует кодировку символов — это определяется потоком кода. В большинстве случаев нет необходимости менять кодировку, так как по умолчанию используется UTF-8.
В Python 2 кодировка зависит от того, данные какого типа выводятся на экран. При выводе текста кириллицей рекомендуется указывать способ кодировки:
>>> print u'Привет'
>>> print "Привет".decode('utf-8')
Системную кодировку можно узнать через sys.stdout.encoding:
>>> import sys
>>> sys.stdout.encoding
'utf-8'
Буферизация ввода-вывода
Буферизация (от англ. buffer) — способ организации обмена, который подразумевает использование буфера для временного хранения данных.
Блочная буферизация (block-buffered)
Операции ввода и вывода иногда буферизуются с целью повышения производительности. Рассмотрим пример:
import time
num_seconds = 1
for countdown in reversed(range(num_seconds + 1)):
if countdown > 0:
print(countdown, end="...")
time.sleep(1)
else:
print('Go!')
В качестве конца строки мы используем «…». В такой реализации функция print() будет накапливать строки в буфер, и выведет сразу весь результат после вызова print('Go!')
3...2...1...Go!
Линейная буферизация (line-buffered)
Линейная буферизация потока, перед началом ввода/вывода, ожидает момента, пока в буфере не появится разрыв строки. Изменив print() в примере выше на следующий:
print(countdown, end="\n")
мы увидим последовательную печать на экран:
3
2
1
Go!
Небуферизированный вывод (unbuffered)
Unbuffered поток соответствует своему названию — никакой буферизации не происходит, операция ввода/вывода выполняются без промедления. Для этого достаточно переписать print() из примера выше следующим образом:
print(countdown, end='...', flush=True)
Тем самым функция print() принудительно очищает поток, не ожидая символа новой строки в буфере.
Стилизированный print
pprint
С помощью модуля pprint, который входит в стандартную библиотеку Python, можно более наглядно отображать некоторые объекты, при этом структура их сохраняется.
Один из примеров использования модуля — словарь со вложенными словарями:
from pprint import pprint
ifaces = [{
"name": "eth0",
"ip": "192.10.120.100",
"speed": 10000,
"options": {
"test1": {
"var1": True,
"var2": False,
},
"test2": True,
}
}]
pprint(ifaces)
вместо длинной строки будет отображен так:
[{'ip': '192.10.120.100',
'name': 'eth0',
'options': {'test1': {'var1': True, 'var2': False}, 'test2': True},
'speed': 10000}]
Есть необязательный параметр depth и indent. Depth указывает — ключи какого уровня вложенности отображать, скрытые уровни будут заменены на троеточие. Indent устанавливает размер отступов:
pprint(ifaces, depth=2, indent=2)[ { 'ip': '192.10.120.100',
'name': 'eth0',
'options': {'test1': {...}, 'test2': True},
'speed': 10000}]
reprlib
Модуль reprlib позволяет использовать функцию repr(), благодаря которой сокращается отображение глубоко вложенных или больших контейнеров, а также множества рекурсивных вызовов:
>>> import reprlib
>>> reprlib.repr([x**10 for x in range(5)])
'[0, 1, 1024, 59049, 1048576]'
json.dumps
Словари часто представляют собой данные JSON, широко используемые во всемирной сети. Для правильной стилизации словаря в строку JSON можно воспользоваться одноименным модулем, который имеет хорошие возможности печати:
import json
users = [{
"name": "Alex",
"age": "30",
"login": "alex89",
}, {
"name": "Petr",
"age": "25",
"login": "one_user1",
}]
print(json.dumps(users, indent=4, sort_keys=True))
результат:
[
{
"age": "30",
"login": "alex89",
"name": "Alex"
},
{
"age": "25",
"login": "one_user1",
"name": "Petr"
}
]
Цвет (управляющие коды ANSI)
Для выделения важной информации при выводе текста можно воспользоваться возможностью форматировать текст с помощью ANSI кодов. Это может выглядеть как «\033[31m«, где \033 — указание на то, что дальше описывается управляющий код, [31m – задание красного цвета текста.
Пример:
def out_red(text):
print("\033[31m {}".format(text))
def out_yellow(text):
print("\033[33m {}".format(text))
def out_blue(text):
print("\033[34m {}".format(text))
out_red("Вывод красным цветом")
out_yellow("Текст жёлтого цвета")
out_blue("Синий текст")
Чтобы такой вариант работал не только на Linux, но и на Windows, необходимо активировать поддержку ANSI для stdout в запущенной консоли, делается это так:
import ctypes
kernel32 = ctypes.windll.kernel32
kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
Анимация (прелоадеры)
Чтобы сделать интерфейс программы более привлекательным, можно анимировать его. Например, используя preloader, пользователь будет знать, что программа все еще работает.
Вращающееся колесо
Одним из примеров прелоадера является вращающее колесо, что указывает на незавершенную работу, когда точно не известно, сколько времени осталось до завершения запущенной операции. Часто такой прием используется во время загрузки данных с сети, устанавливая простую анимацию движения из последовательности нескольких символов, циклически повторяющихся:
from itertools import cycle
from time import sleep
for frame in cycle(r'-\|/-\|/'):
print('\r', frame, sep='', end='', flush=True)
sleep(0.2)
Progress Bar
Если же время до завершения операции известно или же есть возможность определить процент выполнения задачи, можно установить анимированный прелоадер. В таком случае необходимо определить, сколько знаков «#» нужно отобразить и сколько пробелов вставить. После этого текст удаляется и строится сначала:
from time import sleep
def progress(percent=0, width=30):
left = width * percent // 100
right = width - left
print('\r[', '#' * left, ' ' * right, ']',
f' {percent:.0f}%',
sep='', end='', flush=True)
for i in range(101):
progress(i)
sleep(0.1)
Best practice
Как убрать пробелы в print()
Многие начинающие Python разработчики забывают о том, что разделителем у функции print() по умолчанию является пробел (» «)
name = input()
print("Hello,", name, '!') # Hello, Alex !
Для удаления пробела, используйте параметр sep:
print("Hello, ", name, '!', sep='') # Hello, Alex!
Python print to file (печать в файл)
При необходимости записать какой-то объект в файл можно воспользоваться стандартными возможностями функции print():
1 открыть нужный файл для записи, вовсе не обязательно создавать его вручную, следующий код сделает это автоматически:
sample = open('samplefile.txt', 'w')
2 записать нужное значение в открытый файл:
print("I'm starting to learn the language Python", file = sample)
3 закрыть файл после окончания операции:
sample.close()
В результате этого будет создан обычный текстовый файл с записанным значением, работать с которым можно будет точно так же, как и с созданным самостоятельно.
Таким образом, несмотря на свою кажущуюся простоту, стандартная функция для вывода print() имеет немало скрытых возможностей, некоторые из которых были рассмотрены.
