Python "too many values to unpack (expected 2)" Hatası Nasıl Çözülür?

Python “too many values to unpack (expected 2)” hatası, sol taraftaki değişken sayısından daha fazla değer sağ taraftan geldiğinde oluşur. Python, liste veya tuple içindeki değerleri soldaki değişkenlere sırayla dağıtmaya çalışır; iki değişken varken üç değer gelirse eşleştirme tamamlanamaz.

Çözüm, sağdaki verinin kaç parçadan oluştuğunu kontrol etmek ve solda aynı sayıda hedef değişken kullanmaktır. Bazı durumlarda ise yıldızlı unpacking veya döngünün ürettiği veri yapısına uygun bir yöntem tercih edilir.

Bu hata ne anlama gelir? Değer sayısı neden eşleşmez?

Unpacking, bir iterable içindeki değerleri birden fazla değişkene ayırma işlemidir. Aşağıdaki örnekte sağ tarafta üç değer, sol tarafta ise iki değişken bulunur:

a, b = [10, 20, 30]

Bu kod çalıştırıldığında ValueError: too many values to unpack (expected 2) hatası alınır. Hata mesajındaki “expected 2” ifadesi, Python’ın sol tarafta iki hedef değişken beklediğini anlatır. Ancak liste üç değer içerdiği için üçüncü değer atanacak bir değişken bulamaz.

Değişken sayısı ile değer sayısı eşleştirildiğinde kod doğru çalışır:

a, b, c = [10, 20, 30]

print(a)
print(b)
print(c)

# Çıktı:
# 10
# 20
# 30

Aynı kural tuple için de geçerlidir. Liste ile tuple arasında bu hata açısından temel bir fark yoktur:

x, y = (10, 20)

print(x, y)

# Çıktı:
# 10 20

Özetle normal unpacking işleminde sağdaki iterable, soldaki hedeflerle aynı sayıda öğe içermelidir. Python’un atama kuralları, değerleri soldan sağa karşılık gelen hedeflere dağıtır.

Hatanın kaynağı dört farklı kullanım bağlamında nasıl teşhis edilir?

Aynı hata mesajı farklı kod örüntülerinden kaynaklanabilir. Özellikle for döngülerinde önemli olan, döngünün her turda gerçekten ne ürettiğini görmektir. enumerate() her turda indeks ve kayıt olmak üzere iki parçalı bir tuple üretirken, sözlükler doğrudan dolaşıldığında anahtarları üretir; anahtar-değer çifti için .items() kullanılmalıdır.

Bu ayrımı daha fazla örnekle pekiştirmek isteyenler, birebir Python dersleri kapsamında veri yapıları ve döngüler üzerine uygulama yapabilir.

1. Sağdaki öğe kaç parçalı? Liste, tuple veya kayıt içindeki değer sayısını kontrol et.
2. Döngü gerçekten neyi üretiyor? Kayıt mı, indeks-kayıt çifti mi, yoksa yalnızca tek bir anahtar mı geliyor?
3. Sözlükte key-value çifti gerekiyor mu? Gerekiyorsa sözlüğü doğrudan değil, .items() ile dolaş.
4. Fonksiyon kaç değer döndürüyor? return ile dönen değer sayısını soldaki değişkenlerle eşleştir.

Öğrenci notları listesindeki hatalı for döngüsü nasıl düzeltilir?

Her kaydın kaç değerden oluştuğunu, for döngüsünün sol tarafındaki değişken sayısıyla eşleştirmen gerekir. Aşağıdaki listede her tuple üç değer içeriyor: öğrenci adı, puan ve ders.

notlar = [
    ("Ayşe", 85, "Python"),
    ("Mert", 72, "Java")
]

for ogrenci, puan in notlar:
    print(ogrenci, puan)

