Python Nesneleri Neden “Konuşmalı”? `__str__()` ve `__repr__()` Nedir?

Python nesnelerinizi ekrana bastığınızda gördüğünüz anlaşılmaz çıktıları anlamlı hale getirin. __str__() ve __repr__() metotlarıyla nesnelerinizi özelleştirerek kodunuzu daha okunabilir ve hata ayıklamayı kolaylaştırın. Adım adım rehberiniz.

Python Nesneleri Neden “Konuşmalı”? __str__() ve __repr__() Nedir?

Python, nesne yönelimli bir programlama dilidir ve neredeyse her şey bir nesnedir. Kendi özel sınıflarınızı tanımladığınızda, bu sınıflardan türettiğiniz nesneleri ekrana yazdırmak veya hata ayıklama sırasında incelemek isteyebilirsiniz. Ancak varsayılan olarak, Python nesneleri için pek de bilgilendirici olmayan bir çıktı sunar. Örneğin:

class Kitap:
    def __init__(self, baslik, yazar, sayfa_sayisi):
        self.baslik = baslik
        self.yazar = yazar
        self.sayfa_sayisi = sayfa_sayisi

kitap1 = Kitap("Sefiller", "Victor Hugo", 1488)
print(kitap1)
  

Bu kodu çalıştırdığınızda muhtemelen şöyle bir çıktı alacaksınız:

<__main__.Kitap object at 0x103a89e10>
  

Bu çıktı, nesnenin bellekteki adresini gösterir ve geliştiriciye veya son kullanıcıya nesnenin içeriği hakkında hiçbir bilgi vermez. İşte bu problemi çözmek için Python, nesnelerin string temsilini özelleştirmemize olanak tanıyan iki özel metot sunar: __str__() ve __repr__(). Bu metotlar, nesnenizin kendisini bir string olarak nasıl ifade edeceğini belirlemenizi sağlar, böylece kodunuz daha anlaşılır, hata ayıklama süreçleriniz daha verimli hale gelir.

__str__() Metodu: Kullanıcı Dostu Temsil

__str__() metodu, bir nesnenin “resmi olmayan” veya “kullanıcı dostu” string temsilini döndürmek için tasarlanmıştır. Genellikle print() fonksiyonu veya str() yerleşik fonksiyonu çağrıldığında bu metot kullanılır. Amacı, son kullanıcıların veya diğer geliştiricilerin kolayca anlayabileceği, okunabilir bir çıktı sağlamaktır. Bu çıktı, nesnenin tüm detaylarını içermek zorunda değildir; daha ziyade, nesnenin temel özelliklerini özetleyen kısa ve öz bir açıklama olmalıdır. Örneğin, bir Kitap nesnesi için __str__() metodu, “Sefiller (Victor Hugo)” gibi bir çıktı verebilir.

__repr__() Metodu: Geliştirici Dostu ve Kesin Temsil

Öte yandan, __repr__() metodu, bir nesnenin “resmi” veya “geliştirici dostu” string temsilini döndürmek için kullanılır. Bu metot, genellikle repr() yerleşik fonksiyonu veya interaktif Python konsolunda bir nesne doğrudan yazıldığında çağrılır. __repr__()‘ın temel amacı, geliştiricinin nesneyi tekrar oluşturmak için kullanabileceği kesin bir string çıktısı sağlamaktır. İdeal olarak, eval(repr(obj)) == obj koşulunun doğru olması beklenir (tabii obj‘nin içeriği buna uygunsa). Bu, hata ayıklama ve loglama süreçlerinde son derece değerlidir çünkü nesnenin tam durumunu gösterir. Örneğin, bir Kitap nesnesi için __repr__() metodu, “Kitap(baslik='Sefiller', yazar='Victor Hugo', sayfa_sayisi=1488)” gibi bir çıktı verebilir.

