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

9. hafta ev alıştırmaları: listeler ve demetler

Bu sayfadaki sekiz alıştırma Listeler, demetler ve referans sezgisi bölümünün konularıyla kod yazdırır. Alıştırmalar kolaydan zora sıralı. İlk dördü bölümdeki örneklere çok benzer, son dördü birkaç konuyu 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? Beklenen çıktıyı ya da 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 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. İlk ve son kayıt

Ne yapacaksınız? ilk_ve_son(liste) adlı fonksiyonu yazın. Fonksiyon listenin ilk ve son elemanını (ilk, son) demeti olarak döndürsün. Liste boşsa (None, None) döndürsün. Tek elemanlı listede ilk ve son eleman aynıdır.

Nerede işinize yarar? Bir kuyrukta ilk ve son bekleyen kişi, bir günün ilk ve son ölçümü ya da bir dosyadaki ilk ve son satır sık sorulan bilgilerdir. Boş listeyi ayrı düşünmezseniz program IndexError ile durur.

Doğru olduğunu nasıl anlarsınız? Hücrenin sonundaki dört assert geçmeli.

if len(liste) == 0: ile boş listeyi ayırın. Son eleman liste[-1] ya da liste[len(liste) - 1] ile okunur. return a, b iki değeri tek bir demet olarak döndürür.

def ilk_ve_son(liste):
    if len(liste) == 0:
        return None, None
    return liste[0], liste[-1]

assert ilk_ve_son([12, 15, 9, 18]) == (12, 18)
assert ilk_ve_son(["Ali", "Ece", "Can"]) == ("Ali", "Can")
assert ilk_ve_son([7]) == (7, 7)
assert ilk_ve_son([]) == (None, None)

print("Kontroller tamamlandı")

2. Kantin kuyruğu

Ne yapacaksınız? Kantin kuyruğu bir listede tutuluyor, listenin başı kuyruğun önü. Aşağıdaki dört işi sırayla, her biri için bir liste metoduyla yapın:

  1. Deniz kuyruğa geliyor ve en arkaya geçiyor.
  2. Zeynep’in dersi başlamak üzere, en öne alınıyor.
  3. Sıradaki kişiye servis yapılıyor: en öndeki kişi kuyruktan çıkıyor. Onun adını servis değişkenine alın.
  4. Can’ın kaçıncı sırada beklediğini bulun. Sıra 1’den sayılır, indeks 0’dan.

Nerede işinize yarar? Bekleme listeleri, yazıcı kuyrukları ve oyunlardaki sıra hep böyle tutulur. Hangi metodun listeyi değiştirdiğini, hangisinin değer döndürdüğünü bilmeden kuyruğu doğru güncelleyemezsiniz.

Doğru olduğunu nasıl anlarsınız? Çıktınız şu üç satır olmalı:

Servis: Zeynep
Kuyruk: ['Ali', 'Ece', 'Can', 'Deniz']
Can 3. sırada

En arkaya append(), en öne insert(0, ...) ekler. pop(0) en öndeki elemanı çıkarır ve onu döndürür. index("Can") indeksi verir, sıra için 1 ekleyin.

kuyruk = ["Ali", "Ece", "Can"]

kuyruk.append("Deniz")
kuyruk.insert(0, "Zeynep")
servis = kuyruk.pop(0)
sira = kuyruk.index("Can") + 1

print("Servis:", servis)
print("Kuyruk:", kuyruk)
print("Can", f"{sira}.", "sırada")

3. Eşiği geçen ölçümler

Ne yapacaksınız? esigi_gecenler(olcumler, esik) adlı fonksiyonu yazın. Fonksiyon esik değerinden büyük ölçümleri, listedeki sıralarını koruyarak yeni bir listede döndürsün. Verilen listeye dokunmasın.

Nerede işinize yarar? Ateşi 38’i geçen hastalar, hızı sınırı aşan araçlar, stoğu azalan ürünler: veriden bir kısmını seçmek en sık yapılan işlerden biridir. Bölümde gördüğünüz gibi, dolaşılan listeden remove() ile silmek eleman atlatır. Yeni liste kurmak bu sorunu ortadan kaldırır.

Doğru olduğunu nasıl anlarsınız? Dört assert geçmeli. Son assert asıl listenin değişmediğini denetler.

Bölümdeki “Listeye koşullu eleman eklemek” kalıbı: sonuc = [], ardından döngüde koşulu sağlayanları sonuc.append(olcum) ile ekleyin ve en sonda return sonuc yazın. Koşul > olmalı, >= değil.

def esigi_gecenler(olcumler, esik):
    sonuc = []
    for olcum in olcumler:
        if olcum > esik:
            sonuc.append(olcum)
    return sonuc

atesler = [36.5, 38.2, 37.9, 39.1, 38.0]
assert esigi_gecenler(atesler, 38) == [38.2, 39.1]
assert esigi_gecenler([5, 1, 9], 10) == []
assert esigi_gecenler([], 3) == []
assert atesler == [36.5, 38.2, 37.9, 39.1, 38.0]

print("Kontroller tamamlandı")

4. Adım sayısı arttı mı?

