Tuple ve Immutability | Ücretsiz Python Programlama: Sıfırdan İleri Seviyeye Kursu

Tuple (demet), Python'un ikinci sıralı veri yapısı. Listeyle neredeyse aynı — sıralı, indekslenebilir, her tür veriyi barındırabilir. Tek ama çok kritik bir fark var: tuple değiştirilemez (immutable). Bir kez oluşturulduktan sonra eleman ekleyemez, çıkaramaz, değiştiremezsin.

"Neden değiştirilemez bir liste isterim ki?" diye sorabilirsin. Haklı bir soru. Cevabı şu analoji ile açıklayayım: Tuple, bir doğum sertifikası gibidir. Adın, doğum tarihin, doğduğun yer — bunlar bir kez yazıldıktan sonra değişmez (resmi olarak). Listeye ise daha çok bir yapılacaklar listesi gibi bak — sürekli ekleme yaparsın, çıkarırsın, sırasını değiştirirsin. İkisi de "liste" ama doğaları farklı. Bazı verilerin değişmemesi gerekir — işte tuple bunun garantisini verir.

Tuple Oluşturma

Tuple oluşturmanın birden fazla yolu var. En önemlisi şu: virgül tuple yapar, parantez değil.

# Parantezle (en yaygın)
koordinat = (3, 7)
renkler = ("kırmızı", "yeşil", "mavi")
karisik = (42, "merhaba", 3.14, True)

# Parantezsiz — virgül tuple yapar!
sayi_tuple = 1, 2, 3
print(type(sayi_tuple))  # <class 'tuple'>

# Boş tuple
bos = ()
bos2 = tuple()

# Tek elemanlı tuple — virgül ZORUNLU!
tek = (42,)    # ✅ Tuple
yanlis = (42)  # ❌ Bu sadece int! Parantez içinde sayı.

print(type(tek))     # <class 'tuple'>
print(type(yanlis))  # <class 'int'>

Tek Elemanlı Tuple Tuzağı

Bu Python'ın en bilinen gotcha'larından biri. Parantez tek başına tuple yapmaz, virgül yapar:

a = ("merhaba",)  # ✅ Tuple
b = ("merhaba")   # ❌ String!
c = "merhaba",    # ✅ Tuple (virgül var)

print(type(a))  # <class 'tuple'>
print(type(b))  # <class 'str'>
print(type(c))  # <class 'tuple'>

# f-string ve format'ta dikkat
print(f"Sonuç: {(42,)}")   # Sonuç: (42,)
print(f"Sonuç: {(42)}")    # Sonuç: 42 — tuple değil!

tuple() ile Dönüştürme

Herhangi bir iterable'dan tuple oluşturabilirsin:

# Listeden tuple
liste = [1, 2, 3]
t = tuple(liste)
print(t)  # (1, 2, 3)

# String'den tuple — her karakter bir eleman
harfler = tuple("Python")
print(harfler)  # ('P', 'y', 't', 'h', 'o', 'n')

# Range'den tuple
sayilar = tuple(range(5))
print(sayilar)  # (0, 1, 2, 3, 4)

# Set'ten tuple (sıra garanti değil!)
kume = {3, 1, 2}
t = tuple(kume)
print(t)  # Sıra değişebilir

# Generator'dan tuple
kareler = tuple(x**2 for x in range(5))
print(kareler)  # (0, 1, 4, 9, 16)

# Dict'ten tuple (sadece key'ler)
d = {"a": 1, "b": 2}
print(tuple(d))          # ('a', 'b')
print(tuple(d.values())) # (1, 2)
print(tuple(d.items()))  # (('a', 1), ('b', 2))

Tuple İndeksleme ve Dilimleme

Liste ile tamamen aynı söz dizimi. İndeksler 0'dan başlar, negatif indeksler sondan sayar:

meyveler = ("elma", "armut", "muz", "çilek", "kivi")

# İndeksleme
print(meyveler[0])    # elma
print(meyveler[-1])   # kivi
print(meyveler[2])    # muz

# Dilimleme — yeni tuple döndürür
print(meyveler[1:3])  # ('armut', 'muz')
print(meyveler[:2])   # ('elma', 'armut')
print(meyveler[::2])  # ('elma', 'muz', 'kivi')
print(meyveler[::-1]) # ('kivi', 'çilek', 'muz', 'armut', 'elma')

Dilimleme her zaman yeni bir tuple döndürür.