Her iki metot da bir string döndürmelidir. Eğer bir sınıfta ne __str__() ne de __repr__() tanımlanmamışsa, Python varsayılan olarak nesnenin bellek adresini içeren o tanıdık çıktıyı verecektir. Ancak eğer sadece __repr__() tanımlanmış ve __str__() tanımlanmamışsa, print() ve str() fonksiyonları otomatik olarak __repr__() çıktısını kullanır. Bu, Python’ın esnek ve geliştirici dostu yaklaşımının bir parçasıdır. Bu mekanizma sayesinde, en azından bir geliştirici dostu temsil tanımladığınızda, kullanıcı dostu bir temsiliniz olmasa bile varsayılan olarak anlamlı bir çıktı elde edersiniz. Şimdi gelin, bu metotları adım adım nasıl uygulayacağımıza bakalım.

__str__() Metodunu Nasıl Uygularız? Pratik Bir Örnek

__str__() metodunu uygulamak oldukça basittir. Sınıfınızın içine __str__ adında bir metot tanımlamanız ve bu metodun bir string döndürmesini sağlamanız yeterlidir. İşte Kitap sınıfımız için bir örnek:

class Kitap:
    def __init__(self, baslik, yazar, sayfa_sayisi):
        self.baslik = baslik
        self.yazar = yazar
        self.sayfa_sayisi = sayfa_sayisi

    def __str__(self):
        """
        Kullanıcı dostu string temsilini döndürür.
        print() veya str() fonksiyonu ile çağrılır.
        """
        return f"{self.baslik} ({self.yazar})"

# Nesne oluşturma
kitap1 = Kitap("Sefiller", "Victor Hugo", 1488)
kitap2 = Kitap("Suç ve Ceza", "Fyodor Dostoyevski", 672)

# print() ile çıktı alma
print(kitap1)
print(str(kitap2))
  

Yukarıdaki kodu çalıştırdığınızda alacağınız çıktı aşağıdaki gibi olacaktır:

Sefiller (Victor Hugo)
Suç ve Ceza (Fyodor Dostoyevski)
  

Gördüğünüz gibi, artık nesnelerimiz bellek adresleri yerine anlamlı bilgilerle temsil ediliyor. Bu, özellikle bir listede veya başka bir veri yapısında birçok Kitap nesnesi olduğunda ve bunları hızlıca gözden geçirmek istediğinizde çok işe yarar. Son kullanıcıya gösterilecek raporlarda, log mesajlarında veya hata bildirimlerinde bu tür kullanıcı dostu çıktılar, uygulamanızın anlaşılırlığını büyük ölçüde artırır. Bu sayede, kodunuzu kullanan diğer kişiler veya uygulamanızın son kullanıcıları, nesnelerin neyi temsil ettiğini anında kavrayabilirler. Unutmayın, __str__()‘ın amacı okunabilirlik ve özet bilgidir.

__repr__() Metodunu Nasıl Uygularız? Geliştirici İçin Netlik

Şimdi de __repr__() metodunu Kitap sınıfımıza ekleyelim. Bu metot, geliştiricilere yönelik olduğu için, nesnenin tüm önemli özelliklerini içermeli ve mümkünse nesneyi tekrar oluşturmak için kullanılabilecek bir formatta olmalıdır. İşte bir örnek:

class Kitap:
    def __init__(self, baslik, yazar, sayfa_sayisi):
        self.baslik = baslik
        self.yazar = yazar
        self.sayfa_sayisi = sayfa_sayisi

    def __repr__(self):
        """
        Geliştirici dostu, kesin string temsilini döndürür.
        repr() fonksiyonu veya interaktif konsolda çağrılır.
        """
        return f"Kitap(baslik='{self.baslik}', yazar='{self.yazar}', sayfa_sayisi={self.sayfa_sayisi})"

# Nesne oluşturma
kitap1 = Kitap("Sefiller", "Victor Hugo", 1488)

# repr() ile çıktı alma
print(repr(kitap1))

