Python 3 форматирование строк. Комментарии в Python; Форматирование строк: Операторы форматирования и метод format()

Метод строк str.format() позволяет выполнять подстановку переменных, форматировать значения и объединять элементы в одну строку посредством позиционного форматирования, вследствие чего код программы становится более читабельным и удобным.

Данное руководство охватывает основные методы форматирования строк в Python.

Метод format

Метод форматирования str.format() добавляют в строку один или несколько заполнителей, которые определяются фигурными скобками ({}). Вы можете передать методу любое значение, которое необходимо вставить в строку. При запуске программы это значение будет добавлено в строку в то место, где находятся фигурные скобки.

Например:

print("I have {} apples.".format(5))
I have 5 apples.

В приведённой выше строке используются фигурные скобки:

"I have {} apples."

Метод str.format() имеет значение 5. Он вставит это значение в предложенную строку на место фигурных скобок.

apple_string = "I have {}."
print(apple_string.format("5 apples"))
I have 5 apples.

Теперь метод format вставил на место заменителя строку «5 apples».

Множественная замена

В строке можно использовать несколько заменителей. Попробуйте добавить в строку ещё одну пару фигурных скобок, а в метод – ещё одно значение.

new_apple_string = "I love {} {}." #2 {} заменителя
print(new_apple_string.format("red", "apples")) #Значения нужно разделить запятой
I love red apples.

Метод str.format() может передавать несколько строк; для этого нужно разделить их запятыми, как показано в примере выше.

Попробуйте добавить в строку ещё несколько заменителей:

my_string = "I love {} {}, and have {} {}." #4 {} заменителя
print(my_string.format("red", " apples", 5, "apples")) #4 строки в методе
I love red apples, and have 5 apples.

Позиционные и именованные аргументы

Если фигурные скобки передаются без каких-либо параметров, Python вставит значения, переданные с помощью метода str.format (), по порядку, как это было в предыдущих примерах. Рассмотрим ещё один пример:

print("My friend {} has a pet {}!".format("Sam", " winged dinosaur"))
My friend Sam has a pet winged dinosaur!

Первая пара фигурных скобок заменяется первым значением метода, вторая пара – вторым значением. Значения метода выглядят так:

("Sam", " winged dinosaur")

Эти данные являются кортежем. Любое значение кортежа можно вызвать с помощью индекса – порядкового номера (начиная с 0).

Вы можете использовать эти индексы внутри фигурных скобок:

print("My friend {0} has a pet {1}!".format("Sam", " winged dinosaur"))

Это вернёт такой же результат:

My friend Sam has a pet winged dinosaur!

А теперь попробуйте поменять индексы местами:

print("My friend {1} has a pet {0}!".format("Sam", " winged dinosaur"))
My friend winged dinosaur has a pet Sam!

Если вы вызовете значение с индексом 2, а в методе значения с таким индексом нет, программа вернёт ошибку. Например:

print("My friend {2} has a pet {1}!".format("Sam", " winged dinosaur"))
IndexError: tuple index out of range

Это значит, что запрашиваемый индекс находится вне диапазона кортежа (в данном случае это числа между 0 и 1).

Добавьте ещё несколько заполнителей и значений, например:

print("Tom is a {}, {}, and {} {}!".format("happy", "smiling", "tall", "man"))
Tom is a happy, smiling, and tall man!

Без дополнительных параметров метод str.format() вставит значения по порядку.

Значения кортежа имеют следующие индексы:

Попробуйте изменить порядок внесения значений в строку с помощью индексов:

print("Tom is a {3}, {2}, and {1} {0}!".format("happy", "smiling", "tall", "man"))
Tom is a man, tall, and smiling happy!

Кроме позиционных аргументов существуют также именованные аргументы. Эти аргументы можно вызвать по имени. Например:

print("Tom {0} {1} a {pr}.".format("has", "made", pr = "pull request"))
Tom has made a pull request.

Именованный аргумент pr можно использовать вместе с позиционными. Позиционные и именованные аргументы позволяют изменять порядок внесения значений в строку:

print("Tom {pr} {1} a {0}.".format("has", "made", pr = "pull request"))
Tom pull request made a has.

Типы

В фигурные скобки можно добавить больше параметров. Попробуйте использовать синтаксис {field_name:conversion}, где field_name задаёт индекс аргумента метода str.format(), а conversion – тип данных с помощью односимвольного кода, который использует Python. Здесь мы используем такой код:

s – строки (string)
d – десятичные числа (decimal)
f – число с плавающей точкой (float)

Попробуйте передать с помощью метода целое число как число с плавающей точкой, добавив тип f.

print("Sam ate {0:f} percent of a {1}!".format(75, "pizza"))
Sam ate 75.000000 percent of a pizza!

В первых фигурных скобках был использован синтаксис {field_name:conversion}, в остальных заполнителях используется только номер индекса.

