Listeler, demetler ve referans sezgisi

Şimdiye kadar bir değişkende çoğunlukla tek bir değer tuttuk. Gerçek programlarda ise bir öğrencinin sınav puanları, bir ürünün haftalık satışları veya bir sınıftaki isimler gibi birden fazla değeri birlikte saklamak gerekir.

Bu hafta Python’ın iki temel koleksiyonunu (birden fazla değeri bir arada tutan yapı) öğreneceğiz: liste (list) ve demet (tuple). Ayrıca iki değişken aynı listeyi gösterdiğinde ne olduğuna bakacağız. Bu durum, listenin içeriği sonradan değiştirilebildiği için ortaya çıkar.

Bu bölümün kapsamı

NoteSınavda sorulur

• İndeks ve dilimle liste elemanlarına erişim
• append(), remove() ve in davranışları
• sort() ile sorted() farkı
• Liste ile demet ayrımı ve fonksiyondan dönen demeti açma
• Aynı nesnenin paylaşılması ve bağımsız kopya oluşturma
• Üzerinde dolaşılan listeyi aynı anda değiştirmenin riski
• Boş listenin ortalama ve maksimum hesabında uç durum olması

NoteSınav dışı (bilgi amaçlı)

• Liste kavraması (list comprehension)
• Tek elemanlı demetin (5,) biçiminde yazılması
• copy.deepcopy() ile derin kopyalama

Bu başlıklar konunun devamıdır; ileride karşınıza çıkar ama bu derste ezberlemeniz beklenmiyor.

b = a yazdım; neden ikisi birden değişti?

Bu bölümde en çok baş ağrıtan hata bu. Bir listeyi ikinci bir ada bağlamak kopya oluşturmaz. İki ad bellekteki aynı listeyi gösterir; birinde yaptığınız değişikliği ötekinde de görürsünüz.

Liste oluşturmak

Bir liste köşeli parantezlerle oluşturulur:

puanlar = [70, 85, 92, 60]

Liste değerleri belirli bir sırayla tutar ve her değerin bir konumu (indeksi) vardır.

Değer:   70   85   92   60
İndeks:   0    1    2    3

String’lerde olduğu gibi indeksler 0’dan başlar.

puanlar = [70, 85, 92, 60]

print(puanlar[0])
print(puanlar[2])
print(puanlar[-1])

Çıktı:

70
92
60

Liste dilimleme

Geçen hafta string’lerde kullandığımız dilimleme söz dizimi listelerde de çalışır:

puanlar = [70, 85, 92, 60, 78]

print(puanlar[1:4])
print(puanlar[:3])
print(puanlar[-2:])

Çıktı:

[85, 92, 60]
[70, 85, 92]
[60, 78]

String dilimlemede olduğu gibi başlangıç dâhil, bitiş hariçtir. Ancak önemli bir fark vardır: sonuç artık string değil, yeni bir liste olur.

Tam dilim ([:], başı ve sonu boş bırakılmış dilim) listenin kopyasını verir:

orijinal = [1, 2, 3]
kopya = orijinal[:]

kopya.append(4)
print(orijinal)  # [1, 2, 3]
print(kopya)     # [1, 2, 3, 4]

Bu derste çoğunlukla .copy() kullanacağız, çünkü kopya istediğimizi daha açık gösterir. Başka kaynaklarda liste[:] görürseniz onun da aynı işi yaptığını bilin. İkisi de sığ kopya (shallow copy) oluşturur: liste yenidir ama elemanlar kopyalanmaz. İçinde başka liste olmayan (tek seviyeli) bir listede bu ayrıntı sorun çıkarmaz.

Liste elemanını değiştirmek

Geçen hafta string’lerin değiştirilemez olduğunu gördük: bir string’in tek bir harfini yerinde değiştiremezsiniz. Listeler ise değiştirilebilir (mutable): bir elemanını yerinde değiştirebilirsiniz.

puanlar = [70, 85, 92]
puanlar[0] = 75

print(puanlar)

Sonuç:

[75, 85, 92]

Burada yeni bir liste oluşturulmadı; mevcut listenin ilk elemanı değiştirildi.