# İnteraktif konsolda doğrudan nesneyi yazma
# >>> kitap1
  

Bu kodun çıktısı şu şekilde olacaktır:

Kitap(baslik='Sefiller', yazar='Victor Hugo', sayfa_sayisi=1488)
  

Eğer bu kodu interaktif bir Python konsolunda çalıştırıp sadece kitap1 yazıp Enter tuşuna basarsanız, yine aynı çıktıyı göreceksiniz. Bu çıktı, nesnenin sınıf adını ve tüm kurucu argümanlarını içerdiği için, nesnenin durumunu açıkça gösterir. Hata ayıklama sırasında, bir nesnenin anlık durumunu hızla görmek istediğinizde veya log dosyalarına nesne bilgilerini kaydederken __repr__() çıktısı paha biçilmezdir. Bu temsil sayesinde, bir problemle karşılaştığınızda, nesnenin hangi değerlere sahip olduğunu anında anlayabilir ve sorunun kaynağını daha hızlı tespit edebilirsiniz. Güçlü bir __repr__() uygulaması, özellikle karmaşık sistemlerde geliştirme sürecini önemli ölçüde hızlandırır ve hataların izini sürmeyi kolaylaştırır.

__str__() ve __repr__() Arasındaki Temel Farklar Nelerdir?

Bu iki metot arasındaki farkı net bir şekilde anlamak, Python’da nesne temsillerini doğru kullanmanın anahtarıdır. Her ikisi de bir nesnenin string temsilini döndürse de, hitap ettikleri kitle ve amaçları farklıdır. Aşağıdaki tablo, bu farkları özetlemektedir:

Bu farkları göz önünde bulundurarak, aynı Kitap sınıfında hem __str__() hem de __repr__() metotlarını tanımladığımızda nasıl bir çıktı alacağımıza bakalım:

class Kitap:
    def __init__(self, baslik, yazar, sayfa_sayisi):
        self.baslik = baslik
        self.yazar = yazar
        self.sayfa_sayisi = sayfa_sayisi

    def __str__(self):
        return f"{self.baslik} ({self.yazar})"

    def __repr__(self):
        return f"Kitap(baslik='{self.baslik}', yazar='{self.yazar}', sayfa_sayisi={self.sayfa_sayisi})"

kitap1 = Kitap("Sefiller", "Victor Hugo", 1488)

print(kitap1)         # __str__() çağrılır
print(str(kitap1))    # __str__() çağrılır
print(repr(kitap1))   # __repr__() çağrılır

# İnteraktif konsolda:
# >>> kitap1          # __repr__() çağrılır
  

Çıktı:

Sefiller (Victor Hugo)
Sefiller (Victor Hugo)
Kitap(baslik='Sefiller', yazar='Victor Hugo', sayfa_sayisi=1488)
  

Bu örnek, her iki metodun da aynı nesne üzerinde nasıl farklı amaçlar için kullanılabileceğini açıkça göstermektedir. Birini tanımladığınızda diğerinin otomatik olarak çağrılma durumu, esneklik sağlarken, her ikisini de tanımlamak, kodunuzun farklı bağlamlarda en uygun string temsilini sunmasını garanti eder. Bu ayrımı iyi anlamak, özellikle büyük ve karmaşık projelerde hata ayıklama ve kodun anlaşılırlığı açısından kritik bir rol oynar.

Gerçek Dünya Senaryoları: Hangi Durumda Hangisini Tercih Etmeliyiz?

Teorik bilgilerin ötesinde, bu metotları gerçek dünya uygulamalarında nerede ve nasıl kullanacağımızı bilmek önemlidir. İşte birkaç vaka analizi:

Vaka Analizi 1: Loglama ve Hata Ayıklama Süreçleri

Bir uygulamanın çalışması sırasında oluşan olayları kaydetmek (loglama) veya bir hatanın nedenini bulmaya çalışmak (hata ayıklama), geliştiricilerin günlük işlerinin önemli bir parçasıdır. Bu senaryolarda, nesnelerin tam ve kesin bir temsiline ihtiyacımız vardır ki, sorunun kaynağını net bir şekilde anlayabilelim. İşte bu noktada __repr__() metodu parlar.

