``

Toplumsal güven ne işe yarar?

Güven, geleceğin belirsizliğini yönetmemizi sağlar. Her alışverişte satıcının geçmişini araştırmak, her sözleşmede karşı tarafı gözetlemek veya her sabah kullandığımız köprünün mühendislik hesaplarını doğrulamak zorunda kalsaydık toplumsal hayat kilitlenirdi.

Sosyolog Niklas Luhmann’a göre güven, toplumsal karmaşıklığı azaltan bir mekanizmadır. Anthony Giddens ise modern toplumlarda bireylerin yüzünü hiç görmedikleri uzmanlara ve kurumlara dayanan soyut sistemlerden söz eder. Banka hesabımızdaki sayı da aslında bu kurumsal güvenin dijital ifadesidir.

Basit bir modelle, bir işlemin beklenen faydasını şöyle gösterebiliriz:

Burada $p$ işlemin dürüst biçimde sonuçlanma olasılığı, $K$ beklenen kazanç, $Z$ olası zarar ve $D$ doğrulama maliyetidir. Geleneksel kurumlar $p$ değerini hukuk ve itibarla yükseltirken blockchain, kriptografik kanıtlarla $D$ ve manipülasyon ihtimalini azaltmaya çalışır.

Kurumsal güven ve blockchain güveni

Blockchain’in toplumsal güven kuramlarıyla örtüştüğü nokta, davranışları öngörülebilir hâle getirmesidir. Akıllı sözleşme belirli koşullarda aynı sonucu üretir; dağıtık kayıt ise geçmişin tek taraflı değiştirilmesini zorlaştırır. Böylece tanımadığımız kişilerle iş birliği yapabiliriz.

Çelişki ise “güvensiz sistem” söyleminde ortaya çıkar. Toplum yalnızca doğru kayıt üretmekten ibaret değildir. Adalet, niyet, merhamet ve istisna gibi kavramlar algoritmik kesinliğe kolayca sığmaz. Kod, “ödeme gecikti” durumunu görebilir; fakat gecikmenin deprem nedeniyle yaşandığını kendiliğinden anlayamaz.

Kod gerçekten hakem olabilir mi?

Aşağıdaki basitleştirilmiş Solidity sözleşmesi, tarafların ödeme sırasında birbirine değil kurala güvenmesini sağlar:

contract Escrow {
    address public buyer;
    address payable public seller;

    constructor(address payable _seller) {
        buyer = msg.sender;
        seller = _seller;
    }

    function approveDelivery() external {
        require(msg.sender == buyer, "Yalnizca alici onaylayabilir");
        seller.transfer(address(this).balance);
    }

    receive() external payable {}
}

Bu kod parayı emanette tutar ve alıcı teslimatı onayladığında satıcıya aktarır. Aracı banka ortadan kalkmıştır; fakat güven kaybolmamıştır. Kullanıcılar derleyiciye, blokzincir ağına, sözleşmenin hatasız olduğuna ve alıcının dürüst onay vereceğine güvenir. Fiziksel teslimat bilgisini zincire taşıyan bir oracle kullanılırsa bu kez oracle yeni güven merkezi olur.

Merkeziyetsizlik iktidarı yok eder mi?

Merkeziyetsizlik, iktidarı otomatik olarak dağıtmaz. Büyük madencilik havuzları, doğrulayıcılar, token sahipleri ve geliştiriciler karar süreçlerinde diğer kullanıcılardan daha etkili olabilir. “Bir kişi, bir oy” yerine “bir token, bir oy” kullanıldığında ekonomik eşitsizlik doğrudan siyasal güce dönüşebilir.

Bu nedenle blockchain’in gerçek vaadi güvenmeden güvenmek değil, güven ilişkilerini görünür, denetlenebilir ve alternatifli hâle getirmektir. Teknoloji belirli aracılara bağımlılığı azaltabilir; ancak ortak normların, hukukun ve topluluk uzlaşmasının yerini tamamen alamaz. Kısacası blockchain güveni silmez: onu kurumdan protokole, yöneticiden topluluğa ve kapalı defterden incelenebilir koda taşır.

Değişken, değer ve tip birbirinden farklıdır

Python, JavaScript ve Ruby gibi dinamik tipli dillerde değişkenin kendisi çoğunlukla belirli bir veri türüne sahip değildir. Değişken, bellekte bulunan bir değere referans taşır; veri türü ise o değerle ilişkilendirilir.

veri = 42          # veri, bir tam sayı nesnesine bağlanır
veri = "Merhaba"  # artık bir metin nesnesine bağlanır

