Python, verileri yapılandırmak ve saklamak için çeşitli yerleşik veri tipleri sunar. Bunlardan biri de demetler (Tuples)’dir. Listelere oldukça benzeyen ancak temel bir farkla ayrılan demetler, Python programlamada önemli bir yere sahiptir. Bu temel fark, demetlerin değiştirilemez (immutable) olmasıdır. Yani bir demet oluşturulduktan sonra içeriği (öğeleri) değiştirilemez, eklenemez veya silinemez.

Bu “değişmezlik” kısıtlaması gibi görünse de, aslında demetlere belirli avantajlar ve kullanım alanları kazandırır. Bu rehberde, Python demetlerinin ne olduğunu, temel özelliklerini, nasıl oluşturulduklarını, öğelerine nasıl erişildiğini ve neden değiştirilemez olduklarını detaylıca inceleyeceğiz. Ayrıca, demetlerin listelerle karşılaştırmasını yapacak, paketleme (packing) ve açma (unpacking) gibi önemli konseptleri ele alacak ve demetlerin hangi durumlarda tercih edilmesi gerektiğini gösteren çeşitli kullanım alanlarını örneklerle açıklayacağız.

Bölüm 1: Demet (Tuple) Nedir ve Temel Özellikleri
Python’da bir demet (tuple), normal parantezler () içine alınan ve virgülle ayrılmış, sıralı bir öğeler koleksiyonudur. Temel özellikleri şunlardır:

Sıralıdır (Ordered): Tıpkı listeler gibi, demetlerdeki öğelerin de belirli bir sırası vardır ve bu sıra oluşturulduktan sonra korunur. Öğelere indeks numaralarıyla erişilebilir (ilk öğe indeks 0).
tuple1 = (10, 20, 'a') tuple2 = ('a', 10, 20) print(tuple1 == tuple2) # False (Sıraları farklı)
Değiştirilemezdir (Immutable): Bu, demetlerin en ayırt edici özelliğidir. Bir demet oluşturulduktan sonra, öğeleri değiştirilemez, yeni öğe eklenemez veya var olan öğeler silinemez. Herhangi bir değiştirme girişimi TypeError hatasına yol açar.
my_tuple = (1, 2, 3) # my_tuple[0] = 99 # Bu satır TypeError verir! # my_tuple.append(4) # Hata! tuple nesnesinin append metodu yoktur.
Önemli Nuans: Demet içindeki öğelerden biri liste gibi değiştirilebilir bir nesne ise, o nesnenin içeriği değiştirilebilir. Ancak demetin o pozisyonundaki referans (yani listenin kendisi) başka bir nesne ile değiştirilemez. Bu konuya daha sonra detaylı değineceğiz.
Farklı Veri Tiplerini İçerebilir (Heterogeneous): Listeler gibi, demetler de tam sayılar, ondalıklı sayılar, metinler, boolean değerler ve hatta başka demetler veya listeler gibi farklı türden öğeleri bir arada barındırabilir.
karma_tuple = (10, "Python", True, (1, 2), [3, 4]) print(f"Karma Demet: {karma_tuple}")
Yinelenen Öğelere İzin Verir (Allows Duplicates): Aynı değere sahip birden fazla öğe bir demette bulunabilir.
tekrarli_tuple = ('x', 'y', 'z', 'x', 'y') print(f"Tekrarlı Demet: {tekrarli_tuple}")
Bölüm 2: Demet Oluşturma
Python’da demet oluşturmanın çeşitli yolları vardır:

2.1. Normal Parantez Kullanarak (())
En yaygın yöntem, öğeleri normal parantezler içine virgülle ayırarak yazmaktır.

Boş demet oluşturma

bos_demet = ()
print(f"Boş Demet: {bos_demet}, Tipi: {type(bos_demet)}")

Öğelerle dolu demet oluşturma