Örneğin, bir e-ticaret uygulamasında bir Siparis nesnesi üzerinde işlem yaparken bir hata oluştuğunu düşünün. Log dosyasına sadece “Sipariş işlenirken hata oluştu” yazmak yeterli değildir. Hangi sipariş, hangi ürünler, hangi kullanıcı… Bu bilgileri içeren bir log kaydı çok daha faydalı olacaktır:

import logging

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

class Siparis:
    def __init__(self, siparis_id, musteri_id, urunler, toplam_fiyat):
        self.siparis_id = siparis_id
        self.musteri_id = musteri_id
        self.urunler = urunler
        self.toplam_fiyat = toplam_fiyat

    def __repr__(self):
        return f"Siparis(id={self.siparis_id}, musteri_id={self.musteri_id}, urunler={self.urunler}, toplam_fiyat={self.toplam_fiyat})"

    def __str__(self):
        return f"Sipariş #{self.siparis_id} - Müşteri: {self.musteri_id} - Toplam: {self.toplam_fiyat:.2f} TL"

def siparis_isleme(siparis):
    try:
        # Karmaşık sipariş işleme mantığı
        if siparis.toplam_fiyat < 0:
            raise ValueError("Sipariş toplam fiyatı negatif olamaz!")
        logging.info(f"Sipariş başarıyla işlendi: {siparis}") # __str__ çağrılır
    except ValueError as e:
        logging.error(f"Sipariş işlenirken hata oluştu: {repr(siparis)}. Hata: {e}") # __repr__ çağrılır

siparis_gecerli = Siparis(101, 5001, ["Laptop", "Mouse"], 2500.00)
siparis_hatali = Siparis(102, 5002, ["Klavye"], -150.00)

siparis_isleme(siparis_gecerli)
siparis_isleme(siparis_hatali)
  

Bu örnekte, başarılı bir işlemde kullanıcı dostu __str__() çıktısını kullanırken, hata durumunda geliştiriciye tüm detayları sunan __repr__() çıktısını logluyoruz. Bu sayede, log dosyalarına baktığımızda, hatalı siparişin tüm detaylarını anında görebilir ve sorunu çok daha hızlı çözebiliriz.

Vaka Analizi 2: Kullanıcı Arayüzü (UI) Çıktıları ve Raporlama

Kullanıcıların doğrudan etkileşimde bulunduğu arayüzlerde veya onlara sunulan raporlarda, karmaşık ve teknik detaylar içeren çıktılardan kaçınmak gerekir. Bu gibi durumlarda, __str__() metodu devreye girer. Kullanıcılar, nesnenin teknik yapısından ziyade, onun anlamını ve ana özelliklerini görmek isterler.

Örneğin, bir kütüphane yönetim sisteminde kitap listesi gösterirken:

class Kitap:
    def __init__(self, baslik, yazar, yayin_yili):
        self.baslik = baslik
        self.yazar = yazar
        self.yayin_yili = yayin_yili

    def __str__(self):
        return f"'{self.baslik}' ({self.yazar}, {self.yayin_yili})"

    def __repr__(self):
        return f"Kitap(baslik='{self.baslik}', yazar='{self.yazar}', yayin_yili={self.yayin_yili})"

kitaplar = [
    Kitap("1984", "George Orwell", 1949),
    Kitap("Cesur Yeni Dünya", "Aldous Huxley", 1932),
    Kitap("Fahrenheit 451", "Ray Bradbury", 1953)
]

print("Kütüphanedeki Kitaplar:")
for kitap in kitaplar:
    print(f"- {kitap}") # __str__ otomatik çağrılır
  

Çıktı:

Kütüphanedeki Kitaplar:
- '1984' (George Orwell, 1949)
- 'Cesur Yeni Dünya' (Aldous Huxley, 1932)
- 'Fahrenheit 451' (Ray Bradbury, 1953)
  

Bu çıktı, son kullanıcı için son derece okunabilir ve bilgilendiricidir. Kullanıcı, kitabın tüm teknik detaylarını bilmek zorunda kalmadan, aradığı bilgiyi kolayca bulabilir. Benzer şekilde, bir web sayfasında ürün kartları, bir mobil uygulamada profil bilgileri veya bir e-posta bildirimindeki özet bilgiler gibi durumlarda __str__() kullanımı, kullanıcı deneyimini doğrudan iyileştirir.

Vaka Analizi 3: Veri Yapılarının Temsili ve Hata Tespiti

Karmaşık veri yapıları (örneğin, bağlı listeler, ağaçlar, grafikler) ile çalışırken, bu yapıların elemanlarının doğru bir şekilde temsil edilmesi hem geliştirme hem de hata ayıklama açısından hayati öneme sahiptir. Burada hem __str__() hem de __repr__() farklı roller üstlenebilir.

class Dugum:
    def __init__(self, veri):
        self.veri = veri
        self.sonraki = None # Bağlı liste için

    def __repr__(self):
        # Geliştirici için: Dugumun tam durumu
        return f"Dugum(veri={repr(self.veri)}, sonraki={repr(self.sonraki)})"

    def __str__(self):
        # Kullanıcı için: Sadece Dugumun verisi
        return f"Veri: {self.veri}"

# Bir bağlı liste oluşturalım
dugum_a = Dugum("A")
dugum_b = Dugum("B")
dugum_c = Dugum("C")

dugum_a.sonraki = dugum_b
dugum_b.sonraki = dugum_c

print("Kullanıcı Dostu Çıktı:")
current = dugum_a
while current:
    print(current) # __str__ çağrılır
    current = current.sonraki

print("\nGeliştirici Dostu Çıktı (Hata Ayıklama İçin):")
print(repr(dugum_a)) # __repr__ çağrılır
  

Çıktı:

Kullanıcı Dostu Çıktı:
Veri: A
Veri: B
Veri: C

Geliştirici Dostu Çıktı (Hata Ayıklama İçin):
Dugum(veri='A', sonraki=Dugum(veri='B', sonraki=Dugum(veri='C', sonraki=None)))
  

Bu örnekte, __str__() bağlı listenin elemanlarını basitçe listelerken, __repr__() tüm yapıyı (hangi düğümün kime işaret ettiği dahil) tek bir satırda gösterir. Bu, özellikle karmaşık bağlantılar veya hatalı referanslar olduğunda, sorunu hızla tespit etmek için çok değerli bir araçtır. Her iki metodun da doğru kullanılması, veri yapılarının hem anlaşılır hem de hata ayıklanabilir olmasını sağlar.

İleri Düzey Kullanım İpuçları ve En İyi Uygulamalar

__str__() ve __repr__() metotlarını temel düzeyde anladık, ancak daha verimli ve güçlü kullanımlar için bazı ileri düzey ipuçları ve en iyi uygulamalar bulunmaktadır:

1. eval(repr(obj)) Prensibi

İdeal bir __repr__() uygulamasında, çıktının nesneyi yeniden oluşturmak için kullanılabilecek geçerli bir Python ifadesi olması beklenir. Yani, eval(repr(obj)) ifadesinin orijinal obj'ye eşdeğer bir nesne döndürmesi hedeflenir. Bu, özellikle nesneleri dinamik olarak oluşturmanız veya kaydetmeniz gereken durumlarda çok faydalıdır. Ancak, bu her zaman mümkün veya pratik olmayabilir, özellikle karmaşık nesneler veya dış kaynaklara bağımlı nesneler için. Yine de bu prensibi aklınızda tutmak, __repr__() metodunuzu daha güçlü kılar.