İkinci atama sırasında aynı bellek bölgesinin sihirli biçimde metne dönüştürülmesi gerekmez. Çalışma zamanı yeni bir metin nesnesi oluşturur ve veri adının referansını bu nesneye yönlendirir. Eski 42 nesnesine başka bir referans yoksa nesne daha sonra bellekten temizlenebilir.

Bellekte gerçekte ne saklanır?

Basitleştirilmiş bir dinamik dil nesnesini şu şekilde düşünebiliriz:

Tip etiketi, çalışma zamanına verinin sayı mı, metin mi veya başka bir nesne mi olduğunu söyler. Yönetim bilgisi; nesnenin boyutu, referans sayısı ya da çöp toplayıcının kullandığı işaretler olabilir. Bu nedenle yalnızca 5 değerini saklayan dinamik bir nesne, ham makine tamsayısından daha fazla bellek tüketebilir.

Bir değişkenin nesneye bağlanmasını ise kavramsal olarak şöyle gösterebiliriz:

Aynı nesneye birden fazla değişken işaret edebilir:

a = [10, 20]
b = a
b.append(30)
print(a)  # [10, 20, 30]

Burada liste kopyalanmamıştır. a ve b, aynı liste nesnesine referans verir. Bu davranış performans kazandırırken beklenmedik değişikliklere de yol açabilir. Gerçek bir kopya gerekiyorsa dilin kopyalama araçları kullanılmalıdır.

Sayısal veriler nasıl işlenir?

Bir ifade çalıştırıldığında çalışma zamanı operandların tiplerini inceler ve uygun işlemi seçer:

sonuc = 8 + 4       # sayısal toplama: 12
metin = "8" + "4"  # metin birleştirme: "84"

İşlem sembolü aynı olsa da uygulanan davranış farklıdır. Bu yaklaşıma operatör aşırı yükleme veya tipe göre gönderim denebilir. Farklı türlerin karıştırılması ise dilin kurallarına bağlıdır. Python, 8 + "4" ifadesinde hata verirken JavaScript bazı durumlarda otomatik dönüşüm gerçekleştirir.

Açık dönüşüm, niyeti görünür kıldığı için sürprizleri azaltır.

Metinler ve değişmezlik

Metinler birçok dilde değişmez nesnelerdir. Bir metni güncellediğimizi düşündüğümüzde çoğunlukla yeni bir nesne üretilir:

mesaj = "Merhaba"
mesaj = mesaj + " dünya"

İkinci satır yeni bir metin oluşturur ve mesaj referansını ona bağlar. Çok sayıda metni döngü içinde + ile birleştirmek bu nedenle maliyetli olabilir. Parçaları listede toplayıp join kullanmak genellikle daha verimlidir.

Esnekliğin bedeli

Dinamik tipleme hızlı prototipleme, kısa kod ve esnek veri işleme sağlar. Buna karşılık tip hataları çalışma zamanına kalabilir ve her işlemde tip kontrolü ek maliyet oluşturabilir. Modern yorumlayıcılar; önbellekleme, çalışma zamanı uzmanlaştırması ve JIT derleme sayesinde bu maliyeti azaltır.

Sonuç olarak dinamik tip sistemi “tipsiz” değildir; tip bilgisini değişkenden değere ve derleme anından çalışma zamanına taşır. Bu ayrımı anlamak, hem bellek davranışlarını çözmeyi hem de daha güvenli, hızlı ve şaşırtmayan programlar yazmayı kolaylaştırır.

İterasyon Nedir?

İterasyon, bir işlemin adım adım tekrarlanmasıdır. Her tekrar bir iterasyon olarak adlandırılır. Örneğin 1’den 5’e kadar sayıları ekrana yazdıran bir döngü beş iterasyon gerçekleştirir.

Bir döngü genellikle üç temel parçaya sahiptir:

1. Başlangıç durumu: Sayaç veya başlangıç değeri belirlenir.
2. Devam koşulu: Döngünün çalışmayı sürdürüp sürdürmeyeceği kontrol edilir.
3. Güncelleme: Her turdan sonra durum değiştirilir.

Bir sayaç $i$ başlangıçta $0$ ise ve her adımda $1$ artıyorsa güncelleme şöyle ifade edilir:

Döngü $n$ defa çalışıyorsa ve her tur sabit süre alıyorsa yaklaşık zaman karmaşıklığı $O(n)$ olur. İç içe iki döngü ise çoğunlukla $O(n^2)$ maliyet üretir.

while Döngüsü: Koşul Doğru Oldukça Devam

while, tekrar sayısının önceden kesin olarak bilinmediği durumlarda kullanışlıdır. Önce koşulu denetler, sonuç doğruysa gövdeyi çalıştırır.

sayac = 1

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

