Ek: 11. hafta ev alıştırmaları

11. hafta ev alıştırmaları: iç içe kayıtlar ve küçük veri işleme

Bu sayfadaki sekiz alıştırma İç içe kayıtlar ve küçük veri işleme bölümünün konularıyla kod yazdırır. Alıştırmalar kolaydan zora sıralı. İlk beşi bölümdeki kalıpları tek tek kullanır: filtreleme, kopya, sayaç ve biriktirici, ortalama, maksimum arama. Son üçü gruplamayı ve birkaç kalıbı bir arada kullanır.

Her alıştırma aynı düzende:

  • Ne yapacaksınız? Yazacağınız kodun işini anlatır.
  • Nerede işinize yarar? Bu işin gerçek bir programda nerede karşınıza çıkacağını söyler.
  • Doğru olduğunu nasıl anlarsınız? Hücrenin sonundaki assert satırlarını gösterir. Hücre hata vermeden Kontroller tamamlandı yazarsa çözümünüz denemelerin hepsini geçmiştir.

Kodu hücrenin içine yazın ve Run Code düğmesine basın. Hücrenin altında kodunuzu başka verilerle deneyen bir geri bildirim de çıkar. Takılırsanız önce ipucunu açın. Çözümü, kendi kodunuz çalıştıktan sonra karşılaştırmak için açın. Yazdığınız kod tarayıcınızda saklanır: sayfayı kapatıp açtığınızda kaldığınız yerden devam edersiniz.

1. Geciken kargolar

Ne yapacaksınız? Bir kargo şubesi yoldaki her kargoyu bir sözlükte tutuyor: takip kodu, gideceği şehir ve kaç gündür yolda olduğu. Bütün kargolar bir listede. geciken_kargolar(kargolar, sinir) adlı fonksiyonu yazın. Fonksiyon sinir günden fazla yolda kalan kargoların kayıtlarını, listedeki sırayla, yeni bir listede döndürsün. Listeye kaydın tamamı girsin, yalnız takip kodu değil. Sınıra eşit gün sayısı gecikme sayılmaz.

Nerede işinize yarar? “Stoku azalanlar”, “teslim tarihi geçenler”, “notu 50’nin altında kalanlar”: kayıt tutan her programda bir koşula uyan kayıtları ayırmak gerekir. Bu işe filtreleme denir.

Doğru olduğunu nasıl anlarsınız? Dört assert geçmeli. İlk satırdaki kargolar[0] ve kargolar[3], listenin birinci ve dördüncü kaydıdır.

Fonksiyonun başında geciken = [] yazın. Döngüde if kargo["gun"] > sinir: ise geciken.append(kargo). Döngü bitince return geciken.

def geciken_kargolar(kargolar, sinir):
    geciken = []
    for kargo in kargolar:
        if kargo["gun"] > sinir:
            geciken.append(kargo)
    return geciken

kargolar = [
    {"takip": "K104", "sehir": "Ordu", "gun": 5},
    {"takip": "K221", "sehir": "Sinop", "gun": 2},
    {"takip": "K317", "sehir": "Tokat", "gun": 3},
    {"takip": "K402", "sehir": "Amasya", "gun": 7},
]

assert geciken_kargolar(kargolar, 3) == [kargolar[0], kargolar[3]]
assert geciken_kargolar(kargolar, 7) == []
assert geciken_kargolar([], 3) == []
assert len(kargolar) == 4

print("Kontroller tamamlandı")

2. Eski tarife bozulmasın

Ne yapacaksınız? Belediyenin programcısı otobüs ücretlerine zam yapan bir fonksiyon yazdı. Fonksiyon yeni tarifeyi doğru hesaplıyor, ama çalıştıktan sonra eski tarife de değişmiş oluyor. Eski tarife arşivde aynen kalmalı. Hücreyi bir kez çalıştırın: ikinci assert hata verecek. Sonra zamli_tarife fonksiyonunu, asıl listeye ve içindeki kayıtlara dokunmadan yeni tarifeyi döndürecek biçimde düzeltin.

Nerede işinize yarar? Fiyat listesi, not çizelgesi, maaş tablosu: yeni sürümü hazırlarken eskisini saklamak gerekir. append(hat) listeye kaydın kopyasını değil kendisini ekler. Bunu bilmeyen programcı eski veriyi fark etmeden değiştirir.