sayilar = (1, 2, 3, 4, 5)
koordinatlar = (10.5, -3.2, 8.0)
isim_ve_yas = ("Ahmet", 30)
print(f"Sayılar Demeti: {sayilar}")
print(f"Koordinatlar: {koordinatlar}")
print(f"İsim ve Yaş: {isim_ve_yas}")
2.2. Tek Öğeli Demet Oluşturma (Virgül Detayı)
Tek bir öğeden oluşan bir demet oluştururken çok dikkatli olunmalıdır. Parantez içine sadece tek bir öğe yazmak yeterli değildir, çünkü Python bunu sadece gruplama parantezi olarak algılayabilir. Tek öğeli bir demet oluşturmak için öğeden sonra mutlaka bir virgül , konulmalıdır.

yanlis_tek_ogeli = (50) # Bu bir demet DEĞİL, int tipinde 50'dir!
dogru_tek_ogeli = (50,) # Bu bir demet! Sondaki virgüle dikkat!
print(f"Yanlış: {yanlis_tek_ogeli}, Tipi: {type(yanlis_tek_ogeli)}") # Çıktı: Yanlış: 50, Tipi:
print(f"Doğru: {dogru_tek_ogeli}, Tipi: {type(dogru_tek_ogeli)}") # Çıktı: Doğru: (50,), Tipi:
Tek öğeli demetlerde sondaki virgülü unutmak, yaygın yapılan bir hatadır ve beklenmedik davranışlara yol açabilir.

2.3. Parantezsiz Demet Oluşturma (Tuple Packing)
Python, virgülle ayrılmış bir dizi değeri otomatik olarak bir demet olarak kabul eder. Bu işleme paketleme (packing) denir. Parantez kullanmak genellikle okunabilirlik için tercih edilse de, zorunlu değildir.

Parantezsiz demet oluşturma (Packing)

packed_tuple = 10, "elma", True
print(f"Paketlenmiş Demet: {packed_tuple}") # Çıktı: (10, 'elma', True)
print(f"Tipi: {type(packed_tuple)}") # Çıktı:

Fonksiyonlardan birden fazla değer döndürürken sıkça kullanılır

def min_max_bul(liste):
if not liste:
return None, None # None değerlerinden oluşan bir tuple döner
return min(liste), max(liste) # min ve max değerlerinden oluşan bir tuple döner
sayilar = [3, 8, 1, 15, 4]
minimum, maksimum = min_max_bul(sayilar) # Dönen tuple 'unpack' ediliyor
print(f"Minimum: {minimum}, Maksimum: {maksimum}") # Çıktı: Minimum: 1, Maksimum: 15
2.4. tuple() Yapıcı Fonksiyonu Kullanarak
tuple() fonksiyonu, başka bir yinelenebilir (iterable) nesneyi (liste, string, set, range, başka bir demet) argüman olarak alıp yeni bir demet oluşturmak için kullanılabilir. Argüman verilmezse boş bir demet oluşturur.

Boş demet oluşturma

bos_demet_2 = tuple()
print(f"Boş Demet (tuple() ile): {bos_demet_2}")

Listeden demet oluşturma

my_list = [10, 20, 30]
my_tuple_from_list = tuple(my_list)
print(f"Listeden Demet: {my_tuple_from_list}") # Çıktı: (10, 20, 30)

String'den demet oluşturma (her karakter bir öğe olur)

harf_demeti = tuple("Merhaba")
print(f"String'den Demet: {harf_demeti}") # Çıktı: ('M', 'e', 'r', 'h', 'a', 'b', 'a')

Range'den demet oluşturma

range_demeti = tuple(range(5))
print(f"Range'den Demet: {range_demeti}") # Çıktı: (0, 1, 2, 3, 4)
tuple() fonksiyonu, özellikle bir listeyi veya başka bir yinelenebilir yapıyı değiştirilemez bir demete dönüştürmek istediğinizde kullanışlıdır.

Bölüm 3: Demet Öğelerine Erişim
Demetler sıralı koleksiyonlar olduğu için, içindeki öğelere listelerde olduğu gibi indeksleme ve dilimleme yöntemleriyle erişebiliriz.

3.1. İndeksleme (Indexing)
Tek bir öğeye erişmek için öğenin indeks numarası köşeli parantezler [] içinde belirtilir. Pozitif (0'dan başlayan) ve negatif (-1'den başlayan) indeksleme kullanılabilir.