Bu döngü çalıştırıldığında for ogrenci, puan ifadesi her kayıttan iki değer bekler. Ancak ilk kayıtta "Ayşe", 85 ve "Python" olmak üzere üç değer vardır. Bu nedenle Python, değerleri iki hedef değişkene yerleştiremez ve ValueError: too many values to unpack (expected 2) hatasını verir. for döngüsünde her öğe, atama işlemindeki kurallara göre hedeflere dağıtılır; yıldızlı hedef kullanılmadığında sayıların eşleşmesi gerekir.

Çözüm, kayıttaki üç alanı karşılayacak üç değişken kullanmaktır:

notlar = [
    ("Ayşe", 85, "Python"),
    ("Mert", 72, "Java")
]

for ogrenci, puan, ders in notlar:
    print(f"{ogrenci}: {puan} ({ders})")

Beklenen çıktı şöyledir:

Ayşe: 85 (Python)
Mert: 72 (Java)

Ders bilgisini kullanmayacaksan üçüncü hedefte genellikle alt çizgi kullanabilirsin:

for ogrenci, puan, _ in notlar:
    print(f"{ogrenci}: {puan}")

Buradaki _, üçüncü değerin bu döngünün içinde bilinçli olarak kullanılmadığını gösterir. Değer yine kayıttan alınır; yalnızca bir değişken adıyla kullanılmaz. Birden fazla değeri toplamak veya bilinçli olarak yok saymak gerektiğinde ise yıldızlı unpacking farklı bir çözüm sunar.

Yıldızlı unpacking ne zaman kullanılır, hangi veriler kaybolabilir?

Değer sayısı değişebilen bir listeyi parçalarken * işaretli hedef, kendisinden sonra kalan değerleri bir liste olarak toplar:

first, *rest = [10, 20, 30, 40]

print(first)
print(rest)

Beklenen çıktı:

10
[20, 30, 40]

Yıldızlı hedef ortada da bulunabilir. Bu durumda baştaki ve sondaki değerler ayrı hedeflere, aradaki değerler ise yıldızlı hedefe atanır:

first, *middle, last = [10, 20, 30, 40]

print(first)
print(middle)
print(last)

Bu kodda first değeri 10, middle değeri [20, 30] ve last değeri 40 olur. Python, yıldızlı hedefe kalan öğeleri liste olarak atar.

Ancak yıldızlı unpacking her fazla değeri otomatik olarak görmezden gelmek için kullanılmamalıdır. first, *_ = values yazarsan ilk değer alınır, kalan değerler bilinçli olarak atılır. Bu yaklaşım, sabit yapıda olması gereken bir kayda beklenmeyen alanlar eklendiğinde hatayı maskeleyebilir ve veri kaybına yol açabilir.

Karar vermeden önce şu soruyu sor: Değer sayısı gerçekten değişken mi, yoksa beklenmeyen fazlalığı gizlemek mi istiyorum? Değer sayısı gerçekten değişkense yıldızlı unpacking uygundur. Kayıtların şeması sabitse, tüm alanları açık adlarla karşılamak hatayı fark etmeyi ve veriyi korumayı kolaylaştırır.

len() ve type() ile hata nasıl adım adım ayıklanır?

Hatanın kaynağını bulmanın en kısa yolu, döngüye giren verinin türünü ve içindeki öğelerin yapısını kontrol etmektir. type() nesnenin türünü, len() ise bir koleksiyondaki veya kayıttaki öğe sayısını gösterir.

1. Döngüye giren ana verinin type() değerini kontrol et.
2. Dış koleksiyonun len() değerini ve örnek bir öğesini yazdır.
3. Tek bir kaydın type(), len() ve içeriğini incele.
4. Sağdaki öğenin parça sayısını, soldaki hedef değişken sayısıyla karşılaştır.
5. Verinin şekline uygun döngü biçimini seç: tek değişken, iki değişken veya daha fazla değişken kullan.

Örneğin her not kaydı üç parçadan oluşuyorsa aşağıdaki teşhis kodu yapıyı görünür hâle getirir:

notlar = [
    ("Ada", 85, "Python"),
    ("Mert", 92, "Java"),
]