class Nokta:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        return f"Nokta(x={self.x}, y={self.y})"

p1 = Nokta(10, 20)
p1_repr = repr(p1) # "Nokta(x=10, y=20)"
p2 = eval(p1_repr)  # p2 artık Nokta(x=10, y=20) nesnesidir

print(p1)
print(p2)
print(p1.x == p2.x and p1.y == p2.y)
  

Çıktı:

Nokta(x=10, y=20)
Nokta(x=10, y=20)
True
  

2. dataclasses Modülü ile Otomatik __repr__

Python 3.7 ve sonrası sürümlerde tanıtılan dataclasses modülü, veri tutan sınıflar için boilerplate kodu azaltmanın harika bir yoludur. Bu modül, __init__, __repr__, __eq__ gibi özel metotları otomatik olarak oluşturabilir. Bu, özellikle veri sınıflarınızda __repr__()'ı manuel olarak yazma zahmetinden kurtarır.

from dataclasses import dataclass

@dataclass
class Urun:
    ad: str
    fiyat: float
    stok_miktari: int = 0 # Varsayılan değer

urun1 = Urun("Laptop", 1200.50, 50)
print(repr(urun1)) # Otomatik olarak oluşturulan __repr__ çağrılır
  

Çıktı:

Urun(ad='Laptop', fiyat=1200.5, stok_miktari=50)
  

Bu, kodunuzu daha kısa, daha temiz ve daha az hataya açık hale getirir.

3. Performans Etkileri ve Karmaşık Nesneler

__str__() veya __repr__() metotları içinde çok karmaşık veya zaman alıcı işlemler yapmaktan kaçının. Bu metotlar sıkça çağrılabileceği için (özellikle loglama ve hata ayıklama sırasında), performans darboğazlarına neden olabilirler. Eğer nesnenizin string temsilini oluşturmak pahalı bir işlemse, bunu cache'lemeyi düşünebilir veya sadece gerektiğinde hesaplamayı yapabilirsiniz.

4. Tutarlılık ve Her İkisini de Tanımlama

Genel bir en iyi uygulama olarak, bir sınıf tanımladığınızda hem __str__() hem de __repr__() metotlarını tanımlamanız önerilir. Bu, kodunuzun farklı bağlamlarda (kullanıcı arayüzü, loglama, hata ayıklama) en uygun string temsilini sunmasını sağlar. Eğer birini tanımlayacak vaktiniz varsa, önceliği genellikle __repr__()'a vermelisiniz, çünkü __str__() tanımlı olmadığında Python varsayılan olarak __repr__()'ı kullanacaktır.

Mobil Uyumlu Çıktılar İçin Dikkat Edilmesi Gerekenler

Makalenin başında bahsettiğimiz mobil uyumluluk konusu, doğrudan __str__() ve __repr__() metotlarının çıktısıyla ilgili olmasa da, bu çıktıların bir web veya mobil arayüzde nasıl görüntülendiğiyle dolaylı olarak ilişkilidir. Özellikle __repr__() çıktısı gibi uzun ve detaylı stringler, küçük ekranlarda okunması zor olabilir. Bu nedenle, bu stringleri bir kullanıcı arayüzünde gösterirken responsive tasarım prensiplerini uygulamak önemlidir. Örneğin, CSS media query'leri kullanarak ekran boyutuna göre metin boyutunu küçültebilir veya uzun stringleri kaydırılabilir alanlara yerleştirebilirsiniz. Aşağıdaki basit CSS örneği, bu tür bir yaklaşıma işaret eder:

<style>
  .output-container {
    white-space: pre-wrap; /* Uzun metinleri sarar */
    word-wrap: break-word; /* Kelimeleri böler */
    overflow-x: auto; /* Yatay kaydırma çubuğu ekler */
    padding: 10px;
    border: 1px solid #ccc;
    background-color: #f9f9f9;
  }

  @media (max-width: 600px) {
    .output-container {
      font-size: 0.9em; /* Küçük ekranlarda font boyutunu küçült */
      max-height: 200px; /* Belirli bir yükseklik sınırı */
    }
  }