Bu örnekte sayaç 1’den başlar. Koşul her turdan önce kontrol edilir ve sayaç 5’i geçtiğinde döngü sona erer. sayac += 1 satırını unutursak koşul sürekli doğru kalabilir. Bunun sonucu, programcıların meşhur canavarı olan sonsuz döngüdür.

while özellikle kullanıcı doğru veri girene kadar beklemek, bir oyunu oyuncunun canı bitene kadar sürdürmek veya bir arama işlemini sonuç bulunana kadar çalıştırmak için uygundur.

for Döngüsü: Koleksiyonların Düzenli Gezgini

for, bir liste, metin, demet veya belirli bir sayı aralığı üzerinde ilerlemek için tercih edilir.

meyveler = ['elma', 'armut', 'muz']

for meyve in meyveler:
    print(meyve.upper())

Burada meyve değişkeni, her iterasyonda listenin sıradaki elemanını temsil eder. Kod, listedeki meyveleri büyük harflerle yazdırır. Eleman sayısını veya indeks yönetimini elle takip etmemiz gerekmez.

Sayısal tekrarlar için range() kullanılabilir:

for sayi in range(1, 6):
    kare = sayi ** 2
    print(sayi, kare)

range(1, 6), 1’den başlayıp 6 hariç olacak şekilde değer üretir. Her sayının karesi $x^2$ formülüyle hesaplanır.

while ve for Karşılaştırması

Döngü Akışını Yönetmek

break, döngüyü tamamen sonlandırır; continue ise yalnızca mevcut iterasyonu atlayarak sonraki tura geçer.

for sayi in range(1, 11):
    if sayi == 8:
        break
    if sayi % 2 != 0:
        continue
    print(sayi)

Bu kod tek sayıları atlar, çift sayıları yazdırır ve 8’e ulaştığında döngüyü bitirir. % operatörü kalanı verdiği için $sayi \bmod 2 = 0$ koşulu çift sayıları belirler.

Döngü seçerken temel soru şudur: “Bir koşul gerçekleşene kadar mı bekliyorum, yoksa elimdeki elemanları mı geziyorum?” İlk durumda while, ikinci durumda for çoğunlukla daha doğal seçimdir. Doğru döngü; kodu yalnızca kısaltmaz, niyetini de okuyucuya açıkça anlatır.

``

Bug, beklenti ile gerçeklik arasındaki farktır

Bir programın beklenen çıktısını $E$, gözlenen çıktısını $O$ ile gösterelim. İncelediğimiz sapma kabaca şöyle düşünülebilir:

Buradaki asıl mesele $D$ değerini sıfırlamak değil, farkın hangi koşulda doğduğunu açıklayabilmektir. Açıklayamadığımız ama geçici olarak susturduğumuz hata, genellikle daha dramatik bir kostümle geri döner.

İyi bir hata ayıklama süreci bilimsel yönteme benzer:

1. Belirtiyi gözlemle.
2. Hatayı güvenilir biçimde yeniden üret.
3. Bir hipotez kur.
4. Tek bir değişkeni değiştirerek hipotezi test et.
5. Sonucu kaydet ve kapsamı daralt.

Bu yaklaşımın içe dönük tarafı şudur: Her hipotez, kod kadar zihnimiz hakkında da bilgi verir. “Veritabanı bozuktur” demeden önce, neden ilk olarak dış dünyayı suçlamaya eğilimli olduğumuzu fark ederiz.

Tepki vermek ile araştırmak

Önce hatayı görünür kıl

Aşağıdaki Python fonksiyonu, indirimli fiyat hesaplıyor. Ancak oran değerinin yüzde mi, ondalık mı olduğu belirsiz:

def indirimli_fiyat(fiyat, oran):
    print(f"DEBUG fiyat={fiyat}, oran={oran}")
    assert fiyat >= 0, "Fiyat negatif olamaz"
    assert 0 <= oran <= 1, "Oran 0 ile 1 arasında olmalı"
    return fiyat * (1 - oran)

print(indirimli_fiyat(100, 0.20))

print, programın o andaki durumunu görünür yapar; assert ise sessiz bir varsayımı çalıştırılabilir kurala dönüştürür. Formülümüz $P_{son} = P(1-r)$ olduğuna göre 20 değil, 0.20 beklenir. Böylece sorun yalnızca yanlış değer olmaktan çıkar, açıkça tanımlanmış bir sözleşme ihlaline dönüşür.

Gerçek projelerde günlük kayıtları, debugger durak noktaları ve otomatik testler aynı amaca hizmet eder: Zihnimizde kurduğumuz hikâyeyi ölçülebilir kanıtlarla karşılaştırmak.

İkiye böl, sakinleş, tekrar et