# İndeks dizi gösterimi
#  Pozitif:  0       1       2       3       4
#          ("elma", "armut", "muz", "çilek", "kivi")
#  Negatif: -5      -4      -3      -2      -1

Ama Değiştiremezsin!

meyveler = ("elma", "armut", "muz")

# ❌ Bunların hepsi hata verir!
meyveler[0] = "portakal"  # TypeError: 'tuple' object does not support item assignment
meyveler.append("çilek")  # AttributeError: 'tuple' object has no attribute 'append'
del meyveler[1]            # TypeError: 'tuple' object doesn't support item deletion
meyveler.sort()            # AttributeError: 'tuple' object has no attribute 'sort'

Tuple'a eleman ekleyemez, silemez, değiştiremez, sıralayamazsın. Bu onun temel özelliği ve varlık sebebi.

Tuple İçinde Mutable Nesne — Dikkatli Ol!

# Tuple içindeki mutable nesneler DEĞİŞEBİLİR!
t = ([1, 2], [3, 4])

t[0].append(5)
print(t)  # ([1, 2, 5], [3, 4]) — İç liste değişti!

# Ama referansı değiştiremezsin
# t[0] = [9, 9, 9]  # TypeError!

Tuple referansları korur, referansların gösterdiği nesneyi değil. Tuple diyor ki "bu iki kutu hep aynı kutu olarak kalacak" ama kutunun içine bir şey koyman (eğer kutu mutable ise) mümkün.

⚠️ Dikkat: Tuple içine mutable nesne (liste, dict) koymak kafa karıştırıcı davranışlara yol açabilir. Tuple'ın "değişmez" olması, içindeki her şeyin değişmez olduğu anlamına gelmez. Eğer tam immutability istiyorsan, tuple içine sadece immutable nesneler (int, str, float, tuple) koy. Ayrıca mutable eleman içeren tuple hashable değildir — dict key veya set elemanı olamaz.

Tuple Unpacking

Tuple unpacking, Python'un en zarif ve en sık kullanılan özelliklerinden biri. Bir tuple'ın elemanlarını ayrı değişkenlere atayabilirsin:

# Temel unpacking
koordinat = (3, 7)
x, y = koordinat
print(f"x={x}, y={y}")  # x=3, y=7

# Üçlü
isim, yas, sehir = ("Ahmet", 25, "İstanbul")
print(f"{isim}, {yas} yaşında, {sehir}'da yaşıyor")

# Eleman sayısı eşleşmezse hata!
# a, b = (1, 2, 3)  # ValueError: too many values to unpack
# a, b, c = (1, 2)  # ValueError: not enough values to unpack

Fonksiyon Return Değerinde Unpacking

Bu, tuple unpacking'in en yaygın kullanım alanı:

def bolme_islemi(a, b):
    bolum = a // b
    kalan = a % b
    return bolum, kalan  # Aslında tuple döndürüyor: (bolum, kalan)

# Unpack ederek al
b, k = bolme_islemi(17, 5)
print(f"Bölüm: {b}, Kalan: {k}")  # Bölüm: 3, Kalan: 2

# divmod() built-in fonksiyonu da tuple döndürür
b, k = divmod(17, 5)
print(f"Bölüm: {b}, Kalan: {k}")  # Bölüm: 3, Kalan: 2

Python'un standart kütüphanesinde tuple döndüren pek çok fonksiyon var:

# os.path.splitext — dosya adı ve uzantı
import os
isim, uzanti = os.path.splitext("belge.pdf")
print(isim, uzanti)  # belge .pdf

# str.partition — bölme
once, ayrac, sonra = "merhaba dünya".partition(" ")
print(once, sonra)  # merhaba dünya

Yıldızlı Unpacking (Extended Unpacking)

first, *middle, last = (1, 2, 3, 4, 5)
print(first)   # 1
print(middle)  # [2, 3, 4] — liste olarak toplar!
print(last)    # 5

# Sadece ilk ve son
head, *_, tail = (10, 20, 30, 40, 50)
print(head, tail)  # 10 50
# _ kullanılmayan değişken konvansiyonu

# Sadece ilkini al
first, *rest = (1, 2, 3, 4, 5)
print(first)  # 1
print(rest)   # [2, 3, 4, 5]

# Sadece sonuncuyu al
*bas, son = (1, 2, 3, 4, 5)
print(bas)  # [1, 2, 3, 4]
print(son)  # 5

Swap — Geçici Değişken Gerekmez