</style>

<div class="output-container">
  <p>Bu alan, __repr__ çıktısı gibi uzun bir metni içerebilir. Mobil cihazlarda daha okunaklı olması için stiller uygulanmıştır.</p>
  <pre><code>Kitap(baslik='Çok Uzun Bir Başlık Buraya Gelebilir ve Küçük Ekranda Sıkıntı Yaratabilir', yazar='Yazar Adı', sayfa_sayisi=9999)</code></pre>
</div>
  

Bu, Python nesne temsillerinizin, farklı cihazlarda da kullanıcı dostu kalmasını sağlamak için tasarım tarafında alabileceğiniz bir önlemdir.

Sonuç

Python'daki __str__() ve __repr__() metotları, nesnelerinizin string temsillerini özelleştirerek kodunuzun okunabilirliğini, hata ayıklama yeteneğini ve genel kalitesini önemli ölçüde artıran güçlü araçlardır. __str__(), kullanıcı dostu ve özet bir çıktı sağlarken, __repr__() geliştirici dostu, kesin ve nesneyi yeniden oluşturmaya yönelik bir temsil sunar. Her iki metodu da doğru bağlamda kullanmak, hem sizin hem de ekibinizin geliştirme sürecini daha verimli hale getirir.

Unutmayın, iyi yazılmış __str__() ve __repr__() metotları, sadece birer string döndürmekten çok daha fazlasıdır; bunlar, kodunuzun "konuşmasını" ve kendisini daha iyi ifade etmesini sağlayan iletişim köprüleridir. Bu metotları uygulayarak, Python projelerinizde daha temiz, daha anlaşılır ve daha sürdürülebilir bir kod tabanı oluşturma yolunda önemli bir adım atmış olacaksınız.

Sıkça Sorulan Sorular (SSS)

1. __str__() tanımlamazsam ne olur?

   Eğer bir sınıfta __str__() metodu tanımlanmamışsa, Python varsayılan olarak __repr__() metodunu çağırır (eğer tanımlıysa). Eğer __repr__() da tanımlı değilse, nesnenin varsayılan bellek adresini içeren çıktıyı (<__main__.MyClass object at 0x...>) görürsünüz.

2. __repr__() tanımlamazsam ne olur?

   Eğer bir sınıfta __repr__() metodu tanımlanmamışsa, Python nesnenin varsayılan bellek adresini içeren çıktıyı (<__main__.MyClass object at 0x...>) kullanır. Bu, özellikle interaktif konsolda veya hata ayıklama sırasında nesnenin içeriği hakkında hiçbir bilgi alamayacağınız anlamına gelir.

3. Her zaman hem __str__() hem de __repr__() tanımlamak zorunda mıyım?

   Zorunda değilsiniz, ancak genellikle iyi bir uygulamadır. Her ikisini de tanımlamak, nesnenizin farklı bağlamlarda (kullanıcıya yönelik çıktılar ve geliştiriciye yönelik hata ayıklama/loglama) en uygun string temsilini sunmasını sağlar. Eğer sadece birini tanımlayacaksanız, genellikle __repr__()'ı tanımlamak daha faydalıdır, çünkü __str__() tanımlı olmadığında print() onu kullanabilir.

4. str() ve repr() fonksiyonları ile __str__() ve __repr__() metotları arasındaki fark nedir?

   str() ve repr() Python'ın yerleşik fonksiyonlarıdır ve bir nesnenin string temsilini almak için kullanılırlar. Bu fonksiyonlar, arka planda sırasıyla nesnenin __str__() ve __repr__() özel metotlarını çağırır. Yani, str(obj) aslında obj.__str__()'ı, repr(obj) ise obj.__repr__()'ı çağırır. Fonksiyonlar, bu özel metotların çağrılma arayüzüdür.