Hatanın yüz satırlık bir alanda bulunduğunu düşünelim. Her adımda alanı ikiye bölersek gereken yaklaşık inceleme sayısı:

$n=100$ için yalnızca $k=7$ adım yeterlidir. git bisect, modülleri devre dışı bırakma ve girdiyi küçültme teknikleri bu mantığı kullanır. Panik bütün sistemi aynı anda görmeye çalışır; yöntem ise soruyu küçültür.

Debug günlüğü tut

Kısa bir kayıt, dairesel düşünmeyi engeller:

Belirti: Sepet toplamı bazı siparişlerde negatif.
Tekrar: İki kupon aynı anda uygulanınca oluşuyor.
Hipotez: İndirimler sırayla değil, toplam olarak düşülüyor.
Deney: İkinci kuponu kapat.
Sonuç: Negatif değer kayboldu.

Bu günlük gelecekteki ekip arkadaşına yardım ederken geçmişteki hâlinizle de dürüst bir konuşma kurar.

Sonunda iyi debugger, hiç hata yapmayan kişi değildir. Yanıldığını hızlı, sakin ve kanıta dayanarak fark edebilen kişidir. Bug düzeldiğinde yalnızca program değişmez; varsayımlarını sınamayı öğrenen geliştirici de küçük bir sürüm yükseltmesi yaşar.

Operatör ve ifade nedir?

Operatör, bir veya daha fazla değer üzerinde işlem yapan sembol ya da anahtar kelimedir. +, >, == ve and birer operatördür. Operatörün işlediği değerlere operand denir. Örneğin 8 + 2 ifadesinde 8 ve 2 operand, + ise operatördür.

Bir ifade, çalıştırıldığında sonuç üreten kod parçasıdır. Matematiksel olarak bunu şöyle gösterebiliriz:

5 * 4 ifadesinin sonucu 20, 10 > 3 ifadesinin sonucu ise True değeridir. Sonucun her zaman sayı olması gerekmez; mantıksal bir değer, metin veya başka bir veri türü de üretilebilir.

Aritmetik operatörler

Aritmetik operatörler temel matematiksel hesaplamaları gerçekleştirir.

Örneğin indirimli fiyatın formülü $P_{son}=P-(P\times i)$ biçimindedir. Python ile bunu doğrudan ifade edebiliriz:

fiyat = 800
indirim_orani = 0.15
indirimli_fiyat = fiyat - (fiyat * indirim_orani)

print(indirimli_fiyat)  # 680.0

Parantezler yalnızca okunabilirliği artırmaz, işlem sırasını da belirler. 2 + 3 * 4 işlemi 14 üretirken (2 + 3) * 4 işlemi 20 üretir. Genel öncelik sırası parantez, üs alma, çarpma-bölme ve toplama-çıkarma şeklindedir.

Karşılaştırma operatörleri

Karşılaştırmalar iki değerin ilişkisini inceler ve True ya da False üretir.

Burada = ile == karıştırılmamalıdır. = değişkene değer atar; == iki değerin eşitliğini sorgular. Bu küçük fark, büyük hataların klasik kaynağıdır.

Mantıksal operatörler

Mantıksal operatörler birden fazla koşulu birleştirir. and, bütün koşullar doğruysa; or, koşullardan en az biri doğruysa True üretir. not ise sonucu tersine çevirir.

yas = 22
uyelik_aktif = True
kupon_var = False

alisveris_izni = yas >= 18 and uyelik_aktif
avantaj_var = uyelik_aktif and (kupon_var or yas < 25)

print(alisveris_izni)  # True
print(avantaj_var)     # True

İlk ifade, kullanıcının hem yetişkin hem aktif üye olmasını ister. İkinci ifade ise aktif üyeliğe ek olarak kupon veya genç kullanıcı avantajından birini yeterli görür.

Kısa devre değerlendirmesi

Mantıksal ifadeler çoğu dilde soldan sağa değerlendirilir. False and işlem() ifadesinde sonuç zaten yanlış olduğundan işlem() çağrılmayabilir. Benzer biçimde True or işlem() için ikinci bölüm gereksizdir. Buna kısa devre değerlendirmesi denir.

kullanici = None

if kullanici is not None and kullanici["aktif"]:
    print("Hoş geldin!")

İlk koşul yanlışsa ikinci koşul çalıştırılmaz; böylece None değeri üzerinde veri okumaya çalışmaktan doğacak hata önlenir.

Operatörleri öğrenirken ezberden çok ifadeyi parçalara ayırmak faydalıdır: Önce operandları, sonra işlem önceliğini, en sonunda oluşacak veri türünü belirleyin. Kodun matematik kutusu doğru kullanıldığında hesaplamalar netleşir, koşullar okunabilir olur ve veri manipülasyonu şaşırtıcı ölçüde kolaylaşır.

