Python Dize Enterpolasyonu: Yeni Başlayanlar İçin Kılavuz

Diyelim ki bir kişinin adını ve mesleğini çıktı olarak vermek istiyorsunuz. Aşağıdaki gibi basit bir program yazabilirsiniz.

# Define variables
name = 'Mark'
profession = 'Astronaut'
age = 7


# Output info
output_string = ('My name is ' + name +
                ', I am ' + str(age) + ' years old ' +
                'and my profession is ' + profession + '.')
print(output_string)Altyapı:

   My name is Mark, I am 7 years old and my profession is Astronaut.Altyapı:

Bu yaklaşım yeterince öz ve okunaklı değildir. Neyse ki, dize enterpolasyonu daha iyi bir çözüm sunar. Değişkenlerin, ifadelerin veya fonksiyon çıktılarını doğrudan bir dizenin içine yerleştirmenize olanak tanır; böylece dize işlemleri dinamik hâle gelir ve elle birleştirme ihtiyacı ortadan kalkar.

Dize enterpolasyonu yaklaşımını kullanarak kodu şu şekilde yeniden yazabiliriz.

# Define variables
name = 'Mark'
profession = 'Astronaut'
age = 7


# Output info
output_string = f'My name is {name}, I am {age} years old and my profession is {profession}.'
print(output_string)Altyapı:

   My name is Mark, I am 7 years old and my profession is Astronaut.Altyapı:

Dize enterpolasyonlu sürüm, dağınık birleştirmeler kullanmadan ifadelerin doğrudan dizeye gömülmesine olanak tanır. Gördüğünüz gibi çok daha temiz bir yaklaşımdır.

Python'da Temel Dize Enterpolasyonu

Python'da birden fazla dize enterpolasyonu tekniği mevcuttur. En yaygın önerilen yöntem, Python 3.6’dan beri kullanılabilen biçimlendirilmiş dize literal’ları, yani f-string’lerdir.

Python 3.6’dan eski kodlarda sıkça görülen bir diğer yöntem ise .format() metodudur. Bu yöntem f-string’lere göre daha uzun olsa da bazen avantajları vardır (ayrıntılar aşağıda).

Son olarak, eski kodlarda % tarzı biçimlendirmeye de rastlayabilirsiniz.

f-string kullanımı (Python 3.6+)

f-string’ler (biçimlendirilmiş dize literal’ları), Python’da dizeleri biçimlendirmenin güçlü ve özlü bir yoludur. Python 3.6’da tanıtılmıştır ve değişkenleri, ifadeleri ve fonksiyon çağrılarını doğrudan dizelere yerleştirmenin okunabilir ve verimli bir yolunu sağlar.

Bir f-string’in temel sözdizimine basit bir örnek aşağıdadır.

name = 'Mark'
output_string = f'My name is {name}.'
print(output_string)Altyapı:

   My name is Mark.Altyapı:

Bu kodda, output_string değişkenine bir f-string atanmıştır. Açılış tırnağından önceki f öneki, dizenin gömülü ifadeleri desteklediğini gösterir. name değişkeni değerlendirilir ve değeri dizeye yerleştirilir; böylece şu çıktı elde edilir: "My name is Mark."

Yalnızca değişken değerleri değil, hesaplamalar veya ifadeler de f-string’lere eklenebilir. Şu örneği düşünün.

import math


a = 3.0
b = 4.0


# Use string interpolation for the formula
print(f'The hypotenuse of a triangle with base {a} and side {b} is {math.sqrt(a ** 2 + b ** 2)}.')Altyapı:

   The hypotenuse of a triangle with base 3.0 and side 4.0 is 5.0.Altyapı:

math.sqrt(a ** 2 + b ** 2) ifadesi, değeri ayrı hesaplayıp dizeye eklemeye gerek kalmadan doğrudan dize içinde değerlendirilir.

.format() metodunu kullanma

f-string’ler gibi, .format() metodu da dizeye değişken ve ifadeler yerleştirmeye olanak tanır. .format() metodunun temel sözdizimi şöyledir.

