1.

Sentaks ve Temel Kavramlar

1.1 İlk Kodunuz
Python'da en temel komut print() fonksiyonudur. Ekrana çıktı vermek için
kullanılır.
print("Merhaba Dünya!")
print("Python öğreniyorum")
Çıktı:
Merhaba Dünya!
Python öğreniyorum
1.2 Yorumlar
Yorumlar, kodunuzu açıklamak için kullanılır ve program tarafından
çalıştırılmaz.
# Bu bir tek satırlık yorumdur
print("Merhaba") # Satır sonunda da yorum yazılabilir

"""
Bu bir
çok satırlı
yorumdur
"""
1.3 Değişkenler
Değişkenler, verileri bellekte saklamak için kullanılan isimlendirilmiş
alanlardır.
isim = "Ahmet"
yas = 25
boy = 1.75
ogrenci_mi = True

print(isim) # Ahmet
print(yas) # 25
Değişken İsimlendirme Kuralları:
• Harf, rakam ve alt çizgi içerebilir
• Rakamla başlayamaz
• Büyük-küçük harf duyarlıdır (age ≠ Age)
• Türkçe karakter kullanmaktan kaçının
• Anlamlı isimler kullanın
1.4 Veri Türleri
1.4.1 String (Metin)
ad = "Ali"
soyad = 'Yılmaz'
mesaj = """Çok satırlı
metin"""
1.4.2 Sayılar
# Integer (Tam sayı)
sayi1 = 42
sayi2 = -17

# Float (Ondalıklı sayı)

pi = 3.14
sicaklik = -5.5

# Complex (Karmaşık sayı)

karmasik = 3 + 4j
1.4.3 Boolean (Mantıksal)
dogru = True
yanlis = False
1.4.4 Koleksiyonlar
# Liste
meyveler = ["elma", "armut", "muz"]

# Demet (Tuple)
koordinat = (10, 20)

# Küme (Set)
benzersiz = {1, 2, 3, 4}

# Sözlük (Dictionary)
kisi = {"ad": "Ayşe", "yas": 30}
1.5 Tür Sorgulama
isim = "Mehmet"
yas = 25

print(type(isim)) # <class 'str'>

print(type(yas)) # <class 'int'>
1.6 Tür Dönüştürme
# String'e dönüştürme
sayi = 42
metin = str(sayi) # "42"

# Integer'a dönüştürme
metin = "100"
sayi = int(metin) # 100

# Float'a dönüştürme
metin = "3.14"
ondalik = float(metin) # 3.14

# Boolean'a dönüştürme
print(bool(1)) # True
print(bool(0)) # False
print(bool("")) # False
print(bool("Ali")) # True
1.7 Aritmetik İşlemler
# Toplama
sonuc = 10 + 5 # 15

# Çıkarma
sonuc = 10 - 5 # 5
# Çarpma
sonuc = 10 * 5 # 50

# Bölme
sonuc = 10 / 3 # 3.333...

# Tam bölme
sonuc = 10 // 3 # 3

# Mod (kalan)
sonuc = 10 % 3 # 1

# Üs alma
sonuc = 2 ** 3 # 8

# İşlem önceliği
sonuc = 10 + 5 * 2 # 20 (önce çarpma)
sonuc = (10 + 5) * 2 # 30 (parantez öncelikli)
1.8 String Eklemleme
ad = "Ahmet"
soyad = "Yılmaz"

# + operatörü ile
tam_ad = ad + " " + soyad # "Ahmet Yılmaz"

# f-string ile (önerilen)

tam_ad = f"{ad} {soyad}" # "Ahmet Yılmaz"

# format() ile
tam_ad = "{} {}".format(ad, soyad)

# % operatörü ile (eski yöntem)

tam_ad = "%s %s" % (ad, soyad)
1.9 Artı-Eşittir Kullanımı (+=)
# Sayılarla
sayi = 10
sayi += 5 # sayi = sayi + 5 → 15

# String'lerle
mesaj = "Merhaba"
mesaj += " Dünya" # "Merhaba Dünya"

# Diğer operatörler
x = 10
x -= 3 # x = 7
x *= 2 # x = 14
x /= 2 # x = 7.0
1.10 Kullanıcı Veri Girişi
# String olarak giriş alma
isim = input("Adınız: ")
print(f"Merhaba {isim}!")

# Sayı olarak alma (dönüştürme gerekli)

yas = int(input("Yaşınız: "))
print(f"Siz {yas} yaşındasınız")

# Float olarak alma

