Python f строки for

Форматирование строк с помощью f-строк#

В Python 3.6 добавился новый вариант форматирования строк — f-строки или интерполяция строк. F-строки позволяют не только подставлять какие-то значения в шаблон, но и позволяют выполнять вызовы функций, методов и т.п.

Во многих ситуациях f-строки удобней и проще использовать, чем format, кроме того, f-строки работают быстрее, чем format и другие методы форматирования строк.

Синтаксис#

F-строки — это литерал строки с буквой f перед ним. Внутри f-строки в паре фигурных скобок указываются имена переменных, которые надо подставить:

In [1]: ip = '10.1.1.1' In [2]: mask = 24 In [3]: f"IP: ip>, mask: mask>" Out[3]: 'IP: 10.1.1.1, mask: 24' 

Аналогичный результат с format можно получить так: «IP: , mask: «.format(ip=ip, mask=mask) .

Очень важное отличие f-строк от format: f-строки это выражение, которое выполняется, а не просто строка. То есть, в случае с ipython, как только мы написали выражение и нажали Enter, оно выполнилось и вместо выражений и подставились значения переменных.

Поэтому, например, нельзя сначала написать шаблон, а затем определить переменные, которые используются в шаблоне:

In [1]: f"IP: ip>, mask: mask>" --------------------------------------------------------------------------- NameError Traceback (most recent call last) ipython-input-1-e6f8e01ac9c4> in module>() ----> 1 f"IP: ip>, mask: mask>" NameError: name 'ip' is not defined 

Кроме подстановки значений переменных, в фигурных скобках можно писать выражения:

In [1]: octets = ['10', '1', '1', '1'] In [2]: mask = 24 In [3]: f"IP: '.'.join(octets)>, mask: mask>" Out[3]: 'IP: 10.1.1.1, mask: 24' 

После двоеточия в f-строках можно указывать те же значения, что и при использовании format:

In [9]: oct1, oct2, oct3, oct4 = [10, 1, 1, 1] In [10]: print(f''' . IP address: . oct1:> oct2:> oct3:> oct4:> . oct1:08b> oct2:08b> oct3:08b> oct4:08b>''') IP address: 10 1 1 1 00001010 00000001 00000001 00000001 

Особенности использования f-строк#

При использовании f-строк нельзя сначала создать шаблон, а затем его использовать, как при использовании format.

F-строка сразу выполняется и в нее подставляются значения переменных, которые должны быть определены ранее:

In [7]: ip = '10.1.1.1' In [8]: mask = 24 In [9]: print(f"IP: ip>, mask: mask>") IP: 10.1.1.1, mask: 24 

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

In [11]: ip = '10.2.2.2' In [12]: mask = 24 In [13]: print(f"IP: ip>, mask: mask>") IP: 10.2.2.2, mask: 24 

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

In [1]: ip_list = ['10.1.1.1/24', '10.2.2.2/24', '10.3.3.3/24'] In [2]: for ip_address in ip_list: . : ip, mask = ip_address.split('/') . : print(f"IP: ip>, mask: mask>") . : IP: 10.1.1.1, mask: 24 IP: 10.2.2.2, mask: 24 IP: 10.3.3.3, mask: 24 

Примеры использования f-строк#

Базовая подстановка переменных:

In [1]: intf_type = 'Gi' In [2]: intf_name = '0/3' In [3]: f'interface intf_type>/intf_name>' Out[3]: 'interface Gi0/3' 

In [6]: topology = [['sw1', 'Gi0/1', 'r1', 'Gi0/2'], . : ['sw1', 'Gi0/2', 'r2', 'Gi0/1'], . : ['sw1', 'Gi0/3', 'r3', 'Gi0/0'], . : ['sw1', 'Gi0/5', 'sw4', 'Gi0/2']] . : In [7]: for connection in topology: . : l_device, l_port, r_device, r_port = connection . : print(f'l_device:10> l_port:7> r_device:10> r_port:7>') . : sw1 Gi0/1 r1 Gi0/2 sw1 Gi0/2 r2 Gi0/1 sw1 Gi0/3 r3 Gi0/0 sw1 Gi0/5 sw4 Gi0/2 

