Ders 5'in hedefi

Ders 5'in hedefi: transcript.txt'den AGNO'ya Soldan sağa üç parça, aralarında iki ok. Solda transcript.txt dosyası, altı satır (str, yeşil): MAT123;4;C1, FIZ127;3;B2, BBM101;3;F3, TKD103;2;A2, BBM101;3;A3, BBM102;3;. BBM101 iki kez geçiyor, BBM102'nin harf notu yok. Ortada latest_grade ismi (lacivert) beş satırlık bir dict'i (kahverengi) gösteriyor. Key'ler ders kodları (str, yeşil), value'lar kredi ve harf notundan oluşan tuple'lar (mavi-gri): "MAT123" ile (4, "C1"), "FIZ127" ile (3, "B2"), "BBM101" ile (3, "A3"), yani son not, "TKD103" ile (2, "A2"), "BBM102" ile (3, None); None bej. Sağda çıktı AGNO: 3.08, açık mavi bant ve çivit mavisi çerçeve içinde; altında 37 ağırlıklı puan / 12 kredi. MAT123;4;C1 FIZ127;3;B2 BBM101;3;F3 TKD103;2;A2 BBM101;3;A3 BBM102;3; transcript.txt latest_grade "MAT123" (4, "C1") "FIZ127" (3, "B2") "BBM101" (3, "A3") "TKD103" (2, "A2") "BBM102" (3, None) dict Çıktı AGNO: 3.08 37 ağırlıklı puan / 12 kredi
Bu dersin sonunda transkriptinizi bir file'dan okuyup AGNO'yu hesaplayacaksınız.

Ders 5'in hedef programı

Ders 5'in hedef programı: transcript.txt ve Run penceresi Solda transcript.txt dosyası, altı satır (str, yeşil): MAT123;4;C1, FIZ127;3;B2, BBM101;3;F3, TKD103;2;A2, BBM101;3;A3, BBM102;3;. İki BBM101 satırı çivit mavisi çerçeveli; altında BBM101 iki kez yazıyor (F3 ve A3). BBM102 satırında harf notu yok; yanında notu yok yazıyor. Sağda Run penceresi, yedi satır: 5 ders, 1 devam ediyor, 4 bölüm, AGNO: 3.08 (açık mavi bant ve çivit mavisi çerçeveyle vurgulu); MAT123 4 C1 True; FIZ127 3 B2 True; BBM101 3 A3 True (yanında son not); TKD103 2 A2 True; BBM102 3 devam ediyor; AGNO: 3.08. Varsayılan durumda (dersin başı) Run penceresinin sağ üstünde Önizleme etiketi var. final durumunda (finaldeki canlı kurulum) bu etiket gizli, yeri boş kalır; resmin geri kalanı aynıdır. MAT123;4;C1 FIZ127;3;B2 BBM101;3;F3 TKD103;2;A2 BBM101;3;A3 BBM102;3; notu yok transcript.txt BBM101 iki kez Run penceresi Önizleme 5 ders, 1 devam ediyor, 4 bölüm, AGNO: 3.08 MAT123 4 C1 True FIZ127 3 B2 True BBM101 3 A3 True son not TKD103 2 A2 True BBM102 3 devam ediyor AGNO: 3.08

Python ne yazdırır?


def average(a, b):
    return (a + b) / 2

x = average(3, 4)
print(x + 1)
      
  1. 4.5
  2. 4
  3. 3.5 4.5
  4. TypeError

5A konuları

  1. 1. Local variable ve scopeframe, NameError, Step Into
  2. 2. None, print ve returnNone, is None, return
  3. 3. dict{key: value}, GRADE_POINTS, get()
  4. 4. dict üzerinde for, items() ve saymacounts.get(g, 0) + 1
  5. 5. setset(), add(), &, -, |

1. Local variable ve scope

Function'ın kendi isimleri ve yaşadıkları yer.

Local variable (yerel değişken)

Local variable: solve() call'unun frame'i Durum film: Film şeridi, üç kare. Solda kod: def solve(): # 1, girintili local = 5, girintili print("içeride", local), boş satır, solve() # 2, print(local) # 3; altında Çıktı: içeride 5. Kare 1, # 1 satırından sonra: Global frame'de lacivert solve etiketi bir function kutusunu gösteriyor; function kutusu açık mavi, çivit mavisi çerçeveyle vurgulu (yeni). Kare 2, call sürerken: Global frame aynı, altında solve frame'i açık, başlığının altı çivit mavisi çizgili; içinde local etiketi 5'i (int, turuncu) gösteriyor; 5 açık mavi bantla vurgulu. Kare 3, # 3 satırı çalışırken: solve frame'i kapanmış, yerinde gri kesik çerçeve ve kapandı; print(local) satırında local kırmızı kesik halkayla işaretli, altında kırmızı NameError. Alt satırda: Kare n: # n satırı çalıştıktan sonra (2: call sürerken); lejant: düz ok şu anki bağ, çivit mavisi çerçeveli açık mavi kutu bu adımda değişen. Durum scope: Kare 1 gizli; kare 2 ve 3 geniş, yan yana. Kare 2'nin üstünde scope: solve'un gövdesi; solve frame'inde local 5'i (int, turuncu) gösteriyor, 5 vurgulu. Kare 3'ün üstünde scope: dosyanın geri kalanı; frame kapanmış, print(local) kırmızı NameError veriyor. def solve(): # 1 local = 5 print("içeride", local) solve() # 2 print(local) # 3 Çıktı içeride 5 1 Global frame solve function 2 Global frame solve function solve local 5 3 Global frame solve function kapandı print(local) NameError 2 Global frame solve function solve local 5 3 Global frame solve function kapandı print(local) NameError scope: solve'un gövdesi scope: dosyanın geri kalanı Kare n: # n satırı çalıştıktan sonra (2: call sürerken) şu anki bağ bu adımda değişen
Function içindeki isim yalnızca call sürerken vardır.

Müsvedde kağıdı

Local variable müsvedde kağıdı gibi Elle çizilmiş gibi basit bir resim. Solda sınav sırasında bir öğrenci var; bir elinde üzerinde return value yazan cevap kağıdını havaya kaldırmış. Sağda bir gözetmen önünde turuncu bir kutu tutuyor; kutudan üzerinde local = 5 yazan bir müsvedde kağıdı çıkıyor. Gözetmenin konuşma balonunda "Müsveddeler bende kalır." yazıyor. Altta kırmızıyla print(local) → NameError yazıyor. return value local = 5 Müsveddelerbende kalır. print(local) → NameError

Local variable sınavdaki müsvedde kağıdı gibidir: call bitince toplanır, dışarı çıkmaz.

solve() adım adım

NameError ve local variable


def solve():
    local = 5

solve()
print(local)

Function'da oluşan isim dışarıda yoktur; değeri dışarı return ile çıkar.

Çıktı
Traceback (most recent call last):  File "…/python-kurs/example.py", line 5, in <module>    print(local)          ^^^^^NameError: name 'local' is not defined. Did you mean: 'locals'?

Scope (kapsam)

Local variable: solve() call'unun frame'i Durum film: Film şeridi, üç kare. Solda kod: def solve(): # 1, girintili local = 5, girintili print("içeride", local), boş satır, solve() # 2, print(local) # 3; altında Çıktı: içeride 5. Kare 1, # 1 satırından sonra: Global frame'de lacivert solve etiketi bir function kutusunu gösteriyor; function kutusu açık mavi, çivit mavisi çerçeveyle vurgulu (yeni). Kare 2, call sürerken: Global frame aynı, altında solve frame'i açık, başlığının altı çivit mavisi çizgili; içinde local etiketi 5'i (int, turuncu) gösteriyor; 5 açık mavi bantla vurgulu. Kare 3, # 3 satırı çalışırken: solve frame'i kapanmış, yerinde gri kesik çerçeve ve kapandı; print(local) satırında local kırmızı kesik halkayla işaretli, altında kırmızı NameError. Alt satırda: Kare n: # n satırı çalıştıktan sonra (2: call sürerken); lejant: düz ok şu anki bağ, çivit mavisi çerçeveli açık mavi kutu bu adımda değişen. Durum scope: Kare 1 gizli; kare 2 ve 3 geniş, yan yana. Kare 2'nin üstünde scope: solve'un gövdesi; solve frame'inde local 5'i (int, turuncu) gösteriyor, 5 vurgulu. Kare 3'ün üstünde scope: dosyanın geri kalanı; frame kapanmış, print(local) kırmızı NameError veriyor. def solve(): # 1 local = 5 print("içeride", local) solve() # 2 print(local) # 3 Çıktı içeride 5 1 Global frame solve function 2 Global frame solve function solve local 5 3 Global frame solve function kapandı print(local) NameError 2 Global frame solve function solve local 5 3 Global frame solve function kapandı print(local) NameError scope: solve'un gövdesi scope: dosyanın geri kalanı Kare n: # n satırı çalıştıktan sonra (2: call sürerken) şu anki bağ bu adımda değişen
Bir ismin kullanılabildiği yere o ismin scope'u denir.

Local variable (2)

Her call boş bir frame ile başlar Solda kod: def count_once():, girintili count = 0, count += 1, return count, boş satır, print(count_once(), count_once()). Sağda iki ayrı count_once frame'i, 1. call ve 2. call. Her birinde lacivert count etiketinden gri kesik ok eski 0'a (gri), düz ok 1'e (int, turuncu) gidiyor. Her frame'in altından petrol mavisi return oku 1'e (int, turuncu) iniyor. İkinci frame'in başlığı açık mavi, çivit mavisi çerçeveli bantla vurgulu; altında yeniden 0'dan başladı. Çıktı: 1 1. def count_once(): count = 0 count += 1 return count print(count_once(), count_once()) count_once 1. call count 0 1 return 1 int count_once 2. call count 0 1 return 1 int yeniden 0'dan başladı Çıktı 1 1
Her call boş bir frame ile başlar; önceki call'dan hiçbir şey kalmaz.

Function içinde ve dışında x

Function içinde ve dışında x Solda kod: x = 1, boş satır, def change_x():, girintili x = 99, girintili print("içeride", x), boş satır, change_x(), print("dışarıda", x). Sağda call sürerken iki frame. Global frame'de x etiketi 1'i (int, turuncu), change_x etiketi bir function kutusunu gösteriyor. Altındaki change_x frame'inde ayrı bir x etiketi 99'u (int, turuncu) gösteriyor; 99 açık mavi, çivit mavisi çerçeveli bantla vurgulu. Altta: aynı yazılış, iki ayrı isim. Çıktı: içeride 99, dışarıda 1. x = 1 def change_x(): x = 99 print("içeride", x) change_x() print("dışarıda", x) Global frame x 1 int change_x function change_x call sürerken x 99 int aynı yazılış, iki ayrı isim Çıktı içeride 99 dışarıda 1
Function içindeki x, dışarıdaki x'ten ayrı bir isimdir.

Parameter ve scope

Parameter da local'dir Solda kod: def add_one(credits):, girintili credits = credits + 1, girintili return credits, boş satır, n = 3, result = add_one(n), print(n, result). Sağda 2. satır çalıştıktan sonraki resim. Global frame'de add_one etiketi bir function kutusunu, n etiketi 3'ü (int, turuncu) gösteriyor. add_one frame'inde credits etiketinden gri kesik bir ok aynı 3'e (önceki bağ), düz bir ok yeni 4'e (int, turuncu) gidiyor; 4 açık mavi, çivit mavisi çerçeveli bantla vurgulu. Altta: n hala 3'ü gösterir. Çıktı: 3 4. def add_one(credits): credits = credits + 1 return credits n = 3 result = add_one(n) print(n, result) Global frame add_one function n 3 int add_one credits 4 int n hala 3'ü gösterir Çıktı 3 4
Parameter da local'dir; değiştirmek, dışarıdaki int'i değiştirmez.

add_one() adım adım

Bauer, Samelson ve stack (1957)

Friedrich L. Bauer 1995'te bir toplantıda konuşurken: gözlüklü, koyu takım elbiseli; sağ eli havada, sol eli başında.
Fotoğraf: Rolf Kickuth. “FriedrichLBauer29-05-1995”, Wikimedia Commons, CC BY-SA 4.0.

Call'ların frame'leri üst üste bir stack'te durur; fikir Bauer ve Samelson'dan.

Step Into ve Frames

PyCharm Debug: Step Into ve Frames PyCharm Debug penceresinin çizimi. Üstte üç tuş: F8 Step Over, F7 Step Into (açık mavi, çivit mavisi çerçeveyle vurgulu), Shift+F8 Step Out. Frames listesinde seçili satır weighted_points, altında <module>. Variables bölümünde lacivert etiketler: credits 4'ü (int, turuncu), grade_point 2.5'i (float, hardal sarısı), points 10.0'ı (float, hardal sarısı) gösteriyor. Altta: en üstteki frame, şu an çalışan call. F8 Step Over F7 Step Into Shift+F8 Step Out Frames weighted_points <module> Variables credits 4 int grade_point 2.5 float points 10.0 float en üstteki frame, şu an çalışan call

F7 (Step Into) call'un içine girer; Frames listesi açık frame'leri gösterir.

2. None, print ve return

Bilinmeyen bir değeri tutmak.

Bilinmeyen piyasa değeri

Erling Haaland yağmur altında, Norveç milli takımının kırmızı, beyaz ve lacivert çizgili 9 numaralı formasıyla ellerini çırpıyor.
Fotoğraf: MichaelEmilio, “Norway Italy - June 2025 E 07”, Wikimedia Commons, CC BY 4.0. Kırpıldı.

Haaland'ın piyasa değerini bilmiyoruz. 0 yazarsak hiç para etmiyor demiş oluruz.

None

None ve 0 İki satır. Üstte lacivert market_value etiketi None'ı (NoneType, bej) gösteriyor; None açık mavi, çivit mavisi çerçeveli bantla vurgulu; yanında bilinmiyor. Altta ikinci bir market_value etiketi 0'ı (int, turuncu) gösteriyor; yanında kırmızı değeri sıfır: hiç para etmiyor. En altta kod: market_value = None, print(market_value, type(market_value)); Çıktı: None <class 'NoneType'>. market_value None NoneType bilinmiyor market_value 0 int değeri sıfır: hiç para etmiyor market_value = None print(market_value, type(market_value)) Çıktı None <class 'NoneType'>
None, bir değerin bilinmediğini gösterir; 0 değildir.

Ertelenen maç