boy = float(input("Boyunuz (m): "))
print(f"Boyunuz {boy} metre")
1.11 Hatalar (Errors)
1.11.1 SyntaxError
Sözdizimi hatası - kod yazım kurallarına uymaz.
# HATALI
print("Merhaba" # Parantez kapatılmamış

# DOĞRU
print("Merhaba")
1.11.2 NameError
Tanımlanmamış değişken kullanımı.
# HATALI
print(tanımlanmamis_degisken)

# DOĞRU
degisken = "Değer"
print(degisken)
1.11.3 ZeroDivisionError
Sıfıra bölme hatası.
# HATALI
sonuc = 10 / 0

# DOĞRU - Hata yakalanıyor

try:
sonuc = 10 / 0
except ZeroDivisionError:
print("Sıfıra bölme hatası!")
________________________________________
2. Fonksiyonlar
Fonksiyonlar, belirli bir görevi yerine getiren yeniden kullanılabilir kod
bloklarıdır.
2.1 Fonksiyon Tanımlama ve Çağırma
# Basit fonksiyon
def selamla():
print("Merhaba!")

# Fonksiyonu çağırma
selamla() # Merhaba!
2.2 Fonksiyon Girintisi
Python'da kod blokları girinti (indentation) ile belirlenir. Genellikle 4
boşluk kullanılır.
def ornek_fonksiyon():
print("Birinci satır")
print("İkinci satır")
if True:
print("İç içe girinti")
print("Fonksiyon sonu")
2.3 Fonksiyon Parametreleri
def selamla(isim):
print(f"Merhaba {isim}!")

selamla("Ali") # Merhaba Ali!

selamla("Ayşe") # Merhaba Ayşe!
2.4 Fonksiyon Argümanları
# Birden fazla parametre
def topla(a, b):
print(a + b)

topla(5, 3) # 8

# Varsayılan parametre değeri

def selamla(isim="Misafir"):
print(f"Merhaba {isim}!")

selamla() # Merhaba Misafir!

selamla("Mehmet") # Merhaba Mehmet!
2.5 Fonksiyon Anahtar Argümanları
def kisi_bilgi(ad, soyad, yas):
print(f"{ad} {soyad}, {yas} yaşında")

# Pozisyonel argüman
kisi_bilgi("Ali", "Yılmaz", 25)

# Anahtar argüman (sıra önemli değil)

kisi_bilgi(yas=30, ad="Ayşe", soyad="Demir")

# Karışık kullanım
kisi_bilgi("Mehmet", soyad="Öz", yas=35)
2.6 Fonksiyondan Geri Dönüş Almak
def topla(a, b):
return a + b

sonuc = topla(10, 5)
print(sonuc) # 15

# Geri dönüş olmayan fonksiyon None döner

def yazdir(mesaj):
print(mesaj)
sonuc = yazdir("Merhaba")
print(sonuc) # None
2.7 Birden Fazla Geri Dönüş Almak
def dort_islem(a, b):
toplam = a + b
fark = a - b
carpim = a * b
bolum = a / b
return toplam, fark, carpim, bolum

# Değerleri alma
t, f, c, b = dort_islem(10, 5)
print(f"Toplam: {t}, Fark: {f}") # Toplam: 15, Fark: 5

# Tuple olarak alma

sonuclar = dort_islem(20, 4)
print(sonuclar) # (24, 16, 80, 5.0)
2.8 Yerel & Global Değişkenler
# Global değişken
x = 10

def fonksiyon():
# Yerel değişken
y = 5
print(f"İçeride x: {x}") # Global değişkene erişim
print(f"İçeride y: {y}")

fonksiyon()
print(f"Dışarıda x: {x}") # 10
# print(y) # HATA! y yerel değişkendir

# Global değişkeni değiştirme

sayac = 0

def artir():
global sayac
sayac += 1

artir()
artir()
print(sayac) # 2
2.9 Yerel Değişken Olarak Parametreler
Fonksiyon parametreleri yerel değişkenler gibi davranır.
def karesi_al(sayi):
# sayi parametresi yerel bir değişkendir
sayi = sayi ** 2
return sayi
orijinal = 5
sonuc = karesi_al(orijinal)
print(f"Orijinal: {orijinal}") # 5
print(f"Sonuç: {sonuc}") # 25
________________________________________
3. Kıyas ve Denetim Yapıları
3.1 Boolean Değerleri
dogru = True
yanlis = False

# Boolean dönen işlemler

print(10 > 5) # True
print(5 > 10) # False
print(bool(1)) # True
print(bool(0)) # False
3.2 Eşitlik Operatörü (==)
print(5 == 5) # True
print(5 == 3) # False
print("a" == "a") # True
print("A" == "a") # False
3.3 Eşitsizlik Operatörü (!=)
print(5 != 3) # True
print(5 != 5) # False
print("a" != "b") # True
3.4 Kıyaslama Operatörleri
# Büyüktür
print(10 > 5) # True

# Küçüktür
print(3 < 8) # True

# Büyük eşit
print(10 >= 10) # True

# Küçük eşit
print(5 <= 3) # False
3.5 and Operatörü
Her iki koşul da True olmalı.
yas = 25
print(yas >= 18 and yas <= 65) # True

# Kısa devre (short-circuit)

print(False and print("Bu çalışmaz")) # False
3.6 or Operatörü
Koşullardan en az biri True olmalı.
gun = "Cumartesi"
print(gun == "Cumartesi" or gun == "Pazar") # True

# Kısa devre
print(True or print("Bu çalışmaz")) # True
3.7 not Operatörü
Boolean değeri tersine çevirir.
ogrenci = True
print(not ogrenci) # False

sayi = 10
print(not sayi > 20) # True
3.8 if İfadesi
yas = 20

if yas >= 18:

print("Reşitsiniz")
print("Ehliyet alabilirsiniz")

# Tek satırda
if yas >= 18: print("Reşitsiniz")
3.9 else İfadesi
yas = 15

if yas >= 18:

print("Reşitsiniz")
else:
print("Reşit değilsiniz")
3.10 elif İfadesi
puan = 75

if puan >= 90:

print("Notunuz: A")
elif puan >= 80:
print("Notunuz: B")
elif puan >= 70:
print("Notunuz: C")
elif puan >= 60:
print("Notunuz: D")
else:
print("Notunuz: F")
3.11 Hata Denetimi (try-except)
try:
sayi = int(input("Bir sayı girin: "))
sonuc = 100 / sayi
print(f"Sonuç: {sonuc}")
except ValueError:
print("Geçerli bir sayı girmediniz!")
except ZeroDivisionError:
print("Sıfıra bölme hatası!")
except Exception as e:
print(f"Beklenmeyen hata: {e}")
else:
 print("İşlem başarılı!")
finally:
print("Program sonu")
________________________________________
4. Koleksiyonlar
4.1 LİSTELER
Listeler, sıralı ve değiştirilebilir koleksiyonlardır.
meyveler = ["elma", "armut", "muz", "kiraz"]
sayilar = [1, 2, 3, 4, 5]
karisik = [1, "iki", 3.0, True]
4.1.1 Listelerde Veri Türleri
# Farklı türlerde veriler bir arada
liste = [42, "metin", 3.14, True, [1, 2, 3]]
4.1.2 Liste Öğelerine Erişim
meyveler = ["elma", "armut", "muz", "kiraz"]

print(meyveler[0]) # elma (ilk öğe)

print(meyveler[2]) # muz
print(meyveler[-1]) # kiraz (son öğe)
print(meyveler[-2]) # muz (sondan ikinci)

# Dilimle me (slicing)
print(meyveler[1:3]) # ['armut', 'muz']
print(meyveler[:2]) # ['elma', 'armut']
print(meyveler[2:]) # ['muz', 'kiraz']
print(meyveler[::2]) # ['elma', 'muz']
4.1.3 Değer Değiştirme
meyveler = ["elma", "armut", "muz"]
meyveler[1] = "çilek"
print(meyveler) # ['elma', 'çilek', 'muz']

# Birden fazla değer değiştirme

meyveler[0:2] = ["portakal", "kivi"]
print(meyveler) # ['portakal', 'kivi', 'muz']
4.1.4 Öğeleri Döndürme
meyveler = ["elma", "armut", "muz"]

for meyve in meyveler:

print(meyve)

# İndeks ile döndürme

for i, meyve in enumerate(meyveler):
print(f"{i}: {meyve}")
4.1.5 Öğe Sorgulama
meyveler = ["elma", "armut", "muz"]

print("elma" in meyveler) # True

print("kiraz" in meyveler) # False
print("muz" not in meyveler) # False
4.1.6 Öğe Sayısı
meyveler = ["elma", "armut", "muz"]
print(len(meyveler)) # 3

# Boş liste kontrolü

if len(meyveler) > 0:
print("Liste dolu")
4.1.7 Liste İnşası
# Boş liste
liste = []
liste = list()

# Liste comprehension
kareler = [x**2 for x in range(10)]
print(kareler) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Koşullu liste comprehension

ciftler = [x for x in range(20) if x % 2 == 0]
print(ciftler) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
4.1.8 İki Listeyi Birleştirme
liste1 = [1, 2, 3]
liste2 = [4, 5, 6]

# + operatörü
birlesik = liste1 + liste2
print(birlesik) # [1, 2, 3, 4, 5, 6]

# extend metodu
[Link](liste2)
print(liste1) # [1, 2, 3, 4, 5, 6]
4.1.9 Çok Boyutlu Listeler
# 2 boyutlu liste (matris)
matris = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]

print(matris[0][0]) # 1
print(matris[1][2]) # 6

# Döngü ile erişim

