Рубрики
Без рубрики

Python F-String: 73 примера, которые помогут вам освоить Это

Python F-стрит впечатляет! Знаете ли вы, что вы можете использовать F-строки для формата строки почти … Tagged With Python, Tuperial, Beginters, 100daysOfCode.

Python F-стрит впечатляет!

Знаете ли вы, что вы можете использовать F-строки для формата строки практически на Python? Вы можете использовать их для форматирования поплавков, многослойных строк, десятичных знаков, объектов и даже использования условий IF-ELSE в них.

В этом посте я покажу вам как минимум 73 примера о том, как форматировать строки, используя F-стрижки Python 3. Вы увидите множество способов воспользоваться этой мощной функцией.

К концу этого руководства вы освоили:

  • Как использовать F String для формата Float Numbers
  • Как форматировать многослойная строка
  • Как определить Десятичные места в F-String
  • Как исправить неверные синтаксические ошибки, такие как “Синтаксиртор: F-String: непревзойденный ‘[‘” или F-String: непревзойденный ‘(‘
  • Как использовать Если еще оператор в F-String
  • Основная строка Форматирование интерполяции Использование F-стенки
  • Как Печать F-стенки
  • Как эффективно добавить прокладка Использование FSTRING

Пойдем!

Оглавление

  1. Что такое F -стринге Python 3 – a.k.a Literal String Interpolation?
  2. Как отформатировать строки в Python 3 – Основы
  3. Ограничения
  4. Как отформатировать выражение
  5. Как использовать F-строки для отладки вашего кода
  6. Как отформатировать многослойные F-строки (дело с новыми линиями и переменными)
  7. Как исправить ошибку неверного синтаксиса F-String
  8. Как исправить «Форматирование обычной строки, которая может быть F-строкой»
  9. Как форматировать числа в разных основаниях
  10. Как печатать форматированные объекты с помощью F-стенков
  11. Как использовать F-строки для форматирования плавания
  12. Как отформатировать число в процентах
  13. Как оправдать или добавить накладку к F-строке
  14. Как избежать персонажей с F-String
  15. Как добавить тысячу разделителей

    15.1. Как отформатировать число с запятыми в качестве десятичного сепаратора

    15.2. Как отформатировать число с пробелами в виде десятичного сепаратора

  16. Как отформатировать число в научных обозначениях (экспоненциальная обозначения)

  17. Использование IF-ELSE Conditudal в F-String

  18. Как использовать F-String с помощью словаря

  19. Как объединить F-строки

  20. Как отформатировать дату с помощью F-String

  21. Как добавить ведущие нули

  22. Вывод

Что такое Python F -стринг – a.k.a буквальная интерполяция строки?

Форматирование строки развивалось довольно много в истории Python. Перед Python 2.6, чтобы отформатировать строку, можно либо использовать % оператор, или нить. Шаблон модуль. Некоторое время спустя str.format Метод появился и добавил к языку более гибкий и надежный способ форматирования строки.

Старый форматирование строки с % :

>>> msg = 'hello world'
>>> 'msg: %s' % msg
'msg: hello world'

Используя string.format :

>>> msg = 'hello world'
>>> 'msg: {}'.format(msg)
'msg: hello world'

Чтобы еще больше упростить форматирование, в 2015 году Эрик Смит предложил PEP 498 – Буквальная строковая интерполяция , новый способ отформатировать строку для Python 3.

PEP 498 представил эту новую строковую интерполяцию простой и простой в использовании альтернативы str.format Анкет Единственное, что требуется, – это положить «f» перед строкой. И если вы новичок в языке, это то, что f В Python означает, что это новый синтаксис для создания форматированных строк.

Использование F-стенки:

>>> msg = 'hello world'
>>> f'msg: {msg}'
'msg: hello world'

И это было все! Не нужно использовать str.format или % . Тем не менее, F-строки не заменяют str.format полностью. В этом руководстве я покажу вам пример, где они не подходят.

Как отформатировать строки в Python 3 – Основы

Как я показал в предыдущем разделе, форматирование строк в Python с использованием F-строков довольно просто. Единственным требованием является обеспечение достоверного выражения. F-стрит также может начинаться с капитала F И вы можете объединиться с необработанными строками, чтобы получить отформатированный выход. Однако вы не можете смешать их с байтами б "" или "u" Анкет

>>> book = "The dog guide"

>>> num_pages = 124

>>> f"The book {book} has {num_pages} pages"
'The book The dog guide has 124 pages'

>>> F"The book {book} has {num_pages} pages"
'The book The dog guide has 124 pages'

>>> print(Fr"The book {book} has {num_pages} pages\n")
The book The dog guide has 124 pages\n

>>> print(FR"The book {book} has {num_pages} pages\n")
The book The dog guide has 124 pages\n

>>> print(f"The book {book} has {num_pages} pages\n")
The book The dog guide has 124 pages

И это в значительной степени! В следующем разделе я покажу вам несколько примеров всего, что вы можете сделать – и не можете сделать – с F -стринками.

Ограничения

Несмотря на то, что F-строки очень удобны, они не заменяют str.format полностью. F-стрит оценивает выражения в контексте, где они появляются. Согласно PEP 498 Это означает, что выражение имеет полный доступ к локальным и глобальным переменным. Это также выражение, оцениваемое во время выполнения. Если выражение, используемое внутри {} Нельзя оценить, интерпретатор поднимет исключение.

>>> f"{name}"
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
 in 
----> 1 f"{name}"

NameError: name 'name' is not defined

Это не проблема для str.format Метод, как вы можете определить строку шаблона, а затем вызовать .format передать контекст.

>>> s = "{name}"

>>> s.format(name="Python")
'Python'

>>> print(s)
{name}

Другое ограничение состоит в том, что вы не можете использовать встроенные комментарии внутри F-String.

>>> f"My name is {name #name}!"
  File "", line 1
    f"My name is {name #name}!"
    ^
SyntaxError: f-string expression part cannot include '#'

Как отформатировать выражение

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

>>> f"4 * 4 is {4 * 4}"
'4 * 4 is 16'

Или если вы предпочитаете …

>>> n = 4

>>> f"4 * 4 is {n * n}"
'4 * 4 is 16'

Как использовать F-строки для отладки вашего кода

Одним из наиболее частых использования F-String является отладка. Перед Python 3.8 многие люди будут делать привет; f "Hello = {Hello}" , но это очень повторяющееся. В результате Python 3.8 принес новую функцию. Вы можете переписать это выражение как f "{hello =}" и Python отобразит Привет = 42 Анкет Следующий пример иллюстрирует это с использованием функции, но принцип одинаков.

>>> def magic_number():
     ...:     return 42
     ...: 

>>> f"{magic_number() = }"
'magic_number() = 42'

Как отформатировать многослойные F-строки (дело с новыми линиями и переменными)

Вы можете использовать символ Newline \ n с F-строками для печати строки в нескольких строках.

>>> multi_line = (f'R: {color["R"]}\nG: {color["G"]}\nB: {color["B"
    ...: ]}\n')

>>> multi_line
'R: 123\nG: 145\nB: 255\n'

>>> print(multi_line)
R: 123
G: 145
B: 255

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

>>> other = f"""R: {color["R"]}
    ...: G: {color["G"]}
    ...: B: {color["B"]}
    ...: """

>>> print(other)
R: 123
G: 145
B: 255

Пример с Вкладка s.

>>> other = f'''
    ...: this is an example
    ...: 
    ...: ^Iof color {color["R"]}
    ...:     
    ...: '''

>>> other
'\nthis is an example\n\n\tof color 123\n    \n'

>>> print(other)

this is an example

    of color 123



>>>

Как исправить ошибку неверного синтаксиса F-String

Если не используется правильно, F-стринам может поднять Синтаксисеррок Анкет Наиболее распространенной причиной является использование двойных цитатов внутри двойной цитируемой F-строки. То же самое также верно для одиночных кавычек.

>>> color = {"R": 123, "G": 145, "B": 255}

>>> f"{color["R"]}"
  File "", line 1
    f"{color["R"]}"
    ^
SyntaxError: f-string: unmatched '['


# using only single quotes
>>> f'{color['R']}'
  File "", line 1
    f'{color['R']}'
    ^
SyntaxError: f-string: unmatched '['

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

>>> print(f"price: {format(round(12.345), ",")}")
  File "", line 1
    print(f"price: {format(round(12.345), ",")}")
                                           ^
SyntaxError: f-string: unmatched '('

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

>>> print(f"price: {format(round(12.345), ',')}")
price: 12

>>> color = {"R": 123, "G": 145, "B": 255}

>>> f"{color['R']}"
'123'

>>> f'{color["R"]}'
'123'

Другим распространенным случаем является использование F-строков в более старых версиях Python. F-строки были введены в Python 3.6. Если вы используете его в более старой версии, интерпретатор поднимет Синтаксисратор: неверный синтаксис Анкет

>>> f"this is an old version"
  File "", line 1
    f"this is an old verion"
                            ^
SyntaxError: invalid syntax

Если вы видите Неверный синтаксис , не забудьте дважды проверить версию Python, которую вы запускаете. В моем случае я тестировал на Python 2.7, и вы можете найти версию, позвонив Sys.version .

>>> import sys; print(sys.version)
2.7.18 (default, Apr 20 2020, 19:27:10) 
[GCC 8.3.0]

Как исправить «Форматирование обычной строки, которая может быть F-строкой»

Эта ошибка происходит потому, что Pylint обнаруживает старый способ форматирования строки, такой как использование % или str.format метод

C0209: Formatting a regular string which could be a f-string (consider-using-f-string)

Чтобы исправить это, вы можете:

  • Замените старый метод форматирования на F-строке
  • проигнорировать ошибку Pylint, используя

В этот пост Я объясняю, как решить эту проблему шаг за шагом.

Замена на F-стенки

Следующие примеры показывают, как преобразовать старый метод в F-String.

>>>  ip_address = "127.0.0.1"

# pylint complains if we use the methods below
>>> "http://%s:8000/" % ip_address
'http://127.0.0.1:8000/'

>>> "http://{}:8000/".format(ip_address)
'http://127.0.0.1:8000/'

# Replace it with a f-string
>>> f"http://{ip_address}:8000/"
'http://127.0.0.1:8000/'

Отключить пилент

В качестве альтернативы, вы можете отключить Pylint Указав флаг «Отключить» с кодом ошибки.

>>>  ip_address = "127.0.0.1"

# pylint complains if we use the methods below, so we can disable them
>>> "http://%s:8000/" % ip_address  # pylint: disable=C0209
'http://127.0.0.1:8000/'

>>> "http://{}:8000/".format(ip_address)  # pylint: disable=C0209
'http://127.0.0.1:8000/'

Другой способ отключения этой ошибки – добавить ее в .pylintrc файл.

# .pylintrc
disable=
    ...
    consider-using-f-string,
    ...

Есть еще один способ отключения его, который заключается в том, чтобы поместить комментарий в верхней части файла, как так:

 # pylint: disable=consider-using-f-string

def your_function(fun):
    """Your code below"""
    ...

Как форматировать числа в разных основаниях

F-стрит также позволяет отображать целое число в разных основаниях. Например, вы можете отобразить int как бинарный, не преобразуя его, используя b вариант.

>>> f'{7:b}'
'111'

Таким образом, вы можете использовать F-строки для формата:

  • int бинарным
  • int в гекс
  • int к октальному
  • int к гексам (где все чары капитализированы)

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

>>> bases = {
       "b": "bin", 
       "o": "oct", 
       "x": "hex", 
       "X": "HEX", 
       "d": "decimal"
}
>>> for n in range(1, 21):
     ...:     for base, desc in bases.items():
     ...:         print(f"{n:5{base}}", end=' ')
     ...:     print()

    1     1     1     1     1 
   10     2     2     2     2 
   11     3     3     3     3 
  100     4     4     4     4 
  101     5     5     5     5 
  110     6     6     6     6 
  111     7     7     7     7 
 1000    10     8     8     8 
 1001    11     9     9     9 
 1010    12     a     A    10 
 1011    13     b     B    11 
 1100    14     c     C    12 
 1101    15     d     D    13 
 1110    16     e     E    14 
 1111    17     f     F    15 
10000    20    10    10    16 
10001    21    11    11    17 
10010    22    12    12    18 
10011    23    13    13    19 
10100    24    14    14    20

Как печатать форматированные объекты с помощью F-стенков

Вы можете распечатать пользовательские объекты, используя F-строки. По умолчанию, когда вы передаете экземпляр объекта на F-String, он отобразит, что __str__ Метод возвращает. Тем не менее, вы также можете использовать Явный флаг преобразования Чтобы отобразить __repr__ Анкет

!r - converts the value to a string using repr().
!s - converts the value to a string using str().
>>> class Color:
    def __init__(self, r: float = 255, g: float = 255, b: float = 255):
        self.r = r
        self.g = g
        self.b = b

    def __str__(self) -> str:
        return "A RGB color"

    def __repr__(self) -> str:
        return f"Color(r={self.r}, g={self.g}, b={self.b})"

>>> c = Color(r=123, g=32, b=255)

# When no option is passed, the __str__ result is printed
>>> f"{c}"
'A RGB color'

# When `obj!r` is used, the __repr__ output is printed
>>> f"{c!r}"
'Color(r=123, g=32, b=255)'

# Same as the default
>>> f"{c!s}"
'A RGB color'

Python также позволяет нам контролировать форматирование на основе типа через __format__ метод В следующем примере показано, как вы можете сделать все это.

>>> class Color:
    def __init__(self, r: float = 255, g: float = 255, b: float = 255):
        self.r = r
        self.g = g
        self.b = b

    def __str__(self) -> str:
        return "A RGB color"

    def __repr__(self) -> str:
        return f"Color(r={self.r}, g={self.g}, b={self.b})"

    def __format__(self, format_spec: str) -> str:
        if not format_spec or format_spec == "s":
            return str(self)

        if format_spec == "r":
            return repr(self)

        if format_spec == "v":
            return f"Color(r={self.r}, g={self.g}, b={self.b}) - A nice RGB thing."

        if format_spec == "vv":
            return (
                f"Color(r={self.r}, g={self.g}, b={self.b}) "
                f"- A more verbose nice RGB thing."
            )

        if format_spec == "vvv":
            return (
                f"Color(r={self.r}, g={self.g}, b={self.b}) "
                f"- A SUPER verbose nice RGB thing."
            )

        raise ValueError(
            f"Unknown format code '{format_spec}' " "for object of type 'Color'"
        )

>>> c = Color(r=123, g=32, b=255)

>>> f'{c:v}'
'Color(r=123, g=32, b=255) - A nice RGB thing.'

>>> f'{c:vv}'
'Color(r=123, g=32, b=255) - A more verbose nice RGB thing.'

>>> f'{c:vvv}'
'Color(r=123, g=32, b=255) - A SUPER verbose nice RGB thing.'

>>> f'{c}'
'A RGB color'

>>> f'{c:s}'
'A RGB color'

>>> f'{c:r}'
'Color(r=123, g=32, b=255)'

>>> f'{c:j}'
--------------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
 in 
---------> 1 f'{c:j}'

 in __format__(self, format_spec)
     29                 f"- A SUPER verbose nice RGB thing."
     30             )