Ширина столбцов может быть указана через переменную:

In [6]: topology = [['sw1', 'Gi0/1', 'r1', 'Gi0/2'], . : ['sw1', 'Gi0/2', 'r2', 'Gi0/1'], . : ['sw1', 'Gi0/3', 'r3', 'Gi0/0'], . : ['sw1', 'Gi0/5', 'sw4', 'Gi0/2']] . : In [7]: width = 10 In [8]: for connection in topology: . : l_device, l_port, r_device, r_port = connection . : print(f'l_device:width>> l_port:width>> r_device:width>> r_port:width>>') . : sw1 Gi0/1 r1 Gi0/2 sw1 Gi0/2 r2 Gi0/1 sw1 Gi0/3 r3 Gi0/0 sw1 Gi0/5 sw4 Gi0/2 

In [1]: session_stats = 'done': 10, 'todo': 5> In [2]: if session_stats['todo']: . : print(f"Pomodoros done: session_stats['done']>, TODO: session_stats['todo']>") . : else: . : print(f"Good job! All session_stats['done']> pomodoros done!") . : Pomodoros done: 10, TODO: 5 

Вызов функции len внутри f-строки:

In [2]: topology = [['sw1', 'Gi0/1', 'r1', 'Gi0/2'], . : ['sw1', 'Gi0/2', 'r2', 'Gi0/1'], . : ['sw1', 'Gi0/3', 'r3', 'Gi0/0'], . : ['sw1', 'Gi0/5', 'sw4', 'Gi0/2']] . : In [3]: print(f'Количество подключений в топологии: len(topology)>') Количество подключений в топологии: 4 

Вызов метода upper внутри f-строки:

In [1]: name = 'python' In [2]: print(f'Zen of name.upper()>') Zen of PYTHON 

Конвертация чисел в двоичный формат:

In [7]: ip = '10.1.1.1' In [8]: oct1, oct2, oct3, oct4 = ip.split('.') In [9]: print(f'int(oct1):08b> int(oct2):08b> int(oct3):08b> int(oct4):08b>') 00001010 00000001 00000001 00000001 

Что использовать format или f-строки#

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

In [6]: ip = [10, 1, 1, 1] In [7]: oct1, oct2, oct3, oct4 = ip . : print(f'oct1:08b> oct2:08b> oct3:08b> oct4:08b>') . : 00001010 00000001 00000001 00000001 In [8]: template = "  "*4 In [9]: template.format(oct1, oct2, oct3, oct4) Out[9]: '00001010 00000001 00000001 00000001 ' 

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

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

In [1]: def show_me_ip(ip, mask): . : return f"IP: ip>, mask: mask>" . : In [2]: show_me_ip('10.1.1.1', 24) Out[2]: 'IP: 10.1.1.1, mask: 24' In [3]: show_me_ip('192.16.10.192', 28) Out[3]: 'IP: 192.16.10.192, mask: 28' 

Источник

F-Строки: Новый улучшенный способ форматирования строк в Python

У нас для вас хорошие новости: f-строки вступают в дело, чтобы помочь с форматированием. Также известные как «форматированные строковые литералы», f-strings являются строковыми литералами с «f» в начале и фигурные скобки, содержащие выражения, которые в дальнейшем будут заменены своими значениями. Выражения оцениваются по мере выполнения и затем форматируются при помощи протокола __format__ . Как всегда, документация Python может помочь, если хотите узнать больше.

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!

Рассмотрим подробнее, как именно f-strings могут упростить вам жизнь.

Простой синтаксис

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

Вы также можете использовать заглавную букву F:

Вам уже нравится? Надеемся, что да, в любом случае, вы будете в восторге к концу статьи.

Произвольные выражения

Так как f-строки оцениваются по мере выражения, вы можете внести любую или все доступные выражения Python в них. Это позволит вам делать интересные вещи, например следующее:

Также вы можете вызывать функции. Пример:

Также вы можете вызывать метод напрямую:

Вы даже можете использовать объекты, созданные из классов при помощи f-строки. Представим, что у вас есть следующий класс:

Вы могли бы сделать следующее:

Методы __str__() и __repr__() работают с тем, как объекты отображаются в качестве строк, так что вам нужно убедиться в том, что вы используете один из этих методов в вашем определении класса. Если вы хотите выбрать один, попробуйте __repr__(), так как его можно использовать вместо __str__().

Строка, которая возвращается __str__() является неформальным строковым представлением объекта и должна быть читаемой. Строка, которую вернул __str__() — это официальное выражение и должно быть однозначным. При вызове str() и repr(), предпочтительнее использовать __str__() и __repr__() напрямую.

По умолчанию, f-строки будут использовать __str__(), но вы должны убедиться в том, что они используют __repr__(), если вы включаете флаг преобразования !r:

Если вы хотите прочитать часть обсуждения, в результате которого f-strings поддерживают полные выражения Python, вы можете сделать это здесь.

Многострочные F-Strings

У вас могут быть многострочные f-strings:

Однако помните о том, что вам нужно разместить f вначале каждой строки. Следующий код не будет работать:

# Вывод: ‘Hi Eric. You are a . You were in .’

Если вы не внесете f в начале каждой индивидуальной строки, то получите обычную, старую версию строк, без приятных новшеств.

Если вы хотите размножить строки по нескольким линиям, у вас также есть возможность избежать возвратов при помощи \:

Но вот что произойдет, если вы используете «»»:

Инструкция по отступам доступна в PEP 8.

Скорость

Буква f в f-strings может также означать и “fast”. Наши f-строки заметно быстрее чем % и str.format() форматирования. Как мы уже видели, f-строки являются выражениями, которые оцениваются по мере выполнения, а не постоянные значения. Вот выдержка из документации:

“F-Строки предоставляют способ встраивания выражений внутри строковых литералов с минимальным синтаксисом. Стоит обратить внимание на то, что f-строка является выражением, которое оценивается по мере выполнения, а не постоянным значением. В исходном коде Python f-строки является литеральной строкой с префиксом f, которая содержит выражения внутри скобок. Выражения заменяются их значением.”

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

Рассмотрим сравнение скорости:

Источник

f-Строки Python

Основы

Не смотря на один из принципов Python, гласящий: «Должен существовать один — и, желательно, только один – очевидный способ сделать что-то», в нашем любимом языке есть аж четыре способа отформатировать строку. Так сложилось исторически.
Это второй урок цикла, посвящённого форматированию строк. В него входят:

В данном уроке мы познакомимся с f-Строками.
В Python 3.6 появился новый способ форматирования строки – интерполяция строк (чаще называют «форматированные строковые литералы» или «f-Строки»).
f-Строки предоставляют возможность использовать выражения Питона внутри строк. Происходит это следующим образом: каждое выражение вычисляется, затем все части f-Строки отдельно преобразуется в обычные строки, затем все части конкатенируются (склеиваются в одну). Форматированные строковые литералы так же, как и описанный в предыдущем уроке метод строки .format(), поддерживают форматирование, описанное в атрибуте __format__ . Узнать f-Строки Вы можете по символу «f» в начале строки перед открывающей кавычкой.

Простой синтаксис

Для того, чтобы использовать форматированные строковые литералы, просто поставьте символ «f» перед строкой и укажите в ней в фигурных скобках выражения Питона. В простейшем случае это имена переменных. Python, как всегда, радует своей лаконичностью! Пример:

язык = 'Python' проценты = 100 print(f'-Самый лучший язык - .\n' f'-Точно?\n' f'-%!') # Вывод: -Самый лучший язык - Python. -Точно? -100%!
 
Как видите, форматированные строковые литералы могут быть многострочными, но символ «f» должен быть в начале каждой строки. 
Если Вы используете заглавную «F» — интерпретатор всё равно Вас поймёт: 
 
Источник
 
Читайте также:  Javascript цвет от значения