None ertelenen maçın skoru gibi Elle çizilmiş gibi basit bir resim. Yan yana iki skor tabelası var. Soldaki güneşin altında, turuncu ve 0 0 gösteriyor; altında "0: oynandı, gol yok" yazıyor. Sağdaki yağmur bulutunun altında, gri ve boş; üzerine elle yazılmış ERTELENDİ levhası asılmış, altında "None: oynanmadı" yazıyor. Ortada şemsiyeli bir saha görevlisi duruyor. 0 0 ERTELENDİ 0: oynandı, gol yok None: oynanmadı

None ertelenen maçın skoru gibidir; 0-0 ise oynanmış bir maçın skorudur.

NoneType

value
  1. Numbers(sayılar)

    1. Integral

      • int7
      • boolTrue
    2. Real

      • float3.5
  2. Sequences(diziler)

    1. Immutable

      • str"7"
      • rangerange(3)
      • tuple(3, 4)
    2. Mutable

      • list[1, 2]
  3. Set types(kümeler)

    • set5A
  4. Mappings

    • dict5A
  5. None

    • NoneTypeNone
bu derstedaha öncesonraki derslerde

is None


market_value = None
print(market_value is None)
print(market_value == 0)
Çıktı
True
False
None'ın iki kaynağı: is None ve return'süz function Durum one: İki panel; birincisi açık mavi, çivit mavisi çerçeveli bantla vurgulu. is None: lacivert market_value etiketi None'ı (NoneType, bej) gösteriyor; is None True, == 0 False (bool, deniz yeşili). İkinci panelin yeri boş (o konu birkaç slayt sonra geliyor). Durum two: İkinci panel vurgulu, return'süz function: greet() kutusundan petrol mavisi dönen oku None'a (NoneType, bej) gidiyor; lacivert s etiketi aynı None'ı gösteriyor; Çıktı: Afiyet olsun, None. Birinci panel gri. is None is None market_value None NoneType is None is None True == 0 == 0 False return'süz function return'süz function greet() greet() dönen dönen None NoneType s Çıktı Çıktı Afiyet olsun Afiyet olsun None None

None'ı is None ile kontrol ederiz.

is None ve if


market_value = None
if market_value is None:
    print("Değeri bilinmiyor")
Çıktı
Değeri bilinmiyor
is None ile if: market_value = None Akış şeması, market_value None iken. market_value = None kutusu (None bej), ardından market_value is None karar şekli. True kolu petrol mavisi, True (deniz yeşili) etiketli; print("Değeri bilinmiyor") kutusuna gidiyor, bu kutu açık mavi, çivit mavisi çerçeveyle vurgulu, oradan Çıktı: Değeri bilinmiyor. False kolu gri ve soluk, if'ten sonraki satıra gidiyor. market_value = None market_value is None True print("Değeri bilinmiyor") False if'ten sonraki satır Çıktı Değeri bilinmiyor

Bilinmeyen değer, hesaba girmeden önce if ile ayrılır.

TypeError ve None


market_value = None
print(150 + market_value)
Çıktı
Traceback (most recent call last):  File "…/python-kurs/example.py", line 2, in <module>    print(150 + market_value)          ~~~~^~~~~~~~~~~~~~TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

None ile hesap yapılamaz.

Tony Hoare ve null reference (1965, 2009)

Tony Hoare, 2011'de EPFL'deki bir konuşmada: beyaz saçlı ve sakallı, gözlüklü, açık renk ceketli.
Photograph by Rama, Wikimedia Commons, Cc-by-sa-2.0-fr (“Sir Tony Hoare IMG 5125”). Boyutu küçültüldü.

Hoare 1965'te null reference'ı ekledi; 2009'da ona "milyar dolarlık hatam" dedi.

return'süz function


def greet():
    print("Afiyet olsun")

s = greet()
print(s)
Çıktı
Afiyet olsun
None

return yazılmayan her function None döndürür.

None'ın iki kaynağı: is None ve return'süz function Durum one: İki panel; birincisi açık mavi, çivit mavisi çerçeveli bantla vurgulu. is None: lacivert market_value etiketi None'ı (NoneType, bej) gösteriyor; is None True, == 0 False (bool, deniz yeşili). İkinci panelin yeri boş (o konu birkaç slayt sonra geliyor). Durum two: İkinci panel vurgulu, return'süz function: greet() kutusundan petrol mavisi dönen oku None'a (NoneType, bej) gidiyor; lacivert s etiketi aynı None'ı gösteriyor; Çıktı: Afiyet olsun, None. Birinci panel gri. is None is None market_value None NoneType is None is None True == 0 == 0 False return'süz function return'süz function greet() greet() dönen dönen None NoneType s Çıktı Çıktı Afiyet olsun Afiyet olsun None None

Değiştiren method'lar ve None

Değiştiren method'lar None verir result durumu: solda kod grades = ["C1", "B2"], result = grades.append("A2"), print(grades, result); çıktı ['C1', 'B2', 'A2'] None. Sağda grades ismi (lacivert) C1, B2, A2'yi (str, yeşil) tutan list'i (vişneçürüğü), result ismi None değerini (NoneType, bej) gösteriyor; None açık mavi, çivit mavisi çerçeveli şeridin içinde. Altta: pop() ise çıkardığı item'ı verir. mistake durumu: kod grades = ["C1", "A2"], grades = grades.sort(), kırmızı çerçeveli grades.append("B1"). grades ismi artık None'ı (bej) gösteriyor, yeni ok açık mavi şeridin üzerinde; sıralanmış [A2, C1] list'i gri ve ona giden eski ok gri ve kesikli, yanında eski bağ; o list'i gösteren isim kalmadı. Altta kırmızı: AttributeError: 'NoneType' object has no attribute 'append'. grades None NoneType grades = ["C1", "B2"] result = grades.append("A2") print(grades, result) Çıktı ['C1', 'B2', 'A2'] None "C1" "B2" "A2" result pop() ise çıkardığı item'ı verir. grades = ["C1", "A2"] grades = grades.sort() grades.append("B1") "A2" "C1" eski bağ AttributeError: 'NoneType' object has no attribute 'append'
append() ve sort() return'süz function gibidir: list'i değiştirir, None döndürür.

Boş tepsi

Ürün düşürmeyen otomat Elle çizilmiş gibi basit bir resim. Solda mavi bir otomat var; üstündeki lacivert ekranda "Afiyet olsun" yazıyor ama alttaki ürün kapağı bomboş. Sağda bir öğrenci elinde gri bir kart tutuyor; kartta None yazıyor. Üstte s = greet() kodu var. s = greet() Afiyet olsun None

return'süz function, "Afiyet olsun" yazıp ürün düşürmeyen otomat gibidir: elde None kalır.

print ve return

print gösterir, return geri verir Durum flows: Solda kod: def print_square(x):, girintili print(x * x), boş satır, def square(x):, girintili return x * x, boş satır, print_square(4), result = square(4) + 1, print(result). Sağda iki akış. print: print_square(4) kutusundan çıkan ok 16'yı Ekran'a yazıyor; petrol mavisi dönen oku None'a (NoneType, bej) gidiyor. return: square(4) kutusundan petrol mavisi return oku 16'ya (int, turuncu), + 1 oku 17'ye (int, turuncu) gidiyor; lacivert result etiketi 17'yi gösteriyor; 17 açık mavi, çivit mavisi çerçeveli bantla vurgulu. Altta Çıktı: 16, 17. Durum error: Kod: def print_square(x):, girintili print(x * x), boş satır, total = print_square(4) + 1. Üst akışta None vurgulu; arkasındaki + 1 kırmızı çarpıyla kesilmiş, yanında kırmızı hesaplanamaz. Alt akış gri. Çıktı panelinde yalnızca 16; yanında ayrı, kırmızı bir kutuda traceback'in son satırı: TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'. def print_square(x): print(x * x) def square(x): return x * x print_square(4) result = square(4) + 1 print(result) def print_square(x): print(x * x) total = print_square(4) + 1 Çıktı 16 17 16 Traceback'in son satırı TypeError: unsupported operand type(s) for +: 'NoneType' and 'int' print print_square(4) Ekran 16 dönen + 1 hesaplanamaz None return return square(4) square(4) return return 16 + 1 + 1 17 result
print değeri ekrana yazar; return programa geri verir.

TypeError ve print

print gösterir, return geri verir Durum flows: Solda kod: def print_square(x):, girintili print(x * x), boş satır, def square(x):, girintili return x * x, boş satır, print_square(4), result = square(4) + 1, print(result). Sağda iki akış. print: print_square(4) kutusundan çıkan ok 16'yı Ekran'a yazıyor; petrol mavisi dönen oku None'a (NoneType, bej) gidiyor. return: square(4) kutusundan petrol mavisi return oku 16'ya (int, turuncu), + 1 oku 17'ye (int, turuncu) gidiyor; lacivert result etiketi 17'yi gösteriyor; 17 açık mavi, çivit mavisi çerçeveli bantla vurgulu. Altta Çıktı: 16, 17. Durum error: Kod: def print_square(x):, girintili print(x * x), boş satır, total = print_square(4) + 1. Üst akışta None vurgulu; arkasındaki + 1 kırmızı çarpıyla kesilmiş, yanında kırmızı hesaplanamaz. Alt akış gri. Çıktı panelinde yalnızca 16; yanında ayrı, kırmızı bir kutuda traceback'in son satırı: TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'. def print_square(x): print(x * x) def square(x): return x * x print_square(4) result = square(4) + 1 print(result) def print_square(x): print(x * x) total = print_square(4) + 1 Çıktı 16 17 16 Traceback'in son satırı TypeError: unsupported operand type(s) for +: 'NoneType' and 'int' print print_square(4) Ekran 16 dönen + 1 hesaplanamaz None return return square(4) square(4) return return 16 + 1 + 1 17 result
print eden function'ın sonucu None'dır; hesap yapılamaz.

print ve return (2)

Return value bir otomat gibi Elle çizilmiş gibi basit bir resim. Üstte weighted_points(4, 2.5) kodu yazıyor. Solda mavi bir otomat var. Turuncu 4 ve sarı 2.5 yazan iki para, bir okla para deliğine giriyor. Otomatın alttaki ürün kapağında sarı bir kutu içecek yatıyor ve üzerinde 10.0 yazıyor. Sağda bir öğrenci gülerek kapaktaki kutuyu gösteriyor. weighted_points(4, 2.5) 4 2.5 10.0

Function hesaplar ve return eder; ana program print eder.


def square(x):
    return x * x

print(square(4))
Çıktı
16

Devam eden ders

Devam eden ders: None atlanır Solda kod: courses = [("BBM101", "A3"), ("BBM102", None), ("MAT123", "C1")], for code, letter in courses:, girintili if letter is None:, continue, print(code, letter). Sağda iz tablosu, sütunlar code, letter, letter is None, ne olur. BBM101, A3, False, yazılır. BBM102, None (NoneType, bej), True, continue; bu satır çivit mavisi çerçeveyle, continue hücresi açık mavi vurgulu. MAT123, C1, False, yazılır. Kodlar ve notlar str (yeşil), True ve False bool (deniz yeşili). Çıktı: BBM101 A3, MAT123 C1. courses = [("BBM101", "A3"), ("BBM102", None), ("MAT123", "C1")] for code, letter in courses: if letter is None: continue print(code, letter) code letter letter is None ne olur "BBM101" "A3" False yazılır "MAT123" "C1" False yazılır "BBM102" None True continue Çıktı BBM101 A3 MAT123 C1
Notu gelmemiş dersin notu None'dır; is None ile atlanır, hesaba girmez.

Python ne yazdırır?


def calc(x):
    print(x * x)

result = calc(4)
print(result)
      
  1. 16 None
  2. 16 16
  3. None
  4. Hata verir

3. dict

Bir değeri adıyla bulmak

coefficient() ve tablo

coefficient() function'ı ve aynı bilginin tablosu Solda Ders 4'teki coefficient() function'ı, kod paneli içinde: def coefficient(letter):, sonra if letter == "A1": return 4.00, elif letter == "A2": return 3.75, elif letter == "A3": return 3.50, üç nokta ile atlanan satırlar, elif letter == "D": return 1.75, else: return 0.00. Harfler str (yeşil), katsayılar float (hardal sarısı). Sağ kenarda bir köşeli ayraç: 11 dal, 23 satır. Sağda aynı bilgi on dört satırlık bir tablo, yan yana iki yarıda yedişer satır, başlıklar harf notu ve katsayı: A1 4.00; A2 3.75; A3 3.50; B1 3.25; B2 3.00; B3 2.75; C1 2.50; C2 2.25; C3 2.00; D 1.75; F1 0.00; F2 0.00; F3 0.00; F6 0.00. Harf notları str (yeşil), katsayılar float (hardal sarısı); tablo çivit mavisi çerçeveli. Kaynak: Hacettepe Ön Lisans ve Lisans Eğitim-Öğretim ve Sınav Yönetmeliği, Madde 24. def coefficient(letter): if letter == "A1": return 4.00 elif letter == "A2": return 3.75 elif letter == "A3": return 3.50 elif letter == "D": return 1.75 else: return 0.00 11 dal, 23 satır harf notu katsayı A1 4.00 A2 3.75 A3 3.50 B1 3.25 B2 3.00 B3 2.75 C1 2.50 harf notu katsayı C2 2.25 C3 2.00 D 1.75 F1 0.00 F2 0.00 F3 0.00 F6 0.00 Hacettepe Ön Lisans ve Lisans Eğitim-Öğretim ve Sınav Yönetmeliği, Madde 24
Ders 4'teki on bir dal aslında bir tablo: her harfin bir katsayısı var.

dict (sözlük)

dict'in yapısı: grades Üç durumlu tek çizim. Ortada grades ismi (lacivert) bir dict'i (kahverengi çerçeve, altında dict etiketi) gösterir. dict'in içinde key ve value başlıklı iki sütun, iki satır: "MAT123" ile "C1", "FIZ127" ile "B2"; hepsi str (yeşil). table durumunda dict açık mavi bant ve çivit mavisi çerçeve içindedir. anatomy durumunda üstte grades = {"MAT123": "C1", "FIZ127": "B2"} satırı, parçaları numaralı: 1 süslü parantez (açılan ve kapanan), 2 key, 3 iki nokta, 4 value, 5 virgül; bant yok. lookup durumunda sağda grades["FIZ127"] yazar, ondan FIZ127 satırına bir ok gider; FIZ127 satırı çivit mavisi çerçeveli; Çıktı paneli B2. grades = {"MAT123": "C1", "FIZ127": "B2"} 1 2 3 4 5 1 1 süslü parantez 2 key 3 iki nokta 4 value 5 virgül grades key value "MAT123" "C1" "FIZ127" "B2" dict grades["FIZ127"] Çıktı B2
dict, değerleri iki sütunlu bir tablo gibi çiftler halinde tutar.