name = 'Mark'
output_string = 'My name is {}.'.format(name)
print(output_string)Altyapı:

   My name is Mark.Altyapı:

Süslü parantezler {} yer tutucu görevi görür; o konuma bir değişkenin değerinin ekleneceğini belirtir. Yer tutucuya eklenecek spesifik değişkenin değeri, .format() metoduna verilen argüman tarafından belirlenir.

Konumsal argümanlar

Birden çok değişken için birden fazla yer tutucuya ihtiyacınız olursa ne olur? Aşağıdaki kodu inceleyin.

name = 'Mark'
age = 7


# The placeholders are filled in order of the arguments
output_string = 'My name is {} and I am {} years old.'.format(name, age)


print(output_string)Altyapı:

   My name is Mark and I am 7 years old.Altyapı:

Bu örnekte, name ve age olmak üzere iki değişken gereklidir. Dolayısıyla dize iki yer tutucu içerir ve değişkenler .format() metodunda göründükleri sıraya göre yerleştirilir. Bu argümanlara, dize içindeki yerleşimleri metodun argüman listesindeki konumlarına bağlı olduğundan *konumsal* argümanlar denir.

Indeksli ve adlandırılmış yer tutucular

Yer tutucu fikrinin bir varyasyonu olarak şu örneği düşünün.

name = 'Mark'
age = 7


# Print age twice
output_string = 'My name is {} and I am {} years old. My twin brother is also {} years old.'.format(name, age, age)
print(output_string)Altyapı:

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.Altyapı:

Burada age değişkeninin değerini iki kez kullandık. Aynı değişkeni bu şekilde birden fazla kez eklemek hantaldır ve okunabilirliği azaltır. .format() ile biçimlendirilen bir dizede bir değişkeni tekrar etmeden yeniden kullanmanın bir yolu var mı? Evet, sözde *indeksli yer tutucular* kullanarak.

name = 'Mark'
age = 7


# Use indexed placeholders
output_string = 'My name is {0} and I am {1} years old. My twin brother is also {1} years old.'.format(name, age)
print(output_string)Altyapı:

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.Altyapı:

Bu örnekte, Python’un sıfır tabanlı indekslemesini izleyerek değişkenlerin sırasını süslü parantezler içinde açıkça tanımladık. Ayrıca, tekrarlamak yerine 1. sıradaki değişkeni yeniden kullandık.

Konumsal indekslemeye alternatif olarak, her argümana bir ad verildiği adlandırılmış argümanları da kullanabilirsiniz.

print('My name is {name} and I am {age} years old.'.format(name='Mark', age=7))Altyapı:

   My name is Mark and I am 7 years old.Altyapı:

Adlandırılmış argüman, adını belirten süslü parantezler içinde değerlendirilir. Sonuç olarak {name} yer tutucusu "Mark" değeriyle, {age} yer tutucusu ise 30 ile değiştirilir.

% operatörünü kullanma

Dize enterpolasyonunun son yöntemi % operatörüdür. C dilindeki printf() komutuna benzer şekilde çalışır. Kullanımı eskimiştir ve f-string’ler veya .format() lehine şiddetle kaçınılması önerilir. Burada anılmasının nedeni, eski kod tabanlarında karşınıza çıkabilmesidir.

% operatörü için temel biçim: "format string" % values şeklindedir. Biçim dizgesi, dizeler için %s gibi yer tutucular içerir ve bunlar değerlerle değiştirilir. Örneğin aşağıdaki örnek "Hello, Mark." yazdırır

'Hello %s' % 'Mark'Altyapı:

   'Hello Mark'Altyapı:

Diğer yaygın biçim belirteçleri aşağıdaki tabloda gösterilmiştir.

% operatörünün birçok sınırlaması vardır. Öncelikle, f-string’lere göre daha az okunabilirdir. Şu kodu düşünün.

name = "Alice"
age = 30
height = 5.6