Important

Liste indeksi de listenin sınırları içinde kalmalıdır. Üç elemanlı bir listede geçerli pozitif indeksler 0, 1 ve 2’dir.

append(), remove() ve in

Listenin sonuna yeni eleman eklemek için append() kullanılır:

urunler = ["defter", "kalem"]
urunler.append("silgi")

print(urunler)

Çıktı:

['defter', 'kalem', 'silgi']

Belirli bir değeri listeden kaldırmak için remove() kullanılabilir:

urunler.remove("kalem")
print(urunler)

Çıktı:

['defter', 'silgi']

remove() ilk eşleşen değeri siler. Değer listede yoksa Python ValueError verir. Bu yüzden silmeden önce değerin listede olup olmadığını kontrol etmek isteyebilirsiniz:

if "kalem" in urunler:
    urunler.remove("kalem")

in, bir değerin listede olup olmadığını denetler ve True ya da False verir:

print("silgi" in urunler)
print("cetvel" in urunler)

Note

append() ve remove() yeni bir liste döndürmez, var olan listeyi değiştirir. Bu yüzden liste = liste.append(x) yazmayın.

Listeye ekleme ve listeden silme

Tahmin et: liste nasıl değişir?

Aşağıdaki kodu çalıştırmadan önce her print() satırının çıktısını tahmin edin:

Sonra çalıştırıp tahmininizi karşılaştırın.

Alıştırma: eksik puanı ekleyin

Bir öğrencinin üç sınav puanı listede tutuluyor. Dördüncü puan olan 88 değerini listeye ekleyin.

Beklenen sonuç:

[72, 80, 91, 88]

puanlar.append(88) yazabilirsiniz.

puanlar = [72, 80, 91]
puanlar.append(88)

print(puanlar)

Liste üzerinde for ile gezinmek

Bir listedeki her elemanı sırayla işleyebiliriz:

puanlar = [70, 85, 92]

for puan in puanlar:
    print(puan)

Burada puan, her yinelemede listenin sıradaki değerini alır.

Bir toplam hesabı:

puanlar = [70, 85, 92]
toplam = 0

for puan in puanlar:
    toplam = toplam + puan

print(toplam)

Listede gezinmek için çoğu zaman range() gerekmez. Yalnızca elemanlar lazımsa for ile doğrudan listede dolaşmak daha okunur.

WarningDolaştığınız listeden aynı döngüde eleman silmeyin

Şöyle bir kod bazı elemanları atlayabilir:

sayilar = [1, 2, 2, 3]

for sayi in sayilar:
    if sayi == 2:
        sayilar.remove(sayi)

Döngü sürerken listenin uzunluğu ve elemanların konumu değişir. Bu yüzden bazı elemanlar hiç işlenmeden atlanabilir. Daha güvenli yol, tutmak istediğiniz değerleri yeni bir listeye eklemek ya da gerçekten gerekiyorsa listenin kopyasında dolaşmaktır.

Ortalama hesaplamak

Bir listenin ortalaması için önce toplamı, sonra eleman sayısını kullanabiliriz:

puanlar = [70, 85, 92, 73]

toplam = 0
for puan in puanlar:
    toplam = toplam + puan

ortalama = toplam / len(puanlar)
print(ortalama)

Python’da toplamı veren sum() gibi hazır fonksiyonlar da var. Yine de bu aşamada toplamı döngüyle hesaplıyoruz, çünkü böylece biriktiricinin nasıl çalıştığını görürsünüz.

Warning

Boş listenin eleman sayısı 0’dır. toplam / len(puanlar) ifadesi boş listede sıfıra bölme hatası verir. 7. haftada gördüğümüz gibi bu bir uç durumdur.

Minimum ve maksimum

Python listelerinde en küçük ve en büyük değeri doğrudan bulmak için min() ve max() kullanılabilir:

puanlar = [70, 85, 92, 60]

print(min(puanlar))  # 60
print(max(puanlar))  # 92

