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?
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?
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.
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.
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.
Cześć. Dziś luźny artykuł, bo dziś pobawimy się jedną z pierwszy wersji Pythona. Skompilujemy go i zobaczymy co tam w… Read More
Nowy rok czas zacząć! Więc lećmy z podsumowaniem. Nowy artykuł Nie uwierzycie, ale pojawił się na blogu nowy artykuł! Piszę… Read More
Cześć! W Pythonie 3.13 dodano JITa! JIT, czyli just-in-time compiler to optymalizacja na która Python naprawdę długo czekał. Na nasze… Read More
Cześć! Zapraszam na podsumowanie roku 2024. Książki W sumie rok 2024 był pod względem ilości książek nieco podobny do roku… Read More
Podtrzymując tradycję, prawie regularnych podsumowań, zapraszam na wpis! Nie mogło obyć się bez Karkonoszy We wrześniu odwiedziłem z kolegą Karkonosze,… Read More
Oj daaawnoo mnie tu nie było. Ale wakacje to był czas dużej liczby intensywnych wyjazdów i tak naprawdę, dopiero jakoś… Read More
Pokaż komentarze
Dzięki za fajny wpis, uczę się właśnie pythona więc jak najbardziej na czasie.
Cieszę się, że wpis się podoba:)