Inżynieria oprogramowania Programowanie Programowanie webowe

F-stringi – czyli formatowanie stringów w Pythonie

Mateusz M. 30/01/2023

🕑 3 minuty czytania

Cześć! F-stringi pewnie każdy z Was zna. Pojawiły się w Pythonie 3.6 i bez najmniejszego problemu podbiły serca programistów. Pytanie jest jedno, czy podbiły je tylko dzięki wygodzie używania? Czy może mają jeszcze jakieś inne zalety?

Co jeśli nie f-stringi?

Formatować stringi możemy w Pythonie na wiele sposobów:

1
2
3
4
5
6
7
8
9
10

from string import Template

a, b = "jeden", "dwa"

print(" ".join((a, b)))
print("%s %s" % (a, b))
print(a + " " + b)
print(f"{a} {b}")
print("{} {}".format(a, b))
print(Template("$x $y").substitute(x=a, y=b))

Każda z powyższych linijek wypisze to samo. Dlaczego więc f-stringi są polecanym sposobem formatowania stringów?

Szybkość działania

Używając pakietu timeit możemy łatwo zmierzyć szybkość wykonywania się pokazanych przeze mnie możliwości formatowania stringów:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

import timeit

setup = """
x, y = "jeden", "dwa"
from string import Template
"""

case1 = """
" ".join((x, y))
"""

case2 = """
"%s %s" % (x, y)
"""

case3 = """
x + " " + y
"""

case4 = """
f"{x} {y}"
"""

case5 = """
"{} {}".format(x, y)
"""

case6 = """
Template("$x $y").substitute(x=x, y=y)
"""

print('" ".join((x, y)): ',timeit.timeit(stmt=case1, setup=setup))
print('"%s %s" % (x, y) : ',timeit.timeit(stmt=case2, setup=setup))
print('x + " " + y: ',timeit.timeit(stmt=case3, setup=setup))
print('f"{x} {y}" : ',timeit.timeit(stmt=case4, setup=setup))
print('"{} {}".format(x, y): ',timeit.timeit(stmt=case5, setup=setup))
print('Template("$x $y").substitute(x=x, y=y): ',timeit.timeit(stmt=case6, setup=setup))

Co da nam wynik:

" ".join((x, y)):  0.10944065000512637
"%s %s" % (x, y) :  0.15260958099679556
x + " " + y:  0.09211009099090006
f"{x} {y}" :  0.07798413900309242
"{} {}".format(x, y):  0.2143534819915658
Template("$x $y").substitute(x=x, y=y):  1.6274689880083315

Uszeregujmy go rosnąco:

f"{x} {y}" :  0.07798413900309242
x + " " + y:  0.09211009099090006
" ".join((x, y)):  0.10944065000512637
"%s %s" % (x, y) :  0.15260958099679556
"{} {}".format(x, y):  0.2143534819915658
Template("$x $y").substitute(x=x, y=y):  1.6274689880083315

Co ładnie pokazuje nam pierwszą, poza wygodą, dużą zaletę f-stringów. Są po prostu bardzo wydajne.

Możliwości

Niewiele osób wie, że możliwości f-stringów są znacząco większe niż:

1 2	var1 = 12 print(f"Jestem zmienna z wartoscia: {var1}")

Od Pythona 3.8 możemy np. łatwo wypisywać nazwę zmiennej i jej wartość:

1
2
3
4
5
6
7
8
9

var1 = 12
var2 = 13
var3 = 14
print(f"{var1 = } {var2 = } {var3 = }")

"""
Co wypisze nam:
var1 = 12 var2 = 13 var3 = 14
"""

F-stringi pozwalają również przesuwać napisy czy dodawać wiodące zera:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

text: str = "jestem testem"

print(f"{text:>14}")

"""
Co da nam:

" jestem testem"

"""

number: int = 2468123

print(f"{number:09}")

"""
Co da nam
002468123
"""

Możemy też formatować datę:

1
2
3
4
5

import datetime

now = datetime.datetime.now()

print(f"{now:%Y}") # wyświetli 2023

Możemy też zagnieżdżać wyrażenia:

1
2
3
4
5
6
7
8
9

number = 23456

print(f'{f"{number:,}":.4}')

"""
Co da nam: 24,3
- najpierw ustawiamy separator na ","
- następnie precyzje na "4"
"""

I wiele innych ciekawych rzeczy.

Czekaj, stop!

Podoba Ci się to co tworzę? Jeśli tak to zapraszam Cię do zapisania się na newsletter:

a w ramach prezentu otrzymasz całkowicie za darmo, dwa dokumenty PDF „6 (nie zawsze oczywistych) błędów popełnianych podczas nauki programowania” który jest jednym z efektów ponad siedmioletniej pracy i obserwacji rozwoju niejednego programisty oraz „Wstęp do testowania w Pythonie”, będący wprowadzeniem do biblioteki PyTest.
Jeśli to Cię interesuje to zapraszam również na swoje social media.

Jak i do ewentualnego postawienia mi kawy :)

Czy f-stringi wszędzie można bezpiecznie stosować?

Znam jedną sytuację która może być trochę kłopotliwa a dokładniej loggery. Spójrzmy na taką sytuację:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger()

class Test:
def __str__(self):
print("jestem informacją")
return "Object Test"

logger.debug("Test: %s", Test())
logger.debug(f"Test: {Test()}")

"""
Te dwa loggery wyzej wypiszą:
"jestem informacją"
"""

Definiujemy sobie logger na poziomie info i wypisujemy z poziomem debug jakiś tekst. W Pythonie mamy domyślne poziomy logowania uszeregowane w taki sposób:

NOTSET=0
DEBUG=10
INFO=20
WARN=30
ERROR=40
CRITICAL=50

Więc oczekujemy, że nic nie zostanie wypisane. A jednak przecież zostało wypisane „jestem informacją”.

Dlaczego została wypisana jakakolwiek informacja na ekran skoro poziom logowania tego zabrania? I które z wywołań loggera jest za nią odpowiedzialne? Problem powoduje drugie wywołanie loggera a dokładniej: nasz f-string. Logger składa wiadomość dopiero wtedy kiedy nie można już zapobiec jej wyświetleniu. Oznacza to, że jeśli poziom logowania nie pozwala na wypisanie wiadomości to wiadomość nie zostanie złożona. Jeśli natomiast użyjemy f-stringu to wiadomość zostanie złożona przed przekazaniem do loggera a więc metoda str wykona się, mimo, że logger nie wyświetli jej wyniku. Dlatego też nie zaleca się używania f-stringów w loggerach.

Dzięki za wizytę,
Mateusz Mazurek