Key (anahtar) ve value

Kantindeki fiyat panosu Elle çizilmiş gibi basit bir resim. Kantinin duvarında ahşap bir fiyat panosu asılı: çay 15, simit 20, tost 70. Tost satırında ürünün adından fiyatına bir ok gidiyor. Panonun altında, beyaz şapkalı usta tezgahın arkasında durmuş, 70'i gösteriyor; tezgahta ince belli bir çay bardağı var. Sağda bir öğrenci elinde bir madeni parayla soruyor: "Tost kaç?" Sağ üstte kod: prices["tost"] → 70. çay 15 simit 20 tost 70 Tost kaç? prices["tost"] → 70

dict, kantindeki fiyat panosu gibidir: ürünün adı key, fiyatı value.

dict yazmak

Genel biçim
<isim> = {<key>: <value>, <key>: <value>}
dict'in yapısı: grades Üç durumlu tek çizim. Ortada grades ismi (lacivert) bir dict'i (kahverengi çerçeve, altında dict etiketi) gösterir. dict'in içinde key ve value başlıklı iki sütun, iki satır: "MAT123" ile "C1", "FIZ127" ile "B2"; hepsi str (yeşil). table durumunda dict açık mavi bant ve çivit mavisi çerçeve içindedir. anatomy durumunda üstte grades = {"MAT123": "C1", "FIZ127": "B2"} satırı, parçaları numaralı: 1 süslü parantez (açılan ve kapanan), 2 key, 3 iki nokta, 4 value, 5 virgül; bant yok. lookup durumunda sağda grades["FIZ127"] yazar, ondan FIZ127 satırına bir ok gider; FIZ127 satırı çivit mavisi çerçeveli; Çıktı paneli B2. grades = {"MAT123": "C1", "FIZ127": "B2"} 1 2 3 4 5 1 1 süslü parantez 2 key 3 iki nokta 4 value 5 virgül grades key value "MAT123" "C1" "FIZ127" "B2" dict grades["FIZ127"] Çıktı B2
Süslü parantezde key: value çiftleri, aralarında virgül.

dict'ten okumak

Genel biçim
<dict>[<key>]
dict'in yapısı: grades Üç durumlu tek çizim. Ortada grades ismi (lacivert) bir dict'i (kahverengi çerçeve, altında dict etiketi) gösterir. dict'in içinde key ve value başlıklı iki sütun, iki satır: "MAT123" ile "C1", "FIZ127" ile "B2"; hepsi str (yeşil). table durumunda dict açık mavi bant ve çivit mavisi çerçeve içindedir. anatomy durumunda üstte grades = {"MAT123": "C1", "FIZ127": "B2"} satırı, parçaları numaralı: 1 süslü parantez (açılan ve kapanan), 2 key, 3 iki nokta, 4 value, 5 virgül; bant yok. lookup durumunda sağda grades["FIZ127"] yazar, ondan FIZ127 satırına bir ok gider; FIZ127 satırı çivit mavisi çerçeveli; Çıktı paneli B2. grades = {"MAT123": "C1", "FIZ127": "B2"} 1 2 3 4 5 1 1 süslü parantez 2 key 3 iki nokta 4 value 5 virgül grades key value "MAT123" "C1" "FIZ127" "B2" dict grades["FIZ127"] Çıktı B2
Köşeli parantez içine key yazılır; value'su gelir.

dict'i yazdırmak


grades = {"MAT123": "C1", "FIZ127": "B2"}
print(grades)
print(type(grades), len(grades))
Çıktı
{'MAT123': 'C1', 'FIZ127': 'B2'}<class 'dict'> 2

Yazdırınca dict olduğu gibi görünür; len() çift sayısını verir.

dict'in kullanım alanları

dict'in üç kullanım alanı Üç sütun, her biri bir dict (kahverengi çerçeve, altında dict etiketi), isimleri lacivert. 1: ders kodu, ok, harf notu. grades = {"MAT123": "C1", "FIZ127": "B2"}; key'ler ve value'lar str (yeşil). 2: plaka kodu, ok, il. plates = {6: "Ankara", 34: "İstanbul"}; key'ler int (turuncu), value'lar str (yeşil); 34 satırı çivit mavisi çerçeveli: key'in str olması gerekmez. 3: harf notu, ok, katsayı. points = {"A1": 4.0, "B1": 3.25}; key'ler str (yeşil), value'lar float (hardal sarısı). Altta print(grades["MAT123"], plates[34], points["B1"]) ve Çıktı: C1 İstanbul 3.25. ders kodu harf notu grades = {"MAT123": "C1", "FIZ127": "B2"} grades "MAT123" "C1" "FIZ127" "B2" dict plaka kodu il plates = {6: "Ankara", 34: "İstanbul"} plates 6 "Ankara" 34 "İstanbul" dict harf notu katsayı points = {"A1": 4.0, "B1": 3.25} points "A1" 4.0 "B1" 3.25 dict print(grades["MAT123"], plates[34], points["B1"]) Çıktı C1 İstanbul 3.25
Bir değeri adıyla bulmak gerektiğinde dict kullanılır.

Substitutions (xkcd 1288)

Substitutions tablosu: haberleri daha eğlenceli yapan kelime değişimleri; solda haber kelimesi, okun sağında yerine geçen ifade.
xkcd 1288: Substitutions, Randall Munroe, CC BY-NC 2.5, https://xkcd.com/1288/

Soldaki her kelime bir key, sağdaki karşılığı onun value'su.


swaps = {"Space": "Spaaace"}
print(swaps["Space"])
Çıktı
Spaaace

dict ve set

value
  1. Numbers(sayılar)

    1. Integral

      • int7
      • boolTrue
    2. Real

      • float3.5
  2. Sequences(diziler)

    1. Immutable

      • str"7"
      • rangerange(3)
      • tuple(3, 4)
    2. Mutable

      • list[1, 2]
  3. Set types(kümeler)

    • set{1, 2}
  4. Mappings

    • dict{"a": 1}
  5. None

    • NoneTypeNone
bu derstedaha öncesonraki derslerde

Luhn ve hashing (IBM, 1953)

IBM 701'in operatör konsolu: gri gövde üzerinde sıra sıra lambalar, düğmeler ve anahtarlar.
Fotoğraf: Dan (Flickr). “IBM 701console”, Wikimedia Commons, CC BY 2.0.

dict key'i baştan aramaz; key'den yerini hesaplar.

GRADE_POINTS

GRADE_POINTS: harf notlarından katsayılara bir dict Üstte kod: GRADE_POINTS = {"A1": 4.00, "A2": 3.75, "A3": 3.50, "B1": 3.25, "B2": 3.00, "B3": 2.75, "C1": 2.50, "C2": 2.25, "C3": 2.00, "D": 1.75, "F1": 0.00, "F2": 0.00, "F3": 0.00, "F6": 0.00} altı satıra bölünmüş, son satır print(GRADE_POINTS["B1"]); çıktı 3.25. Altta GRADE_POINTS ismi (lacivert) on dört satırlık bir dict'i (kahverengi) gösterir; tablo iki blok halinde, her blokta key ve value sütunları: A1 4.0, A2 3.75, A3 3.5, B1 3.25, B2 3.0, B3 2.75, C1 2.5; C2 2.25, C3 2.0, D 1.75, F1 0.0, F2 0.0, F3 0.0, F6 0.0. Harf notları str (yeşil), katsayılar float (hardal sarısı), Python'un sakladığı biçimde (4.00 yazılır, 4.0 saklanır). B1 satırı çivit mavisi çerçeveli; çıktı 3.25. GRADE_POINTS = {"A1": 4.00, "A2": 3.75, "A3": 3.50, "B1": 3.25, "B2": 3.00, "B3": 2.75, "C1": 2.50, "C2": 2.25, "C3": 2.00, "D": 1.75, "F1": 0.00, "F2": 0.00, "F3": 0.00, "F6": 0.00} print(GRADE_POINTS["B1"]) Çıktı 3.25 GRADE_POINTS key value "A1" 4.0 "A2" 3.75 "A3" 3.5 "B1" 3.25 "B2" 3.0 "B3" 2.75 "C1" 2.5 key value "C2" 2.25 "C3" 2.0 "D" 1.75 "F1" 0.0 "F2" 0.0 "F3" 0.0 "F6" 0.0 dict
Ders 4'teki on bir dal, tek bir dict oldu.

Büyük harfli isimler


MAX_GPA = 4.0
print(GRADE_POINTS["A1"] == MAX_GPA)
Çıktı
True
Büyük harfli isimler: MAX_GPA ve GRADE_POINTS Üç isim (lacivert) ve gösterdikleri değerler. MAX_GPA, 4.0'ı (float, hardal sarısı) gösterir; GRADE_POINTS on dört satırlık bir dict'i (kahverengi, satırlar üç noktayla) gösterir. Bu iki büyük harfli isim aynı açık mavi, çivit mavisi çerçeveli bantta; altlarında: hiç değişmez. latest_grade küçük harfli; program çalıştıkça değişen bir dict'i (kahverengi) gösterir; altında: değişir. MAX_GPA 4.0 GRADE_POINTS hiç değişmez latest_grade değişir

Hiç değişmeyecek değerlerin adı, PEP 8 geleneğiyle büyük harfle yazılır.

dict ve in

dict ve in: yalnızca key'lere bakar Ortada grades dict'i (kahverengi), key ve value sütunlarıyla iki satır: "MAT123" "C1" ve "FIZ127" "B2", hepsi str (yeşil). key sütunu açık mavi bir bantta; bandın altında: in buraya bakar. Solda iki sorgu. "FIZ127" in grades: ok key sütununda aşağı iner ve FIZ127 hücresinde durur; hücre çivit mavisi çerçeveli, sonuç True (bool, deniz yeşili). "B2" in grades: gri ok key sütununu baştan sona geçer, hiçbir key'de durmaz ve tablonun altından çıkar; B2 value sütununda olduğu için ona hiç dokunmaz; sonuç False (bool, deniz yeşili). Çıktı True False. "FIZ127" in grades "B2" in grades key value "MAT123" "C1" "FIZ127" "B2" in buraya bakar dict True bool False bool Çıktı True False
in yalnızca key'lere bakar, value'lara bakmaz.

Boş dict ve eklemek


grades = {}
print(type(grades), len(grades))
grades["MAT123"] = "C1"
print(grades)
Genel biçim
<dict>[<key>] = <value>
Çıktı
<class 'dict'> 0
{'MAT123': 'C1'}
Boş dict ve bir satır eklemek İki kare. Kare 1: lacivert grades ismi boş bir dict'i (kahverengi) gösterir; altında dict yazar. Kare 2: aynı dict'te artık bir satır var, key "MAT123" ve value "C1" (ikisi de str, yeşil); yeni satır çivit mavisi çerçeveli açık mavi bantta. 1 grades dict 2 grades "MAT123" "C1"

Olmayan bir key'e atama yapılırsa dict'e yeni bir satır eklenir.

Değeri değiştirmek

Aynı key'e yeniden atama: film şeridi Film şeridi, üç kare. Üstte kod: latest_grade = {} (# 1), latest_grade["BBM101"] = "F3" (# 2), print(latest_grade), latest_grade["BBM101"] = "A3" (# 3), print(latest_grade); yanında çıktı {'BBM101': 'F3'} ve {'BBM101': 'A3'}. Her karede lacivert latest_grade isminden aşağı inen ok aynı yerdeki dict'i (kahverengi) gösterir. Kare 1: dict boş, çivit mavisi çerçeveli açık mavi bantta. Kare 2: dict'te bir satır var, key "BBM101" ve value "F3" (ikisi de str, yeşil); yeni satır açık mavi bantta. Kare 3: aynı satır yerinde, value artık "A3"; satır açık mavi bantta, ikinci satır yok. Altta: kare n, # n satırı çalıştıktan sonraki durumdur; açık mavi bant bu adımda değişen. latest_grade = {} # 1 latest_grade["BBM101"] = "F3" # 2 print(latest_grade) latest_grade["BBM101"] = "A3" # 3 print(latest_grade) Çıktı {'BBM101': 'F3'} {'BBM101': 'A3'} 1 latest_grade 2 latest_grade "BBM101" "F3" 3 latest_grade "BBM101" "A3" ikinci satır yok Kare n: # n satırı çalıştıktan sonra bu adımda değişen
Var olan bir key'e atama, eski value'nun üstüne yazar.

Değeri değiştirmek (2)

Çaya zam: eski fiyatın üstüne yazılır Elle çizilmiş gibi basit bir resim. Kantinin fiyat panosunda üç satır var: çay, simit ve tost. Çayın eski fiyatı 15 kırmızıyla karalanmış, hemen yanına 20 yazılmış; simit 20, tost 70 aynen duruyor. Usta küçük bir taburenin üstünde, elindeki kalemle panoyu gösteriyor ve "Çay artık 20." diyor. Altta kod: prices["çay"] = 20 ve len(prices) → 3; pano yine üç satır. çay 15 simit 20 tost 70 20 Çay artık 20. prices["çay"] = 20 len(prices) → 3

Zam gelince usta yeni satır açmaz, eski fiyatın üstüne yazar.

Tekrar alınan ders

get()

Genel biçim
<dict>.get(<key>, <yoksa bu değer>)
get(): key yoksa yedek değer Ortada GRADE_POINTS dict'inden (kahverengi) bir kesit: A1 4.0, B1 3.25, B2 3.0 satırları ve geri kalanını gösteren üç nokta; key'ler str (yeşil), value'lar float (hardal sarısı). default durumu: GRADE_POINTS.get("B1", 0.0) B1 key'ine gider (çivit mavisi çerçeve) ve 3.25'i (float, hardal sarısı) getirir. GRADE_POINTS.get("b1", 0.0): gri ok key sütununda satır bulamaz ve tablonun altından çıkar; hata yerine petrol mavisi ok, ikinci argument olan 0.0'ı sonuca taşır (yedek değer); sonuç 0.0 (float) açık mavi bantta. Çıktı 3.25 ve 0.0. none durumu: yalnızca GRADE_POINTS.get("b1") çizili; satır bulamaz ve yedek değer verilmemiş: sonuç None (NoneType, bej) açık mavi bantta; çıktı None. "A1" 4.0 "B1" 3.25 "B2" 3.0 dict GRADE_POINTS.get("B1", 0.0) 3.25 GRADE_POINTS.get("b1", 0.0) 0.0 yedek değer Çıktı 3.25 0.0 GRADE_POINTS.get("b1") None yedek değer yok Çıktı None
get(), key yoksa hata vermez; verdiğimiz ikinci değeri döndürür.

