İyi Kod Yazma ve Etkili Kod İnceleme

Bu ders kimler için?

Kod yazabilen; okunabilirlik, test ve ekipte kod inceleme alışkanlıklarını geliştirmek isteyen öğrenciler ve yazılımcılar. Odak, çalışan bir çözümü başkasının da anlayıp değiştirebileceği hale getirmek.

Temel Python bilgisi. İleri algoritma veya kod inceleme deneyimi gerekmiyor; Git alıştırmasının hazırlığı ayrıca anlatılıyor.

Bu dersin amacı

Anlamlı isimler, tek bir işi yapan fonksiyonlar, düzenli kod ve yararlı yorumlarla okunabilir çözüm yazmak.

Özgün algoritma örneklerindeki düşünceyi ve çözümü bozabilecek sınırları açıklayıp kontrol etmek.

Test, odaklı değişiklik ve yapıcı kod incelemeyle ekip çalışmasında daha güvenli değişiklik yapmak.

Başlamadan önce

Python’da temel fonksiyon, döngü, liste, sözlük ve koşul bilgisi. Yığın ve ağaç özyinelemesi kullanıldığı yerde açıklanıyor. Okumak için kurulum gerekmez; atölyeyi çalıştırmak için Python 3, terminal ve belgelenen bağımlılıklar gerekir. İsteğe bağlı Git alıştırması için Git gerekir; başlamadan git --version ile kontrol edin. Ayrı bir deneme klasörü veriliyor ve commit öncesi dosya seçme adımı açıklanıyor.



İyi Kod Yazma ve Etkili Kod İnceleme

Çalışan bir çözümü; sizin, mülakatı yapan kişinin ve ekip arkadaşınızın anlayıp değiştirebileceği bir koda nasıl dönüştürürsünüz?

Bu ders, çözüm fikrini bulduktan sonra kodu nasıl yazdığınız ve incelediğiniz üzerine. Doğru bir algoritmanın kodu yine de zor okunabilir, zor test edilebilir veya değiştirildiğinde kolayca bozulabilir. İsimler, fonksiyonların sınırları, kodun düzeni ve yorumlar çözüm fikrinizi başkasına anlatır.

Önce kodlama mülakatlarından örnekler üzerinde çalışacağız: palindrom, kum saati toplamı, parantez eşleştirme, en fazla su tutan iki çizgi ve ağaçlar. Ardından aynı alışkanlıkları ekip çalışmasına taşıyacağız: küçük değişiklikler, testler, pull request ve yararlı inceleme yorumları. Bu algoritmaları önceden bilmeniz gerekmiyor; her örnekte önce problemi açıklayacağız.

Küçük bir örnek: parantezler doğru kapanıyor mu?

Parantez kontrolü, yalnızca yuvarlak (), köşeli [] ve süslü {} parantez işaretlerinden oluşan bir metin alır. Her açılış doğru işaretle ve doğru sırada kapanıyorsa True, kapanmıyorsa False döndürür. Örneğin () geçerlidir: yuvarlak parantez açılır, ardından kapanır.

Geçerli örnek: ([]). Soldan sağa okuyalım. Önce ( ile yuvarlak parantez açılır; sonra onun içinde [ ile köşeli parantez açılır. Ardından ] içteki köşeli parantezi, en son ) dıştaki yuvarlak parantezi kapatır. Sonuç True olur. Bir parantezin içinde başka bir parantez açılmışsa önce içteki kapanmalıdır.

Geçersiz örnek: ([)]. İlk iki işaret yine önce yuvarlak, sonra onun içinde köşeli parantez açar. Fakat üçüncü işaret ): içteki köşeli parantez hâlâ açıkken dıştaki yuvarlak parantezi kapatmaya çalışır. Bu noktada ) değil ] gelmeliydi. Sonuç False olur. Her türün açılışı ve kapanışı vardır ama sıraları yanlıştır.

Bunun kod kalitesiyle bağlantısı şu: Fonksiyon hem doğru sonucu vermeli hem de isimleri ve koşulları, bu kararı nasıl verdiğini okuyucuya göstermeli. Yalnızca () için geçen bir test, bütün parantez düzenlerinin doğru işlendiğini veya kodun kolay anlaşıldığını göstermez. Bu ilk örnek için yığın ya da algoritma bilgisine ihtiyacınız yok.



Sıra sizde

Bu kontrolün () için True döndürmesi tek başına yeterli mi? Başka bir girdi seçip beklenen sonucu ve nedenini söyleyin. İsterseniz parantezleri nasıl kontrol edeceğinizi de anlatabilirsiniz.





Örnek çözümü göster

Hayır. Örneğin ([]) geçerlidir: içteki köşeli parantez, dıştaki yuvarlak parantezden önce kapanır; sonuç True olmalı. ([)] ise aynı sırayı izlemez ve False olmalı. Doğru açıklanmış tek bir ek örnek bu soru için yeterlidir.

Bir çözüm de anlatırsanız açılışları yığında tutup kapanış geldiğinde son açılanla eşleştirmek geçerli bir yaklaşımdır. Burada aynı işaretler değil, ( ile ) gibi eşleşen çiftler aranır. Örneğin tek karakterlik ) girdisinde, açılış olmadan kapanış gelir: yığın boştur, eleman çekmeden geçersiz sayılmalıdır. Okumayı bitirince de açık parantez kalmamalıdır. Bu açıklama örnek bir yaklaşımdır, soruyu cevaplamak için algoritma yazmanız gerekmez.



Kod kalitesini, kod artık zor değiştirilmeye başladığında yapılacak bir süsleme işi saymak.



İyi alışkanlıklar hız kazandırır

Okunur kodun amacı; tahmin yürütmeye, hata aramaya ve aynı şeyi yeniden açıklamaya daha az zaman harcamaktır.

İyi kod yazmak için dört somut neden var: hız, daha az hata, gereksiz uzamayan kod ve okunabilirlik. Anlamlı bir isim belirsizliği kaldırdığında ya da bir yardımcı fonksiyon karmaşık işlemi anlaşılır kıldığında bu faydalar birbirini destekler. Amaç en az karakteri yazmak değil.

Mülakatta çözümü açıklarken bir yandan da kod yazarsınız. İş hayatında ise aylar sonra o kodu başka biri düzeltmek zorunda kalabilir. Her iki durumda da amaç ve varsayımlar görünür olmalı. Anlaşılır kod, algoritmanın doğruluğunu kanıtlamaz; yanlış düşünceyi bulmayı kolaylaştırır.

Kısalmak her zaman sadeleşmek değildir

Aşağıdaki iki fonksiyon da negatif olmayan bir tam sayı n için 1’den n’ye kadar sayıların toplamını hesaplar. İkincisinde çarpanların anlamı daha görünür. Yine de n ile n + 1’in çarpımının neden ikiye bölündüğünü açıklamanız gerekir; matematiksel gerekçenin yerini iyi bir değişken adı tutmaz.

def f(n):
    return n * (n + 1) // 2

def sum_first_numbers(count):
    next_number = count + 1
    return count * next_number // 2

assert sum_first_numbers(4) == f(4) == 10
assert sum_first_numbers(0) == 0

Sıra sizde

On satırlık bir fonksiyonu tek bir yoğun satıra indirmek mutlaka iyileştirme midir? Kararınızı açıklayın.





Örnek çözümü göster

Hayır. Davranışı, okuyucunun aklında tutması gereken varsayımları ve her durumun ne kadar kolay test edildiğini karşılaştırın. Tekrarı kaldırıp kuralı görünür bırakan kısa sürüm yararlıdır. İlgisiz adımları birleştiriyor veya sınır durumunu gizliyorsa uzun sürüm daha anlaşılır olabilir.



Gereksiz uzamayan kod ile sıkıştırılmış kodu aynı şey sanmak.



İsim, değerin ne olduğunu anlatsın

Palindrom, iki yönden de aynı okunan metindir. Bu ASCII metin örneğinde noktalama işaretlerini ve büyük-küçük harf farkını yok sayacağız.

Örneğin A man, a plan, a canal: Panama metni amanaplanacanalpanama olur ve sonuç True olmalı. text girdiyi, normalized dönüştürülmüş metni, left ve right ise konumları anlatır. l harfi 1 rakamıyla karışabilir; kısa isimler ancak belirsizlik yaratmadığında yararlıdır.

İki sürümü karşılaştırırken tek bir şeyi değiştirin. Aşağıda metni temizleme adımı ve iki işaretçili algoritma aynı; böylece isimlerin etkisini, algoritma değişikliğiyle karıştırmadan değerlendirebilirsiniz. Temizlenmiş metin için O(n) ek bellek kullanılır; iyi isimlendirme bu maliyeti azaltmaz.

Burada n, girdideki karakter sayısıdır. O(n) bellek, kullanılan alanın n ile orantılı büyüyebileceğini; O(1) ise girdi büyüse de sabit miktarda kalacağını söyler. Bu gösterim tam bayt veya saniye sayısını değil, büyüme biçimini anlatır.

Anlaşılır isimlerle palindrom kontrolü

Metin temizlendikten sonra iki işaretçi içeriye doğru ilerler. Bir çift uyuşmazsa hemen False döner. İşaretçiler buluştuğunda veya birbirini geçtiğinde bütün çiftler eşleşmiştir. Bu alıştırmanın tanımında temizlendikten sonra boş kalan metin de True verir.

# Before: the same algorithm, with ambiguous names.
def palindrome_before(s):
    s = "".join(c.lower() for c in s if c.isalnum())
    l, r = 0, len(s) - 1
    while l < r:
        if s[l] != s[r]:
            return False
        l += 1
        r -= 1
    return True