print(type(notlar), len(notlar))

kayit = notlar[0]
print(type(kayit), len(kayit), kayit)

# Hatalı: for ad, puan in notlar
for ad, puan, ders in notlar:
    print(ad, puan, ders)

<class 'list'> 2
<class 'tuple'> 3 ('Ada', 85, 'Python')
Ada 85 Python
Mert 92 Java

Burada dış yapı iki kayıt içeren bir liste, tek kayıt ise üç öğeli bir tuple’dır. Bu nedenle iki değişkenli döngü kullanılırsa sağdaki kayıt üç değer ürettiği için ValueError oluşur.

Sözlüklerde de aynı kontrol mantığı geçerlidir. for anahtar, deger in veriler yazıldığında döngü doğrudan anahtarlar üzerinde ilerler; anahtar bir metinse karakterlerine ayrılmaya çalışılabilir. Anahtar-değer çifti için for anahtar, deger in veriler.items() kullanılmalıdır. items(), her öğeyi iki parçalı (anahtar, değer) çifti olarak verir.

try-except ile ValueError yakalanıp continue kullanılması hatayı yalnızca gizler:

for kayit in notlar:
    try:
        ad, puan = kayit
    except ValueError:
        continue

Bu yaklaşım hatalı veri kaydını sessizce atlayabilir; kaynak verinin neden üç parçalı olduğunu veya açma biçiminin neden iki değişken beklediğini düzeltmez. Önce verinin gerçek yapısını incelemek, ardından döngüyü bu yapıya eşleştirmek daha güvenlidir. İstisna yakalama kullanılacaksa sorunlu kayıt en azından raporlanmalıdır.

Bu konudaki temel bilgini ölçmek için ücretsiz Python ve algoritmik düşünme bilgi testlerini çözebilirsin.

Sık Sorulan Sorular

“too many values to unpack (expected 2)” ile “not enough values to unpack” arasındaki fark nedir?

İlkinde sağ taraftan beklenenden fazla değer gelir; ikincisinde beklenen değişkenleri dolduracak kadar değer gelmez. Örneğin iki değişkene üç değer vermek ilk hatayı, iki değişkene tek değer vermek ikinci hatayı oluşturur.

Sözlükte anahtar ve değerleri dolaşırken neden items() kullanmak gerekir?

Sözlük üzerinde doğrudan dolaşmak anahtarları üretir. Hem anahtarı hem değeri almak için items() kullanılmalıdır; çünkü bu yöntem her öğeyi iki parçalı bir çift olarak sunar.

enumerate() kullanırken bir kaydı hem sıra numarasıyla hem de alanlarıyla nasıl açabilirim?

İç içe unpacking kullanabilirsin: for sira, (ad, puan, ders) in enumerate(notlar, start=1):. İlk değişken sıra numarasını, parantez içindeki değişkenler ise kaydın alanlarını alır. İlk çıktı 1 Ada 85 Python olur. enumerate() her adımda sıra numarası ve öğeden oluşan bir tuple verir.

Yıldızlı unpacking, beklenenden fazla gelen her değeri güvenli biçimde çözmek için kullanılabilir mi?

Hayır. ilk, *orta, son = veriler biçimi fazladan değerleri orta listesinde toplar; ancak verinin gerçekten bu yapıya uygun olduğunu doğrulamaz. Beklenmeyen kayıtları otomatik olarak doğru hâle getirmez.

try-except ile bu hatayı yakalayıp programı sürdürmek neden çoğu durumda iyi bir çözüm değildir?

Çünkü hatalı kayıt sessizce atlanabilir ve veri kaybı fark edilmeyebilir. try-except, beklenen ve raporlanabilir hatalar için kullanılmalı; veri yapısı ile unpacking biçimi arasındaki uyumsuzluğun yerine geçmemelidir.

Unpacking hatalarında en güvenilir yol, önce verinin gerçek şeklini görmek, sonra soldaki değişkenleri bu şekle göre düzenlemektir.