Doğru olduğunu nasıl anlarsınız? Üç assert geçmeli.

Döngüde önce kaydın sığ kopyasını alın: yeni_hat = hat.copy(). Ücreti yeni_hat üzerinde güncelleyin ve listeye yeni_hat’ı ekleyin. Kayıtlardaki değerler yalnız sayı ve metin olduğu için sığ kopya yeterli.

def zamli_tarife(hatlar, zam):
    yeni = []
    for hat in hatlar:
        yeni_hat = hat.copy()
        yeni_hat["ucret"] = yeni_hat["ucret"] + zam
        yeni.append(yeni_hat)
    return yeni

hatlar = [
    {"hat": "12A", "durak": 18, "ucret": 20},
    {"hat": "7", "durak": 25, "ucret": 22},
]

yeni_tarife = zamli_tarife(hatlar, 3)

assert yeni_tarife == [{"hat": "12A", "durak": 18, "ucret": 23}, {"hat": "7", "durak": 25, "ucret": 25}]
assert hatlar == [{"hat": "12A", "durak": 18, "ucret": 20}, {"hat": "7", "durak": 25, "ucret": 22}]
assert zamli_tarife([], 3) == []

print("Kontroller tamamlandı")

İlk yazımda yeni listesi boş bir listeyle başlıyordu, yani ayrı bir listeydi. Ortak olan, içine eklenen sözlüklerdi. Bu yüzden listeyi değil, her kaydı kopyalamak gerekir.

3. Onaylanan bağışlar

Ne yapacaksınız? Bir yardım kampanyasında her bağış bir sözlükte duruyor: bağışçının adı, tutar ve bağışın onaylanıp onaylanmadığı. Bazı kayıtlara onay bilgisi henüz girilmemiş. Kampanyanın kuralı şu: onay bilgisi yazılmamış bağış onaylanmamış sayılır. onayli_ozet(bagislar) adlı fonksiyonu yazın. Fonksiyon onaylanan bağışların sayısını ve toplam tutarını (adet, toplam) demeti olarak döndürsün.

Nerede işinize yarar? “Kaç sipariş teslim edildi, toplamı ne?”, “Kaç öğrenci devamsız, toplam kaç saat?”: aynı döngüde bir sayaç ve bir biriktirici birlikte çalışır. Eksik alanın varsayılan değerini de kampanyanın kuralı belirler.

Doğru olduğunu nasıl anlarsınız? Üç assert geçmeli.

adet = 0 ve toplam = 0 ile başlayın. Döngüde if bagis.get("onaylandi", False): ise adet = adet + 1 ve toplam = toplam + bagis["tutar"]. Sonunda return adet, toplam.

def onayli_ozet(bagislar):
    adet = 0
    toplam = 0
    for bagis in bagislar:
        if bagis.get("onaylandi", False):
            adet = adet + 1
            toplam = toplam + bagis["tutar"]
    return adet, toplam

bagislar = [
    {"bagisci": "Selin", "tutar": 150, "onaylandi": True},
    {"bagisci": "Okan", "tutar": 200, "onaylandi": False},
    {"bagisci": "Derya", "tutar": 100},
    {"bagisci": "Kaan", "tutar": 50, "onaylandi": True},
]

assert onayli_ozet(bagislar) == (2, 200)
assert onayli_ozet([]) == (0, 0)
assert onayli_ozet([{"bagisci": "Ece", "tutar": 75}]) == (0, 0)

print("Kontroller tamamlandı")

Varsayılan değeri True seçseydiniz Derya’nın bağışı onaylanmış sayılır, sonuç (3, 300) olurdu. Kod hata vermezdi, ama rapor yanlış olurdu.

4. Koşu ortalaması

Ne yapacaksınız? Bir koşucu saatinin kaydettiği koşular bir listede. Saatin şarjı bir gün bittiği için o günün kaydında mesafe yok. ortalama_mesafe(kosular) adlı fonksiyonu yazın. Fonksiyon km alanı olan koşuların ortalama mesafesini döndürsün. km alanı olmayan koşu ortalamaya hiç girmesin: ne toplama ne de bölene. Hiç km kaydı yoksa fonksiyon None döndürsün. 0 km’lik bir kayıt ise gerçek bir ölçümdür, ortalamaya girer.