Geçersiz bir indeks kullanıldığında IndexError hatası alınır.

renkler_tuple = ("kırmızı", "mavi", "yeşil", "sarı", "mor")

0 1 2 3 4

-5 -4 -3 -2 -1

print(f"İlk renk (indeks 0): {renkler_tuple[0]}") # kırmızı
print(f"Son renk (indeks -1): {renkler_tuple[-1]}") # mor
print(f"İkinci renk (indeks 1): {renkler_tuple[1]}") # mavi

İç içe demetlerde erişim

nested_tuple = (1, 2, ('a', 'b'))
print(f"İç demetin ilk öğesi: {nested_tuple[2][0]}") # 'a'
3.2. Dilimleme (Slicing)
Demetin belirli bir bölümünü (alt demet) almak için dilimleme kullanılır. Dilimleme işlemi her zaman yeni bir demet oluşturur.

Sözdizimi: demetbaşlangıç:bitiş:adım

başlangıç: Dahil olan başlangıç indeksi (varsayılan: 0).
bitiş: Dahil olmayan bitiş indeksi (varsayılan: demetin sonu).
adım: Atlama miktarı (varsayılan: 1).
sayilar_tuple = (10, 11, 12, 13, 14, 15, 16, 17, 18, 19)

0 1 2 3 4 5 6 7 8 9

Dilimleme Örnekleri

print(f"İndeks 1'den 4'e kadar: {sayilar_tuple[1:4]}") # (11, 12, 13)
print(f"Baştan 3. indekse kadar: {sayilar_tuple[:3]}") # (10, 11, 12)
print(f"İndeks 5'ten sona kadar: {sayilar_tuple[5:]}") # (15, 16, 17, 18, 19)
print(f"Tüm demetin kopyası: {sayilar_tuple[:]}") # Tüm demet
print(f"Son 4 eleman: {sayilar_tuple[-4:]}") # (16, 17, 18, 19)
print(f"Çift indeksli elemanlar: {sayilar_tuple[::2]}") # (10, 12, 14, 16, 18)
print(f"Demetin tersi: {sayilar_tuple[::-1]}") # (19, 18, ..., 11, 10)
Bölüm 4: Demetlerin Değişmezliği (Immutability)
Demetlerin en temel ve tanımlayıcı özelliği değiştirilemez (immutable) olmalarıdır. Bu, bir demet oluşturulduktan sonra üzerinde aşağıdaki işlemlerin yapılamayacağı anlamına gelir:

Mevcut bir öğenin değerini değiştirmek.
Deme’e yeni bir öğe eklemek.
Demetten bir öğeyi silmek.
Bu tür bir değişiklik yapmaya çalışmak TypeError hatasına neden olur.

my_immutable_tuple = ('a', 'b', 'c')
print(f"Orijinal Demet: {my_immutable_tuple}")
try:
my_immutable_tuple[0] = 'X' # Öğeyi değiştirmeye çalışma
except TypeError as e:
print(f"Hata (Öğe Değiştirme): {e}")
try:
my_immutable_tuple.append('d') # Öğeyi eklemeye çalışma (append metodu yok)
except AttributeError as e:
print(f"Hata (Öğe Ekleme): {e}")
try:
del my_immutable_tuple[1] # Öğeyi silmeye çalışma
except TypeError as e:
print(f"Hata (Öğe Silme): {e}")
Değişmezliğin Arkasındaki Mantık ve Avantajları
Neden Python’da listeler gibi değiştirilebilir sıralı tipler varken, demetler gibi değiştirilemez bir tipe ihtiyaç duyulmuştur?