Вы можете ограничить количество нулей после точки. Указывая тип f, вы можете дополнительно задать точность значения; для этого добавьте точку, затем укажите количество цифр, которое должно идти после запятой, а затем – сам тип.

Рассмотрим такой пример:

print("Sam ate {0:.3f} percent of a pizza!".format(75.765367))
Sam ate 75.765 percent of a pizza!

Как видите, несмотря на то, что в значении после точки идёт 6 символов, в строке отображается только три символа.

Попробуйте уменьшить количество символов после точки до одного.

print("Sam ate {0:.1f} percent of a pizza!".format(75.765367))
Sam ate 75.8 percent of a pizza!

Метод format округлит число до 75.8.

Попробуйте изменить тип данных на десятичные числа:

print("Sam ate {0:.d} percent of a pizza!".format(75.765367))
ValueError: Unknown format code "d" for object of type "float"

Чтобы вывести только целое число и опустить все символы после точки, используйте:

print("Sam ate {0:.0f} percent of a pizza!".format(75.765367))

При этом число с плавающей точкой не станет целым числом.

Отступы в переменных

Чтобы создать внутренние отступы в заполнителях, вы можете просто увеличить размер поля с помощью дополнительных параметров. Эта функция позволяет визуально организовать большое количество данных.

Для этого добавьте в фигурные скобки после индекса через двоеточие длину поля (в символах). Например:

print("Tom has {0:4} red {1:10}!".format(5, "apples"))
Sammy has 5 red apples !

По умолчанию строки выравниваются внутри поля по левому краю, а числа – по правому краю. Это можно изменить с помощью символов:

< — выравнивание по левому краю;
^ — выравнивание по центру;
> — выравнивание по правому краю.

Символ указывается после двоеточия. Например, чтобы выровнять объект в первых фигурных скобках по левому краю, а во вторых – по центру, нужно ввести:

print("Tom has {0:<4} red {1:^10}!".format(5, "apples"))
Sammy has 5 red apples !

По умолчанию Python заполняет свободное пространство внутри поля пробелами. Вы можете выбрать другой символ для заполнения. Его нужно указать сразу после двоеточия. Например:

print("{:*^20s}".format("Hallo"))
******* Hallo********

Эти параметры можно комбинировать с другими параметрами, например:

print("Sam ate {0:5.0f} percent of a pizza!".format(75.765367))
Sam ate 76 percent of a pizza!

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

Переменные

Теперь вы умеете передавать методу str.format() целые числа, числа с плавающей точкой и строки.

Кроме того, метод str.format() может работать с переменными.

Рассмотрим такой пример:

nApples = 8
print("Tommy has {} apples today!".format(nApples))
Tommy has 8 apples today!

Переменную можно использовать и вместо исходной строки, например:

tommy = "Tommy has {} apples today!"
nApples = 8
print(tommy.format(nApples))
Tommy has 8 apples today!

Переменными можно заменить любую часть синтаксиса. Это упрощает работу с пользовательскими входными данными.

Организация данных

Функции форматирования позволяют структурировать большое количество данных. Чтобы сделать вывод удобочитаемым, можно увеличить размер поля и изменить выравнивание.

Рассмотрим типичный пример Python, который выведет число «i», «i*i» и «i*i*i» в диапазоне от 3 до 12:

for i in range(3,13):
print(i, i*i, i*i*i)
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
11 121 1331
12 144 1728

Этот вывод выглядит понятно, однако из-за сдвигов в нижней части наступает путаница. И чем больше символов будет в числе, тем большим будет сдвиг. В результате такой вывод будет неудобно читать.

Попробуйте отформатировать его:

for i in range(3,13):
print("{:3d} {:4d} {:5d}".format(i, i*i, i*i*i))

В данном случае фигурные скобки не содержат индекса. После двоеточия сразу идёт размер поля, затем тип данных (d). Таким образом, в каждом столбце окажется минимум один свободный символ.

3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
11 121 1331
12 144 1728

Также можно задать одинаковое количество символов в каждом столбце.

for i in range(3,13):
print("{:6d} {:6d} {:6d}".format(i, i*i, i*i*i))
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
11 121 1331
12 144 1728

Также вы можете изменять выравнивание с помощью символов <, ^ и >, изменять тип данных, добавлять индексы.

Заключение

Форматирование в Python – это удобный и эффективный способ объединения строк и визуальной организации данных. Методы форматирования довольно просты, но их синтаксис не всегда очевиден. Тем не менее, с их помощью вы можете передавать переменные в строку и сделать вывод удобочитаемым.

Tags:

Текст программы говорит о том, как, а комментарии должны объяснять, почемуSwaroop Chitlur («A Byte of Python»)

Строки исходного текста

Физические строки