``

Python felsefesi: Kod insanlar içindir

Python’ın yaklaşımı, Tim Peters tarafından yazılan The Zen of Python ilkelerinde özetlenir. Bu ilkeleri görmek için Python yorumlayıcısında aşağıdaki komut çalıştırılabilir:

import this

Karşımıza çıkan metindeki en ünlü ifadelerden biri şudur: “Readability counts.”, yani “Okunabilirlik önemlidir.” Python’a göre kod yalnızca bilgisayarın çalıştıracağı komutlardan ibaret değildir. Aynı zamanda başka geliştiricilerin ve gelecekteki hâlimizin okuyacağı teknik bir anlatıdır.

Bu düşünceyi basitçe şöyle modelleyebiliriz:

Program doğru sonuç üretse bile anlaşılması çok zorsa bakım maliyeti yükselir. Python, görsel düzeni sözdiziminin bir parçası yaparak bu sorunu azaltmaya çalışır.

Girinti nasıl blok oluşturur?

C, Java ve JavaScript gibi dillerde bir bloğun başlangıcı ve sonu süslü parantezlerle belirtilir. Python’da ise aynı hizadaki satırlar aynı bloğa aittir.

Aşağıdaki örnekte if satırından sonra gelen iki komut aynı girinti seviyesindedir ve koşul bloğuna dahildir:

sicaklik = 28

if sicaklik > 25:
    print('Hava sıcak.')
    print('Su içmeyi unutma!')

print('Program tamamlandı.')

Koşul doğruysa girintili iki satır çalışır. Son satır sola döndüğü için if bloğunun dışındadır ve koşuldan bağımsız olarak yürütülür. Buradaki iki nokta :, yeni bir kod bloğunun başlayacağını haber verir.

Girinti seviyelerinin mantığı

Her iç içe blok, bir önceki seviyeye göre daha fazla girintilenir. Girinti düzeyi $n$, standart olarak kullanılan boşluk sayısı da $4$ ise satırın toplam girintisi yaklaşık olarak şöyle düşünülebilir:

Örneğin bir döngünün içindeki koşul ikinci seviyededir ve sekiz boşluk kullanır:

sayilar = [3, 8, 11, 14]

for sayi in sayilar:
    if sayi % 2 == 0:
        print(f'{sayi} çift sayıdır.')
    else:
        print(f'{sayi} tek sayıdır.')

Bu kod, listedeki sayıları dolaşır ve % operatörüyle kalanı kontrol eder. Girintiler sayesinde döngü, koşul ve alternatif dal gözle kolayca ayırt edilir.

Boşluk mu, sekme mi?

Python teknik olarak sekmelerle girintiye izin verse de PEP 8, her seviye için dört boşluk kullanılmasını önerir. Boşluk ve sekmeyi aynı dosyada karıştırmak TabError hatasına veya editörler arasında farklı görünümlere yol açabilir.

Modern editörler Tab tuşuna basıldığında otomatik olarak dört boşluk ekleyebilir. Böylece hem hız hem tutarlılık elde edilir.

Okunabilirliğin pratik sonucu

Python’ın girinti zorunluluğu ilk başta katı görünebilir; aslında ekip içinde ortak bir görsel dil oluşturur. Gereksiz parantezler azalır, blokların kapsamı hızla anlaşılır ve kötü biçimlendirilmiş kod daha yazılmadan engellenir. Kısacası girinti, Python’da dekorasyon değil anlamdır. Bu yaklaşımı benimsediğinizde yalnızca çalışan programlar değil, başkalarının keyifle okuyabileceği temiz ve sürdürülebilir yazılımlar üretmeye başlarsınız.

Python yorumlayıcısı ne yapar?

Python, yüksek seviyeli ve yorumlanan bir programlama dilidir. Yazdığımız kaynak kod doğrudan işlemcinin anlayacağı makine dili değildir. Python yorumlayıcısı kodu okur, bytecode adı verilen ara gösterime dönüştürür ve Python Sanal Makinesi üzerinde çalıştırır.

Bu ilişkiyi basitleştirirsek:

Bir programın toplam çalışma süresini kavramsal olarak şöyle düşünebiliriz:

Bu yaklaşım Python’a taşınabilirlik kazandırır. Aynı .py dosyası, uygun yorumlayıcı bulunduğu sürece Windows, macOS ve Linux üzerinde çalışabilir.

Python kurulumu

Python, resmi olarak python.org adresinden indirilebilir. Windows kurulumunda Add Python to PATH kutusunu işaretlemek kritik önemdedir. PATH, işletim sisteminin python komutunu yazdığımızda yorumlayıcıyı nerede bulacağını belirleyen dizinler listesidir.