get() (2)

Ekmek yoksa simit al Elle çizilmiş gibi basit bir resim. Solda köşedeki bakkal: çizgili bir tente, camekanda boş bir ekmek sepeti ve "Ekmek bitti" yazan bir kağıt, açık bir kapı. Kapıdan çıkan öğrenci elinde bir simitle gülümsüyor; düşünce balonunda "Ekmek yoksa simit al." yazıyor. Üstte kod: GRADE_POINTS.get("b1", 0.0) → 0.0; aranan key yok, yedek value geliyor. GRADE_POINTS.get("b1", 0.0) → 0.0 Ekmekbitti Ekmek yoksasimit al.

get(), annenin "ekmek yoksa simit al" demesi gibidir: aranan yoksa yedeği gelir.

get() (3)

get(): key yoksa yedek değer Ortada GRADE_POINTS dict'inden (kahverengi) bir kesit: A1 4.0, B1 3.25, B2 3.0 satırları ve geri kalanını gösteren üç nokta; key'ler str (yeşil), value'lar float (hardal sarısı). default durumu: GRADE_POINTS.get("B1", 0.0) B1 key'ine gider (çivit mavisi çerçeve) ve 3.25'i (float, hardal sarısı) getirir. GRADE_POINTS.get("b1", 0.0): gri ok key sütununda satır bulamaz ve tablonun altından çıkar; hata yerine petrol mavisi ok, ikinci argument olan 0.0'ı sonuca taşır (yedek değer); sonuç 0.0 (float) açık mavi bantta. Çıktı 3.25 ve 0.0. none durumu: yalnızca GRADE_POINTS.get("b1") çizili; satır bulamaz ve yedek değer verilmemiş: sonuç None (NoneType, bej) açık mavi bantta; çıktı None. "A1" 4.0 "B1" 3.25 "B2" 3.0 dict GRADE_POINTS.get("B1", 0.0) 3.25 GRADE_POINTS.get("b1", 0.0) 0.0 yedek değer Çıktı 3.25 0.0 GRADE_POINTS.get("b1") None yedek değer yok Çıktı None
Yedek değer verilmezse get() None döndürür.

KeyError


grades = {"MAT123": "C1", "FIZ127": "B2"}
print(grades["mat123"])
Çıktı
Traceback (most recent call last):  File "…/python-kurs/example.py", line 2, in <module>2    print(grades["mat123"])          ~~~~~~^^^^^^^^^^3KeyError: 'mat123'1

Olmayan bir key KeyError verir; mat123 ile MAT123 farklıdır.

TypeError ve list key

list key olamaz, tuple olur İki sütun. dict durumu: solda Geçersiz (kırmızı): attempts = {["BBM101", 2025]: "F3"}; ["BBM101", 2025] bir list (vişneçürüğü), kırmızı ok onu dict key'inin yerine götürmek ister ama yer kırmızı kesik çizgili ve boş kalır; altta kırmızı kutuda hatanın son satırı, iki satıra bölünmüş: TypeError: cannot use 'list' as a dict key (unhashable type: 'list'). Sağda Geçerli (petrol mavisi): attempts = {("BBM101", 2025): "F3"}; aynı bilgi bir tuple (mavi-gri) olarak dict'in (kahverengi) key'i olur, key hücresi çivit mavisi çerçeveli; value "F3" (str, yeşil); attempts[("BBM101", 2025)] çıktısı F3. set durumu: solda s = {["BBM", "MAT"]}; list (vişneçürüğü) set'in (zeytin yeşili) içindeki kırmızı kesik çizgili yere giremez; kırmızı kutuda TypeError: cannot use 'list' as a set element. Sağda s = {"BBM", "MAT"}; aynı değerler ayrı ayrı str (yeşil) olarak set'e (zeytin yeşili) girer; set çivit mavisi çerçeveli. Geçersiz Geçerli attempts = {["BBM101", 2025]: "F3"} ["BBM101", 2025] list TypeError: cannot use 'list' as a dict key (unhashable type: 'list') attempts = {("BBM101", 2025): "F3"} ("BBM101", 2025) "F3" tuple dict attempts[("BBM101", 2025)] F3 s = {["BBM", "MAT"]} ["BBM", "MAT"] list set TypeError: cannot use 'list' as a set element (unhashable type: 'list') s = {"BBM", "MAT"} "BBM" "MAT" set
Key şimdilik değişmez bir değer olmalı: str, int ve tuple olur, list olmaz.

4. dict üzerinde for, items() ve sayma

Bir dict'in bütün satırlarını dolaşmak

dict üzerinde for

dict üzerinde for: iki tur İki kare, her biri for satırı o turda çalıştıktan sonraki an. Her karede code ismi (lacivert) ve grades'in iki satırlık dict'i (kahverengi çerçeve, altında dict etiketi): "MAT123" ile "C1", "FIZ127" ile "B2"; hepsi str (yeşil). 1. turda code'un oku MAT123 key'ine gider; o key hücresi çivit mavisi çerçeveli. Çıktı: MAT123. 2. turda ok FIZ127 key'ine gider ve o hücre çivit mavisi çerçeveli; MAT123'e giden eski ok gri ve kesikli. Çıktı: MAT123 ve FIZ127. for, key'leri eklendikleri sırayla verir. 1. tur code "MAT123" "C1" "FIZ127" "B2" dict Çıktı MAT123 2. tur code "MAT123" "C1" "FIZ127" "B2" dict Çıktı MAT123 FIZ127
for, dict'in key'lerini eklendikleri sırayla verir.

items()

items(): her satır bir tuple Üç durumlu tek çizim. Solda grades.items() yazısının altında grades'in iki satırlık dict'i (kahverengi çerçeve, altında dict etiketi): "MAT123" ile "C1", "FIZ127" ile "B2"; hepsi str (yeşil). Her satırdan bir ok, iki str hücreli bir tuple'a (mavi-gri, altında tuple etiketi) gider: ("MAT123", "C1") ve ("FIZ127", "B2"). pairs durumunda ilk tuple açık mavi, çivit mavisi çerçeveli bantta; çıktı ('MAT123', 'C1') ve ('FIZ127', 'B2'). unpack durumunda sağda code ve grade isimleri (lacivert) ilk tuple'ın iki str'ini gösterir: code "MAT123"ü, grade "C1"i; grade açık mavi bantta; çıktı MAT123 C1 ve FIZ127 B2. gp durumunda ayrıca GRADE_POINTS ismi (lacivert) iki satırlık bir kesiti gösterir (kahverengi dict, GRADE_POINTS'teki sırayla): "B2" ile 3.0, "C1" ile 2.5; katsayılar float (hardal sarısı). grade'den bir ok C1 key'ine gider; C1 hücresi çivit mavisi çerçeveli, bant yok. grade'in gösterdiği C1, GRADE_POINTS'in key'idir; value'su 2.5. Çıktı MAT123: C1, katsayı 2.50 ve FIZ127: B2, katsayı 3.00. grades.items() "MAT123" "C1" "FIZ127" "B2" dict "MAT123" "C1" "FIZ127" "B2" tuple Çıktı ('MAT123', 'C1') ('FIZ127', 'B2') code grade MAT123 C1 FIZ127 B2 GRADE_POINTS "B2" 3.0 "C1" 2.5 dict MAT123: C1, katsayı 2.50 FIZ127: B2, katsayı 3.00
items(), her satırı bir (key, value) tuple'ı olarak verir.

items() (2)

Genel biçim
for <key ismi>, <value ismi> in <dict>.items():
items(): her satır bir tuple Üç durumlu tek çizim. Solda grades.items() yazısının altında grades'in iki satırlık dict'i (kahverengi çerçeve, altında dict etiketi): "MAT123" ile "C1", "FIZ127" ile "B2"; hepsi str (yeşil). Her satırdan bir ok, iki str hücreli bir tuple'a (mavi-gri, altında tuple etiketi) gider: ("MAT123", "C1") ve ("FIZ127", "B2"). pairs durumunda ilk tuple açık mavi, çivit mavisi çerçeveli bantta; çıktı ('MAT123', 'C1') ve ('FIZ127', 'B2'). unpack durumunda sağda code ve grade isimleri (lacivert) ilk tuple'ın iki str'ini gösterir: code "MAT123"ü, grade "C1"i; grade açık mavi bantta; çıktı MAT123 C1 ve FIZ127 B2. gp durumunda ayrıca GRADE_POINTS ismi (lacivert) iki satırlık bir kesiti gösterir (kahverengi dict, GRADE_POINTS'teki sırayla): "B2" ile 3.0, "C1" ile 2.5; katsayılar float (hardal sarısı). grade'den bir ok C1 key'ine gider; C1 hücresi çivit mavisi çerçeveli, bant yok. grade'in gösterdiği C1, GRADE_POINTS'in key'idir; value'su 2.5. Çıktı MAT123: C1, katsayı 2.50 ve FIZ127: B2, katsayı 3.00. grades.items() "MAT123" "C1" "FIZ127" "B2" dict "MAT123" "C1" "FIZ127" "B2" tuple Çıktı ('MAT123', 'C1') ('FIZ127', 'B2') code grade MAT123 C1 FIZ127 B2 GRADE_POINTS "B2" 3.0 "C1" 2.5 dict MAT123: C1, katsayı 2.50 FIZ127: B2, katsayı 3.00
Tuple, Ders 4'teki gibi for satırında iki isme açılır.

Sayma

Sınıf başkanlığı seçiminde oy saymak Elle çizilmiş gibi basit bir resim. Yeşil bir kara tahtada üç isim ve yanlarında çizikler var: Zehra üç, Mehmet iki, Ali bir. Ali'nin adı ve tek çiziği yeni yazılmış, çizik mavi tebeşirle. Solda şaşırmış bir öğrenci üstünde Ali yazan oy pusulasını uzatıyor; tahtanın önündeki öğrenci Ali'nin çiziğini gösterip "Ali yoktu, yazdım." diyor. Altta kod: counts[name] = counts.get(name, 0) + 1; ok bu satırdan yeni çiziğe gidiyor. Zehra Mehmet Ali Ali Ali yoktu,yazdım. counts[name] = counts.get(name, 0) + 1

Sayma, sınıf başkanlığı seçimi gibidir: isim tahtada yoksa yazılır, sonra çizik atılır.

Sayma (2)


counts = {}
print(counts.get("B2", 0))
counts["B2"] = counts.get("B2", 0) + 1
print(counts)

get(g, 0), ilk kez görülen değer için 0 verir.

Çıktı
0
{'B2': 1}
get("B2", 0) ve ilk sayım Üstte get("B2", 0) çağrısı. Gri, soluk bir ok boş bir dict'e (kahverengi çerçeve) girer ve satır bulamadan alt kenarında biter: B2 yok. Çağrının sağından petrol mavisi bir ok 0 değerine (int, turuncu kutu) gider: get yedek değer 0'ı verir. Altta aynı dict artık bir satırlı: "B2" (str, yeşil) ile 1 (int, turuncu); dict açık mavi, çivit mavisi çerçeveli bantta. Sağdaki 0 + 1 yazısından bir ok 1 hücresine gider. Çıktı: 0 ve {'B2': 1}. get("B2", 0) 0 "B2" 1 0 + 1
Genel biçim
<sayaç>[<değer>] = <sayaç>.get(<değer>, 0) + 1

Sayma (3)

F klavye (1955)

Türkçe F klavyenin tuş dizilimi: üst harf sırası F, G, Ğ, I, O, D, R, N, H, P, Q, W diye başlar.
Görsel: Veritas.vos.Liberabit.58, “Kbd trf”, Wikimedia Commons, CC0.

F klavyenin tuşları, Türkçede harflerin ne sıklıkla geçtiği sayılarak dizildi.

Kelime sayan spam filtreleri (2002)

Spam ve normal e-postalarda kelime sayıları İki dict (kahverengi çerçeve, altlarında dict etiketi), lacivert isimlerin altında. Solda spam_counts (üstünde spam yazar): "bedava" 3, "telefon" 1, "kazandınız" 1, "tatil" 1, "fırsatı" 1, "hemen" 1, "tıklayın" 1, "hediye" 1; bedava satırı çivit mavisi çerçeveli. Sağda normal_counts (üstünde normal yazar): "yarın" 1, "lab" 2, "var" 1, "ödev" 1, "pazar" 1, "günü" 1, "notları" 1, "ekte" 1. Kelimeler str (yeşil), sayılar int (turuncu). Satırlar kelimelerin ilk görüldüğü sırada. spam_counts spam "bedava" 3 "telefon" 1 "kazandınız" 1 "tatil" 1 "fırsatı" 1 "hemen" 1 "tıklayın" 1 "hediye" 1 dict normal_counts normal "yarın" 1 "lab" 2 "var" 1 "ödev" 1 "pazar" 1 "günü" 1 "notları" 1 "ekte" 1 dict
2002'de spam filtreleri e-postadaki kelimeleri saydı; SpamBayes bunu Python'la yaptı.

Sayma ve KeyError

Sayma: += ile KeyError, get ile doğru sonuç İki sütun. Solda kırmızı Geçersiz başlığı altında kod: counts = {}, for g in ["B2", "A1", "B2"]:, counts[g] += 1. Üçüncü satırdan kırmızı bir ok boş bir dict'e (kahverengi çerçeve) girer ve satır bulamadan alt kenarında biter; yanında boş dict, B2 satırı yok yazar. Altta kırmızı kutuda KeyError: 'B2'. Sağda petrol mavisi Geçerli başlığı altında aynı döngü counts[g] = counts.get(g, 0) + 1 ile; Çıktı paneli {'B2': 2, 'A1': 1} yazar, açık mavi, çivit mavisi çerçeveli bantta. Geçersiz counts = {} for g in ["B2", "A1", "B2"]: counts[g] += 1 boş dict, B2 satırı yok KeyError: 'B2' Geçerli counts = {} for g in ["B2", "A1", "B2"]: counts[g] = counts.get(g, 0) + 1 Çıktı {'B2': 2, 'A1': 1}
+= yalnızca var olan bir key'de çalışır; ilk tur KeyError verir.

5. set

Her değeri bir kez tutmak

set (küme)