# The % operator is hard to scan
message = "My name is %s, I am %d years old, and my height is %.1f feet." % (name, age, height)
print(message)Altyapı:

   My name is Alice, I am 30 years old, and my height is 5.6 feet.Altyapı:

Bu kod bir bakışta anlaşılır mı? Muhtemelen hayır. Yer tutucular ile boşlukları dolduran değişkenler arasında çok fazla görsel tarama gerekir. Bu gidip gelmeler kafa karıştırıcı (hatta baş döndürücü) olabilir.

Şimdi, f-string kullanan eşdeğer koda bakalım.

# This is much cleaner
message = f"My name is {name}, I am {age} years old, and my height is {height:.1f} feet."
print(message)Altyapı:

   My name is Alice, I am 30 years old, and my height is 5.6 feet.Altyapı:

Ne taramaya ne de anlaşılması güç biçimlendirme dizelerine ihtiyaç vardır. Kod temizdir, anlaması ve yazması kolaydır. Daha net, optimize kod yazmaya dair başka ipuçlarını DataCamp’in Python Programming yetkinlik yolunda öğrenebilirsiniz. 

Gelişmiş Python Dize Enterpolasyonu Teknikleri

Artık Python dize enterpolasyonunun temellerini anladığımıza göre, biraz daha gelişmiş kullanımlara bakalım. 

Python çok satırlı dize enterpolasyonu

f-string’ler, tek veya çift üç tırnakla birlikte f öneki kullanılarak çok satırlı içerik için de kullanılabilir. Metin birden fazla satıra yayılabilir ve çıktı, biçimlendirildiği gibi görünür.

name = 'Mark'
profession = 'Astronaut'
age = 7


# This is an example of a multiline string
bio = f"""
Name: {name}
Profession: {profession}
Age: {age}
"""
print(bio)Altyapı:

   Name: Mark

   Profession: Astronaut

   Age: 7Altyapı:

 Çok satırlı dizeler .format() metoduyla da oluşturulabilir.

name = 'Mark'
profession = 'Astronaut'
age = 7


# This is a multiline string with .format()
bio = """
Name: {}
Profession: {}
Age: {}
""".format(name, profession, age)
print(bio)Altyapı:

   Name: Mark

   Profession: Astronaut

   Age: 7Altyapı:

Çok satırlı dize enterpolasyonu için kullanım alanları

Neden çok satırlı dize enterpolasyonu kullanmak isteyesiniz? Çok sayıda kullanım alanı vardır. İşte birkaç örnek:

• Çok satırlı e-posta veya mesaj oluşturma
• Günlükleme ve hata ayıklama
• SQL sorgularını dinamik olarak oluşturma

Çok satırlı e-posta veya mesaj oluşturma

Diyelim ki birçok davetliye bir teknoloji konferansı için şablon bir mektup gönderiyorsunuz.

name = "Alice"
event = "Annual Tech Conference"
date = "March 15, 2025"


email = """Dear {name},


We are pleased to invite you to the {event} taking place on {date}.
We hope you can join us for an exciting experience.


Best regards, 
The Event Team""".format(name=name, event=event, date=date)


print(email)Altyapı:

   Dear Alice,

  

   We are pleased to invite you to the Annual Tech Conference taking place on March 15, 2025.

   We hope you can join us for an exciting experience.

  

   Best regards, 

   The Event TeamAltyapı:

f-string’lerle şablon bir mektup oluşturmak basit ve verimlidir. İsim, etkinlik veya tarihi değiştirmek için değişkenlerde değiştirmeniz yeterlidir; dize kendiliğinden güncellenir.

Günlükleme ve hata ayıklama

Çok satırlı dizeler, günlükler için hata mesajlarını yazdırmada kullanışlıdır.

error_code = 404
url = '/missing-page'
timestamp = '2025-02-05 12:30:00'
error_message = 'The requested page could not be found.'


log_message = f"""[ERROR {error_code}]
Time: {timestamp}
URL: {url}


{error_message}"""


print(log_message)Altyapı:

   [ERROR 404]

   Time: 2025-02-05 12:30:00

   URL: /missing-page

 

   The requested page could not be found.Altyapı:

