Bu bilgiler Eric Matthes’in Kapsamlı Python Kursu Programlama Uygulama ve Proje Tabanlı Giriş kitabından derlenmiştir.

DEĞİŞKENLER

Değişkenler, verileri depolamak için kullanılan isimlendirilmiş bellek konumlarıdır. Bir değişkene bir değer atandığında, o değere referans veren bir etiket oluşturmuş oluruz.

İsimlendirme Kuralları: Değişken adları bir harf veya alt çizgi (_) ile başlamalıdır. Sayı ile başlayamaz. Yalnızca alfanümerik karakterler ve alt çizgi içerebilir (A-z, 0-9, ve _). Değişken adları büyük/küçük harfe duyarlıdır (isim ve Isim iki farklı değişkendir).
Atama: Değer atamak için eşittir (=) operatörü kullanılır.

Çoklu Atama

Python, tek bir satırda birden çok değişkene değer atamaya olanak tanır. Bu, kodun daha kısa ve okunaklı olmasını sağlar.

# Çoklu atama ile değişkenlere sırasıyla değer atanır.
x, y, z = 1, 2, 3
print(f"x= {x}")

## x= 1

print(f"y= {y}")

## y= 2

print(f"z= {z}")

## z= 3

Sabitler (Constants)

Python’da teknik olarak sabit (değeri değiştirilemez) kavramı yoktur. Ancak programcılar arasında, program boyunca değeri değişmemesi gereken bir değişkeni belirtmek için, değişken adının tamamı büyük harflerle yazılır. Bu bir kuraldan ziyade bir konvansiyondur (PEP 8 stil rehberi önerisi).

# SABIT değişkeninin değerinin program boyunca değiştirilmemesi beklenir.
SABIT_PI = 3.14
print(f"PI Değeri= {SABIT_PI}")

## PI Değeri= 3.14

Programa Yorum Yazma

Kod yazarken, hem kendimizin hem de kodu okuyacak diğer kişilerin ne yaptığımızı anlamasını kolaylaştırmak için yorumlar eklemek çok önemlidir. Yorumlar, kodun mantığını, amacını veya karmaşık kısımlarını açıklamak için kullanılır. Python yorumlayıcısı, yorum satırlarını tamamen görmezden gelir ve çalıştırmaz.

Python’da yorum eklemek için iki yaygın yöntem bulunur.