# After: names reveal the same decisions.
def is_palindrome(text):
    normalized = "".join(
        char.lower() for char in text if char.isalnum()
    )
    left, right = 0, len(normalized) - 1
    while left < right:
        if normalized[left] != normalized[right]:
            return False
        left += 1
        right -= 1
    return True

assert is_palindrome("A man, a plan, a canal: Panama")
assert not is_palindrome("race a car")
assert is_palindrome("!!!")
for sample in ("A man, a plan, a canal: Panama", "race a car", "!!!"):
    assert palindrome_before(sample) == is_palindrome(sample)

Sıra sizde

s, l ve r için isim önerin. l adını bir yerde değiştirip karşılaştırmada değiştirmezseniz ne olur?





Örnek çözümü göster

text veya normalized_text; left veya left_index; right veya right_index kullanılabilir. İsmini değiştirdiğiniz değişkenin bütün kullanımlarını güncelleyin. Eski isim NameError üretebilir veya yanlışlıkla başka bir değişkeni okuyabilir. İsim değiştirmek, fonksiyonun kabul ettiği karakterleri değiştirmek değildir.



İsimlendirme iyileştirmesini algoritmanın hızlandığına dair kanıt saymak.



Yardımcı fonksiyon çözümün bir adımını anlatsın

Bir matriste kum saati şekli; üstte üç, ortada bir, altta üç hücreden oluşur.

Bir kum saatinin toplamını hesaplamak ile bütün matriste en büyük toplamı aramak farklı iki iştir. Bu anlamlı bir ayrım: yedi hücrenin hesabını doğrularken iki iç içe arama döngüsünü de düşünmeniz gerekmiyor. Yardımcı fonksiyonun değeri satır azaltmasından değil, çözümün bir adımına isim vermesinden gelir.

Bu örnekte girdi, en az üç satırı ve üç sütunu olan dikdörtgen bir tam sayı matrisi. Her sol üst konum için bir aday toplam hesaplayıp o ana kadarki en iyi sonuçla karşılaştırıyoruz. Yan yana duran kum saatlerinin toplamlarını birbirine eklemiyoruz; bunlar birbirine alternatif adaylar. Bütün değerler negatifken de çalışması için başlangıç değerini gerçek bir adaydan alın.

Önce tek şeklin hesabı, sonra arama

Satırları [1, 2, 3, 4], [0, 5, 6, 0] ve [7, 8, 9, 10] olan bir matris alalım. Soldaki konumda üstten 1, 2, 3; ortadan 5; alttan 7, 8, 9 seçilir. Toplam 1 + 2 + 3 + 5 + 7 + 8 + 9 = 35 olur. Bir sütun sağa kayınca 2 + 3 + 4 + 6 + 8 + 9 + 10 = 42 elde edilir. Aradığımız, tek bir şeklin en büyük toplamı olan 42’dir; 35 + 42 = 77 değil.

3 satırlı, 4 sütunlu bir matriste iki kum saati adayı vardır. Yardımcı fonksiyon grid, top ve left girdilerini açıkça alır. Kum saatinin boyutu sabit olduğu için her hesap O(1), bütün arama O(rows × columns) sürer.

def hourglass_sum(grid, top, left):
    top_sum = sum(grid[top][left:left + 3])
    middle = grid[top + 1][left + 1]
    bottom_sum = sum(grid[top + 2][left:left + 3])
    return top_sum + middle + bottom_sum

def max_hourglass_sum(grid):
    best = hourglass_sum(grid, 0, 0)
    for top in range(len(grid) - 2):
        for left in range(len(grid[0]) - 2):
            best = max(best, hourglass_sum(grid, top, left))
    return best

assert hourglass_sum([[1]*3, [1]*3, [1]*3], 0, 0) == 7
assert max_hourglass_sum([[-1]*4 for _ in range(3)]) == -7

Sıra sizde

3 × 3 bir matrisin bütün hücreleri -1. Tek kum saatinin toplamı nedir; best = 0 hangi yanlış sonucu korur? hourglass_sum yardımcısını aramadan ayrı test etmek için bir girdi ve beklenen sonuç verin.





Örnek çözümü göster

Seçilen yedi hücrenin toplamı -7’dir. Başlangıç maksimumu 0 olursa hiçbir kum saatine ait olmayan 0 sonuç olarak kalır. İlk gerçek adaydan başlamak -7 verir. Ayrı bir yardımcı kontrolü: hourglass_sum([[1, 1, 1], [1, 1, 1], [1, 1, 1]], 0, 0) == 7. Bu, arama döngüsü olmadan yedi hücrenin hesabını kontrol eder.



Hesap yanlış toplanıyor veya yanlış bir başlangıç değeri kullanıyorken yalnızca yardımcı fonksiyona ayırmak.



Kodun düzeni akışı görünür kılsın

Python’da girinti, bir satırın hangi koşula veya döngüye ait olduğunu belirler. Parantez içindeki satır kırılımları da aynı yapıyı okuyucuya gösterir.

Tutarlı bir girinti kullanın; Python stil rehberi her blok için dört boşluk önerir. Uzun koşulları parantez içine alıp her parçayı ayrı değerlendirmeyi kolaylaştıracak şekilde yazın. Python’da girinti yalnızca görsel değildir: bir return satırını kaydırmak sonucu değiştirebilir.

Sıkıştırılmış bir matris kontrolünü, parçaları ayrı satırlarda görülen bir koşulla karşılaştırın. Bu örnekte inside_grid, iki koordinatın da dikdörtgen matrisin içinde olup olmadığını söyler. grid[0] okumadan önce en az bir satır bulunduğunu kontrol edin. Python’daki and soldan sağa çalışıp ilk yanlış koşulda durur; bu yüzden boş matris güvenle ele alınır.

Sınır kontrolleri ayrı ayrı görülsün

2 satırlı ve 3 sütunlu bir matriste 1. satır ile 2. sütun geçerlidir; 2. satır sınırın dışındadır. Her satır bir koşulu gösterir. Matris boşsa son koşul hiç çalıştırılmaz.

# Before: the conditions are correct but crowded onto one line.
def inside_grid_compact(grid, row, column):
    return bool(grid) and 0 <= row < len(grid) and 0 <= column < len(grid[0])

# After: preserve the evaluation order while exposing each condition.
def inside_grid(grid, row, column):
    return (
        bool(grid)
        and 0 <= row < len(grid)
        and 0 <= column < len(grid[0])
    )

assert inside_grid([[0]*3 for _ in range(2)], 1, 2)
assert not inside_grid([[0]*3 for _ in range(2)], 2, 0)
assert not inside_grid([], 0, 0)
for grid, row, column in (([], 0, 0), ([[0]*3]*2, 1, 2), ([[0]*3]*2, 2, 0)):
    assert inside_grid_compact(grid, row, column) == inside_grid(grid, row, column)

Sıra sizde

inside_grid([], 0, 0) çağrısında grid[0] okunmadan hangi ifade değerlendirmeyi durdurur? Önce 0 <= column < len(grid[0]) değerlendirilse ne olur?





Örnek çözümü göster

[] için bool(grid) False olur; and durur ve fonksiyon grid[0] okumadan False döndürür. Sütun ifadesi önce değerlendirilirse var olmayan ilk satır grid[0] okunurken IndexError oluşur. Aynı kontrollerin değerlendirme sırası davranışı değiştirebilir.



Bir koşulu yeniden düzenlerken değerlendirme sırasını veya return satırının ait olduğu bloğu kontrol etmemek.



Yorum, kolay anlaşılmayan kararı açıklasın

Yararlı yorum, bir adımın neden gerekli olduğunu anlatır. Her atamayı tekrar etmez.

Yorumun görevine odaklanın: sağdaki sayının neden önce alındığını açıklamalı. Aşağıdaki çıkarma örneği, bu yorumu değerlendirmek için yeterli; alıştırmadan sonra hesaplayıcının tamamını yeniden inceleyebilirsiniz.

Yığında en son eklenen değer ilk çıkar. Python listesinde append sona ekler, pop sondakini çıkarır. Sonekli gösterimde işlem işareti sayılardan sonra gelir: 7 3 - ifadesi 7 eksi 3 demektir. Sağdaki sayı yığına en son konduğu için önce o çıkarılır. Açıklanması gereken bu sıradır; yığından çıkar yorumu pek bir şey katmaz.

Tam sayı bölmesinin kuralı da açık olmalı. Bu alıştırmada sonuç sıfıra doğru kesilir: -7 bölü 3, -2 olur. Python’daki // ise aşağı yuvarlayıp -3 verir. Mutlak değerlerle bölüp işareti sonradan uygulamak hem bu farkı hem de çok büyük tam sayıları float’a çevirirken oluşabilecek hassasiyet kaybını önler.

Dilin kendiliğinden uygulamadığı kuralı açıklayın

Aşağıdaki yardımcı fonksiyon yalnızca bölme adımını uygular. Girdilerin tam sayı olduğu kabul edilir; bölen sıfırsa bilerek ZeroDivisionError üretir. Tam bir ifade hesaplayıcısı, işaretleri ve yığındaki eleman sayısını da kontrol etmelidir; bu yardımcı bütün programın yerine geçmez.

stack = [7, 3]
right = stack.pop()
left = stack.pop()
stack.append(left - right)
assert stack == [4]

def divide_toward_zero(left, right):
    if right == 0:
        raise ZeroDivisionError("division by zero")
    # // rounds down; the expression language truncates toward zero.
    magnitude = abs(left) // abs(right)
    return -magnitude if (left < 0) != (right < 0) else magnitude

assert divide_toward_zero(-7, 3) == -2
assert divide_toward_zero(7, -3) == -2
assert divide_toward_zero(-7, -3) == 2