list'ten set'e: tekrarlar bir kez kalır Solda bir list (vişneçürüğü çerçeve), index 0'dan 5'e: 1, 2, 2, 3, 3, 3 (int, turuncu). Tekrar edenler, index 2'deki 2 ile index 4 ve 5'teki 3'ler, gri ve soluk. set() okuyla sağda bir set (zeytin yeşili, köşeleri yuvarlak çerçeve), açık mavi bantta ve çivit mavisi çerçevede: içinde serbest duran 1, 2 ve 3 (int, turuncu); yuvası ve index'i yok, sırası yok. Altta Çıktı paneli: {1, 2, 3} ve 3. 1 0 2 1 2 2 3 3 3 4 3 5 list set() 1 2 3 set Çıktı {1, 2, 3} 3
set, her değeri bir kez tutar; sırası ve index'i yoktur.

set (2)

Gezilen iller haritası bir set gibi Elle çizilmiş gibi basit bir resim. Üstte elle çizilmiş bir Türkiye haritası; yalnızca Ankara ve İzmir'in olduğu yerler maviye boyanmış. Altta solda dört otobüs bileti: Ankara, İzmir, Ankara, Ankara; altında len(trips) → 4. Sağda elinde fırçayla bir öğrenci gülümseyerek "Ankara zaten boyalı." diyor. Haritanın altında len(set(trips)) → 2. len(set(trips)) → 2 Ankara İzmir Ankara Ankara len(trips) → 4 Ankarazatenboyalı.

set, gezdiğiniz iller haritası gibidir: Ankara'ya on kez gitseniz de bir kez boyanır.

Cantor'un küme tanımı (1895)

Georg Cantor'un 1884-1885'te çekilmiş siyah beyaz portresi: dalgalı saçlı, gür sakallı, papyon kravatlı.
Fotoğraf: Otto Zeth; Weierstrass'a sunulan fotoğraf albümünden (R. Bölling, Das Fotoalbum für Weierstraß, 1994). “Das Fotoalbum für Weierstraß 033 (Georg Cantor)”, Wikimedia Commons, Kamu malı (PD-old-70-expired).

Kümenin elemanları birbirinden ayrıdır; aynı eleman iki kez bulunmaz.

set ve list

set ve list Karşılaştırma. Solda list (vişneçürüğü çerçeve): "C1", "B2", "C1" (str, yeşil), altlarında index 0, 1, 2. Sağda set (zeytin yeşili, köşeleri yuvarlak çerçeve): serbest duran "C1" ve "B2" (str, yeşil), index yok. Tablo: sırası korunur mu? list evet, set hayır. index var mı? list evet, set hayır. Aynı değer iki kez olur mu? list evet, set hayır. Değiştirilebilir mi? İkisi de evet. Altta çıktı: len(letters) 3, len(set(letters)) 2; 2 açık mavi bantta ve çivit mavisi çerçevede. list "C1" 0 "B2" 1 "C1" 2 list set "C1" "B2" set sırası korunur mu? evet hayır index var mı? evet hayır aynı değer iki kez olur mu? evet hayır değiştirilebilir mi? evet evet len(letters) 3 len(set(letters)) 2
Sıra ve tekrar önemliyse list, yalnızca "var mı?" önemliyse set.

str, range, list, tuple, dict ve set

str, range, list, tuple, dict ve set Collection tablosu; sütunlar sırası korunur mu?, değiştirilebilir mi?, index var mı?, tekrar olur mu?. str (yeşil): evet, hayır, evet, evet. range: evet, hayır, evet, hayır. list (vişneçürüğü): evet, evet, evet, evet. tuple (mavi-gri): evet, hayır, evet, evet. evet'ler petrol mavisi. w4a durumunda list'in değiştirilebilir mi? hücresi açık mavi, çivit mavisi çerçeveyle vurgulu; dict ve set satırları gri kesikli, Ders 5'te dolacak. w5a durumunda dict (kahverengi): evet (eklenme sırası), evet, hayır (key ile okunur), key hayır, value evet; set (zeytin yeşili): hayır, evet, hayır, hayır; dict ve set adları vurgulu. sırası korunur mu? değiştirilebilir mi? index var mı? tekrar olur mu? str evet hayır evet evet range evet hayır evet hayır list evet evet evet evet tuple evet hayır evet evet dict Ders 5 set Ders 5 evet (eklenme sırası) evet hayır (key ile okunur) key hayır, value evet hayır evet hayır hayır dict set
Altı collection, aynı dört soru.

add() ve in


codes = ["MAT123", "BBM101", "BBM102"]
departments = set()
for code in codes:
    departments.add(code[:3])
print(len(departments), "BBM" in departments)
Çıktı
2 True
add() ile set'in büyümesi Dört kare, soldan sağa. Kare 1, set(): boş bir set (zeytin yeşili, köşeleri yuvarlak çerçeve), altında set etiketi. Kare 2, add("MAT"): "MAT" (str, yeşil) eklenir, açık mavi bantta ve çivit mavisi çerçevede. Kare 3, add("BBM"): "MAT" yerinde durur, "BBM" eklenir ve bantlıdır. Kare 4, add("BBM") gri: set değişmez, altında zaten var yazısı. 1 set() 2 add("MAT") "MAT" 3 add("BBM") "MAT" "BBM" 4 add("BBM") "MAT" "BBM" set zaten var
Bölümleri set'e eklemek, tekrarları kendiliğinden atar.

Süslü parantezle set


letters = {"C1", "B2", "C1"}
print(len(letters), "B2" in letters)
Çıktı
2 True
Süslü parantezle set: iki değer Üstte {"C1", "B2", "C1"} yazısı; ikinci "C1" gri. Altında bir set (zeytin yeşili, köşeleri yuvarlak çerçeve), açık mavi bantta ve çivit mavisi çerçevede, yalnızca iki değer tutar: "C1" ve "B2" (str, yeşil). Altında set etiketi ve 2 değer yazısı. {"C1", "B2", "C1"} "C1" "B2" set 2 değer

set süslü parantezle de yazılır; tekrar eden değer yine bir kez sayılır.

&, - ve |

İki arkadaşın haritası ve ortak il Elle çizilmiş gibi basit bir resim. Yan yana iki küçük Türkiye haritası. Soldakinin adı mine: Ankara, İzmir ve Van boyalı. Sağdakinin adı friend: Ankara ve Trabzon boyalı. İki haritada da Ankara aynı koyu renkle boyanmış. Altta iki öğrenci sevinçle kollarını kaldırmış. Ortada kod: mine & friend → {'Ankara'}; iki ok, iki haritadaki Ankara'yı gösteriyor. mine friend mine & friend → {'Ankara'}

İki arkadaşın haritasında mine & friend ortak illeri, mine | friend hepsini, mine -⁠ friend yalnız sizinkileri verir.

University Website (xkcd 773)

İki kümeli Venn şeması: solda üniversite sitesinin ana sayfasındakiler, sağda insanların sitede aradıkları; kesişimde yalnızca okulun tam adı.
xkcd 773: University Website, Randall Munroe, CC BY-NC 2.5, https://xkcd.com/773/

Ortadaki bölge front & wanted: ikisinde de olan tek şey okulun tam adı.


front = {"foto", "haber", "tam ad"}
wanted = {"takvim", "tam ad"}
print(front & wanted)
Çıktı
{'tam ad'}

set ve TypeError

set'te index yok: TypeError Solda kod paneli: s = {"BBM", "MAT"} ve print(s[0]). Altında s'nin set'i (zeytin yeşili, köşeleri yuvarlak çerçeve): serbest duran "BBM" ve "MAT" (str, yeşil), index'leri yok; altında set etiketi. Ortada s[0]'dan kırmızı bir ok, kırmızı kesik çizgili boş bir kareye gider: 0. eleman yok. Sağda kırmızı TypeError başlığı ve kırmızı çerçeveli kutuda mesaj: 'set' object is not subscriptable. s = {"BBM", "MAT"} print(s[0]) "BBM" "MAT" set s[0] 0. eleman yok TypeError 'set' object is not subscriptable
set'te index yoktur; s[0] TypeError verir.

{} ve set()


print(type({}), type(set()))
Çıktı
<class 'dict'> <class 'set'>
{} ve set(): iki boş değer Üstte {} yazısından bir ok, boş bir dict'e (kahverengi çerçeve, altında dict etiketi) gider; dict açık mavi bant ve çivit mavisi çerçeve içindedir. Altta set() yazısından bir ok, boş bir set'e (zeytin yeşili, köşeleri yuvarlak çerçeve, altında set etiketi) gider. {} boş bir dict yapar; set() boş bir set yapar. {} dict set() set

{} boş bir dict'tir; boş set set() ile yazılır.

Python ne yazdırır?


s = {"BBM", "MAT", "BBM"}
e = {}
print(len(s), e == set())
      
  1. 2 False
  2. 3 True
  3. 2 True
  4. 3 False

10 dakika ara

5A
Scope, None, dict ve set
5B
File okuma, file'a yazma ve Python'dan ilerisi

Sırada 5B

5B'nin hedefi

5B'nin hedefi: transcript.txt'den report.txt'ye Solda transcript.txt dosyası, altı satır (str, yeşil): MAT123;4;C1, FIZ127;3;B2, BBM101;3;F3, TKD103;2;A2, BBM101;3;A3, BBM102;3;. Dosyadan ortadaki program kutusuna bir ok gidiyor; okun üstünde open(), altında okur yazıyor. Programdan report.txt dosyasına ikinci bir ok gidiyor; üstünde write(), altında yazar. report.txt'de altı satır var (str, yeşil): MAT123 4 C1 True, FIZ127 3 B2 True, BBM101 3 A3 True, TKD103 2 A2 True, BBM102 3 devam ediyor ve AGNO: 3.08. report.txt açık mavi zeminde, çivit mavisi çerçeveli. Altta: Program bitince report.txt diskte kalır. MAT123;4;C1 FIZ127;3;B2 BBM101;3;F3 TKD103;2;A2 BBM101;3;A3 BBM102;3; transcript.txt open() okur program write() yazar MAT123 4 C1 True FIZ127 3 B2 True BBM101 3 A3 True TKD103 2 A2 True BBM102 3 devam ediyor AGNO: 3.08 report.txt Program bitince report.txt diskte kalır.
Bu yarının sonunda programınız transcript.txt'yi okuyacak ve sonucu report.txt'ye yazacak.

5B konuları

  1. 6. File okumawith open(), strip(), split(";")
  2. 7. File'a yazma"w", "a", write(), \n
  3. 8. Hedef programtranscript.txt, report.txt, AGNO
  4. 9. Python'dan ilerisimatplotlib, Flask, pygame

6. File okuma

Program bittikten sonra da kalan veri

File (dosya)

Disk ve memory Disk ve memory. Altta Disk (SSD) bloğunda iki dosya: hello.py ve Python interpreter'ının kendisi olan python. Üstte Memory (RAM) bloğu kesikli bir çizgiyle Code ve Data diye ikiye bölünmüş. İki Run oku diskten memory'ye çıkar: python'dan Code bölümündeki Python interpreter şeridine, hello.py'den iki satır koda: name = input("Adınız: ") ve print("Merhaba", name); run durumunda bu iki Run okunun arkasında çivit mavisi çerçeveli açık mavi şeritler var. Data bölümünde lacivert name ismi "Mehmet" değerini gösteriyor; bu değer str olduğu için kutusu yeşil; diskte yok, yalnızca memory'de. Alt satır: Program bitince memory boşalır; dosyalar diskte kalır. Ders 1'de iki durum daha var. memory durumu: Memory bloğu açık mavi, çivit mavisi çerçeveli; Disk bloğu, dosyaları ve Run okları gri; alt satır: Memory şu an çalışan programı ve değerlerini tutar. disk durumu: Disk bloğu açık mavi, çivit mavisi çerçeveli, iki dosyası düz; Memory bölümünün içeriği ve Run okları gri; alt satır: Disk dosyaları tutar; bilgisayar kapanınca da silinmez. Ders 5'te aynı şekil iki durumla kullanılır ve Ders 1 parçaları gri olur. read durumu: diskteki transcript.txt dosyasından (satırlar MAT123;4;C1, FIZ127;3;B2 ve devamını gösteren üç nokta; dosyadaki satırlar str olduğu için yeşil) for line in f oku Data bölümüne çıkar; latest_grade ismi kahverengi kutudaki {'MAT123': 'C1', ve devamı} değerini (dict) gösterir; bu kutu çivit mavisi çerçeveli açık mavi bir şeridin içinde, çünkü bu durumda yeni gelen o; alt satır: transcript.txt diskte kalır; okunan satırlar memory'de data olur. write durumu: transcript.txt kısmı da gri; gpa ismi hardal sarısı kutudaki 3.0833333333333335 değerini (float) gösterir, Data bölümünden report.write(...) oku diskteki açık mavi report.txt dosyasına iner (yeşil str satırlar MAT123 4 C1 True, üç nokta, AGNO: 3.08); alt satır: report.txt program bitince de diskte kalır; gpa gibi variable'lar silinir. Memory RAM Code Python interpreter Data Disk SSD name = input("Adınız: ") print("Merhaba", name) name "Mehmet" hello.py python Run transcript.txt MAT123;4;C1 FIZ127;3;B2 latest_grade {'MAT123': 'C1', } for line in f report.txt MAT123 4 C1 True AGNO: 3.08 gpa 3.0833333333333335 report.write(...) Program bitince memory boşalır; dosyalar diskte kalır. Memory şu an çalışan programı ve değerlerini tutar. Disk dosyaları tutar; bilgisayar kapanınca da silinmez. transcript.txt diskte kalır; okunan satırlar memory'de data olur. report.txt program bitince de diskte kalır; gpa gibi variable'lar silinir.

File (2)

Dosya okumak fotokopi çekmek gibi Elle çizilmiş gibi basit bir resim. Kampüsteki fotokopicide elle yazılmış sarı bir tabela: FOTOKOPİ. Makinenin kapağı açık, camın üstünde yazılı asıl kağıt duruyor; yanında "asıl: disk" yazıyor. Öğrenci makineden çıkan kopyayı elinde tutuyor; yanında "kopya: memory" yazıyor. Asıl kağıt makinede kalıyor. FOTOKOPİ asıl: disk kopya: memory

Dosya okumak fotokopi çekmek gibidir: kopya memory'ye gelir, asıl kağıt diskte kalır.

.NORM Normal File Format (xkcd 2116)

Laptop başında Cueball'a biri veriyi gönderdiğini söylüyor; gelen dosya, ekranda açık tablonun fotoğrafının gömüldüğü bir Word belgesi.
xkcd 2116: .NORM Normal File Format, Randall Munroe, CC BY-NC 2.5, https://xkcd.com/2116/