Yöntem 1: Her Satırın Başına Diyez (#) İşareti Koymak

Bu, Python’da yorum yazmanın standart ve en temel yoludur. Diyez (#) işaretinden sonra o satırın sonuna kadar yazılan her şey bir yorum olarak kabul edilir.

Birden çok satırı yoruma almak istediğinizde, her satırın başına bir # işareti koymanız gerekir. Modern kod editörleri, yorumlamak istediğiniz satırları seçtikten sonra Command + Shift + C (Mac) tuş kombinasyonunu kullanarak bu işlemi otomatik olarak yapmanızı sağlar.

# Bu, çok satırlı bir yorum bloğudur.
# Python'da uzun açıklamalar yapmak için en standart yöntem budur.
# Her bir satır, yorumlayıcı tarafından ayrı ayrı göz ardı edilir.
# Bu yöntem, kodun belirli bir bölümünü geçici olarak devre dışı bırakmak
# için de sıklıkla kullanılır.

a = 10
# b = 20  # Bu satır bir yorum olduğu için çalışmayacak.
c = 30
print(a + c)

## 40

Yöntem 2: Üç Tırnak (““” veya ’’’) Kullanarak Yorum Bloğu Oluşturma

Bu yöntem, teknik olarak bir “yorum” değil, çok satırlı bir karakter dizisidir (multi-line string). Ancak bu string herhangi bir değişkene atanmazsa, Python tarafından bir işlem yapılmaz ve etkili bir şekilde bir yorum bloğu gibi davranır.

Bu format, özellikle birkaç paragraf süren uzun açıklamalar için çok kullanışlıdır çünkü her satırın başına # koyma zahmetini ortadan kaldırır.

"""
Bu da çok satırlı yorum yazmak için kullanılan
yaygın bir yöntemdir. Teknik olarak bu bir yorum değil,
değere atanmamış çok satırlı bir karakter dizisidir.

Okunabilirliği daha yüksek olduğu için uzun açıklamalarda
tercih edilebilir.
"""

## '\nBu da çok satırlı yorum yazmak için kullanılan\nyaygın bir yöntemdir. Teknik olarak bu bir yorum değil,\ndeğere atanmamış çok satırlı bir karakter dizisidir.\n\nOkunabilirliği daha yüksek olduğu için uzun açıklamalarda\ntercih edilebilir.\n'

x = 100
y = 200
print(x + y)

## 300

'''
Tek tırnak kullanarak da aynı işlemi yapabilirsiniz.
Üç tek tırnak ile üç çift tırnak arasında
bu kullanımda bir fark yoktur.
'''

## '\nTek tırnak kullanarak da aynı işlemi yapabilirsiniz.\nÜç tek tırnak ile üç çift tırnak arasında\nbu kullanımda bir fark yoktur.\n'

z = 300
print(z)

## 300

Özet: Hangi Yöntem Ne Zaman Kullanılmalı?

Yöntem	Teknik Anlamı	Avantajları	En İyi Kullanım Alanı
`#` ile başlayan satırlar	Gerçek Yorum	- Yorumlayıcı tarafından tamamen göz ardı edilir. - Kod satırlarını test amacıyla devre dışı bırakmak için idealdir.	- Satır içi açıklamalar. - Bir veya birkaç satırlık yorum blokları. - Kodun bölümlerini geçici olarak pasif hale getirme.
`"""..."""` veya `'''...'''`	Çok Satırlı String	- Uzun metinler için daha temiz ve okunaklı bir görünüm sunar. - Her satırın başına işaret koyma gerektirmez.	- Çok paragraflı uzun açıklamalar.

BASİT VERİ TİPLERİ

Python’da her değerin bir veri tipi vardır. En temel veri tipleri karakter dizileri (string), sayılar (numeric) ve boolean’lardır.

Karakter Dizileri (Strings)

String’ler, metin verilerini temsil eden, tek tırnak (') veya çift tırnak (") arasına yazılmış karakter dizileridir. String’ler değiştirilemez (immutable) veri tipleridir; yani bir kere oluşturulduktan sonra içerikleri doğrudan değiştirilemez.

`print()` Fonksiyonu

Ekrana çıktı vermek için kullanılır.

print("PYTHON BİLGİLERİ.")

## PYTHON BİLGİLERİ.

print("Adım adım ilerleyip tüm kaynaklar taranarak not oluşturulacaktır.")

## Adım adım ilerleyip tüm kaynaklar taranarak not oluşturulacaktır.

String Metotları ile Metin Düzenleme

Python, string’ler üzerinde işlem yapmak için çeşitli yerleşik metotlar sunar.

isim_soyad = "ada lovelace"
print(isim_soyad)

## ada lovelace

print(isim_soyad.title())  # Her kelimenin baş harfini büyük yapar.

## Ada Lovelace

print(isim_soyad.upper())  # Tüm harfleri büyük yapar.

## ADA LOVELACE

print(isim_soyad.lower())  # Tüm harfleri küçük yapar.

## ada lovelace

f-string ile Biçimlendirme

f veya F öneki ile başlayan string’ler, süslü parantezler {} içine yazılan değişkenleri veya ifadeleri doğrudan string içine yerleştirir.

isim = "ismail cüneyt"
soyad = "varilci"
# f-string kullanarak değişkenleri birleştirme ve metot uygulama
komple_isim = f"{isim.title()} {soyad.upper()}"
print(komple_isim)

## Ismail Cüneyt VARILCI

Boşluk Karakterleri ve Kontrolü

Metin içinde özel boşluklar eklemek veya mevcut boşlukları temizlemek için özel karakterler ve metotlar kullanılır.

# \t (tab) ile bir sekme boşluk bırakma
print("Sekmeli:\tPython")

## Sekmeli: Python

# \n (newline) ile bir alt satıra geçme
print("Diller:\nPython\nR\nC#")

## Diller:
## Python
## R
## C#

# \n\t ile alt satıra geçip bir sekme boşluk bırakma
print("Diller:\n\tPython\n\tR\n\tC#")

## Diller:
##  Python
##  R
##  C#

dil = " Python "
print(f"Orjinal: '{dil}'")

## Orjinal: ' Python '

print(f"Sağdan Boşluk Sil (rstrip): '{dil.rstrip()}'")

## Sağdan Boşluk Sil (rstrip): ' Python'

print(f"Soldan Boşluk Sil (lstrip): '{dil.lstrip()}'")

## Soldan Boşluk Sil (lstrip): 'Python '

print(f"Her İki Taraftan Boşluk Sil (strip): '{dil.strip()}'")

## Her İki Taraftan Boşluk Sil (strip): 'Python'

Sayılar (Numeric Types)

Sayısal verileri tutmak için kullanılırlar. Temel sayısal tipler int (tam sayı) ve float (ondalıklı sayı)’tır.

Tam Sayılar (Integers)

Pozitif veya negatif tam sayılardır.

a = 5
b = 3
toplam = a + b
print(f"{a} + {b} = {toplam}")

## 5 + 3 = 8

Ondalıklı Sayılar (Floats)

Ondalık noktası içeren sayılardır.

d = 0.2
e = 0.3
f = d + e
print(f"f= {f}")

## f= 0.5

Sayısal Tiplerin Birlikte Kullanımı

Bir int ve bir float ile yapılan matematiksel işlemin sonucu her zaman float olur.

g = 1
h = 2.0
j = g + h
print(f"j= {j}, tipi: {type(j)}")

## j= 3.0, tipi: <class 'float'>

Okunabilirlik için Alt Çizgi

Büyük sayıları yazarken, okunabilirliği artırmak için basamakları ayırmada alt çizgi (_) kullanılabilir. Python bu karakterleri görmezden gelir.

buyuk_sayi = 14_000_000_000
print(f"Sayı= {buyuk_sayi}")

## Sayı= 14000000000

Boole İfadeleri (Booleans)

Sadece iki değer alabilen bir veri tipidir: True (Doğru) veya False (Yanlış). Genellikle koşullu durumlarda kullanılır.

is_active = True
has_permission = False
print(f"Kullanıcı aktif mi? {is_active}")

## Kullanıcı aktif mi? True

LİSTELERE GİRİŞ

Listeler, birden çok öğeyi tek bir değişken altında toplamanızı sağlayan veri yapılarıdır. Python’da listeler en çok kullanılan veri tiplerinden biridir çünkü oldukça esnektirler.

Sıralıdır (Ordered): Listeye eklediğiniz elemanlar, eklediğiniz sırada kalır. Her elemanın belirli bir konumu (indeksi) vardır.
Değiştirilebilirdir (Mutable): Bir liste oluşturduktan sonra elemanlarını değiştirebilir, yeni elemanlar ekleyebilir veya mevcut elemanları silebilirsiniz.
Farklı Veri Tiplerini Barındırabilir: Bir listenin içinde string, tam sayı, float gibi farklı veri tiplerinden elemanlar aynı anda bulunabilir.

Bir Liste Tanımlamak

Listeler, köşeli parantezler [] içine, elemanları virgülle ayırarak tanımlanır

cars = ["vw","audi","mercedes","BMW","aston martin","bentley","cadillac"]
print(cars)

## ['vw', 'audi', 'mercedes', 'BMW', 'aston martin', 'bentley', 'cadillac']

Bir Listedeki Elemanlara Erişmek

Listedeki herhangi bir elemana, o elemanın indeks numarasını kullanarak erişebilirsiniz. Python’da indeksleme 0’dan başlar. Yani listenin ilk elemanının indeksi 0’dır.

Ayrıca listenin sonundan elemanlara erişmek için negatif indeksleme de kullanılabilir. -1 son elemanı, -2 sondan ikinci elemanı ifade eder.

print(cars[0])  # İlk eleman

## vw

print(cars[-1])  # Son eleman

## cadillac

# title, upper, lower örnekleri
print(cars[0].title())

## Vw

print(cars[-1].upper())

## CADILLAC

print(cars[-2].upper())

## BENTLEY

print(cars[3].lower())

## bmw

# Bir listeden değer kullanma
message = f"Benim en çok sevdiğim araba markası {cars[4].title()}'dir."
print(message)

## Benim en çok sevdiğim araba markası Aston Martin'dir.

Bir eleman Değiştirme, ekleme, silme

Listeler değiştirilebilir olduğu için içerikleri üzerinde tam kontrole sahibiz.

append() Metodu: Listenin sonuna yeni bir eleman ekler.
insert() Metodu: Belirttiğiniz indekse yeni bir eleman ekler ve diğer elemanları sağa kaydırır.
del İfadesi: Belirtilen indeksteki elemanı kalıcı olarak siler. Silinen elemana sonradan erişemezsiniz.
pop() Metodu: Bir elemanı listeden siler ve sildiği bu elemanı kullanmanıza olanak tanır. Eğer indeks belirtmezseniz, listenin sonundaki elemanı siler.
remove() Metodu: Silmek istediğiniz elemanın indeksini değil, değerini bilirken kullanılır. Bu metot, belirttiğiniz değerin listede karşılaştığı ilk örneğini siler.

cars[0] = "toyota" # Eleman değişimi
print(cars)

## ['toyota', 'audi', 'mercedes', 'BMW', 'aston martin', 'bentley', 'cadillac']

cars.append("suzuki") # Eleman sona eklenir
print(cars)

## ['toyota', 'audi', 'mercedes', 'BMW', 'aston martin', 'bentley', 'cadillac', 'suzuki']

cars.insert(2,"Anadol") # Eleman araya eklenir
print(cars)

## ['toyota', 'audi', 'Anadol', 'mercedes', 'BMW', 'aston martin', 'bentley', 'cadillac', 'suzuki']

del cars[2] # Eleman kalıcı olarak silinir.
print(cars)

## ['toyota', 'audi', 'mercedes', 'BMW', 'aston martin', 'bentley', 'cadillac', 'suzuki']

# pop() örneği
son_eleman = cars.pop() # Sondan eleman kalıcı silinir o yüzden değişkene atandı.
message = f"Listedeki son arabam {son_eleman.title()}'dır."
print(message)

## Listedeki son arabam Suzuki'dır.

print(cars)

## ['toyota', 'audi', 'mercedes', 'BMW', 'aston martin', 'bentley', 'cadillac']

# pop(index) örneği
cars = ["vw","audi","mercedes","BMW","aston martin","bentley","cadillac"]
ara_eleman = cars.pop(2)
ikinci_message = f"Geçenlerde sattığım {ara_eleman.title()} çok ucuza gitti"
print(ikinci_message)

## Geçenlerde sattığım Mercedes çok ucuza gitti

print(cars)

## ['vw', 'audi', 'BMW', 'aston martin', 'bentley', 'cadillac']

# remove() örneği
cars = ["vw","audi","mercedes","BMW","aston martin","bentley","cadillac"]
remove_ornek = "bentley"
cars.remove(remove_ornek)
pahali_araba_mesaj = f"Sattığım {remove_ornek.title()} masraf çıkaran pahalı bir arabaydı."
print(pahali_araba_mesaj)

## Sattığım Bentley masraf çıkaran pahalı bir arabaydı.

Listeleri Sıralama

Python, listelerdeki elemanları sıralamak için iki kullanışlı yöntem sunar: listenin kendi sort() metodu ve genel amaçlı sorted() fonksiyonu. İkisi de aynı işi yapıyor gibi görünse de aralarında çok temel ve önemli bir fark vardır: biri listeyi kalıcı olarak değiştirirken, diğeri orijinal listeye dokunmadan sıralanmış yeni bir kopya oluşturur.

Listenin Kalıcı Olarak Sıralanması: sort() Metodu

sort() metodu, bir listenin kendi üzerinde çalışır ve elemanlarını kalıcı olarak sıralar. Bu metot çağrıldıktan sonra listenin orijinal sırası kaybolur. sort() metodu geriye yeni bir liste döndürmez (teknik olarak None döndürür), doğrudan mevcut listeyi düzenler.

Varsayılan olarak alfabetik (A’dan Z’ye) veya sayısal (küçükten büyüğe) sıralama yapar.

meyvalar = ["elma","armut","çilek","portakal","mandalina","üzüm","ayva","greyfurt"]
print(meyvalar)

## ['elma', 'armut', 'çilek', 'portakal', 'mandalina', 'üzüm', 'ayva', 'greyfurt']

meyvalar.sort()
print(meyvalar)

## ['armut', 'ayva', 'elma', 'greyfurt', 'mandalina', 'portakal', 'çilek', 'üzüm']

meyvalar.sort(reverse=True)
print(meyvalar)

## ['üzüm', 'çilek', 'portakal', 'mandalina', 'greyfurt', 'elma', 'ayva', 'armut']

Listenin Geçici Olarak Sıralanması: sorted() Fonksiyonu

sorted() fonksiyonu, herhangi bir sıralanabilir nesne (liste, demet vb.) alır ve bu nesnenin elemanlarını içeren yeni ve sıralanmış bir liste döndürür. En önemli özelliği, orijinal listenin sırasını asla değiştirmemesidir.

Bu, orijinal veriyi korumak istediğinizde veya sadece sıralanmış bir kopyaya ihtiyaç duyduğunuzda son derece kullanışlıdır.

# sorted() geçici sıralama
meyvalar = ["elma","armut","çilek","portakal","mandalina","üzüm","ayva","greyfurt"]
print(meyvalar)

## ['elma', 'armut', 'çilek', 'portakal', 'mandalina', 'üzüm', 'ayva', 'greyfurt']

print("Geçici sıralanmış liste:")

## Geçici sıralanmış liste:

print(sorted(meyvalar))

## ['armut', 'ayva', 'elma', 'greyfurt', 'mandalina', 'portakal', 'çilek', 'üzüm']

print("Sıralamadan önceki liste korunuyor")

## Sıralamadan önceki liste korunuyor

print(meyvalar)

## ['elma', 'armut', 'çilek', 'portakal', 'mandalina', 'üzüm', 'ayva', 'greyfurt']

# sorted(reverse=True)
print(sorted(meyvalar, reverse=True))

## ['üzüm', 'çilek', 'portakal', 'mandalina', 'greyfurt', 'elma', 'ayva', 'armut']

print(meyvalar)

## ['elma', 'armut', 'çilek', 'portakal', 'mandalina', 'üzüm', 'ayva', 'greyfurt']

Özet: `sort()` ve `sorted()` Arasındaki Farklar

Özellik	`sort()` Metodu	`sorted()` Fonksiyonu
Uygulanma Şekli	Bir liste üzerinden çağrılır: `liste.sort()`	Bir listeyi parametre olarak alır: `sorted(liste)`
Etkisi	Orijinal listeyi kalıcı olarak değiştirir.	Orijinal listeyi değiştirmez.
Dönüş Değeri	Hiçbir şey (`None`) döndürmez.	Sıralanmış yeni bir liste döndürür.
Kullanım Amacı	Listenin orijinal sırasına bir daha ihtiyaç duyulmadığında.	Orijinal sıranın korunması gerektiğinde veya sıralı bir kopyaya ihtiyaç duyulduğunda.

Listenin Sırasını Ters Çevirme: reverse()

Sıralama ile karıştırılmaması gereken bir diğer metot reverse() metodudur. Bu metot, listeyi alfabetik veya sayısal olarak sıralamaz; sadece elemanların mevcut sırasını kalıcı olarak baştan sona ters çevirir.

# reverse() ile ters çevirme
meyvalar = ["elma","armut","çilek","portakal","mandalina","üzüm","ayva","greyfurt"]
meyvalar.reverse()
print(meyvalar)

## ['greyfurt', 'ayva', 'üzüm', 'mandalina', 'portakal', 'çilek', 'armut', 'elma']

meyvalar.reverse()
print(meyvalar)

## ['elma', 'armut', 'çilek', 'portakal', 'mandalina', 'üzüm', 'ayva', 'greyfurt']

Listenin Uzunluğunu Bulma: len()

Bir listede kaç eleman olduğunu bulmak için len() fonksiyonu kullanılır. Bu fonksiyon, listenin eleman sayısını bir tam sayı olarak döndürür. Unutmayın, indeksleme 0’dan başlarken, len() toplam eleman sayısını verir.

# len() ile uzunluk bulma
meyvalar = ["elma","armut","çilek","portakal","mandalina","üzüm","ayva","greyfurt"]
print(f"Meyvalar listesinde {len(meyvalar)} eleman bulunmaktadır.")

## Meyvalar listesinde 8 eleman bulunmaktadır.

#Önemli Not: Sonuç 8 gelir. İndeksleme 0'dan 7'ye yapılır.

LİSTELERLE ÇALIŞMAK

Listeleri oluşturmayı, elemanlarına erişmeyi ve değiştirmeyi öğrendik. Şimdi ise listelerdeki verileri daha etkili bir şekilde işlemek için döngüler, dilimleme ve kopyalama gibi güçlü teknikleri inceleyeceğiz.

Listenin Tamamı Üzerinden Döngü Kurmak

Genellikle bir listedeki her bir elemanla aynı işlemi yapmak isteriz. Örneğin, bir listedeki tüm isimleri ekrana yazdırmak veya tüm sayıları ikiyle çarpmak gibi. Bu tür tekrarlı görevler için for döngüsü kullanılır.

for döngüsü, listedeki her bir elemanı sırayla geçici bir değişkene atar ve ardından bu değişkenle belirttiğiniz işlemleri yapar.

# Beatles üyelerinden oluşan bir liste
beatles = ["john lennon", "paul mccartney", "george harrison", "ringo starr"]

# 'beatles' listesindeki her bir 'uye' için aşağıdaki kod bloğunu çalıştır.
for uye in beatles:
  # Her üyenin ismini title() metoduyla düzenleyip yazdır.
  print(f"{uye.title()}, harika bir müzisyendi.")

## John Lennon, harika bir müzisyendi.
## Paul Mccartney, harika bir müzisyendi.
## George Harrison, harika bir müzisyendi.
## Ringo Starr, harika bir müzisyendi.

# Döngü bittiğinde (listede eleman kalmadığında) bu satır çalışır.
print("\nTüm Beatles üyelerini çok seviyoruz!")

## 
## Tüm Beatles üyelerini çok seviyoruz!

Bu yapı, “beatles listesindeki her bir üye için, o üyenin adını yazdır” şeklinde okunabilir. uye değişkeni, döngünün her adımında listedeki bir sonraki elemanın değerini alır.

Sayısal Listeler Yapmak

Sıkça belirli bir aralıktaki sayılardan oluşan listeler oluşturmamız gerekir. Python, bu işlemi range() fonksiyonu ile çok kolay hale getirir.

range() Fonksiyonunu Kullanmak

range() fonksiyonu, belirli bir aralıkta sayı dizisi oluşturur. En önemli özelliği, belirttiğiniz bitiş sayısına kadar gitmesi, ancak o sayıyı dahil etmemesidir.

for i in range(1,6):
  print(i)

## 1
## 2
## 3
## 4
## 5

# Farklı bir yazım şekli
print([ i for i in range(1,6)])

## [1, 2, 3, 4, 5]

Sayı Listesi Oluşturmak İçin range() Komutunu Kullanmak

range() tarafından oluşturulan sayı dizisini doğrudan bir listeye dönüştürmek için list() fonksiyonunu kullanırız.

sayilar = list(range(1,11))
print(sayilar)

## [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for i in sayilar:
  print(i,end = " ")

## 1 2 3 4 5 6 7 8 9 10

sayilar2 = list(range(2,13,2))
print(sayilar2)

## [2, 4, 6, 8, 10, 12]

kareler = []
for sayi in sayilar2:
  kareler.append(sayi**2)
print(kareler)

## [4, 16, 36, 64, 100, 144]

Bir Sayı Listesinde Min, Max ve Toplam Bulma

Python, sayısal listelerle çalışmayı kolaylaştıran bazı yerleşik fonksiyonlara sahiptir:

min(): Listenin en küçük elemanını bulur.
max(): Listenin en büyük elemanını bulur.
sum(): Listedeki tüm elemanları toplar.

sayilar3 = list(range(5,101,5))
print("Minumum Sayı= ",min(sayilar3))

## Minumum Sayı=  5

print("Maksimum Sayı= ",max(sayilar3))

## Maksimum Sayı=  100

print("Toplam = ",sum(sayilar3))

## Toplam =  1050

Bir Listenin Bir Kısmı İle Çalışmak

Bir Listeyi Dilimlemek

Bazen listenin tamamıyla değil, sadece belirli bir alt kümesiyle çalışmak isteriz. Bir listenin belirli bir bölümünü seçme işlemine dilimleme (slicing) denir. Dilimleme yaparken orijinal liste değişmez; yeni bir alt liste oluşturulur.

Dilimleme için liste[başlangıç_indeksi:bitiş_indeksi] sözdizimi kullanılır. range() fonksiyonunda olduğu gibi, bitiş indeksi sonuca dahil edilmez.

oyuncular = ["bruce willis","sharon stone","sylvester stallone","daniel craig","roger moore"]

print(oyuncular[0:3]) # 0, 1 ve 2. indisteki elemanları al.

## ['bruce willis', 'sharon stone', 'sylvester stallone']

print(oyuncular[1:4]) # 1, 2 ve 3. indisteki elemanları al.

## ['sharon stone', 'sylvester stallone', 'daniel craig']

# Başlangıç indeksi belirtilmezse 0'dan başlar.
print(oyuncular[:4]) # Baştan 4. indekse kadar al (4. dahil değil).

## ['bruce willis', 'sharon stone', 'sylvester stallone', 'daniel craig']

# Bitiş indeksi belirtilmezse listenin sonuna kadar gider.
print(oyuncular[2:]) # 2. indisten başlayarak sona kadar tüm elemanları al.

## ['sylvester stallone', 'daniel craig', 'roger moore']

# Negatif indeksleme ile sondan dilimleme yapabiliriz.
print(oyuncular[-3:]) # Son 3 elemanı al.

## ['sylvester stallone', 'daniel craig', 'roger moore']

# Listenin son elemananı yazdırmak
print(oyuncular[-1])

## roger moore

# Listeyi tersten yazdırmak
print(oyuncular[::-1])

## ['roger moore', 'daniel craig', 'sylvester stallone', 'sharon stone', 'bruce willis']

Dilimler Üzerinden Döngü Kurma

Bir listenin sadece bir kısmı üzerinde döngü kurmak için for döngüsünde listenin kendisi yerine bir dilimini kullanabilirsiniz.

sebzeler = ["ispanak","semizotu","kabak","bakla","fasulye","biber","pırasa","domates"]

print(sebzeler)

## ['ispanak', 'semizotu', 'kabak', 'bakla', 'fasulye', 'biber', 'pırasa', 'domates']

for sebze in sebzeler[1:4]:
  print(sebze.title())

## Semizotu
## Kabak
## Bakla

Bir Listeyi Kopyalamak (Doğru Yöntemdir)

Bazen mevcut bir listenin kopyasını oluşturup, orijinal listeyi bozmadan bu kopya üzerinde çalışmak isteriz. Burada dikkat edilmesi gereken çok önemli bir nokta vardır: yeni_liste = eski_liste şeklinde bir atama yapmak, listeyi kopyalamaz. Bu işlem, bellekteki aynı listeye işaret eden ikinci bir etiket (referans) oluşturur. Dolayısıyla, bu değişkenlerden birinde yapılan değişiklik diğerini de doğrudan etkiler.

Bir listenin bağımsız bir kopyasını oluşturmak için iki doğru yöntem vardır:

Yöntem 1: Dilimleme (Slicing) Kullanarak Kopyalama

Bir listeyi doğru şekilde kopyalamanın klasik yolu, baştan sona bir dilim oluşturmaktır: yeni_liste = eski_liste[:]. Bu işlem, orijinal listenin tüm elemanlarını içeren yeni ve bağımsız bir liste oluşturur.

fast_foods = ["hamburger", "sosisli", "lahmacun", "pide"]

favorilerim = fast_foods[:] # fast_foods listesinin bir kopyasını oluştur.

# Şimdi iki liste birbirinden bağımsızdır. Orijinal listeye yapılan ekleme kopyayı etkilemez.
fast_foods.append("döner")

print(f"Orijinal Liste: {fast_foods}")

## Orijinal Liste: ['hamburger', 'sosisli', 'lahmacun', 'pide', 'döner']

print(f"Kopya Liste (Değişmedi): {favorilerim}")

## Kopya Liste (Değişmedi): ['hamburger', 'sosisli', 'lahmacun', 'pide']

Yöntem 2: copy() Metodunu Kullanarak Kopyalama

Listeyi kopyalamanın daha modern, açık ve okunabilir yolu, listenin kendi copy() metodunu kullanmaktır. Bu metot, [:] dilimlemesi ile tamamen aynı işi yapar: listenin yeni ve bağımsız bir kopyasını oluşturur. Kodun niyetini daha net belirttiği için genellikle bu yöntemin kullanılması tavsiye edilir.

icecekler = ["kola", "ayran", "limonata"]
yedek_icecekler = icecekler.copy() # icecekler listesinin bir kopyasını oluştur.

# Kopyada yapılan değişiklik orijinali etkilemez.
yedek_icecekler.append("soda")

print(f"Orijinal İçecekler: {icecekler}")

## Orijinal İçecekler: ['kola', 'ayran', 'limonata']

print(f"Yedek İçecekler (Değişti): {yedek_icecekler}")

## Yedek İçecekler (Değişti): ['kola', 'ayran', 'limonata', 'soda']

Önemli Not: Her iki yöntem de ([:] ve copy()) yüzeysel kopya (shallow copy) oluşturur. Bu, iç içe listeler gibi daha karmaşık veri yapılarında önem kazanır, ancak basit listeler için bu iki yöntem tamamen güvenilirdir.

DİKKAT Yanlış Yöntem (Referans Ataması) DİKKAT

Aşağıdaki örnek, kopyalama işleminin neden yeni_liste = eski_liste şeklinde yapılmaması gerektiğini göstermektedir. DİKKAT DİKKAT DİKKAT

print("\n--- Yanlış Kopyalama Örneği ---")

## 
## --- Yanlış Kopyalama Örneği ---

orijinal_liste = [1, 2, 3]
hatali_kopya = orijinal_liste # Bu bir kopyalama değil, referans atamasıdır.

hatali_kopya.append(99) # Sözde 'kopyaya' bir eleman ekliyoruz...

# Sonucu görelim:
print(f"Hatalı Kopya: {hatali_kopya}")

## Hatalı Kopya: [1, 2, 3, 99]

print(f"Orijinal Liste: {orijinal_liste}") # ...ama orijinal liste de değişti!

## Orijinal Liste: [1, 2, 3, 99]

Not: Lütfen bu hataya düşmeyiniz DİKKAT DİKKAT DİKKAT

Demetler (Tuples)

Python’da listelere çok benzeyen ama önemli bir farkı olan bir başka veri yapısı daha vardır: Demetler (Tuples). Demetler de listeler gibi sıralı bir öğe koleksiyonudur. Ancak aralarındaki en temel ve en önemli fark şudur:

Listeler değiştirilebilirken (mutable), demetler değiştirilemezdir (immutable).

Bu, bir demet oluşturulduktan sonra, tıpkı bir string’de olduğu gibi, içindeki elemanları değiştiremeyeceğiniz, silemeyeceğiniz veya yeni eleman ekleyemeyeceğiniz anlamına gelir. Değişmemesi gereken bir veri koleksiyonunuz olduğunda demetler mükemmel bir seçimdir.

Bir Demeti Tanımlamak

Demetler, listelerdeki köşeli parantezler [] yerine, normal parantezler () kullanılarak tanımlanır. Elemanlara erişim ise listelerle tamamen aynı şekilde, indeks numaraları kullanılarak yapılır.

# Genişlik ve yükseklik gibi değişmemesi gereken değerleri bir demette saklayabiliriz.
boyutlar = (200, 50)
print(boyutlar[0])

## 200

print(boyutlar[1])

## 50

print(f"Orijinal boyutlar: {boyutlar[0]}x{boyutlar[1]}")

## Orijinal boyutlar: 200x50

Demetlerin Değiştirilemezliği (Immutability)

Bir demetin elemanını değiştirmeye çalıştığınızda Python size bir hata (TypeError) verecektir. Bu özellik, programınızda yanlışlıkla değiştirilmemesi gereken değerleri korumanızı sağlar.

boyutlar = (200, 50)
# boyutlar[0] = 250 # Bu kod TypeError hatası verir: 'tuple' object does not support item assignment. O yüzden başına # kondu kaldırıp çalıştırır iseniz hata alırsınız.

Tek Elemanlı Bir Demet Tanımlamak

Tek elemanlı bir demet tanımlarken dikkatli olmak gerekir. Eğer parantez içine tek bir değer yazarsanız, Python bunu bir demet olarak değil, o değerin kendisi olarak algılar. Bir değerin tek elemanlı bir demet olduğunu belirtmek için, elemandan sonra bir virgül koymanız gerekir.

# Bu bir demet DEĞİLDİR. Python bunu bir tam sayı olarak görür.
yanlis_demet = (4)
print(f"Değer: {yanlis_demet}, Tipi: {type(yanlis_demet)}")

## Değer: 4, Tipi: <class 'int'>

# Bu DOĞRU bir tek elemanlı demettir. Sondaki virgüle dikkat edin.
dogru_demet = (4,)
print(f"Değer: {dogru_demet}, Tipi: {type(dogru_demet)}")

## Değer: (4,), Tipi: <class 'tuple'>

Bir Demetteki Bütün Değerler Üzerinden Döngü Kurmak

Tıpkı listelerde olduğu gibi, bir demetin tüm elemanları üzerinde for döngüsü kullanarak gezinebilirsiniz.

boyutlar = (200, 50, 100, 30)

print("Demetin elemanları:")

## Demetin elemanları:

for boyut in boyutlar:
  print(boyut)

## 200
## 50
## 100
## 30

Bir Demetin Tamamının Üzerine Yazmak (Yeniden Tanımlamak)

Demetin içindeki elemanları değiştiremesek de, demeti tutan değişkenin tamamına yeni bir demet atayabiliriz. Bu, demeti “değiştirmek” anlamına gelmez; daha ziyade, değişkenin artık eski demeti değil, tamamen yeni bir demeti göstermesi anlamına gelir.

demet = (10, 20, 30, 40)

print("Orijinal demet:")

## Orijinal demet:

for i in demet:
  print(i, end=" ") # end=" " parametresi, çıktıların aynı satırda kalmasını sağlar.

## 10 20 30 40

# 'demet' değişkenine tamamen yeni bir demet atıyoruz.
demet = (50, 60, 70, 80)

print("\n\nYeni demet:")

## 
## 
## Yeni demet:

for i in demet:
  print(i, end=" ")

## 50 60 70 80

Demetleri Neden ve Ne Zaman Kullanırız?

Listeler varken neden değiştirilemez demetlere ihtiyaç duyalım?

Veri Bütünlüğü: Programınızda sabit kalması gereken ve yanlışlıkla bile değiştirilmemesi gereken veriler için demetler idealdir (örneğin, RGB renk kodları, coğrafi koordinatlar, program ayarları).

Performans: Demetler, listelerden teknik olarak biraz daha hızlıdır ve daha az bellek kullanır. Bu fark küçük veri setlerinde önemsiz olsa da, çok büyük veri setlerinde bir avantaj olabilir.

Sözlük Anahtarları: (Sözlükler konusunda göreceğimiz gibi) Değiştirilemez oldukları için demetler, sözlüklerde anahtar olarak kullanılabilirken, listeler kullanılamaz.

IF İFADELERİ

Şu ana kadar yazdığımız kodlar, yukarıdan aşağıya doğru her bir satırı sırasıyla çalıştırıyordu. Ancak gerçek dünya uygulamalarında, programların belirli koşulları kontrol etmesi ve bu koşulların sonucuna göre farklı yollar izlemesi gerekir. Örneğin, bir kullanıcı doğru şifreyi girerse giriş yapmasına izin verilir, yanlış girerse bir uyarı gösterilir. İşte bu tür karar mekanizmalarını if ifadeleri ile kurarız.

if ifadesi, bir koşulun True (Doğru) olup olmadığını kontrol eder. Eğer koşul doğru ise, if bloğunun altındaki girintili kod çalıştırılır. Eğer koşul False (Yanlış) ise, o blok atlanır.

Basit Bir Örnek

isimler = ["ali","veli","fatma","ayse","orhan","zeynep","fatih","gamze","elif"]

for isim in isimler:
  if isim =="ayse":
    print("aranan isim bulundu :",isim)

## aranan isim bulundu : ayse

Koşullu İfadeler

Bir if ifadesinin kalbinde, sonucu True veya False olan bir ifade yer alır. Bu ifadelere koşullu test denir.

Eşitliği Kontrol Etmek

Bir değerin başka bir değere eşit olup olmadığını kontrol etmek için çift eşittir (==) işareti kullanılır.

Önemli: Tek eşittir (=) atama operatörüdür, çift eşittir (==) ise bir karşılaştırma (eşitlik kontrolü) operatörüdür. Bu ikisi sıkça karıştırılır.

for isim in isimler:
  if isim =="ayse":  # eşitlik kontrol için == konmalı dikkat
    print("aranan isim bulundu :",isim)

## aranan isim bulundu : ayse

Eşitsizliği Kontrol Etmek

İki değerin birbirine eşit olmadığını kontrol etmek için ünlem ve eşittir (!=) işaretleri kullanılır.

for isim in isimler:
  if isim != "ismail":  # eşitsizlik kontrol için != konmalı dikkat
    print("bir başka mekana bakayım.")

## bir başka mekana bakayım.
## bir başka mekana bakayım.
## bir başka mekana bakayım.
## bir başka mekana bakayım.
## bir başka mekana bakayım.
## bir başka mekana bakayım.
## bir başka mekana bakayım.
## bir başka mekana bakayım.
## bir başka mekana bakayım.

Sayısal Karşılaştırmalar

Sayıları karşılaştırmak için standart matematiksel operatörler kullanılır:

> (büyüktür)
< (küçüktür)
>= (büyüktür veya eşittir)
<= (küçüktür veya eşittir)

Birden fazla koşulu aynı anda kontrol etmek için and ve or anahtar kelimeleri kullanılır:

and: Her iki koşul da True ise True döner.
or: Koşullardan en az biri True ise True döner.

a = 19
a > 10

## True

a < 11

## False

a >=19

## True

a <=19

## True

a = 10
b = 20

a < 5 and b > 15

## False

a < 15 or b > 15

## True

Bir Değerin Bir Listede Olduğunu Kontrol Etmek

in anahtar kelimesi, bir değerin bir listenin içinde olup olmadığını kontrol eder.

isimler = ["ali", "veli", "fatma", "ayşe"]
print('veli' in isimler)     # True

## True

print('ismail' in isimler)  # False

## False

Bir Değerin Bir Listede Olmadığını Kontrol Etmek

not in anahtar kelimesi, bir değerin listenin içinde olmadığını doğrulamak için kullanılır.

yasakli_kullanicilar = ['ahmet', 'mehmet', 'can']
kullanici = 'zeynep'

if kullanici not in yasakli_kullanicilar:
  print(f"{kullanici.title()}, siteye hoş geldiniz!")

## Zeynep, siteye hoş geldiniz!

Boole Deyimleri

aktif = True
pasif = False

if İfadeleri

Basit if İfadeleri

En temel if yapısı, tek bir koşulu kontrol eder ve doğruysa bir eylem gerçekleştirir. if satırından sonra gelen ve çalıştırılacak olan kod bloğu mutlaka girintili (indented) olmalıdır.

yas = 19

if yas >=18:
  print("Yaşınız ehliyet almaya müsaittir.")
  print("Arzu ederseniz başvurunuzu başlatıyorum.")

## Yaşınız ehliyet almaya müsaittir.
## Arzu ederseniz başvurunuzu başlatıyorum.

if - else İfadeleri

Bazen bir koşul doğru olduğunda bir şey yapmak, doğru olmadığında ise başka bir şey yapmak isteriz. Bu durumda if-else yapısı kullanılır.

yas = 17

if yas >= 18:
  print("Ehliyet alabilirsiniz.")
  
else:
  print("Üzgünüz, yaşınız ehliyet almak için uygun değil.")

## Üzgünüz, yaşınız ehliyet almak için uygun değil.

if - elif - else Zinciri

İkiden fazla olası durum olduğunda, if-elif-else zincirini kullanırız. Python, zincirdeki her koşulu sırayla test eder. Doğru olan ilk koşulu bulduğu anda o bloğu çalıştırır ve zincirin geri kalanını atlar.

# Örnek Vaka: Sinema Bilet Fiyatları
# 4 yaş altı ücretsiz.
# 4 ile 18 yaş arası 25 TL.
# 18 yaş ve üstü 40 TL.
yas = 12

if yas < 4:
  fiyat = 0
elif yas < 18:
  fiyat = 25
else:
  fiyat = 40

print(f"Bilet ücretiniz: {fiyat} TL")

## Bilet ücretiniz: 25 TL

Birden Fazla `if` Bloğu Kullanmak (elif’ten Farkı)

elif zincirinde Python doğru olan ilk koşulu bulduğu anda testi durdurur. Ancak bazen birden çok koşulun hepsini kontrol etmek isteyebilirsiniz. Bu durumda, bağımsız if blokları kullanırsınız.

istenenler = ["foto", "dilekce", "rapor", "odeme"]

if "foto" in istenenler:
  print("Fotoğraflar hazır.")

## Fotoğraflar hazır.

  
if "dilekce" in istenenler:
  print("Dilekçeniz hazır.")

## Dilekçeniz hazır.

  
if "rapor" in istenenler:
  print("Raporunuz hazır.")

## Raporunuz hazır.

print("\nBaşvuru tamamlandı.")

## 
## Başvuru tamamlandı.

Listelerle if İfadeleri Kullanmak

if ifadeleri, listelerle birlikte kullanıldığında çok güçlü hale gelir.

Özel Öğeleri Kontrol Etmek

Bir döngü içinde belirli bir elemanla karşılaştığınızda farklı bir işlem yapmak için if kullanabilirsiniz.

siparis_pizza = ["mantar", "biber", "bol peynir"]

for malzeme in siparis_pizza:
  if malzeme == "biber":
    print(f"Üzgünüz, elimizde {malzeme} kalmamış.")
  else:
    print(f"{malzeme} ekleniyor.")

## mantar ekleniyor.
## Üzgünüz, elimizde biber kalmamış.
## bol peynir ekleniyor.

print("\nPizzanız hazır!")

## 
## Pizzanız hazır!

Bir Listenin Boş Olmadığını Kontrol Etmek

Bir programda, üzerinde işlem yapmadan önce bir listenin boş olup olmadığını kontrol etmek iyi bir pratiktir. Python, if liste: şeklindeki bir ifadede, liste boşsa False, doluysa True olarak değerlendirir.

siparisler = []

if siparisler: # Liste boş olduğu için bu koşul False döner.
  
  for siparis in siparisler:
    print(f"{siparis} hazırlanıyor.")
    
  print("Siparişiniz hazır.")
  
else:
  print("Sepetiniz boş. Düz pizza mı istemiştiniz?")

## Sepetiniz boş. Düz pizza mı istemiştiniz?

Çoklu Listeler Kullanmak

Bir listedeki elemanların başka bir listede mevcut olup olmadığını kontrol edebiliriz.

stoktaki_malzemeler = ["mantar", "zeytin", "biber", "pepperoni", "ananas"]
musteri_istekleri = ["mantar", "patates kızartması", "zeytin"]

for istek in musteri_istekleri:
  if istek in stoktaki_malzemeler:
    print(f"{istek.title()} pizzanıza ekleniyor.")
  else:
    print(f"Üzgünüz, şu an elimizde {istek} mevcut değil.")

## Mantar pizzanıza ekleniyor.
## Üzgünüz, şu an elimizde patates kızartması mevcut değil.
## Zeytin pizzanıza ekleniyor.

print("\nPizzanız hazır!")

## 
## Pizzanız hazır!

SÖZLÜKLER

Sözlükler, birbiriyle ilişkili verileri anahtar-değer (key-value) çiftleri olarak saklamanızı sağlayan veri yapılarıdır. Listelerde elemanlara sayısal bir indeksle (0, 1, 2, …) ulaşırken, sözlüklerde her bir değere, onunla ilişkilendirilmiş benzersiz bir anahtar (key) aracılığıyla ulaşırız.

Değiştirilebilirdir (Mutable): Oluşturulduktan sonra yeni anahtar-değer çiftleri ekleyebilir, mevcut olanları değiştirebilir veya silebilirsiniz.
Sırasızdır (Unordered - Eski Python Sürümlerinde): Python 3.7 ve sonrası sürümlerde sözlükler ekleme sırasını korur hale gelmiştir. Ancak genel olarak sözlüklere indeks numarasıyla değil, anahtarlarla erişildiği unutulmamalıdır.
Benzersiz Anahtarlar: Bir sözlükte her anahtar yalnızca bir kez bulunabilir.

Basit Bir Sözlük

Sözlükler, süslü parantezler {} içine, anahtar: değer formatındaki çiftlerin virgülle ayrılmasıyla tanımlanır.

# Bir uzaylının rengini ve puanını saklayan basit bir sözlük
alien_0 = {"renk": "yeşil", "puan": 5}

print(f"Uzaylının rengi: {alien_0['renk']}")

## Uzaylının rengi: yeşil

print(f"Kazanılan puan: {alien_0['puan']}")

## Kazanılan puan: 5

Yeni Anahtar - Değer Çiftleri Eklemek

Sözlükler dinamiktir. Program çalışırken onlara kolayca yeni çiftler ekleyebilirsiniz.

alien_0 = {"renk": "yeşil", "puan": 5}
print(f"Orijinal sözlük: {alien_0}")

## Orijinal sözlük: {'renk': 'yeşil', 'puan': 5}

# Yeni anahtar-değer çiftleri ekleniyor
alien_0["x_pozisyon"] = 0
alien_0["y_pozisyon"] = 25
print(f"Genişletilmiş sözlük: {alien_0}")

## Genişletilmiş sözlük: {'renk': 'yeşil', 'puan': 5, 'x_pozisyon': 0, 'y_pozisyon': 25}

Boş Bir Sözlükle Başlamak

Bazen bir sözlüğü en baştan boş olarak oluşturup, programın akışına göre doldurmak daha mantıklıdır.

alien_0 = {}
alien_0["renk"] = "yeşil"
alien_0["puan"] = 5
print(alien_0)

## {'renk': 'yeşil', 'puan': 5}

Bir Sözlükteki Değerleri Değiştirmek

Mevcut bir anahtarın değerini güncellemek için, o anahtara yeni bir değer atamanız yeterlidir.

alien_0 = {"renk": "yeşil"}
print(f"Uzaylının rengi {alien_0['renk']}.")

## Uzaylının rengi yeşil.

alien_0["renk"] = "sarı"
print(f"Uzaylının yeni rengi artık {alien_0['renk']}.")

## Uzaylının yeni rengi artık sarı.

Anahtar - Değer Çiftlerini Silmek

Bir sözlükten bir çifti kalıcı olarak silmek için del ifadesi kullanılır.

alien_0 = {"renk": "yeşil", "puan": 5}
print(f"Silme öncesi: {alien_0}")

## Silme öncesi: {'renk': 'yeşil', 'puan': 5}

del alien_0["puan"]
print(f"Silme sonrası: {alien_0}")

## Silme sonrası: {'renk': 'yeşil'}

Benzer Nesnelerin Sözlüğü

ulkeler = {"turkiye":"ankara","yunanistan":"atina","rusya":"moskova","iran":"tahran"}
baskent = ulkeler["turkiye"]
print(f"Türkiye'nin başkenti {baskent.title()}'dır.")

## Türkiye'nin başkenti Ankara'dır.

Değerleri Erişmek İçin get() Komutunu Kullanmak

Bir anahtarı kullanarak değere erişmeye çalıştığınızda, eğer o anahtar sözlükte yoksa Python bir KeyError hatası verir. Bu, programınızın çökmesine neden olabilir.

Bu tür hatalardan kaçınmak için get() metodu kullanılır. get(), aranan anahtar sözlükte varsa onun değerini döndürür. Eğer anahtar yoksa, hata vermek yerine, belirteceğiniz varsayılan bir değeri (veya hiçbir şey belirtmezseniz None değerini) döndürür.

alien_0 = {"renk": "yeşil", "hız": "yavaş"}

# 'puan' anahtarı sözlükte olmadığı için get() metodu varsayılan mesajı döndürecek.
puan_degeri = alien_0.get("puan", "Bu uzaylının puan değeri tanımlanmamış.")
print(puan_degeri)

## Bu uzaylının puan değeri tanımlanmamış.

# 'renk' anahtarı olduğu için onun değerini döndürecek.
renk_degeri = alien_0.get("renk", "Renk tanımlanmamış.")
print(renk_degeri)

## yeşil

Sözlük Üzerinden Döngü Kurmak

Bir sözlükteki verilerle çalışmanın en yaygın yolu, elemanları üzerinde döngü kurmaktır.

Bütün Anahtar-Değer Çiftleri Üzerinden Döngü Kurmak (.items())

Sözlüğün hem anahtarlarına hem de değerlerine aynı anda ihtiyacınız varsa, .items() metodunu kullanabilirsiniz. Bu metot, her bir anahtar-değer çiftini bir demet olarak döndürür.

user_0 = {
  "username" : "icv",
  "first" : "ismail",
  "last"  : "varilci"
}

for key,value in user_0.items():
  print(f"{key} : {value}")

## username : icv
## first : ismail
## last : varilci

ulkeler = {"turkiye":"ankara","yunanistan":"atina","rusya":"moskova","iran":"tahran"}
for key,value in ulkeler.items():
  print(f"{key.title()}'in başkenti {value.title()}'dır.")

## Turkiye'in başkenti Ankara'dır.
## Yunanistan'in başkenti Atina'dır.
## Rusya'in başkenti Moskova'dır.
## Iran'in başkenti Tahran'dır.

Bir Sözlükteki Bütün Anahtarlar Üzerinden Döngü Kurmak(.keys())

for name in ulkeler.keys():
  print(f"{name.title()}")

## Turkiye
## Yunanistan
## Rusya
## Iran

Bir Sözlüğün Anahtarları Üzerinden Belirli Bir Sıralamada Döngü Kurmak

Döngüye başlamadan önce anahtarları sorted() fonksiyonu ile sıralayarak, çıktılarınızın her zaman belirli bir sırada olmasını sağlayabilirsiniz.

for name in sorted(ulkeler.keys()):
  print(f"{name.title()},barışa hizmet verin")

## Iran,barışa hizmet verin
## Rusya,barışa hizmet verin
## Turkiye,barışa hizmet verin
## Yunanistan,barışa hizmet verin

print(ulkeler)

## {'turkiye': 'ankara', 'yunanistan': 'atina', 'rusya': 'moskova', 'iran': 'tahran'}

Bir Sözlükteki Bütün Değerler Üzerinden Döngü Kurmak (.values())

for capital in ulkeler.values():
  print(capital.upper())

## ANKARA
## ATINA
## MOSKOVA
## TAHRAN

set() Komutu ile Tekrarlanan İfadeleri Benzersiz Hale Getirmek

Tekrarları engellemek ve her değeri sadece bir kez görmek için set() kullanabilirsiniz. set, tıpkı liste gibi bir koleksiyondur ama sadece benzersiz elemanları barındırır.

favori_diller = {
  "jen" : "python",
  "sarac" : "c",
  "edward" : "java",
  "phil" : "python",
  "john" : "java",
  "mary" : "python"
}

print ("Aşağıdaki dillerden bahsedilmiştir.")

## Aşağıdaki dillerden bahsedilmiştir.

for dil in set(favori_diller.values()):
  print(dil.title())

## C
## Python
## Java

Küme Tanıtma

diller = {"python","c#","python","javascript","javascript","python","c#"}
print(diller)

## {'python', 'javascript', 'c#'}

İçiçe Yerleştirme

Bazen verileri daha karmaşık şekillerde modellemek gerekir. Python, veri yapılarını iç içe kullanmanıza olanak tanır.

Sözlüklerin Bir Listesi

Birden çok sözlüğü tek bir listede toplayabilirsiniz. Örneğin, her biri farklı bir uzaylıyı temsil eden sözlükleri bir listede saklayabilirsiniz.

alien_0 = {"renk" : "yeşil", "puan" : 5 }
alien_1 = {"renk" : "sarı", "puan" : 10 }
alien_2 = {"renk" : "kırmızı", "puan" :15 }

aliens = [alien_0, alien_1, alien_2]
print(aliens)

## [{'renk': 'yeşil', 'puan': 5}, {'renk': 'sarı', 'puan': 10}, {'renk': 'kırmızı', 'puan': 15}]

aliens=[]
for alien_number in range(30):
  new_alien={"renk":"yesil","puan":5,"hız":"yavaş"}
  aliens.append(new_alien)

for alien in aliens[:3]:
  if alien["renk"] == "yesil":
    alien["renk"] = "sarı"
    alien["hız"] = "orta"
    alien["puan"] = 10

for alien in aliens[:5]:
  print(alien)
  print(".....")

## {'renk': 'sarı', 'puan': 10, 'hız': 'orta'}
## .....
## {'renk': 'sarı', 'puan': 10, 'hız': 'orta'}
## .....
## {'renk': 'sarı', 'puan': 10, 'hız': 'orta'}
## .....
## {'renk': 'yesil', 'puan': 5, 'hız': 'yavaş'}
## .....
## {'renk': 'yesil', 'puan': 5, 'hız': 'yavaş'}
## .....

print(f"Toplam uzaylı sayısı : {len(aliens)}")

## Toplam uzaylı sayısı : 30

Sözlük İçerisinde Liste ve Sözlük içinde Sözlük

Bir sözlüğün değeri, bir liste olabilir. Bu, bir anahtarla birden çok değeri ilişkilendirmenizi sağlar.

pizza = {"hamur" : "kalın",
         "malzemeler" : ["mantar","bol peynirli","jambonlu","küp sucuklu"]}
print(f"Aşağıdaki malzemelerle birlikte {pizza['hamur']} - hamurlu pizza siparişi verdiniz:")

## Aşağıdaki malzemelerle birlikte kalın - hamurlu pizza siparişi verdiniz:

for malzeme in pizza["malzemeler"]:
  print(f"\t{malzeme}")

##  mantar
##  bol peynirli
##  jambonlu
##  küp sucuklu

favorite_languages = {
  'jen': ['python','r'],
  'sarah': ['c','javascript'],
  'edward': ['java','c#'],
  'phil': ['python','javascript']
}

for name,languages in favorite_languages.items():
  print(f"\n{name.title()}'in favori dilleri:")
  for language in languages:
    print(f"\t{language.title()}")

## 
## Jen'in favori dilleri:
##  Python
##  R
## 
## Sarah'in favori dilleri:
##  C
##  Javascript
## 
## Edward'in favori dilleri:
##  Java
##  C#
## 
## Phil'in favori dilleri:
##  Python
##  Javascript

Bir sözlüğün değeri, başka bir sözlük olabilir. Bu, verileri hiyerarşik bir yapıda saklamak için kullanılır.

users = {
  'aeinstein': {
    'first': 'albert',
    'last': 'einstein',
    'location': 'princeton',
  },
  'mcurie': {
    'first': 'marie',
    'last': 'curie',
    'location': 'paris',
  },
}

for username, user_info in users.items():
  print(f"\nUsername: {username}")
  full_name = f"{user_info['first']} {user_info['last']}"
  location = user_info['location']

  print(f"\tFull name: {full_name.title()}")
  print(f"\tLocation: {location.title()}")

## 
## Username: aeinstein
##  Full name: Albert Einstein
##  Location: Princeton
## 
## Username: mcurie
##  Full name: Marie Curie
##  Location: Paris

WHILE DÖNGÜLERİ

while döngüsü, belirtilen bir koşul True olduğu sürece bir kod bloğunu tekrar tekrar çalıştırır. Koşul False olduğunda döngü sona erer. Döngünün sonsuza kadar çalışmasını önlemek için döngü içindeki bir mekanizmanın koşulu eninde sonunda False yapacak şekilde değiştirilmesi gerekir.

`while` Döngüsü Eylem Halinde

Bu örnekte, sayi değişkeni 5’ten küçük veya eşit olduğu sürece döngü çalışır. Her döngü adımında sayi bir artırılır ve koşul eninde sonunda False olur.

sayi = 1
while sayi <= 5:
  print(sayi)
  sayi += 1

## 1
## 2
## 3
## 4
## 5

Bayrak (Flag) Kullanmak

Bazen bir programın çalışmasını kontrol eden birden fazla koşul olabilir. Bu gibi durumlarda, programın genel durumunu temsil eden bir “bayrak” değişkeni (genellikle bir boolean) kullanmak yararlıdır. Döngü, bayrak True olduğu sürece devam eder.

# Bu örnekte, 'aktif' bayrağı döngünün çalışıp çalışmayacağını kontrol eder.
# Bir koşul (burada bir sayaç) bayrağı False yaparak döngüyü sonlandırır.
aktif = True
sayac = 0
while aktif:
  print(f"Döngü çalışıyor... Sayaç: {sayac}")
  sayac += 1
  if sayac >= 5:
    aktif = False  # Bayrağı False yaparak döngüyü sonlandır.

## Döngü çalışıyor... Sayaç: 0
## Döngü çalışıyor... Sayaç: 1
## Döngü çalışıyor... Sayaç: 2
## Döngü çalışıyor... Sayaç: 3
## Döngü çalışıyor... Sayaç: 4

Döngüden Çıkmak İçin `break` Kullanmak

break ifadesi, içinde bulunduğu döngüyü koşul ne olursa olsun anında sonlandırır. Genellikle bir if bloğu içinde, belirli bir koşul sağlandığında döngüden çıkmak için kullanılır.

# Bu döngü, normalde sonsuza kadar çalışacak şekilde (while True) ayarlanmıştır.
# Ancak 'sayac' 5'e ulaştığında 'break' ifadesi döngüyü kırar.
sayac = 0
while True:
  print(f"Şu anki değer: {sayac}")
  sayac += 1
  if sayac == 5:
    print("Koşul sağlandı, döngüden çıkılıyor.")
    break

## Şu anki değer: 0
## Şu anki değer: 1
## Şu anki değer: 2
## Şu anki değer: 3
## Şu anki değer: 4
## Koşul sağlandı, döngüden çıkılıyor.

Döngüde `continue` Kullanmak

continue ifadesi, döngünün geri kalanını atlayıp bir sonraki döngü adımının başına dönmesini sağlar. Belirli koşullar altında mevcut adımı pas geçmek için kullanılır.

# Bu örnek, 10'dan küçük sayıları inceler.
# Sayı çift ise, 'continue' çalışır, 'print' komutu atlanır ve döngü bir sonraki sayıya geçer.
# Sonuç olarak sadece tek sayılar ekrana yazdırılır.
mevcut_sayi = 0
while mevcut_sayi < 10:
  mevcut_sayi += 1
  if mevcut_sayi % 2 == 0:
    continue  # Sayı çiftse bu adımı atla.
  print(mevcut_sayi)

## 1
## 3
## 5
## 7
## 9

Listeler ve Sözlüklerde `while` Döngüsü Kullanmak

while döngüleri, bir liste veya sözlük değiştirilirken (örneğin, elemanlar silinirken veya taşınırken) döngü kurmak için oldukça kullanışlıdır. for döngüsü, üzerinde çalıştığı listeyi değiştirirken beklenmedik davranışlara yol açabilirken, while döngüsü bu tür senaryolar için daha güvenilirdir.

Öğeleri Bir Listeden Diğerine Taşımak

# Doğrulanmamış kullanıcılar listesi boşalana kadar döngü çalışır.
unconfirmed_users = ['ismail', 'ahmet', 'zeynep']
confirmed_users = []
while unconfirmed_users:
    current_user = unconfirmed_users.pop() # Son kullanıcıyı al ve listeden sil.
    print(f"Kullanıcı doğrulanıyor: {current_user.title()}")
    confirmed_users.append(current_user)

## Kullanıcı doğrulanıyor: Zeynep
## Kullanıcı doğrulanıyor: Ahmet
## Kullanıcı doğrulanıyor: Ismail

print("\nAşağıdaki kullanıcılar onaylanmıştır:")

## 
## Aşağıdaki kullanıcılar onaylanmıştır:

for confirmed_user in confirmed_users:
    print(confirmed_user.title())

## Zeynep
## Ahmet
## Ismail

Belirli Değerlerin Bütün Örneklerini Bir Listeden Silmek

# Listede 'cat' değeri bulunduğu sürece döngü çalışmaya devam eder.
pets = ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']
print(f"Orijinal liste: {pets}")

## Orijinal liste: ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']

while 'cat' in pets:
    pets.remove('cat')
print(f"Temizlenmiş liste: {pets}")

## Temizlenmiş liste: ['dog', 'dog', 'goldfish', 'rabbit']

PYTHON DERLEME NOTLARI 1

İsmail Cüneyt VARİLCİ

2026-07-04