Sıra sizde

Çıkarma işleminde yığından iki sayı alınmasının sırası için yararlı, tek cümlelik bir yorum yazın.





Örnek çözümü göster

Örneğin: Sağdaki sayı yığının tepesinde olduğundan önce onu alır, ardından sol eksi sağ işlemini yaparız. Bu yorum, sırayı ters çevirmenin 7 - 3 yerine neden 3 - 7 hesaplayacağını açıklar.



Önce isimleri ve yapıyı iyileştirmek yerine anlaşılmaz kodu yorumlarla kapatmak.



Anlaşılır arayüz, gizli işi azaltır

Önek toplamları, aynı aralıkları tekrar tekrar toplamak yerine o ana kadarki toplamları saklar.

Bu örnekte arayüzü inceleyin: çağıran kişi hangi sınırın dahil olduğunu ve bir kez yapılacak hazırlığın nerede duracağını anlayabiliyor mu? Önce sorulan iki aralığın toplamını hesaplayın, sonra bu kararların sınıfta açıkça görünüp görünmediğine bakın.

Bu örnekte dizinin değerleri ve sorgudaki indeksler tam sayıdır. [2, -1, 4] için [0, 2, 1, 5] önek toplamlarını tutalım. start konumundan başlayıp end konumunu dışarıda bırakan aralığın toplamı, prefix[end] eksi prefix[start] olur. Baştaki sıfır, start sıfırken ayrı bir koşul yazma ihtiyacını kaldırır. Aralığın sınırları, fonksiyonun nasıl kullanılacağının bir parçasıdır ve açıklanmalıdır.

Hazırlığı sorgulamadan ayırın: toplamları O(n) sürede bir kez hazırlayıp her sorguya O(1) sürede yanıt verin. Her sorguda toplamları yeniden kurmak gereksiz iş yapar. Aşağıdaki sınıfta PrefixSums(values) bir nesne oluştururken __init__ çalışır. self.prefix o nesnenin toplamlarını saklar; sonraki range_sum çağrıları bunları yeniden kullanır.

Aralık kuralı açık olan küçük bir sınıf

Toplamları tek tek oluşturalım: 0’dan başlarız; 2 ekleyince 2, -1 ekleyince 1, 4 ekleyince 5 olur. Böylece [0, 2, 1, 5] elde edilir. Dizide konumlar sıfırdan başlar: values[1] değeri -1, values[2] değeri 4’tür. range_sum(1, 3) bu iki konumu alır, 3. konumdan önce durur. Hesap prefix[3] - prefix[1] = 5 - 2 = 3 olur.

range_sum(1, 3), -1 ve 4 değerlerini kapsar; sonuç 3’tür. range_sum(0, 0) boş aralık için 0 döndürür. Tam sayı indekslerde sınır dışı veya ters aralık ValueError ile reddedilir. Tam sayı olmayan indeksler bu örneğin desteklediği girdiler arasında değildir.

class PrefixSums:
    def __init__(self, values):
        self.prefix = [0]
        for value in values:
            self.prefix.append(self.prefix[-1] + value)

    def range_sum(self, start, end):
        if not 0 <= start <= end < len(self.prefix):
            raise ValueError("invalid half-open range")
        return self.prefix[end] - self.prefix[start]

sums = PrefixSums([2, -1, 4])
assert sums.range_sum(1, 3) == 3
assert sums.range_sum(0, 0) == 0

Sıra sizde

[2, -1, 4] için range_sum(0, 3) ve range_sum(2, 2) ne döndürmeli? Nesneyi sorgu döngüsünün dışında oluşturmak neden önemli?





Örnek çözümü göster

Sonuçlar 5 ve 0’dır. Bir kez hazırlık O(n), q sorgu O(q) sürer; toplam O(n + q) olur. Nesneyi döngü içinde tekrar kurmak O(n × q) maliyet doğurabilir. Sınıfa iyi bir isim vermek, onu kullanan kodun da verimli olduğunu garanti etmez.



Bitiş indeksinin aralığa dahil olup olmadığını belirtmeden arayüzün anlaşılır olduğunu söylemek.



Daha önce gördüğünüz toplamları takip edin

Hedef toplamı veren, boş olmayan kesintisiz bir aralık ararken her konumdan önce görülen toplamları hatırlayın.

Burada isimler ve işlem sırası, hangi bilginin saklandığını göstermeli. Önce alıştırmadaki tek elemanlı girdileri izleyin: seen_totals yalnızca önceki toplamları mı, mevcut toplamı da mı içeriyor? Ardından daha uzun aralık örneğine dönebilirsiniz.

Bu örnekte dizinin değerleri ve hedef toplam tam sayıdır. Önek toplamları, belirli toplamı veren kesintisiz bir aralık olup olmadığını da gösterebilir. O anki toplam current, önceki bir toplam previous ise aradaki elemanların toplamı current - previous olur. Dolayısıyla current - target değerinde bir önceki toplam ararız.

İlk elemandan başlayan aralıkların da bulunması için seen kümesini sıfırla başlatın. Hedef sıfır olduğunda boş aralığı yanlışlıkla eşleşme saymamak için mevcut toplamı eklemeden önce kontrol edin. Küme, dizinin tek tek değerlerini değil toplamları tutar. Hash kümesiyle beklenen süre O(n), ek bellek O(n) olur. Küme, farklı değerleri tutar: {0} tek bir toplamla başlar, add yeni toplam ekler. Bir değerin kümede olup olmadığı sorusu, önceki toplamların hepsini tek tek dolaşmadan yanıtlanır.

Negatif sayıyı ve sıfır hedefi izleyin

[2, -1, 4] ve hedef 3 için toplamlar 2, 1, 5 ilerler. 5’e gelince önceki 2 bulunur; aradaki [-1, 4] toplamı 3’tür. [5] ve hedef 0 için boş olmayan eşleşme yoktur; 5’i kontrol öncesinde eklemek mevcut toplamı kendisiyle eşleştirip yanlış sonuç verir.

def contains_target_sum(values, target):
    seen_totals = {0}
    current_total = 0
    for value in values:
        current_total += value
        if current_total - target in seen_totals:
            return True
        seen_totals.add(current_total)
    return False

assert contains_target_sum([2, -1, 4], 3)
assert contains_target_sum([0], 0)
assert not contains_target_sum([5], 0)
assert not contains_target_sum([], 0)

Sıra sizde

seen_totals başlangıçta {0}. Hedef 0 iken [0] neden True, [5] neden False döner? Mevcut toplam neden kümeye eklenmeden önce kontrol edilir?





Örnek çözümü göster

[0] için current_total 0 olur; current_total - target olan 0, {0} içinde zaten vardır. Bu önceki sıfır, elemandan önceki konumu temsil eder; dolayısıyla [0] boş olmayan bir eşleşmedir. [5] için gereken 5 toplamı {0} içinde yoktur ve sonuç False olur. Önce 5 eklenirse kendisiyle eşleşir ve boş aralık yanlışlıkla kabul edilir.



Toplamlar yerine dizinin değerlerini saklamak veya kontrol etmeden önce mevcut toplamı kümeye eklemek.



Parantez eşleştirmeyi okuyarak inceleyin

Geçerli bir parantez dizisinde her açılış aynı türden bir kapanışla ve doğru iç içe geçme sırasıyla eşleşir.

Bu parantez eşleştirme örneği, A2SV öğrenci kodu karşılaştırmasından uyarlandı. Girdide yalnızca (), [] ve {} karakterleri bulunuyor. Yığın, henüz kapanmamış açılışları tutar; en son açılan önce kapanmalı. Bu yüzden yalnızca sayıları karşılaştırmak ([)] girdisini reddetmeye yetmez.

closing_for ve openings isimleri iki veri yapısının işini anlatır. Koşul, yığından eleman almadan önce boş olup olmadığını kontrol eder. Sonunda yığının boş olması bütün açılışların kapandığını gösterir. Algoritma O(n) zaman ve en fazla O(n) yığın belleği kullanır.

Yalnızca doğru girdiyi değil, hatanın yakalandığı yeri izleyin