Yine de en büyük değeri döngüyle bulmayı (maksimum arama kalıbı) bilmeniz gerekir. İleride “puanı en yüksek öğrencinin adı” gibi sorularda sayının yanında o puanın kime ait olduğunu da bulmamız gerekecek.

Boş olmayan bir liste için ilk elemanı başlangıç kabul edebiliriz:

puanlar = [70, 85, 92, 60]
en_yuksek = puanlar[0]

for puan in puanlar[1:]:
    if puan > en_yuksek:
        en_yuksek = puan

print(en_yuksek)

Adım adım:

1. İlk değeri “şimdiye kadarki en yüksek” kabul et.
2. Kalan her değeri bununla karşılaştır.
3. Daha yüksek değer bulursan en_yuksek değerini güncelle.

Important

Bu kalıp listenin boş olmadığını varsayar. Boş listede puanlar[0] ve max(puanlar) hata verir. Fonksiyonu yazarken “liste boş gelirse ne döndürecek?” sorusunu da cevaplamalı ve bunu fonksiyonun sözleşmesine yazmalısınız. 11. haftada kayıtlarla çalışırken bu durumu None döndürerek ele alacağız.

Sıralama: sort() ve sorted()

Bir listeyi küçükten büyüğe sıralamanın iki yolu vardır:

puanlar = [70, 92, 60, 85]

puanlar.sort()
print(puanlar)

sort() mevcut listeyi değiştirir.

Orijinal sırayı korumak istiyorsanız sorted() kullanın; bu fonksiyon yeni bir liste döndürür:

puanlar = [70, 92, 60, 85]
sirali = sorted(puanlar)

print(puanlar)  # [70, 92, 60, 85]
print(sirali)   # [60, 70, 85, 92]

Ters sıralama için:

print(sorted(puanlar, reverse=True))

Sıralama algoritmalarını bu derste kendimiz yazmayacağız; onları Veri Yapıları ve Programlama dersinde ayrıntılı göreceğiz. Burada var olan listeyi sıralamakla yeni bir sıralı liste almak arasındaki farkı bilmeniz yeterli.

Alıştırma: geçen puanları sayın

Aşağıdaki listede 60 ve üzeri kaç puan olduğunu bulun.

Beklenen sonuç 3’tür.

if puan >= 60: koşulu içinde sayacı bir artırın.

puanlar = [45, 60, 72, 38, 90, 59]
gecen_sayisi = 0

for puan in puanlar:
    if puan >= 60:
        gecen_sayisi = gecen_sayisi + 1

print(gecen_sayisi)

Listeye koşullu eleman eklemek

Bir listedeki bazı değerlerden yeni bir liste oluşturabiliriz:

sicakliklar = [12, 25, 31, 18, 35]
sicak_gunler = []

for sicaklik in sicakliklar:
    if sicaklik >= 30:
        sicak_gunler.append(sicaklik)

print(sicak_gunler)

Sonuç:

[31, 35]

Buna filtreleme denir: yalnızca koşulu sağlayan elemanlar yeni listeye eklenir.

Demet (tuple)

Demet de liste gibi değerleri belirli bir sırayla tutar, ama oluşturulduktan sonra elemanları değiştirilemez. Demet köşeli parantezle değil, normal parantezle yazılır:

koordinat = (41.2867, 36.33)

print(koordinat[0])
print(koordinat[1])

Bir demetin elemanına yeniden değer atayamayız:

koordinat = (41.2867, 36.33)
# koordinat[0] = 42   # Geçerli değildir.

Bu yüzden seçim şöyle yapılır:

• Liste: içerik zamanla değişecekse.
• Demet: birkaç değer birlikte küçük ve sabit bir grup oluşturuyorsa.

Örneğin bir rengin RGB bileşenleri (kırmızı, yeşil, mavi) ya da bir konumun enlem ve boylamı demette tutulabilir.

Tek elemanlı demet tuzağı (sınav dışı)

Parantez tek başına demet oluşturmaz:

x = (5)
y = (5,)

print(type(x))  # int
print(type(y))  # tuple

Tek elemanlı demeti sondaki virgül belirler. (5) yalnızca 5 ifadesini paranteze alır; (5,) ise bir elemanlı demettir.