Veri Bütünlüğü (Data Integrity): Demetler, yanlışlıkla değiştirilmemesi gereken sabit veri koleksiyonlarını temsil etmek için idealdir. Bir fonksiyona demet olarak veri gönderdiğinizde, fonksiyonun o veriyi değiştiremeyeceğinden emin olursunuz.
Sözlük Anahtarı Olarak Kullanılabilme (Dictionary Keys): Python sözlüklerinin anahtarları değiştirilemez (immutable) ve hash’lenebilir (hashable) olmalıdır. Demetler (içlerinde sadece değiştirilemez öğeler barındırıyorsa) bu koşulları sağladığı için sözlük anahtarı olarak kullanılabilirler. Listeler ise değiştirilebilir oldukları için anahtar olamazlar.
konum_bilgileri = {} ankara_koordinat = (39.9334, 32.8597) # Koordinatlar değişmez, tuple uygun istanbul_koordinat = (41.0082, 28.9784) konum_bilgileri[ankara_koordinat] = "Ankara" konum_bilgileri[istanbul_koordinat] = "İstanbul" print(konum_bilgileri) # {(39.9334, 32.8597): 'Ankara', (41.0082, 28.9784): 'İstanbul'} # liste_key = [1, 2] # konum_bilgileri[liste_key] = "Hata" # TypeError: unhashable type: 'list'
Performans Optimizasyonları: Değişmez oldukları için, Python yorumlayıcısı demetler için bazı optimizasyonlar yapabilir. Genellikle aynı boyuttaki listelere göre biraz daha az bellek kullanırlar ve üzerlerinde iterasyon yapmak (döngüyle gezmek) veya bir öğenin varlığını kontrol etmek (üyelik testi) listelere göre potansiyel olarak daha hızlı olabilir. Ancak bu farklar çoğu pratik uygulamada çok büyük olmayabilir.
Anlamsal Netlik: Bir veri yapısını demet olarak tanımlamak, “bu veri koleksiyonunun değişmemesi gerekiyor” niyetini açıkça belirtir.
Dikkat: Demet İçindeki Değiştirilebilir Nesneler
Demetlerin kendisi değiştirilemez olsa da, içerdikleri öğeler değiştirilebilir (mutable) nesneler ise (örneğin listeler), bu iç nesnelerin içeriği hala değiştirilebilir. Bu durum bazen kafa karıştırıcı olabilir.

İçinde liste barındıran bir demet

tuple_with_list = (1, 2, ['a', 'b'])
print(f"Başlangıç: {tuple_with_list}")

Demetin kendisini değiştiremeyiz:

tuple_with_list[0] = 99 # TypeError

Ama demet İÇİNDEKİ listeyi DEĞİŞTİREBİLİRİZ!

tuple_with_list[2].append('c') # Demetin 2. indeksindeki listeye 'c' ekle
tuple_with_list[2][0] = 'X' # İçteki listenin 0. indeksini değiştir
print(f"Değişim Sonrası: {tuple_with_list}") # Çıktı: (1, 2, ['X', 'b', 'c'])

Demetin 2. indeksindeki listeyi başka bir listeyle değiştiremeyiz:

tuple_with_list[2] = [10, 20] # TypeError

Bu davranış nedeniyle, eğer bir demeti gerçekten tamamen değişmez yapmak istiyorsanız (örneğin sözlük anahtarı olarak güvenle kullanmak için), demetin içindeki tüm öğelerin de değiştirilemez (sayı, string, bool, başka demetler vb.) olduğundan emin olmalısınız. İçinde liste veya başka değiştirilebilir nesne içeren bir demet hash’lenemez ve sözlük anahtarı olamaz.

Bölüm 5: Demet Operasyonları ve Metotları
Demetler değiştirilemez olduğu için, listelerde bulunan append, extend, insert, remove, pop, sort, reverse gibi değiştirici metotlara sahip değillerdir. Ancak bazı temel operasyonları ve bilgi veren metotları desteklerler.