for satir in matris:
for eleman in satir:
print(eleman, end=" ")
print()
4.1.10 Liste Metotları
liste = [3, 1, 4, 1, 5]
# append() - Sona ekle
[Link](9)
print(liste) # [3, 1, 4, 1, 5, 9]

# insert() - Belirli konuma ekle

[Link](0, 0)
print(liste) # [0, 3, 1, 4, 1, 5, 9]

# remove() - İlk eşleşeni sil

[Link](1)
print(liste) # [0, 3, 4, 1, 5, 9]

# pop() - Son öğeyi çıkar

son = [Link]()
print(son) # 9
print(liste) # [0, 3, 4, 1, 5]

# pop(index) - Belirli indeksteki öğeyi çıkar

ikinci = [Link](1)
print(ikinci) # 3

# clear() - Tüm öğeleri sil

# [Link]()

# sort() - Sırala
[Link]()
print(liste) # [0, 1, 4, 5]

# reverse() - Tersine çevir

[Link]()
print(liste) # [5, 4, 1, 0]

# count() - Öğe sayısını bul

liste2 = [1, 2, 2, 3, 2, 4]
print([Link](2)) # 3

# index() - Öğenin indeksini bul

print([Link](3)) # 3

# copy() - Liste kopyala

kopya = [Link]()
4.2 DEMETLER (TUPLES)
Demetler, sıralı ancak değiştirilemez koleksiyonlardır.
koordinat = (10, 20)
renkler = ("kırmızı", "yeşil", "mavi")
karisik = (1, "iki", 3.0, True)
4.2.1 Demet Öğelerine Erişim
renkler = ("kırmızı", "yeşil", "mavi", "sarı")
print(renkler[0]) # kırmızı
print(renkler[-1]) # sarı

# Dilimleme
print(renkler[1:3]) # ('yeşil', 'mavi')
4.2.2 Değer Değiştirme
Demetler değiştirilemez, ancak listeye çevirip değiştirebilirsiniz.
renkler = ("kırmızı", "yeşil", "mavi")
# renkler[0] = "siyah" # HATA!

# Liste çevirme yöntemi

renkler_liste = list(renkler)
renkler_liste[0] = "siyah"
renkler = tuple(renkler_liste)
print(renkler) # ('siyah', 'yeşil', 'mavi')
4.2.3 Öğeleri Döndürme
renkler = ("kırmızı", "yeşil", "mavi")

for renk in renkler:

print(renk)

# İndeks ile
for i, renk in enumerate(renkler):
print(f"{i}: {renk}")
4.2.4 Öğe Sorgulama
renkler = ("kırmızı", "yeşil", "mavi")

print("yeşil" in renkler) # True

print("sarı" in renkler) # False
4.2.5 Öğe Sayısı
renkler = ("kırmızı", "yeşil", "mavi")
print(len(renkler)) # 3
4.2.6 Tek Öğeli Demet
# Yanlış - bu bir demet değil
tek = (1)
print(type(tek)) # <class 'int'>

# Doğru - virgül gerekli

tek = (1,)
print(type(tek)) # <class 'tuple'>
4.2.7 İki Demeti Birleştirme
demet1 = (1, 2, 3)
demet2 = (4, 5, 6)

birlesik = demet1 + demet2

print(birlesik) # (1, 2, 3, 4, 5, 6)
4.2.8 Demet İnşası
# Boş demet
bos = ()
bos = tuple()

# Listeden demet
liste = [1, 2, 3]
demet = tuple(liste)
4.2.9 Demet Metodları
sayilar = (1, 2, 2, 3, 2, 4)

# count() - Öğe sayısını bul

print([Link](2)) # 3

# index() - Öğenin indeksini bul

print([Link](3)) # 3
4.3 KÜMELER (SETS)
Kümeler, sırasız ve benzersiz öğeler içeren koleksiyonlardır.
sayilar = {1, 2, 3, 4, 5}
meyveler = {"elma", "armut", "muz"}
4.3.1 Küme Öğelerine Erişim
Kümeler sırasız olduğu için indeks ile erişilemez.
meyveler = {"elma", "armut", "muz"}

# Döngü ile erişim

for meyve in meyveler:
print(meyve)
4.3.2 Öğeleri Döndürme
sayilar = {1, 2, 3, 4, 5}

for sayi in sayilar:

print(sayi)
4.3.3 Öğe Sorgulama
meyveler = {"elma", "armut", "muz"}

print("elma" in meyveler) # True

print("kiraz" in meyveler) # False
4.3.4 Öğe Ekleme
meyveler = {"elma", "armut", "muz"}

# add() - Tek öğe ekle

[Link]("kiraz")
print(meyveler)

# update() - Birden fazla öğe ekle

[Link](["portakal", "kivi"])
print(meyveler)
4.3.5 Öğe Silme
meyveler = {"elma", "armut", "muz", "kiraz"}

# remove() - Öğe yoksa hata verir

[Link]("armut")
# [Link]("portakal") # HATA!

# discard() - Öğe yoksa hata vermez

[Link]("muz")
[Link]("portakal") # Hata vermiyor

# pop() - Rastgele bir öğe çıkar

oge = [Link]()

# clear() - Tüm öğeleri sil

# [Link]()
4.3.6 Öğe Sayısı
meyveler = {"elma", "armut", "muz"}
print(len(meyveler)) # 3
4.3.7 İki Kümeyi Birleştirme
kume1 = {1, 2, 3}
kume2 = {3, 4, 5}

# union() - Birleşim
birlesim = [Link](kume2)
print(birlesim) # {1, 2, 3, 4, 5}

# intersection() - Kesişim
kesisim = [Link](kume2)
print(kesisim) # {3}

# difference() - Fark
fark = [Link](kume2)
print(fark) # {1, 2}

# symmetric_difference() - Simetrik fark

sim_fark = kume1.symmetric_difference(kume2)
print(sim_fark) # {1, 2, 4, 5}
4.3.8 Küme İnşası
# Boş küme
bos = set() # {} kullanılamaz (sözlük olur)

# Listeden küme (tekrarlıları siler)

liste = [1, 2, 2, 3, 3, 3, 4]
kume = set(liste)
print(kume) # {1, 2, 3, 4}

# Set comprehension
kareler = {x**2 for x in range(5)}
print(kareler) # {0, 1, 4, 9, 16}
4.3.9 Küme Metodları
kume1 = {1, 2, 3, 4}
kume2 = {3, 4, 5, 6}
# add() - Öğe ekle
[Link](5)

# update() - Birden fazla öğe ekle

[Link]([6, 7, 8])

# remove() - Öğe sil (yoksa hata)

[Link](1)

# discard() - Öğe sil (yoksa hata vermez)

[Link](10)

# pop() - Rastgele öğe çıkar

eleman = [Link]()

# clear() - Tümünü sil

# [Link]()

# union() - Birleşim
print([Link](kume2))

# intersection() - Kesişim
print([Link](kume2))

# difference() - Fark
print([Link](kume2))

# symmetric_difference() - Simetrik fark

print(kume1.symmetric_difference(kume2))

# issubset() - Alt küme mi?

kume3 = {1, 2}
print([Link](kume1))

# issuperset() - Üst küme mi?