--------> 31         raise ValueError(
     32             f"Unknown format code '{format_spec}' " "for object of type 'Color'"
     33         )

ValueError: Unknown format code 'j' for object of type 'Color'

Наконец, есть также A Вариант, который ускользает от не ASCII Chars. Для получения дополнительной информации: https://docs.python.org/3/library/functions.html#ascii

>>> utf_str = "Áeiöu"

>>> f"{utf_str!a}"
"'\\xc1ei\\xf6u'"

Как использовать F-строки для форматирования плавания

F-строки разрешают форматы Float числа, аналогичные str.format метод Для этого вы можете добавить : (толстая кишка) с последующим Анкет (DOT) и количество десятичных мест с f суффикс.

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

>>> num = 4.123956

>>> f"num rounded to 2 decimal places = {num:.2f}"
'num rounded to 2 decimal places = 4.12'

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

>>> print(f'{num}')
4.123956

Как отформатировать число в процентах

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

>>> total = 87

>>> true_pos = 34

>>> perc = true_pos / total

>>> perc
0.39080459770114945

>>> f"Percentage of true positive: {perc:%}"
'Percentage of true positive: 39.080460%'

>>> f"Percentage of true positive: {perc:.2%}"
'Percentage of true positive: 39.08%'

Как оправдать или добавить накладку к F-строке