Geçersiz ([)] girdisini işaret işaret izleyin. Önce ( kapanmamış bir yuvarlak parantez olarak saklanır. Sonra [ onun üstüne kapanmamış köşeli parantez olarak eklenir. ) geldiğinde en son açılan parantez [, onun beklediği kapanış ise ] olur. Türler uyuşmadığı için fonksiyon hemen False döndürür.

Şimdi ([] girdisini izleyin. İlk iki işaret yuvarlak ve köşeli parantez açar. Son işaret ] köşeli açılışla eşleşir; bu açılış kayıttan çıkarılır. Metin bittiğinde yuvarlak açılış ( hâlâ durur. Bu yüzden sondaki yığın boş mu kontrolü False verir. Sona ) ekleyip ([]) yaparsanız son açılış da kapanır ve sonuç True olur.

def brackets_match(text):
    closing_for = {"(": ")", "[": "]", "{": "}"}
    openings = []
    for char in text:
        if char in closing_for:
            openings.append(char)
        elif not openings or closing_for[openings.pop()] != char:
            return False
    return not openings

assert brackets_match("([]){()}")
assert not brackets_match(")")
assert not brackets_match("([)]")
assert not brackets_match("([]")

Sıra sizde

Şu girdilerin her birini hangi kontrol reddeder: ), ([)] ve ([]?





Örnek çözümü göster

İlkinde karşılığı olmayan bir kapanış gelir. İkincisinde en son açılan parantezin türüyle kapanış uyuşmaz. Üçüncüsünde işlem sonunda açık parantez kalır. Bunlar üç ayrı hata biçimidir; her biri için ayrı test yazmak anlamlıdır.



Açılan ve kapanan parantez sayıları eşitse iç içe geçme sırasının da doğru olduğunu varsaymak.



İşaretçinin neden ilerlediğini anlatın

En çok su tutan iki dikey çizgiyi seçin. Alan, aralarındaki uzaklık ile kısa olan çizginin yüksekliğinin çarpımıdır.

İki sürümün aynı işaretçi kararını nasıl anlattığını karşılaştırın. Verilen yüksekliklerle tek bir hareketi izleyin; isimler, durma koşulu ve yorum, başka bir okuyucunun bu hareketi açıklamasını sağlıyor mu? Aramanın tamamını daha ayrıntılı incelemek için koda dönebilirsiniz.

li, l ve r yerine anlamlı sınır isimleri kullanın. Kullanmadığınız değerler üzerinde dönen for yerine, iki çizgi arasında hâlâ genişlik olduğunu söyleyen bir while koşulu yazın. Bu değişiklikler yalnızca kodu güzelleştirmez; algoritmayı görünür kılar.

Neden kısa çizgiyi ilerletiyoruz? Kısa olanı yerinde tutup uzun olanı içeri alırsanız genişlik azalır, suyu sınırlayan yükseklik ise artamaz. Bu şekilde mevcut alandan daha iyisini elde edemezsiniz. Bu yüzden kısa sınırı bırakıp daha uzun bir aday arayın. İşaretçinin hareketini açıklayan gerekçe budur; left değerini artır yorumu değil.

Kararı gerçek sayılarla izleyin

Dizideki her sayı bir dikey çizginin yüksekliğidir; yan yana iki çizgi arasında bir birim vardır. Aşağıdaki örnekte ilk ve son çizgi 8 birim uzaktadır; yükseklikleri 1 ve 7’dir. Su kısa çizgi olan 1 yüksekliğini aşamayacağı için alan 1 × 8 = 8 olur. Sol ucu bir sonraki çizgiye taşırsak solda 8, sağda 7 yükseklik ve arada 7 birim genişlik kalır.

[1, 8, 6, 2, 5, 4, 8, 3, 7] için en dıştaki alan 1 × 8 = 8 olur. Sol işaretçiyi ilerletince 7 × 7 = 49 elde edilir. Bütün arama bu en büyük değeri korur. Yükseklikler negatif olmayan tam sayılardır; ikiden az çizgi varsa sonuç 0 olur. Her turda bir işaretçi içeri ilerler; süre O(n), ek bellek O(1) olur.

# Before: the loop variable is unused and the stopping rule is buried.
def max_area_before(li):
    l, best, r = 0, 0, len(li) - 1
    for _ in li:
        best = max(best, min(li[l], li[r]) * (r - l))
        if li[r] < li[l]:
            r -= 1
        else:
            l += 1
        if l >= r:
            break
    return best

# After: the same supported results with explicit pointer names and loop bounds.
def max_water_area(heights):
    left, right = 0, len(heights) - 1
    best = 0
    while left < right:
        width = right - left
        height = min(heights[left], heights[right])
        best = max(best, width * height)
        # Keeping the shorter boundary cannot improve the area.
        if heights[left] <= heights[right]:
            left += 1
        else:
            right -= 1
    return best

assert max_water_area([1,8,6,2,5,4,8,3,7]) == 49
assert max_water_area([]) == 0
for heights in ([], [5], [1,8,6,2,5,4,8,3,7]):
    assert max_area_before(heights) == max_water_area(heights)

Sıra sizde

Yükseklikler 8 ve 7, aralarındaki uzaklık 7 ise hangi işaretçi ilerlemeli? 7 yüksekliğini tutup genişliği küçültmek neden işe yaramaz?





Örnek çözümü göster

Yüksekliği 7 olan sınırı ilerletin. Onu yerinde tutarsanız yükseklik en fazla 7 olur ve genişlik küçülür; alan mevcut 49’u geçemez. İki yükseklik eşitse herhangi bir tarafı ilerletebilirsiniz; atılan sınırı kullanan daha iyi bir çifti kaçırmazsınız.



Hangi adayların güvenle elendiğini açıklamadan işaretçi hareketini ezberlenecek bir numara gibi sunmak.



Özyinelemede hangi düğümü kontrol ettiğinizi belirtin

Bir ikili arama ağacını doğrularken her düğüm, bütün atalarından gelen değer sınırlarına uymalıdır.

Parametre isimlerini, her çağrının ihtiyaç duyduğu bilgiye göre değerlendirin: mevcut düğüm ve izin verilen sınırlar. Bütün özyinelemeli çağrılardan önce verilen ağaçta 6 düğümüne giden yolu izleyin. Bu yol, alıştırmadaki isim ve sınır kararlarını açıklamak için yeterlidir.

Düğüm, ağaçtaki bir değer ve en fazla iki çocuk düğüme giden bağlantılardan oluşur: sol ve sağ. Kök, en üstteki düğümdür. Alt ağaç, bir düğümü ve onun altındakileri kapsar. Bir düğümün ataları, kökten ona gelirken geçilen düğümlerdir; değer sınırı yalnızca hemen üstündeki ebeveynden değil, bunların herhangi birinden gelebilir.

Bu örnekte ikili arama ağacının solundaki değerler kesinlikle küçük, sağındakiler kesinlikle büyük olmalı; tekrar eden değerlere izin verilmiyor. Düğümü yalnızca doğrudan çocuklarıyla karşılaştırmak daha derindeki hataları kaçırır. İzin verilen alt ve üst sınırı özyinelemeli çağrılara taşıyın.

Özyineleme, bir fonksiyonun kendisini yapının daha küçük bir parçası için çağırmasıdır; burada her çağrı bir alt ağacı ele alır. Özyinelemeli yardımcı fonksiyonda düğüm parametresi için root yerine current adını düşünün. İkisi de kullanılabilir; current her çağrıda farklı bir düğümün incelendiğini daha açık anlatır. Asıl mesele parametrelerin anlamı: sol alt ağaca daha dar bir üst sınır, sağ alt ağaca daha dar bir alt sınır aktarılır.

Yalnızca ebeveynine bakınca kaçan hata

Kökü 10 olan ağacın sağ çocuğu 15, onun sol çocuğu 6 olsun. 6, 15’ten küçüktür ama 10’un sağ alt ağacında olduğu için 10’dan da büyük olmalıdır. Atadan gelen sınır bunu yakalar. Kodda bir düğüm (değer, sol, sağ) üçlüsüyle, boş alt ağaç None ile gösteriliyor.

def valid_bst(current, lower=float("-inf"), upper=float("inf")):
    if current is None:
        return True
    value, left, right = current
    if not lower < value < upper:
        return False
    return (
        valid_bst(left, lower, value)
        and valid_bst(right, value, upper)
    )

assert valid_bst((10, (5, None, None), (15, None, None)))
assert not valid_bst((10, None, (15, (6, None, None), None)))

Sıra sizde

Bu ağaçtaki 6 düğümü için lower ve upper nedir? Hangi koşul sağlanmaz?





Örnek çözümü göster

Sınırlar 10 ve 15’tir. 10 < 6 < 15 koşulu sağlanmaz. Boş alt ağaç geçerlidir; düğüm varsa kesin alt ve üst sınırlar içinde kalmalıdır. Algoritma en fazla n düğüm gezer, yüksekliği h olan ağaç için O(h) çağrı yığını kullanır.



root adını current yapıp hâlâ yalnızca doğrudan ebeveyni kontrol etmek.



Değişebilen bağımlılıkları açıkça gösterin

Sonucun, başka yerde değiştirilen bir değere değil görünen girdilere bağlı olması fonksiyonu anlamayı kolaylaştırır.

Başka yerde değiştirilen bir değer, hesabı takip etmeyi zorlaştırır. Fonksiyon böleni dışarıdan okuyor, başka bir fonksiyon da onu değiştiriyorsa aynı girdi çağrı sırasına göre farklı sonuç verebilir. Bölen hesabın parçasıysa parametre olarak alın.

Bu örnekte set_value içindeki value ataması fonksiyonun kendi yerel değişkenini değiştirir; global veya nonlocal ile başka bir kapsama yönlendirilmemiştir. Çağıranın tam sayısını güncellemez. Güncelleme istiyorsanız yeni değeri döndürüp çağrının yapıldığı yerde atayın. Modül düzeyindeki sabitler, değişen ortak durumdan farklıdır; sabit bir kuralı daha anlaşılır kılabilirler.

Girdiler de sonuç da görünür olsun

Burada divide iki sayıyı da parametre olarak alır ve sıfıra bölmeyi reddeder. Önce bir hazırlık fonksiyonunun çalışmasına gerek yoktur. İkinci örnek, fonksiyon içinde value = 5 yazmanın çağıranın tam sayısını neden değiştirmediğini gösterir.

def divide(value, divisor):
    if divisor == 0:
        raise ValueError("divisor must not be zero")
    return value / divisor

def set_value(value):
    value = 5

number = 1
set_value(number)
assert number == 1
assert divide(12, 3) == 4

Sıra sizde

number başlangıçta 1. Gösterilen set_value(number), fonksiyon içinde value = 5 atıyor ama değer döndürmüyor. Çağrıdan sonra number nedir? Değer döndürüp çağrı yerinde atama yaparak number değerini 5 yapmayı gösterin.





Örnek çözümü göster

number 1 kalır: value yerel parametredir; ona atama yapmak çağıranın değişkenini yeniden atamaz. Açık bir değişiklik: def set_value(value): return 5; ardından number = set_value(number). Çağıran artık dönen 5 değerini number değişkenine atar. Global değişken veya paylaşılan nesneyi değiştirmek gerekmez.



Sabitleri, yerel atamayı ve paylaşılan değişebilir durumu ayırmadan global asla kullanılmaz kuralını tekrarlamak.



Küçük stil kararlarında tutarlı olun

Import düzeni, boşluklar ve isimler tutarlı olduğunda okuyucu, yazanın tarzına alışmak yerine kodun mantığına odaklanır.

Import satırlarını ayrı, işlemleri okunur yazın. Python’da import os ve import sys ayrı satırlarda yer alır; aynı modülden alınan ilgili isimler tek bir from import satırında bulunabilir. Her dosyaya alışkanlıkla import eklemek yerine kullanılmayanları kaldırın.

Projenin stilini seçip mekanik düzenlemeyi mümkün olduğunca otomatikleştirin. Biçimlendirici boşlukları ve satır kırılımlarını düzenleyebilir; değişkenin doğru kavramı anlatıp anlatmadığına veya koşulun doğruluğuna karar veremez. Davranış değiştiren bir pull request içinde ilgisiz dosyaları biçimlendirmekten kaçının; önemli satırları gizler.

İfade bir bakışta okunabilsin

Kareler farkı hesabını düşünün. Boşluklar iki parantezli ifadeyi ayırır; isim de işlemin neyi temsil ettiğini söyler. assert, biçimin beğenilip beğenilmediğini değil hesaplanan değeri kontrol eder.

def difference_of_squares(first, second):
    return (first + second) * (first - second)

assert difference_of_squares(5, 2) == 21

Sıra sizde

Bir pull request tek bir sınır kontrolünü düzeltirken ilgisiz 40 dosyayı da biçimlendiriyor. Yazardan ne istersiniz, neden?





Örnek çözümü göster

İlgisiz biçim düzenlemesini ayrı değişikliğe almasını isteyin. Odaklı farklar, davranış değişikliğini incelemeyi ve gerektiğinde geri almayı kolaylaştırır. Düzenlenen dosyada biçimlendirme gerekiyorsa her yerde sıfır boşluk değişikliği istemek yerine kapsamı açıklayın.



Projenin biçimlendiricisinin zaten çözdüğü bir konuda kişisel stil tercihini dayatmak.



Mülakat zorlaşınca bu alışkanlıklara başvurun

Zaman baskısı altında anlamlı isimler ve küçük adımlar, aynı anda aklınızda tutmanız gereken işi azaltır.

Aynı anda açıklamanız, kod yazmanız ve hata aramanız gerekebilir. İsimli bir yardımcı fonksiyon, bir düşünce adımını tamamlayıp sonraki adımda onu kullanmanızı sağlar. Yazmadan önce fonksiyonun girdisini ve sonucunu söyleyin; her tuşu anlatmak yerine tamamladığınız mantıksal bloğu açıklayın.

En verimli algoritmayı hemen bitiremiyorsanız önce doğru ama daha basit bir yaklaşımı ve maliyetini anlatın; ardından yavaş kısmı araştırın. Belirsizliği yoğun kodla veya ezberlenmiş bir numarayla saklamayın. Bu dersteki mülakat örnekleri düşüncenizi başkasının inceleyebileceği hale getirme alıştırmasıdır; problemi anlamanın yerine geçmez.

Kod yazarken yapılabilecek somut açıklama

Kum saati araması için: Önce bir sol üst konumdaki yedi hücreyi toplayan yardımcı fonksiyonu yazacağım. Sonra geçerli bütün konumları gezip en büyük adayı tutacağım. Başlangıç için sıfır güvenli olmadığından tamamen negatif bir matrisle de kontrol edeceğim. Bu, başka birinin takip edebileceği bir plandır.



Sıra sizde

Parantez döngüsünü yazdınız ama henüz test etmediniz. Mülakatı yapan kişiye kısa bir durum açıklaması yapın; ardından yalnızca parantezlerden oluşan iki test girdisini, beklenen sonuçlarını ve nedenlerini söyleyin.





Örnek çözümü göster

“Döngü artık eşleşmemiş açılışları tutuyor; henüz test etmedim. Sonraki kontrolüm ([)] olacak: ) son açılış [ ile eşleşmediği için False bekliyorum. Ayrıca ([] deneyeceğim: dıştaki ( sonda açık kaldığı için False bekliyorum.” Bunlar planlanan kontrollerdir; geçmiş test sonucu değildir.



Yalnızca denemek istediğiniz girdileri sıraladığınız halde testler geçti demek.



Kodu düzenlerken kuralı sessizce değiştirmeyin

Yeniden düzenleme, kodun yapısını iyileştirirken kullananların dayandığı davranışı korur. Yeni bir indirim politikası ayrı bir davranış değişikliğidir.

Aynı alışkanlıklar, ekipte kod değiştirirken de önemlidir. Aynı kuralı izlemek zorunda olan yerlerde mantığı paylaşın. Satırların benzemesi tek başına yeterli değil: geçmiş fatura eski fiyatı korurken canlı sepet bugünkü fiyatı kullanabilir.

Yardımcı fonksiyon çıkarmadan önce örnek sonuçları ve sınırları kaydedin. Yapısal değişikliği yapıp bu kontrolleri yeniden çalıştırın. Mevcut davranış yanlışsa bunu ayrıca belirtin: hatayı koruyan bir test, kodun şu an ne yaptığını gösterir; hatayı sonsuza kadar tutma gerekçesi değildir.

Bir fiyatlandırma kuralını ayırın

Alıştırmanın kuralı, kitaplara %10 indirim uygulanması ve diğer türlere uygulanmaması. calculate_item_price bu kurala isim verir; calculate_cart_total sonuçları birleştirir. Geçerli ürünlerde type ve negatif olmayan sayısal price bulunur. Örnek; vergi, para yuvarlama veya eksik alan politikası eklemiyor.

BOOK_DISCOUNT_RATE = 0.10

def calculate_item_price(item):
    if item["type"] == "book":
        return item["price"] * (1 - BOOK_DISCOUNT_RATE)
    return item["price"]

def calculate_cart_total(items):
    return sum(calculate_item_price(item) for item in items)

assert calculate_item_price({"type": "book", "price": 100}) == 90
assert calculate_cart_total([]) == 0

Sıra sizde

Kitap indirimini yardımcı fonksiyona çıkarırken aynı commit içinde %10’dan %15’e yükselttiniz. Bu yalnızca yeniden düzenleme midir?





Örnek çözümü göster

Hayır. Fonksiyona ayırmak yapıyı, yeni oran ise sonucu değiştirir. Fiyatı 100 olan kitapta sonuç 90’dan 85’e iner. İnceleyen kişi iki kararı ayrı değerlendirebilsin diye politika değişikliğini ayrıca açıklayın ve test edin.



İki farklı politikayı, şu an aynı çarpımı yapıyorlar diye tek bir kurala zorlamak.



Hesabı dış dünyadaki işlemden ayırın

E-posta göndermek ile hesap yapmak farklı nedenlerle başarısız olur. İkisine de ayrı test edilebilen bir sınır verin.

Yan etki, hesabın dışında bir şeyi değiştirir: e-posta yollar, dosya yazar veya ödeme kaydeder. Aritmetik fonksiyonu aynı zamanda e-posta gönderiyorsa hesabı test etmek de gönderime bağımlı hale gelir. Önce hesabı, sonra gönderimi çağıran fonksiyona, gönderme fonksiyonunu parametre olarak verin. Testte onun yerine bir listeye ekleyen fonksiyon kullanabilirsiniz.

Hata durumundaki davranış da fonksiyonun kullanım kuralıdır. Burada negatif miktar geçersiz; calculate_total, gönderime ulaşmadan ValueError üretir. Bulunamadı sonucu için belgelenmiş bir None dönüşü uygun olabilir; bütün hataları None arkasına gizlemek uygun değildir. Çağıran, hangi sonuçları ele alacağını bilmelidir.

Geçersiz girdi hiçbir gönderim oluşturmasın

receipts.append gönderimin yerine verilen ve tutarları listeye ekleyen bir fonksiyondur; mesaj göndermez. Doğrulama başarısızsa bu satıra ulaşılmamalı. Gerçek gönderim hizmeti ayrıca hata verebilir; bu küçük test güvenilir e-posta teslimatını kanıtlamaz.

def calculate_total(price, quantity):
    if quantity < 0:
        raise ValueError("quantity must not be negative")
    return price * quantity

def complete_order(price, quantity, send_receipt):
    total = calculate_total(price, quantity)
    send_receipt(total)
    return total

receipts = []
assert complete_order(12, 3, receipts.append) == 36
try:
    complete_order(12, -1, receipts.append)
except ValueError:
    pass
else:
    raise AssertionError("negative quantity accepted")
assert receipts == [36]

Sıra sizde

Son assert neyi kanıtlar, neleri test etmeden bırakır?





Örnek çözümü göster

Reddedilen negatif miktar denemesinin receipts listesine yeni tutar eklemediğini kanıtlar. Gerçek e-postanın ulaştığını, yeniden denemelerde korunduğunu veya ağ hatasında yalnızca bir kez gönderildiğini kanıtlamaz. Bunlar ayrı entegrasyon ve teslimat gereklilikleridir.



Tek bir başarılı hesap testini, gerçek dış servisin de çalıştığına kanıt saymak.



Değişikliğin geçmişi de incelenebilir olsun

Git, dosyaların anlık durumlarını kaydeder. Dal, geliştirip incelettiğiniz bir işi diğer çalışmalardan ayırır.

Çalışma klasöründe dosyaların o anki hali bulunur. Hazırlık alanı, sıradaki commit’e seçtiğiniz dosya sürümlerini tutar: git add bu seçimi yapar, git diff --staged seçilenleri gösterir. Yerel commit bu seçimi kaydeder. Seçtiğiniz dosyayı tekrar düzenlerseniz yeni halinin de kayda girmesi için yeniden git add kullanın.

Ekipte tipik akış: ana dal → çalışma dalı → odaklı commit → dalı paylaşma → pull request → inceleme → düzeltip yeniden kontrol → birleştirme. Paylaşmadan veya birleştirmeden önce ekibin kurallarını belirleyin. Aşağıdaki alıştırma yerel commit’lerde biter; commit, testlerin geçtiğini veya canlıya çıkıldığını söylemez.

Kaydetmeden önce neyi kaydettiğinize bakın

Atölye yolu: git-practice/ isteğe bağlı yerel Git alıştırması; demo/ kurup test edeceğiniz ve inceleyeceğiniz sepet; examples/test_item_price.py bağımsız test örneği; homework/ kendi incelemeniz için. Ödeve arşivin ana klasöründeki CURRENT-ASSIGNMENT-tr.txt ile başlayın. Demo ile ödevin indirim kurallarını ayrı tutun. Her örnekteki dosya bağlantıları ilgili materyali açar.

Atölyeyi indirip açın; terminali açılan ana klasörde başlatın. git-practice, cart.py, check_cart.py ve .gitignore içeren ayrı bir deneme klasörüdür; site deposu veya özgün demo değildir. Önce git --version komutunu kontrol edin. Your Name ve you@example.com yerine kendi commit kimliğinizi yazın; ayarlar yalnızca bu deneme deposuna uygulanır. İlk komutlar verilen başlangıç dosyalarını kaydeder.

Dalı açtıktan sonra cart.py içindeki calc adını calculate_item_price yapın; check_cart.py içindeki import’u ve iki çağrıyı da güncelleyin. İndirim davranışını değiştirmeyin. Ardından aşağıdaki ikinci komut grubuyla kontrol edip isim değişikliğini kaydedin. Windows’ta python3 check_cart.py yerine py check_cart.py kullanın. Beklenen kontrol sonucu, assert hatası olmadan sıfır çıkış kodudur.

cd git-practice
git init
git config user.name "Your Name"
git config user.email "you@example.com"
git add cart.py check_cart.py .gitignore
git diff --staged
git commit -m "chore: record cart practice baseline"
git switch -c refactor/cart-function-name


Sıra sizde

Bir sınır kontrolünü ve ilgisiz bir logoyu değiştirdiniz. Genellikle aynı commit’te mi olmalılar? Commit etmek, testlerin durumu hakkında ne söyler?



python3 check_cart.py
git diff
git add cart.py check_cart.py
git diff --staged
git commit -m "refactor: name cart calculation clearly"

Örnek çözümü göster

Farklı sorunları çözdükleri ve ayrı incelenip geri alınmaları gerekebileceği için genellikle ayırın. Commit, bir durumun kaydedildiğini söyler; testlerin geçtiğini söylemez. Gerçekten çalıştırdığınız kontrolleri ve sonuçlarını ayrıca belirtin.



Commit kaydı, uzak depoya push ve canlıya çıkışı aynı olay sanmak.



Pull request, kararın nedenini anlatsın

Pull request, bir değişikliği incelemeye sunar. Açıklaması, dosya farklarını çözülen probleme bağlar.

Neyin değiştiğini, eski davranışın neden sorun olduğunu ve yenisini nasıl kontrol ettiğinizi yazın. İnceleyen kişinin gereksinimi değişken isimlerinden çıkarması gerekmemeli. Özellikle değişiklik olduğundan geniş görünebiliyorsa önemli sınırları belirtin.

Açıklama, planlanan kontrol ile tamamlanmış kontrolü ayırmalı. Komutu çalıştırmadıysanız söyleyin. Ekran görüntüsü görsel değişikliği destekleyebilir ama tek başına hesabın veya sunucudaki davranışın doğruluğunu göstermez. İlgisiz temizlik kararın görülmesini zorlaştırıyorsa farkların dışında tutun.

Somut bir inceleme açıklaması

Bu varsayımsal miktar değişikliğinde eski çarpım negatif toplam döndürüyordu. Önerilen kural negatif miktarı reddedip pozitif ve sıfır miktarları koruyor. Aşağıdaki açıklama, henüz test sonucu iddia etmiyor; kontrolleri çalıştırınca gerçek sonuçlarla değiştirin.

Problem: Negative quantity currently produces a negative total.
Change: Raise ValueError for quantity < 0; preserve zero and positive results.
Scope: No currency or rounding changes.
Validation: Not run yet. Check positive, zero, and negative quantity.

Sıra sizde

Yukarıdaki miktar değişikliği için “Bir şeyleri düzelttim; çalışması lazım” yerine iki veya üç cümlelik pull request açıklaması yazın. Eski kod negatif toplam döndürüyordu; yeni kural negatif miktarda ValueError üretir. Pozitif/sıfır sonuçları ve yuvarlama korunuyor; henüz test çalıştırılmadı.





Örnek çözümü göster

Negatif miktarlar daha önce negatif sipariş toplamı üretiyordu. Bu değişiklik quantity < 0 için ValueError üretirken pozitif ve sıfır sonuçlarını, mevcut fiyat ve yuvarlama kurallarını korur. Henüz doğrulama çalıştırılmadı; planlanan kontroller pozitif, sıfır ve negatif miktarları kapsıyor.



Test bölümüne gözlenen sonuçlar yerine çalıştırmayı düşündüğünüz komutları yazmak.



Depoyu yeni gelen birinin kullanabileceği hale getirin

README, yeni bir katkıcının temiz bir kopyadan çalışan programa ve anlamlı kontrollere ulaşmasını sağlamalı.

Projenin ne yaptığını, ön koşulları, kurulumu, çalıştırmayı ve testleri açıklayın. Gerekli ayarları örnek değerlerle gösterin. Sırları örneklere, sürüm kontrolüne veya ekran görüntülerine koymayın. Klasör yapısı ancak gerçek sorumlulukların nerede bulunduğunu anlatıyorsa yararlıdır.

Yazdığınız adımları temiz bir ortamda deneyin. Sizin makinenizde önceden kurulmuş, belirtilmeyen bir bağımlılık sayesinde çalışan komut eksik belgelenmiştir. Yalnızca README.md ve requirements.txt dosyaları var diye deponun kullanıma hazır olduğunu söylemeyin.

Sepet atölyesini çalıştırın

Atölyenin sepet projesi demo/ ile devam edin. git-practice/ alıştırmasını yaptıysanız önce açılan arşivin ana klasörüne dönün; aşağıdaki cd demo komutu oradan başlar. Komutlar yalıtılmış ortam oluşturup ileride güçlendireceğimiz mevcut zayıf testi çalıştırır. Windows’ta py -m venv .venv kullanın; aşağıdaki POSIX Python yolları yerine .venv\Scripts\python yazın.

cd demo
python3 -m venv .venv
.venv/bin/python -m pip install -r requirements.txt
.venv/bin/python -m pytest -q

Sıra sizde

Ekip arkadaşınız pytest’i demo/.venv içine kurdu; fakat demo içinden sistem yorumlayıcısıyla python3 -m pytest -q çalıştırınca “No module named pytest” görüyor. Sonraki denemede hangi komutu kullanırsınız, neden?





Örnek çözümü göster

demo içinden .venv/bin/python -m pytest -q çalıştırın; Windows’ta .venv\Scripts\python -m pytest -q kullanın. Bu komut sistem yorumlayıcısı yerine pytest’in kurulduğu ortamı seçer. Orada da pytest yoksa aynı ortamın Python’uyla requirements.txt bağımlılıklarını kurup yeniden deneyin; genel kurulum gerekmez.



Komutların hangi klasörde ve hangi Python ortamında çalışacağını söylememek.



Test, yanlış çıkabilecek bir sonucu kontrol etsin

Yararlı test belirli bir davranışı kontrol eder. Toplam pozitif demek, indirim hesabını doğrulamaya yetmez.

Atölyenin demo testi yalnızca sonucun sıfırdan büyük olduğunu kontrol ediyor. Birçok yanlış toplam da bu testi geçer. Fiyatı 100 olan kitaba %10 indirim uygulanıyorsa beklenen fiyat 90’dır; indirimin unutulmasını veya yanlış uygulanmasını gösterecek sonucu kontrol edin.

pytest, test dosyalarındaki test_ ile başlayan fonksiyonları bulur ve başarısız assert satırlarını bildirir. Testin adına kontrol ettiği davranışı yazın. Kayan noktalı hesaplarda pytest.approx toleranslı karşılaştırma yapar; toleransı ihtiyaca göre seçin. Buradaki öğretim örnekleri float kullanır; canlı bir ödeme sisteminin para gösterimini tanımlamaz.

İndirimli ve indirimsiz yolu test edin

Önceki kurulumu yaptığınız demo klasöründen devam edin. Arşivde bu bağımsız örnek ../examples/test_item_price.py olarak zaten bulunuyor. .venv/bin/python -m pytest -q ../examples/test_item_price.py komutunu çalıştırın; Windows’ta .venv\Scripts\python -m pytest -q ../examples/test_item_price.py kullanın. Kodu kendiniz yazacaksanız demo/test_item_price.py olarak kaydedip demo klasöründen .venv/bin/python -m pytest -q test_item_price.py çalıştırın.

Tek başına anlaşılması için hesap da örneğe dahil. Atölyedeki gerçek uygulamayı test ederken fonksiyonu testin içine kopyalamak yerine src.cart_improved içinden calculate_item_price import edin.

import pytest

def calculate_item_price(item):
    if item["type"] == "book":
        return item["price"] * 0.90
    return item["price"]

def test_book_gets_ten_percent_discount():
    assert calculate_item_price({"type": "book", "price": 100}) == pytest.approx(90)

def test_other_item_keeps_its_price():
    assert calculate_item_price({"type": "other", "price": 100}) == pytest.approx(100)

Sıra sizde

Kitap çarpanı yanlışlıkla 0.90 yerine 0.95 olursa hangi kontrol yakalar? total > 0 bunu yakalar mı?





Örnek çözümü göster

Yaklaşık 90 bekleyen test, 95 sonucunu yakalar. Pozitif toplam kontrolü ikisini de kabul ettiği için yanlış oranı kaçırır. Diğer ürün testi ise kitap kuralının bütün ürünlere uygulanmadığını kontrol eder.



Beklenen sonucu, test edilen fonksiyonu yeniden çağırarak üretmek.



Testi bir gerekçe için seçin, yüzde için değil

Kapsama raporu hangi kodun çalıştığını gösterir. Testin doğru sonucu kontrol ettiğini söylemez.

Bir test bütün satırları çalıştırabilir ama zayıf bir assert yüzünden hatayı kaçırabilir. Kapsamayı çalıştırılmayan yerleri bulmak için kullanın; ardından hangi önemli sonuçların henüz kontrol edilmediğini sorun. Her proje için %80 gibi bir hedef koymak, indirim kuralının veya geçersiz girdinin yeterince test edildiğini söylemez.

Testi, tanımlı davranıştan ve olası hatalardan çıkarın. Parantez kontrolünde doğru iç içe geçme, tür uyuşmazlığı, erken kapanış ve sonda kalan açılış; sepette boş girdi, kitap ve diğer ürünler, indirim seçenekleri ve premium üyelik kontrol edilebilir. Desteklenmeyen bir girdi türü için önce gereksinimi belirlemeden davranış uydurmayın.

Her örneği yakalayacağı hataya bağlayın

Demoda kitap indirimi, isteğe bağlı genel indirim ve isteğe bağlı premium indirimi uygulanır. Her birini tek başına, en az bir birleşimi de birlikte test edin: bir yardımcı atlanabilir, yanlış oran kullanabilir veya yanlış kullanıcıya uygulanabilir. Bu hesapta 0.90 ve 0.95 çarpanlarının yerini değiştirmek matematiksel sonucu değiştirmez.



Sıra sizde

Demoda kitaplara %10, ardından istenirse ara toplama %10 ve premium kullanıcıya %5 indirim uygulanır. %100 satır kapsamı var ama tek kontrol total > 0. Bu yeterli mi? Her birinin girdisi/seçenekleri ve beklenen tutarı belli olan iki güçlü kontrol önerin; düz yazıyla belirtebilirsiniz.





Örnek çözümü göster

Hayır: pozitif ama yanlış tutar da geçer. Kontrol 1: fiyatı 100 olan tek kitap, genel indirim ve premium üyelik olmadan 90 tutmalı. Kontrol 2: aynı kitapta genel indirim açık ve kullanıcı premium ise 76.95 olmalı: 100 × 0.90 × 0.90 × 0.95. Float sonuçlarını uygun toleransla karşılaştırın. İlk kontrol eksik kitap indirimini, ikincisi atlanan veya yanlış ek indirimi yakalayabilir.



Kapsama yüzdesini doğruluk kanıtı saymak veya yalnızca hedefi tutturmak için anlamsız test istemek.



Kontrolü otomatikleştirin, sonucunu da uygulayın

Sürekli entegrasyon, değişikliklerde tekrarlanabilir kontroller çalıştırır. Başarısız kontrolün birleştirmeyi engelleyip engellemediğini depo kuralları belirler.

Ekip; testleri, biçim kontrolünü, linter’ı ve derlemeyi her pull request için otomatik çalıştırabilir. Projeye yararlı geri bildirim veren kontrollerle başlayın. Biçimlendirici düzeni, linter ise tanımlı şüpheli kod kalıplarını kontrol eder; ikisi de uygulamanın davranış testlerinin yerini tutmaz.

Bir CI akışının olması, başarısız kodun birleştirilemeyeceğini garanti etmez. Zorunlu kontrolleri ve uygun dal korumalarını veya kural kümelerini ayarlayın. Kimlerin bu kuralları aşabildiğine de bakın. Yeşil işaret yalnızca ayarlanmış kontrollerin geçtiğini söyler; test edilmeyen bir gereksinim hâlâ yanlış olabilir.

Yereldeki komut CI ortamında da tekrarlanabilsin

Sepet atölyesinde, belgelenen bağımlılıklar kurulmuşken aynı pytest komutunu hem yerelde hem temiz bir CI ortamında çalıştırın. Hata varsa çıktısını koruyup nedenini düzeltin. Hatayı susturmak veya testi koşulsuz başarılı yapmak korumayı ortadan kaldırır.



Sıra sizde

CI testi başarısız ama birleştirme düğmesi hâlâ kullanılabiliyor. Birbirinden ayrı hangi iki şeyi araştırırsınız?





Örnek çözümü göster

Önce başarısız testi tekrar üretip sorunun kodda mı, testte mi, ortamda mı olduğunu araştırın. Ayrı olarak depo kurallarına bakın: bu kontrol zorunlu mu, mevcut kişi onu atlayabiliyor mu? Birleştirme kuralını düzeltmek, test hatasını düzeltmez.



Hangi kontrollerin zorunlu olduğunu görmeden CI bütün hatalı birleştirmeleri engelliyor demek.



İnceleme yorumu kanıtı ve etkisini içersin

Somut bir hata bulun, nasıl ortaya çıktığını gösterin ve yazana uygulanabilir bir sonraki adım verin.

Gereksinimden ve değişen davranıştan başlayın. Yalnızca değiştirilen fonksiyonu değil, onu çağıran kodu da okuyun. Doğruluğu, okunabilirliği, hata davranışını, testleri ve kapsamı inceleyin. Kodu kendinizin farklı yazacak olmasından önce, tekrar üretilebilen hataya öncelik verin.

Yararlı yorum, gözlemi sonucuna bağlar: kullanıcı yoksa find_email None döndürüyor; normalized_email ise hemen lower çağırıyor. Böylece eksik kullanıcı AttributeError üretiyor. Bulunamama durumunun ele alınmasını ve bu yol için test eklenmesini önerin. Her aramada mutlaka exception istemeyin; arayüzün hangi sonucu vaat etmesi gerektiğine karar verin.

Dönen değeri çağıran koda kadar izleyin

Bilerek hatalı bırakılan örnekte çağıran kod da var; böylece hata görülebiliyor. Aramanın None döndürmesi kendi başına yanlış değil; iki fonksiyonun bu durumu ele almadan birlikte kullanılması sorun. Yalnızca mevcut bir kullanıcıyla yapılan test bunu göstermez.

def find_email(users, user_id):
    return users.get(user_id)

def normalized_email(users, user_id):
    return find_email(users, user_id).lower()

assert normalized_email({1: "A@EXAMPLE.COM"}, 1) == "a@example.com"
# Intentionally faulty: normalized_email({}, 1) raises AttributeError.

Sıra sizde

normalized_email({}, 1) için hatayı ve çağırana etkisini belirten bir inceleme yorumu yazın. Düzeltmek veya görünür kılmak için somut bir sonraki adım önerin.





Örnek çözümü göster

“users={} ve user_id=1 olduğunda find_email None döndürüyor. normalized_email, None üzerinde .lower() çağırıp AttributeError üretiyor; eksik kullanıcı bu yolu çökertiyor. Eksik kullanıcı sonucunu belirleyip .lower() öncesinde ele alabilir miyiz; örneğin belgelenmiş None döndürelim?” Bu eksik kullanıcı çağrısını yeniden üreten bir test de yararlı bir sonraki adımdır.



Hatalı girdiyi, etkisini veya uygulanabilir öneriyi söylemeden hata yönetimi kötü yazmak.



İncelemeyi kod üzerine kurun

İnceleme, değişiklik hakkında bir konuşmadır; yazanla inceleyen arasında bir yarış değildir.

Birleştirmeyi durdurması gereken hataları önerilerden ayırın. Desteklenen girdide tekrar üretilebilen çökme çözülmeli. Kişisel isim tercihi ise isteğe bağlı olabilir. Yazar öncelik verebilsin diye nedenini ve önemini söyleyin. Sorular konuşmayı açabilir ama bilinen bir hatayı doğrudan açıklamak da uygundur.

Yazan olarak uygulamanızı savunmadan önce kaygıyı anlayın. Düzeltin, mevcut yaklaşımın gereksinimi neden karşıladığını açıklayın veya netleştirme isteyin. Kodu değiştirdikten sonra neyin değiştiğini ve neyi kontrol ettiğinizi söyleyin. Anlaşamıyorsanız seçenekleri ve kanıtı karşılaştırın; onay, tartışmayı kazanma ödülü değildir.

Yararlı bir konuşma

İnceleyen: Birleştirmeden önce çözülmeli: normalized_email, eksik kullanıcıda AttributeError üretiyor; desteklenen bu durumu ele alıp test ekleyelim. Yazan: Katılıyorum. Eksik kullanıcı için artık None döndürüyorum ve bu yol için test ekledim. Arama testlerini çalıştırdım; geçti. Son cümle ancak gerçekten çalıştırdıktan sonra söylenmeli.



Sıra sizde

İnceleyen, kendi tercihi olduğu için current adını root yapmanızı istiyor. current özyinelemeli parametreyi doğru anlatıyorsa nasıl yanıtlarsınız?





Örnek çözümü göster

“current adını kullandım çünkü bu parametre her özyinelemeli çağrıda incelenen düğümü gösteriyor; her zaman ilk ağacın kökü değil. Burada root adını daha uygun kılan bir ekip kuralı veya somut belirsizlik var mı? Yerleşmiş kurala uyabilirim; yoksa değişen çağrıları anlatmak için current adını korumayı öneriyorum.”



Kişisel stil yüzünden doğru değişikliği engellemek veya gerçek hatayı stil tercihi diye geçiştirmek.



AI ile, anladığınız çözümü zorlayın

AI test veya inceleme bulgusu önerebilir. Gereksinime hangisinin uyduğuna karar vermek ve ortaya çıkan kodu doğrulamak yine sizin işiniz.

Fonksiyonu, gerekiyorsa çağıran kodu, desteklenen girdileri ve korunacak davranışı verin. Odaklı çıktı isteyin: karşı örnekler, eksik testler veya küçük bir yeniden düzenleme. Her şeyi iyileştir gibi belirsiz istekler ilgisiz değişiklikleri teşvik eder ve cevabı kontrol etmeyi zorlaştırır.

Üretilen testteki assert satırlarını da uygulama kadar dikkatli okuyun. Model bir politika uydurabilir, aynı zayıf kontrolü tekrarlayabilir veya çalıştırmadığı kodu kendinden emin açıklayabilir. İsteme sır veya gereksiz kişisel veri koymayın. AI incelemesini araştırılacak başka bir öneri kaynağı olarak kullanın; testin ve değişiklik sorumluluğunun yerine geçmez.

Gerçek bir sınıra bağlı istek

Kum saati yardımcısında hücrelerin negatif olabileceğini, matrisin dikdörtgen ve en az 3 × 3 olduğunu açıkça söyleyin. Böylece önerilen sıfır başlangıcının veya boş matris kuralının probleme uyup uymadığını değerlendirebilirsiniz. Modelden elle yürütülen düşünce ile gerçek çalıştırmayı ayırmasını isteyin.

Türkçe kullanabileceğiniz istek: max_hourglass_sum fonksiyonunu şu kurallarla incele: Matris dikdörtgen, en az 3 × 3 ve tam sayı içeriyor; negatif değerler geçerli. Tek bir kum saatinin en büyük toplamını döndürmeli. Her hata iddian için karşı örnek ve odaklı test öner. Elle akıl yürütme ile gerçekten çalıştırılan sonuçları ayır; girdi kurallarını değiştirme.

Review max_hourglass_sum for this contract:
- Rectangular integer grid, at least 3 rows and 3 columns.
- Negative values are allowed.
- Return the largest SINGLE seven-cell hourglass sum.
Give a counterexample for each correctness finding.
Suggest focused tests; distinguish hand reasoning from executed results.
Do not redesign the input contract.

Sıra sizde

AI, tamamen negatif bir matris için başlangıç maksimumunu max(0, candidate) yapmayı öneriyor. Nasıl kontrol edip yanıt verirsiniz?





Örnek çözümü göster

“Bütün hücreleri -1 olan 3 × 3 matriste tek kum saati yedi tane -1 içerir; toplamı -7’dir. max(0, -7) sonucu 0 olur; önerilen başlangıç hiçbir kum saatine ait olmayan değeri döndürür. Başlangıcı ilk geçerli adaydan alalım. Bu karşı örneği elle izledim; kodu çalıştırmadım.”



Akıcı bir açıklamayı, üretilen kodun çalıştırıldığına veya gereksinimi karşıladığına kanıt saymak.



Atölye: sepet kodunu inceleyin

Alışkanlıkları birlikte uygulayın: sepet kodunu inceleyin, beklenen tutarı hesaplayın ve yararlı inceleme yorumları yazın.

Atölyeyi indirip demo/src/cart.py dosyasını açın. calc; items, user ve d adlı bir seçenek alır. Kitap indirimini, isteğe bağlı genel indirimi, sonra premium indirimini uygular. process_cart ayrıca mesaj yazdırır. cart_improved.py ile karşılaştırın ama referansı okumadan önce kendi gözlemlerinizi yazın.

Yapıyı iyileştirirken belirtilen indirim politikasını koruyun. Anlamlı isimler ve yardımcı fonksiyonlar yapısal değişikliktir. Yeni girdi kontrolü veya başka bir yuvarlama kuralı ayrı gereksinim ve test ister. Eski referans karşılaştırma için yararlıdır; eksiksiz bir canlı ödeme sistemi değildir.

Testi incelemeden önce beklenen sonucu hesaplayın

Fiyatı 100 olan kitap ve fiyatı 50 olan başka bir ürün için kitap kuralı 90 + 50 = 140 verir. Genel indirim açıksa 140 × 0.90 = 126 olur. Kullanıcı premium ise 126 × 0.95 = 119.70 elde edilir. Mevcut > 0 kontrolü bu sonucu birçok yanlış toplamdan ayıramaz.

Bir doğruluk veya test yorumu, bir de okunabilirlik veya tasarım yorumu yazın. Ardından eski testleri çalıştırın, beklenen sonuç kontrolünü güçlendirin ve uygulamayı bağımsız hesapladığınız sonuçla doğrulayın.

Book: 100 × 0.90 = 90
Other item: 50
Subtotal: 140
General discount: 140 × 0.90 = 126
Premium discount: 126 × 0.95 = 119.70

Sıra sizde

Mevcut demo/tests/test_cart.py testi fiyatı 100 olan tek kitap, premium kullanıcı ve genel indirim=True kullanıyor; fakat yalnızca calc(...) > 0 arıyor. Demo için bir test/assert yorumu ve bir isimlendirme/sorumluluk yorumu yazın. Hangisi yanlış premium oranını yakalayabilir?





Örnek çözümü göster

Test yorumu: “demo/tests/test_cart.py içindeki test_calc, bu premium siparişte her pozitif sonucu kabul ediyor. Mevcut tek kitap girdisinde yaklaşık 76.95 bekleyelim: 100 × 0.90 × 0.90 × 0.95. Bu kontrol yanlış premium oranını yakalayabilir; > 0 yakalayamaz.”

İsim yorumu: “demo/src/cart.py içindeki calc fonksiyonunun d seçeneği amacını açıklamıyor. Adını discount_enabled yapıp kullanımlarını güncelleyelim; böylece çağıranlar genel indirimi açtığını görebilir.” Bu okunabilirliği iyileştirir; isim değişikliği premium hesabını doğrulamaz.



Eski zayıf testin referansı veya kendi düzenlemenizi tamamen doğruladığını söylemek.



Sonunda uygulanabilir bir inceleme bırakın

Ödev klasöründe kendi incelemenizi yazın, doğrulayın ve açıklayın. Amaç yüzeysel yorum sayısını doldurmak değil, yararlı bulgu üretmek.

homework/src/orders.py dosyasını ve testlerini açın. Kitapta %10, VIP için ek %5 indirim var; demodaki isteğe bağlı genel indirim burada yok. Fiyatı 100 olan kitap VIP olmadan 90, VIP ile 85.50 tutmalı. Arşivdeki eski ASSIGNMENT.md kaynak olarak korunuyor; onun yorum sayısı kotaları bu sürüm için geçerli değil. Açılan ana klasördeki CURRENT-ASSIGNMENT-tr.txt yönergesini izleyin.

Dosyayı ve konumu, gözlediğiniz sorunu, neden önemli olduğunu ve somut öneriyi kaydedin. En az bir bağımsız hesaplanmış test beklentisi, bir isimlendirme veya sorumluluk iyileştirmesi ve gerçekten kontrol ettiğiniz bir kurulum ya da belge gözlemi ekleyin. Hataları isteğe bağlı iyileştirmelerden ayırın; emin olmadığınız şeyi kesin bulgu gibi sunmayın.

Bitirmeden ilgili kontrolleri çalıştırıp son farkları inceleyin. Neyi çalıştırdığınızı, neyin geçtiğini veya başarısız olduğunu ve nelerin doğrulanmadığını söyleyin. Dersin alışkanlığı uygulanabilir: düşüncenizi görünür, önemli davranışı kontrol edilebilir hale getirin; sizden sonrakinin işini kolaylaştırın.

Nasıl düşündüğünüzü gösteren teslim

İnceleme notlarını, yaptıysanız odaklı düzeltmeyi ve gözlenen test sonuçlarını teslim edin. Mevcut kontrol calc(items, False) > 0: VIP olmayan siparişi çalıştırır ama doğru tutar olan 90’ı aramaz. VIP=True durumunu hiç çağırmaz. İyi bir yorum, mevcut test VIP’yi denemiş gibi konuşmak yerine VIP olmayan duruma 90, ayrı VIP durumuna 85.50 bekleyen kontrol ister.



Sıra sizde

Ödev için son bir inceleme bulgusu yazın: konum, kanıt, etki ve önerilen kontrol olsun. Çalıştırmadıysanız bunu söyleyin.





Örnek çözümü göster

“homework/tests/test_orders.py içindeki test_calc, fiyatı 100 olan kitap için calc(items, False) çağırıyor ama yalnızca > 0 arıyor. Yanlış pozitif tutarlar geçebilir; ayrıca VIP=True hiç denenmiyor. Mevcut VIP olmayan çağrıda yaklaşık 90, ayrı bir VIP=True kontrolünde 85.50 bekleyelim. Bunlar önerilen kontroller; henüz çalıştırmadım.”



Demodaki ek genel indirimi ödeve taşımak veya çalıştırılmamış kontroller geçti demek.