5.1. Desteklenen Operasyonlar
Birleştirme (Concatenation) +: İki demeti birleştirerek yeni bir demet oluşturur.
Tekrarlama (Repetition) *: Bir demeti belirtilen sayıda tekrarlayarak yeni bir demet oluşturur.
Üyelik Testi (Membership) in / not in: Bir öğenin demette olup olmadığını kontrol eder (True/False döndürür).
Uzunluk (Length) len(): Demetin öğe sayısını döndürür.
Minimum/Maksimum min() / max(): Demetteki en küçük veya en büyük öğeyi döndürür (öğeler karşılaştırılabilir olmalıdır).
Toplam sum(): Demetteki tüm sayısal öğelerin toplamını döndürür (öğeler sayısal olmalıdır).
Döngü ile Gezinme (Iteration): for döngüsü ile demetin her bir öğesi üzerinde işlem yapılabilir.
Karşılaştırma: İki demet, öğe öğe karşılaştırılarak (lexicographical comparison) büyüklük/küçüklük veya eşitlik açısından karşılaştırılabilir. Karşılaştırma ilk farklı öğede durur.
tuple_a = (1, 2, 3)
tuple_b = (4, 5)
tuple_c = ('a', 'b')
tuple_d = (1, 2, 3)

Birleştirme (+) -> Yeni demet

birlesik = tuple_a + tuple_b
print(f"Birleşik: {birlesik}") # (1, 2, 3, 4, 5)

Tekrarlama (*) -> Yeni demet

tekrarli = tuple_c * 3
print(f"Tekrarlı: {tekrarli}") # ('a', 'b', 'a', 'b', 'a', 'b')

Üyelik (in)

print(f"3 tuple_a içinde mi? {3 in tuple_a}") # True
print(f"'c' tuple_c içinde mi? {'c' not in tuple_c}") # False

Uzunluk (len)

print(f"Birleşik demet uzunluğu: {len(birlesik)}") # 5

Min/Max/Sum

sayi_demeti = (15, 8, 22, 5)
print(f"Min: {min(sayi_demeti)}, Max: {max(sayi_demeti)}, Sum: {sum(sayi_demeti)}") # Min: 5, Max: 22, Sum: 50

Döngü

print("tuple_a öğeleri:")
for item in tuple_a:
print(f"- {item}")

Karşılaştırma

print(f"tuple_a == tuple_d ? {tuple_a == tuple_d}") # True (Değerler ve sıra aynı)
print(f"tuple_a == birlesik ? {tuple_a == birlesik}") # False
print(f"tuple_a < tuple_b ? {tuple_a < tuple_b}") # True (1 < 4 olduğu için ilk elemanda karar verilir)
print(f"(1, 5) < (1, 4, 9) ? {(1, 5) < (1, 4, 9)}") # False (İlk elemanlar eşit, ikinciye bakılır: 5 < 4 False)
5.2. Demet Metotları
Demetlerin sadece iki adet yerleşik metodu vardır:

count(item)
Ne Yapar: Demette belirtilen item değerinden kaç tane olduğunu sayar.
Değişiklik: Demeti değiştirmez.
Dönüş Değeri: Öğenin demetteki tekrar sayısı (int). Öğğe yoksa 0 döner.
my_tuple = (1, 'a', 2, 'b', 'a', 3, 'a')
print(f"Demet: {my_tuple}")
print(f"'a' sayısı: {my_tuple.count('a')}") # 3
print(f"2 sayısı: {my_tuple.count(2)}") # 1
print(f"'z' sayısı: {my_tuple.count('z')}") # 0
index(item, start=0, end=len(tuple))
Ne Yapar: Demette belirtilen item değerine sahip ilk öğenin indeksini döndürür.
Değişiklik: Demeti değiştirmez.
Dönüş Değeri: Bulunan ilk öğenin indeksi (int).
Hata: Eğer belirtilen item demette bulunamazsa ValueError hatası verir.
İsteğe Bağlı Argümanlar: Aramanın başlayacağı start ve biteceği (dahil olmayan) end indeksi belirtilebilir.
my_tuple = (10, 20, 30, 20, 40, 50)
print(f"Demet: {my_tuple}")

20'nin ilk indeksi

idx1 = my_tuple.index(20)
print(f"20'nin ilk indeksi: {idx1}") # 1

İndeks 2'den başlayarak 20'yi ara

idx2 = my_tuple.index(20, 2)
print(f"2. indeksten sonraki 20'nin indeksi: {idx2}") # 3

Olmayan öğeyi arama

