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.
Ostatnio tygodnie były tak bardzo wypełnione, że nie udało mi się napisać nawet krótkiego podsumowanie. Więc dziś zbiorczo podsumuję luty… Read More
Zapraszam na krótkie podsumowanie miesiąca. Książki W styczniu przeczytałem "Homo Deus: Historia jutra". Książka łudząco podoba do wcześniejszej książki tego… Read More
Cześć! Zapraszam na podsumowanie roku 2023. Książki Zacznijmy od książek. W tym roku cel 35 książek nie został osiągnięty. Niemniej… Read More
Zapraszam na krótkie podsumowanie miesiąca. Książki W grudniu skończyłem czytać Mein Kampf. Nudna książka. Ciekawsze fragmenty można by było streścić… Read More
Cześć, ostatnio w Internecie pojawiło się dużo artykułów, które nie były przychylne pracy zdalnej. Z drugiej strony większość komentarzy pod… Read More
Zapraszam na krótkie podsumowanie miesiąca. Książki W listopadzie dokończyłem cykl "Z mgły zrodzony" Sandersona. Tylko "Stop prawa" mi nie do… 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:)