Programın satır satır okuyabildiği file düz metindir: .txt gibi.

Dosyanın yeri

PyCharm ekran görüntüsü, Dosyanın yeri

Şimdilik grades.txt, .py dosyasıyla aynı klasörde durmalı.

  1. 1python-kurs
  2. 2New (+), File
  3. 3grades.txt

with open()

Genel biçim
with open(<dosya adı>, encoding="utf-8") as <isim>:
    <dosyayla çalışan satırlar>
with open() ve f Solda grades.txt dosyası, iki satır: MAT123;4;C1 ve FIZ127;3;B2 (str, yeşil). Ortada kod: with open("grades.txt", ...) as f:, altında girintili for line in f: ve print(line); girintili iki satır blok diye işaretli. Sağda f ismi (lacivert, açık mavi bant ve çivit mavisi çerçeve içinde), üstten giden bir okla açık dosyayı gösterir. Altında açık yazan petrol mavisi kutudan bir ok, blok bitince yazısının yanından kapalı yazan gri kutuya iner: blok bitince dosya kapanır. MAT123;4;C1 FIZ127;3;B2 grades.txt with open("grades.txt", ) as f: for line in f: print(line) blok f açık blok bitince kapalı
with open() dosyayı açar; blok bitince kendisi kapatır.

Satır satır okumak


with open("grades.txt", encoding="utf-8") as f:
    for line in f:
        print(line)
for line in f: iki tur Üstte grades.txt dosyası, iki satır: MAT123;4;C1 ve FIZ127;3;B2 (str, yeşil). line ismi (lacivert) birinci turda birinci satırı gösterir; o satır çivit mavisi çerçevelidir. Gri kesik çizgili ok, 2. tur yazısıyla, ikinci satırı gösterir. Altta Çıktı: MAT123;4;C1, boş satır, FIZ127;3;B2, boş satır; boş satırlar açık mavi şeritle gösterilir. Çıktıda her satırdan sonra bir boş satır var. MAT123;4;C1 FIZ127;3;B2 line 2. tur Çıktı MAT123;4;C1 boş satır FIZ127;3;B2

for, dosyanın satırlarını sırayla verir.

Satır sonu ve \n


with open("grades.txt", encoding="utf-8") as f:
    for line in f:
        print(len(line))
Çıktı
12
12
Satır sonu: \n Birinci turda line on iki karakterdir, yan yana on iki hücrede: M, A, T, 1, 2, 3, noktalı virgül, 4, noktalı virgül, C, 1 ve sonunda \n (str, yeşil). \n hücresi çivit mavisi çerçevelidir ve altında satır sonu yazar. Sağda len(line) 12. Altta print(line) çıktısı: MAT123;4;C1, ardından açık mavi şeritle gösterilen bir boş satır. Sağdaki yazı ok ile boş satırı gösterir: \n ve print'in kendi satır sonu. print bir satır sonu daha ekler; bu yüzden boş satır çıkar. line, 1. tur M A T 1 2 3 ; 4 ; C 1 \n satır sonu len(line) 12 print(line) MAT123;4;C1 boş satır \n + print'in kendi satır sonu
Her satırın sonunda görünmeyen bir \n karakteri vardır.

strip()


with open("grades.txt", encoding="utf-8") as f:
    for line in f:
        print(line.strip())
Çıktı
MAT123;4;C1
FIZ127;3;B2
strip() ve satır sonu strip() sondaki \n'i siler: line.strip() on bir hücre, M, A, T, 1, 2, 3, noktalı virgül, 4, noktalı virgül, C, 1 (str, yeşil). On ikinci yer gri ve boş, çivit mavisi çerçeveli; yanında strip() sildi yazar. line.strip(), 1. tur M A T 1 2 3 ; 4 ; C 1 strip() sildi

strip(), satırın sonundaki \n'i siler.

LIGO'nun açık verisi

GW150914 kütleçekim dalgası sinyali: Hanford ve Livingston dedektörlerinin ölçümleri üst üste, zamanla sıklaşan ve büyüyen dalga.
Görsel: Courtesy Caltech/MIT/LIGO Laboratory, “GW150914 Strain-diagrams”, Wikimedia Commons, CC0. Boyutu küçültüldü. Veri: LIGO Scientific Collaboration ve Virgo Collaboration, GWOSC, CC BY 4.0.

Kara delik sinyali bir metin dosyasında: her satırda bir sayı, 32 saniyede 131072 satır.

Çıktı
131072 32.0

Kendi kodunu okuyan program

Kendi dosyasını okuyan program Solda mirror.py dosyası, altı satır (str, yeşil): # mirror.py reads itself; number = 0; with open("mirror.py", encoding="utf-8") as f:; for line in f:; number += 1; print(number, line.replace("\n", "")). Dosyadan iki ok çıkar. Üstteki ok Run yazısıyla Python kutusuna gider: Python dosyayı code olarak çalıştırır. Alttaki ok open("mirror.py") yazısıyla Çıktı paneline iner: program aynı dosyayı data olarak okur. Çıktı paneli (açık mavi, çivit mavisi çerçeveli) satırları numaralarıyla yazar, uzun satırlar kısaltılmış: 1 # mirror.py, 2 number = 0, 3 with open(, 4 for line in f:, 5 number += 1, 6 print(. # mirror.py reads itself number = 0 with open("mirror.py", encoding="utf-8") as f: for line in f: number += 1 print(number, line.replace("\n", "")) mirror.py Run Python code olarak çalıştırır open("mirror.py") data olarak okur Çıktı 1 # mirror.py 2 number = 0 3 with open( 4 for line in f: 5 number += 1 6 print(
Bir .py file'ı da metindir; program kendini okuyabilir.

split()


with open("grades.txt", encoding="utf-8") as f:
    for line in f:
        code, credits, grade = line.strip().split(";")
        print(code, int(credits) * 2, grade)
Çıktı
MAT123 8 C1
FIZ127 6 B2
Satırı strip() ve split(";") ile parçalamak Soldan sağa: 'MAT123;4;C1 ' satırı (str, yeşil), strip() oku, sonundaki 'i silinmiş 'MAT123;4;C1' (str, yeşil), split(";") oku, üç parçalı list ['MAT123', '4', 'C1'] (vişneçürüğü, list etiketi). list'ten üç ok code, credits ve grade isimlerine (lacivert) iner; code 'MAT123', credits '4', grade 'C1' gösterir, üçü de str (yeşil, altında str). '4' açık mavi bant ve çivit mavisi çerçeve içinde, altında hala str yazar. Solda int(credits) * 2 bir int (turuncu) verir: 8. strip() split(";") list 'MAT123;4;C1\n' 'MAT123;4;C1' ['MAT123', '4', 'C1'] code str credits grade str 'MAT123' '4' 'C1' hala str int(credits) * 2 8 int
split(";") satırı üç parçaya böler; parçalar str'dir.

encoding="utf-8"

Genel biçim
open(<dosya adı>, encoding="utf-8")
encoding: aynı baytlar, iki farklı okuma "Büşra" (str, yeşil) diskte UTF-8 ile yedi bayt olarak durur; bayt kutuları beyaz: 42, C3, BC, C5, 9F, 72, 61. Altlarındaki köşeli çizgiler baytları harflere ayırır: B bir bayt (42), ü iki bayt (C3 BC), ş iki bayt (C5 9F), r bir bayt (72), a bir bayt (61). Soldaki petrol mavisi ok encoding="utf-8" ile okumayı gösterir: sonuç yine "Büşra" (str, yeşil), altında petrol mavisi doğru yazar. Sağdaki kırmızı ok encoding="cp1254" ile okumayı gösterir: sonuç "Büşra" (str, yeşil), kırmızı kesikli bir çerçevenin içinde, altında kırmızı bozuk yazar. Yanında gri yazı: cp1254, Türkçe Windows'un eski kod sayfası. "Büşra" diskte 42 B C3 BC ü C5 9F ş 72 r 61 a encoding="utf-8" "Büşra" doğru encoding="cp1254" "Büşra" bozuk cp1254, Türkçe Windows'un eski kod sayfası Baytlar: "Büşra".encode("utf-8"); bozuk hali aynı baytlar cp1254 ile okununca, Python 3.14.8.
Türkçe harfler için her zaman encoding="utf-8" yazılır.

encoding="utf-8" (2)

encoding: yazanla okuyan aynı düzeni kullanmalı Elle çizilmiş gibi basit bir resim. Solda bir öğrenci dizüstü bilgisayarda ağaç yazıyor; ekranda "ağaç" görünüyor, ayağının altında utf-8 yazıyor. Bilgisayardan bir kağıt uçak, yani dosya, kesik çizgili bir yolla sağdaki öğrenciye uçuyor. Sağdaki öğrencinin altında cp1254 yazıyor; şaşkın bir yüzle "aÄŸaç ne demek?" diye soruyor. ağaç aÄŸaçne demek? utf-8 cp1254

encoding, F klavye ile Q klavye gibidir: yazanla okuyan aynı düzeni kullanmalıdır.

Mojibake


with open("names.txt", encoding="utf-8") as f:
    for line in f:
        print(line.strip())
with open("names.txt", encoding="cp1254") as f:
    for line in f:
        print(line.strip())
Çıktı
Büşra
Melikşah
Büşra
MelikÅŸah

UTF-8 ile yazılmış bir file cp1254 ile okununca Büşra, Büşra olur.

Dosya modları

Genel biçim
open(<dosya adı>, "r", encoding="utf-8")
Dosya modları: r, w, a Dosya modları, üç sütun. Her sütunda bir mode kutusu, program yazılı bir kutu ve bir dosya simgesi var; dosya satırları str (yeşil). Sütun "r": iki eski satırlı dosyadan programa bir ok; altında okur (varsayılan). Sütun "w": programdan küçük bir dosyaya ok; o dosyanın iki eski satırının üstü kırmızı kesikli çizgiyle çizili; oradan ikinci küçük dosyaya ok, içinde tek satır yeni; altında önce boşaltır, sonra yazar. Sütun "a": programdan dosyanın en alt satırına ok; dosyada eski, eski ve en altta yeni; altında sonuna ekler. Bu durumda (r) r sütununun mode kutusu ve dosyası açık mavi, çivit mavisi çerçeveli; w ve a sütunları kesikli gri çerçeve içinde, gri, üstlerinde 7. bölüm yazar. "r" program eski eski okur (varsayılan) 7. bölüm "w" program eski eski yeni önce boşaltır, sonra yazar 7. bölüm "a" program eski eski yeni sonuna ekler
Varsayılan mod "r", yani okuma; "w" ve "a" bir sonraki bölümde.

Dosya modları (2)

Dosya modları: r, w ve a Elle çizilmiş gibi basit bir resim: yan yana üç spiralli bloknot, üstlerinde r, w ve a yazıyor. r renkli: dolu sayfanın üstünde sayfayı okuyan bir göz. w ve a soluk: w'de bir el dolu sayfayı yırtıyor, a'da kalem yazılı satırların altındaki ilk boş satırda. r w a

r sayfayı okur, w sayfayı yırtıp baştan yazar, a kaldığı satırdan sürer.

Dosyadan dict'e


grades = {}
with open("grades.txt", encoding="utf-8") as f:
    for line in f:
        code, credits, grade = line.strip().split(";")
        grades[code] = grade
print(grades)
Çıktı
{'MAT123': 'C1', 'FIZ127': 'B2'}

Her satır dict'e bir çift olur; boş dict döngüden önce kurulur.

Dosyadan dict'e (2)

Dosya satırından dict'e İki durumlu tek çizim. Üstte soldan sağa: bir satır str'si (yeşil), strip() oku, sonundaki \n'i silinmiş str (yeşil), split(";") oku, üç parçalı bir list (vişneçürüğü, list etiketi). list'ten üç ok code, credits ve grade isimlerine (lacivert) iner; her isim bir str değeri (yeşil, altında str) gösterir. split durumunda (birinci tur) satır 'MAT123;4;C1\n', temizlenmiş hali 'MAT123;4;C1', list ['MAT123', '4', 'C1']; code 'MAT123', credits '4', grade 'C1'. '4' açık mavi bant ve çivit mavisi çerçeve içinde, altında hala str yazar. Solda Çıktı: MAT123 8 C1 ve FIZ127 6 B2. dict durumunda (ikinci turun sonu) satır 'FIZ127;3;B2\n', temizlenmiş hali 'FIZ127;3;B2', list ['FIZ127', '3', 'B2']; code 'FIZ127', grade 'B2'; credits ismi ve '3' gridir, bu programda kullanılmaz. Solda grades ismi (lacivert) bir dict'i (kahverengi çerçeve, altında dict etiketi) gösterir; iki satırı "MAT123" ile "C1" ve "FIZ127" ile "B2" (str, yeşil). grades[code] = grade yazısının altındaki dict'e, grade değeri 'B2'den bir ok gelir ve ikinci turda eklenen FIZ127 satırını gösterir; o satır çivit mavisi çerçevelidir. Çıktı {'MAT123': 'C1', 'FIZ127': 'B2'}. strip() split(";") list 'MAT123;4;C1\n' 'MAT123;4;C1' ['MAT123', '4', 'C1'] 'FIZ127;3;B2\n' 'FIZ127;3;B2' ['FIZ127', '3', 'B2'] code str credits grade str 'MAT123' '4' 'C1' 'FIZ127' 'B2' credits '3' str Çıktı MAT123 8 C1 FIZ127 6 B2 hala str grades[code] = grade grades "MAT123" "C1" "FIZ127" "B2" dict Çıktı {'MAT123': 'C1', 'FIZ127': 'B2'}
İkinci tur dict'e FIZ127 satırını ekler.

FileNotFoundError


with open("missing.txt", encoding="utf-8") as f:
    for line in f:
        print(line)
Çıktı
Traceback (most recent call last):  File "…/python-kurs/example.py", line 1, in <module>2    with open("missing.txt", encoding="utf-8") as f:         ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^3FileNotFoundError: [Errno 2] No such file or directory: 'missing.txt'1

Dosya yoksa ya da başka klasördeyse bu hata gelir.

try ve FileNotFoundError


name = "missing.txt"
try:
    with open(name, encoding="utf-8") as f:
        for line in f:
            print(line.strip())
except FileNotFoundError:
    print(name, "bulunamadı")

Ders 4'teki try burada da çalışır: program mesajla devam eder.

Çıktı
missing.txt bulunamadı

try ve FileNotFoundError (2)

