Форматирование строк может быть довольно фундаментальным и простым, но что меня действительно поразило, так это то, как лучше всего выполнять форматирование при написании кода для конкретных ситуаций. И это любопытство как бы подвело меня к кроличьей норе.
Кстати, я уже писал другие статьи, связанные с Python, такие как Двоичный тип форматирования чисел в Python, который, возможно, требует от меня написания еще одной только для Python 3. Если вы также заинтересованы, я написал эту статью о написании сообщений в бинарный просто для удовольствия. Кроме этого, я писал в основном на Java и немного на JavaScript, не стесняйтесь проверить!
Форматирование строк в целом представляет собой процесс, который оценивает ваш строковый литерал, который содержит заполнители, которые в конечном итоге будут заменены соответствующими значениями. Это означает, что у вас может быть что-то вроде:
“I am [your_name] and I am [age] years old.”
Итак, в приведенном выше примере строки вы можете видеть, что your_name и age — это заполнители, в которых можно заменить любые входные данные или значения, которые вы хотите. В приведенном выше случае вы можете заменить имя на свое имя и возраст на свой возрастной номер.
Python в основном позволяет вам написать такую строку, а также заменить значения при ее запуске. Это действительно может помочь вам динамически обновлять значения в зависимости от того, кем является человек, вместо того, чтобы исправлять имя и возраст на месте.
Я уже писал Форматирование строк на Java, так что давайте посмотрим, как это делает Python. Я также постараюсь больше сосредоточиться на Python 3, а не на Python 2.
С учетом сказанного, в Python существует около 4 способов форматирования строк. Вот список:
- %-форматирование
- ул.формат()
- f-строка
- string.Шаблон
Если вам интересно, как произнести это вслух, вот как я их называю:
- Процентное форматирование
- Точечный формат
- струна фа
- Строковый шаблон
Да, пока у меня это работает, но если у вас есть предложения получше, оставьте свои комментарии ниже!
1. %-форматирование
Я помню, что узнал об этом, когда Python 2 еще существовал, и люди в основном все еще используют Python 2. Итак, как работает этот оператор %, так это то, что он использует позиционное форматирование. Позиционное форматирование — это тип форматирования, при котором заполнители заменяются в зависимости от порядка или положения ваших значений.
Позвольте мне показать вам пример:
name = ‘John’ friend = ‘Sarah’ “I am %s and I am with %s.” % (name, friend) # Output I am John and I am with Sarah.
Давайте еще раз взглянем на пример выше, но я поменял местами имя и друга:
“I am %s and I am with %s.” % (friend, name) # Output I am Sarah and I am with John.
Обратите внимание, как два значения меняются местами, когда я их меняю местами? Да, это из-за позиционного форматирования. Он принимает первое переданное ему значение и соответственно заменяет первый заполнитель, и так далее и тому подобное. Первый к первому, второй ко второму и т.
Теперь приведенный выше пример имеет дело только с одним типом, типом значения String или обозначенным %s под оператором %. А как насчет других типов? Что ж, оператор % предоставляет разные заполнители для разных типов, например:
- %s — Строка
- %d — Целые числа
- %f — числа с плавающей запятой
- %x / %X — целые числа в шестнадцатеричном представлении (как строчные, так и прописные)
- %.‹no_of_digits›f — числа с плавающей запятой с заданным количеством цифр. Я думаю, что по умолчанию есть 6 десятичных цифр.
Давайте посмотрим на другой пример:
name = ‘John’ age = 23 "I am %s and I am %d years old." % (name, age) # Output I am John and I am 23 years old.
Обратите внимание, как успешно заменяются значения в зависимости от типа заполнителя. Таким образом, если вы поменяете имя и возраст, оставив позиции заполнителей, как указано выше, это вызовет ошибку, потому что %s для строкового типа, но вместо этого вы указываете целое число. Помните, что дело в позиционном форматировании, то есть соответствие первого первому, второму совпадению и т. д.
Если вы поменяете местами %s и %d, оставив имя и возраст одинаковыми, это все равно выдаст ошибку из-за несоответствия типов.
Еще примеры для понимания:
name = ‘John’ age = 23 friend = ‘Sarah’ money = 68.88 print(‘I am %s and I am %d years old.’ % (name, age)) print(‘I am %s and I am with %s.’ % (name, friend)) print(‘I am %s and I am with %s.’ % (friend, name)) print(‘You are %s and your current balance is %f.’ % (name, money)) print(‘You are %s and your current balance is %.3f.’ % (name, money)) # Output I am John and I am 23 years old. I am John and I am with Sarah. I am Sarah and I am with John. You are John and your current balance is 68.880000. You are John and your current balance is 68.880.
Этот другой пример также интересен тем, что он может иметь именованный заполнитель, но все же использует позиционное форматирование. Давайте взглянем:
"I am %(my_name)s and my friend is %(friend_name)s." % {'my_name':name, 'friend_name':friend}
Он по-прежнему будет давать те же результаты, что и без именования. Тем не менее, я редко использую это и не видел, чтобы это использовалось часто, поскольку вы все еще не можете поменять его местами. Так что, на мой взгляд, в этом есть негибкость. Это главная причина, по которой я почти не использую его часто или вообще не использую.
2. Стр.формат()
Однако я использую его относительно часто, когда все просто, а не сложно. Кроме того, люди могут быстрее понять, когда читают код. Я имею в виду, там написано «формат».
Основной синтаксис для этого выглядит следующим образом:
[your_string].format()
Здесь есть 2 способа форматирования. Первый — это позиционное форматирование, при котором заполнители заменяются соответствующим образом. Второй - это то, что я бы сказал, форматирование на основе имени заполнителей. Это последнее просто означает, что даже если позиция ваших значений не в порядке, вы все равно можете заменить их правильно, если значения соответственно относятся к именованию заполнителей.
Давайте посмотрим, как работает позиционное форматирование:
name = ‘John’
age = 24
print('I am {} and {}.'.format(name, age))
print('I am {} and {}.'.format(age, name))
# Output
I am John and 24.
I am 24 and John.
Теперь давайте посмотрим на форматирование, ссылаясь вместо этого на имена:
print('I am {your_name} and {your_age}.'.format(your_name=name, your_age=age))
print('I am {your_name} and {your_age}.'.format(your_age=age, your_name=name))
# Output
I am John and 24.
I am John and 24.
Довольно просто и понятно, правда? Более того, второй способ действительно дает вам ту гибкость, что вам не нужно заботиться о порядке, и лично мне этот больше нравится.
Другие примеры с небольшим описанием:
# positional arguments
print("Hello {}, your current balance is {}.".format("John", 288.1234))
# index arguments
print("Hello {0}, your current balance is {1}.".format("John", 288.1234))
print("Hello {1}, your current balance is {0}.".format("John", 288.1234))
# keyword arguments
print("Hello {name}, your current balance is {blc}.".format(name="John", blc=288.1234))
# mixed arguments
print("Hello {0}, your current balance is {blc}.".format("John", blc=288.1234))
# Output
Hello John, your current balance is 288.1234.
Hello John, your current balance is 288.1234.
Hello 288.1234, your current balance is John.
Hello John, your current balance is 288.1234.
Hello John, your current balance is 288.1234.
Несмотря на все плюсы, люди все еще могут не захотеть использовать str.format(). Одна из вещей, которая может не понравиться людям, — это многословие. Например, здесь повторяется текстовое значение:
value = 5 * 10
'The value is {value}.'.format(value=value)
# Output
'The value is 50.'
Даже в самой простой форме есть немного шаблона, и значение, которое вставляется в заполнитель, иногда находится далеко от того места, где находится заполнитель:
'The value is {}.'.format(value)
'The value is 80.'
Честно говоря, я не нахожу проблемы, описанные выше, меня беспокоящими, но кто знает, решать вам.
3. Фа-струна
Этот тип называется так буквально потому, что вы пишете строку с буквой f в начале, за которой следует либо одинарная кавычка, либо тройная кавычка со строковым значением, заключенным внутри. Это выражение оценивается во время выполнения.
Вот синтаксис:
f’I am {name} and {age} years old.’
Таким образом, этот тип форматирования позволяет вам встраивать выражения Python внутрь самой строки. Используя приведенный выше синтаксис/пример, мы видим, что я вставляю переменные прямо в строку. Запустите его, и вы получите это без ошибок:
# Output I am John and 24 years old.
Этот способ форматирования действительно удивителен в том смысле, что он может быть очень гибким. Вы можете не только отформатировать весь шаблон, но и выполнять арифметические действия прямо внутри него. Как:
a = 5
b = 10
print(f‘Basic arithmetic gets you {a * b} and {2 * b + a}.’)
# Output
Basic arithmetic gets you 50 and 25.
Итак, как насчет форматирования всего шаблона? Это как-то связано со строкой f с тройной кавычкой. Используя тройные кавычки вместо одинарных, он может отображать именно ту строку, которую вы написали. Давайте посмотрим, что я имею в виду ниже:
name = 'Mark'
friend = 'John'
a = 5
b = 10
output = f'''
My friend is {friend}
and I am {name}
and we are doing simple math
which yields {a * b}.
'''
print(output)
# Output
My friend is John
and I am Mark
and we are doing simple math
which yields 50.
Как видите, он следует даже за пробелами без использования \n и т. д. Это действительно полезно, когда вам нужно выполнить сложное форматирование. Однако для простых вы можете использовать одинарную кавычку.
Обратная косая черта может не появляться внутри частей выражений f-строк, так как это может привести к ошибкам. Это означает, что вы не можете использовать их, например, для экранирования кавычек:
$ f'{\'quoted string\'}'
File "<stdin>", line 1
SyntaxError: f-string expression part cannot include a backslash
Я на самом деле использовал это много до недавнего времени. Я думаю, что str.format() тоже подойдет, и я просто использую его взаимозаменяемо.
Кроме того, говорят, что f-строки быстрее, чем два других наиболее часто используемых механизма форматирования строк: %-formatting и str.format().
4. Строковый шаблон
Еще один вариант форматирования строки в Python. Предположительно, это несколько более простой синтаксис и функциональность, но это вам судить.
Лично я не очень часто работаю с этим, зная 3 других способа форматирования строк, но я понимаю, почему его проще использовать из-за синтаксиса и обстоятельств. Давайте взглянем.
Чтобы использовать это, вам нужно импортировать шаблон. Давайте посмотрим на синтаксис:
from string import Template Template(‘Your string here: $ans’).substitute(ans=’yes’)
Так что, посмотрев на синтаксис, его, вероятно, можно сравнить с str.format() из-за того, что он немного похож на него.
Второе, что очевидно, помимо использования Template и структуры, — это заполнитель. Вместо фигурных скобок {} используется знак доллара $. Итак, если мы посмотрим на простоту заполнителя, он, вероятно, похож на %, используемый в %-форматировании.
Однако, если вы хотите использовать фигурные скобки, это тоже возможно. Просто это ничем не отличается от без фигурных скобок, если вы используете это так:
‘You are ${adj}’
Это то же самое, что:
‘You are $adj’
Итак, когда мы используем фигурные скобки? Когда после этого следуют письма.
‘You are ${adj}.’
‘When you want to do ${noun}fication.’
Извините за случайные предложения, но это когда вы включаете скобки. Это нужно для того, чтобы определить, что именно это слово или ключевое слово будет заменено. В противном случае может быть неправильно истолковано, что вместо наименование вместо существительное это заполнитель. Для adj. это все еще может работать, так как учитываются только допустимые символы. Однако в целях безопасности лучше просто использовать фигурные скобки. Без фигурных скобок вы рискуете вызвать ошибки.
Вот к примерам:
Template('$obj is $colour').substitute(obj='Car',colour='black')
Template('$obj. is $colour').substitute(obj=’It’,colour='blue')
Template('${noun}ification').substitute(noun='Ident')
# Output
Car is black
It. is blue
Identification
Самое классное в этом то, что вы можете использовать словарь в качестве замены вместо того, чтобы определять ключ-значение один за другим, как описано выше. Давайте посмотрим на пример:
dict_var = dict(name=’Mark’, friend=’John’) Template(‘The $friend has $name as a friend.’).substitute(dict_var) # Output That John has Mark as a friend.
Итак, чтобы вместо этого использовать словарь, убедитесь, что ключи совпадают с заполнителями. Python позаботится обо всем остальном.
Еще одна вещь, на которую вы, возможно, захотите обратить внимание, - это использование побега. Что произойдет, если вы захотите использовать знак доллара? Это в основном то же самое, что и любой другой способ форматирования, просто избегайте символа, удваивая его. Вот что я имею в виду:
Template(‘$name owes you $$$amount.’).substitute(name=’John’, amount=100) # Output John owes you $100.
Обратите внимание, как я использую два $ для вывода одного $, а третий $ просто указывает, что это ключевое слово-заполнитель, которое будет заменено моим значением.
Для получения дополнительной информации об этом вы можете получить доступ к документации строки шаблона.
Заворачивать
В этой статье мы увидели различные способы форматирования, доступные в Python. Мы также видели различные синтаксисы, которые можно использовать для форматирования строк, и типы преобразования, которые можно использовать для разных типов данных. Надеюсь, вы узнали их лучше.
Это все для сегодняшнего обучения. Если вы заметили что-то, чего мне не хватает в этой статье, не стесняйтесь поделиться этим в разделе комментариев ниже. Мы все хотели бы учиться вместе.
Спасибо за прочтение.
