Python Tuples (Demetler)
- dersimizde Listeler (Lists) konusunu tepeden tırnağa sökmüştük: ekleme, silme, dilimleme, iç içe yapılar. Bugün karşımızda onların daha az konuşulan ama en az onlar kadar iş gören kardeşi var. Adı demet. İngilizcesi tuple. Değiştirilemez bir liste. Tanım kulağa basit geliyor olabilir; ama arkasında iş görüşmelerinde bile sorulan incelikler saklı. Özellikle tek elemanlı tuple konusunda sayısız Python geliştiricisinin ayağı kaymıştır. Benimki de dahil.
Tuple Nedir?
Sözlük anlamıyla demet, bir araya getirilip bağlanmış şeyler topluluğudur. Python'da da anlam bozulmuyor: tuple, sıralı ve değiştirilemez (immutable) bir veri topluluğudur. Liste hangi okuma işlemine izin veriyorsa, demet de sıralama, indeksleme ve dilimleme konusunda aynı izinleri verir. Tek fark kocaman: oluşturulduktan sonra eleman ekleyemez, silemez, değiştiremezsiniz. Liste büyür, küçülür, dönüşür; tuple yazıldığı gibi kalır.
Peki bu neden avantaj olsun? Oraya birazdan geleceğiz. Önce temel kullanıma bakalım:
- Elemanlara
demet[0],demet[-1]gibi indekslerle ulaşırsınız. demet[1:3]dilimlemesi listedeki gibi çalışır.len()eleman sayısını,inoperatörü üyelik kontrolünü destekler.count()veindex()metotları listedekilerle birebir aynıdır.
demet = ("elma", "armut", "kiraz", "üzüm")
print(demet[0]) # elma — ilk eleman
print(demet[-1]) # üzüm — negatif indeks son elemanı verir
print(demet[1:3]) # ('armut', 'kiraz') — dilimleme yeni bir demet üretir
print(len(demet)) # 4 — eleman sayısı
print("kiraz" in demet) # True — üyelik kontrolü
Burada olan biten, listede gördüğünüzden farksız: Python demeti arka planda C seviyesinde sıralı bir dizi olarak tutar, indeksleme bu dizideki konuma doğrudan erişim sağlar. Dilimleme ise orijinal veriye dokunmaz; size yeni bir demet döndürür. Yani okuma tarafı tamamen tanıdık; fark, yazma tarafında.
Bir de şu var: değiştirilemezlik Python'da tuple'a özgü değildir; karakter dizileri de değiştirilemezdir. metin[0] = 'x' yazarsanız aynı TypeError ile karşılaşırsınız. Yani değiştirilemez türlerle aslında çoktan tanışmıştınız; tuple, bu ailenin sıralı ve farklı türde eleman barındırabilen üyesidir.
Tuple Nasıl Oluşturulur?
Parantez Şart Değil, Virgül Şart
Yeni başlayanlar tuple'ı parantezle özdeşleştirir: (1, 2, 3). Oysa Python'ın umurunda olan tek şey virgüldür. Parantezler yalnızca okunabilirliği artırır ve işlem önceliği karışıklıklarını engeller.
# Klasik parantezli tanım
koordinat = (35.24, 33.92)
# Parantezsiz tanım: virgül varsa tuple'dır
renk = 255, 128, 0
# İkisi de aynı türdendir
print(type(koordinat)) # <class 'tuple'>
print(type(renk)) # <class 'tuple'>
renk = 255, 128, 0 satırında Python virgülleri görür ve üç değeri tek bir demet nesnesine paketler (packing). a, b = b, a takas ifadesinin çalışma sebebi de tam olarak budur: sağ taraf önce bir demete paketlenir, sonra soldaki değişkenlere açılır (unpacking). Parantezler bu süreçte yalnızca görsel bir yardımcıdır; söz sahibi virgüldür.
Peki parantez ne zaman gerçekten gerekir? Tuple'ı başka bir ifadenin içine, örneğin bir liste elemanı olarak yazarken: liste = [(1, 2), (3, 4)]. Burada parantezleri kaldırırsanız Python nerede liste bitiyor, nerede tuple başlıyor karıştırır. Tek başına duran tanımlarda ise parantez tamamen isteğe bağlıdır.
Tek Elemanlı Tuple: (5,) Tuzağı
Şimdi yüzlerce geliştiricinin saatini yemiş olan o tuzağa geliyoruz.
2015'te ilk ciddi projelerimden birinde harita tabanlı bir uygulama yazıyordum. Ekran boyutlarını sabitler dosyasında tutuyordum ve boyut = (10) yazdım; tek değerli bir demet sandım. Uygulama çalışınca boyut[0] satırında 'int' object is not subscriptable hatası aldım. Saatlerimi yedi. Hata mesajı, Python'un bir tamsayı üzerinde indeksleme yapamayacağını açıkça söylüyordu; ben ise kendi yazdığım o tek satırın suçlu olabileceğini aklıma bile getirmeden ortalıkta geziyordum. Suçlu tabii ki o satırdı.
Sebep şu: Python parantezleri matematiksel gruplama olarak yorumlar. (5) bir demet değil, bildiğiniz 5 sayısıdır.
# Bu bir demet DEĞİL; parantezler burada sadece gruplamadır
sayi = (5)
print(type(sayi)) # <class 'int'> — bekle, ne?
# Tek elemanlı demet için sona virgül koymak şarttır
tek = (5,)
print(type(tek)) # <class 'tuple'> — işte bu
İlk satırda parantezlerin arasında virgül olmadığı için Python ifadeyi olduğu gibi değerlendirir ve bir tamsayı üretir. İkinci tanımda sondaki virgül "bu bir demet" sinyalini verir ve Python tek elemanlı bir tuple nesnesi yaratır. Kural çok basit: tek eleman, mutlaka virgül.
tuple[0] = x Hata Verir… İçindeki Liste Hariç
Değiştirilemezlik iddiasını teste tabi tutalım.
demet = (10, 20, 30)
try:
demet[0] = 99 # Demette eleman değiştirme denemesi
except TypeError as hata:
print(hata) # 'tuple' object does not support item assignment
# Ama içeride bir liste varsa işler değişir
kayit = ("istihbarat", [1, 2, 3])
kayit[1].append(4) # Değişen şey demet değil, içindeki liste
print(kayit) # ('istihbarat', [1, 2, 3, 4])
İlk denemede Python atamayı reddeder; tuple nesnesi eleman değişimini desteklemez ve TypeError fırlatır. İkinci bölümde ise append çağrısı demeti değil, demetin işaret ettiği listeyi değiştirir. Demet hangi nesnelere işaret edeceğini sabitler; işaret edilen nesnelerin içinde ne olup bittiğine karışmaz. Bu yüzden "demetim kesin sabit" diye düşünmeden önce içindeki nesnelerin türüne bakın.
Bu arada yasak yalnızca atamayla sınırlı değil. del demet[0] da çalışmaz; demet.append(40) diye bir metot zaten yoktur. Değiştirme kapısının tamamı kapalıdır; açık kalan tek kapı okumadır.
Neden Tuple Kullanıyoruz?
Demet listeden daha az yetenekliyse neden var? Çünkü kısıtlama bazen özelliktir.
- Sabit veriler için idealdir: haftanın günleri, veri tabanı sütun adları, API sabitleri. Yanlışlıkla değiştirilemezler; kod kendini korur.
- Unpacking için biçilmiş kaftandır: tek satırda çoklu atama, temiz fonksiyon dönüşleri.
- Sözlük anahtarı olabilir: değiştirilemez olduğu için hash'i sabittir. Liste olamaz.
- Fonksiyonların çoklu değer döndürmesi aslında tuple döndürmesidir.
Bir ara stajyerimin kodunu inceliyordum; sözlükte anahtar olarak liste kullanmaya çalışmıştı. TypeError: unhashable type: 'list' hatası ekranında duruyordu ve çaresizce bakıyordu. Anlattım: sözlükler anahtarları hash değerine göre depolar; liste değiştirilebilir olduğu için hash'i güvenilir olmaz. Tuple değiştirilemezdir, hash'i sabittir, anahtar olmaya uygundur. Ona anlatırken kendi yıllar önceki halimi gördüm; aynı hatada ben de birkaç saatimi gömmüştüm.
# Tuple, sözlük anahtarı olarak kullanılabilir; liste kullanılamaz
sinav_takvimi = {("Ali", "Matematik"): 85, ("Ali", "Fizik"): 78}
print(sinav_takvimi[("Ali", "Fizik")]) # 78
Burada sözlüğün anahtarları birer tuple'dır; demet sabit olduğu için Python hash değerini güvenle hesaplar ve aramayı anında yapar. Aynı örneği listeyle yazmaya kalksaydınız aynı unhashable hatasıyla karşılaşırdınız.
Bir de performans boyutu var. Tuple, listenin dinamik büyüme mekanizmasını taşımaz; sabit boyutlu olduğu için genellikle daha az bellek harcar, oluşturulması ve gezilmesi de biraz daha hızlıdır. Tek bir demette fark hissetmezsiniz; ama milyonlarca kaydın döndüğü bir hatta bu fark birikir.
# Tuple unpacking: tek satırda çoklu atama
isim, yas, sehir = ("Mert", 28, "İzmir")
print(yas) # 28
# Fonksiyon çoklu değer döndürdüğünde aslında tuple döndürür
def bol_ve_kalan(a, b):
return a // b, a % b # Virgül, bu ikiliyi demete paketler
bolum, kalan = bol_ve_kalan(17, 5)
print(bolum, kalan) # 3 2
# İki değişkeni takas etmek bile arkada packing/unpacking kullanır
x, y = 5, 10
x, y = y, x
print(x, y) # 10 5
return a // b, a % b satırında Python iki sonucu tek bir demette toplar; fonksiyonun gerçek dönüş değeri budur. Çağıran tarafta bolum, kalan = ifadesi bu demeti açıp değişkenlere dağıtır. Yani Python'da "bir fonksiyon birden fazla değer döndürüyor" dediğimiz her şeyin altında bir tuple vardır.
Tuple ve List Arası Dönüşümler
İki yapı arasında geçiş iki fonksiyonluk iştir.
# Tuple'dan listeye: üzerinde değişiklik yapacaksanız
demet = (1, 2, 3)
liste = list(demet) # [1, 2, 3]
liste.append(4) # Artık serbestçe değiştirebilirsiniz
# Listeden tuple'a: veriyi dondurmak istiyorsanız
dondurulmus = tuple(liste) # (1, 2, 3, 4)
# Karakter dizisinden de tuple üretilebilir
harfler = tuple("abc") # ('a', 'b', 'c')
list() çağrısı demetin elemanlarını tek tek kopyalayıp yeni bir liste üretir; orijinal demete hiçbir şey olmaz. tuple() da ters yönde çalışır; kopyalama sonucu elemanlar aynı nesneleri işaret eder, yalnızca kap değişir. Bu iki dönüşümü, veri akışının bir noktasında "buraya kadar esnek, buradan sonra sabit" demek istediğiniz her yerde kullanırsınız.
Liste mi, Tuple mı? Seçim Kriterleri
Karar anında şu soruları sorun:
- Veri ömrü boyunca değişecek mi? Evet ise liste.
- Sabit kalması gereken, korunacak değerler mi? Tuple.
- Sözlük anahtarı ya da küme elemanı mı olacak? Tuple (teknik zorunluluk).
- Kodu okuyan kişiye "bu değişmemeli" mesajı mı vermek istiyorsunuz? Tuple; niyet, kodun kendisinde taşınır.
- Performans kritik mi? Tuple genellikle daha hızlıdır ve listeden daha az bellek harcar; fark küçük ama milyonlarca elemanlı veride birikir.
Pratik kuralım şu: değişecekse list, değişmeyecekse tuple. Kararsız kaldığınız yerde önce tuple yazın; sonradan listeye çevirmek her zaman kolaydır, tersi pişmanlık doğurabilir.
Karar tablosunu ezberlemeye çalışmayın. İlk aylarda herkes her yere liste yazar; bu normal. Tuple refleksi, yanlışlıkla değiştirilen bir sabit veri size ilk kez pahalıya patladığında oturur.
Sık Sorulan Sorular
Tuple ile liste arasındaki tek fark değiştirilemezlik mi?
Pratikte evet, ama bir de metot farkı vardır. append, remove, sort gibi yapıyı değiştiren metotlar tuple'da yoktur; count ve index gibi salt okunur metotlar ikisinde de bulunur. Ayrıca değiştirilemezlik, tuple'a listenin asla kazanamayacağı bir özellik kazandırır: hash'lenebilirlik. Bu sayede sözlük anahtarı ve küme elemanı olabilir.
Tek elemanlı tuple neden virgül ister?
Çünkü Python (5) ifadesini matematikteki parantez olarak okur; ortada virgül yoksa ortada tuple da yoktur. Virgül, tuple'ı tanımlayan asıl işarettir. (5,) yazımındaki parantezler sadece süs; asıl işi sondaki virgül yapar.
İçindeki listeyi değiştirebiliyorsak tuple'a "değiştirilemez" demek çelişki değil mi?
Değil. Değiştirilemez olan, demetin hangi elemanlara işaret ettiğidir. İşaret edilen listede neler olduğu, o listenin sorumluluğudur. Demet yapınızı sabitler; içindeki nesneler kendi türlerinin kurallarına göre yaşar.
Sırada Ne Var?
Bugün sözlük anahtarı meselesine iki kez değindik: tuple hash'lenebilir, liste değil. Peki bu sözlük dediğimiz yapı tam olarak ne, nasıl çalışıyor? Bir sonraki dersimizde anahtar-değer çiftlerinin dünyasına giriyoruz. Sözlükler (Dictionaries) ile get() kurtarıcısını, KeyError kâbusunu ve dict comprehension'ın ilk adımlarını konuşacağız. Görüşmek üzere.