Bu yöntem, günlük mesajlarını yapılandırılmış tutar ve düzgün biçimlendirilmiş günlüklerle hata ayıklamayı kolaylaştırır.

SQL sorgularını dinamik olarak oluşturma

SQL sorguları çok satırlı dizeler kullanılarak dinamik biçimde oluşturulabilir.

table = 'users'
column = 'email'
value = '[email protected]'


query = f"""SELECT *
FROM {table}
WHERE {column} = '{value}';"""


print(query)Altyapı:

   SELECT *

   FROM users

   WHERE email = '[email protected]';Altyapı:

Bu yöntem, SQL sorgularını okunabilir kılar ve girintiyi korur. Ayrıca, dize birleştirme için + kullanma ihtiyacını ortadan kaldırır.

Diğer kullanım alanları şunlardır:

• Biçimlendirilmiş sözleşmeler yazma
• Markdown veya $\LaTeX$ belgeleri oluşturma
• Çok satırlı HTML/XML şablonları
• API yanıtları veya JSON benzeri metin üretme

Çok satırlı dize enterpolasyonunun avantajları

Gördüğümüz gibi, çok satırlı dize enterpolasyonunun çeşitli avantajları vardır.

• Dize enterpolasyonu, kaçış karakteri \n gerekmeden biçimi korur. 
• Dize enterpolasyonu, tek satırlı biçimlendirmeye kıyasla okunabilirliği artırır. 
• Dize enterpolasyonu, yapılandırılmış metinlerle (ör. günlükler, sorgular, raporlar) çalışırken karmaşıklığı azaltır. 
• Dize enterpolasyonu, girintiyi bozmadan dinamik metin üretimine olanak tanır. 

Sayıların ve özel değerlerin biçimlendirilmesi

Bir f-string kullanarak gösterilen ondalık basamak sayısını kontrol etmek için şu sözdizimini kullanın: f'{value:.nf}'. Burada value kayan noktalı sayı, n ondalık basamak sayısıdır ve f (.’dan sonraki) float biçimlendirmeyi ifade eder.

Örneğin aşağıdaki kod, $\pi$ sayısını farklı ondalık basamaklarla yazdırır.

pi = 3.1415926535


print(f'Pi rounded to 2 decimal places: {pi:.2f}')
print(f'Pi rounded to 4 decimal places: {pi:.4f}')
print(f'Pi rounded to 0 decimal places: {pi:.0f}')Altyapı:

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3Altyapı:

.format() ile biçimlendirme de benzerdir.

print('Pi rounded to 2 decimal places: {:.2f}'.format(pi))
print('Pi rounded to 4 decimal places: {:.4f}'.format(pi))
print('Pi rounded to 0 decimal places: {:.0f}'.format(pi))Altyapı:

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3Altyapı:

Bir f-string ile yüzde biçimlendirmek için :.nf sözdizimini % ile birlikte kullanabilirsiniz; burada n, ondalık basamak sayısıdır.

score = 0.875
print(f"Success rate: {score:.2%}")Altyapı:

   Success rate: 87.50%Altyapı:

Bir f-string ile para birimi biçimlendirmek için binlik ayırıcı olarak :, ve ondalık basamakları kontrol etmek için .nf kullanabilirsiniz. Ayrıca $, € veya £ gibi bir para birimi simgesini doğrudan dizeye ekleyebilirsiniz.

amount = 98765.4321


print(f"USD: ${amount:,.2f}")
print(f"EUR: €{amount:,.2f}")
print(f"GBP: £{amount:,.2f}")Altyapı:

   USD: $98,765.43

   EUR: €98,765.43

   GBP: £98,765.43Altyapı:

Sözlükler ve listelerle f-string kullanma

Python’da bir sözlükle f-string kullanmak için, süslü parantezlerin içinde köşeli parantez gösterimiyle (dict['key']) değerleri erişebilir veya ** ile sözlüğü açabilirsiniz.

