f-строки в Python
Начиная с версии 3.6 в Python появился новый тип строк — f-строки, которые буквально означают «formatted string». Эти строки улучшают читаемость кода, а также работают быстрее чем другие способы форматирования. F-строки задаются с помощью литерала «f» перед кавычками.
>>> "обычная строка" >>> f"f-строка"f-строки — это пятый способ (sic!) форматирования строк в Python, который очень похож на использование метода format().
Вспомним все 5 способов форматирования.
5 способов форматирования строк
1. Конкатенация. Грубый способ форматирования, в котором мы просто склеиваем несколько строк с помощью операции сложения:
>>> name = "Дмитрий" >>> age = 25 >>> print("Меня зовут " + name + ". Мне " + str(age) + " лет.") >>> Меня зовут Дмитрий. Мне 25 лет.2. %-форматирование. Самый популярный способ, который перешел в Python из языка С. Передавать значения в строку можно через списки и кортежи , а также и с помощью словаря. Во втором случае значения помещаются не по позиции, а в соответствии с именами.
>>> name = "Дмитрий" >>> age = 25 >>> print("Меня зовут %s. Мне %d лет." % (name, age)) >>> Меня зовут Дмитрий. Мне 25 лет. >>> print("Меня зовут %(name)s. Мне %(age)d лет." % ) >>> Меня зовут Дмитрий. Мне 25 лет.3. Template-строки. Этот способ появился в Python 2.4, как замена %-форматированию ( PEP 292 ), но популярным так и не стал. Поддерживает передачу значений по имени и использует $-синтаксис как в PHP.
>>> from string import Template >>> name = "Дмитрий" >>> age = 25 >>> s = Template('Меня зовут $name. Мне $age лет.') >>> print(s.substitute(name=name, age=age)) >>> Меня зовут Дмитрий. Мне 25 лет.4. Форматирование с помощью метода format(). Этот способ появился в Python 3 в качестве замены %-форматированию. Он также поддерживает передачу значений по позиции и по имени.
>>> name = "Дмитрий" >>> age = 25 >>> print("Меня зовут <>. Мне <> лет.".format(name, age) >>> Меня зовут Дмитрий. Мне 25 лет. >>> print("Меня зовут Мне лет.".format(age=age, name=name) >>> Меня зовут Дмитрий. Мне 25 лет.5. f-строки. Форматирование, которое появилось в Python 3.6 ( PEP 498 ). Этот способ похож на форматирование с помощью метода format(), но гибче, читабельней и быстрей.
>>> name = "Дмитрий" >>> age = 25 >>> print(f"Меня зовут Мне лет.") >>> Меня зовут Дмитрий. Мне 25 лет.Курс по языку Python 3
- Научитесь программировать на Python с нуля
- Более 130 уроков и 300 заданий
- Поддержка преподавателя на всех этапах
Погружение в f-строки
f-строки делают очень простую вещь — они берут значения переменных, которые есть в текущей области видимости, и подставляют их в строку. В самой строке вам лишь нужно указать имя этой переменной в фигурных скобках.
>>> name = "Дмитрий" >>> age = 25 >>> print(f"Меня зовут Мне лет.") >>> Меня зовут Дмитрий. Мне 25 лет.f-строки также поддерживают расширенное форматирование чисел:
>>> from math import pi >>> print(f"Значение числа pi: ") >>> Значение числа pi: 3.14С помощью f-строк можно форматировать дату без вызова метода strftime():
>>> from datetime import datetime as dt >>> now = dt.now() >>> print(f"Текущее время ") >>> Текущее время 24.02.2017 15:51Они поддерживают базовые арифметические операции. Да, прямо в строках:
>>> x = 10 >>> y = 5 >>> print(f" x / 2 = ") >>> 10 x 5 / 2 = 25.0Позволяют обращаться к значениям списков по индексу:
>>> planets = ["Меркурий", "Венера", "Земля", "Марс"] >>> print(f"Мы живим не планете ") >>> Мы живим не планете ЗемляА также к элементам словаря по ключу:
>>> planet = >>> print(f"Планета . Радиус км.") >>> Планета Земля. Радиус 6378.0 км. Причем вы можете использовать как строковые, так и числовые ключи. Точно так же, как в обычном Python коде:
>>> digits = >>> print(f"0 - , 1 - ") >>> 0 - ноль, 1 - одинВы можете вызывать в f-строках методы объектов:
>>> name = "Дмитрий" >>> print(f"Имя: ") >>> Имя: ДМИТИРИЙА также вызывать функции:
>>> print(f"13 / 3 = ") >>> 13 / 3 = 4 f-строки очень гибкий и мощный инструмент для создания самых разнообразных шаблонов.
Со всеми возможностями f-строк вы можете ознакомиться в PEP498.
Производительность
F-строки не только гибкие, но и быстрые. И для сравнения производительности разных подходов к форматированию я подготовил два шаблона:
- простой, в который нужно вставить всего два значения: строку и число;
- сложный, данные для которого собираются из разных переменных, а внутри происходит преобразование даты, вещественного числа, а также округление.
Финальная простая строка получается такой:
Привет, меня зовут Дмитрий. Мне 27 лет.
Сложная строка на выходе такая:
Сегодня 24.02.2017.
Мы живём на планете Земля. Её радиус 6378 км., а масса 5.973e+24
Период обращения планеты вокруг Солнца 365 дней.
Далее я написал 5 функций, каждая из которых возвращает строку отформатированную одним из способом, а после запустил каждую функцию много раз. Пример всех функций и тестового скрипта можете скачать тут.
После недолгого тестирования я получил следующие результаты:
На простых примерах f-строки показывают наилучшие результаты.
На 25% быстрее %-форматирования и метода format().
На сложных шаблонах f-строки ведут себя так же как %-форматирование
(разница в пользу %-форматирования не превышает величину погрешности).
А вот относительно метода format() f-строки быстрее на 27%.
Заключение
Если вы используете Python 3.6 и старше, то самое время использовать f-строки — они гибкие и быстрые.
Форматирование в Python с помощью f-строк
В этом руководстве вы узнаете и увидите на примерах, какие преимущества для форматирования дает использование f-строк в Python.
Вступление
Что такое форматирование строк?
Форматирование строк — это оформление строк с помощью методов форматирования, предложенных конкретным языком программирования. В Python таких несколько, но речь пойдет только об одном: f-строках.
f-строки исполняются при исполнении самой программы. Это работает быстрее других методов.
У f-строк более простой синтаксис в сравнении с другими техниками форматирования Python. Эта особенность будет рассмотрена на примерах.
Синтаксис
Каждая инструкция f-строки состоит из двух частей: символа f (или F ) и строки, которую нужно форматировать. Строка должна быть в одинарных, двойных или тройных кавычках.
# мы также можем использовать F, '', ''''', """""" f"string" На месте string нужно написать предложение, которое требуется отформатировать.
Отображение переменных
Раньше для форматирования использовался метод str.format() . Новый подход делает все вдвое быстрее.
Переменные в фигурных <> скобках отображаются в выводе как обычно в print . Стоит посмотреть на примере.
# объявление переменных name = "Pythonru" type_of_site = "Блог" # заключите переменную в <>, чтобы отобразить ее значение в выводе print(f" это .") Pythonru это Блог. Все значения переменных отобразились в выводе. С этим все понятно. Вместо f можно написать F .
# объявление переменных name = "Pythonru" type_of_site = "Блог" # заключите переменную в <>, чтобы отобразить ее значение в выводе print(F" это ?") Pythonru это Блог? Выражения
Что, если можно было бы выполнять арифметические выражения или вызовы функций в строке? Это удобно. И f-строки позволяют делать это.
Просто вставьте выражение в <> для исполнения. Оно выполнится при запуске программы. Экономит время и код.
Вот примеры отдельных выражений.
# объявление переменных print(f"") # вывод: 4 Также в <> можно вызвать функцию. Определим функцию greet() и вызовем ее в f-строке.
def greet(name): return "Привет, " + name # вызов функции с использованием f-строки name = "Олег" print(f"") Привет, Олег Также можно вызвать определенные заранее методы.
# метод title, делает первую букву каждого слова заглавной string = "pythonru это блог." print(f"") Pythonru Это Блог. Что еще умеет f-строка? Отображать объект? Да. Работает это так же, как и при выводе переменных.
class Sample: def __init__(self, name, age): self.name = name self.age = age # этот метод будет вызываться при выводе объекта def __str__(self): return f'Имя: . Возвраст: .' user= Sample("Игорь", 19) # это вызовет метод __str__() print(f"") Имя: Игорь. Возвраст: 19. Специальные символы
Что делать, если нужно отобразить специальные символы, такие как <> , \’ , \» ? Они ведь используются в Python для определенных целей. Можно ли использовать экранирование внутри f-строки? Вот ответы на все вопросы.
Кавычки
Можно использовать любые кавычки (одинарные, двойные или тройные) в f-строке. Для их вывода потребуется использовать экранирование. Выражение f-строки не позволяет использовать обратную косую черту. Ее нужно размещать вне <> .
Рассмотрим на примерах.
name = "Pythonru" # отображение одинарных кавычек print(f"Привет, \'\'") print() # отображение двойных кавычек print(f"Привет, \"\"") Привет, 'Pythonru' Привет, "Pythonru" Другие кавычки в f-строках.
f'' # 'Привет, Pythonru' f"" # 'Привет, Pythonru' f"""Привет, Pythonru""" # 'Привет, Pythonru' f'''Привет, Pythonru''' # 'Привет, Pythonru' <> также можно включать в тройные кавычки.
В f-строках нельзя использовать обратную косую черту в <> . Если попробовать, то будет ошибка.
print(f"") # SyntaxError Скобки
Двойные скобки нужны, чтобы вывести одни фигурные скобки в f-строке.
print(f">") Если нужно вывести две пары скобок, то в выражении потребуется указать по четыре.
print(f">>>") Словари
Нужно быть осторожным, работая с ключами словаря в f-строке. Необходимо использовать другие кавычки по отношению к ключам. Они не должны быть теми же, которыми окружена f-строка.
person = "name": "Игорь", "age": 19> print(f", лет.") Игорь, 19 лет. Со словарями так нельзя.
person = "name": "Игорь", "age": 19> print(f'name']>, age']> лет.') File "", line 2 print(f', лет.') ^ SyntaxError: invalid syntax Форматированные строки. F-строки в Python
«F-строки» обеспечивают краткий, читаемый способ включения значения выражений Python внутри строк. В исходном коде Python форматированная строка или по другому f-string — это буквальная строка с префиксом ‘f’ или ‘F’ , которая содержит выражения внутри фигурных скобок <> . Выражения заменяются их значениями.
[Escape-последовательности][escape-sequence] декодируются как в обычных строковых литералах, за исключением случаев, когда литерал также помечается как необработанная строка r’string’ .
Выражения в форматированных строках рассматриваются как обычные выражения Python, окруженные круглыми скобками.
Ограничения, дополнения и изменения синтаксиса f-string:
- Пустое выражение недопустимо.
- Как лямбда-выражения, так и выражения присваивания := должны быть заключены в явные круглые скобки.
- Каждое выражение вычисляется в контексте, где отображается форматированный строковый литерал, в порядке слева направо.
- До версии Python 3.12кавычки в выражениях f-string не должны были конфликтовать с кавычками, используемыми во внешнем форматированном строковом литерале. В Python 3.12 это ограничение снято.
- До версии Python 3.12 выражения (в фигурных скобках) могли содержать переносы только в строках с тройными кавычками, но не могли содержать комментарии. В Python 3.12 ограничение на использование переносов строк и комментариев было снято. В Python 3.12, все, что идет после # внутри поля замены, является комментарием (. даже закрывающие скобки и кавычки). В этом случае поля замены необходимо закрыть в другой строке.
>>> a = 2 >>> f'abca # This is a comment >' . + 3>' # 'abc5'
А еще в Python 3.12 стало возможным делать такие вещи:
>>> f"This is the playlist: ", ".join([ . 'Take me back to Eden', # My, my, those eyes like fire . 'Alkaline', # Not acid nor alkaline . 'Ascensionism' # Take to the broken skies at last . ])>" 'This is the playlist: Take me back to Eden, Alkaline, Ascensionism'
a = ["a", "b", "c"] print(f"List a contains:\n"\n".join(a)>") # List a contains: # a # b # c
>>> a = 1 >>> f'a + 1 = >' # 'a + 1 = 2'
В качестве положительного побочного эффекта от того, как была реализована новая функциональность в Python 3.12 (путем анализа f-строк с помощью синтаксического анализатора PEG), сообщения об ошибках стали включать её точное местоположение. Например, до версии Python 3.12 следующая f-строка вызывает SyntaxError :
>>> my_string = f"x z y>" + f"1 + 1>" # File "", line 1 # (x z y) # ^^^ # SyntaxError: f-string: invalid syntax. Perhaps you forgot a comma?
Сообщение об ошибке не содержит точного местоположения внутри строки, а также содержит выражение, искусственно заключенное в круглые скобки. В Python 3.12 сообщения об ошибках стали более точными и могут отображать всю строку:
>>> my_string = f"x z y>" + f"1 + 1>" # File "", line 1 # my_string = f"" + f"" # ^^^ # SyntaxError: invalid syntax. Perhaps you forgot a comma?
Содержание:
- Простое форматирование вывода f-строкой;
- Вложение f-строк друг в друга;
- Использование кавычек в f-строках;
- Обратная косая черта и символы юникода в f-строках;
- Фигурные скобки и f-строки;
- Многострочные f-строки;
- Спецификатор ‘=’ в f-строках;
- Использование однострочного if / else в f-строке;
- Использование спецификатора формата даты;
- Cтроки документации и f-строки;
- Поддержка спецификации формата Mini-Language:
- Отступы/выравнивание в f-строках;
- Форматирование числа с помощью запятых в качестве десятичного разделителя;
- Форматирование числа в экспоненциальном представлении;
- Использование спецификатора целочисленного формата.
Простое форматирование вывода f-строкой.
>>> name = 'Fred' >>> f'He said his name is name!r>.' # 'He said his name is 'Fred'.' # repr() является эквивалентом '!r' >>> f'He said his name is repr(name)>.' # He said his name is 'Fred'.
Вложение f-строк друг в друга.
>>> import decimal >>> width = 10 >>> precision = 4 >>> value = decimal.Decimal("12.34567") >>> f'result: value:width>.precision>>' 'result: 12.35'
Использование кавычек в f-строках.
До версии Python 3.12 кавычки в полях замены/выражениях f-string не должны конфликтовать с кавычками, используемыми во внешнем форматированном строковом литерале:
>>> a = 'x': 120> >>> f'abc a['x']> def' # File "", line 1 # f'abc def' # ^ # SyntaxError: invalid syntax # Нужно было использовать различные кавычки f"abc a['x']> def" # 'abc 120 def'
В версии Python 3.12 и выше теперь можно делать такие вещи:
>>> songs = ['Take me back to Eden', 'Alkaline', 'Ascensionism'] >>> f"This is the playlist: ", ".join(songs)>" # 'This is the playlist: Take me back to Eden, Alkaline, Ascensionism'
Обратите внимание, что до Python 3.12 не было явного ограничения на вложение f-строк, но тот факт, что строковые кавычки не могли быть повторно использованы внутри компонента выражения f-string, делал невозможным произвольное вложение f-строк. Фактически, это самая вложенная f-строка, которую можно написать:
>>> f"""f'''f'f"1+1>">'>'''>""" '2'
Так как в Python 3.12 и выше f-строки могут содержать любое допустимое выражение Python внутри компонентов выражения, то теперь f-строки можно вкладывать произвольное количество раз:
>>> f"f"f"f"f"f"1+1>">">">">">" # '2'
Обратная косая черта и символы юникода в f-строках.
До версии Python 3.12 выражения f-string не могли содержать ни одного символа \ . Это также повлияло на управляющие последовательности unicode (такие как \N ), поскольку они содержат часть \N , которая ранее не могла быть частью компонентов выражения f-строк.
Пример того, что до версии Python 3.12 обратные косые черты не допускались внутри компонента выражения f-строк и вызывали ошибку:
>>> f'newline: ord("\n")>' # File "", line 1 # SyntaxError: f-string expression part cannot include a backslash
Чтобы включить значение, в котором используется обратная косая черта, нужно было создать временную переменную.
>>> newline = ord('\n') >>> f'newline: newline>' # 'newline: 10'
В версии Python 3.12 и выше стало возможным определить выражения следующим образом:
>>> songs = ['Take me back to Eden', 'Alkaline', 'Ascensionism'] >>> print(f"This is the playlist: "\n".join(songs)>") # This is the playlist: Take me back to Eden # Alkaline # Ascensionism >>> print(f"This is the playlist: "\N ".join(songs)>") # This is the playlist: Take me back to Eden♥Alkaline♥Ascensionism
Фигурные скобки и f-строки.
F-строки используют одинарные фигурные скобки <> для вывода выражений Python. Но как быть, если в итоговой строки необходим вывод самой фигурной скобки? Чтобы в итоговой строке появились фигурные скобки, необходимо использовать двойные скобки, при этом выражение Python вычисляться не будет:
>>> num = 53 >>> f"num>>" #
Обратите внимание, что если нужно вычислить выражение Python и при этом вывести скобки, то нужно использовать тройные скобки:
>>> num = 53 >>> f"num>>>" #
Другими словами для итогового вывода одной скобки в f-строке, необходимо использовать две скобки + одна, если нужно вычислить выражение. Для вывода 2-х скобок, в f-строке используйте 4 + 1 для вычисления выражения Python, и так далее (в общем четное количество + одна, если нужно вычислить выражение ):
>>> num = 53 >>> f"num>>>>>" # >
Многострочные выражения в f-строках.
До Python 3.12 сами выражения f-string (в фигурных скобках) должны были быть определены только в одной строке при использовании одинарных кавычек или могли содержать переносы строк только в строках с тройными кавычками, что было не совсем удобно.
>>> f"""This is the playlist: ", ".join([ . 'Take me back to Eden', . 'Alkaline', . 'Ascensionism' . ])>""" # 'This is the playlist: Take me back to Eden, Alkaline, Ascensionism'
В Python 3.12 это ограничение снято и теперь можно определять f-строки, выражения которых охватывают несколько строк, при этом разрешено повторное использование одинаковых кавычек во внешнем обрамлении f-строки и внутри выражения:
>>> f"This is the playlist: ", ".join([ . 'Take me back to Eden', . 'Alkaline', . 'Ascensionism' . ])>" # 'This is the playlist: Take me back to Eden, Alkaline, Ascensionism'
Спецификатор ‘=’ в f-строках:
Для документирования выражений и отладки в Python 3.8 к f-строкам добавлен спецификатор ‘=’ . F-строка, такая как f» , расширится до текста выражения и знака равенства, а затем представления вычисляемого выражения. Например:
>>> import datetime >>> user = 'eric_idle' >>> member_since = datetime.date(1975, 7, 31) >>> f'user=> member_since=>' # "user='eric_idle' member_since=datetime.date(1975, 7, 31)"
Обычные спецификаторы формата f-string позволяют более точно контролировать способ отображения результата выражения:
>>> import datetime >>> delta = datetime.date.today() - member_since >>> f'user=!s> delta.days=:,d>' # 'user=eric_idle delta.days=16,075'
Спецификатор = будет отображать все выражение, чтобы можно было показать вычисления:
>>> from math import cos, radians >>> theta = 30 >>> print(f'theta=> cos(radians(theta))=:.3f>') theta=30 cos(radians(theta))=0.866
Использование однострочного if / else в f-строке.
>>> a = 10 >>> b = 5 >>> f"a if a > b else b>" # `10` >>> f"a if a b else b>" # `5`
Использование спецификатора формата даты.
>>> import datetime >>> today = datetime.datetime(year=2021, month=1, day=27) >>> f'today:%B %d, %Y>' 'January 27, 2021' >>> now = datetime.datetime.now() >>> ten_days_ago = now - datetime.timedelta(days=10) >>> f'ten_days_ago:%Y-%m-%d %H:%M:%S>' # '2020-10-13 20:24:17' >>> f'now:%Y-%m-%d %H:%M:%S>' # '2020-10-23 20:24:17'
Cтроки документации и f-строки.
Форматированные строковые литералы нельзя использовать в качестве строк документации, даже если они не содержат выражений.
>>> def foo(): . f'Not a docstring' . >>> foo.__doc__ is None True
F-строки не могут использоваться как шаблоны строк str.format() .
>>> tmp = "R: \nG: \nB: " >>> rgb = 'r': 123, 'g': 145, 'b': 255> >>> print(tmp.format(**rgb)) # R: 123 # G: 145 # B: 255 >>> tmp = "Шаблон строки: <>" >>> line = "Привет" >>> tmp.format(line) # 'Шаблон строки: Привет'
Поддержка спецификации формата Mini-Language.
>>> b = 2999 >>> pi = 3.1415926 >>> f'Pi=pi:.3f>, b=b:*^11.2f>' # 'Pi=3.142, b=**2999.00**' >>> print("\n".join(f'a:a>a>>' for a in range(1, 6))) # 1 # 22 # 333 # 4444 # 55555 # форматирование процентов >>> perc = 34 / 87 >>> perc # 0.39080459770114945 >>> f"Процентное отношение: perc:%>" # 'Процентное отношение: 39.080460%' >>> f"Процентное отношение: perc:.2%>" # 'Процентное отношение: 39.08%'
Отступы/выравнивание в f-строках.
>>> greetings = "hello" # отступы справа и слева >>> f"greetings:>10>" # ' hello' >>> f"greetings:>" # 'hello ' # выравнивание чисел >>> a = "1" >>> b = "21" >>> c = "321" >>> d = "4321" >>> print("\n".join((f"a:>10>", f"b:>10>", f"c:>10>", f"d:>10>"))) # 1 # 21 # 321 # 4321 # выравнивание посередине >>> hello = "world" >>> f"hello:^11>" # ' world ' >>> f"hello:*^11>" # '***world***'
Форматирование числа с помощью запятых в качестве десятичного разделителя.
>>> big_num = 1234567890 >>> f"big_num:,>" # '1,234,567,890' >>> num = 2343552.6516251625 >>> f"num:,.3f>" # '2,343,552.652'
Форматирование числа в экспоненциальном представлении.
>>> num = 2343552.6516251625 >>> f"num:e>" # '2.343553e+06' >>> f"num:E>" # '2.343553E+06' >>> f"num:.2e>" # '2.34e+06' >>> f"num:.4E>" # '2.3436E+06'
Использование спецификатора целочисленного формата.
>>> number = 1024 >>> f"number:#0x>" '0x400'
- ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
- Метод str.capitalize(), первая буква в строке заглавная
- Метод str.casefold(), сворачивает регистр строки
- Метод str.center(), выравнивает строку по центру
- Метод str.count(), считает совпадения в строке
- Метод str.encode(), преобразует строку в байты
- Метод str.endswith(), совпадение с концом строки
- Метод str.expandtabs(), меняет табуляцию на пробел
- Метод str.find(), индекс первого совпадения в строке
- Метод str.format(), форматирует строку
- Метод str.format_map()
- Метод str.index(), индекс первого совпадения подстроки
- Метод str.isalnum(), строка состоит из цифр и букв
- Метод str.isalpha(), строка состоит только из букв
- Метод str.isascii(), все символы в строке являются ASCII
- Метод str.isdecimal(), проверяет строку на десятичное число
- Метод str.isdigit(), строка состоит только из цифр
- Метод str.isidentifier() проверяет строку на идентификатор Python
- Метод str.islower( ), проверяет строку на нижний регистр
- Метод str.isnumeric(), проверяет строку на числовые символы
- Метод str.isprintable(), проверяет на доступность для печати
- Метод str.isspace(), является ли строка пробелом
- Метод str.istitle(), проверяет наличие заглавных букв в словах
- Метод str.isupper(), проверяет строку на верхний регистр
- Метод str.join(), объединяет список строк
- Метод str.ljust(), ровняет строку по левому краю
- Метод str.lower(), строку в нижний регистр
- Метод str.lstrip(), обрезает символы в начале строки
- Метод str.maketrans(), таблица символов для str.translate()
- Метод str.partition(), делит строку по первому совпадению
- Метод str.removeprefix(), удаляет префикс строки
- Метод str.removesuffix(), удаляет суффикс строки
- Метод str.replace(), меняет подстроку/символ в строке
- Метод str.rfind(), индекс последнего совпадения подстроки
- Метод str.rindex(), индекс последнего совпадения в строке
- Метод str.rjust(), ровняет строку по правому краю
- Метод str.rpartition(), делит строку по последнему совпадению
- Метод str.rsplit(), делит строку справа
- Метод str.rstrip(), обрезает символы на конце строки
- Метод str.split(), делит строку по подстроке
- Метод str.splitlines(), делит текст по символу ‘\n’
- Метод str.startswith(), совпадение с началом строки
- Метод str.strip(), обрежет строку с обоих концов
- Метод str.swapcase(), сменит регистр символов в строке
- Метод str.title(), каждое слово с заглавной буквы
- Метод str.translate(), транслирование строки
- Метод str.upper(), переведет строку в верхний регистр
- Метод str.zfill(), дополнит строку нулями
- Форматирование строк в стиле printf
- F-string. Форматированные строки
F-строки в Python
В языке программирования Python 3.6, f строки начали появляться для улучшения читаемости кода и продуктивного форматирования. Маркируются литерой «f» перед кавычками. Разберемся с особенностями этого полезного инструмента, без которого сложно представить работу Python-программиста.
Даниил Фам
Исполнительный директор
31 июля 2023
Синтаксис и скорость
Синтаксис прямой и понятный. Перед открывающимися двойными или одинарными кавычками добавляется буква F, что делает строчку автоматически форматированной. Это продуктивно использовать для повышения читабельности и наглядности кода.
[code_lib_fix]
>>> "стандартная строка" >>> f"f-строка"F-строка может быть отформатирована почти так же, как методом str.format, при этом облегчается интерполяция литеральной строки. Это продуктивный способ встраивания выражения Python в строковые литералы для форматирования. При этом за такое преимущество не потребуется жертвовать производительностью. Скорость не падает. Согласно сведениям, полученным с использованием модуля timeit, следует, что на фоне других способов f-строки оказались наиболее производительным инструментом.
Форматирование
Форматирование — оформление кода методами, предложенными языком программирования.
- Процентное форматирование. Поддерживает вариант несложной корректировки, но при этом ограничен числами двойной точности
- Шаблонные строки. Работают с аргументами слов-запросов (ключей)
- String format. Функция внедрена для устранения проблемы форматирования
F-строки работают по аналогичному принципу, что и format, но удаляют многослойность этой функции.
Мини-язык спецификаций
Дополнительное преимущество — поддержка мини-языка спецификаций Python. Эта особенность открывает возможность внедрить в модификаторы новые корректирующие операции.
Мини-язык — универсальный инструмент, который помимо конструкций для работы с датами, числами, помогает обрабатывать текст.
Такие возможности доступны в других способах форматирования, но применение f-строк ускоряет этот процесс.
Работа с числами, датой, временем
При необходимости округлить число с плавающей точкой до N десятичных дробей рекомендуется использовать precision c f-типом. Для округления числа применяют знак %. Для разделения тысяч задействуется запятая (,).
[code_lib_fix]
import datetime today = datetime.datetime.today() print(f"") # 2023-10-05 print(f"") # 2023С помощью инструмента можно легко форматировать календарные числовые показатели. Дата и время задаются по тем же принципам, что и в datetime.strftime. Примечательно, что тут заложено больше способов работы со значениями, чем указано в инструкции к языку программирования. Возможно, создатели Python пошли на такой шаг, понимая, что эти показатели зависят также от используемой платформы. Однако это не значит, что такими вариантами нельзя пользоваться. Не стоит забывать о %x, %X, которые также представляют собой способы установки времени и даты.
Отладка
Начиная с Python 3.8, функционал расширился за счет новых вариаций ввода переменных вместе со значениями. Такую функцию программисты называют «отладкой». Применение нового инструмента упростило процесс. Вместо того чтобы записывать имя и значение, программисты могут прописать это только внутри самого кода:
. Стоит отметить, что процесс стал более ясным, несмотря на необходимость обертывать переменные специфическим синтаксисом. Перепутать порядок вводимых переменных теперь невозможно. Также сохраняются пробелы, полезность которых можно легко оценить при работе с запутанными логами в терминале. [code_lib_fix]
x = 23 y = 12 print(f"x = , y = ") # x = 23, y = 12 print(f", ") # Лучше! (3.8+) # x = 23, y = 12 print(f"") # x = 23.000Кроме продуктивности при отладке, гибкость f-строк оказалась крайне полезна при форматировании. Читать, писать, поддерживать ввод стало гораздо проще в сравнении с конкатенацией.
Выравнивание
Необходимость выравнивания слева направо встречается нечасто. Однако именно этот процесс помогает понять, как включать нули слева (справа) от числа, что крайне полезно при корректировке числовых значений цифр. Для выравнивания по правому краю используют синтаксис, выбирая только элемент width. Если потребовалось сделать, предположим, шесть пробелов, то нужно добавить тот же элемент со значением «8». При выравнивании слева используется ( _ ) в качестве символа-заполнителя. Для закрепления width со значением «8» добавляется «6» и используемый код.
Вложенные строки
Применяется, когда стандартного набора инструментов для форматирования не хватает. Например, можно легко добавить знак $ к цифре с плавающей точкой.
[code_lib_fix]
number = 345.858 formatted_number = f"$" print(f"10s>") # ' $345.858'Итог
С появлением Python 3.6 f-строки стали универсальным способом форматирования. Часто программисты недооценивают инструмент, поскольку не видят скрытый потенциал. При том, что львиная доля этих «неизвестных» возможностей раскрыта в инструкции по Python. F-строки просты в применении и чрезвычайно продуктивны. Поэтому игнорировать такой ценный инструмент не стоит.