Demet açma ve fonksiyondan birden fazla değer döndürme

Demetteki değerleri ayrı değişkenlere alabiliriz:

boyut = (1920, 1080)
genislik, yukseklik = boyut

print(genislik)
print(yukseklik)

Buna demet açma (tuple unpacking) denir.

return satırında değerleri virgülle ayırırsak Python bunları tek bir demette toplar:

def sinirlar():
    return 0, 100

sonuc = sinirlar()
print(sonuc)       # (0, 100)
print(type(sonuc)) # tuple

Şu iki return aynı demeti döndürür:

return 0, 100
return (0, 100)

Çağıran tarafta demeti doğrudan açabiliriz:

alt, ust = sinirlar()
print(alt)
print(ust)

Aynı listeye referans verme

Listeler değiştirilebilir olduğu için şu davranışa dikkat etmek gerekir:

liste1 = [10, 20, 30]
liste2 = liste1

liste2.append(40)

print(liste1)
print(liste2)

İki çıktı da:

[10, 20, 30, 40]

olur.

Çünkü liste2 = liste1 ataması ikinci bir liste oluşturmaz. İki değişken bellekteki aynı liste nesnesini gösterir. Bu duruma aynı nesneye referans verme (aliasing) denir.

Bunu şöyle düşünebilirsiniz:

liste1 ─┐
        ├──> [10, 20, 30]
liste2 ─┘

liste2 ile yaptığınız değişiklik bu tek listeyi değiştirir. Bu yüzden liste1’i yazdırdığınızda da aynı değişikliği görürsünüz.

Tahmin et: iki değişken mi, iki liste mi?

Çalıştırmadan önce çıktıyı tahmin edin:

Sonucu görünce “Python a’yı gizlice değiştirdi” diye düşünmeyin. Ortada tek bir liste var ve iki ad da onu gösteriyor.

Bağımsız kopya oluşturmak

Bağımsız bir liste gerekiyorsa .copy() kullanabiliriz:

orijinal = [1, 2, 3]
kopya = orijinal.copy()

kopya.append(4)

print(orijinal)
print(kopya)

Çıktı:

[1, 2, 3]
[1, 2, 3, 4]

Daha önce gördüğümüz orijinal[:] de aynı sonucu verir. İç içe listelerin kopyalanmasına bu derste girmiyoruz; .copy() ile tam dilimin sığ kopya oluşturduğunu bilmeniz yeterli.

Aynı listeyi paylaşma ve kopyalama

Alıştırma: bağımsız çalışma listesi

Aşağıdaki kodda taslak listesine yapılan değişiklik orijinal listeyi de değiştiriyor. taslak için bağımsız bir kopya oluşturun.

Beklenen:

Orijinal: ['A', 'B', 'C']
Taslak: ['A', 'B', 'C', 'D']

taslak = orijinal.copy() yazın.

orijinal = ["A", "B", "C"]
taslak = orijinal.copy()

taslak.append("D")

print("Orijinal:", orijinal)
print("Taslak:", taslak)

Fonksiyona liste vermek

Bir fonksiyona argüman olarak liste de verebiliriz:

def en_az_gecen_sayisi(puanlar):
    adet = 0

    for puan in puanlar:
        if puan >= 60:
            adet = adet + 1

    return adet

print(en_az_gecen_sayisi([45, 70, 81, 50]))

Sonuç 2’dir.

Fonksiyon listeyi yalnızca okuyorsa ne yaptığını izlemek kolaydır. append() ya da indeksle atama yaparak listeyi değiştiriyorsa çağıran koddaki liste de değişir, çünkü fonksiyon listenin kopyasıyla değil kendisiyle çalışır.

Tip

Bir fonksiyonu kullanan kişi, ona verdiği listenin değişip değişmeyeceğini bilmelidir. Hesap yapan fonksiyonlarda listeyi yalnızca okuyun; yeni bir sonuç gerekiyorsa onu döndürün.

Üret: ölçüm özetini hesaplayın

Bir sensörün sıcaklık ölçümleri şu listede olsun:

olcumler = [18.5, 21.0, 19.5, 24.0, 22.5]

olcum_ozeti(olcumler) adlı bir fonksiyon yazın. Fonksiyon:

• Toplamı döngüyle hesaplamalı,
• Ortalamayı bulmalı,
• 20 ve üzeri ölçümlerin sayısını hesaplamalı,
• Sonucu (ortalama, sicak_olcum_sayisi) biçiminde bir demet olarak döndürmeli.

Başlangıç:

Beklenen yaklaşık sonuç:

(21.1, 3)

Toplam ve 20 üzeri sayaç için iki ayrı biriktirici kullanabilirsiniz. Ortalama toplam / len(olcumler) olur.

def olcum_ozeti(olcumler):
    toplam = 0
    sicak_olcum_sayisi = 0

    for olcum in olcumler:
        toplam = toplam + olcum
        if olcum >= 20:
            sicak_olcum_sayisi = sicak_olcum_sayisi + 1

    ortalama = toplam / len(olcumler)
    return ortalama, sicak_olcum_sayisi

ortalama, sicak_sayisi = olcum_ozeti([18.5, 21.0, 19.5, 24.0, 22.5])
print(ortalama)
print(sicak_sayisi)

Dikkat edin: return ortalama, sicak_olcum_sayisi satırı (ortalama, sicak_olcum_sayisi) demetini döndürür. Çağıran taraf ortalama, sicak_sayisi = ... yazarak iki değeri doğrudan ayrı değişkenlere alır.

Sınav provası

Önce kendi cevabınızı seçin, sonra cevap anahtarında her şıkkın neden doğru ya da yanlış olduğunu okuyun. Yanlış şıklar rastgele yazılmadı; bu konuda öğrencilerin gerçekten yaptığı hatalardan seçildi. Sınav soruları da aynı yolla hazırlanır.

Madde 1. [10, 20, 30, 40][1:3] ifadesinin sonucu nedir?

• A. 20 ve 30 ayrı ayrı
• B. [20, 30, 40]
• C. [10, 20, 30]
• D. [20, 30]
• E. [10, 20]

Madde 2. append() ve remove() sırasıyla ne yapar?

• A. append() başa ekler; remove() son elemanı siler
• B. append() sona ekler, remove() verilen değeri siler
• C. append() listeyi sıralar; remove() listeyi boşaltır
• D. İkisi de yeni bir liste döndürür
• E. append() eleman ekler; remove() verilen indeksteki elemanı siler

Madde 3. Aşağıdaki program ne yazdırır?

sayilar = [3, 1, 2]
yeni = sayilar.sort()
print(yeni)

• A. None
• B. Hata verir; sort() bir değişkene atanamaz
• C. [1, 2, 3]
• D. Boş liste
• E. [3, 1, 2]

Madde 4. sort() ile sorted() arasındaki temel fark nedir?

• A. İkisi aynıdır; sorted() yalnızca daha yeni yazımdır
• B. sort() artan, sorted() azalan sırada sıralar
• C. sort() yerinde sıralar, sorted() yeni liste döndürür
• D. sort() sayılarda, sorted() metinlerde çalışır
• E. sorted() listeyi yerinde değiştirir, sort() kopyalar

Madde 5. Liste ile demet arasındaki temel fark nedir?

• A. Demet indekslenemez, yalnızca döngüyle okunur
• B. Liste yalnızca sayı, demet yalnızca metin tutar
• C. Liste değiştirilebilir, demet değiştirilemez
• D. Liste sıralı, demet sırasızdır
• E. Liste bellekte, demet diskte tutulur

Madde 6. Aşağıdaki fonksiyon ne tür bir değer döndürür ve çağıran tarafta nasıl açılır?

def en_kucuk_en_buyuk(sayilar):
    return min(sayilar), max(sayilar)

• A. Demet döndürür; a, b = en_kucuk_en_buyuk(liste) ile açılır
• B. Yalnızca min(sayilar) döner; ikinci değer yok sayılır
• C. Bir liste döndürür; append() ile genişletilebilir
• D. İki ayrı değer döndürür; her biri için ayrı bir çağrı gerekir
• E. Hata verir; return tek bir değer alabilir