Ne yapacaksınız? Telefonunuz her gün attığınız adımları bir listeye yazıyor. artis_gunleri(adimlar) adlı fonksiyonu yazın. Fonksiyon, bir önceki güne göre adım sayısının arttığı günlerin indekslerini bir listede döndürsün. İlk günün öncesi olmadığı için ilk gün hiçbir zaman listeye girmez.

Nerede işinize yarar? Fiyat yükseldi mi, sıcaklık düştü mü, satış arttı mı: ardışık iki değeri karşılaştırmak zaman içinde değişen her veride gerekir. Burada döngü elemanlarda değil indekslerde dolaşmalı, çünkü her elemanın komşusuna da bakılacak.

Doğru olduğunu nasıl anlarsınız? Dört assert geçmeli. Fonksiyon boş ve tek elemanlı listede IndexError vermemeli.

İki yol var. for i in range(1, len(adimlar)): ile dolaşıp adimlar[i] ile adimlar[i - 1]’i karşılaştırabilirsiniz. Bölümdeki gibi range(len(adimlar) - 1) ile dolaşırsanız karşılaştırma adimlar[i + 1] > adimlar[i] olur, ama listeye i + 1 eklenir.

def artis_gunleri(adimlar):
    gunler = []
    for i in range(1, len(adimlar)):
        if adimlar[i] > adimlar[i - 1]:
            gunler.append(i)
    return gunler

assert artis_gunleri([4000, 6500, 6000, 8000, 9000]) == [1, 3, 4]
assert artis_gunleri([9000, 8000, 7000]) == []
assert artis_gunleri([5000]) == []
assert artis_gunleri([]) == []

print("Kontroller tamamlandı")

5. Asıl puanlara dokunmadan bonus

Ne yapacaksınız? Öğretim elemanı herkese bonus puan vermeyi düşünüyor, ama önce sonucu görmek istiyor. bonuslu(puanlar, bonus) adlı fonksiyonu yazın. Fonksiyon her puana bonus eklenmiş yeni bir liste döndürsün. Puan 100’ü geçmesin: 95 + 10 sonucu 100 olur. Verilen liste değişmesin.

Nerede işinize yarar? “Şöyle yapsak ne olur?” diye deneme hesabı yapan her programda asıl veriyi korumak gerekir. Bölümdeki asistan örneğinde olduğu gibi, = ile verilen liste kopya değildir.

Doğru olduğunu nasıl anlarsınız? Dört assert geçmeli. Son iki assert, asıl listenin değişmediğini ve dönen listenin ayrı bir nesne olduğunu denetler.

İki yol var. Boş bir listeye eklemek: sonuc = [], döngüde sonuc.append(...). Ya da önce sonuc = puanlar.copy() alıp kopyanın elemanlarını range(len(sonuc)) ile değiştirmek. sonuc = puanlar yazarsanız asıl listeyi değiştirirsiniz. 100 sınırı için if ya da min(puan + bonus, 100) kullanabilirsiniz.

def bonuslu(puanlar, bonus):
    sonuc = []
    for puan in puanlar:
        yeni_puan = puan + bonus
        if yeni_puan > 100:
            yeni_puan = 100
        sonuc.append(yeni_puan)
    return sonuc

asil = [45, 70, 95, 58]
yeni = bonuslu(asil, 10)
assert yeni == [55, 80, 100, 68]
assert bonuslu([], 5) == []
assert asil == [45, 70, 95, 58]
assert yeni is not asil

print("Kontroller tamamlandı")

6. En çok seçilen şık

Ne yapacaksınız? Bir ankette her öğrenci A, B, C, D ya da E şıklarından birini seçti. en_cok_secilen(cevaplar) adlı fonksiyonu yazın. Fonksiyon en çok seçilen şıkkı ve kaç kez seçildiğini (sik, adet) demeti olarak döndürsün. İki şık eşit sayıda seçildiyse alfabede önce gelen kazansın. Liste boşsa (None, 0) döndürsün. Verilen cevaplar listesini değiştirmeyin.

Nerede işinize yarar? Anket sonucu, en çok satan ürün, en sık görülen hata kodu: hepsi “en çok hangisi” sorusudur. 10. haftada aynı sayımı sözlükle de yapacaksınız.

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

en_iyi = None ve en_cok = 0 ile başlayın. for sik in siklar: döngüsünde adet = cevaplar.count(sik) hesaplayın. adet > en_cok ise ikisini de güncelleyin. Şıklar alfabe sırasıyla dolaşıldığı için > eşitlikte öncekini korur. Boş listede hiçbir adet 0’dan büyük olmaz, fonksiyon kendiliğinden (None, 0) döndürür.

def en_cok_secilen(cevaplar):
    siklar = ["A", "B", "C", "D", "E"]
    en_iyi = None
    en_cok = 0

    for sik in siklar:
        adet = cevaplar.count(sik)
        if adet > en_cok:
            en_iyi = sik
            en_cok = adet

    return en_iyi, en_cok