macOS kullanıcıları Homebrew, Linux kullanıcıları ise dağıtımlarının paket yöneticisini tercih edebilir:

# macOS
brew install python

# Ubuntu veya Debian
sudo apt update
sudo apt install python3 python3-venv

Kurulumun başarılı olduğunu terminalde doğrulayalım:

python --version
# Bazı sistemlerde:
python3 --version

Ekranda Python 3.x.x benzeri bir sonuç görülüyorsa yorumlayıcı göreve hazırdır. Komut bulunamıyorsa terminali yeniden başlatmak ve PATH ayarını kontrol etmek gerekir.

VS Code ortamını hazırlama

VS Code kurulduktan sonra sol menüdeki Extensions bölümünü açıp Microsoft tarafından yayımlanan Python eklentisini yükleyin. Bu eklenti sözdizimi renklendirme, otomatik tamamlama, hata analizi ve hata ayıklama gibi özellikler sağlar.

Ardından bir proje klasörü oluşturup VS Code ile açın. Terminali Ctrl + Ö veya menüdeki Terminal > New Terminal seçeneğiyle çalıştırabilirsiniz. Projeye özel sanal ortam oluşturalım:

python -m venv .venv

Sanal ortamı etkinleştirme komutu işletim sistemine göre değişir:

Sanal ortam, bir projede kurulan paketlerin diğer projeleri etkilemesini önler. Örneğin bir proje Paket 1.0, diğeri Paket 2.0 kullanabilir; böylece bağımlılık kavgası çıkmaz.

VS Code’da Ctrl + Shift + P tuşlarına basıp Python: Select Interpreter komutunu seçin ve .venv içindeki yorumlayıcıyı işaretleyin.

İlk programı çalıştırma

main.py adlı bir dosya oluşturup aşağıdaki kodu yazalım:

name = input("Adın nedir? ")
message = f"Merhaba {name}, Python ortamın çalışıyor!"
print(message)

Bu program input() ile kullanıcıdan veri alır, f-string ile metin oluşturur ve print() ile sonucu terminale gönderir. Çalıştırmak için şu komutu kullanın:

python main.py

Artık yorumlayıcı, editör, terminal ve sanal ortam aynı ekipte çalışıyor. Kısacası sahne hazır; bundan sonra hatalar bile öğrenme macerasının eğlenceli karakterleri olacak!

``

Ortak temel: Sıralı veri yapıları

Liste ve demetler, elemanların eklenme sırasını korur. Her iki yapıda da indeksler sıfırdan başlar. $n$ elemanlı bir koleksiyonun geçerli indeks aralığı şu şekilde ifade edilir:

Negatif indeksler ise sondan erişim sağlar. Örneğin -1 son elemanı, -2 sondan ikinci elemanı temsil eder. İndeks üzerinden okuma işlemi iki yapıda da genellikle $O(1)$ zaman karmaşıklığına sahiptir.

liste = ["Python", "JavaScript", "Go"]
demet = ("Python", "JavaScript", "Go")

print(liste[0])   # Python
print(demet[-1])  # Go

Bu kod, iki veri yapısında da indeksleme mantığının aynı olduğunu gösterir. Fakat koleksiyonu değiştirmeye çalıştığımızda yollar ayrılır.

Değiştirilebilirlik: Listenin süper gücü

Listeler mutable, yani değiştirilebilir yapılardır. Eleman ekleyebilir, silebilir veya mevcut bir değeri güncelleyebiliriz. Bu nedenle kullanıcı sepeti, görev listesi ya da sürekli büyüyen sensör verileri gibi dinamik senaryolarda idealdir.

gorevler = ["Kod yaz", "Test yap"]

gorevler.append("Belgele")       # Sona yeni görev ekler
gorevler[0] = "Temiz kod yaz"    # İlk görevi günceller
gorevler.remove("Test yap")      # Belirtilen görevi siler

print(gorevler)

Bir listenin sonuna append() ile eleman eklemek ortalama $O(1)$ maliyetlidir. Buna karşılık listenin başına eleman eklemek, diğer elemanların kaydırılmasını gerektirdiği için $O(n)$ maliyetine ulaşabilir.

Demetler ise immutable, yani değiştirilemez yapılardır:

koordinat = (41.0082, 28.9784)
# koordinat[0] = 40.0  # TypeError üretir

Buradaki “sabitlik”, demetin tuttuğu referansların değiştirilememesi anlamına gelir. Demetin içinde bir liste bulunuyorsa o listenin içeriği yine değiştirilebilir. Kısacası demet koruyucu bir kasa gibidir; ancak kasanın içine koyduğunuz nesnenin kendi davranışı ayrıca değerlendirilmelidir.