Madde 7. Aşağıdaki program ne yazdırır?

a = [1, 2, 3]
b = a
b.append(4)
print(a)

• A. [4]
• B. [1, 2, 3]
• C. None
• D. [1, 2, 3, 4]
• E. Hata verir; bir liste iki değişkene atanamaz

Madde 8. Tek seviyeli bir listenin bağımsız kopyasını üretmek için hangisi kullanılır?

• A. b = a.append()
• B. b = a
• C. b = sorted(a) her zaman doğru kopyalama yöntemidir
• D. b = list
• E. b = a.copy() veya b = a[:]

Madde 9. Üzerinde for ile dolaşılan bir listeden aynı anda remove() yapmak neden risklidir?

• A. Riskli değildir; remove() döngüyle uyumludur
• B. Döngü hiç bitmez, sonsuza kadar döner
• C. Python bu işlemi engeller ve hata verir
• D. Liste döngü sırasında kendiliğinden demete dönüşür
• E. Silinen elemandan sonrakiler atlanabilir

Madde 10. Boş liste ortalama hesabında neden özel bir durumdur?

• A. Boş listede len() çalışmaz
• B. Eleman sayısı sıfırdır, bölme işlemi hata verir
• C. Boş listenin ortalaması kendiliğinden 0 olur
• D. Boş liste Python’da None ile aynıdır
• E. Özel bir durum değildir; ortalama her listede hesaplanabilir

TipCevaplar ve gerekçeler

Madde 1. Doğru: D. Dilimlemede başlangıç dâhil, bitiş hariçtir; 3 numaralı eleman alınmaz.

• A yanlış: Dilimin sonucu tek bir listedir; ayrı değerler değil.
• B yanlış: Bitiş indeksi dilime girmez.
• C yanlış: Başlangıç 1 olduğu için ilk eleman alınmaz.
• E yanlış: Dilim 1’den başlar, 0’dan değil.

Madde 2. Doğru: B. append() elemanı listenin sonuna ekler. remove() indekse değil değere göre çalışır ve yalnızca ilk eşleşmeyi kaldırır.

• A yanlış: Ekleme ile silmenin listenin iki ayrı ucunda yapıldığı düşünülünce simetrik görünür. Ama append() sona ekler; son elemanı silmek pop() işidir.
• C yanlış: İki metot da listeyi değiştirdiği için listeyi değiştiren öteki metotlarla karışabilir. Ama sıralama sort(), boşaltma clear() işidir.
• D yanlış: String metotları yeni değer döndürdüğü için liste metotlarının da öyle yaptığı sanılır. Ama ikisi de listeyi yerinde değiştirir ve None döndürür.
• E yanlış: Listelerde çoğu işlem indeksle yapıldığı için remove()un da indeks aldığı sanılır. Ama remove() indeks değil değer alır; indeksle silmek için del ya da pop() kullanılır.

Madde 3. Doğru: A. sort() listeyi yerinde sıralar ve None döndürür. Sıralı liste isteniyorsa sorted() kullanılır.

• B yanlış: Atanabilir; atanan değer None olur.
• C yanlış: Bu, sorted(sayilar) sonucudur; sort() yeni liste döndürmez.
• D yanlış: Liste boşalmaz; yerinde sıralanır.
• E yanlış: yeni değişkeni listeyi değil, sort()un dönüş değerini tutar.

Madde 4. Doğru: C. sort() listeyi yerinde sıralar ve None döndürür. sorted() özgün listeyi bozmadan yeni bir sıralı liste döndürür. Özgün sıranın korunması gerekiyorsa sorted(), gerekmiyorsa sort() seçilir.