# Python'da swap çok zarif
a, b = 5, 10
a, b = b, a
print(a, b)  # 10, 5

# Perde arkasında: sağ taraf önce tuple olarak oluşturulur (b, a) → (10, 5)
# Sonra unpacking yapılır: a, b = (10, 5)

# Üçlü swap bile mümkün
a, b, c = 1, 2, 3
a, b, c = c, a, b
print(a, b, c)  # 3, 1, 2

for Döngüsünde Unpacking

ogrenciler = [
    ("Ahmet", 85, "A"),
    ("Ayşe", 92, "B"),
    ("Mehmet", 78, "A"),
]

for isim, not_, sinif in ogrenciler:
    durum = "Geçti" if not_ >= 60 else "Kaldı"
    print(f"[{sinif}] {isim}: {not_} ({durum})")

# enumerate ile kombine
for i, (isim, not_, sinif) in enumerate(ogrenciler, 1):
    print(f"{i}. {isim} - Sınıf {sinif}")

Dikkat: enumerate ile birlikte kullanırken iç tuple'ı paranteze al: for i, (isim, not_, sinif).

Neden Tuple Kullanılır?

1. Hashable — Dictionary Key Olabilir

Bu tuple'ın en önemli teknik avantajı. Hashable olduğu için dict key ve set elemanı olarak kullanılabilir. Liste asla:

# ✅ Tuple key olabilir
lokasyonlar = {
    (41.01, 28.97): "İstanbul",
    (39.93, 32.86): "Ankara",
    (38.42, 27.14): "İzmir",
}

print(lokasyonlar[(41.01, 28.97)])  # İstanbul

# ❌ Liste key olamaz!
# d = {[1, 2]: "değer"}  # TypeError: unhashable type: 'list'

# Pratik: iki boyutlu ızgara (grid) için mükemmel
grid = {}
for x in range(3):
    for y in range(3):
        grid[(x, y)] = f"hücre_{x}_{y}"

print(grid[(1, 2)])  # hücre_1_2

2. Set Elemanı Olabilir

# ✅ Tuple'lar set'e eklenebilir
noktalar = {(0, 0), (1, 1), (2, 2)}
noktalar.add((3, 3))
print((1, 1) in noktalar)  # True — O(1) arama!

# ❌ Liste set'e eklenemez
# s = {[1, 2]}  # TypeError: unhashable type: 'list'

# Pratik: ziyaret edilen konumları takip
ziyaret_edildi = set()
konum = (0, 0)
ziyaret_edildi.add(konum)

yeni_konum = (1, 0)
if yeni_konum not in ziyaret_edildi:
    print("Yeni konum!")
    ziyaret_edildi.add(yeni_konum)

3. Fonksiyon Return Değeri

Python fonksiyonları birden fazla değer döndürmek için doğal olarak tuple kullanır:

def istatistik(sayilar):
    n = len(sayilar)
    ortalama = sum(sayilar) / n
    varyans = sum((x - ortalama) ** 2 for x in sayilar) / n
    return min(sayilar), max(sayilar), ortalama, varyans ** 0.5

mn, mx, ort, std = istatistik([4, 7, 2, 9, 1])
print(f"Min: {mn}, Max: {mx}, Ort: {ort:.1f}, Std: {std:.2f}")

4. Veri Bütünlüğü Garantisi

# Haftanın günleri hiç değişmemeli
GUNLER = ("Pazartesi", "Salı", "Çarşamba", "Perşembe", "Cuma", "Cumartesi", "Pazar")

# Sabitler tuple olmalı — yanlışlıkla değiştirmek imkansız
IZIN_VERILEN_UZANTILAR = (".jpg", ".png", ".gif", ".webp")
HTTP_METODLARI = ("GET", "POST", "PUT", "DELETE", "PATCH")
AYLAR = ("Ocak", "Şubat", "Mart", "Nisan", "Mayıs", "Haziran",
         "Temmuz", "Ağustos", "Eylül", "Ekim", "Kasım", "Aralık")

# Fonksiyon argümanlarının yanlışlıkla değişmesini önle
def rapor_olustur(basliklar):
    for b in basliklar:
        print(f"--- {b} ---")
    # basliklar tuple ise, fonksiyon içinde değiştirilmesinden emin olursun

5. Performans Avantajı

Tuple'lar listelerden biraz daha hızlı oluşturulur ve daha az bellek kullanır:

import sys