Karşılaştırma tablosu

Demetler neden daha performanslı olabilir?

Python listeleri gelecekte eklenecek elemanlar için fazladan kapasite ayırabilir. Bu yaklaşım ekleme işlemlerini hızlandırır, fakat ek bellek kullanır. Demetlerin boyutu baştan belli olduğu için daha kompakt bir bellek düzeni kullanılabilir. Ayrıca değişmeyecekleri bilindiğinden bazı işlemler daha az kontrol gerektirir.

import sys

liste = [1, 2, 3, 4, 5]
demet = (1, 2, 3, 4, 5)

print(sys.getsizeof(liste))
print(sys.getsizeof(demet))

Bu örnek, aynı elemanları içeren yapıların yüzeysel bellek boyutlarını karşılaştırır. Sonuçlar Python sürümüne ve platforma göre değişse de demet çoğunlukla daha az yer kaplar. Yine de küçük koleksiyonlarda performans farkı için okunabilirliği feda etmek pek mantıklı değildir.

Paketleme ve parçalama

Demetler, bir fonksiyondan birden fazla değer döndürürken oldukça kullanışlıdır:

def min_max(sayilar):
    return min(sayilar), max(sayilar)

en_kucuk, en_buyuk = min_max([8, 3, 12, 5])
print(en_kucuk, en_buyuk)

Fonksiyon gerçekte iki değeri bir demet içinde paketler; atama sırasında bu demet parçalanır. Böylece kod hem kısa hem de anlamlı olur.

Hangisini seçmeliyiz?

Veriler zamanla değişecekse liste seçmek en doğal yaklaşımdır. Koordinat, RGB rengi, tarih bileşenleri veya veritabanından gelen sabit bir kayıt gibi elemanların değişmemesi gerekiyorsa demet daha güçlü bir niyet beyanıdır. Özetle liste “üzerimde çalış” derken demet “beni bir bütün olarak koru” der. Doğru seçim yalnızca birkaç nanosaniye kazanmak değil, kodun gelecekteki okuyucusuna verinin nasıl davranması gerektiğini açıkça anlatmaktır.

String Nedir?

Python’da tek, çift veya üç tırnak arasına yazılan değerler string kabul edilir. Her string, sıralı bir karakter dizisidir:

mesaj = "Python eğlencelidir!"
print(type(mesaj))  # <class 'str'>

Bir string’in uzunluğu len() fonksiyonuyla bulunur. Matematiksel olarak uzunluğu $n$ olan bir string’in geçerli pozitif indeksleri $0$ ile $n-1$ arasındadır. Python ayrıca sondan erişim için negatif indeksleri destekler; son karakterin indeksi $-1$ olur.

kelime = "Python"

print(len(kelime))  # 6
print(kelime[0])    # P
print(kelime[5])    # n
print(kelime[-1])   # n
print(kelime[-2])   # o

Var olmayan bir indekse erişmek IndexError üretir. Örneğin altı karakterli bir string’de kelime[6] kullanılamaz.

Slicing: Metni Dilimlemek

Dilimleme söz dizimi metin[başlangıç:bitiş:adım] biçimindedir. Başlangıç dahil, bitiş hariçtir. Başlangıç $a$, bitiş $b$ olduğunda ve adım bir olduğunda seçilen karakter sayısı genel olarak $b-a$ kadardır.

metin = "Programlama"

print(metin[0:7])   # Program
print(metin[:7])    # Program
print(metin[7:])    # lama
print(metin[::2])   # Pormaa
print(metin[::-1])  # amalmargorP

[::-1] ifadesi string’i tersten okumak için kullanılan kısa ve eğlenceli bir yöntemdir. Palindrom kontrolünde de işe yarar:

def palindrom_mu(metin):
    temiz = metin.lower().replace(" ", "")
    return temiz == temiz[::-1]

print(palindrom_mu("Nalan"))  # True

Bu fonksiyon önce harfleri küçültür, boşlukları kaldırır ve metni ters hâliyle karşılaştırır.

String Metotlarıyla Dönüşüm

String’ler değiştirilemez, yani immutable yapılardır. Bir metot mevcut string’i yerinde değiştirmez; yeni bir string üretir. Sonucu korumak için bir değişkene atamak gerekir.

ad = "  ada lovelace  "
sonuc = ad.strip().title()
print(sonuc)  # Ada Lovelace

cumle = "Python hızlı ve okunaklıdır"
kelimeler = cumle.split()
print(kelimeler)

yeni_cumle = "-".join(kelimeler)
print(yeni_cumle)  # Python-hızlı-ve-okunaklıdır