• A yanlış: İkisi de sonunda sıralı bir liste gösterdiği için aynı sanılır. Ama davranışları farklıdır; biri yerinde çalışır, öteki yeni bir liste döndürür.
• B yanlış: İki ayrı ad görünce iki ayrı yön bekleyen öğrenci bunu seçer. Ama ikisi de varsayılan olarak artan sıralar; yön reverse ile değiştirilir.
• D yanlış: İki ayrı fonksiyonun ayrı türler için yazıldığı sanılabilir. Ama ikisi de her iki türle çalışır.
• E yanlış: İkisinin farklı çalıştığını bilen ama hangisinin ne yaptığını karıştıran öğrenci bunu seçer. Görevler ters yazılmış; sorted() özgün listeye dokunmaz.

Madde 5. Doğru: C. Listeye oluşturulduktan sonra eleman eklenip çıkarılabilir; demet oluşturulduktan sonra değiştirilemez. Demet seçmek, bu değerlerin program boyunca değişmeyeceğini de gösterir.

• A yanlış: Demetin değiştirilemediğini bilen öğrenci ona köşeli parantezle erişilemeyeceğini de düşünebilir. Ama demet indekslenebilir; yalnızca elemanı değiştirilemez.
• B yanlış: Farklı yapıların farklı türler için olduğu düşünülebilir. Ama ikisi de her türü tutabilir.
• D yanlış: Sırasız bir koleksiyon olan kümeyle karıştırıldığı için akla gelir. Ama ikisi de sıralıdır; sırasız olan kümedir.
• E yanlış: Değişmeyen verinin kalıcı bir yerde saklandığı düşünülebilir. Ama ikisi de bellekte tutulur.

Madde 6. Doğru: A. Virgülle ayrılmış birden fazla değer tek bir demet olarak döner. Çağıran tarafta kucuk, buyuk = en_kucuk_en_buyuk(liste) gibi bir satırla ayrı adlara açılabilir.

• B yanlış: returnun fonksiyonu hemen bitirdiğini bilen öğrenci ilk değerden sonrasının kaybolduğunu düşünebilir. Ama ikisi de döner; return virgülle birden fazla değer taşıyabilir.
• C yanlış: Birden fazla değeri bir arada tutan yapı denince akla önce liste gelir. Ama köşeli parantez yazılmadığı için sonuç demettir ve demete append() uygulanamaz.
• D yanlış: return satırında iki ayrı fonksiyon çağrısı göründüğü için iki ayrı sonuç beklenir. Ama tek çağrı yeter; dönen tek değer, iki eleman taşıyan bir demettir.
• E yanlış: Önceki örneklerde return hep tek değer döndürdüğü için bu bir kural sanılabilir. Ama virgülle ayrılan değerler tek bir demet oluşturur; bu geçerlidir.

Madde 7. Doğru: D. b = a kopya oluşturmaz; iki ad aynı listeyi gösterir. b ile yapılan ekleme ada da görünür.

• A yanlış: append() var olan elemanları silmez.
• B yanlış: a bağımsız bir kopya değildir; b üzerinden yapılan değişiklik onu da etkiler.
• C yanlış: a bir listedir; yazdırılan liste içeriğidir.
• E yanlış: Aynı nesneye istenildiği kadar ad bağlanabilir.

Madde 8. Doğru: E. İkisi de yeni bir liste nesnesi oluşturur; tek seviyeli listelerde bağımsız kopya sağlar.

• A yanlış: append() eleman ekler ve None döndürür; ayrıca argüman ister.
• B yanlış: Bu yalnızca ikinci bir ad oluşturur; nesne aynı kalır.
• C yanlış: Yeni bir liste döndürür ama sırayı da değiştirir; kopyalama amacıyla seçilmez.
• D yanlış: Bu, list türünün kendisini bye bağlar; kopya oluşturmaz.

Madde 9. Doğru: E. Eleman silinince sonraki elemanlar öne kayar ama döngü bir sonraki konumdan devam eder; kayan eleman işlenmeden atlanır. Bu yüzden ya yeni bir liste kurulur ya da listenin bir kopyası üzerinde dolaşılır.