Физическая строка исходного файла - это строка заканчивающаяся символом признака конца строки (вводится нажатием на клавишу Enter). Этот признак - специальный символ, зависящий от платформы. В Unix, использует ASCII LF (перевод строки), в Windows - последовательность ASCII CR LF (возврат каретки с последующим переводом строки) и Macintosh - ASCII CR (возврат каретки). Все эти формы можно использовать в равной степени, независимо от платформы.

Логические строки

Программа Python разделена на несколько логических строк. Логическая строка содержит одну или более физических строк, соединяющихся правилами языка. (В интерактивном режиме продолжение логической строки на новой физической строке будет начинаться с символов...). Логическая строка - это законченное высказывание (инструкция ) языка.

Отступы в начале строки

Ведущие пробельные символы (пробелы и табуляции) в начале строки используются в Python для определения группы инструкций, как единого целого - составной инструкции или блока. Отступы в пределах блока должны быть равной символьной длины , иначе это приведет к ошибке. Для совместимости на разных платформах не следует применять смесь из пробелов и табуляций. Например:
Программа 2.1

From turtle import* begin_fill() for i in range(5): fd(150) for j in range(5): fd(50) left(144) left(144) end_fill() mainloop()

Примечание. В дальнейшем, программы будут нумероваться в формате: Программа x.y, где x - номер урока, y - номер программы в этом уроке.

Комментарии в Python начинаются с символа “#”. Комментарий заканчивается в конце физической строки и означают конец логической строки, если не используется неявное соединение строки (см. ниже). Комментарии предназначены для пояснений или заметок программиста. Комментарии помогают понять смысл исходного кода другим программистам (см. эпиграф). Комментарии полезны также при отладке программного кода и выявления ошибок. В пределах комментария можно использовать любые символы, в том числе служебные.

Объединение нескольких физических строк

Две (или более) физические строки могут быть объединены в одну логическую строку с использованием обратного слэша (бэк-слэш, “\”), а именно: когда физическая строка заканчивается символом “\” и он не является частью строки (т. е. не находится в пределах ” “) или комментария, он присоединяет следующую физическую строку, образуя одну логическую строку. После символа “\” должен следовать символ признака конца строки (т. е. физическая строка должна заканчиваться). Например:

If 1900 < year < 2100 and 1 <= month <= 12 \ and 1 <= day <= 31 and 0 <= hour < 24 \ and 0 <= minute < 60 and 0 <= second < 60: # Успешная проверка даты return 1

Примечание. Внутри строкового литерала экранирование бзк-слэша не имеет эффекта, но «\\» уменьшает количество выводимых символов "\" на 1:

Print("\ ") print("\\ ") print("\\\ ") print("\\\\") \ \ \\ \\

Неявное объединение физических строк

Выражения в скобках, в квадратных скобках, либо в фигурных скобках можно разделить на несколько физических строк без использования обратной косой черты. Например:
Программа 2.2