liste = [1, 2, 3, 4, 5]
demet = (1, 2, 3, 4, 5)

print(f"Liste: {sys.getsizeof(liste)} byte")  # ~120 byte
print(f"Tuple: {sys.getsizeof(demet)} byte")  # ~80 byte

Fark küçük görünebilir ama milyonlarca eleman olduğunda önemli hale gelir. Ayrıca Python tuple'ları intern edebilir (aynı tuple'ı birden fazla yerde tek kopya olarak saklar), bu da ek bellek tasarrufu sağlar.

import timeit

# Oluşturma hızı
print("Liste:", timeit.timeit("[1, 2, 3, 4, 5]", number=1_000_000))
print("Tuple:", timeit.timeit("(1, 2, 3, 4, 5)", number=1_000_000))
# Tuple genellikle 5-10x daha hızlı oluşturulur

Named Tuple: İsimli Alanlar

Sade tuple'larda elemanların ne anlama geldiğini anlamak zor:

# Sade tuple — hangi eleman ne?
ogrenci = ("Ahmet", 25, "İstanbul", 3.5)
print(ogrenci[0])  # Ahmet — ama 0 ne anlama geliyor?
print(ogrenci[3])  # 3.5 — GPA mı? Yaş mı? Boyutu mu?

namedtuple bu sorunu çözer — her elemana isim verir:

from collections import namedtuple

# Tanımlama — iki yol
Ogrenci = namedtuple("Ogrenci", ["isim", "yas", "sehir", "gpa"])
# veya
Ogrenci = namedtuple("Ogrenci", "isim yas sehir gpa")  # Space-separated

# Oluşturma
ahmet = Ogrenci("Ahmet", 25, "İstanbul", 3.5)
ayse = Ogrenci(isim="Ayşe", yas=22, sehir="Ankara", gpa=3.8)

# İsimle erişim — okunabilir!
print(ahmet.isim)   # Ahmet
print(ahmet.gpa)    # 3.5

# İndeksle de erişim (tuple uyumluluğu korunuyor)
print(ahmet[0])     # Ahmet
print(ahmet[-1])    # 3.5

# Unpacking hâlâ çalışır
isim, yas, sehir, gpa = ahmet
print(f"{isim} - {sehir}")

# Tuple'ın tüm özellikleri geçerli
print(len(ahmet))       # 4
print(ahmet.count(25))  # 1

namedtuple Özel Metodları

Nokta = namedtuple("Nokta", ["x", "y"])
p = Nokta(3, 7)

# _asdict(): Sözlüğe çevir
print(p._asdict())  # {'x': 3, 'y': 7}

# _replace(): Yeni tuple döndür (orijinal değişmez — immutable!)
p2 = p._replace(x=10)
print(p2)  # Nokta(x=10, y=7)
print(p)   # Nokta(x=3, y=7) — değişmedi

# _fields: Alan isimleri
print(Nokta._fields)  # ('x', 'y')

# _make(): Iterable'dan oluştur
p3 = Nokta._make([5, 9])
print(p3)  # Nokta(x=5, y=9)

# _field_defaults: Varsayılan değerler (Python 3.6.1+)
Renk = namedtuple("Renk", ["r", "g", "b", "a"], defaults=[255])
kirmizi = Renk(255, 0, 0)
print(kirmizi)  # Renk(r=255, g=0, b=0, a=255)

typing.NamedTuple (Modern Yaklaşım)

Python 3.6+ ile sınıf söz dizimi kullanabilirsin — type hint desteğiyle:

from typing import NamedTuple

class Ogrenci(NamedTuple):
    isim: str
    yas: int
    sehir: str
    gpa: float = 0.0  # Varsayılan değer!

ahmet = Ogrenci("Ahmet", 25, "İstanbul", 3.5)
mehmet = Ogrenci("Mehmet", 22, "İzmir")  # gpa = 0.0

print(ahmet)  # Ogrenci(isim='Ahmet', yas=25, sehir='İstanbul', gpa=3.5)
print(mehmet)  # Ogrenci(isim='Mehmet', yas=22, sehir='İzmir', gpa=0.0)

# isinstance kontrolü
print(isinstance(ahmet, tuple))  # True — hâlâ tuple!

Bu yaklaşım IDE otomatik tamamlama ve type checking de sağlar.