Nerede işinize yarar? Sensör ölçümleri, anket puanları, sınava girmeyen öğrenciler: eksik değeri 0 saymak ortalamayı düşürür. “Veri yok” ile “değer sıfır” farkını da ancak None korur.

Doğru olduğunu nasıl anlarsınız? Dört assert geçmeli.

İki değişken tutun: toplam ve sayi. Döngüde if "km" in kosu: ise ikisini de güncelleyin. Döngüden sonra if sayi == 0: return None yazın, yoksa toplam / sayi döndürün.

def ortalama_mesafe(kosular):
    toplam = 0
    sayi = 0
    for kosu in kosular:
        if "km" in kosu:
            toplam = toplam + kosu["km"]
            sayi = sayi + 1

    if sayi == 0:
        return None
    return toplam / sayi

kosular = [
    {"tarih": "3 Mart", "km": 5},
    {"tarih": "5 Mart"},
    {"tarih": "8 Mart", "km": 7},
    {"tarih": "10 Mart", "km": 6},
]

assert ortalama_mesafe(kosular) == 6.0
assert ortalama_mesafe([]) is None
assert ortalama_mesafe([{"tarih": "1 Nisan"}]) is None
assert ortalama_mesafe([{"tarih": "2 Nisan", "km": 0}]) == 0

print("Kontroller tamamlandı")

kosu.get("km", 0) ile toplayıp len(kosular)’a bölseydiniz şarjı biten gün 0 km koşulmuş gibi sayılır, ortalama 18 / 4 = 4.5 çıkardı.

5. En uzun parkur

Ne yapacaksınız? Bir doğa yürüyüşü kulübünün parkurları bir listede: her kayıtta parkurun adı ve uzunluğu var. en_uzun_parkur(parkurlar) adlı fonksiyonu yazın. Fonksiyon en uzun parkurun kaydını döndürsün, yalnız uzunluğu ya da adı değil. Dönen değer listedeki sözlüğün kendisi olsun, kopyası değil. İki parkur eşit uzunluktaysa listede önce geleni döndürsün. Liste boşsa None döndürsün.

Nerede işinize yarar? “En pahalı ürün hangisi?”, “En geç gelen öğrenci kim?” sorularında yalnız en büyük sayıyı bulmak yetmez. Cevap o sayının ait olduğu kayıttır: ad, tarih ve öteki alanlar da gerekir.

Doğru olduğunu nasıl anlarsınız? Dört assert geçmeli. is ile yazılan satır, dönen kaydın listedeki kaydın kendisi olup olmadığını sınar.

en_uzun = None ile başlayın. Döngüde if en_uzun is None or parkur["km"] > en_uzun["km"]: ise en_uzun = parkur. İlk turda en_uzun is None doğru olduğu için or sağ tarafı hesaplamaz ve None["km"] okunmaz.

def en_uzun_parkur(parkurlar):
    en_uzun = None
    for parkur in parkurlar:
        if en_uzun is None or parkur["km"] > en_uzun["km"]:
            en_uzun = parkur
    return en_uzun

parkurlar = [
    {"ad": "Göl kenarı", "km": 6},
    {"ad": "Orman yolu", "km": 11},
    {"ad": "Sahil", "km": 11},
    {"ad": "Tepe", "km": 4},
]

assert en_uzun_parkur(parkurlar) is parkurlar[1]
assert en_uzun_parkur(parkurlar[2:]) == {"ad": "Sahil", "km": 11}
assert en_uzun_parkur([]) is None
assert en_uzun_parkur([{"ad": "Kısa tur", "km": 2}]) == {"ad": "Kısa tur", "km": 2}

print("Kontroller tamamlandı")

Liste boşsa döngü hiç dönmez ve en_uzun None kalır. Boş liste için ayrıca if yazmanız gerekmez.

6. Katılımcıların şehirleri

Ne yapacaksınız? Bir kodlama kampına başvuranlar şehirlerini formdaki boş bir kutuya kendileri yazdı. Kimi büyük harfle, kimi küçük harfle yazdı, kiminin başında ya da sonunda boşluk kaldı. sehir_sayilari(katilimcilar) adlı fonksiyonu yazın. Fonksiyon her şehirden kaç kişinin başvurduğunu bir sözlükte döndürsün. Anahtar, şehrin strip() ve lower() ile normalleştirilmiş adı olsun. Bu verideki şehir adlarında I ve İ harfi yok, bu yüzden lower() yeter. Katılımcı kayıtları değişmesin.