• A yanlış: Küçük örneklerde sonuç çoğu zaman doğru çıktığı için sorun fark edilmeyebilir. Ama art arda silinmesi gereken elemanlardan biri atlanır ve bu gözden kaçan bir hataya yol açar.
• B yanlış: Döngü sırasında liste değiştiği için döngünün sonunu bulamayacağı sanılabilir. Ama döngü sonlanır; sorun bazı elemanların hiç işlenmemesi.
• C yanlış: Riskli bir işlemin Python tarafından engelleneceği beklenir. Ama çoğu zaman hata vermez, yanlış sonuçla devam eder; tehlikeli olan da budur.
• D yanlış: Döngü sırasında listenin korunması gerektiği fikri demetin değiştirilemezliğini akla getirir. Ama tür değişmez; liste liste olarak kalır.

Madde 10. Doğru: B. Ortalama, toplamın eleman sayısına bölünmesidir. Boş listede eleman sayısı sıfır olduğu için ZeroDivisionError çıkar. Bu yüzden boş veri durumu ayrıca denetlenir: fonksiyon ya None döndürür ya da açık bir hata bildirir.

• A yanlış: Sayılacak eleman olmadığı için len()in çalışmayacağı sanılabilir. Ama len([]) sonucu 0’dır ve sorunsuz çalışır; sorun o 0’a bölmektir.
• C yanlış: Toplamı 0 olan bir listenin ortalamasının da 0 olacağı düşünülebilir. Ama Python kendiliğinden 0 vermez; bölme hata verir.
• D yanlış: İkisi de “veri yok” gibi düşünüldüğü için karıştırılır. Ama [] bir listedir; None ayrı bir değerdir.
• E yanlış: Ortalama formülü her listede aynı olduğu için her zaman çalışacağı düşünülebilir. Ama boş listede hesaplanamaz; bölen sıfır olur.

Tek sayfa özet

Bu hafta birden fazla değeri birlikte tutmaya başladık.

• Liste sıralı ve değiştirilebilir bir koleksiyondur.
• String dilimleme söz dizimi listelerde de çalışır; dilim yeni bir liste verir ve liste[:] sığ kopya oluşturur.
• Liste elemanlarına indeksle erişilebilir ve elemanlar değiştirilebilir.
• append() listenin sonuna eleman ekler; remove() ilk eşleşen değeri siler; in değerin listede olup olmadığını söyler.
• Üzerinde dolaşılan listeyi aynı anda remove() ile değiştirmek eleman atlamalarına neden olabilir.
• min() ve max() en küçük ve en büyük değeri doğrudan verir. Döngüyle yazılan “şimdiye kadarki en büyük” kalıbı ise değerin yanında kime ait olduğunu da bulmak gerektiğinde işe yarar.
• sort() listeyi yerinde değiştirir; sorted() yeni sıralı liste döndürür.
• for ile liste elemanlarında doğrudan dolaşılabilir.
• Koşulu sağlayan elemanları yeni bir listeye eklemek filtreleme kalıbıdır.
• Demet sıralıdır ancak değiştirilemez.
• Fonksiyonda return a, b iki değeri bir demet olarak döndürür ve çağıran tarafta x, y = ... ile açılabilir.
• b = a bağımsız kopya oluşturmaz; iki değişken aynı listeyi gösterir.
• .copy() ya da tam dilim, tek seviyeli listelerde bağımsız bir sığ kopya oluşturur.
• Fonksiyonun kendisine verilen listeyi değiştirip değiştirmeyeceği bilerek verilmesi gereken bir tasarım kararıdır.

Bir sonraki bölümde verilere indeks yerine anlamlı anahtarlarla erişmek için sözlükleri, tekrarsız değerler için ise kümeleri kullanacağız.

Bu bölümün kazanımları

Bu bölümü bitiren öğrenci:

• İndeks ve dilimle liste elemanlarına erişir.
• append(), remove() ve in ile listeyi günceller ve sorgular.
• sort() ile sorted() arasındaki farkı açıklar.
• Liste ile demeti ayırt eder ve fonksiyondan dönen demeti açar.
• b = a ile aynı nesnenin paylaşıldığını tanır ve bağımsız kopya oluşturur.
• Üzerinde dolaşılan listeyi aynı anda değiştirmenin riskini açıklar.
• Boş listeyi ortalama ve maksimum hesabında uç durum olarak denetler.