Вы можете довольно легко оправдать строку, используя < или > персонажи.

>>> greetings = "hello"

>>> f"She says {greetings:>10}"
'She says      hello'

# Pad 10 char to the right
>>> f"{greetings:>10}"
'     hello'

>>> f"{greetings:<10}"
'hello     '

# You can omit the < for left padding
>>> f"{greetings:10}"
'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

Как избежать персонажей с F-String

Если вы хотите отобразить имя переменной, окруженное вьющимися кронштейнами, вместо того, чтобы отобразить его значение, вы можете избежать его, используя Double {{}} Анкет

>>> hello = "world"

>>> f"{{hello}} = {hello}"
'{hello} = world'

Теперь, если вы хотите избежать двойной цитаты, вы можете использовать Backslash \ " .

>>> f"{hello} = \"hello\""
'world = "hello"'

Как центрировать струну

Центрирование строки может быть достигнуто с помощью var:^n где var переменная, которую вы хотите отобразить, и N Длина строки. Если N короче, чем вар , затем Python отображает всю строку.

>>> hello = "world"

>>> f"{hello:^11}"
'   world   '

>>> f"{hello:*^11}"
'***world***'

# Extra padding is added to the right
>>> f"{hello:*^10}"
'**world***'

# N shorter than len(hello)
>>> f"{hello:^2}"
'world'