try ve FileNotFoundError: dosya yoksa akış Akış, name = "missing.txt" için izlenen çalıştırma. Başla, sonra name = "missing.txt" kutusu (değer str, yeşil), sonra bir karar kutusu: open(name), dosya var mı? True yolu yukarıdaki for line in f: ... kutusuna gider; bu çalıştırmada izlenmediği için gri; oradan gri bir okla Devam'a. False yolu (kırmızı False etiketli, koyu ok, çünkü bu çalıştırmada izlenen yol) aşağıdaki except FileNotFoundError: kutusuna, oradan print(name, "bulunamadı") kutusuna gider; bu kutu açık mavi, çivit mavisi çerçeveli. Oradan yukarı Devam'a: program devam eder. Çıktı paneli: missing.txt bulunamadı. Başla name = "missing.txt" open(name) dosya var mı? True for line in f: ... False except FileNotFoundError: print(name, "bulunamadı") Devam Çıktı missing.txt bulunamadı
Dosya yoksa akış except'ten sonraki satırla devam eder.

7. File'a yazma

Memory'deki sonucu diskteki bir file'a kaydetmek.

File'a yazmak

Disk ve memory Disk ve memory. Altta Disk (SSD) bloğunda iki dosya: hello.py ve Python interpreter'ının kendisi olan python. Üstte Memory (RAM) bloğu kesikli bir çizgiyle Code ve Data diye ikiye bölünmüş. İki Run oku diskten memory'ye çıkar: python'dan Code bölümündeki Python interpreter şeridine, hello.py'den iki satır koda: name = input("Adınız: ") ve print("Merhaba", name); run durumunda bu iki Run okunun arkasında çivit mavisi çerçeveli açık mavi şeritler var. Data bölümünde lacivert name ismi "Mehmet" değerini gösteriyor; bu değer str olduğu için kutusu yeşil; diskte yok, yalnızca memory'de. Alt satır: Program bitince memory boşalır; dosyalar diskte kalır. Ders 1'de iki durum daha var. memory durumu: Memory bloğu açık mavi, çivit mavisi çerçeveli; Disk bloğu, dosyaları ve Run okları gri; alt satır: Memory şu an çalışan programı ve değerlerini tutar. disk durumu: Disk bloğu açık mavi, çivit mavisi çerçeveli, iki dosyası düz; Memory bölümünün içeriği ve Run okları gri; alt satır: Disk dosyaları tutar; bilgisayar kapanınca da silinmez. Ders 5'te aynı şekil iki durumla kullanılır ve Ders 1 parçaları gri olur. read durumu: diskteki transcript.txt dosyasından (satırlar MAT123;4;C1, FIZ127;3;B2 ve devamını gösteren üç nokta; dosyadaki satırlar str olduğu için yeşil) for line in f oku Data bölümüne çıkar; latest_grade ismi kahverengi kutudaki {'MAT123': 'C1', ve devamı} değerini (dict) gösterir; bu kutu çivit mavisi çerçeveli açık mavi bir şeridin içinde, çünkü bu durumda yeni gelen o; alt satır: transcript.txt diskte kalır; okunan satırlar memory'de data olur. write durumu: transcript.txt kısmı da gri; gpa ismi hardal sarısı kutudaki 3.0833333333333335 değerini (float) gösterir, Data bölümünden report.write(...) oku diskteki açık mavi report.txt dosyasına iner (yeşil str satırlar MAT123 4 C1 True, üç nokta, AGNO: 3.08); alt satır: report.txt program bitince de diskte kalır; gpa gibi variable'lar silinir. Memory RAM Code Python interpreter Data Disk SSD name = input("Adınız: ") print("Merhaba", name) name "Mehmet" hello.py python Run transcript.txt MAT123;4;C1 FIZ127;3;B2 latest_grade {'MAT123': 'C1', } for line in f report.txt MAT123 4 C1 True AGNO: 3.08 gpa 3.0833333333333335 report.write(...) Program bitince memory boşalır; dosyalar diskte kalır. Memory şu an çalışan programı ve değerlerini tutar. Disk dosyaları tutar; bilgisayar kapanınca da silinmez. transcript.txt diskte kalır; okunan satırlar memory'de data olur. report.txt program bitince de diskte kalır; gpa gibi variable'lar silinir.

Kaydetmek

Elektrik gidince memory boşalır Elle çizilmiş gibi basit bir resim. Gece, tavandaki lamba sönük. Solda şaşkın bir öğrenci elleri yanaklarında duruyor; konuşma balonunda "Ödevim gitti." yazıyor. Masadaki dizüstü bilgisayarın ekranı simsiyah. Bilgisayarın üstünde boş bir düşünce bulutu var; yanında "memory: boş" yazıyor. Masanın altındaki açık çekmecede düzgün bir kağıt duruyor; yanında "disk: kaydedilen dosya duruyor" yazıyor. memory: boş Ödevim gitti. disk: kaydedilendosya duruyor

Program bitince memory boşalır; yalnızca file'a yazılan sonuç kalır.

report.txt, log.txt, history.txt

open() ve "w"

Genel biçim
with open(<dosya adı>, "w", encoding="utf-8") as <isim>:
    <isim>.write(<str>)
Dosya modları: r, w, a Dosya modları, üç sütun. Her sütunda bir mode kutusu, program yazılı bir kutu ve bir dosya simgesi var; dosya satırları str (yeşil). Sütun "r": iki eski satırlı dosyadan programa bir ok; altında okur (varsayılan). Sütun "w": programdan küçük bir dosyaya ok; o dosyanın iki eski satırının üstü kırmızı kesikli çizgiyle çizili; oradan ikinci küçük dosyaya ok, içinde tek satır yeni; altında önce boşaltır, sonra yazar. Sütun "a": programdan dosyanın en alt satırına ok; dosyada eski, eski ve en altta yeni; altında sonuna ekler. Bu durumda (r) r sütununun mode kutusu ve dosyası açık mavi, çivit mavisi çerçeveli; w ve a sütunları kesikli gri çerçeve içinde, gri, üstlerinde 7. bölüm yazar. "r" program eski eski okur (varsayılan) 7. bölüm "w" program eski eski yeni önce boşaltır, sonra yazar 7. bölüm "a" program eski eski yeni sonuna ekler
"w", file yoksa onu oluşturur; varsa içini önce boşaltır.

open() ve "w" (2)

Dosya modları: w ve a Elle çizilmiş gibi basit bir resim. Yan yana üç spiralli bloknot, üstlerinde r, w ve a yazıyor. r soluk: dolu sayfanın üstünde bir göz. w kırmızı: bir el dolu sayfayı yırtıp koparıyor, kağıt parçaları uçuşuyor, bloknotta boş bir sayfa kalıyor. a koyu mavi: kalem, yazılı satırların altındaki ilk boş satıra yeni bir satır ekliyor. r w a

"w", "Üzerine yazılsın mı?" diye sormayan bir Kaydet düğmesi gibidir.

write()


with open("report.txt", "w", encoding="utf-8") as f:
    f.write("AGNO: 3.08\n")
write(): ekran boş, yazı report.txt'de Solda Run penceresi boş: ekrana hiçbir şey yazılmadı. Sağda python-kurs klasöründeki report.txt dosyasında tek satır var: AGNO: 3.08 (str, yeşil) ve hemen ardından kesikli kutuda görünmeyen satır sonu \n. Dosya açık mavi zeminde, çivit mavisi çerçeveli. Run penceresi ekrana hiçbir şey yazılmadı python-kurs/ AGNO: 3.08 \n report.txt

write() ekrana değil, file'a yazar.

write() ve \n


with open("codes.txt", "w", encoding="utf-8") as f:
    f.write("MAT123")
    f.write("FIZ127")

with open("codes.txt", encoding="utf-8") as f:
    for line in f:
        print(line.strip())
Çıktı
MAT123FIZ127
write() ve \n: tek satır ya da iki satır İki durum. Durum joined: \n olmadan yazılan codes.txt'de tek satır var: MAT123FIZ127 (str, yeşil); dosya açık mavi zeminde, çivit mavisi çerçeveli; sağdaki yer boş. Durum lines: sağda \n ile yazılan codes.txt'de iki satır var: MAT123 ve FIZ127 (str, yeşil), her birinin sonunda kesikli kutuda \n; bu dosya açık mavi; soldaki tek satırlı hali gri. \n olmadan MAT123FIZ127 codes.txt \n ile MAT123 \n FIZ127 \n codes.txt
write() satır sonu eklemez; iki yazı yan yana birleşir.

write() ve \n (2)


with open("codes.txt", "w", encoding="utf-8") as f:
    f.write("MAT123\n")
    f.write("FIZ127\n")

with open("codes.txt", encoding="utf-8") as f:
    for line in f:
        print(line.strip())
Çıktı
MAT123
FIZ127
write() ve \n: tek satır ya da iki satır İki durum. Durum joined: \n olmadan yazılan codes.txt'de tek satır var: MAT123FIZ127 (str, yeşil); dosya açık mavi zeminde, çivit mavisi çerçeveli; sağdaki yer boş. Durum lines: sağda \n ile yazılan codes.txt'de iki satır var: MAT123 ve FIZ127 (str, yeşil), her birinin sonunda kesikli kutuda \n; bu dosya açık mavi; soldaki tek satırlı hali gri. \n olmadan MAT123FIZ127 codes.txt \n ile MAT123 \n FIZ127 \n codes.txt
Her satırın sonuna \n'i kendimiz yazarız.

print() ve write()

print() ve write() karşılaştırması İki sütunlu karşılaştırma tablosu. Solda print(): nereye sorusuna Run penceresi; satır sonunu kendisi ekler; her type'ı alır: 4 (int, turuncu), 3.08 (float, hardal sarısı) ve "C1" (str, yeşil). Sağda f.write(): report.txt dosyasına yazar; satır sonu eklemez, kesikli kutudaki \n'i siz yazarsınız (bu satır açık mavi zeminde, çivit mavisi çerçeveli); yalnızca str alır: "C1" (str, yeşil) kabul, 4 (int, turuncu) kırmızı kesikli çizgiyle üstü çizili. print() f.write() nereye Run penceresi nereye report.txt satır sonu kendisi ekler satır sonu eklemez \n siz yazarsınız ne alır her type 4 3.08 "C1" ne alır yalnızca str "C1" 4
print() ekrana yazar ve satırı bitirir; write() yalnızca str'yi file'a yazar.

"w" modu


with open("log.txt", "w", encoding="utf-8") as f:
    f.write("spam\n")

with open("log.txt", encoding="utf-8") as f:
    for line in f:
        print(line.strip())
"w" ve "a" ile iki çalıştırma İki durum. Durum w: "w" satırında log.txt 1. çalıştırmadan sonra tek satır spam, 2. çalıştırmadan sonra yine tek satır spam (str, yeşil); ikinci dosya açık mavi zeminde, çivit mavisi çerçeveli; 2. çalıştırmanın çıktısı spam. Alttaki "a" satırının yeri boş. Durum a: alttaki "a" satırında log.txt önce bir satır spam, 2. çalıştırmadan sonra iki satır spam, spam (str, yeşil); ikinci dosya açık mavi; çıktı spam, spam. Üstteki "w" satırı gri. 1. çalıştırmadan sonra 2. çalıştırmadan sonra Çıktı, 2. çalıştırma "w" spam log.txt spam log.txt Run spam "a" spam log.txt spam spam log.txt Run spam spam
"w" ile iki kez çalışan program da tek satır bırakır.

"a" modu

Genel biçim
with open(<dosya adı>, "a", encoding="utf-8") as <isim>:
    <isim>.write(<str>)
Dosya modları: r, w, a Dosya modları, üç sütun. Her sütunda bir mode kutusu, program yazılı bir kutu ve bir dosya simgesi var; dosya satırları str (yeşil). Sütun "r": iki eski satırlı dosyadan programa bir ok; altında okur (varsayılan). Sütun "w": programdan küçük bir dosyaya ok; o dosyanın iki eski satırının üstü kırmızı kesikli çizgiyle çizili; oradan ikinci küçük dosyaya ok, içinde tek satır yeni; altında önce boşaltır, sonra yazar. Sütun "a": programdan dosyanın en alt satırına ok; dosyada eski, eski ve en altta yeni; altında sonuna ekler. Bu durumda (r) r sütununun mode kutusu ve dosyası açık mavi, çivit mavisi çerçeveli; w ve a sütunları kesikli gri çerçeve içinde, gri, üstlerinde 7. bölüm yazar. "r" program eski eski okur (varsayılan) 7. bölüm "w" program eski eski yeni önce boşaltır, sonra yazar 7. bölüm "a" program eski eski yeni sonuna ekler
"a" yeni satırı file'ın sonuna ekler; eski satırlar yerinde kalır.

"a" modu (2)


with open("log.txt", "a", encoding="utf-8") as f:
    f.write("spam\n")

with open("log.txt", encoding="utf-8") as f:
    for line in f:
        print(line.strip())
"w" ve "a" ile iki çalıştırma İki durum. Durum w: "w" satırında log.txt 1. çalıştırmadan sonra tek satır spam, 2. çalıştırmadan sonra yine tek satır spam (str, yeşil); ikinci dosya açık mavi zeminde, çivit mavisi çerçeveli; 2. çalıştırmanın çıktısı spam. Alttaki "a" satırının yeri boş. Durum a: alttaki "a" satırında log.txt önce bir satır spam, 2. çalıştırmadan sonra iki satır spam, spam (str, yeşil); ikinci dosya açık mavi; çıktı spam, spam. Üstteki "w" satırı gri. 1. çalıştırmadan sonra 2. çalıştırmadan sonra Çıktı, 2. çalıştırma "w" spam log.txt spam log.txt Run spam "a" spam log.txt spam spam log.txt Run spam spam
"a" ile iki kez çalışan program iki satır bırakır.

Project penceresinde file

PyCharm ekran görüntüsü, Project penceresinde file

Yazılan file, .py dosyasıyla aynı klasörde görünür.

  1. 1python-kurs
  2. 2log.txt
  3. 3Reload All from Disk

write() ve TypeError

write() ve TypeError: int yerine str İki sütun. Solda Geçersiz: kod credits = 12, with open(...) as f:, f.write(credits). Üçüncü satırdaki credits çivit mavisi bir halkayla işaretli; ok 12 (int, turuncu) değerini gösteriyor. Altında kırmızı hata satırı: TypeError: write() argument must be str, not int. Sağda Geçerli: aynı kod, üçüncü satır f.write(f"Kredi: {credits}\n"); f-string yeşil. Ok report.txt'ye iniyor; dosyada Kredi: 12 (str, yeşil). Dosya açık mavi zeminde, çivit mavisi çerçeveli. Geçersiz credits = 12 with open( ) as f: f.write(credits) 12 int TypeError: write() argument must be str, not int Geçerli credits = 12 with open( ) as f: f.write(f"Kredi: {credits}\n") Kredi: 12 report.txt
write() yalnızca str alır; sayıyı f-string ile yazın.