print([Link](kume3))

# isdisjoint() - Kesişim var mı?

kume4 = {10, 11}
print([Link](kume4))
4.4 SÖZLÜKLER (DICTIONARIES)
Sözlükler, anahtar-değer çiftlerinden oluşan sırasız koleksiyonlardır.
kisi = {
"ad": "Ahmet",
"soyad": "Yılmaz",
"yas": 30,
"sehir": "İstanbul"
}
print(kisi["ad"]) # Ahmet
4.4.1 Sözlük Öğelerine Erişim
kisi = {"ad": "Ahmet", "yas": 30, "sehir": "İstanbul"}

# Köşeli parantez ile

print(kisi["ad"]) # Ahmet

# get() metodu ile (güvenli)

print([Link]("ad")) # Ahmet
print([Link]("meslek")) # None
print([Link]("meslek", "Belirtilmemiş")) # Belirtilmemiş

# Tüm anahtarlar
print([Link]()) # dict_keys(['ad', 'yas', 'sehir'])

# Tüm değerler
print([Link]()) # dict_values(['Ahmet', 30, 'İstanbul'])

# Anahtar-değer çiftleri
print([Link]()) # dict_items([('ad', 'Ahmet'), ...])
4.4.2 Değer Değiştirme
kisi = {"ad": "Ahmet", "yas": 30}

# Mevcut değeri değiştir

kisi["yas"] = 31
print(kisi) # {'ad': 'Ahmet', 'yas': 31}

# update() ile birden fazla değer değiştir

[Link]({"yas": 32, "sehir": "Ankara"})
print(kisi)
4.4.3 Öğeleri Döndürme
kisi = {"ad": "Ahmet", "yas": 30, "sehir": "İstanbul"}

# Anahtarları döndür
for anahtar in kisi:
print(anahtar)

# Değerleri döndür
for deger in [Link]():
print(deger)

# Anahtar-değer çiftlerini döndür

for anahtar, deger in [Link]():
print(f"{anahtar}: {deger}")
4.4.4 Anahtar Sorgulama
kisi = {"ad": "Ahmet", "yas": 30}

print("ad" in kisi) # True

print("meslek" in kisi) # False
print("Ahmet" in kisi) # False (değerler değil, anahtarlar)

# Değer sorgulama
print("Ahmet" in [Link]()) # True
4.4.5 Öğe Ekleme
kisi = {"ad": "Ahmet", "yas": 30}

# Tek öğe ekle

kisi["sehir"] = "İstanbul"
print(kisi)

# Birden fazla öğe ekle

[Link]({
"meslek": "Mühendis",
"telefon": "555-1234"
})
print(kisi)
4.4.6 Öğe Silme
kisi = {"ad": "Ahmet", "yas": 30, "sehir": "İstanbul"}

# pop() - Belirli anahtarı sil

yas = [Link]("yas")
print(yas) # 30
print(kisi) # {'ad': 'Ahmet', 'sehir': 'İstanbul'}

# popitem() - Son öğeyi sil (Python 3.7+)

son = [Link]()
print(son) # ('sehir', 'İstanbul')

# del - Öğe sil

kisi["telefon"] = "555-1234"
del kisi["telefon"]

# clear() - Tümünü sil

# [Link]()
4.4.7 Sözlük Kopyalama
kisi1 = {"ad": "Ahmet", "yas": 30}

# Yanlış yöntem (referans kopyalar)

kisi2 = kisi1
kisi2["yas"] = 31
print(kisi1) # {'ad': 'Ahmet', 'yas': 31} # Değişti!

# Doğru yöntem - copy()

kisi3 = [Link]()
kisi3["yas"] = 32
print(kisi1) # {'ad': 'Ahmet', 'yas': 31} # Değişmedi

# dict() ile kopyalama

kisi4 = dict(kisi1)
4.4.8 İç İçe Sözlükler
ogrenciler = {
"ogr1": {
"ad": "Ali",
"yas": 20,
"notlar": [80, 90, 85]
},
"ogr2": {
"ad": "Ayşe",
"yas": 21,
"notlar": [95, 88, 92]
}
}

# Erişim
print(ogrenciler["ogr1"]["ad"]) # Ali
print(ogrenciler["ogr2"]["notlar"][0]) # 95

# Döngü ile erişim

for ogr_id, bilgi in [Link]():
print(f"{ogr_id}: {bilgi['ad']}")
4.4.9 Sözlük İnşası
# Boş sözlük
bos = {}
bos = dict()

# dict() ile oluşturma

kisi = dict(ad="Ahmet", yas=30, sehir="İstanbul")
print(kisi)

# Listeden sözlük
anahtar_deger = [("ad", "Mehmet"), ("yas", 25)]
sozluk = dict(anahtar_deger)
print(sozluk)

# Dictionary comprehension
kareler = {x: x**2 for x in range(5)}
print(kareler) # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# fromkeys() - Aynı değerle sözlük oluştur

anahtarlar = ["a", "b", "c"]
sozluk = [Link](anahtarlar, 0)
print(sozluk) # {'a': 0, 'b': 0, 'c': 0}
________________________________________
5. Döngüler
5.1 for Döngüsü
Bir koleksiyon üzerinde yineleme yapmak için kullanılır.
# Liste üzerinde döngü
meyveler = ["elma", "armut", "muz"]
for meyve in meyveler:
print(meyve)

# String üzerinde döngü

for harf in "Python":
print(harf)

# Sözlük üzerinde döngü

kisi = {"ad": "Ahmet", "yas": 30}
for anahtar, deger in [Link]():
print(f"{anahtar}: {deger}")
5.1.1 break İfadesi
Döngüyü tamamen sonlandırır.
sayilar = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for sayi in sayilar:

if sayi == 5:
break
print(sayi)
# Çıktı: 1 2 3 4
5.1.2 continue İfadesi
Döngünün mevcut yinelemesini atlar.
sayilar = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for sayi in sayilar:

if sayi % 2 == 0: # Çift sayıları atla
continue
print(sayi)
# Çıktı: 1 3 5 7 9
5.1.3 range() Fonksiyonu
Sayı dizisi oluşturur.
# 0'dan 5'e kadar (5 dahil değil)
for i in range(5):
print(i) # 0 1 2 3 4

# Başlangıç ve bitiş
for i in range(2, 7):
print(i) # 2 3 4 5 6

# Adım değeri ile

for i in range(0, 10, 2):
print(i) # 0 2 4 6 8

# Geriye doğru
for i in range(10, 0, -1):
print(i) # 10 9 8 7 6 5 4 3 2 1

# Liste oluşturma
sayilar = list(range(1, 11))
print(sayilar) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
5.1.4 pass İfadesi
Hiçbir şey yapmaz, yer tutucu olarak kullanılır.
for i in range(5):
if i == 3:
pass # Daha sonra kodlanacak
else:
print(i)

# Boş fonksiyon/sınıf tanımlama

def gelecekteki_fonksiyon():
pass # Henüz kodlanmadı
5.1.5 İç İçe Döngüler
# Çarpım tablosu
for i in range(1, 6):
for j in range(1, 6):
print(f"{i} x {j} = {i*j}")
print() # Boş satır

