[Python3.6] F-String //Easyly

[FONT="Courier New"]isim = 'Omer'
string = "Merhabalar {}".format(isim)
print(string)

#Out:
#Merhabalar Omer[/FONT]

[FONT="Courier New"]isim = 'Omer'
string = f"Merhabalar {isim}"
print(string)

#Out
#Merhabalar Omer[/FONT]

[FONT="Courier New"]isim = 'Ahmet'
string = f"Merhabalar {isim if isim == 'Ahmet' else 'Belirtilmedi'}"
print(string)

#Out:
#Merhabalar Ahmet

## Eger isim degeri 'Ahmet' olmasaydi ciktimiz soyle olurdu:
## Merhabalar Belirtilmedi[/FONT]

[FONT="Courier New"]print(f"Sectiginiz sayilarin toplami: {int(input('Sayi1: ')) + int(input('Sayi2: '))}")


#Out:
#Sayi1: 12
#Sayi2: 2
#Sectiginiz sayilarin toplami: 14[/FONT]

[FONT="Courier New"]isim = 'Ali'
yas = 6

print(f"{isim.upper()}'in yasi {yas} ve 10 yil sonra yasi {yas + 10} olacaktir...")


#Out
#ALI'nin yasi 6 ve 10 yil sonra yasi 16 olacaktir...
[/FONT]

ALcatraz'' Alıntı:

Aslında f-string'in kullanışından çok hızı çok önemli bence.
Mesela resmedilmiş bir örneği ;

Kod:

In [13]: timeit f'{a} + {b} = {a + b}'
12.4 ns ± [COLOR="Red"][B]0.17[/B][/COLOR] ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)

In [14]: timeit '{} + {} = {}'.format(a, b, a + b)
510 ns ± [COLOR="Red"][B]4.19[/B][/COLOR] ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [15]: timeit '%s + %s = %s' % (a, b, a + b)
366 ns ± [COLOR="Red"][B]4.05[/B][/COLOR] ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

Ve tabi böyle olmasının nedeni bytecodelardan kaynaklanıyor.
Dissambled bytecode'dan iki bytecode komutunu atlıyor: LOAD_ATTR ve CALL_FUNCTION. Sadece a ile b'yi toplayan bir fonksiyon çağıralım f-string ile beraber.

Kod:

dis.dis(add_two_fstring)
  2           0 LOAD_CONST               1 (1)
              2 STORE_FAST               0 (a)

  3           4 LOAD_CONST               2 (2)
              6 STORE_FAST               1 (b)

  4           8 LOAD_FAST                0 (a)
             10 LOAD_FAST                1 (b)
             12 BINARY_ADD
             14 FORMAT_VALUE             0
             16 RETURN_VALUE

Str.format () kullandığımızda, format işlevinin öncelikle global değişken olarak"Araştırılması" gerekir. Bu LOAD_ATTR bytecode ile yapılır. Global değişken "Araştırılması" gerçekten kolay bir işlem değildir. .format() fonksiyonu bulunduğunda, a ve b değişkenlerini toplamak için ikili ekleme işlemi (BINARY_ADD) çağrılır. Son olarak, format fonksiyonu CALL_FUNCTION bytecode ile işleme devam eder ve belirtilen sonuçlar döndürülür. Hemen a ile b'yi toplayan fonksiyonun str.format() ile çağrılmasına göz atalım;

Kod:

dis.dis(add_two_string_format)
 
  2           0 LOAD_CONST               1 (1)
              2 STORE_FAST               0 (a)

  3           4 LOAD_CONST               2 (2)
              6 STORE_FAST               1 (b)

  4           8 LOAD_CONST               3 ('{}')
             10 [COLOR="Red"]LOAD_ATTR [/COLOR]               0 (format)
             12 LOAD_FAST                0 (a)
             14 LOAD_FAST                1 (b)
             16 BINARY_ADD
             18 [COLOR="Red"]CALL_FUNCTION[/COLOR]            1
             20 RETURN_VALUE

Pythonda işlev çağırma gerçekten kolay bir işlem değildir ve büyük bir yüke sahiptir. str.format() işlevini kullanırken, LOAD_ATTR ve CALL_FUNCTION değerlerinde harcanan zaman, str.format() 'ın f-stringden çok daha yavaş olmasına katkıda bulunan şeydir.

Pardon pardon birde %-string vardı dimi?
Mesela %-string , str.format() 'a göre daha hızlı yukarıda da gördüğünüz gibi. Ama f-string'e göre daha yavaş peki %-string ' in str.format() 'a karşı hızlı olduğu yer neresi?Deminki gibi sadece a ile b'yi toplayan fonksiyon %-string ile çağrılmasına göz atalım ;

Kod:

dis.dis(add_two_percent_string_format)
  2           0 LOAD_CONST               1 (1)
              2 STORE_FAST               0 (a)

  3           4 LOAD_CONST               2 (2)
              6 STORE_FAST               1 (b)

  4           8 LOAD_CONST               3 ('%s')
             10 LOAD_FAST                0 (a)
             12 BINARY_MODULO
             14 LOAD_FAST                1 (b)
             16 BINARY_ADD
             18 RETURN_VALUE

Ee burada da LOAD_ATTR , CALL_FUNCTION yok? O zaman f-string ile aynı hızda olması gerekmez mi? Ama dikkatlice baktığımızda;

Kod:

dis.dis(add_two_percent_string_format)
  2           0 LOAD_CONST               1 (1)
              2 STORE_FAST               0 (a)

  3           4 LOAD_CONST               2 (2)
              6 STORE_FAST               1 (b)

  4           8 LOAD_CONST               3 ('%s')
             10 LOAD_FAST                0 (a)
             [COLOR="Red"]12 BINARY_MODULO[/COLOR]
             14 LOAD_FAST                1 (b)
             16 BINARY_ADD
             18 RETURN_VALUE

BINARY_MODULO Cpython'un source'sinden bakabilirsiniz.

LINK - Bu kadar az olmasına rağmen yinede ciddi bir zaman kaybı var..

f-string kullanın iyidir.
Makaleyi yazan arkadaşında ellerine, emeğine sağlık.
Secrets modülünü de bekliyoruz

Genişletmek için tıkla ...