Как добавить тысячу разделителей

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

>>> big_num = 1234567890

>>> f"{big_num:_}"
'1_234_567_890'

Как отформатировать число с запятыми в качестве десятичного сепаратора

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

>>> big_num = 1234567890

>>> f"{big_num:,}"
'1,234,567,890'

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

>>> num = 2343552.6516251625

>>> f"{num:,.3f}"
'2,343,552.652'

Как отформатировать число с пробелами в виде десятичного сепаратора

Как насчет того, чтобы использовать пространства вместо этого?

Ну, этот немного “хакерский”, но это работает. Вы можете использовать , в качестве сепаратора, затем замените его пространством.

>>> big_num = 1234567890

>>> f"{big_num:,}".replace(',', ' ')
'1 234 567 890'

Другой вариант – установить локацию вашей среды в тот, который использует места в качестве тысячи сепаратора, таких как pl_pl Анкет Для получения дополнительной информации см. Эта ветка на Сток переполнен Анкет

Как отформатировать число в научных обозначениях (экспоненциальная обозначения)

Форматирование числа в научной нотации возможно с E или E вариант.

>>> 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'

Использование IF-ELSE Conditudal в F-String

F-строки также оценивает более сложные выражения, такие как встроенные Если/else Анкет

>>> a = "this is a"