# Matris işleme
matris = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for satir in matris:
for eleman in satir:
print(eleman, end=" ")
print()
5.2 while Döngüsü
Koşul doğru olduğu sürece çalışır.
# Temel kullanım
sayac = 0
while sayac < 5:
print(sayac)
sayac += 1

# Kullanıcı girişi ile

while True:
cevap = input("Devam etmek istiyor musunuz? (e/h): ")
if [Link]() == "h":
break
print("Devam ediliyor...")

# break ve continue ile

sayac = 0
while sayac < 10:
sayac += 1
if sayac == 5:
continue # 5'i atla
if sayac == 8:
break # 8'de dur
 print(sayac)
5.3 Sonsuz Döngü
# DİKKAT: Bu döngü sonsuza kadar çalışır!
# while True:
# print("Sonsuz döngü")

# Sonsuz döngüden çıkış

while True:
veri = input("Veri girin (çıkmak için 'q'): ")
if veri == 'q':
break
print(f"Girilen: {veri}")

# Koşullu sonsuz döngü

sayac = 0
while True:
print(sayac)
sayac += 1
if sayac >= 10:
break
________________________________________
6. String İşlemleri
6.1 Çok Satırlı Stringler
# Üç tırnak ile
metin = """Bu bir
çok satırlı
string'dir"""

print(metin)

# Tek tırnak veya çift tırnak

siir = '''Gözlerinin rengini unuttum
Söyle hangi renk
Yoksa ben mi karıştırıyorum
Bir başka şey ile'''

# Satır sonu karakteri ile

adres = "Atatürk Caddesi\nNo: 123\n34000 İstanbul"
print(adres)
6.2 String İndeksi
metin = "Python"

# Pozitif indeks
print(metin[0]) # P
print(metin[2]) # t

# Negatif indeks
print(metin[-1]) # n
print(metin[-2]) # o
# Dilimleme (slicing)
print(metin[0:3]) # Pyt
print(metin[:3]) # Pyt
print(metin[3:]) # hon
print(metin[::2]) # Pto (her 2 karakterde bir)
print(metin[::-1]) # nohtyP (tersine çevir)

# İleri seviye dilimleme

cumle = "Python programlama dili"
print(cumle[0:6]) # Python
print(cumle[7:19]) # programlama
print(cumle[-4:]) # dili
print(cumle[::3]) # Ph oaa l
6.3 String Eklemleme
# + operatörü
ad = "Ahmet"
soyad = "Yılmaz"
tam_ad = ad + " " + soyad
print(tam_ad) # Ahmet Yılmaz

# * operatörü (tekrar)
print("Ha" * 3) # HaHaHa
print("-" * 20) # --------------------

# f-string (Python 3.6+)

isim = "Ali"
yas = 25
print(f"Benim adım {isim} ve {yas} yaşındayım")

# format() metodu
print("Benim adım {} ve {} yaşındayım".format(isim, yas))
print("Benim adım {0} ve {1} yaşındayım".format(isim, yas))
print("Benim adım {isim} ve {yas} yaşındayım".format(isim=isim, yas=yas))

# % operatörü (eski yöntem)

print("Benim adım %s ve %d yaşındayım" % (isim, yas))
6.4 String Uzunluğu
metin = "Python"
print(len(metin)) # 6

# Boş string
bos = ""
print(len(bos)) # 0

# Uzunluk kontrolü
sifre = input("Şifre girin: ")
if len(sifre) < 8:
print("Şifre en az 8 karakter olmalı")
else:
print("Şifre kabul edildi")
6.5 Kaçış Karakteri
# \n - Yeni satır
print("Birinci satır\nİkinci satır")

# \t - Tab
print("İsim\tYaş\tŞehir")
print("Ali\t25\tİstanbul")

# \\ - Backslash
print("Dosya yolu: C:\\Kullanıcılar\\Belgeler")

# \' - Tek tırnak

print('O dedi ki: \'Merhaba\'')

# \" - Çift tırnak

print("O dedi ki: \"Merhaba\"")

# \r - Satır başı (Carriage return)

print("12345\rAB") # AB345

# \b - Backspace
print("Python\b\b\b") # Pyt

# Raw string (kaçış karakteri yok)

print(r"C:\Users\Desktop\new_folder")
6.6 Karakterlerin Sıralı Çağırımı
metin = "Python"

# for döngüsü ile

for karakter in metin:
print(karakter)

# İndeks ile
for i in range(len(metin)):
print(f"{i}: {metin[i]}")

# enumerate ile
for i, karakter in enumerate(metin):
print(f"{i}: {karakter}")
6.7 in İfadesi
cumle = "Python programlama dili"

# Alt string kontrolü

print("Python" in cumle) # True
print("Java" in cumle) # False
print("programlama" in cumle) # True
# not in
print("Ruby" not in cumle) # True

# Karakter kontrolü
print("P" in cumle) # True

# Kullanım örneği
email = "kullanici@[Link]"
if "@" in email and "." in email:
print("Geçerli email formatı")
else:
print("Geçersiz email formatı")
6.8 String Metotları
lower()
Tüm harfleri küçük yapar.
metin = "PYTHON"
print([Link]()) # python

# Karşılaştırma için kullanım

giris = input("Evet mi? (E/H): ")
if [Link]() == "e":
print("Evet seçildi")
upper()
Tüm harfleri büyük yapar.
metin = "python"
print([Link]()) # PYTHON

# Başlıklar için
baslik = "python programlama"
print([Link]()) # PYTHON PROGRAMLAMA
title()
Her kelimenin ilk harfini büyük yapar.
metin = "python programlama dili"
print([Link]()) # Python Programlama Dili

# capitalize() - Sadece ilk harfi büyük yapar

print([Link]()) # Python programlama dili
split()
String'i parçalara böler.
cumle = "Python programlama dili"
kelimeler = [Link]()
print(kelimeler) # ['Python', 'programlama', 'dili']

# Belirli bir ayırıcı ile

tarih = "01-05-2024"
parcalar = [Link]("-")
print(parcalar) # ['01', '05', '2024']

# Maksimum bölme sayısı

metin = "bir-iki-üç-dört"
print([Link]("-", 2)) # ['bir', 'iki', 'üç-dört']

# CSV işleme
veri = "Ali,25,İstanbul,Mühendis"
bilgiler = [Link](",")
print(bilgiler)
join()
Liste öğelerini birleştirir.
kelimeler = ["Python", "programlama", "dili"]
cumle = " ".join(kelimeler)
print(cumle) # Python programlama dili

# Farklı ayırıcılar
print("-".join(kelimeler)) # Python-programlama-dili
print("\n".join(kelimeler)) # Her kelime yeni satırda

# CSV oluşturma
veriler = ["Ali", "25", "İstanbul"]
csv_satir = ",".join(veriler)
print(csv_satir) # Ali,25,İstanbul
strip()
Baş ve sondaki boşlukları siler.
metin = " Python "
print([Link]()) # "Python"

# lstrip() - Soldaki boşlukları sil

print([Link]()) # "Python "