try:
idx_err = my_tuple.index(99)
except ValueError as e:
print(f"Hata: {e}") # Hata: tuple.index(x): x not in tuple
Bölüm 6: Demet Paketleme ve Açma (Tuple Packing and Unpacking)
Python’da demetlerle ilgili en kullanışlı ve sık kullanılan özelliklerden biri paketleme (packing) ve açma (unpacking) mekanizmasıdır.

6.1. Paketleme (Packing)
Daha önce de belirtildiği gibi, virgülle ayrılmış bir dizi değeri bir değişkene atadığınızda, Python bu değerleri otomatik olarak bir demet içinde toplar (paketler).

veri_paketi = "Metin", 123, 45.67 # Packing
print(veri_paketi) # ('Metin', 123, 45.67)
print(type(veri_paketi)) #
6.2. Açma (Unpacking)
Bir demetteki (veya listedeki gibi başka bir yinelenebilirdeki) öğeleri, sol tarafta virgülle ayrılmış değişkenlere atayarak ayrı ayrı değişkenlere dağıtabiliriz. Buna açma (unpacking) denir. Unpacking işlemi için, sol taraftaki değişken sayısının, sağ taraftaki demetin öğe sayısıyla tam olarak eşleşmesi gerekir (genişletilmiş unpacking hariç).

koordinat = (15, 25)
x, y = koordinat # Unpacking
print(f"x = {x}, y = {y}") # x = 15, y = 25
renk_rgb = (255, 128, 0)
kirmizi, yesil, mavi = renk_rgb
print(f"R: {kirmizi}, G: {yesil}, B: {mavi}") # R: 255, G: 128, B: 0

Değişken Sayıları Eşleşmezse Hata:

a, b = renk_rgb # ValueError: too many values to unpack (expected 2)

r, g, b, alpha = renk_rgb # ValueError: not enough values to unpack (expected 4, got 3)