A = "Меня зовут - " b = input("Ваше имя: ") c = "\nМне - " d = input("Ваш возраст: ") e = "лет." print(a, # "Меня зовут - " b, # Имя, которое вы ввели c, # "Мне - " d, # Возраст, который вы ввели e # "лет")

Функция print()

В программа 2.2 для вывода данных на дисплей используется функция print() . Если не используется метод format() (см. ниже), то функция используется для вывода без форматов. Функция print имеет аргументы, которые могут придать выводимой информации читаемый вид. В общем виде функция имеет следующие аргументы:

Print(*objects, sep=" ", end="\n", file=sys.stdout, flush=False)

*objects - перечисленные через запятую объекты (переменные, строки, константы), значения которых нужно выводить
sep=" " - разделитель (по умолчанию - пробел)
end="\n" - завершающий символ (по умолчанию - символ конца строки)
file=sys.stdout - вывод в файл. Объект file должен быть объектом с методом write(str) . print() можно использовать только для текстовых файлов.
flush=False - принудительная очистка буфера вывода (по умолчанию - нет, поскольку обычно определяется файлом).

Например:
Программа 2.3 print("2", "+", "2", "= ") print("4") print("2", "+", "2", "= ", end="") print("4") print("2", "+", "2", "= ", sep="\n") print("4")

Вывод программы:

2 + 2 = 4 2 + 2 = 4 2 + 2 = 4

Метод format()

Функция print() имеет существенный недостаток - она не имеет аргументов, позволяющих производить форматированный вывод. Для осуществления вывода данных с определенным форматированием необходимо использовать метод format() .
Мини-руководство по этому методу на страницах документации
Примечание . В python отсутствует символьный тип данных, поэтому одиночный символ также рассматривается как строка.
Синтаксис метода format() :

"{:format_spec}".format()

где format_spec - спецификация формата:
[#][.precision]
Выглядит довольно пугающе, но не беспокойтесь! Обычно используется ограниченное количество форматирующих элементов, к тому же все они не являются обязательными!
Назначение форматирующих элементов:

fill - символ-заполнитель (любой символ)
align - выравнивание. Значения: "" | "=" | "^"
sign - вывод знака. Значения: "+" | "-" | " "
# - вывод префикса для двоичного, восьмеричного и шестнадцатеричного формата (т. е. 0x , 0o , или 0b)
0 - заполнение лидирующими нулями для числовых типов, когда выравнивание не задано явно
width - ширина поля вывода (целое число)
grouping_option - разделитель разрядов «,» или «_» . Не используется для российской локали (для этих целей используется формат «n»)
.precision - количество дробных знаков (точка обязательна, затем следует целое число)
type - тип выводимого значения (см. таблицу ниже).

Обозначения типов

Символ	Описание
b	Бинарный формат. Выводит число в двоичной системе счисления
c	Преобразует на выводе целое число в соответствующий символ юникода
d	Десятичное целое число
e	Число в экспоненциальном (научном) формате, e - строчная
E	Число в экспоненциальном (с плавающей точкой, научном) формате, E - Прописная
f	Число с фиксированной точкой
F	Число с фиксированной точкой, NAN и INF (не число и бесконечность) выводить прописными
g	Общий числовой формат. Для заданной точности p >= 1 это число округляется до p значащих цифр, а затем форматирует результат как в формате с фиксированной точкой или в научной нотации в зависимости от величины.
G	То же самое, что и «g», но буквенные символы выводятся прописными
n	То же самое, что и «d», за исключением того, что используется текущая настройка локали для вставки соответствующих символов разделителей.
o	Число в восьмеричной системе счисления
s	Строковый тип (по умолчанию)
x	Шестнадцатеричное число
X	То же самое, что и «x», только буквенные символы выводятся прописными
%	Значение выводится в процентах (умножается на 100 и добавляется символ «%»)
None	Аналогичен «g», за исключением того, что нотация с фиксированной точкой, используется, тогда, когда число имеет по крайней мере одну цифру после десятичной точки. Точность по умолчанию настолько высока, насколько это необходимо для представления конкретного значения.

Флаги используемые для выравнивания:

> - Выравнивание объекта по правому краю
^ - Выравнивание по центру

Например:
Программа 2.4 print("{:<10}".format("Я")) print("{:^10}".format("Я")) print("{:>10}".format("Я"))

Вывод программы:

Я Я Я

Постановка задачи: С помощью символа "*" вывести следующий рисунок:

* *** ***** ******* ********* ***********

Решение: будем выводить символ "*" c выравниванием по центру:
Программа 2.5

Print("{:^11}".format("*")) print("{:^11}".format("***")) print("{:^11}".format("*****")) print("{:^11}".format("*******")) print("{:^11}".format("*********")) print("***********")

Можно использовать несколько спецификаций формата для одного и более выводимых значений различных объектов, перечисленных в методе format. Каждая спецификация должна заключаться в отдельные {} . Между спецификациями, заключенными в {} могут находиться произвольное количество различных символов-разделителей. Это позволяет выполнить сколь угодно сложное форматирование внятными и понятными инструментами. Например.
Постановка задачи: Вывести следующий рисунок:

********** ********** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ********** **********

Символы пробела и табуляции не использовать!
Решение:
Программа 2.6

Print("**********") print("**********") print("{:}{:>8}".format("**", "**")) print("{:}{:>8}".format("**", "**")) print("{:}{:>4}{:>4}".format("**", "**", "**")) print("{:}{:>4}{:>4}".format("**", "**", "**")) print("{:}{:>8}".format("**", "**")) print("{:}{:>8}".format("**", "**")) print("**********") print("**********")

Несложно заметить, что в этой программе выводится один и тот же объект несколько раз. Метод format() , позволяет рассматривать совокупность перчисляемых объектов как список и, соответственно, использовать индексацию для повторного вывода нужного объекта. Тогда этот код можно переписать следующим образом:

Print("**********") print("**********") print("{0:}{0:>8}".format("**")) print("{0:}{0:>8}".format("**")) print("{0:}{0:>4}{0:>4}".format("**")) print("{0:}{0:>4}{0:>4}".format("**")) print("{0:}{0:>8}".format("**")) print("{0:}{0:>8}".format("**")) print("**********") print("**********")

Примечание. Первый элемент списка имеет индекс 0. Когда для одного объекта используется несколько спецификаций формата, то для каждой из них первым символом в спецификации должен следовать символ-индекс выводимого объекта (в данном случае - он единственный, поэтому везде стоят нули).
Усложним задачу для закрепления основ работы с методом format() .
Постановка задачи: Вывести слово "МИР" с помощью символа "*". Символы пробела и табуляции не использовать.

* * * * ***** ** ** * ** * * * * * * * * ***** * * ** * * * * * * *

Решение:
Программа 2.7

Print("{0:1}{0:>6}{0:>2}{0:>6}{1:>6}".format("*","*****")) print("{0:1}{0:>5}{1:>2}{0:>6}{1:>2}{1:>5}".format("**","*")) print("{0:1}{0:>3}{0:>3}{0:>2}{0:>3}{0:>3}{1:>6}".format("*","*****")) print("{0:1}{0:>6}{1:>3}{0:>5}{0:>2}".format("*","**")) print("{0:1}{0:>6}{0:>2}{0:>6}{0:>2}".format("*"))

В этой программе для одного или двух выводимых объектов используются от 5 до 7 спецификаций формата. На рисунке ниже поясняется как используется индексация для каждой спецификации.

Домашнее задание

Выведите следующие рисунки с помощью метода format() и функции print() :

1. * ** *** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ************* ************** 2. ***** * ** *** **** ***** ****** ******* ******** ********* ********** *********** ********************* ******************* **************** 3. * *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** * 4. * * * * * * * * * * * * * * * * * * * * * * * ** * ** * * * * * * * * * * *** * *** ******* * * * ***

До сих пор мы использовали два способа вывода: вывод значений выражений в интерактивном режиме и с помощью инструкции print (третий способ — метод объектов-файлов write() ).

Часто возникает желание иметь больший контроль над форматированием вывода, чем просто выводить значения, разделённые пробелом. Конечно, Вы можете сами обрабатывать строки: с помощью операций среза и объединения можно создать любое расположение, какое только Вы сможете представить. Строки имеют методы, позволяющие дополнять их пробелами до необходимой ширины колонки 1 . Другой путь — использовать оператор % со строкой в качестве левого аргумента. Оператор % интерпретирует строку справа как строку формата в стиле функции sprintf() в C, которую нужно применить к правому аргументу, и возвращает строку с результатом форматирования.

Безусловно, остаётся еще один вопрос: как получить строковое представление для значений различного типа? К счастью, Python предоставляет возможность преобразовывать значение любого типа в строку: с помощью функции str() . Фактически язык предоставляет две функции для получения строкового представления — repr() (тот же эффект можно получить просто заключив выражение в обратные кавычки: `expr` ) и str() . Первый способ, например, используется интерпретатором для вывода значений выражений в интерактивном режиме, второй — для вывода аргументов инструкцией print . Функция str() по возможности возвращает представление, наиболее пригодное для вывода, а функция repr() — для ввода выражения в интерактивном режиме. Приведём несколько примеров:

>>> x = 10 * 3.14

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

>>> x
31.400000000000002

Однако функция str() выведет число с разумной точностью:

>>> y = 200*200
>>> s = "Значение x равно " + str(x) + \
... ", значение y равно " + str(y) + "..."
>>> print s
Значение x равно 31.4, значение y равно 40000...

Длинные целые числа записываются в языке Python с суффиксом "L". Начиная с версии 1.6, функция str() его не выводит:

>>> repr(1000L)
"1000L"
>>> str(1000L)
"1000"

Строковое представление можно получить и для других типов:

>>> p =
>>> ps = repr(p)
>>> ps
""
>>> `x, y, ("spam", "eggs")`
"(31.400000000000002, 40000, ("spam", "eggs"))"

Функция repr() (или `` ) добавляет кавычки и записывает спецсимволы с помощью управляющих последовательностей:

>>> hello = "hello, world\n"
>>> print hello
hello, world

>>> hellos = `hello`
>>> print hellos
"hello, world\n"

Выведем таблицу квадратов и кубов двумя описанными способами:

>>> for x in range(1, 11):
... print str(x).rjust(2), str(x*x).rjust(3),
... # Обратим внимание на завершающую запятую
... print str(x*x*x).rjust(4)
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000

>>> for x in range(1,11):
... print "%2d %3d %4d" % (x, x*x, x*x*x)
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000

(Обратите внимание на то, что один пробел между колонками был добавлен инструкцией print .)

Этот пример демонстрирует использование метода строк rjust() , который выравнивает строку вправо в поле заданной ширины, дополняя её слева пробелами. Аналогично действуют методы ljust() и center() . Они не выводят ничего — просто возвращают новую строку. Если исходная строка слишком длинная, она не обрезается, а возвращается в неизменном виде: обычно лучше внести беспорядок в расположение колонок, чем вывести неверное значение. (Если Вы действительно хотите её обрезать, воспользуйтесь операцией среза: "s.ljust(n)" .)

Также может быть полезна функция zfill() , определённая в модуле string , которая дополняет слева нулями строку с числом, корректно обрабатывая знаки плюс и минус:

>>> import string
>>> string.zfill("12", 5)
"00012"
>>> string.zfill("-3.14", 7)
"-003.14"
>>> string.zfill("3.14159265359", 5)
"3.14159265359"

Использование оператора % выглядит примерно так:

>>> import math
>>> print "Значение PI приблежённо равно %5.3f." % \
... math.pi
Значение PI приблежённо равно 3.142.

Если в строке нужно вывести несколько значений, в качестве правого операнда используется кортеж:

>>> table = {"Sjoerd": 4127, "Jack" : 4098, "Dcab" : 7678}
>>> for name, phone in table.items():
... print "%-10s ==> %10d" % (name, phone)
...
Dcab ==> 7678
Jack ==> 4098
Sjoerd ==> 4127

Большинство форматов работают точно так же, как и в C. Однако, если типы аргументов не соответствуют формату, интерпретатор приводит их к необходимому типу (например, выражение любого типа может быть преобразовано в строку с помощью встроенной функции str() ) или, если это невозможно, генерирует исключение 2 . Вы можете использовать * для того, чтобы передать отдельным параметром ширину поля или точность.

Заметим, что если правый аргумент кортеж, он всегда считается списком аргументов:

>>> def f(x):
... print "Функции передано значение "%s"" % x
...
>>> f(1)

>>> f()

>>> # интерпретируется не так, как вы ожидали
... f((1,))
Функции передано значение "1"
>>> # ошибка
... f((1, 2))
Traceback (most recent call last):
File "", line 2, in
File "", line 2, in f
TypeError: not all arguments converted during string formatting

В данном случае надёжнее будет использовать в качестве правого операнда кортеж, состоящий из одного элемента:

>>> def f(x):
... print "Функции передано значение "%s"" % (x,)
...
>>> # Теперь всё правильно
... f((1,))
Функции передано значение "(1,)"
>>> f((1, 2))
Функции передано значение "(1, 2)"
>>> f(1)
Функции передано значение "1"
>>> f()
Функции передано значение ""

В случае длинных строк формата, Вы можете захотеть ссылаться на переменные по имени вместо их положения. Это можно сделать, используя расширенную запись в виде %(name)format , например:

>>> table = {"Sjoerd": 4127, "Jack": 4098, "Dcab": 8637678}
>>> print "Jack: %(Jack)d; Sjoerd: %(Sjoerd)d; Dcab: %(Dcab)d" % table
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Такая запись особенно полезна в комбинации со встроенной функцией vars() , которая возвращает словарь с переменными в текущей области видимости.

На этой стадии, мы владеем уже достаточно обширным набором инструментария и можем писать достаточно "запутанный" код. После написания кода в несколько десятков строк, уже через несколько дней, его будет достаточно сложно прочесть. Другим же людям, будет его прочесть еще сложнее.
А если представить, что в крупных проектах мегабайты текстовых файлов с кодом, то они становятся еще более сложно читаемыми. Эту ситуацию спасают комментарии внутри кода. Эти комментарии, программисты оставляют для того, чтобы со временем, они могли прояснить тот или иной фрагмент кода и описать, какие-то действия, происходящие в определенных частях программного кода. Для ваших коллег и для вас же - это значительно облегчит читаемость кода.

В питоне различают два типа комментариев: Однострочный и многострочный. Однострочный комментарий начинается с символа "#", может быть как в отдельной строке, так и оканчивать строку с кодом, но обязательно должен быть однострочным, Т.Е. Не должен разбиваться на две строки. Он может оканчивать строку с кодом, но не может находиться в середине строки между двух частей кода. Кпримеру:

i = 0 # Счетчик для цикла

# Цикл будет выполняться исходя из условия выше

Многострочные комментарии заключаются в тройные кавычки""". Они могут разбиваться на несколько строк и быть достаточно длинными. По-факту, хоть сочинение пишите. Многострочный комментарий должен начинаться с новой строки и может продолжаться в других строках. Кпримеру:

"""Обходим список для нахождения необходимого элемента

После нахождения, обрываем цикл и сохраняем результат в переменную x

Если необходимый элемент найден небудет, сообщаем про это пользователю"""

Обратите внимание, однострочный комментарий, обязан начинаться с таким же отступом, как и код соответствующего блока, в противном случае будет трекбек. Также и многострочный комментарий, должен начинаться с соответствующим блоку кода отступом. Последующие строки комментария уже не требуют сохранять отступ, отступ должен быть только перед открывающими комментарий кавычками """.

Начинающие программисты, да и не только начинающие, часто пишут в комментариях очевидные вещи, что-то вроде "Я объявил тут переменную x". Пытайтесь избегать комментариев, которые дублируют произведенное действие человеческим языком. Перед написанием комментария, попробуйте задавать себе такие вопросы: "Для чего служит этот фрагмент?", "Какую цель я приследую этим фрагментом кода?", "Что я делаю при помощи этого фрагмента кода?", "Что в этом фрагменте неочевидно?"... Подобный ряд вопросов, поможет сконструировать правильный комментарий, который действительно поможет сопровождать код в будущем и сделает его более читаемым.

Операторы форматирования строки

Сейчас под выражением "форматирование строки", мы имеем ввиду разворачивание значений переменных в строке, Т.Е. КОгда есть необходимость в какой-тро строке, вставить значения каких-то переменных. Ранее мы делали это при помощи "+" - соединения строк и "," запись численных выражений после строк. Выглядело это, как минимум, некрасиво.

>>> a = "Hello"

>>> b = "dear"

>>> a + " " + b

Есть 2 штатных способа разворачивания значений переменных в строке. Сейчас мы поговорим о способе форматирования операторами форматирования. Этот способ более старый, устаревший, наименее удобный и нежелательный к использованию, но часто применяющийся в более старом коде.

Давайте рассмотрим следующий вариант:

>>> a = "Vasya"

>>> print "Привет %s" % a

Привет Vasya

Что происходит? Все достаточно просто. Оператор %s в нашей строке, заменяется на переменную, которая стоит справа от знака % после нашей строки.

Давайте рассмотрим еще один пример:

>>> name = "Vasya"

>>> lastname = "Pupkin"

>>> age = 25

>>> print "Имя %s, фамилия %s, возраст %d" % (name,lastname,age)

Имя Vasya, фамилия Pupkin, возраст 25

Во-первых обратите внимание, что если переменных более одной, мы передаем их в кортеже (). Также вы могли заметить, что строчные значения переменных, я передал при помощи оператора %s, а переменную ссылающуюся на число, при помощи оператора %d. Это работает только так. Каждый оператор может развернуть значение определенного типа: %s - строку, %d - число и Т.Д. Более подробный список операторов, будет приведен ниже.

Первый вопрос, который напрашивается сам собой: "Как нам вывести значение одной переменной несколько раз в одной строке?". Ответ очевиден, нам прийдется передать эту переменную в кортеже столько раз и в том порядке, в котором мы разворачиваем значения этих переменных в нашей строке. Это топорно и неудобно. Мы всегда должны записывать переменные в строгом порядке, который будет соответствовать разворачиванию их операторами в строке, да еще и повторять их при необходимости.

Список операторов форматирования:

"%d", "%i", "%u"

Десятичное число.

Число в восьмеричной системе счисления.

Число в шестнадцатеричной системе счисления (буквы в нижнем регистре).

Число в шестнадцатеричной системе счисления (буквы в верхнем регистре).

Число с плавающей точкой с экспонентой (экспонента в нижнем регистре).

Число с плавающей точкой с экспонентой (экспонента в верхнем регистре).

Число с плавающей точкой (обычный формат).

Число с плавающей точкой. с экспонентой (экспонента в нижнем регистре), если она меньше, чем -4 или точности, иначе обычный формат.

Число с плавающей точкой. с экспонентой (экспонента в верхнем регистре), если она меньше, чем -4 или точности, иначе обычный формат.

Символ (строка из одного символа или число - код символа).

Строка (литерал python).

Строка (как обычно воспринимается пользователем).

Операторы форматирования (дополнительно)

Тут я коротко продемонстрирую дополнительные возможности операторов форматирования.

Спецификаторы преобразования записываются в следующем порядке:

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

3. Флаги преобразования.

4. Минимальная ширина поля. Если *, значение берётся из кортежа.

5. Точность, начинается с ".", затем - желаемая точность.

6. Модификатор длины (опционально).

7. Тип (см. таблицу выше).

>>> print ("%(language)s has %(number)03d quote types." % {"language": "Python", "number": 2})

Python has 002 quote types.

Флаги преобразования:

Значение будет использовать альтернативную форму.

Свободное место будет заполнено нулями.

Свободное место будет заполнено пробелами справа.

Свободное место будет заполнено пробелами слева.

>>> "%.2s" % "Hello!"

>>> "%.*s" % (2, "Hello!")

>>> "%-10d" % 25

>>> "%+10f" % 25

>>> "%+10s" % "Hello"

Более подробно разбирать эти возможности не имеет смысла, ввиду их редкого использования.

Метод форматирования строк format()

На смену операторам форматирования, кнам пришел строчный метод format() . Этот метод куда более гибкий, удобный и многогранный в использовании. Давайте рассмотрим его применение для разворачивания значений переменных в строке.

>>> name = "Vasya"

>>> lastname = "Pupkin"

>>> age = 25

>>> print "{} {}, возраст {}".format(name,lastname,age)

Vasya Pupkin, возраст 25

Тут все достаточно очевидно. Фигурные скобочки {}, определяют места развертывания переменных в строке, а методу format(), мы передаем переменные, которые нужно разворачивать. На первый взгляд, ничего по сравнению с операторами форматирования не изменилось. Мы попрежнему неможем никак управлять нашим разворачиванием. Разница только в том, что нам уже ненужно запоминать кучку операторов, для разворачивания значений разных типов. Ничего, это только начало. Давайте наращивать функционал последовательно. Давайте рассмотрим следующий вариант:

>>> name = "Vasya"

>>> lastname = "Pupkin"

>>> age = 25

>>> print "{0} {1}, возраст {2}".format(name,lastname,age)

Vasya Pupkin, возраст 25

Ничего не изменилось, но в наших фигурных скобочках добавились какие-то циферки. Смотрим следующий пример:

>>> print "{1} {0}, возраст {2}".format(name,lastname,age)

Pupkin Vasya, возраст 25

Выводимая строка изменилась, Мы поменяли местами значения. Вы могли заметить, что на не пришлось менять местами переменные, которые мы передали в метод, мы просто поменяли цифры в фигурных скобочках {}. Эти цифры, являются своеобразными индексами тех переменных, которые мы хотим развернуть в нашей строке. В последнем примере, мы развернули переменную под индексом 1, потом 0 и 2, Т.Е. Вторую, первую и третью переданные в метод переменные. Это значит, что мы, указывая индексы переменных, которые были переданы в метод, можем разворачивать их в нужном нам порядке. Также, мы можем несколько раз вывести в строке значение одной переменной, несколько раз указав ее индекс в фигурных скобочках.

>>> print "{1} {1}, возраст {2}".format(name,lastname,age)

Pupkin Pupkin, возраст 25

Согласитесь, это уже куда более гибкий и удобный способ форматирования строки, в сравнении с операторами форматирования. Но и на этом гибкость этого метода для разворачивания значений переменных не заканчивается. Давайте рассмотрим вариант, именованных аргументов.

>>> a = "Vasya"

>>> b = "Pupkin"

>>> print "{name} {lastname}, возраст {age}".format(age=c,name=a,lastname=b)

Vasya Pupkin, возраст 25

Тут еще интереснее. Необходимые данные, находились под ничего не говорящими переменными a, b и c. При передаче этих переменных в наш метод, мы дали им осмысленные названия вида (название=переменная), после чего использовали эти названия в наших фигурных скобочках {}.

Методу format, мы можем передавать список значений и разворачивать их внутри нашей строки. Происходит это следующим образом:

>>> l = ["Vasya", "Pupkin", 25]

["Vasya", "Pupkin", 25]

>>> print "{0} {1}, возраст {2}".format(*l)

Vasya Pupkin, возраст 25

Тут все более чем очевидно. Мы передали список и обращались к его элементам по индексам, но при передаче списка, перед переменной, мы указали знак "*", что явно сообщило методу format() о том, что мы будем разворачивать элементы этого списка. Что произойдет, если мы опустим "*", перед указанием аргумента со списком?

>>> print "{0} {1}, возраст {2}".format(l)

Traceback (most recent call last):

File " ", line 1, in

IndexError: tuple index out of range

Метод не знал, что мы передали список и пытался искать в себе обычные аргументы под индексами 1 и 2, к которым мы обращались в строке.

Схожим образом, мы можем передать в метод format() и словарь.

>>> db = {"name":"Vasya", "lastname":"Pupkin", "age":25}

{"lastname": "Pupkin", "age": 25, "name": "Vasya"}

>>> print "{name} {lastname}, возраст {age}".format(**db)

Vasya Pupkin, возраст 25

Это очень похоже на передачу именованных аргументов с той только разницей, что мы передали в наш метод словарь. Если перед передачей списка мы указывали одну звездочку "*", то перед передачей словаря, мы ставим две звездочки "**" перед аргументом в методе format(), а в фигурных скобочках строки, мы обращаемся к ключам переданного словаря, для разворачивания их значений.

Мы рассмотрели все варианты разворачивания переменных в строке, при помощи метода format(). В дальнейшем, я крайне рекомендую использовать этот метод вместо операторов форматирования, Т.К. Этот способ является более новым, гибким и официальные источники, советуют нам придерживаться именно этого метода.

Метод format() (дополнительно)

Далее я приведу дополнительные возможности строчного метода format(). Более обширную информацию про данный метод, вы можете посмотреть в статье на хабре , или в официальной документации по Python.

Внимание! Дальнейшее является фрагментом статьи про метод format()

Снова начнем с простого: если нужно вывести строку заданной длины, то после имени переменной добавляем двоеточие (:) и затем количество символов. Так, чтобы вывести мое имя и дополнить его до десяти символов пробелами я должен делать так:

>>> "Your name is {name:10}".format(name="Reuven")

"Your name is Reuven "

(Обратите внимание что строка дополнена пробелами после имени.)

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

>>> "Your name is {name:>10}".format(name="Reuven")

"Your name is Reuven"

И да, можно явно указать что я хочу выравнивания по левой стороне с помощью знака <

Если нужно вывести значение в центре блока, то вместо < и > используется символ ^:

>>> "Your name is {name:*^10}".format(name="Reuven")

"Your name is **Reuven**"

С текстом более менее понятно, но что насчет чисел? Лично мне было трудно предположить как это будет работать, но все оказалось достаточно прямолинейно. Для простого вывода чисел используем синтаксис похожий на строки:

>>> "The price is ${number}.".format(number=123)