# rstrip() - Sağdaki boşlukları sil

print([Link]()) # " Python"

# Belirli karakterleri silme

url = "[Link]
print([Link]("[Link] # [Link]/
print([Link]("/")) # [Link]

# Kullanıcı girişi temizleme

ad = input("Adınız: ").strip()
replace()
Alt string'i değiştirir.
metin = "Python programlama dili"
yeni = [Link]("Python", "Java")
print(yeni) # Java programlama dili

# Birden fazla değiştirme

cumle = "Merhaba Merhaba Merhaba"
print([Link]("Merhaba", "Selam"))
# Selam Selam Selam
# Maksimum değiştirme sayısı
print([Link]("Merhaba", "Selam", 2))
# Selam Selam Merhaba

# Boşlukları silme
telefon = "555 123 45 67"
print([Link](" ", "")) # 5551234567
find()
Alt string'in indeksini bulur.
metin = "Python programlama dili"
print([Link]("programlama")) # 7
print([Link]("Java")) # -1 (bulunamadı)

# rfind() - Sağdan arama

print([Link]("a")) # 18

# index() - find() gibi ama bulamazsa hata verir

print([Link]("Python")) # 0
# print([Link]("Java")) # ValueError!

# Kullanım örneği
email = "kullanici@[Link]"
at_index = [Link]("@")
if at_index != -1:
kullanici_adi = email[:at_index]
alan_adi = email[at_index+1:]
print(f"Kullanıcı: {kullanici_adi}")
print(f"Alan: {alan_adi}")
format()
String formatlama yapar.
# Pozisyonel argümanlar
print("{} {}".format("Merhaba", "Dünya"))
# Merhaba Dünya

# İndeksli
print("{0} {1} {0}".format("Merhaba", "Dünya"))
# Merhaba Dünya Merhaba

# İsimli argümanlar
print("{isim} {yas} yaşında".format(isim="Ali", yas=25))
# Ali 25 yaşında

# Sayı formatlama
sayi = 3.14159
print("{:.2f}".format(sayi)) # 3.14

# Hizalama
print("{:<10}".format("Sol")) # Sol_______
print("{:>10}".format("Sağ")) # _______Sağ
print("{:^10}".format("Orta")) # ___Orta___

# Binlik ayırıcı
print("{:,}".format(1000000)) # 1,000,000

# Yüzde
oran = 0.85
print("{:.1%}".format(oran)) # 85.0%
6.9 Diğer String Metotları
metin = "Python Programlama"

# startswith() - ile başlar mı?

print([Link]("Python")) # True
print([Link]("Java")) # False

# endswith() - ile biter mi?

print([Link]("lama")) # True
print([Link](".txt")) # False

# count() - alt string sayısını bul

cumle = "Python Python Python"
print([Link]("Python")) # 3

# isalpha() - sadece harf mi?

print("Python".isalpha()) # True
print("Python3".isalpha()) # False

# isdigit() - sadece rakam mı?

print("12345".isdigit()) # True
print("123a45".isdigit()) # False

# isalnum() - harf veya rakam mı?

print("Python3".isalnum()) # True
print("Python 3".isalnum()) # False

# islower() - küçük harf mi?

print("python".islower()) # True
print("Python".islower()) # False

# isupper() - büyük harf mi?

print("PYTHON".isupper()) # True
print("Python".isupper()) # False

# isspace() - boşluk mu?

print(" ".isspace()) # True
print(" a ".isspace()) # False

# swapcase() - büyük/küçük harf değiştir

print("Python".swapcase()) # pYTHON

# zfill() - başa sıfır ekle

print("42".zfill(5)) # 00042
________________________________________
7. Matematik İşlemleri
7.1 Yerleşik Fonksiyonlar
Python'da yerleşik matematik fonksiyonları:
# abs() - Mutlak değer
print(abs(-10)) # 10
print(abs(5.5)) # 5.5

# round() - Yuvarlama
print(round(3.14159)) # 3
print(round(3.14159, 2)) # 3.14
print(round(3.5)) # 4 (çift sayıya yuvarlar)

# pow() - Üs alma
print(pow(2, 3)) # 8 (2^3)
print(pow(2, 3, 5)) # 3 (2^3 mod 5)

# min() - Minimum değer

print(min(5, 3, 8, 1)) # 1
print(min([5, 3, 8, 1])) # 1
print(min("Python")) # P

# max() - Maksimum değer

print(max(5, 3, 8, 1)) # 8
print(max([5, 3, 8, 1])) # 8

# sum() - Toplam
sayilar = [1, 2, 3, 4, 5]
print(sum(sayilar)) # 15
print(sum(sayilar, 10)) # 25 (başlangıç değeri 10)

# divmod() - Bölüm ve kalan

bolum, kalan = divmod(17, 5)
print(f"Bölüm: {bolum}, Kalan: {kalan}") # Bölüm: 3, Kalan: 2
7.2 Math Modülü
Gelişmiş matematik işlemleri için math modülü:
import math

# π (pi) sayısı
print([Link]) # 3.141592653589793

# e sayısı
print(math.e) # 2.718281828459045
7.2.1 Sabitler
import math
# Pi
print([Link]) # 3.141592653589793

# Euler sayısı
print(math.e) # 2.718281828459045

# Tau (2*pi)
print([Link]) # 6.283185307179586

# Sonsuz
print([Link]) # inf
print(-[Link]) # -inf

# Tanımsız sayı (Not a Number)

print([Link]) # nan
7.2.2 Fonksiyonlar
import math

# ceil() - Yukarı yuvarlama

print([Link](3.2)) # 4
print([Link](-3.8)) # -3

# floor() - Aşağı yuvarlama

print([Link](3.8)) # 3
print([Link](-3.2)) # -4

# trunc() - Kesme (virgülden sonrasını at)

print([Link](3.9)) # 3
print([Link](-3.9)) # -3

# sqrt() - Karekök
print([Link](16)) # 4.0
print([Link](2)) # 1.4142135623730951

# pow() - Üs alma
print([Link](2, 3)) # 8.0
print([Link](9, 0.5)) # 3.0 (karekök)

# exp() - e^x
print([Link](1)) # 2.718281828459045
print([Link](2)) # 7.38905609893065

# log() - Doğal logaritma (ln)

print([Link](math.e)) # 1.0
print([Link](10)) # 2.302585092994046

# log10() - 10 tabanında logaritma

print(math.log10(100)) # 2.0
print(math.log10(1000)) # 3.0

# log2() - 2 tabanında logaritma

print(math.log2(8)) # 3.0
print(math.log2(16)) # 4.0

# Trigonometrik fonksiyonlar (radyan cinsinden)

# sin() - Sinüs
print([Link]([Link]/2)) # 1.0
print([Link](0)) # 0.0

# cos() - Kosinüs
print([Link](0)) # 1.0
print([Link]([Link])) # -1.0

# tan() - Tanjant
print([Link]([Link]/4)) # 0.9999999999999999 (yaklaşık 1)

# Ters trigonometrik fonksiyonlar

# asin() - Arksinüs
print([Link](1)) # 1.5707963267948966 (pi/2)

# acos() - Arkkosinüs
print([Link](1)) # 0.0

# atan() - Arktanjant
print([Link](1)) # 0.7853981981633974 (pi/4)

# atan2() - İki argümanlı arktanjant

print(math.atan2(1, 1)) # 0.7853981981633974 (pi/4)

# Hiperbolik fonksiyonlar
# sinh() - Hiperbolik sinüs
print([Link](0)) # 0.0

# cosh() - Hiperbolik kosinüs

print([Link](0)) # 1.0

# tanh() - Hiperbolik tanjant

print([Link](0)) # 0.0

# Derece-Radyan dönüşümü
# degrees() - Radyandan dereceye
print([Link]([Link])) # 180.0
print([Link]([Link]/2))# 90.0

# radians() - Dereceden radyana

print([Link](180)) # 3.141592653589793
print([Link](90)) # 1.5707963267948966
# fabs() - Mutlak değer (float döner)
print([Link](-5)) # 5.0

# factorial() - Faktöriyel
print([Link](5)) # 120 (5! = 5*4*3*2*1)
print([Link](0)) # 1

# gcd() - En büyük ortak bölen

print([Link](48, 18)) # 6
print([Link](100, 75)) # 25

# lcm() - En küçük ortak kat (Python 3.9+)

# print([Link](4, 6)) # 12

# isclose() - Yaklaşık eşitlik kontrolü

print([Link](0.1 + 0.2, 0.3)) # True
print(0.1 + 0.2 == 0.3) # False (floating point hatası)

# isfinite() - Sonlu mu?

print([Link](100)) # True
print([Link]([Link]))# False

# isinf() - Sonsuz mu?

print([Link]([Link])) # True
print([Link](100)) # False

# isnan() - NaN mı?

print([Link]([Link])) # True
print([Link](100)) # False

# copysign() - İşareti kopyala

print([Link](5, -1)) # -5.0
print([Link](-5, 1)) # 5.0

# hypot() - Hipotenüs (Pisagor)

print([Link](3, 4)) # 5.0 (3^2 + 4^2 = 5^2)

# dist() - İki nokta arası mesafe (Python 3.8+)

# print([Link]([0, 0], [3, 4])) # 5.0

# prod() - Çarpım (Python 3.8+)

# print([Link]([2, 3, 4])) # 24

# comb() - Kombinasyon (Python 3.8+)

# print([Link](5, 2)) # 10 (C(5,2))

# perm() - Permütasyon (Python 3.8+)

# print([Link](5, 2)) # 20 (P(5,2))
________________________________________
Pratik Örnekler ve Uygulamalar
Örnek 1: Hesap Makinesi
def hesap_makinesi():
print("Basit Hesap Makinesi")
print("1. Toplama")
print("2. Çıkarma")
print("3. Çarpma")
print("4. Bölme")

secim = input("İşlem seçin (1-4): ")

sayi1 = float(input("Birinci sayı: "))

sayi2 = float(input("İkinci sayı: "))

if secim == "1":
print(f"Sonuç: {sayi1 + sayi2}")
elif secim == "2":
print(f"Sonuç: {sayi1 - sayi2}")
elif secim == "3":
print(f"Sonuç: {sayi1 * sayi2}")
elif secim == "4":
if sayi2 != 0:
print(f"Sonuç: {sayi1 / sayi2}")
else:
print("Hata: Sıfıra bölme!")
else:
print("Geçersiz seçim!")

# hesap_makinesi()
Örnek 2: Asal Sayı Kontrolü
def asal_mi(sayi):
"""Bir sayının asal olup olmadığını kontrol eder"""
if sayi < 2:
return False
for i in range(2, int(sayi**0.5) + 1):
if sayi % i == 0:
return False
return True

# Test
print(asal_mi(17)) # True
print(asal_mi(20)) # False

# 1-100 arası asal sayılar

asallar = [x for x in range(2, 101) if asal_mi(x)]
print(f"1-100 arası asal sayılar: {asallar}")
Örnek 3: Fibonacci Dizisi
def fibonacci(n):
 """İlk n fibonacci sayısını döner"""
if n <= 0:
return []
elif n == 1:
return [0]

dizi = [0, 1]
for i in range(2, n):
[Link](dizi[-1] + dizi[-2])
return dizi

# Test
print(fibonacci(10))
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
Örnek 4: Kelime Sayacı
def kelime_sayaci(metin):
"""Metindeki kelime sıklıklarını bulur"""
kelimeler = [Link]().split()
sayac = {}

for kelime in kelimeler:

# Noktalama işaretlerini temizle
kelime = [Link](".,!?;:")
if kelime in sayac:
sayac[kelime] += 1
else:
sayac[kelime] = 1

return sayac

# Test
metin = "Python programlama dili. Python öğrenmek kolay. Programlama
eğlencelidir."
sonuc = kelime_sayaci(metin)
print(sonuc)
# {'python': 2, 'programlama': 2, 'dili': 1, ...}
Örnek 5: Öğrenci Not Sistemi
ogrenciler = {
"Ali": [80, 90, 85],
"Ayşe": [95, 88, 92],
"Mehmet": [70, 75, 80],
"Fatma": [85, 90, 88]
}

def ortalama_hesapla(notlar):
return sum(notlar) / len(notlar)

def harf_notu(ortalama):
if ortalama >= 90:
 return "A"
elif ortalama >= 80:
return "B"
elif ortalama >= 70:
return "C"
elif ortalama >= 60:
return "D"
else:
return "F"

# Tüm öğrencilerin sonuçlarını göster

for isim, notlar in [Link]():
ort = ortalama_hesapla(notlar)
harf = harf_notu(ort)
print(f"{isim}: Ortalama={ort:.2f}, Harf Notu={harf}")
Örnek 6: Şifre Güvenlik Kontrolü
def sifre_kontrolu(sifre):
"""Şifre güvenliğini kontrol eder"""
if len(sifre) < 8:
return False, "Şifre en az 8 karakter olmalı"

buyuk_harf = any([Link]() for c in sifre)

kucuk_harf = any([Link]() for c in sifre)
rakam = any([Link]() for c in sifre)
ozel_karakter = any(not [Link]() for c in sifre)

if not buyuk_harf:
return False, "En az bir büyük harf gerekli"
if not kucuk_harf:
return False, "En az bir küçük harf gerekli"
if not rakam:
return False, "En az bir rakam gerekli"
if not ozel_karakter:
return False, "En az bir özel karakter gerekli"

return True, "Güçlü şifre!"

# Test
sifreler = ["abc123", "Abc123", "Abc123!", "Ab1!"]
for sifre in sifreler:
gecerli, mesaj = sifre_kontrolu(sifre)
print(f"{sifre}: {mesaj}")
Örnek 7: Basit To-Do List
yapilacaklar = []

def gorev_ekle(gorev):
[Link]({"gorev": gorev, "tamamlandi": False})
print(f"✓ '{gorev}' eklendi")
def gorev_tamamla(indeks):
if 0 <= indeks < len(yapilacaklar):
yapilacaklar[indeks]["tamamlandi"] = True
print(f"✓ Görev tamamlandı")
else:
print("✗ Geçersiz indeks")

def gorev_sil(indeks):
if 0 <= indeks < len(yapilacaklar):
silinen = [Link](indeks)
print(f"✓ '{silinen['gorev']}' silindi")
else:
print("✗ Geçersiz indeks")

def gorevleri_listele():
if not yapilacaklar:
print("Görev yok")
return

for i, gorev in enumerate(yapilacaklar):

durum = "✓" if gorev["tamamlandi"] else "○"
print(f"{i}. {durum} {gorev['gorev']}")

# Kullanım
gorev_ekle("Python öğren")
gorev_ekle("Proje yap")
gorev_ekle("Kitap oku")
gorevleri_listele()
gorev_tamamla(0)
gorevleri_listele()
Örnek 8: Basit Sayı Tahmin Oyunu
import random

def sayi_tahmin_oyunu():
sayi = [Link](1, 100)
tahmin_hakki = 7

print("1-100 arası bir sayı tuttum. Tahmin et!")

print(f"Toplam {tahmin_hakki} hakkın var.")

for deneme in range(1, tahmin_hakki + 1):

try:
tahmin = int(input(f"\n{deneme}. tahmin: "))

if tahmin < 1 or tahmin > 100:

print("Lütfen 1-100 arası bir sayı gir!")
continue

if tahmin == sayi:
 print(f"🎉 Tebrikler! {deneme} denemede bildin!")
return
elif tahmin < sayi:
print("⬆️ Daha büyük bir sayı söyle")
else:
print("⬇️ Daha küçük bir sayı söyle")

except ValueError:
print("Lütfen geçerli bir sayı gir!")

print(f"\n😞 Kaybettin! Sayı {sayi} idi.")

# sayi_tahmin_oyunu()
Örnek 9: Metin İstatistikleri
def metin_analizi(metin):
"""Metin hakkında detaylı istatistikler verir"""
# Temel sayımlar
karakter_sayisi = len(metin)
bosluksuz_karakter = len([Link](" ", ""))
kelime_sayisi = len([Link]())
cumle_sayisi = [Link](".") + [Link]("!") + [Link]("?")

# Harf dağılımı
harfler = {}
for harf in [Link]():
if [Link]():
harfler[harf] = [Link](harf, 0) + 1

# En çok kullanılan harf

en_cok_kullanilan = max(harfler, key=[Link]) if harfler else None

# Sonuçları göster
print(f"Toplam karakter: {karakter_sayisi}")
print(f"Boşluksuz karakter: {bosluksuz_karakter}")
print(f"Kelime sayısı: {kelime_sayisi}")
print(f"Cümle sayısı: {cumle_sayisi}")
print(f"En çok kullanılan harf: {en_cok_kullanilan}
({[Link](en_cok_kullanilan, 0)} kez)")

# Ortalamalar
if kelime_sayisi > 0:
ort_kelime_uzunlugu = bosluksuz_karakter / kelime_sayisi
print(f"Ortalama kelime uzunluğu: {ort_kelime_uzunlugu:.2f}")

# Test
metin = """Python programlama dili kolay ve güçlüdür.
Veri bilimi ve web geliştirme için idealdir!"""
metin_analizi(metin)
Örnek 10: Basit Banka Sistemi
class BankaHesabi:
def __init__(self, hesap_sahibi, baslangic_bakiye=0):
self.hesap_sahibi = hesap_sahibi
[Link] = baslangic_bakiye
self.islem_gecmisi = []

def para_yatir(self, miktar):

if miktar > 0:
[Link] += miktar
self.islem_gecmisi.append(f"+{miktar} TL yatırıldı")
print(f"✓ {miktar} TL yatırıldı. Yeni bakiye: {[Link]} TL")
else:
print("✗ Geçersiz miktar!")

def para_cek(self, miktar):

if miktar > [Link]:
print("✗ Yetersiz bakiye!")
elif miktar > 0:
[Link] -= miktar
self.islem_gecmisi.append(f"-{miktar} TL çekildi")
print(f"✓ {miktar} TL çekildi. Kalan bakiye: {[Link]} TL")
else:
print("✗ Geçersiz miktar!")

def bakiye_goruntule(self):
print(f"Hesap sahibi: {self.hesap_sahibi}")
print(f"Güncel bakiye: {[Link]} TL")

def gecmis_goruntule(self):
print(f"\n{self.hesap_sahibi} - İşlem Geçmişi:")
if not self.islem_gecmisi:
print("Henüz işlem yok")
else:
for i, islem in enumerate(self.islem_gecmisi, 1):
print(f"{i}. {islem}")

# Kullanım
hesap = BankaHesabi("Ahmet Yılmaz", 1000)
hesap.bakiye_goruntule()
hesap.para_yatir(500)
hesap.para_cek(300)
hesap.para_cek(2000) # Yetersiz bakiye
hesap.gecmis_goruntule()
________________________________________

Alıştırmalar ve Öneriler
Başlangıç Seviyesi Alıştırmalar
1. Değişkenler ve Veri Türleri
o Adınız, yaşınız ve şehrinizi değişkenlerde saklayın ve ekrana yazdırın
o İki sayının toplamını, farkını, çarpımını ve bölümünü hesaplayın
2. String İşlemleri
o Kullanıcıdan bir cümle alın ve kelimelere ayırın
o Bir stringi tersine çevirin
o Bir stringdeki sesli harfleri sayın
3. Listeler
o 1-100 arası çift sayılardan oluşan bir liste oluşturun
o Bir listedeki en büyük ve en küçük sayıyı bulun
o İki listeyi birleştirin ve sıralayın
4. Döngüler
o 1-10 arası çarpım tablosunu yazdırın
o Faktöriyel hesaplayan bir program yazın
o Bir sayının rakamlarının toplamını bulun
5. Fonksiyonlar
o İki sayının en büyük ortak bölenini bulan fonksiyon
o Palindrom kontrolü yapan fonksiyon
o Celsius'u Fahrenheit'a çeviren fonksiyon
İleri Seviye Projeler
1. Öğrenci Yönetim Sistemi: Öğrenci ekleme, silme, not girişi ve ortalama
hesaplama
2. Kelime Oyunu: Bilgisayarın tuttuğu kelimeyi tahmin etme oyunu
3. Hesap Makinesi: Bilimsel hesap makinesi (+, -, *, /, sin, cos, log, vb.)
4. Dosya Yöneticisi: Metin dosyası okuma, yazma ve düzenleme
5. Quiz Uygulaması: Çoktan seçmeli soru sistemi ve puanlama
Öğrenme İpuçları
1. Düzenli Pratik Yapın: Her gün en az 30 dakika kod yazın
2. Hata Mesajlarını Okuyun: Hatalar en iyi öğretmenlerdir
3. Kod Okuyun: Başkalarının kodunu inceleyerek öğrenin
4. Proje Yapın: Küçük projelerle başlayın, yavaş yavaş büyütün
5. Dokümantasyon Okuyun: Python'un resmi dokümantasyonunu inceleyin
6. Toplulukla Etkileşim: Stack Overflow, GitHub gibi platformlarda aktif olun