Как перенести f строку в python

Перенос f-string по PEP

Решил следить за написанием своего кода и столкнулся с проблемой, как правильно делать перенос строк и выражений в Python.

def get_message(self) -> str: return f'Тип тренировки: ; Длительность: ч.; Дистанция: км; Ср. скорость: км/ч; Потрачено ккал: .' 

 def get_spent_calories(self) -> float: """Получить количество затраченных калорий.""" mean_speed = self.get_mean_speed() return (self.coeff_calorie_1 * mean_speed - self.coeff_calorie_2) * self.weight / self.M_IN_KM * self.duration * self.H_IN_MIN 

Как делать перенос строки (не превышало 79 символов) при этом в консоли вывод должен быть в одну строку. Заранее извиняюсь за столь глупый вопрос)

Отслеживать
задан 21 ноя 2021 в 15:46
41 2 2 серебряных знака 6 6 бронзовых знаков
4 дек 2021 в 9:06

2 ответа 2

Сортировка: Сброс на вариант по умолчанию

Почему бы не обратиться к первоисточнику:

The preferred way of wrapping long lines is by using Python’s implied line continuation inside parentheses, brackets and braces. Long lines can be broken over multiple lines by wrapping expressions in parentheses. These should be used in preference to using a backslash for line continuation.

Предпочтительный способ обертывания длинных строк — использование подразумеваемого продолжения строки Python внутри скобок, скобок и фигурных скобок. Длинные строки можно разбить на несколько строк, заключив выражения в круглые скобки. Их следует использовать вместо использования обратной косой черты для продолжения строки.

def get_message(self) -> str: return (f'Тип тренировки: ; ' f'Длительность: ч.; ' f'Дистанция: км; ' f'Ср. скорость: км/ч; ' f'Потрачено ккал: .') 