Uygulamalar:
Değişken Değerlerini Takas Etme (Swapping): Python’da iki değişkenin değerini geçici bir değişkene ihtiyaç duymadan takas etmenin en zarif yolu unpacking kullanmaktır.
a = 10 b = 20 a, b = b, a # Sağ taraf (b, a) -> (20, 10) tuple'ı oluşturur, sonra unpack edilir. print(f"Takas sonrası: a = {a}, b = {b}") # a = 20, b = 10
Fonksiyonlardan Dönüş Değerlerini Alma: Birden fazla değer döndüren (aslında bir tuple döndüren) fonksiyonların sonuçlarını kolayca ayrı değişkenlere atamak için kullanılır. (Bkz. Bölüm 2.3'teki min_max_bul örneği).
Döngülerde Kullanım: Özellikle enumerate() veya sözlüklerin .items() metodu ile birlikte for döngülerinde unpacking sıkça kullanılır.
isimler = ["Ali", "Ayşe", "Can"] for indeks, isim in enumerate(isimler): # enumerate (indeks, değer) tuple'ları üretir print(f"{indeks}: {isim}") stok = {"elma": 5, "armut": 10} for urun, miktar in stok.items(): # items() (anahtar, değer) tuple'ları üretir print(f"{urun} -> {miktar} adet")
6.3. Genişletilmiş Açma (Extended Unpacking — *)
Python 3 ile birlikte, unpacking sırasında bir değişkenin önüne yıldız * koyarak, o değişkene geri kalan "eşleşmeyen" tüm öğelerin bir liste olarak atanmasını sağlayabiliriz. Bu, değişken sayısı ile öğe sayısının tam eşleşmediği durumlarda esneklik sağlar.

sayilar = (1, 2, 3, 4, 5, 6)
ilk, ikinci, *kalanlar = sayilar
print(f"İlk: {ilk}") # 1
print(f"İkinci: {ikinci}") # 2
print(f"Kalanlar: {kalanlar}") # 3, 4, 5, 6
ilk, *orta, son = sayilar
print(f"\nİlk: {ilk}") # 1
print(f"Orta: {orta}") # [2, 3, 4, 5]
print(f"Son: {son}") # 6
*baslangic, sondan_bir_onceki, son = sayilar
print(f"\nBaşlangıç: {baslangic}") # [1, 2, 3, 4]
print(f"Sondan Bir Önceki: {sondan_bir_onceki}") # 5
print(f"Son: {son}") # 6

* sadece bir değişkende kullanılabilir.

ilk, *orta1, *orta2, son = sayilar # SyntaxError: multiple starred expressions in assignment

Bölüm 7: Demetler ve Listelerin Karşılaştırılması
Demetler ve listeler birçok yönden benzer olsa da (sıralı, heterojen, yinelenen öğelere izin verir), aralarındaki temel farklar kullanım amaçlarını belirler.

ÖzellikDemet (Tuple)Liste (List)Tanımlama() (veya parantezsiz - packing)[]DeğiştirilebilirlikDeğiştirilemez (Immutable)Değiştirilebilir (Mutable)BoyutOluşturulduktan sonra sabitDinamik (büyüyebilir/küçülebilir)Metot SayısıAz (count, index)Çok (append, extend, sort, remove vb.)PerformansGenellikle biraz daha hızlı iterasyon/lookup, biraz daha az bellekGenellikle biraz daha yavaş, biraz daha fazla bellekSözlük Anahtarı OlabilmeEvet (iç öğeler de immutable ise)Hayır (çünkü mutable)Temel Kullanım AmacıSabit koleksiyonlar, değişmez veri yapıları, heterojen kayıtlar, fonksiyon dönüş değerleri, sözlük anahtarlarıHomojen veya heterojen öğe listeleri, sırası önemli ve içeriği değişebilen koleksiyonlar, yığın/kuyruk uygulamaları

Bölüm 8: Demetlerin Kullanım Alanları
Demetlerin değiştirilemez doğası ve diğer özellikleri, onları belirli senaryolar için listelerden daha uygun hale getirir:

Sabit Veri Koleksiyonları: Değişmemesi gereken değerler dizisi. Örneğin, haftanın günleri, ay adları, bir projenin sabit konfigürasyon ayarları, geometrik şekillerin köşe sayısı gibi.
HAFTANIN_GUNLERI = ("Pazartesi", "Salı", "Çarşamba", "Perşembe", "Cuma", "Cumartesi", "Pazar") print(f"Haftanın 3. günü: {HAFTANIN_GUNLERI[2]}") # HAFTANIN_GUNLERI[0] = "Yeni Pazartesi" # TypeError! Veri bütünlüğü korunur.
Sözlük Anahtarları: Daha önce belirtildiği gibi, birden fazla değerden oluşan bir anahtara ihtiyacınız olduğunda (ve bu değerlerin kendileri de değiştirilemez ise) demetler mükemmel bir çözümdür. Örneğin, (enlem, boylam) çiftlerini anahtar olarak kullanmak.
Fonksiyonlardan Birden Fazla Değer Döndürme: Bir fonksiyonun birden fazla sonuç üretmesi gerektiğinde, bu sonuçları bir demet içinde döndürmek standart ve temiz bir Python pratiğidir. Çağıran taraf bu demeti kolayca açabilir (unpack).
Veri Bütünlüğünü Garanti Etme: Bir fonksiyon veya metot, aldığı veri yapısını yanlışlıkla değiştirmemesi gerekiyorsa, bu veriyi demet olarak almak veya demete dönüştürmek güvenli bir yaklaşımdır.
String Formatlama: Eski stil % formatlama operatörü veya bazen str.format() metodu, formatlanacak değerleri içeren bir demet kabul edebilir.
isim = "Ayşe" yas = 25 print("Ad: %s, Yaş: %d" % (isim, yas)) # % operatörü sağda bir demet bekler
Heterojen Veri Kayıtları: Birbirine benzemeyen ancak ilişkili olan sabit bir veri grubunu temsil etmek için kullanılabilir. Örneğin, bir kişinin adı (string), yaşı (int) ve aktif olup olmadığı (bool) bilgisini tek bir yapıda tutmak: kisi = ("Ali", 35, True). (Bu kullanım alanı için NamedTuple'lar daha da okunabilir bir alternatif sunar.)
Performansın Kritik Olduğu Durumlar (Küçük Farklar): Çok büyük veri setleri üzerinde sıkça iterasyon yapılıyorsa veya üyelik testi gerçekleştiriliyorsa, demetlerin listelere göre (genellikle küçük de olsa) sağladığı performans avantajı ve daha düşük bellek kullanımı tercih sebebi olabilir.
Bölüm 9: İleri Konu: Adlandırılmış Demetler (Named Tuples)
Normal demetlerde öğelere sadece indeks numaralarıyla erişiriz (my_tuple[0], my_tuple[1] vb.). Bu, özellikle demet birden fazla öğe içerdiğinde kodun okunabilirliğini azaltabilir (örneğin, person[1]'in yaş mı yoksa boy mu olduğunu anlamak zor olabilir).

Python’un collections modülü, bu soruna bir çözüm olarak adlandırılmış demetleri (named tuples) sunar. Adlandırılmış demetler, normal demetler gibi değiştirilemez ve sıralıdır, ancak öğelerine hem indeks numaralarıyla hem de anlamlı isimlerle (nokta notasyonu kullanarak) erişmenizi sağlar.

collections.namedtuple fonksiyonu kullanılarak oluşturulurlar.

from collections import namedtuple

'Nokta' adında, 'x' ve 'y' alanlarına sahip bir adlandırılmış demet türü oluştur

Nokta = namedtuple("Nokta", ["x", "y"])

Bu türü kullanarak örnekler oluştur

nokta1 = Nokta(10, 20)
nokta2 = Nokta(x=-5, y=15) # Anahtar kelime argümanları da kullanılabilir

Öğelere erişim

print(f"Nokta 1: {nokta1}") # Nokta(x=10, y=20)
print(f"Nokta 1 - x (isimle): {nokta1.x}") # 10
print(f"Nokta 1 - y (isimle): {nokta1.y}") # 20
print(f"Nokta 2 - x (indeksle): {nokta2[0]}") # -5
print(f"Nokta 2 - y (indeksle): {nokta2[1]}") # 15

Adlandırılmış demetler hala değiştirilemezdir:

nokta1.x = 100 # AttributeError: can't set attribute

Adlandırılmış demetler, basit sınıflara (classes) hafif bir alternatif olarak, özellikle verileri gruplamak ve daha okunabilir hale getirmek için kullanışlıdır.

Sonuç
Python demetleri (Tuples), dilin temel veri yapılarından biridir ve değiştirilemez (immutable) olmalarıyla karakterize edilirler. Bu değişmezlik, onlara veri bütünlüğü sağlama, sözlük anahtarı olarak kullanılabilme ve potansiyel performans avantajları gibi önemli özellikler kazandırır.

Listelere benzer şekilde sıralı olmaları ve çeşitli veri tiplerini barındırabilmeleri, ancak öğe ekleme, silme veya değiştirme işlemlerine izin vermemeleri, demetleri belirli kullanım senaryoları için ideal kılar. Sabit veri koleksiyonlarını temsil etmek, fonksiyonlardan birden fazla değeri güvenli bir şekilde döndürmek ve kodun niyetini (verinin değişmemesi gerektiğini) açıkça belirtmek için demetler tercih edilir.

Demet paketleme (packing) ve açma (unpacking), Python’da sıkça kullanılan ve kod yazımını kolaylaştıran güçlü özelliklerdir. Özellikle değişken takası ve döngülerde kullanımı oldukça pratiktir.

Listeler ve demetler arasındaki farkları anlamak ve projenizin gereksinimlerine göre doğru veri yapısını seçmek, etkili ve sağlam Python kodu yazmanın önemli bir parçasıdır. Demetler, Python’un sunduğu veri yapıları araç kutusunda değerli ve sıklıkla başvurulan bir araçtır.

Abdulkadir Güngör - Kişisel WebSite
Abdulkadir Güngör - Kişisel WebSite
Abdulkadir Güngör - Özgeçmiş
Github
Github
Linkedin