💡 İpucu: Python 3.7+ kullanıyorsan ve mutable yapıya da ihtiyacın varsa, @dataclass decorator'ını düşün. NamedTuple immutable, dataclass varsayılan olarak mutable. İkisi de alanları isimlendirir ama farklı kullanım senaryoları var. Genel kural: veri değişmeyecekse NamedTuple, değişecekse dataclass.

Tuple vs List: Ne Zaman Hangisi?

Kriter	Tuple	List
Mutable	❌ Hayır	✅ Evet
Hashable	✅ Evet*	❌ Hayır
Dict key	✅ Olabilir	❌ Olamaz
Set elemanı	✅ Olabilir	❌ Olamaz
Performans	Biraz daha hızlı	Biraz daha yavaş
Bellek	Daha az	Daha fazla
Metod sayısı	2	11+
Kullanım	Sabit, yapısal veriler	Değişen koleksiyonlar

\* Sadece tüm elemanları da hashable ise

Pratik Karar Kuralları

Tuple kullan:

Veri asla değişmeyecekse (koordinat, renk, tarih bileşenleri)
Dictionary key olarak kullanılacaksa
Fonksiyondan birden fazla değer döndürürken
Sabit konfigürasyon değerleri, enum benzeri sabitler
Heterojenik veri (farklı tipteki verilerin bir arada — record/struct benzeri)

List kullan:

Eleman ekleme/çıkarma yapılacaksa
Sıralama gerekiyorsa (sort)
Homojen koleksiyonlar (aynı tipte verilerin listesi)
Büyüklüğü değişen koleksiyonlar
Filtreleme/mapping sonuçları

# Tuple uygun: koordinat (değişmez, yapısal)
konum = (41.01, 28.97)

# List uygun: alışveriş sepeti (ekleme/çıkarma var)
sepet = ["ekmek", "süt"]
sepet.append("yumurta")

# Tuple uygun: RGB renk (3 sabit bileşen)
kirmizi = (255, 0, 0)

# List uygun: log kayıtları (sürekli ekleniyor)
loglar = []
loglar.append("Sistem başladı")

# Tuple uygun: veritabanı satırı (sabit yapı)
kayit = ("Ahmet", 25, "İstanbul")

# List uygun: filtreleme sonuçları
sonuclar = [x for x in veriler if x > 100]

# Tuple uygun: fonksiyon return
return (success, message, data)

# List uygun: kullanıcı listesi (dinamik)
kullanicilar = []
kullanicilar.append(yeni_kullanici)

Tuple Metodları — Sadece 2 Tane!

Tuple'ın sadece 2 metodu var. Listede 11'den fazla metod var. Bu minimalizm tuple'ın doğasından geliyor — değiştirilemez olduğu için append, remove, sort gibi metodlara ihtiyacı yok.

t = (1, 2, 3, 2, 4, 2, 5)

# count: Eleman kaç kez geçiyor
print(t.count(2))    # 3
print(t.count(10))   # 0

# index: İlk bulunduğu indeks
print(t.index(3))    # 2
print(t.index(2))    # 1 (ilk 2'nin indeksi)

# Belirli aralıkta ara
print(t.index(2, 2))    # 3 (2. indeksten sonraki ilk 2)
print(t.index(2, 4))    # 5 (4. indeksten sonraki ilk 2)

# Olmayan eleman — ValueError!
# t.index(99)  # ValueError: tuple.index(x): x not in tuple

Tuple ile Kullanılabilecek Built-in Fonksiyonlar

t = (5, 2, 8, 1, 9, 3)

print(len(t))       # 6
print(sum(t))       # 28
print(min(t))       # 1
print(max(t))       # 9
print(sorted(t))    # [1, 2, 3, 5, 8, 9] — DİKKAT: list döndürür!
print(reversed(t))  # <reversed object> — iterator döndürür

# in operatörü
print(5 in t)       # True
print(99 in t)      # False
print(99 not in t)  # True

# any / all
print(any(x > 5 for x in t))  # True
print(all(x > 0 for x in t))  # True

Tuple Birleştirme ve Çoğaltma

Değiştiremezsin ama yeni tuple oluşturabilirsin:

a = (1, 2, 3)
b = (4, 5, 6)

# Birleştirme (+) — yeni tuple oluşturur
c = a + b
print(c)  # (1, 2, 3, 4, 5, 6)

# Çoğaltma (*) — yeni tuple oluşturur
d = a * 3
print(d)  # (1, 2, 3, 1, 2, 3, 1, 2, 3)