Nerede işinize yarar? Elle doldurulan her formda aynı değer farklı biçimlerde gelir. Normalleştirmeden gruplarsanız "Samsun" ile "samsun " iki ayrı şehir gibi sayılır ve rapor yanlış çıkar.

Doğru olduğunu nasıl anlarsınız? Üç assert geçmeli. İki sözlük karşılaştırılırken anahtarların sırasına bakılmaz.

Boş bir sözlükle başlayın. Döngüde önce sehir = katilimci["sehir"].strip().lower() yazın, sonra sayilar[sehir] = sayilar.get(sehir, 0) + 1. Kaydın içindeki yazımı değiştirmeyin.

def sehir_sayilari(katilimcilar):
    sayilar = {}
    for katilimci in katilimcilar:
        sehir = katilimci["sehir"].strip().lower()
        sayilar[sehir] = sayilar.get(sehir, 0) + 1
    return sayilar

katilimcilar = [
    {"ad": "Burak", "sehir": "Samsun"},
    {"ad": "Gizem", "sehir": "samsun "},
    {"ad": "Tolga", "sehir": "Ordu"},
    {"ad": "Nazlı", "sehir": " SAMSUN"},
    {"ad": "Emel", "sehir": "ordu"},
    {"ad": "Sevgi", "sehir": "Tokat"},
]

assert sehir_sayilari(katilimcilar) == {"samsun": 3, "ordu": 2, "tokat": 1}
assert sehir_sayilari([]) == {}
assert katilimcilar[1]["sehir"] == "samsun "

print("Kontroller tamamlandı")

Veride "İZMİR" gibi bir yazım olsaydı lower() onu "izmir" yapmazdı. 8. bölümdeki Türkçe harf uyarısı burada da geçerli.

7. Kulüp başvuru listeleri

Ne yapacaksınız? Okulun kulüp başvuruları geliş sırasıyla bir listede duruyor. Her kayıtta öğrencinin adı ve başvurduğu kulüp var. Kulüp adları düzgün yazılmış, normalleştirme gerekmiyor. Ama bazı öğrenciler aynı kulübe iki kez başvurmuş. kulup_listeleri(basvurular) adlı fonksiyonu yazın. Fonksiyon bir sözlük döndürsün: anahtar kulübün adı, değer o kulübe başvuranların adlarını geliş sırasıyla tutan bir liste. Aynı öğrencinin adı bir kulübün listesinde bir kez geçsin.

Nerede işinize yarar? Sınıf listeleri, departmanlara göre çalışanlar, kategorilere göre ürünler: bazen bir grupta kaç kayıt olduğu yetmez, kimlerin olduğu da gerekir.

Doğru olduğunu nasıl anlarsınız? Üç assert geçmeli.

gruplar = {} ile başlayın. Döngüde önce kulübün listesi yoksa boş bir liste koyun: if kulup not in gruplar: gruplar[kulup] = []. Sonra ad o listede yoksa ekleyin: if ad not in gruplar[kulup]: gruplar[kulup].append(ad).

def kulup_listeleri(basvurular):
    gruplar = {}
    for basvuru in basvurular:
        kulup = basvuru["kulup"]
        ad = basvuru["ad"]
        if kulup not in gruplar:
            gruplar[kulup] = []
        if ad not in gruplar[kulup]:
            gruplar[kulup].append(ad)
    return gruplar

basvurular = [
    {"ad": "Arda", "kulup": "Satranç"},
    {"ad": "Bora", "kulup": "Müzik"},
    {"ad": "Cemre", "kulup": "Satranç"},
    {"ad": "Arda", "kulup": "Satranç"},
    {"ad": "Duru", "kulup": "Tiyatro"},
    {"ad": "Arda", "kulup": "Müzik"},
]

assert kulup_listeleri(basvurular) == {
    "Satranç": ["Arda", "Cemre"],
    "Müzik": ["Bora", "Arda"],
    "Tiyatro": ["Duru"],
}
assert kulup_listeleri([]) == {}
assert kulup_listeleri([{"ad": "Efe", "kulup": "Müzik"}]) == {"Müzik": ["Efe"]}

print("Kontroller tamamlandı")

Arda iki kulüpte de var: tekrar denetimi kulübün kendi listesine bakar, bütün başvurulara değil.