person = {
   'name': 'Alice',
   'age': 30,
   'city': 'New York'
}


print(f"My name is {person['name']}, I am {person['age']} years old, and I live in {person['city']}.")Altyapı:

   My name is Alice, I am 30 years old, and I live in New York.Altyapı:

Her anahtara tek tek erişmek yerine, sözlüğü bir f-string’e şu şekilde açabilirsiniz.

person = {
   'name': 'Alice',
   'age': 30,
}


print(f'My name is {name} and I am {age} years old.'.format(**person))Altyapı:

   My name is Alice and I am 7 years old.Altyapı:

Eksik anahtarlar için hata almamak adına, sözlük erişiminde get() kullanın.

person = {"name": "Alice"}


# Error: key 'city' is missing
print(f"City: {person['city']}") Altyapı:

   ---------------------------------------------------------------------------




   KeyError                                  Traceback (most recent call last)




   Cell In[87], line 4

         1 person = {"name": "Alice"}

         3 # Error: key 'city' is missing

   ----> 4 print(f"City: {person['city']}")







   KeyError: 'city'Altyapı:

print(f"City: {person.get('city', 'Not specified')}")Altyapı:

   City: Not specifiedAltyapı:

Dize Enterpolasyonu Yöntemlerinin Artıları ve Eksileri

Gördüğümüz üzere, f-string’ler ve .format() metodu dize enterpolasyonu için yararlı yöntemlerdir. Şimdi her bir yöntemin artı ve eksilerini karşılaştıralım.

Ne zaman .format() kullanımı f-string’lere göre tercih edilmelidir?

Yaygın Tuzaklar ve En İyi Uygulamalar

Aşağıda, Python dize enterpolasyonunu kullanırken bazı sorun giderme yöntemleri ve önemli ipuçlarını bulabilirsiniz. 

Süslü parantezlerle sözdizimi hatalarından kaçınma

Süslü parantez içeren dize enterpolasyonunda pek çok sözdizimi hatası yapılabilir.

• Her { için eşleşen bir } olduğundan emin olun

print('Hello, my name is {name!'}Altyapı:

     Cell In[96], line 1

       print('Hello, my name is {name!'}
                                       ^
   SyntaxError: closing parenthesis '}' does not match opening parenthesis '('Altyapı:

Neyse ki hata açıktır ve düzeltmesi kolaydır.

• Literal {} göstermek için {{ ve }} kullanın

Enterpolasyonlu bir dize içinde süslü parantez yazdırmak isterseniz ne olur? Süslü parantezler içindeki her şey (değerlendirilmeye) çalışılır.

print(f'Set notation: {a, b, c}')Altyapı:

   ---------------------------------------------------------------------------

   NameError                                 Traceback (most recent call last)

   Cell In[101], line 1

   ----> 1 print(f'Set notation: {a, b, c}')

   NameError: name 'c' is not definedAltyapı:

Python, süslü parantez içindeki a, b, c ifadesini bir demet (tuple) olarak yorumlar ve a ile ilişkili bir değer bulmaya çalışır. Böyle bir değişken mevcut olmadığından KeyError hatası yükseltir. Çözüm, çift süslü parantez {{}} kullanmaktır.

print("Set notation: {{a, b, c}}")Altyapı:

   Küme gösterimi: {{a, b, c}}

Performans karşılaştırması: f-string’ler vs .format()

f-string’ler ile .format()’ın performansını karşılaştıralım.

import timeit


name = "Alice"
age = 30
pi = 3.1415926535


# Measure f-string performance
f_string_time = timeit.timeit('f"My name is {name} and I am {age} years old."', globals=globals(), number=1000000)


# Measure .format() performance
format_time = timeit.timeit('"My name is {} and I am {} years old.".format(name, age)', globals=globals(), number=1000000)


# Measure f-string performance with expressions
f_string_expr_time = timeit.timeit('f"Pi rounded to 2 decimal places: {pi:.2f}"', globals=globals(), number=1000000)