>>> b = "this is b"

>>> f"{a if 10 > 5 else b}"
'this is a'

>>> f"{a if 10 < 5 else b}"
'this is b'

Как использовать F-String с помощью словаря

Вы можете использовать словаря в F-String. Единственным требованием является использование другой кавычки, чем тот, который прилагает выражение.

>>> color = {"R": 123, "G": 145, "B": 255}

>>> f"{color['R']}"
'123'

>>> f'{color["R"]}'
''123'

>>> f"RGB = ({color['R']}, {color['G']}, {color['B']})"
'RGB = (123, 145, 255)'

Как объединить F-строки

Согласование F-строки-это похоже на концентрацию обычных строк, вы можете сделать это неявно или явно, применяя + оператор или использование str.join метод

# Implicit string concatenation
>>> f"{123}" " = " f"{100}" " + " f"{20}" " + " f"{3}"
'123 = 100 + 20 + 3'

# Explicity concatenation using '+' operator
>>> f"{12}" + " != " + f"{13}"
'12 != 13'

# string concatenation using `str.join`
>>> " ".join((f"{13}", f"{45}"))
'13 45'

>>> "#".join((f"{13}", f"{45}"))
'13#45'

Как отформатировать дату с помощью F-String

F-строки также поддерживают форматирование DateTime объекты. Процесс очень похож на то, как str.format форматы даты. Для получения дополнительной информации о поддерживаемых форматах, проверьте это Таблица в официальных документах.

>>> import datetime

>>> 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'

Как добавить ведущие нули

Вы можете добавить ведущие нули, добавив, используя формат {expr: 0len} где Лен Длина возвращаемой строки. Вы можете включить знак вариант. В этом случае + означает, что знак должен использоваться для положительных и отрицательных чисел. - используется только для отрицательных чисел, что является поведением по умолчанию. Для получения дополнительной информации, проверьте Страница спецификации формата строки Анкет

>>> num = 42

>>> f"{num:05}"
'00042'

>>> f'{num:+010}'
'+000000042'

>>> f'{num:-010}'
'0000000042'

>>> f"{num:010}"
'0000000042'

>>> num = -42

>>> f'{num:+010}'
'-000000042'

>>> f'{num:010}'
'-000000042'

>>> f'{num:-010}'
'-000000042'

Вывод

Вот и все на сегодняшний день, ребята! Я надеюсь, что вы узнали что -то другое и полезное. Знание того, как максимально использовать F-String, может сделать нашу жизнь намного проще. В этом посте я показал самые распространенные уловки, которые я использую на повседневной жизни.

Другие сообщения, которые вам могут понравиться:

Увидимся в следующий раз!

Python F-String: 73 примера, которые помогут вам освоить Это впервые появился на Блог Мигендеса Анкет

Оригинал: “https://dev.to/miguendes/73-examples-to-help-you-master-python-s-f-strings-ln5”