assert en_cok_secilen(["A", "C", "A", "B", "C", "A"]) == ("A", 3)
assert en_cok_secilen(["E", "D", "E"]) == ("E", 2)
assert en_cok_secilen(["B", "C", "C", "B"]) == ("B", 2)
assert en_cok_secilen([]) == (None, 0)

print("Kontroller tamamlandı")

7. Listeyi takasla ters çevirmek

Ne yapacaksınız? yerinde_ters_cevir(liste) adlı fonksiyonu yazın. Fonksiyon yeni liste oluşturmasın, verilen listenin elemanlarını yerinde ters sıraya koysun ve bir şey döndürmesin. reverse(), [::-1] ve sorted() kullanmayın: işi bölümdeki tek satırlık takasla yapın. İlk elemanı son elemanla, ikinciyi sondan ikinciyle takas edin ve ortaya gelince durun.

Nerede işinize yarar? Python’da hazır reverse() metodu var. Ama “iki ucu takas edip ortaya doğru ilerlemek” sıralama ve arama programlarında sık kullanılan bir kalıptır. Bunu bir kez kendiniz yazınca hazır metotların içinde ne olduğunu da görürsünüz.

Doğru olduğunu nasıl anlarsınız? Dört assert geçmeli. Tek ve çift sayıda elemanlı listeyi de denemeyi unutmayın.

Takas sayısı eleman sayısının yarısıdır: len(liste) // 2 (5 elemanlı listede ortadaki eleman yerinde kalır). i numaralı elemanın karşısı -1 - i numaralı elemandır. Bu indeksi len(liste) - 1 - i diye de yazabilirsiniz. Takas: liste[i], liste[-1 - i] = liste[-1 - i], liste[i].

def yerinde_ters_cevir(liste):
    for i in range(len(liste) // 2):
        liste[i], liste[-1 - i] = liste[-1 - i], liste[i]

a = [1, 2, 3, 4]
yerinde_ters_cevir(a)
assert a == [4, 3, 2, 1]

b = ["x", "y", "z"]
yerinde_ters_cevir(b)
assert b == ["z", "y", "x"]

c = []
yerinde_ters_cevir(c)
assert c == []

assert yerinde_ters_cevir([5, 6]) is None

print("Kontroller tamamlandı")

Döngü listenin tamamında dolaşsaydı ne olurdu? İlk yarıda yapılan takaslar ikinci yarıda geri alınır ve liste eski hâline döner.

8. Sınıf raporu

Ne yapacaksınız? Bölümdeki puan kâğıdıyla yapılan işleri tek bir fonksiyonda toplayın. Adlar ve puanlar iki ayrı listede, aynı sırayla duruyor. sinif_raporu(adlar, puanlar) adlı fonksiyon üç elemanlı bir demet döndürsün:

  • Sınıf ortalaması
  • En yüksek puanı alan öğrencinin adı (eşitlikte listede önce gelen)
  • 60’ın altında kalan öğrencilerin adları, listedeki sırasıyla, yeni bir listede

Listeler boşsa (None, None, []) döndürsün. Verilen listeler değişmesin. adlar ile puanlar her zaman aynı uzunluktadır.

Nerede işinize yarar? Not sistemleri, satış raporları ve maç istatistikleri hep böyle çalışır: aynı veriden birkaç özet çıkarılır ve hepsi birlikte döndürülür. Bu alıştırma haftanın konularını bir arada kullanır: len(), indeksle dolaşma, filtreleme, demet döndürme, boş liste uç durumu ve verilen listeyi korumak.

Doğru olduğunu nasıl anlarsınız? Dört assert geçmeli. Ardından hücre rapor satırlarını yazdırmalı.

Boş listeyi başta ayırın. Sonra tek bir for i in range(len(puanlar)): döngüsünde üç iş yapın: toplam’a puanlar[i]’yi ekleyin, puanlar[i] > puanlar[en_iyi] ise en_iyi = i yapın, puanlar[i] < 60 ise adlar[i]’yi bütünleme listesine ekleyin. En sonda return toplam / len(puanlar), adlar[en_iyi], butunleme yazın.

def sinif_raporu(adlar, puanlar):
    if len(puanlar) == 0:
        return None, None, []

    toplam = 0
    en_iyi = 0
    butunleme = []

    for i in range(len(puanlar)):
        toplam = toplam + puanlar[i]
        if puanlar[i] > puanlar[en_iyi]:
            en_iyi = i
        if puanlar[i] < 60:
            butunleme.append(adlar[i])

    ortalama = toplam / len(puanlar)
    return ortalama, adlar[en_iyi], butunleme

adlar = ["Ece", "Mert", "Zeynep", "Can", "Deniz"]
puanlar = [72, 45, 95, 58, 95]

assert sinif_raporu(adlar, puanlar) == (73.0, "Zeynep", ["Mert", "Can"])
assert sinif_raporu(["Ali"], [100]) == (100.0, "Ali", [])
assert sinif_raporu([], []) == (None, None, [])
assert puanlar == [72, 45, 95, 58, 95]

ortalama, birinci, butunleme = sinif_raporu(adlar, puanlar)
print(f"Ortalama: {ortalama:.2f}")
print("En yüksek puanı alan:", birinci)
print("Bütünleme:", butunleme)
Başa dön