Unix'te text file ve fopen() (1974)

Viyana Teknik Müzesi'nde sergilenen bir DEC PDP-11/40: dolap biçiminde gövde, üstte iki DECtape sürücüsünün dört makarası, ortada kırmızı-mor ön panel.
Fotoğraf: Jeff Keyzer. “PDP-11-40 in Technisches Museum Wien”, Wikimedia Commons, CC BY-SA 2.0. Boyutu küçültüldü.

"r", "w" ve "a" harfleri C dilinin fopen() function'ından geliyor.

open("log.txt", "a", encoding="utf-8")

Python ne yazdırır?


with open("test.txt", "w",
          encoding="utf-8") as f:
    f.write("bir")
    print("iki")
    f.write("üç\n")
      
  1. birikiüç
  2. bir iki üç
  3. iki
  4. Hiçbir şey

8. Hedef program

Beş haftanın parçaları tek bir programda

Ders 1'deki söz

Ders 1'deki söz ve Ders 5'in report.txt dosyası Solda Ders 1, 20 Ekim: Run penceresi, beş satır: Hacettepe Üniversitesi - Not Dökümü (örnek); Toplam kredi: 9; Toplam ağırlıklı puan: 26.5; AGNO: 2.9444444444444446; <class 'int'> <class 'float'>. Ortada sağa bir ok, üstünde 4 hafta. Sağda Ders 5, 17 Kasım: report.txt dosyası, açık mavi ve çivit mavisi çerçeveli; içinde altı satır (str, yeşil): MAT123 4 C1 True; FIZ127 3 B2 True; BBM101 3 A3 True; TKD103 2 A2 True; BBM102 3 devam ediyor; AGNO: 3.08. Ders 1, 20 Ekim Hacettepe Üniversitesi - Not Dökümü (örnek) Toplam kredi: 9 Toplam ağırlıklı puan: 26.5 AGNO: 2.9444444444444446 <class 'int'> <class 'float'> 4 hafta Ders 5, 17 Kasım MAT123 4 C1 True FIZ127 3 B2 True BBM101 3 A3 True TKD103 2 A2 True BBM102 3 devam ediyor AGNO: 3.08 report.txt
“Bu dersin sonunda bu not dökümünü yazdıran programı kendiniz yazabileceksiniz.”

Ders 5'in hedef programı

Ders 5'in hedef programı: transcript.txt ve Run penceresi Solda transcript.txt dosyası, altı satır (str, yeşil): MAT123;4;C1, FIZ127;3;B2, BBM101;3;F3, TKD103;2;A2, BBM101;3;A3, BBM102;3;. İki BBM101 satırı çivit mavisi çerçeveli; altında BBM101 iki kez yazıyor (F3 ve A3). BBM102 satırında harf notu yok; yanında notu yok yazıyor. Sağda Run penceresi, yedi satır: 5 ders, 1 devam ediyor, 4 bölüm, AGNO: 3.08 (açık mavi bant ve çivit mavisi çerçeveyle vurgulu); MAT123 4 C1 True; FIZ127 3 B2 True; BBM101 3 A3 True (yanında son not); TKD103 2 A2 True; BBM102 3 devam ediyor; AGNO: 3.08. Varsayılan durumda (dersin başı) Run penceresinin sağ üstünde Önizleme etiketi var. final durumunda (finaldeki canlı kurulum) bu etiket gizli, yeri boş kalır; resmin geri kalanı aynıdır. MAT123;4;C1 FIZ127;3;B2 BBM101;3;F3 TKD103;2;A2 BBM101;3;A3 BBM102;3; notu yok transcript.txt BBM101 iki kez Run penceresi Önizleme 5 ders, 1 devam ediyor, 4 bölüm, AGNO: 3.08 MAT123 4 C1 True FIZ127 3 B2 True BBM101 3 A3 True son not TKD103 2 A2 True BBM102 3 devam ediyor AGNO: 3.08

Ders 5'in hedef programı (2)

Ders 5'in hedef programı ve parçalarının geldiği dersler Solda hedef programın on yedi anahtar satırı, atlanan yerler üç noktayla. Her satırın sağında o satırı kuran dersin numarası, sağ sütunda ne öğrendiğimiz: Ders 1 variable ve aritmetik (gpa = total_points / total_credits); Ders 2 f-string, :.2f, strip() ve if (strip satırı, if grade is None, report.write ve print); Ders 3 for, += ve [:3] (for line in f, departments.add(code[:3]), total_points +=); Ders 4 tuple (mavi-gri), function ve try (def weighted_points, try, except FileNotFoundError, unpacking ve (int(credits), grade)); Ders 5A None (bej), dict (kahverengi) ve set (zeytin yeşili) (GRADE_POINTS, latest_grade, items(), departments, is None); Ders 5B okuma ve yazma (open("transcript.txt"), for line in f, open("report.txt", "w"), report.write). Ders 5B satırları açık mavi bantta; sağdaki Ders 5B açık mavi, çivit mavisi çerçeveli. GRADE_POINTS = {"A1": 4.00, 5A def weighted_points(credits, grade): 4 latest_grade = {} 5A try: 4 with open("transcript.txt", 5B for line in f: 3, 5B code, credits, grade = line.strip() 2, 4 latest_grade[code] = (int(credits), 4, 5A except FileNotFoundError: 4 with open("report.txt", "w", 5B for code, course in latest_grade.items(): 5A departments.add(code[:3]) 3, 5A if grade is None: 2, 5A total_points += weighted_points( 3, 4 report.write(f"{code} 2, 5B gpa = total_points / total_credits 1 print(f" AGNO: {gpa:.2f}") 2 Ders 1 variable, aritmetik Ders 2 f-string, :.2f, strip(), if Ders 3 for, +=, [:3] Ders 4 tuple, function, try Ders 5A None, dict, set Ders 5B okuma, yazma

Beş ders

Beş ders: her dersin anahtar parçaları ve AGNO programı Beş durak soldan sağa; numaralı daireler bir yolla, oklarla bağlı. Her durakta o dersin anahtar parçaları ve o hafta AGNO programının yaptığı iş. Ders 1, 20 Ekim: int (turuncu), float (hardal sarısı), print() ve =; üç dersin AGNO'su. Ders 2, 27 Ekim: reassignment (x = x + 1), str (yeşil), input(), if ve elif; puandan katsayı. Ders 3, 3 Kasım: while, counter ve accumulator (+=), for, slicing ([:3]); n dersin AGNO'su. Ders 4, 10 Kasım: list (vişneçürüğü), tuple (mavi-gri), try ve except, def; function ile AGNO. Ders 5, 17 Kasım, açık mavi bant ve çivit mavisi çerçeve içinde: None (bej), dict (kahverengi), set (zeytin yeşili) ve file için open(); dosyadan report.txt'ye. 1 Ders 1 20 Ekim int float print() = üç dersin AGNO'su 2 Ders 2 27 Ekim x = x + 1 str input() if elif puandan katsayı 3 Ders 3 3 Kasım while += for [:3] n dersin AGNO'su 4 Ders 4 10 Kasım list tuple try except def function ile AGNO 5 Ders 5 17 Kasım None dict set open() dosyadan report.txt'ye
Her ders bir öncekinin üstüne kuruldu.

On type

value
  1. Numbers(sayılar)

    1. Integral

      • int7
      • boolTrue
    2. Real

      • float3.5
  2. Sequences(diziler)

    1. Immutable

      • str"7"
      • rangerange(3)
      • tuple(3, 4)
    2. Mutable

      • list[1, 2]
  3. Set types(kümeler)

    • set{1, 2}
  4. Mappings

    • dict{"a": 1}
  5. None

    • NoneTypeNone
bu derstedaha öncesonraki derslerde

On type'ın hepsini tanıyorsunuz.

9. Python'dan ilerisi

Kursun bittiği yerden açılan kapılar

Altı kapı

Python'dan ilerisi: altı kapı Python'dan sonra açılan altı kapı, iki sıra halinde; hepsi eşit, hiçbiri vurgulu değil. Her kapıda adı ve ilk adımı yazıyor. Üst sıra: Veri ve bilim, ilk adım matplotlib ve NumPy; Web, ilk adım Flask; Otomasyon, ilk adım Automate the Boring Stuff kitabı. Alt sıra: Donanım, ilk adım MicroPython ve Raspberry Pi Pico; Oyun, ilk adım pygame; Yapay zeka, ilk adım DeepLearning.AI'ın AI Python for Beginners dersi. Veri ve bilim ilk adım matplotlib, NumPy Web ilk adım Flask Otomasyon ilk adım Automate the Boring Stuff Donanım ilk adım MicroPython, Raspberry Pi Pico Oyun ilk adım pygame Yapay zeka ilk adım AI Python for Beginners, DeepLearning.AI
Yapay zeka bir kapı, ama tek kapı değil.

Veri ve grafik

Önizleme

import matplotlib.pyplot as plt
codes = ["MAT123", "FIZ127",
         "BBM101", "TKD103"]
points = [2.50, 3.00, 3.50, 3.75]
plt.rcParams["font.size"] = 24
plt.figure(figsize=(4.6, 3.8))
plt.barh(codes, points,
         color="#49B0D7")
plt.axvline(3.08, color="#181C3E",
            linewidth=3)
plt.title("Katsayılar ve AGNO")
plt.savefig("grades.png", dpi=200,
            bbox_inches="tight")
Katsayılar ve AGNO

Aynı notlar, matplotlib ile bir grafikte.

Python for Everybody (Ek kaynaklar)

PyPI ve Cheese Shop (2002)

Monty Python grubunun beş üyesi 2014'te Londra'daki Monty Python Live (Mostly) gösterisinden sonra sahnede yan yana; soldan sağa Michael Palin, Terry Gilliam, Terry Jones, Eric Idle ve John Cleese.
Fotoğraf: Eduardo Unda-Sanzana, “Monty Python O2 Arena”, Wikimedia Commons, CC BY 2.0. Boyutu küçültüldü.

Kurulumla gelmeyen paketler PyPI'dadır; eski takma adı Cheese Shop, bir Monty Python skecidir.

pip install matplotlib

Otomasyon


latest_grade = {"MAT123": "C1", "FIZ127": "B2",
                "BBM101": "A3", "TKD103": "A2"}
for code, grade in latest_grade.items():
    name = f"{code}.txt"
    with open(name, "w", encoding="utf-8") as f:
        f.write(f"{code} {grade}\n")
print(len(latest_grade), "file yazıldı")
Çıktı
4 file yazıldı

Dört derse dört file; yüz derse de aynı loop yeter.

Automate the Boring Stuff (Ek kaynaklar)

Ödev 5

Kahve falı: fincan, kulp ve telve Beyaz zemin üzerinde, yukarıdan görülen bir kahve fincanı: koyu lacivert iki iç içe daire fincanın ağzını, sağda ona değen iki küçük iç içe daire kulpu çiziyor. Fincanın içine rastgele büyüklükte 100 koyu kahverengi telve noktası serpilmiş: 40'ı sol alt çeyrekte, 23'ü sol üstte, 21'i sağ üstte, 16'sı sağ altta. Program en kalabalık çeyreği, sol altı seçti ve Mehmet'in falını yazdı: Bir yılan görüyorum; korkmayın, bu Python.

Ödev 5'in son görevinde kahve falı programını kendiniz yazıyorsunuz.

Son gün: 22 Kasım Pazar, 23.59

Form: forms.gle/GoDQP1oTpEdeC2RD6

Dersten sonra izlemek isteyenlere

scope
MIT OCW, Decomposition, Abstraction, and Functions
dict
PY4E, Dictionaries
set
Computerphile, Hash Sets
File
CS50P, File I/O
Belgesel
Python: The Documentary

İsteğe bağlı; bağlantılar Ek kaynaklar sayfasında.

Artık neler yapabiliyorsunuz

  1. 1Problemi adım adım koda çevirmek
  2. 2Error message okuyup düzeltmek
  3. 3dict ve set ile bulmak ve saymak
  4. 4Dosyadan okuyup dosyaya yazmak

Çalışma soruları

Dersten sonra kendi başınıza: önce soruyu çözün, tıklayınca cevap gelir.

Python ne yazdırır?


def f(x):
    x = x + 1
    return x
x = 5
y = f(x)
print(x, y)
      
  1. 6 6
  2. 5 5
  3. NameError
  4. 5 6

Parameter x, call'un içinde ayrı bir isimdir; dönen 6 y'ye bağlanır.

Python ne yazdırır?


def calc(x):
    return x * x

result = calc(4)
print(result)
      
  1. 16 None
  2. 16
  3. None
  4. Hata verir

calc 16'yı return eder; ekrana yalnızca son satırdaki print yazar.

Python ne yazdırır?


grades = {"MAT123": "C1"}
grades["BBM101"] = "F3"
grades["BBM101"] = "A3"
print(len(grades), grades["BBM101"])
      
  1. 3 A3
  2. 2 F3
  3. KeyError
  4. 2 A3

Var olan bir key'e atama value'nun üstüne yazar; dict'te 2 key var.

Python ne yazdırır?


counts = {}
for c in ["B", "B", "M"]:
    counts[c] = counts.get(c, 0) + 1
print(counts["B"], len(counts))
      
  1. 1 2
  2. 2 2
  3. 2 3
  4. KeyError

get(c, 0) ilk B'de 0, ikinci B'de 1 verir; iki farklı harf, iki key.

Python ne yazdırır?


points = {"A1": 4.0, "B1": 3.25}
print("A1" in points, 4.0 in points)
      
  1. True True
  2. False True
  3. KeyError
  4. True False

dict üzerinde in yalnızca key'lere bakar; 4.0 bir value'dur.

Python ne yazdırır?


name = "grades.txt"
with open(name, encoding="utf-8") as f:
    for line in f:
        parts = line.strip().split(";")
        print(parts[0], len(parts))
      
  1. MAT123 11 FIZ127 11
  2. MAT123 3 (boş satır) FIZ127 3
  3. MAT123 3 FIZ127 3
  4. M 3 F 3

strip() \n'i siler, split(";") 3 parça yapar; parts[0] ders kodudur.