# Tuple'a "eleman ekleme" (aslında yeni tuple oluşturma)
t = (1, 2, 3)
t = t + (4,)    # Yeni tuple yaratılır, eski t garbage collected olur
print(t)  # (1, 2, 3, 4)

⚠️ Dikkat: Tuple birleştirme O(n) işlemdir — her seferinde tüm elemanlar kopyalanır. Sık birleştirme yapıyorsan liste kullan, işin bitince tuple() ile çevir: ```python # ❌ Yavaş — her ekleme O(n) t = () for i in range(1000): t = t + (i,)

# ✅ Hızlı — list append O(1), sonra çevir items = [] for i in range(1000): items.append(i) t = tuple(items) ```

Karşılaştırma (Lexicographic)

Tuple'lar eleman eleman karşılaştırılır — ilk farklı elemana göre karar verilir:

print((1, 2, 3) < (1, 2, 4))   # True — 3. eleman 3 < 4
print((1, 2) < (1, 3))          # True — 2. eleman 2 < 3
print((2,) < (1, 2, 3))         # False — 1. eleman 2 > 1
print((1, 2) < (1, 2, 0))      # True — kısa olan küçük

# Sıralama: önce 1. elemana, sonra 2. elemana göre
veriler = [(3, "c"), (1, "b"), (2, "a"), (1, "a")]
print(sorted(veriler))
# [(1, 'a'), (1, 'b'), (2, 'a'), (3, 'c')]

Bu özellik çok kullanışlı — özellikle çoklu kriter sıralamasında:

# Önce nota göre (azalan), sonra isme göre (artan) sırala
ogrenciler = [("Ahmet", 85), ("Ayşe", 85), ("Mehmet", 92)]

sirali = sorted(ogrenciler, key=lambda x: (-x[1], x[0]))
print(sirali)  # [('Mehmet', 92), ('Ahmet', 85), ('Ayşe', 85)]

Gerçek Dünya Kullanımları

1. Veritabanı Sorgu Sonuçları

# Çoğu DB kütüphanesi satırları tuple olarak döndürür
satirlar = [
    (1, "Ahmet", "ahmet@mail.com", True),
    (2, "Ayşe", "ayse@mail.com", True),
    (3, "Mehmet", "mehmet@mail.com", False),
]

for id_, isim, email, aktif in satirlar:
    durum = "✅" if aktif else "❌"
    print(f"{durum} #{id_} {isim} ({email})")

2. Harita/Grid Koordinatları

# 2D oyun haritası
duvarlar = {(0, 0), (0, 1), (0, 2), (1, 0), (2, 0)}
oyuncu = (3, 3)

def hareket_et(konum, yon):
    x, y = konum
    dx, dy = yon
    yeni = (x + dx, y + dy)
    if yeni in duvarlar:
        print("Duvara çarptın!")
        return konum
    return yeni

oyuncu = hareket_et(oyuncu, (-1, 0))  # Sola git

3. Konfigürasyon Sabitleri

# Sabitler tuple olarak — yanlışlıkla değiştirilemez
DESTEKLENEN_FORMATLAR = (".jpg", ".png", ".gif", ".webp", ".svg")
VARSAYILAN_BOYUT = (1920, 1080)
RENK_PALETI = ((255, 0, 0), (0, 255, 0), (0, 0, 255))

def resim_yukle(dosya_yolu):
    uzanti = os.path.splitext(dosya_yolu)[1].lower()
    if uzanti not in DESTEKLENEN_FORMATLAR:
        raise ValueError(f"Desteklenmeyen format: {uzanti}")
    # ...

Özet

Tuple sıralı ve immutable bir veri yapısıdır — oluşturulduktan sonra değiştirilemez. Virgül tuple yapar, parantez değil: (42) int, (42,) tuple.
Tuple unpacking (a, b = (1, 2)) Python'un en zarif özelliklerinden biri — fonksiyon return'ü, swap, for döngüleri ve değişken atamasında yaygın.
Hashable olduğu için dict key ve set elemanı olabilir — list olamaz. Bu tuple'ın en önemli teknik avantajı.
Named tuple (collections.namedtuple veya typing.NamedTuple) elemanlara isim verir — okunabilirliği dramatik artırır ve struct/record benzeri kullanım sağlar.
Tuple vs list: Veri değişmeyecekse ve yapısal (farklı anlamlı alanlar) ise tuple, değişen homojen koleksiyonlar için list kullan.
Tuple'ın sadece 2 metodu var: count() ve index(). Basitliği gücüdür — az ama öz.