PS кроме соответствия стандартам PEP-8, код должен быть легко-читаемым. Поэтому я разбил строки таким образом.

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

  Начиная с версии 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-строки — они гибкие и быстрые.

  F-строки и 3 эффективных способа их применения

  Далеко в прошлом остались те времена, когда разработчики Python еще использовали оператор % для форматирования строк.

  С момента появления Python 3.0 его постепенно заменили вызовом метода .format() для строкового объекта.

  А вот когда наступила эра Python 3.6 и последующих версий, то в обиход вошли f-строки, ставшие новым способом вставки выражения Python внутрь строковых констант. И в настоящее время многие уже освоили это нововведение.

  Для тех, кто еще не знаком с этим способом форматирования, отметим, что работать с f-строками чрезвычайно просто. Достаточно лишь предварить строку префиксом f или F , а затем поставить одинарные, двойные или даже тройные кавычки для оформления строки, например f»Hello, Python!» .

  Наверняка большинство из вас прекрасно осведомлены о механизме форматирования с помощью f-строк, но в этой статье будут представлены малоизвестные способы их применения в Python 3.8+.

  Содержание.

  • F-строки для более эффективной отладки.
  • F-строки для форматирования float до N десятичных знаков, денежных значений, объектов datetime и заполнения целых чисел ведущими нулями или пробелами.
  • F-строки для конверсий (ASCII и repr() ).

  1. F-строки для отладки

  Разработчики часто задействуют инструкции print для отладки кода просто потому, что их так легко добавлять.

  Как правило, мы делаем так:

  viewer = "��"
  owner = "��"
  editor = "��"
  
  print(viewer)
  print(owner)
  print(editor)

  Отличный способ запутаться в переменных и их значениях.

  А вот и вывод в терминале:

  На самом деле с инструкциями print в данном коде все в порядке.

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

  �� 
  �� -- Извините, а какой переменной принадлежит это значение? 
  ��

  Более эффективный способ вывода переменных в процессе отладки

  Для решения этой проблемы воспользуемся print(f’’) :

  print(f"")
  print(f"")
  print(f"")
  
  # Поток Stdout:
  
  # viewer = "��"
  # owner = "��"
  # editor = "��"

  F-строки делают вывод более понятным!

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

  Более того, благодаря такому способу применения f-строк сохраняются пробелы. Их пользу в процессе отладки вы сможете оценить, оказавшись в гуще запутанных логов в терминале.

  print(f"")
  print(f"")
  print(f"")
  
  # Поток Stdout:
  
  # viewer= '��'
  # owner ='��'
  # editor = '��'

  2. Форматирование строк

  Помимо эффективности f-строк в отладке, большего всего полезна их гибкость, позволяющая легко форматировать строки.

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

  И сейчас вы в этом убедитесь на простейшем примере переменных типа float .

  Форматирование float до N десятичных знаков

  Допустим, нужно вывести переменную типа float с двумя десятичными знаками после точки, преобразовав 3.1425123 в 3.14 . Не такой уж и редкий случай, надо сказать.

  Как правило, на ум приходят варианты со встроенным методом round или “устаревшим” str.format . Ниже рассмотрим эти способы ограничения числа с плавающей точкой до двух десятичных знаков:

  # "Устаревшие" способы корректировки числа с плавающей точкой до двух десятичных знаков
  float_variable = 3.141592653589793
  
  print("%.2f" % float_variable)
  print("".format(float_variable))
  
  # Поток Stdout:
  
  # 3.14
  # 3.14

  А теперь для этой цели попробуем задействовать f-строки:

  float_variable = 3.141592653589793
  
  print(f"")
  
  # Поток Stdout:
  # 3.14

  По сравнению с str.format() f-строки все значительно упрощают.

  Преобразование float в “красивый” денежный формат

  Когда дело касается денежных единиц, строкам необходимо придать максимально удобный для пользователя вид. Например, целесообразно представить значение 3142671.76 как $3,142,671.76 .

  В данном случае с помощью f-строк очень удобно оформить значение float в денежном формате. С этой целью нам понадобится ,:2f .

  money = 3_142_671.76 # �� Это тоже самое, что и 3142671.76
  
  print(f"$")
  
  # Поток Stdout:
  # $3,142,671.76

  Вот так без особого труда мы представили переменную типа float в “красивом” денежном формате.

  Представление datetime в “красивом» формате посредством strftime

  F-строки можно использовать не только для форматирования переменных типа float , но и типа datetime .

  Наиболее распространенный способ представить объект datetime в удобном для восприятия формате, например 05-July-2021 , состоит в применении стандартного встроенного метода strftime , а именно datetime_var.strftime(‘%d-%b-%y’) .

  То же самое мы легко сможем сделать, обратившись к f-строкам:

  from datetime import datetime
  
  
  now = datetime.now()
  
  # Стандартный способ 
  formatted_datetime_now = now.strftime('%d-%B-%Y')
  print(formatted_datetime_now)
  
  # Способ с f-строкой 
  formatted_datetime_now = f""
  print(formatted_datetime_now)
  
  # Поток Stdout
  # 05-July-2021

  Заполнение переменных int ведущими нулями или пробелами

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

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

  # Выводим длину в 20 цифр и заполняем остальные позиции нулями. 
  
  int_variable = 1_234_567
  print(f'')
  
  # Поток Stdout
  # 00000000000001234567
  
  
  # Выводим длину в 24 цифры и заполняем остальные позиции нулями 
  int_variable = 30
  print(f'')
  
  # Поток Stdout
  # 000000000000000000000030

  Для заполнения целых чисел ведущими пробелами делаем следующее:

  # Выводим длину в 10 символов и заполняем остальные позиции ведущими пробелами 
  whitesplace
  int_variable = 20_21
  print(f'')
  
  # Stdout
  # ' 2021'
  
  
  # Выводим длину в 5 символов и заполняем остальные позиции пробелами 
  print(f"")
  
  # Поток Stdout
  # ' 2021'

  Конверсия

  В последнем разделе статьи мы кратко рассмотрим несколько примеров с f-строками для конверсии. Если в f-строке присутствует синтаксис восклицательного знака ! , за которым следует переменная, то она проведет дополнительное преобразование этой переменной.

  Преобразование строки в ASCII

  Например, можно легко вывести представление строки в ASCII с помощью f’’ следующим образом:

  owl = '��'
  print(f'')
  
  # Поток Stdout
  # '\U0001f989'

  Перед вами эмоджи в виде ASCII.

  A repr() alternative with f-string

  И наконец, еще один отличный способ использовать синтаксис ! в f-строках — отобразить строку, которая содержит выводимое представление объекта наподобие метода repr() в Python.

  Обратимся к примеру, в котором вместо repr() воспользуемся !r :

  from datetime import datetime
  
  
  now = datetime.now()
  
  # repr()
  print(repr(now))
  
  
  # F-строки 
  print(f'')
  
  # Поток Stdout
  # datetime.datetime(2021, 7, 5, 13, 2, 34, 672383)
  
  repr(now) == f''
  # True

  Заключение

  С началом эры Python 3.6 f-строки стали отличным способом форматирования строк.

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

  Из всех перечисленных способов мне особенно нравится форматирование объекта datetime и любых денежных значений.

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

  • Асинхронная многопоточность в Python
  • Отладка кода на Python с помощью icecream
  • Как писать код на Python лучше: 6 рекомендаций
  Похожие публикации:

  1. Как получить рут права на смарт тв
  2. Как посмотреть скрытые файлы в линукс
  3. Как успехи в изучении
  4. Сервисы которые помогают сконцентрироваться на работе