split() metni parçalarken join() parçaları yeniden bir araya getirir. Özellikle CSV verileri, etiketler ve kullanıcı girdileri işlenirken bu ikili adeta metin mutfağının bıçak ve kesme tahtasıdır.

Arama ve Kontrol İşlemleri

Bir parçanın metinde bulunup bulunmadığı in operatörüyle kontrol edilebilir. find() konumu döndürür; eşleşme yoksa -1 verir. startswith() ve endswith() ise başlangıç ya da bitiş denetimi yapar.

dosya = "rapor_2026.pdf"

print("2026" in dosya)          # True
print(dosya.find("rapor"))      # 0
print(dosya.startswith("rapor")) # True
print(dosya.endswith(".pdf"))    # True

Sonuç olarak indeksleme tek karaktere erişmeyi, slicing belirli aralıkları çıkarmayı, yerleşik metotlar ise metni temizleyip dönüştürmeyi sağlar. Bu araçları birlikte kullanmak; doğrulama, arama, veri temizleme ve doğal dil işleme gibi daha büyük problemlerin temelini oluşturur.

``

Koşul Nedir?

Koşul, sonucu doğru veya yanlış olan bir ifadedir. Programlama dilinde bu iki sonuç True ve False değerleriyle temsil edilir. Örneğin puan >= 50 ifadesi, puan 50 veya daha büyükse doğru; aksi durumda yanlıştır.

Bu mantık matematiksel olarak bir karar fonksiyonu şeklinde düşünülebilir:

Buradaki $x$, öğrencinin puanıdır. Koşullu bloklar, bu matematiksel ayrımı çalıştırılabilir koda dönüştürür.

if, elif ve else Görevleri

Basit bir not değerlendirme sistemi oluşturalım:

puan = 76

if puan >= 85:
    print("Pekiyi")
elif puan >= 70:
    print("İyi")
elif puan >= 50:
    print("Geçer")
else:
    print("Kaldı")

Python koşulları yukarıdan aşağıya kontrol eder. puan >= 70 doğru olduğunda ekrana İyi yazdırılır ve zincirin geri kalanı değerlendirilmez. Bu nedenle koşulların sırası önemlidir. Önce daha genel olan puan >= 50 yazılsaydı 76 puan, yanlışlıkla yalnızca Geçer olarak sınıflandırılırdı.

Karşılaştırma ve Mantıksal Operatörler

Koşullar oluşturulurken karşılaştırma operatörlerinden yararlanılır:

Birden fazla şartı birleştirmek için and, or ve not kullanılır. and bütün şartların, or ise en az bir şartın doğru olmasını bekler. not, mantıksal sonucu tersine çevirir.

yas = 22
bileti_var = True

if yas >= 18 and bileti_var:
    print("Etkinliğe giriş yapabilirsiniz.")
elif yas >= 18 and not bileti_var:
    print("Önce bilet almalısınız.")
else:
    print("Yaş sınırı nedeniyle giriş yapılamaz.")

Bu kod hem yaş hem de bilet bilgisini değerlendirerek akışı dinamik biçimde yönlendirir. Gerçek uygulamalarda kullanıcı yetkilendirme, ödeme kontrolü ve form doğrulama gibi pek çok süreç aynı mantığa dayanır.

İç İçe Koşullar mı, Birleşik Koşullar mı?

Bir if bloğunun içine başka bir if yazılabilir. Buna iç içe koşul denir. Ancak gereksiz katmanlar kodu merdivene dönüştürebilir:

kullanici_aktif = True
rol = "admin"

if kullanici_aktif:
    if rol == "admin":
        print("Yönetim paneli açıldı.")

Aynı kontrol, if kullanici_aktif and rol == "admin": biçiminde daha sade yazılabilir. Yine de ikinci kontrol yalnızca ilk koşul gerçekleştiğinde anlamlıysa iç içe yapı tercih edilebilir.

Yaygın Hatalar ve İpuçları

Python’da bloklar süslü parantezle değil, girintilerle belirlenir. Bu yüzden koşul altındaki satırlar aynı miktarda girintilenmelidir. Ayrıca değer atayan = ile karşılaştırma yapan == birbirine karıştırılmamalıdır.

Koşulları yazarken en özel durumdan en genel duruma ilerlemek, beklenmeyen girişler için bir else dalı bırakmak ve karmaşık ifadeleri anlamlı değişkenlere ayırmak okunabilirliği artırır. Kısacası if-elif-else, programın yol ayrımlarındaki trafik ışığıdır: Doğru tasarlanırsa akış düzenli ilerler; yanlış sıralanırsa kod kendini beklenmedik bir mahallede bulabilir.