Как перенести 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
51 1 1 золотой знак 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-string)

  Форматированные строковые литералы — это литералы-строки с префиксом f или F .

   animal = 'кот' 
  age = 7 
  f'У меня есть . Ему .' # У меня есть кот. Ему 8. 
   
  def print_me(one, two): 
  print(f'Вот тебе , а вот тебе .')

  Такие строки могут содержать маркеры для замещения (выражения в фигурных скобах — <> ). В то время как обычные литералы представляют собой константы, значение форматированных строк вычисляются в ходе исполнения программы.

  Попытка использования обратных косых черт (слешей) в форматной строке (например, \n ) приведёт к исключению SyntaxError.

  Маркеры могут включать в себя другие маркеры.

  • Пустые выражения недопустимы;
  • Лямбда-выражения должны быть окружены скобками;
  • Допускаются переносы строк (например, в литералах с тройными кавычками), однако комментарии не поддерживаются;
  • Каждое выражение вычисляется в том же контексте, в котором содержится форматная строка, слева направо.

   animal = 'cat' 
  f"6>" # ' cat'

  После этого маркер в строке заменяется отформатированным результатом вычисления выражения.

  Форматные строки можно склеивать, однако маркеры при этом не должны принадлежать разным литералам.

  Преобразование

  Если затребовано преобразование, оно будет выполнено над результатом вычисления выражения непосредственно перед форматированием.

  !r	Использовать repr().
  !s	Использовать str().
  !a	Использовать ascii().

   animal = 'cat' 
  f'I have a .' # I have a 'cat'. 
  f'I have a .' # I have a 'cat'.
   
  # Вложенные маркеры: 
  width = 10 
  precision = 4 
  value = decimal.Decimal('12.34567') 
  f'result: .>' # result: 12.35

  Упрощение для отладки

  Начиная с +py3.8 можно использовать форму f» , чтобы вывести название переменной и её текущее значение.

   my_var = 'cat' 
  print(f'') # my_var = 'cat' 
  # Имеется возможность дополнения строки до указанной длины: 
  print(f'') # my_var = 'aaCATaa' 
  print(f'7>') # my_var = 'bbbbCAT'

  Как оформить перенос f-строки в Python?

  

  

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

  • Способ №1: с использованием скобок
  • Способ №2: посредством символа переноса — обратного слеша «\»

  Кстати, согласно PEP-8, строки питоновского кода не должны быть длиннее 79 символов!
  *PEP-8 — это официальный документ с рекомендациями по оформлению кода на Python

  Способ №1: Заключаем f-строки в скобки

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

  name = "Число Гэма" symbol = "G63" fact = (f" самое большое. " f"Оно обозначается .") print(fact)

  Число Гэма самое большое. Оно обозначается G63.

  ! Обратите внимание, что каждая подстрока заключена в кавычки и предварена символом ‘f’. То есть речь идет именно о группе f-строк, которые нужно визуально отделить друг от друга с помощью переносов.

  Способ №2: Используем для переноса символ обратного слеша «\»

  Здесь все просто: для переноса текста на новую строку ставим символ обратного слеша «\» и радуемся результату! В данном случае дополнительно заключать подстроки в кавычки и ставить символы «f» не нужно. Этот вариант уместен в случае длинного предложения или текста, который не удобно разбивать на отдельные f-строки:

  name = "Число Гэма" symbol = "G63" fact = f" значительно превосходит число гугол \ и считается самым большим. Оно обозначается как . " print(fact)

  Число Гэма значительно превосходит число гугол и считается самым большим. Оно обозначается как G63.

  Интересный факт: в f-строках перед открывающими кавычками символ «f», то есть строчную букву f можно заменить заглавной F . Таким образом, f-строка F’Текст ‘ также успешно будет выведена на экран, как и строка f’Текст ‘

  Какой из предложенных вариантов выбрать?

  Официальная документация по оформлению кода PEP-8 гласит о том, что вариант с использованием скобок предпочтительнее для переноса строк. С другой строны, как отмечено в PEP-8, вариант с использованием слеша может быть удобнее в ряде случаев. Поэтому, друзья-программисты, будем ориентироваться по-ситуации!

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

  

  У нас появился Telegram-канал для изучающих Python! Присоединяйтесь: вместе «питонить» веселее! �� Ссылка на канал: «Кодим на Python!»

  Похожие публикации:

  1. Sql запросы что это
  2. Как изменить отображение формул в excel
  3. Как откатить обновление сервиса google play
  4. Как подключить код доступа майл ру