8. Gönüllü saatleri raporu

Ne yapacaksınız? Bir belediyenin gönüllü ekipleri her hafta park, kütüphane ve hayvan barınağında çalışıyor. Her çalışma bir kayıt: gönüllünün adı, ekibi ve kaç saat çalıştığı. Ekip adları elle yazılmış: kiminde büyük harf, kiminde fazladan boşluk var. Bazı kayıtlarda saat yazılmamış. Belediyenin kuralı şu: saati yazılmamış kayıt hatalıdır, hiçbir hesaba girmez, yalnız ayrıca sayılır. gonullu_raporu(kayitlar) adlı fonksiyon üç elemanlı bir demet döndürsün:

  • Ekip saatleri: anahtarı normalleştirilmiş ekip adı (strip().lower()), değeri o ekibin toplam saati olan bir sözlük. Yalnız saati yazılmış kayıtlar girer. Bir ekibin hiç geçerli kaydı yoksa o ekip sözlükte yer almaz.
  • Saati yazılmamış kayıtların sayısı.
  • En uzun çalışmanın kaydı: saati en büyük olan kaydın tamamı. Eşitlikte listede önce gelen kayıt kalır. Geçerli kayıt yoksa None.

Ekip adlarında büyük I ya da İ yok, bu yüzden lower() yeter. Verilen kayıtlar değişmesin.

Nerede işinize yarar? Gerçek bir raporda bölümdeki kalıplar tek tek değil, aynı döngüde birlikte çalışır: eksik alanı ayırmak, gruplamak, normalleştirmek ve en büyüğü bulmak. Bu alıştırma hepsini bir araya getirir.

Doğru olduğunu nasıl anlarsınız? Üç assert geçmeli ve hücre Kontroller tamamlandı yazmalı. Ardından rapor satırları gelir.

saatler = {}, eksik = 0 ve en_uzun = None ile başlayın. Döngüde önce if "saat" not in kayit: ise eksik = eksik + 1 yazıp continue ile sıradaki kayda geçin. Saati olan kayıtta ekip adını kayit["ekip"].strip().lower() ile ayrı bir değişkene alın, saatler[ekip] = saatler.get(ekip, 0) + kayit["saat"] ile toplayın. Aynı turda en_uzun is None or kayit["saat"] > en_uzun["saat"] ise en_uzun = kayit. Sonunda return saatler, eksik, en_uzun.

def gonullu_raporu(kayitlar):
    saatler = {}
    eksik = 0
    en_uzun = None

    for kayit in kayitlar:
        if "saat" not in kayit:
            eksik = eksik + 1
            continue

        ekip = kayit["ekip"].strip().lower()
        saatler[ekip] = saatler.get(ekip, 0) + kayit["saat"]

        if en_uzun is None or kayit["saat"] > en_uzun["saat"]:
            en_uzun = kayit

    return saatler, eksik, en_uzun

kayitlar = [
    {"gonullu": "Selin", "ekip": "Park", "saat": 3},
    {"gonullu": "Okan", "ekip": " kütüphane", "saat": 4},
    {"gonullu": "Derya", "ekip": "park "},
    {"gonullu": "Kaan", "ekip": "Barınak", "saat": 5},
    {"gonullu": "Ece", "ekip": "PARK", "saat": 2},
    {"gonullu": "Mert", "ekip": "Kütüphane", "saat": 5},
]

assert gonullu_raporu(kayitlar) == ({"park": 5, "kütüphane": 9, "barınak": 5}, 1, kayitlar[3])
assert gonullu_raporu([]) == ({}, 0, None)
assert gonullu_raporu([{"gonullu": "Can", "ekip": "Park"}]) == ({}, 1, None)

print("Kontroller tamamlandı")

ekipler, eksik, en_uzun = gonullu_raporu(kayitlar)
for ekip, saat in ekipler.items():
    print(f"{ekip}: {saat} saat")
print("Saati yazılmamış kayıt:", eksik)
if en_uzun is not None:
    print("En uzun çalışma:", en_uzun["gonullu"], en_uzun["saat"], "saat")

Derya’nın kaydını kayit.get("saat", 0) ile okusaydınız park ekibine 0 saat eklenirdi. Bu örnekte toplam değişmezdi, ama yalnız saati yazılmamış kayıtları olan bir ekip raporda 0 saatle görünürdü.

Başa dön