# Measure .format() performance with expressions
format_expr_time = timeit.timeit('"Pi rounded to 2 decimal places: {:.2f}".format(pi)', globals=globals(), number=1000000)


# Print results
print(f"f-string (simple): {f_string_time:.6f} seconds")
print(f".format() (simple): {format_time:.6f} seconds")
print(f"f-string (with expression): {f_string_expr_time:.6f} seconds")
print(f".format() (with expression): {format_expr_time:.6f} seconds")Altyapı:

   f-string (simple): 0.080447 seconds

   .format() (simple): 0.129860 seconds

   f-string (with expression): 0.123171 seconds

   .format() (with expression): 0.146242 secondsAltyapı:

Görüldüğü gibi, verimlilik açısından .format() yerine f-string’leri tercih etmek gerekir.

Temiz ve okunabilir dize enterpolasyonu için en iyi uygulamalar

Dize biçimlendirmenizin açık, verimli ve sürdürülebilir olmasını sağlamak için enterpolasyonlu dizeleri kullanırken şu en iyi uygulamaları takip edin.

• Okunabilirlik için f-string’leri tercih edin (Python 3.6+)

# Recommended
name = "Alice"
age = 30
print(f"My name is {name} and I am {age} years old.")


# Not Recommended (Less readable)
print("My name is {} and I am {} years old.".format(name, age))


# Avoid using % formatting (Outdated)
print("My name is %s and I am %d years old." % (name, age))Altyapı:

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.Altyapı:

• Netlik için adlandırılmış yer tutucular kullanın

# Named placeholders (readable)
user = {"name": "Alice", "age": 30}
print(f"My name is {user['name']} and I am {user['age']} years old.")


# Using indexes in .format() (not as readable)
print("My name is {0} and I am {1} years old.".format("Alice", 30))Altyapı:

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.Altyapı:

• Çok satırlı dizeleri okunabilir tutun.

name = "Alice"
age = 30


message = f"""Hello, {name}!


We are happy to invite you to our event.
At {age} years old, you are eligible for the VIP pass.


Best regards,
Event Team
"""
print(message)Altyapı:

   Hello, Alice!


   We are happy to invite you to our event.

   At 30 years old, you are eligible for the VIP pass.


   Best regards,

   Event Team  Altyapı:

• Hata ayıklamayı iyileştirmek için günlüklemede f-string kullanın

Python 3.8 ve sonrasında f-string’lerde hata ayıklama için = desteği vardır.

value = 42


# Output: value = 42
print(f"{value = }") Altyapı:

   value = 42Altyapı:

Sonuç

Dize enterpolasyonu, Python’da dize biçimlendirmeyi daha temiz, daha okunabilir ve daha verimli hâle getiren güçlü bir özelliktir. Mevcut yöntemler arasında f-string’ler en modern ve önerilen yaklaşımdır; .format() ve % biçimlendirmeye göre daha iyi performans, netlik ve esneklik sunar. 

Adlandırılmış yer tutucular kullanmak, ondalık duyarlılığı kontrol etmek, okunabilirlik için hizalamayı ayarlamak ve eksik sözlük anahtarlarını zarifçe ele almak gibi en iyi uygulamaları takip ederek Python’da temiz, profesyonel ve sürdürülebilir dize biçimlendirmeleri yazabilirsiniz. 

İster biçimlendirilmiş raporlar, ister çok satırlı mesajlar veya yapılandırılmış veri çıktıları üretiyor olun, f-string’ler değişkenleri ve ifadeleri sorunsuz biçimde entegre etmenin basit ama güçlü bir yolunu sunar. f-string’leri benimsemek yalnızca kod kalitenizi artırmakla kalmaz, verimliliğini de yükseltir. 

Python dize enterpolasyonu hakkında daha fazla bilgi için DataCamp’in kaynaklarına göz atın:

• Python’da f-string Biçimlendirme eğitimi
• Python Append String: 6 Temel Birleştirme Tekniği
• Python Programming yetkinlik yolu
• Python Fundamentals yetkinlik yolu
• Introduction to Data Science in Python dersi