Что означает f в питоне
Перейти к содержимому

Что означает f в питоне

  • автор:

Форматированные строки. 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 мощнее, чем можно подумать

    Форматированные строковые литералы, которые ещё называют f-строками (f-strings), появились довольно давно, в Python 3.6. Поэтому все знают о том, что это такое, и о том, как ими пользоваться. Правда, f-строки обладают кое-какими полезными возможностями, некоторыми особенностями, о которых кто-нибудь может и не знать. Разберёмся с некоторыми интересными возможностями f-строк, которые могут оказаться очень кстати в повседневной работе Python-программиста.

    Форматирование даты и времени

    Форматирование чисел средствами f-строк — это обычное дело. А вы знали, что с их помощью можно ещё форматировать значения, представляющие даты и временные метки?

    import datetime today = datetime.datetime.today() print(f"") # 2022-03-11 print(f"") # 2022

    С помощью f-строк можно форматировать дату и время так, как если бы для этого использовался бы метод datetime.strftime . Это особенно приятно, когда понимаешь, что тут имеется больше возможностей форматирования значений, чем те немногие, которые упомянуты в документации. Так, Python-метод strftime поддерживает, кроме прочего, все способы форматирования значений, поддерживаемые его базовой реализацией на C. Эти возможности могут зависеть от платформы, именно поэтому в документации они не упоминаются. Но получается, что этими возможностями по форматированию значений, всё равно, можно воспользоваться. Например, можно применить спецификатор формата %F , являющийся эквивалентом %Y-%m-%d , или спецификатор %T , аналогичный %H:%M:%S . Стоит ещё упомянуть и о спецификаторах формата %x и %X , представляющих собой, соответственно, принятые в используемом языковом стандарте способы представления даты и времени. Использование этих возможностей форматирования значений, конечно, не ограничивается только f-строками. Полный список спецификаторов формата даты и времени можно найти в Linux-справке по strftime.

    Имена переменных и отладка

    Функционал f-строк сравнительно недавно (начиная с Python 3.8) дополнен возможностями по выводу имён переменных вместе с их значениями:

    x = 10 y = 25 print(f"x = , y = ") # x = 10, y = 25 print(f", ") # Лучше! (3.8+) # x = 10, y = 25 print(f"") # x = 10.000

    Эта возможность называется «отладкой» («debugging»), её можно применять вместе с другими модификаторами. Она, кроме того, сохраняет пробелы, поэтому при обработке конструкций вида f»» и f»» получатся разные строки.

    Методы __repr__ и __str__

    Для формирования строковых представлений экземпляров классов по умолчанию используется метод __str__ . Но если вместо этого метода нужно применить метод __repr__ — можно воспользоваться флагом преобразования !r :

    class User: def __init__(self, first_name, last_name): self.first_name = first_name self.last_name = last_name def __str__(self): return f" " def __repr__(self): return f"User's name is: " user = User("John", "Doe") print(f"") # John Doe print(f"") # User's name is: John Doe

    Тут, внутри f-строки, можно было бы просто вызвать repr(some_var) , но использование флага преобразования — это образец приятного стандартного и краткого решения подобной задачи.

    Отличная производительность

    За некие мощные возможности чего-либо и за «синтаксический сахар» часто приходится платить производительностью. Но в случае с f-строками это не так:

    # python -m timeit -s 'x, y = "Hello", "World"' 'f" "' from string import Template x, y = "Hello", "World" print(f" ") # 39.6 nsec per loop - Быстро! print(x + " " + y) # 43.5 nsec per loop print(" ".join((x, y))) # 58.1 nsec per loop print("%s %s" % (x, y)) # 103 nsec per loop print("<> <>".format(x, y)) # 141 nsec per loop print(Template("$x $y").substitute(x=x, y=y)) # 1.24 usec per loop - Медленно!

    Вышеприведённый код протестирован с помощью модуля timeit ( python -m timeit -s ‘x, y = «Hello», «World»’ ‘f» »’ ). Как видите, f-строки оказались самым быстрым из всех механизмов форматирования данных, которые даёт нам Python. Поэтому, даже если вы предпочитаете пользоваться другими средствами форматирования строк, рассмотреть возможность перехода на f-строки стоит хотя бы ради повышения производительности.

    Вся сила мини-языка спецификаций форматирования

    F-строки поддерживают мини-язык спецификаций форматирования Python. Поэтому в модификаторы, используемые в f-строках, можно внедрить множество операций форматирования данных:

    text = "hello world" # Центрирование текста: print(f"") # ' hello world ' number = 1234567890 # Установка разделителя групп разрядов print(f"") # 1,234,567,890 number = 123 # Добавление начальных нулей print(f"") # 00000123

    Мини-язык форматирования Python включает в себя гораздо больше, чем конструкции, рассчитанные на форматирование чисел и дат. Этот язык, кроме прочего, позволяет выравнивать или центрировать текст, добавлять к строкам начальные нули или пробелы, задавать разделители групп разрядов. Всем этим, конечно, можно пользоваться не только в f-строках, но и при применении других способов форматирования данных.

    Вложенные f-строки

    Если чьи-то нужды по форматированию данных не удаётся удовлетворить с помощью простых f-строк, можно прибегнуть к f-строкам, вложенным друг в друга:

    number = 254.3463 print(f"':>10s>") # ' $254.346'

    Одни f-строки можно встраивать в другие f-строки, поступая так ради решения хитрых задач форматирования данных. Например — чтобы, как показано выше, добавить знак доллара к числу с плавающей точкой, выровненному по правому краю.

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

    import decimal width = 8 precision = 3 value = decimal.Decimal("42.12345") print(f"output: .>") # 'output: 42.1'

    Условное форматирование

    Взяв за основу предыдущий пример с вложенными f-строками, можно пойти немного дальше и воспользоваться во внутренних f-строках тернарными условными операторами:

    import decimal value = decimal.Decimal("42.12345") print(f'Result: >') # Result: 42.1 value = decimal.Decimal("142.12345") print(f'Result: >') # Result: 142

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

    Лямбда-выражения

    Тот, кто хочет расширить границы возможностей f-строк, попутно взбесив тех, кто будет читать его код, может, приложив некоторые усилия, воспользоваться лямбда-выражениями:

    print(f"<(lambda x: x**2)(3)>") # 9

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

    Итоги

    Как видите, f-строки — это, и правда, весьма мощный механизм. Они обладают гораздо большими возможностями, чем думает большинство программистов. Основная часть этих «неизвестных» возможностей, правда, описана в документации по Python. Поэтому рекомендую читать документацию, причём — не только по f-строкам, но и по другим используемым вами модулям или возможностям Python. Углубление в документацию часто помогает обнаружить какие-то очень полезные вещи, которые не найти даже зарывшись в Stack Overflow.

    О, а приходите к нам работать? �� ��

    Мы в wunderfund.io занимаемся высокочастотной алготорговлей с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.

    Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.

    Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.

    Форматирование в 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

    Начиная с версии 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 функций, каждая из которых возвращает строку отформатированную одним из способом, а после запустил каждую функцию много раз. Пример всех функций и тестового скрипта можете скачать тут.

    После недолгого тестирования я получил следующие результаты:

    График сравнения производительности различных способов форматирования строк в Python 3

    На простых примерах f-строки показывают наилучшие результаты.
    На 25% быстрее %-форматирования и метода format().

    График сравнения производительности различных способов форматирования строк в Python 3

    На сложных шаблонах f-строки ведут себя так же как %-форматирование
    (разница в пользу %-форматирования не превышает величину погрешности).
    А вот относительно метода format() f-строки быстрее на 27%.

    Заключение

    Если вы используете Python 3.6 и старше, то самое время использовать f-строки — они гибкие и быстрые.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *