DEV Community: Vebende Akademi

Python String Format Rehberi

Vebende Akademi — Sun, 28 Jun 2026 19:08:04 +0000

Python String Format Rehberi

Python'da metin (string) biçimlendirme, değişkenleri metin içerisine yerleştirmenin en kolay yollarından biridir. Özellikle kullanıcıya bilgi gösterirken, rapor üretirken veya dosya içerikleri oluştururken string formatlama sıkça kullanılır.

Python'da string formatlamak için üç temel yöntem vardır:

% operatörü (Eski yöntem)
str.format() metodu
f-string (Önerilen modern yöntem)

Bu yazıda hepsini örneklerle inceleyeceğiz.

1. % Operatörü (Eski Yöntem)

Bu yöntem Python'un eski sürümlerinden beri bulunmaktadır.

Örnek 1

isim = "Ahmet"

print("Merhaba %s" % isim)

Çıktı:

Merhaba Ahmet

Örnek 2

yas = 25

print("Yaşım %d" % yas)

Çıktı

Yaşım 25

Örnek 3

puan = 89.75

print("Not: %.2f" % puan)

Çıktı

Not: 89.75

Buradaki .2f, ondalık kısmın 2 basamak gösterileceğini ifade eder.

Birden Fazla Değişken

isim = "Ayşe"
yas = 22

print("İsim: %s Yaş: %d" % (isim, yas))

Çıktı

İsim: Ayşe Yaş: 22

2. format() Metodu

Python 3 ile birlikte daha güçlü hale gelen yöntemdir.

Temel Kullanım

isim = "Mehmet"

print("Merhaba {}".format(isim))

Çıktı

Merhaba Mehmet

Birden Fazla Değişken

isim = "Ali"
yas = 30

print("{} {} yaşındadır.".format(isim, yas))

Çıktı

Ali 30 yaşındadır.

Sıralı Kullanım

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

Çıktı

Merhaba Dünya

İsim Vererek Kullanım

print("{isim} {yas}".format(isim="Can", yas=18))

Çıktı

Can 18

Sayıları Biçimlendirme

Ondalık Basamak

pi = 3.14159265

print("{:.2f}".format(pi))

Çıktı

3.14

Binlik Ayırıcı

sayi = 1250000

print("{:,}".format(sayi))

Çıktı

1,250,000

Yüzde Gösterimi

oran = 0.85

print("{:.0%}".format(oran))

Çıktı

85%

Alan Genişliği

print("{:10}".format("Python"))

Çıktı

Python

Kelime sağa yaslanır ve toplam uzunluk 10 karakter olur.

Sola Yaslama

print("{:<10}".format("Python"))

Çıktı

Python

Sağa Yaslama

print("{:>10}".format("Python"))

Çıktı

    Python

Ortalama

print("{:^10}".format("Python"))

Çıktı

  Python

Karakter ile Doldurma

print("{:*^20}".format("Python"))

Çıktı

*******Python*******

Sayıları Sıfır ile Tamamlama

print("{:05}".format(42))

Çıktı

3. f-String (En Çok Kullanılan)

Python 3.6 ve sonrasında gelen en pratik yöntemdir.

Temel Kullanım

isim = "Zeynep"

print(f"Merhaba {isim}")

Çıktı

Merhaba Zeynep

Birden Fazla Değişken

isim = "Ali"
yas = 28

print(f"{isim} {yas} yaşındadır.")

Çıktı

Ali 28 yaşındadır.

Matematiksel İşlem

a = 15
b = 5

print(f"Toplam = {a+b}")

Çıktı

Toplam = 20

İfade Kullanımı

isim = "Python"

print(f"{isim.upper()}")

Çıktı

PYTHON

Ondalık Basamak

pi = 3.1415926

print(f"{pi:.3f}")

Çıktı

3.142

Binlik Ayırıcı

para = 123456789

print(f"{para:,}")

Çıktı

123,456,789

Yüzde

oran = 0.756

print(f"{oran:.1%}")

Çıktı

75.6%

Sağa Yaslama

isim = "Ali"

print(f"|{isim:>10}|")

Çıktı

|       Ali|

Sola Yaslama

print(f"|{isim:<10}|")

Çıktı

|Ali       |

Ortalama

print(f"|{isim:^10}|")

Çıktı

|   Ali    |

Karakter ile Doldurma

print(f"{isim:-^20}")

Çıktı

--------Ali---------

Sayıları Farklı Tabanlarda Gösterme

İkilik (Binary)

sayi = 15

print(f"{sayi:b}")

Çıktı

Sekizlik (Octal)

print(f"{sayi:o}")

Çıktı

Onaltılık (Hexadecimal)

print(f"{sayi:x}")

Çıktı

Tarih Formatlama

from datetime import datetime

bugun = datetime.now()

print(f"{bugun:%d.%m.%Y}")

Örnek çıktı

15.06.2025

Tablo Oluşturma

urun = "Laptop"
fiyat = 45000

print(f"{urun:<15}{fiyat:>10}")

Çıktı

Laptop             45000

Döngü ile Kullanım

for i in range(1, 6):
    print(f"{i:02}")

Çıktı

Hesaplama Sonucu Yazdırma

urun = "Klavye"
adet = 3
fiyat = 750

print(f"Toplam: {adet*fiyat} TL")

Çıktı

Toplam: 2250 TL

Sözlük (Dictionary) Kullanımı

ogrenci = {
    "isim": "Elif",
    "yas": 20
}

print(f"{ogrenci['isim']} {ogrenci['yas']}")

Çıktı

Elif 20

Liste Kullanımı

sayilar = [5, 10, 15]

print(f"İlk sayı: {sayilar[0]}")

Çıktı

İlk sayı: 5

Karşılaştırma

Özellik	% Operatörü	format()	f-string
Okunabilirlik	Düşük	Orta	Çok yüksek
Hız	Orta	Orta	Yüksek
Python Sürümü	Eski	Python 3	Python 3.6+
Önerilen	❌ Hayır	✔️ Kullanılabilir	⭐ Evet

En Sık Kullanılan Format Kodları

Kod	Açıklama	Örnek
`:.2f`	2 ondalık basamak	`3.14`
`:,`	Binlik ayırıcı	`1,000,000`
`:05`	Baştan sıfır ekleme	`00042`
`:>10`	Sağa yaslama	`Ali`
`:<10`	Sola yaslama	`Ali`
`:^10`	Ortalama	`Ali`
`:*^20`	Karakterle doldurma	`**Ali**`
`:b`	Binary	`1010`
`:o`	Octal	`12`
`:x`	Hexadecimal	`a`
`:.1%`	Yüzde	`75.5%`

Sonuç

Modern Python projelerinde f-string kullanımı tavsiye edilir. Daha okunabilir, daha hızlı ve kod yazmayı kolaylaştırır. Eski projelerde % operatörü veya format() metodu ile karşılaşabilirsiniz; bu nedenle üç yöntemi de bilmek faydalıdır. Güncel Python geliştirmelerinde ise yeni kod yazarken öncelikli tercih f-string olmalıdır.

Linux fork(), Copy-on-Write, CPython Heap/Stack Yapısı ve Reference Counting İlişkisi

Vebende Akademi — Wed, 24 Jun 2026 12:12:26 +0000

https://www.youtube.com/watch?v=Iwfe5d-DlVU

Linux fork(), Copy-on-Write, CPython Heap/Stack Yapısı ve Reference Counting İlişkisi

Giriş

CPython üzerinde çalışan uygulamalarda performans optimizasyonu amacıyla çoklu süreç (multiprocessing) kullanımı oldukça yaygındır. Özellikle Linux sistemlerinde fork() çağrısı sayesinde yeni süreç oluşturma işlemi son derece hızlı gerçekleşir. Ancak birçok geliştiricinin gözden kaçırdığı önemli bir detay vardır:

CPython'un referans sayımı (Reference Counting) mekanizması ile Linux'un Copy-on-Write (CoW) sistemi birbirleriyle etkileşime girer ve beklenenden çok daha fazla bellek tüketimine neden olabilir.

Bu makalede;

Linux sanal bellek mimarisi
Process adres alanı
Heap ve Stack yapıları
fork() sistem çağrısı
Copy-on-Write mekanizması
CPython nesne modeli
Reference Counting
fork() sonrası oluşan performans problemleri

konularını detaylı olarak inceleyeceğiz.

1. Bir Linux Sürecinin Bellek Yapısı

Bir proses oluşturulduğunda işletim sistemi ona sanal bir adres alanı tahsis eder.

Tipik görünüm:

+----------------------+
|      Kernel Space    |
+----------------------+

|        Stack         |
|        ↓↓↓           |
+----------------------+

|                      |
|      Free Area       |
|                      |
+----------------------+

|        Heap          |
|        ↑↑↑           |
+----------------------+

|   BSS / Data Segment |
+----------------------+

|      Text Segment    |
+----------------------+

Text Segment

Programın makine kodlarını içerir.

Örneğin:

print("Hello")

CPython yorumlayıcısının çalıştırdığı makine kodları burada bulunur.

Salt okunurdur.

Data Segment

Global değişkenler burada tutulur.

Örnek:

GLOBAL_COUNT = 100

Heap

Dinamik olarak oluşturulan nesneler burada yer alır.

Python'daki her nesne:

x = [1, 2, 3]

Heap üzerinde oluşturulur.

Bellek büyümesi yukarı doğrudur.

Heap
 ↑
 ↑
 ↑

Stack

Fonksiyon çağrıları burada tutulur.

Örnek:

def foo():
    x = 10

Buradaki:

değişkeninin referansı stack üzerinde bulunur.

Bellek büyümesi aşağı doğrudur.

 ↓
 ↓
 ↓
Stack

2. CPython Nesne Yapısı

Python'da her nesne aslında bir C yapısıdır.

Basitleştirilmiş hali:

typedef struct {
    Py_ssize_t ob_refcnt;
    PyTypeObject *ob_type;
} PyObject;

Bellekte:

+----------------+
| ob_refcnt = 3  |
+----------------+
| ob_type        |
+----------------+
| object data    |
+----------------+

Örnek:

x = [1, 2, 3]

Heap üzerinde:

Stack                    Heap

x  ------------->   [PyListObject]

3. Reference Counting Sistemi

CPython'un temel Garbage Collection mekanizmasıdır.

Referans Ekleme

a = [1,2,3]

b = a

Önce:

ob_refcnt = 1

Sonra:

ob_refcnt = 2

olur.

Referans Silme

del b

sonrası:

ob_refcnt = 1

Sıfıra Düşerse

ob_refcnt = 0

olursa:

free(object)

çalışır.

Nesne yok edilir.

4. fork() Sistem Çağrısı

Linux'ta yeni süreç oluşturmanın temel yöntemidir.

pid = fork();

Çağrı sonrası:

Parent Process
      |
      |
    fork()
      |
      |
      +------ Child Process

İlk bakışta sanki tüm RAM kopyalanıyormuş gibi görünür.

Ancak gerçekte durum farklıdır.

5. Copy-on-Write (CoW)

Linux performans için tüm belleği anında kopyalamaz.

Bunun yerine:

Parent
   |
   +------+
          |
          |
      Physical Page

aynı fiziksel sayfa hem parent hem child tarafından paylaşılır.

Örnek

Parent:

data = [1] * 1000000

100 MB bellek kullansın.

Fork sonrası:

pid = os.fork()

Normalde:

100 MB + 100 MB

olması gerekir.

Ancak Linux:

100 MB

kullanır.

Çünkü aynı sayfalar paylaşılır.

Sayfa Tablosu

Parent Page Table
      |
      +------> Physical Page

Child Page Table
      |
      +------> Physical Page

6. CoW Ne Zaman Tetiklenir?

Bir süreç yazma yaparsa.

Örnek:

data[0] = 999

İşletim sistemi şunu görür:

WRITE DETECTED

ve ilgili sayfayı kopyalar.

Parent ----> Page A

Child -----> Page B

Artık paylaşım sona ermiştir.

7. CPython ve Büyük Problem

Teorik olarak:

obj[0]

gibi bir okuma işlemi CoW tetiklememelidir.

Çünkü veri değişmiyordur.

Ancak CPython'da durum farklıdır.

8. Okuma Sırasında Reference Count Güncellenmesi

Örneğin:

item = obj[0]

CPython arka planda:

Py_INCREF(item);

çağırır.

Bu da:

ob_refcnt

alanına yazı yazılması anlamına gelir.

Bellekte:

+----------------+
| ob_refcnt = 7  |
+----------------+

olur:

+----------------+
| ob_refcnt = 8  |
+----------------+

Bu bir WRITE işlemidir.

9. CoW Neden Bozuluyor?

İşletim sistemi açısından:

READ OBJECT

değil,

WRITE MEMORY

gerçekleşmiştir.

Çünkü:

ob_refcnt++

yapılmıştır.

Sonuç:

Copy-on-Write Triggered

10. Sayfa Kopyalanması

Diyelim ki:

huge_data = [...]

10 milyon nesne içeriyor.

Fork sonrası:

pid = os.fork()

Bellek paylaşılır.

Child:

for x in huge_data:
    pass

çalıştırıyor.

Görünürde sadece okuma yapıyor.

Ancak gerçekte:

Py_INCREF(x);
Py_DECREF(x);

işlemleri sürekli çalışıyor.

Sonuç:

Page Modified

olur.

Linux:

Copy Page
Copy Page
Copy Page
Copy Page

işlemine başlar.

11. Bellek Patlaması

Başlangıç:

Parent = 4 GB
Child  = 0 GB ekstra

Toplam:

4 GB

Bir süre sonra:

Parent = 4 GB
Child  = 4 GB

Toplam:

8 GB

Buna literatürde sıklıkla:

Memory Double-Up

denir.

12. Multiprocessing'de Neden Görülür?

Örnek:

from multiprocessing import Process

Linux'ta varsayılan olarak:

fork

kullanılır.

Dolayısıyla:

100 GB dataset

yükleyip ardından:

8 worker

oluşturmak teoride:

100 GB

kullanmalı gibi görünür.

Pratikte:

800 GB+

RAM tüketimine kadar çıkabilir.

13. Modern Yapay Zeka Sistemlerinde Etkisi

Özellikle:

PyTorch
NumPy
Pandas
Transformers
TensorFlow

uygulamalarında önemlidir.

Örnek:

model = load_llm()
os.fork()

Çocuk süreç modeli okumaya başlar.

Referans sayaçları güncellenir.

CoW sayfaları kırılır.

RAM kullanımı hızla yükselir.

14. Python Geliştiricileri Ne Yapmalı?

Spawn Kullanmak

Linux'ta:

multiprocessing.set_start_method("spawn")

Forkserver Kullanmak

multiprocessing.set_start_method(
    "forkserver"
)

Shared Memory Kullanmak

Python 3.8+

from multiprocessing import shared_memory

NumPy Shared Memory

numpy.memmap

PyTorch

torch.multiprocessing

share_memory_()

kullanmak.

Sonuç

Linux'un fork() mekanizması, Copy-on-Write sayesinde başlangıçta son derece verimli görünür. Ancak CPython'un her nesnenin yaşam döngüsünü takip etmek için kullandığı Reference Counting sistemi, nesnelere yapılan masum görünen erişimlerde bile ob_refcnt alanına yazma işlemi gerçekleştirir.

Bu yazma işlemleri işletim sistemi tarafından gerçek bir bellek değişikliği olarak algılanır ve CoW sayfalarının kopyalanmasına neden olur. Sonuç olarak büyük veri kümeleri, yapay zekâ modelleri ve yüksek hacimli bellek kullanan uygulamalarda fork() sonrasında beklenmedik RAM artışları ortaya çıkabilir.

Bu nedenle ileri seviye Python geliştiricileri için yalnızca Python dilini bilmek yeterli değildir; CPython'un C seviyesindeki nesne modeli ile Linux çekirdeğinin sanal bellek yönetiminin nasıl etkileştiğini anlamak, yüksek performanslı sistemler tasarlamanın temel şartlarından biridir.

CPython Çalışma Zamanında Python Kodunun AST Bytecode PVM Yolculuğu

Vebende Akademi — Wed, 24 Jun 2026 12:00:00 +0000

CPython Çalışma Zamanında Python Kodunun AST → Bytecode → PVM Yolculuğu

Bir Python geliştiricisi için aşağıdaki soru oldukça önemlidir:

CPython çalışma zamanı ortamında bir .py dosyası çalıştırıldığında, kaynak kodun AST seviyesinden Bytecode seviyesine dönüştürülmesi ve Python Virtual Machine (PVM) üzerinde yürütülmesi sürecinde ilk gerçekleşen aşama nedir?

Doğru cevap:

Kaynak kodun tokenize edilerek Parse Tree'ye dönüştürülmesi ve ardından AST'nin oluşturulmasıdır.

Bu cevabı gerçekten anlayabilmek için CPython'un bir Python dosyasını nasıl çalıştırdığına derinlemesine bakalım.

Genel Mimari

Bir Python dosyası çalıştırıldığında CPython aşağıdaki adımları izler:

Python Kaynak Kodu (.py)
          │
          ▼
      Tokenizer
          │
          ▼
       Parser
          │
          ▼
      Parse Tree
          │
          ▼
         AST
          │
          ▼
 Bytecode Compiler
          │
          ▼
       Bytecode
          │
          ▼
      PVM (Python Virtual Machine)
          │
          ▼
       Sonuç

1. Kaynak Kodun Okunması

Örnek Python kodumuz:

x = 10
y = 20
print(x + y)

CPython ilk olarak dosyayı diskten okur.

Bu aşamada elimizde sadece metin vardır.

"x = 10\ny = 20\nprint(x+y)"

Henüz Python neyin değişken, neyin sayı olduğunu bilmez.

2. Tokenization (Lexical Analysis)

İlk gerçek derleme adımı budur.

Tokenizer kaynak kodu küçük anlamlı parçalara ayırır.

Örneğimiz:

x = 10

şuna dönüşür:

NAME     x
OP       =
NUMBER   10
NEWLINE

Tüm program için:

NAME(x)
=
NUMBER(10)

NAME(y)
=
NUMBER(20)

NAME(print)
(
NAME(x)
+
NAME(y)
)

Bu parçalara Token denir.

Token Nedir?

Token programlama dilinin en küçük anlamlı birimidir.

Örneğin:

if x > 5:

tokenlere ayrılır:

IF
NAME(x)
GREATER_THAN
NUMBER(5)
COLON

3. Parsing

Tokenlar tek başlarına yeterli değildir.

Parser bunların gramer kurallarına uygun olup olmadığını kontrol eder.

Örneğin:

x = 10

geçerli bir ifadedir.

Ama:

= x 10

gramere uymaz.

Parser hata verir:

SyntaxError

Parse Tree Oluşturulması

Parser başarılı olursa bir Parse Tree üretir.

Örneğin:

x = 10

için:

Assignment
├── Variable(x)
└── Number(10)

Bu yapı Python dilinin dilbilgisine bağlıdır.

Çok detaylıdır.

Bu nedenle bir sonraki aşamada sadeleştirilir.

4. AST (Abstract Syntax Tree)

AST = Soyut Sözdizimi Ağacı

Parse Tree'deki gereksiz gramer detayları kaldırılır.

Örnek:

x = 10

AST:

Assign
├── Name(x)
└── Constant(10)

Daha karmaşık örnek:

result = x + y * 2

AST:

Assign
├── Name(result)
└── BinOp(+)
     ├── Name(x)
     └── BinOp(*)
          ├── Name(y)
          └── Constant(2)

AST artık programın mantıksal yapısını temsil eder.

AST'yi Python İçinden Görmek

import ast

code = """
x = 10
y = 20
print(x+y)
"""

tree = ast.parse(code)

print(ast.dump(tree, indent=4))

Çıktı:

Module(
    body=[
        Assign(...),
        Assign(...),
        Expr(...)
    ]
)

CPython'un derleyicisi de tam olarak bu AST üzerinden çalışır.

5. Bytecode Üretimi

AST daha sonra Bytecode Compiler'a gönderilir.

Burada Python'a özgü sanal makine komutları üretilir.

Örnek:

x = 10
print(x)

Bytecode'u Görüntüleme

import dis

def demo():
    x = 10
    print(x)

dis.dis(demo)

Çıktı benzeri:

LOAD_CONST 10
STORE_FAST x

LOAD_GLOBAL print
LOAD_FAST x

CALL
POP_TOP

RETURN_VALUE

Artık Python kodu yoktur.

Artık Bytecode vardır.

Bytecode Nedir?

Bytecode:

Makine kodu değildir
CPU tarafından çalıştırılamaz
Platform bağımsızdır
PVM tarafından çalıştırılır

Bir anlamda:

Python Kaynak Kodu
       ↓
Bytecode
       ↓
Makine Kodu

şeklinde düşünebiliriz.

6. .pyc Dosyası Oluşturulması

CPython bytecode'u cacheleyebilir.

__pycache__/

altında:

main.cpython-313.pyc

gibi dosyalar oluşur.

Bunlar doğrudan Bytecode içerir.

Ama dikkat:

.pyc = Bytecode

değildir tamamen.

İçinde ayrıca:

sürüm bilgisi
timestamp
metadata

bulunur.

7. Python Virtual Machine (PVM)

Bytecode artık çalıştırılmaya hazırdır.

Devreye PVM girer.

PVM:

LOAD_CONST
STORE_FAST
LOAD_FAST
CALL
RETURN_VALUE

gibi komutları tek tek işler.

PVM Döngüsü

Basitleştirilmiş hali:

while True:
    instruction = next_instruction()

    execute(instruction)

Gerçekte CPython'un kalbi olan:

ceval.c

dosyasında çalışır.

Temel yapı:

for (;;) {
    opcode = NEXTOP();
    switch(opcode) {
        ...
    }
}

şeklindedir.

Buna:

Interpreter Loop

veya

Evaluation Loop

denir.

Stack-Based Mimari

PVM bir stack kullanır.

Örnek:

print(2 + 3)

Bytecode:

LOAD_CONST 2
LOAD_CONST 3
BINARY_ADD
PRINT

Stack hareketi:

[]

[2]

[2,3]

[5]

[]

Bu yüzden Python VM'e:

Stack Based Virtual Machine

denir.

Gerçek Süreç Adım Adım

Kod:

x = 10
y = 20
print(x+y)

CPython içinde:

Adım 1

Kaynak kod okunur.

Source Code

↓

Adım 2

Tokenization

NAME
NUMBER
OPERATOR

↓

Adım 3

Parsing

Parse Tree

↓

Adım 4

AST oluşturulur.

Abstract Syntax Tree

↓

Adım 5

Compiler çalışır.

Bytecode

↓

Adım 6

Bytecode oluşturulur.

.pyc

↓

Adım 7

PVM bytecode'u yürütür.

Execution

↓

Adım 8

Program sonucu üretilir.

Mülakat ve Sertifikasyon İçin Kritik Bilgi

Sorudaki ifade:

"AST seviyesinden Bytecode seviyesine dönüştürülmesi ve PVM üzerinde çalıştırılması sürecinde ilk gerçekleşen aşama hangisidir?"

cevaplanırken birçok kişi doğrudan:

AST → Bytecode

dönüşümünü düşünür.

Fakat AST'nin oluşabilmesi için önce:

Source Code okunur
Tokenization yapılır
Parse Tree oluşturulur
AST oluşturulur

Bu nedenle süreçte ilk gerçekleşen kritik derleme aşaması:

Kaynak kodun tokenize edilmesi, Parse Tree'nin oluşturulması ve ardından AST'nin inşa edilmesidir.

Bu aşama tamamlanmadan Bytecode üretimine geçilemez ve PVM'in çalıştıracağı hiçbir komut oluşamaz.

Özet

CPython'un yürütme zinciri:

.py Source Code
        │
        ▼
Tokenization
        │
        ▼
Parsing
        │
        ▼
Parse Tree
        │
        ▼
AST
        │
        ▼
Bytecode Compiler
        │
        ▼
Bytecode (.pyc)
        │
        ▼
Python Virtual Machine (PVM)
        │
        ▼
Program Execution

Dolayısıyla sorudaki doğru yaklaşım:

İlk olarak kaynak kod tokenize edilir, Parse Tree oluşturulur ve bu yapıdan AST üretilir. Bytecode üretimi ve PVM yürütmesi daha sonraki aşamalardır.

PYTHON STANDARD LIBRARY – KURUMSAL GELİŞTİRME REHBERİ

Vebende Akademi — Mon, 22 Jun 2026 09:38:36 +0000

PYTHON STANDARD LIBRARY – KURUMSAL GELİŞTİRME REHBERİ

Python standart kütüphanesi, harici bir paket yüklemeden üretim seviyesinde yazılım geliştirmeyi mümkün kılan çekirdek araç setidir. Bu yapı; veri işleme, sistem entegrasyonu, ağ iletişimi, concurrency, güvenlik ve otomasyon gibi alanları kapsayan bir ekosistem sunar.

Aşağıda bu ekosistemi fonksiyonel katmanlar halinde detaylandırıyoruz.

1. Matematik ve Sayısal Hesaplama Katmanı

math

Temel matematiksel operasyonlar için kullanılır.

Önemli fonksiyonlar:

sqrt(x) → karekök
ceil(x) → yukarı yuvarlama
floor(x) → aşağı yuvarlama
pow(x, y) → üs alma
log(x, base) → logaritma
sin(x), cos(x), tan(x) → trigonometrik işlemler

Kullanım alanı: finans, mühendislik, ML feature engineering

cmath

Kompleks sayılar için matematik katmanı.

Önemli fonksiyonlar:

cmath.sqrt()
cmath.phase()
cmath.polar()
cmath.rect()

decimal

Hassas finansal hesaplama için kritik modül.

Önemli fonksiyonlar:

Decimal(x) → hassas sayı oluşturma
getcontext() → precision kontrolü

Kullanım: bankacılık, muhasebe sistemleri

fractions

Kesirli sayı hesaplama.

Önemli fonksiyonlar:

Fraction(n, d) → kesir oluşturma
otomatik sadeleştirme

statistics

Veri analizi ve istatistiksel hesaplamalar.

Önemli fonksiyonlar:

mean() → ortalama
median() → medyan
mode() → tepe değer
variance() → varyans
stdev() → standart sapma

random

Simülasyon, test ve rastgele veri üretimi.

Önemli fonksiyonlar:

random() → 0-1 arası sayı
randint(a,b) → aralıkta tamsayı
choice(list) → rastgele seçim
shuffle(list) → karıştırma
sample(population, k) → örnekleme

2. Veri Yapıları ve Koleksiyon Katmanı

collections

Gelişmiş veri yapıları sağlar.

Önemli sınıflar:

Counter → frekans sayımı
deque → çift uçlu kuyruk
defaultdict → default dictionary
namedtuple → alan bazlı tuple

array

Tip güvenli düşük seviyeli diziler.

Önemli fonksiyonlar:

array(type, values)
append()

heapq

Öncelik kuyruğu (priority queue) yapısı.

Önemli fonksiyonlar:

heappush()
heappop()
heapify()

queue

Thread-safe kuyruk yapıları.

Önemli sınıflar:

Queue
LifoQueue
PriorityQueue

bisect

Sıralı listelerde binary insert işlemleri.

Önemli fonksiyonlar:

bisect_left()
bisect_right()
insort()

3. Tarih ve Zaman Yönetimi

datetime

Kurumsal sistemlerin zaman omurgasıdır.

Önemli sınıflar/fonksiyonlar:

datetime.now()
datetime.today()
timedelta
strftime() / strptime()

time

Düşük seviye zaman işlemleri.

Önemli fonksiyonlar:

time()
sleep()
perf_counter() → performans ölçüm

calendar

Takvim hesaplamaları.

Önemli fonksiyonlar:

month()
calendar()
isleap()

zoneinfo

Zaman dilimi yönetimi.

Önemli özellik:

TZ bazlı datetime işlemleri

4. Dosya Sistemi ve OS Katmanı

os

İşletim sistemi ile iletişim.

Önemli fonksiyonlar:

getcwd()
listdir()
mkdir()
remove()
environ

sys

Python runtime kontrolü.

Önemli fonksiyonlar:

sys.argv
sys.path
sys.exit()

pathlib

Modern dosya yolu yönetimi.

Önemli sınıf:

Path()

Önemli fonksiyonlar:

exists()
read_text()
write_text()

shutil

Dosya operasyonları.

Önemli fonksiyonlar:

copy()
move()
rmtree()

subprocess

Sistem komutu çalıştırma.

Önemli fonksiyonlar:

run()
Popen()

5. Veri Formatları ve Serialization

json

API ve veri değişimi standardı.

Önemli fonksiyonlar:

json.dumps()
json.loads()
json.dump()
json.load()

csv

Tablolu veri işleme.

Önemli fonksiyonlar:

reader()
writer()

pickle

Python nesne serialization.

Önemli fonksiyonlar:

dump()
load()

configparser

Config dosyaları yönetimi.

Önemli fonksiyonlar:

read()
sections()

xml.etree.ElementTree

XML parsing.

Önemli fonksiyonlar:

parse()
Element()
find()

6. UUID ve Kimlik Yönetimi

uuid

Dağıtık sistemlerde benzersiz kimlik üretimi.

Önemli fonksiyonlar:

uuid4() → rastgele UUID
uuid1() → timestamp tabanlı
uuid5() → namespace hash

7. Metin İşleme ve Regex

re

Pattern matching motoru.

Önemli fonksiyonlar:

search()
match()
findall()
sub()
split()

string

String sabitleri ve yardımcılar.

textwrap

Metin formatlama.

Önemli fonksiyonlar:

wrap()
fill()

8. Network ve Internet

socket

Düşük seviyeli network iletişimi.

Önemli fonksiyonlar:

socket()
bind()
listen()
connect()

urllib

URL işlemleri.

Önemli modüller:

request
parse

ssl

Güvenli iletişim.

email

Email üretimi ve parsing.

9. Concurrency (Eşzamanlılık)

threading

Thread tabanlı paralellik.

Önemli sınıflar:

Thread
Lock

multiprocessing

Process bazlı paralellik.

Önemli sınıflar:

Process
Pool

asyncio

Asenkron programlama çekirdeği.

Önemli fonksiyonlar:

async
await
create_task()
run()

concurrent.futures

Yüksek seviye paralellik.

Önemli sınıflar:

ThreadPoolExecutor
ProcessPoolExecutor

10. Logging, Debug ve Test

logging

Kurumsal loglama sistemi.

Önemli fonksiyonlar:

debug()
info()
warning()
error()
critical()

unittest

Test framework.

Önemli sınıflar:

TestCase
assertEqual()

doctest

Docstring test sistemi.

pdb

Debugging aracı.

11. Güvenlik ve Hashing

hashlib

Hash algoritmaları.

Önemli fonksiyonlar:

sha256()
md5()
hexdigest()

hmac

Message authentication.

secrets

Kriptografik random üretimi.

Önemli fonksiyonlar:

token_hex()
choice()

12. Compression & Archive

zipfile

ZIP dosyaları.

Önemli fonksiyonlar:

ZipFile()
extractall()

tarfile

TAR arşivleri.

13. Runtime Kontrol

sys

Interpreter kontrolü.

gc

Garbage collector yönetimi.

platform

Sistem bilgisi.

importlib

Dinamik import sistemi.

GENEL MİMARİ YORUM (EĞİTMEN PERSPEKTİFİ)

Python standard library 3 kritik katmana ayrılır:

1. Core Runtime Layer

(os, sys, pathlib, json)

2. Enterprise Logic Layer

(logging, threading, subprocess, uuid)

3. System Integration Layer

(socket, ssl, multiprocessing, asyncio)

Python Lambda İfadeleri: Anonim Fonksiyonlar ve Sınırları

Vebende Akademi — Sun, 21 Jun 2026 16:10:05 +0000

Python Lambda İfadeleri: Anonim Fonksiyonlar ve Sınırları

Python programlama dilinde kod yazarken bazen yalnızca bir kez kullanılacak küçük fonksiyonlara ihtiyaç duyarız. Bu tür durumlarda klasik def anahtar kelimesiyle fonksiyon tanımlamak yerine daha kısa ve pratik bir yöntem olan lambda ifadeleri kullanılabilir.

Lambda ifadeleri Python'ın fonksiyonel programlama yaklaşımını destekleyen güçlü araçlarından biridir. Ancak birçok geliştirici lambda kullanımında aşırıya kaçmakta veya okunabilirliği düşüren yapılar oluşturmaktadır. Bu nedenle lambda ifadelerinin ne zaman kullanılacağını ve ne zaman kullanılmaması gerektiğini anlamak oldukça önemlidir.

Lambda Nedir?

Lambda, isimsiz (anonymous) fonksiyon oluşturmak için kullanılan özel bir ifadedir.

Normal fonksiyon:

def kare_al(x):
    return x * x

Lambda karşılığı:

kare_al = lambda x: x * x

Kullanımı:

print(kare_al(5))

Çıktı:

Burada dikkat edilmesi gereken nokta, fonksiyonun herhangi bir isimle tanımlanmadan oluşturulabilmesidir.

Lambda Sözdizimi

Genel yapı:

lambda parametreler: ifade

Örnek:

lambda x: x + 10

Bu ifade aslında aşağıdaki fonksiyonun kısa halidir:

def fonksiyon(x):
    return x + 10

Birden Fazla Parametre Kullanımı

Lambda fonksiyonları birden fazla parametre alabilir.

topla = lambda a, b: a + b

print(topla(10, 20))

Çıktı:

Üç parametre:

hacim = lambda en, boy, yukseklik: en * boy * yukseklik

print(hacim(3, 4, 5))

Çıktı:

Lambda ile Koşullu İfadeler

Lambda içerisinde tek satırlık koşullar kullanılabilir.

Normal fonksiyon:

def cift_mi(sayi):
    if sayi % 2 == 0:
        return "Çift"
    else:
        return "Tek"

Lambda karşılığı:

cift_mi = lambda sayi: "Çift" if sayi % 2 == 0 else "Tek"

print(cift_mi(8))
print(cift_mi(7))

Çıktı:

Çift
Tek

Lambda ve sorted()

Lambda'nın en yaygın kullanım alanlarından biri sıralama işlemleridir.

Basit Liste Sıralama

sayilar = [5, 2, 8, 1, 9]

sirali = sorted(sayilar)

print(sirali)

Karmaşık Veri Yapılarını Sıralama

Öğrencileri nota göre sıralayalım:

ogrenciler = [
    ("Ali", 75),
    ("Ayşe", 95),
    ("Mehmet", 60),
    ("Zeynep", 85)
]

sonuc = sorted(
    ogrenciler,
    key=lambda ogrenci: ogrenci[1]
)

print(sonuc)

Çıktı:

[
 ('Mehmet', 60),
 ('Ali', 75),
 ('Zeynep', 85),
 ('Ayşe', 95)
]

Ters Sıralama

sonuc = sorted(
    ogrenciler,
    key=lambda ogrenci: ogrenci[1],
    reverse=True
)

print(sonuc)

Çıktı:

[
 ('Ayşe', 95),
 ('Zeynep', 85),
 ('Ali', 75),
 ('Mehmet', 60)
]

Lambda ve map()

map() fonksiyonu bir koleksiyonun tüm elemanlarına belirli bir işlemi uygular.

Örnek:

sayilar = [1, 2, 3, 4, 5]

sonuc = list(
    map(
        lambda x: x * 2,
        sayilar
    )
)

print(sonuc)

Çıktı:

[2, 4, 6, 8, 10]

Metinleri Büyük Harfe Çevirme

isimler = ["ali", "ayşe", "mehmet"]

sonuc = list(
    map(
        lambda isim: isim.upper(),
        isimler
    )
)

print(sonuc)

Çıktı:

['ALI', 'AYŞE', 'MEHMET']

Lambda ve filter()

Belirli bir koşulu sağlayan elemanları filtrelemek için kullanılır.

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

ciftler = list(
    filter(
        lambda x: x % 2 == 0,
        sayilar
    )
)

print(ciftler)

Çıktı:

[2, 4, 6, 8, 10]

18 Yaş Üstünü Filtreleme

yaslar = [15, 22, 17, 30, 18, 12]

yetiskinler = list(
    filter(
        lambda yas: yas >= 18,
        yaslar
    )
)

print(yetiskinler)

Çıktı:

[22, 30, 18]

Lambda ve reduce()

reduce() fonksiyonu koleksiyon elemanlarını tek bir sonuca indirger.

from functools import reduce

sayilar = [1,2,3,4,5]

toplam = reduce(
    lambda x, y: x + y,
    sayilar
)

print(toplam)

Çıktı:

Çarpım Hesaplama

from functools import reduce

sayilar = [1,2,3,4]

sonuc = reduce(
    lambda x, y: x * y,
    sayilar
)

print(sonuc)

Çıktı:

Lambda ve Dictionary İşlemleri

Sözlüklerde belirli alanlara göre sıralama yapmak oldukça yaygındır.

urunler = [
    {"ad": "Laptop", "fiyat": 45000},
    {"ad": "Tablet", "fiyat": 12000},
    {"ad": "Telefon", "fiyat": 30000}
]

sonuc = sorted(
    urunler,
    key=lambda urun: urun["fiyat"]
)

print(sonuc)

Lambda ve Çoklu Anahtar Sıralama

kisiler = [
    ("Ali", "Yazılım"),
    ("Ayşe", "Muhasebe"),
    ("Ali", "Finans"),
    ("Mehmet", "Yazılım")
]

sonuc = sorted(
    kisiler,
    key=lambda x: (x[0], x[1])
)

print(sonuc)

Burada önce isim, sonra departman baz alınmaktadır.

Lambda ve List Comprehension Karşılaştırması

Lambda ile:

sonuc = list(
    map(
        lambda x: x * 2,
        sayilar
    )
)

List comprehension ile:

sonuc = [x * 2 for x in sayilar]

Python topluluğu genellikle ikinci yaklaşımı daha okunabilir bulmaktadır.

Lambda'nın Sınırları

Lambda ifadelerinin bazı önemli kısıtları vardır.

1. Sadece Tek İfade Kullanılabilir

Geçersiz:

lambda x:
    y = x * 2
    return y

Lambda içinde:

Döngü
Atama
Çok satırlı işlem
try/except

kullanılamaz.

2. Dokümantasyon Zordur

hesapla = lambda x: x * x

yerine

def hesapla(x):
    """
    Sayının karesini döndürür.
    """
    return x * x

daha açıklayıcıdır.

3. Debug İşlemleri Daha Zordur

Bir hata oluştuğunda:

<lambda>

şeklinde görünür.

Normal fonksiyonlarda ise fonksiyon ismi görünür.

4. Okunabilirlik Problemleri

Kötü örnek:

sonuc = lambda a,b,c,d,e: (
    a+b if a>b else c*d if d>e else e
)

Bunu anlamak oldukça zordur.

Daha doğru yaklaşım:

def hesapla(a, b, c, d, e):

    if a > b:
        return a + b

    if d > e:
        return c * d

    return e

Python Geliştiricileri İçin Genel Kural

Aşağıdaki durumlarda lambda kullanın:

Basit dönüşümler
map()
filter()
sorted()
key parametreleri
Kısa callback işlemleri

Aşağıdaki durumlarda normal fonksiyon kullanın:

Birden fazla işlem varsa
Karmaşık iş kuralları varsa
Hata yönetimi gerekiyorsa
Test edilebilirlik önemliyse
Dokümantasyon gerekiyorsa

Python ve C# Karşılaştırması

Python:

kare = lambda x: x * x

print(kare(5))

C#:

Func<int, int> kare = x => x * x;

Console.WriteLine(kare(5));

Python lambda ve C# lambda ifadeleri benzer görünse de C# tarafında LINQ ekosistemi ile çok daha yoğun kullanılmaktadır.

Sonuç

Lambda ifadeleri Python'un en zarif özelliklerinden biridir. Özellikle sorted(), map(), filter() ve reduce() gibi fonksiyonlarla birlikte kullanıldığında kod miktarını ciddi şekilde azaltabilir. Ancak lambda'nın amacı küçük ve tek satırlık işlemler gerçekleştirmektir. Kod büyümeye başladığında veya iş mantığı karmaşıklaştığında normal fonksiyonlara geçmek okunabilirlik, bakım kolaylığı ve hata ayıklama açısından çok daha doğru bir yaklaşım olacaktır.

Deneyimli Python geliştiricilerinin genel yaklaşımı şu şekildedir:

Eğer lambda ifadesini açıklamak zorunda kalıyorsanız, büyük ihtimalle normal bir def fonksiyonu yazmanız gerekiyordur.

Gelişmiş Veri İşleme (Python)

Vebende Akademi — Sun, 21 Jun 2026 09:12:32 +0000

Gelişmiş Veri İşleme (Python)

Sıralama, Filtreleme ve Arama – Profesyonel Veri Manipülasyonu Rehberi

Python’da veri işleme, sadece döngülerden ibaret değildir. Modern Python yaklaşımı; fonksiyonel programlama araçları, yüksek seviyeli built-in fonksiyonlar ve lambda ifadeleri ile daha kısa, daha okunabilir ve daha performanslı çözümler üretmeyi hedefler.

Bu bölümde dört kritik alanı derinlemesine inceleyeceğiz:

sorted() ile gelişmiş sıralama
lambda ile karmaşık veri yapıları üzerinde sıralama
filter() ve map() ile fonksiyonel veri dönüşümü
any() ve all() ile toplu doğrulama (validation)

Her bölümde gerçek dünya senaryoları ve hands-on örnekler olacak.

1. sorted() Fonksiyonu — Gelişmiş Sıralama Motoru

1.1 Temel Yapı

sorted(iterable, key=None, reverse=False)

Parametreler:

iterable: Liste, tuple, set vb.
key: Sıralama kriteri (fonksiyon)
reverse: True → büyükten küçüğe

1.2 Basit Sıralama

```python id="s1"
sayilar = [5, 1, 9, 3, 7]

sonuc = sorted(sayilar)

print(sonuc)




---

## 1.3 Ters Sıralama



```python id="s2"
sayilar = [5, 1, 9, 3, 7]

print(sorted(sayilar, reverse=True))

1.4 Tuple Sıralama

```python id="s3"
veri = (10, 5, 20, 15)

print(sorted(veri))




---

## 1.5 String Sıralama (ASCII mantığı)



```python id="s4"
kelimeler = ["python", "ai", "data", "backend"]

print(sorted(kelimeler))

2. key Parametresi — Sıralamanın Beyni

sorted() fonksiyonunun gerçek gücü burada başlar.

2.1 String Uzunluğuna Göre Sıralama

```python id="k1"
kelimeler = ["python", "ai", "veri", "makineöğrenmesi"]

sonuc = sorted(kelimeler, key=len)

print(sonuc)




---

## 2.2 Sayıların Moduna Göre Sıralama



```python id="k2"
sayilar = [10, 3, 7, 21, 14, 9]

sonuc = sorted(sayilar, key=lambda x: x % 5)

print(sonuc)

2.3 Tuple Sıralama (Gerçek Dünya)

```python id="k3"
urunler = [
("Laptop", 45000),
("Mouse", 500),
("Monitör", 12000)
]

sonuc = sorted(urunler, key=lambda x: x[1])

print(sonuc)




---

## 2.4 Çok Katmanlı Sıralama

Fiyat → sonra isim



```python id="k4"
urunler = [
    ("Laptop", 45000),
    ("Mouse", 500),
    ("Monitör", 12000),
    ("Laptop Pro", 45000)
]

sonuc = sorted(
    urunler,
    key=lambda x: (x[1], x[0])
)

print(sonuc)

2.5 Dictionary Sıralama

```python id="k5"
urunler = {
"Laptop": 45000,
"Mouse": 500,
"Monitör": 12000
}

sonuc = sorted(
urunler.items(),
key=lambda x: x[1]
)

print(sonuc)




---

# 3. Lambda ile Karmaşık Sıralama

Lambda = isimsiz fonksiyon

---

## 3.1 Temel Lambda



```python id="l1"
f = lambda x: x * 2

print(f(5))

3.2 Sıralamada Lambda Kullanımı

```python id="l2"
ogrenciler = [
{"ad": "Ali", "not": 80},
{"ad": "Ayşe", "not": 95},
{"ad": "Mehmet", "not": 70}
]

print(sorted(ogrenciler, key=lambda x: x["not"]))




---

## 3.3 En Yüksek Not



```python id="l3"
print(sorted(ogrenciler, key=lambda x: x["not"], reverse=True))

3.4 Çok Alanlı Sıralama

```python id="l4"
data = [
{"ad": "Ali", "not": 80, "yas": 22},
{"ad": "Ayşe", "not": 80, "yas": 20},
{"ad": "Mehmet", "not": 70, "yas": 25}
]

sonuc = sorted(
data,
key=lambda x: (-x["not"], x["yas"])
)

print(sonuc)




---

# 4. filter() — Veri Filtreleme Motoru

## 4.1 Temel Yapı



```python
filter(function, iterable)

4.2 Çift Sayıları Filtreleme

```python id="f1"
sayilar = [1, 2, 3, 4, 5, 6]

ciftler = list(filter(lambda x: x % 2 == 0, sayilar))

print(ciftler)




---

## 4.3 Boş Değer Temizleme



```python id="f2"
veri = ["Ali", "", "Ayşe", None, "Mehmet"]

temiz = list(filter(None, veri))

print(temiz)

4.4 10’dan Büyük Sayılar

```python id="f3"
sayilar = [5, 10, 15, 3, 20]

sonuc = list(filter(lambda x: x > 10, sayilar))

print(sonuc)




---

## 4.5 Dictionary Filter



```python id="f4"
urunler = [
    {"ad": "Laptop", "stok": 10},
    {"ad": "Mouse", "stok": 0},
    {"ad": "Monitör", "stok": 5}
]

sonuc = list(
    filter(lambda x: x["stok"] > 0, urunler)
)

print(sonuc)

5. map() — Veri Dönüştürme Motoru

5.1 Temel Yapı

map(function, iterable)

5.2 Sayıları 2 ile Çarpma

```python id="m1"
sayilar = [1, 2, 3, 4]

sonuc = list(map(lambda x: x * 2, sayilar))

print(sonuc)




---

## 5.3 String Uppercase



```python id="m2"
isimler = ["ali", "ayşe", "mehmet"]

sonuc = list(map(str.upper, isimler))

print(sonuc)

5.4 Float → Int Dönüşüm

```python id="m3"
sayilar = [1.2, 3.7, 5.9]

sonuc = list(map(int, sayilar))

print(sonuc)




---

## 5.5 Dictionary Transform



```python id="m4"
urunler = [
    {"ad": "Laptop", "fiyat": 1000},
    {"ad": "Mouse", "fiyat": 50}
]

sonuc = list(
    map(lambda x: x["fiyat"] * 1.2, urunler)
)

print(sonuc)

5.6 map + lambda vs comprehension

```python id="m5"

map

list(map(lambda x: x * 2, range(5)))

comprehension (tercih edilir)

[x * 2 for x in range(5)]




---

# 6. any() — En Az Bir True Var mı?

## 6.1 Temel Kullanım



```python id="a1"
sayilar = [0, 0, 1, 0]

print(any(sayilar))

6.2 Şart Kontrolü

```python id="a2"
sayilar = [2, 4, 6, 7]

print(any(x % 2 == 1 for x in sayilar))




---

## 6.3 Kullanıcı Kontrolü



```python id="a3"
kullanicilar = [
    {"aktif": False},
    {"aktif": False},
    {"aktif": True}
]

print(any(u["aktif"] for u in kullanicilar))

7. all() — Hepsi True mu?

7.1 Temel Kullanım

```python id="al1"
sayilar = [1, 2, 3, 4]

print(all(sayilar))




---

## 7.2 Tüm Sayılar Pozitif mi?



```python id="al2"
sayilar = [1, 2, 3, -1]

print(all(x > 0 for x in sayilar))

7.3 Validation Sistemi

```python id="al3"
form = {
"email": "test@mail.com",
"password": "12345",
"username": "admin"
}

print(all(form.values()))




---

# 8. any() vs all() Karşılaştırma

| Fonksiyon | Anlam        |
| --------- | ------------ |
| any()     | en az 1 True |
| all()     | hepsi True   |

---

# 9. Gerçek Hayat Hands-On Projeler

---

## 9.1 Log Analizi Sistemi



```python id="r1"
loglar = [
    {"level": "INFO"},
    {"level": "ERROR"},
    {"level": "INFO"}
]

errors = list(
    filter(lambda x: x["level"] == "ERROR", loglar)
)

print(errors)

9.2 En Pahalı Ürün

```python id="r2"
urunler = [
("A", 100),
("B", 500),
("C", 300)
]

en_pahali = max(urunler, key=lambda x: x[1])

print(en_pahali)




---

## 9.3 Geçerli Kullanıcı Kontrolü



```python id="r3"
kullanicilar = [
    {"ad": "Ali", "aktif": True},
    {"ad": "Ayşe", "aktif": False}
]

print(any(u["aktif"] for u in kullanicilar))
print(all(u["aktif"] for u in kullanicilar))

9.4 Veri Pipeline

```python id="r4"
data = [10, 15, 20, 25, 30]

sonuc = list(
map(
lambda x: x * 2,
filter(lambda x: x > 15, data)
)
)

print(sonuc)




---

# 10. Performans Perspektifi

* comprehension > map/filter (çoğu durumda)
* sorted() C implementasyonu ile çok hızlıdır
* any/all short-circuit çalışır (erken durur)

---

# 11. Python ve C# Karşılaştırma

## sorted()



```python
sorted(data, key=lambda x: x["not"])

data.OrderBy(x => x.Not);

filter()

list(filter(lambda x: x > 10, data))

data.Where(x => x > 10);

map()

list(map(lambda x: x * 2, data))

data.Select(x => x * 2);

12. Özet

Bu makalede öğrendiklerin:

sorted()

Gelişmiş sıralama
key parametresi
lambda ile multi-sort

filter()

veri eleme
koşullu filtreleme

map()

veri dönüşümü

any / all

toplu doğrulama

Sonuç

Bu fonksiyonlar Python’un fonksiyonel programlama çekirdeğini oluşturur.

Modern backend, AI pipeline, data engineering sistemlerinde:

sorted → ranking
filter → cleaning
map → transformation
any/all → validation

olarak kritik rol oynar.

Python Dictionary ve Set Comprehensions: Sıfırdan İleri Seviye Kapsamlı Rehber

Vebende Akademi — Sun, 21 Jun 2026 09:07:34 +0000

Python Dictionary ve Set Comprehensions: Sıfırdan İleri Seviye Kapsamlı Rehber

Python’da comprehension yapıları, kodu hem daha okunabilir hem de daha performanslı hale getiren modern programlama yaklaşımıdır.

En çok bilinenler:

List Comprehension
Dictionary Comprehension
Set Comprehension

Bu makalede özellikle Dictionary ve Set Comprehension yapılarını:

mantık
performans
gerçek dünya kullanımı
bol hands-on örneklerle

derinlemesine öğreneceksin.

1. Comprehension Nedir?

Comprehension, döngü ve koşul yapısını tek satırda ifade etme yöntemidir.

Klasik yöntem:

```python id="c1"
kareler = []

for x in range(10):
kareler.append(x * x)

print(kareler)




Comprehension:



```python id="c2"
kareler = [x * x for x in range(10)]

Ama bugün odak:

Dictionary Comprehension
Set Comprehension

2. Dictionary Comprehension (Sözlük Üretimi)

Dictionary comprehension, key-value çiftlerini tek satırda üretme yöntemidir.

2.1 Temel Yapı

{key: value for item in iterable}

2.2 İlk Örnek – Kare Tablosu

```python id="d1"
kareler = {
x: x * x
for x in range(1, 6)
}

print(kareler)




Çıktı:



```text
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

2.3 Koşullu Dictionary Comprehension

Sadece çift sayılar:

```python id="d2"
cift_kareler = {
x: x * x
for x in range(10)
if x % 2 == 0
}

print(cift_kareler)




---

## 2.4 String → Dictionary



```python id="d3"
kelimeler = ["python", "java", "csharp"]

uzunluk = {
    k: len(k)
    for k in kelimeler
}

print(uzunluk)

2.5 Veriyi Normalize Etme (Real World)

```python id="d4"
ham_veri = [" Ali ", " Ayşe ", " Mehmet "]

temiz = {
isim.strip().lower(): len(isim.strip())
for isim in ham_veri
}

print(temiz)




---

## 2.6 Key Mapping (API Transform)



```python id="d5"
api_response = [
    ("id", 1),
    ("name", "Laptop"),
    ("price", 45000)
]

product = {
    k: v
    for k, v in api_response
}

print(product)

2.7 Nested Dictionary Comprehension

```python id="d6"
data = {
f"item_{x}": {
"value": x,
"square": x * x
}
for x in range(5)
}

print(data)




---

## 2.8 Dictionary Filtering (Log Analizi)



```python id="d7"
logs = {
    "INFO": 120,
    "ERROR": 5,
    "WARNING": 10
}

critical = {
    k: v
    for k, v in logs.items()
    if v > 10
}

print(critical)

3. Set Comprehension (Küme Üretimi)

Set comprehension, benzersiz veri üretmek için kullanılır.

3.1 Temel Yapı

{expression for item in iterable}

3.2 İlk Örnek

```python id="s1"
kareler = {
x * x
for x in range(10)
}

print(kareler)




---

## 3.3 Duplicate Otomatik Silme



```python id="s2"
veri = [1, 2, 2, 3, 3, 4, 5]

unique = {
    x
    for x in veri
}

print(unique)

3.4 String Set Comprehension

```python id="s3"
kelime = "python programming"

harfler = {
c
for c in kelime
if c != " "
}

print(harfler)




---

## 3.5 Filtreleme (Sadece Çift Sayılar)



```python id="s4"
ciftler = {
    x
    for x in range(20)
    if x % 2 == 0
}

print(ciftler)

3.6 Unique Domain Extraction (Real World)

```python id="s5"
emails = [
"ali@gmail.com",
"ayse@gmail.com",
"mehmet@yahoo.com",
"zeynep@gmail.com"
]

domainler = {
email.split("@")[1]
for email in emails
}

print(domainler)




---

## 3.7 Log Level Extraction



```python id="s6"
logs = [
    "INFO: start",
    "ERROR: fail",
    "INFO: continue",
    "WARNING: slow"
]

tipler = {
    log.split(":")[0]
    for log in logs
}

print(tipler)

3.8 Set + Condition (Data Cleaning)

```python id="s7"
veri = [10, 20, -5, 30, -1, 40]

temiz = {
x
for x in veri
if x > 0
}

print(temiz)




---

# 4. Dictionary vs Set Comprehension

| Özellik    | Dictionary  | Set             |
| ---------- | ----------- | --------------- |
| Çıktı tipi | key-value   | unique values   |
| Duplicate  | key unique  | tamamen unique  |
| Kullanım   | mapping     | filtering       |
| Performans | O(1) lookup | O(1) membership |

---

# 5. Gerçek Hayat Kullanım Senaryoları

## 5.1 API Response Mapping



```python id="r1"
response = [
    ("status", "ok"),
    ("code", 200),
    ("time", "120ms")
]

result = {
    k: v
    for k, v in response
}

print(result)

5.2 Data Deduplication Pipeline

```python id="r2"
raw = [
"user1",
"user2",
"user1",
"user3"
]

unique_users = {
u
for u in raw
}

print(unique_users)




---

## 5.3 Feature Engineering (AI / ML)



```python id="r3"
features = {
    f"x{i}": i * 2
    for i in range(10)
}

print(features)

5.4 KPI Filtering

```python id="r4"
kpi = {
"sales": 100,
"cost": 90,
"profit": 10
}

filtered = {
k: v
for k, v in kpi.items()
if v > 20
}

print(filtered)




---

# 6. Performans Perspektifi

Comprehension yapıları:

* Daha hızlı çalışır
* CPython optimizasyonu vardır
* append loop’a göre daha az overhead üretir

Örnek karşılaştırma:



```python id="perf1"
# klasik yöntem
liste = []
for i in range(1000):
    liste.append(i * 2)

# comprehension
liste2 = [i * 2 for i in range(1000)]

7. İç İçe (Nested) Comprehension

7.1 Dictionary içinde Dictionary

```python id="n1"
matrix = {
i: {
j: i * j
for j in range(3)
}
for i in range(3)
}

print(matrix)




---

## 7.2 Set of Tuples



```python id="n2"
pairs = {
    (x, y)
    for x in range(3)
    for y in range(3)
}

print(pairs)

8. En Güçlü Kullanım: Veri Dönüştürme Pipeline

```python id="p1"
raw_data = [
{"name": " Ali ", "age": 30},
{"name": "Ayşe", "age": 25}
]

cleaned = {
item["name"].strip(): item["age"]
for item in raw_data
}

print(cleaned)




---

# 9. Python ve C# Perspektifi

## Python



```python id="csh1"
{ x: x*x for x in range(5) }

C# Alternatif

```csharp id="csh2"
var dict = Enumerable.Range(0, 5)
.ToDictionary(x => x, x => x * x);




---

# 10. Profesyonel Kullanım Tavsiyeleri

Dictionary / Set comprehension kullan:

* Veri transformasyonunda
* ETL pipeline’larda
* API response mapping’de
* Log parsing işlemlerinde
* Feature engineering’de
* Deduplication süreçlerinde

Kullanma:

* Çok karmaşık logic varsa
* Debug edilmesi zor olacaksa
* 1 satır okunabilirliği bozuyorsa

---

# 11. Özet

Dictionary ve Set Comprehensions:

* Kod yazımını sadeleştirir
* Performansı artırır
* Veri dönüşümünü hızlandırır
* Modern Python’un temel yeteneklerindendir

Özetle:

* Dictionary comprehension → **mapping / transform**
* Set comprehension → **unique / filter**

Python Set (Küme) Veri Yapısı: Sıfırdan İleri Seviye Kapsamlı Rehber

Vebende Akademi — Sun, 21 Jun 2026 08:58:48 +0000

Python Set (Küme) Veri Yapısı: Sıfırdan İleri Seviye Kapsamlı Rehber

Python’da Set (Küme) veri yapısı, özellikle benzersiz veri tutma ve hızlı üyelik kontrolü gerektiren senaryolar için tasarlanmıştır.

Gerçek dünyada set mantığı şuralarda karşımıza çıkar:

Duplicate (tekrarlı) veri temizleme
Log analizi
Kullanıcı etkileşim filtreleme
Etiket (tag) sistemleri
Veri karşılaştırma
Matematiksel küme işlemleri (union, intersection)

Set, Python ekosisteminde performans odaklı en kritik veri yapılarından biridir.

Set Nedir?

Set, benzersiz (unique) elemanlardan oluşan, sırasız ve değiştirilebilir bir veri yapısıdır.

```python id="set1"
sayilar = {1, 2, 3, 4, 5}

print(sayilar)




---

# Set Özellikleri

Set:

* Sırasızdır
* Duplicate (tekrar) kabul etmez
* Mutable (değiştirilebilir)
* Indexlenemez
* Hash tabanlıdır → çok hızlıdır

---

# Set Oluşturma

## Temel Set



```python id="set2"
renkler = {"kırmızı", "mavi", "yeşil"}

print(renkler)

Boş Set (ÖNEMLİ!)

Yanlış:

```python id="set3"
bos = {}

print(type(bos))




Çıktı:



```text id="set4"
<class 'dict'>

Doğru:

```python id="set5"
bos = set()

print(type(bos))




---

# Duplicate Otomatik Silme



```python id="set6"
sayilar = {1, 2, 2, 3, 3, 3, 4}

print(sayilar)

Çıktı:

```text id="set7"
{1, 2, 3, 4}




---

# Set Elemanları Farklı Tipte Olabilir



```python id="set8"
veri = {1, "Python", 3.14, True}

print(veri)

Set Elemanına Erişim Yok

```python id="set9"
sayilar = {10, 20, 30}

print(sayilar[0]) # HATA




Çıktı:



```text id="set10"
TypeError

Set’e Eleman Ekleme

add()

```python id="set11"
sayilar = {1, 2, 3}

sayilar.add(4)

print(sayilar)




---

# Çoklu Eleman Ekleme

## update()



```python id="set12"
sayilar = {1, 2, 3}

sayilar.update([4, 5, 6])

print(sayilar)

Eleman Silme

remove()

```python id="set13"
sayilar = {1, 2, 3}

sayilar.remove(2)

print(sayilar)




Hata riski vardır.

---

## discard()



```python id="set14"
sayilar = {1, 2, 3}

sayilar.discard(99)

print(sayilar)

Hata vermez.

pop()

```python id="set15"
sayilar = {1, 2, 3, 4}

print(sayilar.pop())
print(sayilar)




---

## clear()



```python id="set16"
sayilar = {1, 2, 3}

sayilar.clear()

print(sayilar)

Set Üyelik Kontrolü (En Güçlü Özellik)

```python id="set17"
sayilar = {1, 2, 3, 4, 5}

print(3 in sayilar)
print(10 in sayilar)




Çıktı:



```text id="set18"
True
False

Set Uzunluğu

```python id="set19"
veri = {1, 2, 3, 4}

print(len(veri))




---

# Döngü ile Set Kullanımı



```python id="set20"
meyveler = {"elma", "armut", "muz"}

for m in meyveler:
    print(m)

Set Matematiksel İşlemler

Set’in en güçlü tarafı burasıdır.

Union (Birleşim)

```python id="set21"
a = {1, 2, 3}
b = {3, 4, 5}

print(a | b)




Çıktı:



```text id="set22"
{1, 2, 3, 4, 5}

union()

```python id="set23"
print(a.union(b))




---

# Intersection (Kesişim)



```python id="set24"
a = {1, 2, 3}
b = {2, 3, 4}

print(a & b)

Çıktı:

```text id="set25"
{2, 3}




---

# Difference (Fark)



```python id="set26"
a = {1, 2, 3}
b = {2, 3, 4}

print(a - b)

Çıktı:

```text id="set27"
{1}




---

# Symmetric Difference



```python id="set28"
a = {1, 2, 3}
b = {2, 3, 4}

print(a ^ b)

Çıktı:

```text id="set29"
{1, 4}




---

# Subset & Superset



```python id="set30"
a = {1, 2}
b = {1, 2, 3}

print(a.issubset(b))
print(b.issuperset(a))

Disjoint (Ortak eleman yok mu?)

```python id="set31"
a = {1, 2}
b = {3, 4}

print(a.isdisjoint(b))




---

# Set Comprehension



```python id="set32"
kareler = {x*x for x in range(10)}

print(kareler)

Hands-On 1: Duplicate Temizleme

```python id="set33"
veri = [1, 2, 2, 3, 3, 4, 5, 5]

temiz = set(veri)

print(list(temiz))




---

# Hands-On 2: Kullanıcı Analizi



```python id="set34"
giris1 = {"Ali", "Ayşe", "Mehmet"}
giris2 = {"Mehmet", "Zeynep", "Ali"}

aktif = giris1 & giris2

print(aktif)

Hands-On 3: Benzersiz Ürünler

```python id="set35"
satislar = [
"Laptop",
"Mouse",
"Laptop",
"Klavye",
"Mouse"
]

urunler = set(satislar)

print(urunler)




---

# Hands-On 4: Log Analizi



```python id="set36"
loglar = [
    "INFO",
    "ERROR",
    "INFO",
    "WARNING",
    "ERROR"
]

unique_logs = set(loglar)

print(unique_logs)

Hands-On 5: Eksik Veri Tespiti

```python id="set37"
tum_kullanicilar = {"Ali", "Ayşe", "Mehmet", "Zeynep"}
aktif_kullanicilar = {"Ali", "Mehmet"}

pasif = tum_kullanicilar - aktif_kullanicilar

print(pasif)




---

# Hands-On 6: Etiket Sistemi



```python id="set38"
urun = {
    "ad": "Laptop",
    "tag": {"oyun", "performans", "ssd"}
}

urun["tag"].add("yeni")

print(urun)

Set vs List vs Tuple

Özellik	List	Tuple	Set
Sıralı	✔	✔	✖
Değiştirilebilir	✔	✖	✔
Duplicate	✔	✔	✖
Index	✔	✔	✖
Hızlı arama	❌	❌	✔

Performans Avantajı

Set’in en güçlü yönü:

```python id="set39"
import time

veri = set(range(1000000))

start = time.time()
print(999999 in veri)
end = time.time()

print(end - start)




👉 O(1) arama performansı

---

# Python ve C# Karşılaştırma

## Python



```python id="set40"
a = {1, 2, 3}
b = {3, 4, 5}

print(a | b)

C

```csharp id="set41"
HashSet a = new() { 1, 2, 3 };
HashSet b = new() { 3, 4, 5 };

a.UnionWith(b);




---

# Gerçek Hayat Kullanım Alanları

Set özellikle şuralarda kullanılır:

* Log deduplication
* Email list filtering
* API rate limiting
* Search indexing
* Recommendation systems
* Data cleaning pipelines

---

# İleri Seviye Örnek: Ziyaretçi Analizi



```python id="set42"
gun1 = {"user1", "user2", "user3"}
gun2 = {"user2", "user3", "user4"}
gun3 = {"user3", "user4", "user5"}

aktif = gun1 | gun2 | gun3
sadik = gun1 & gun2 & gun3

print("Aktif:", aktif)
print("Sadık:", sadik)

Özet

Set veri yapısı Python’da:

Duplicate verileri temizlemek
Hızlı üyelik kontrolü yapmak
Matematiksel küme işlemleri yapmak
Veri analizi ve filtreleme yapmak

için vazgeçilmezdir.

İyi bir Python geliştiricisi:

Set operations (union, intersection, difference)
add / remove / discard farkları
Performans avantajlarını
Set comprehension
Real-world data filtering tekniklerini

çok iyi bilmelidir.

Set, özellikle veri analizi, büyük veri, backend sistemler ve log processing alanlarında kritik öneme sahiptir.

Python Tuple (Demet) Veri Yapısı: Sıfırdan İleri Seviyeye Kapsamlı Rehber

Vebende Akademi — Sun, 21 Jun 2026 08:56:23 +0000

Python Tuple (Demet) Veri Yapısı: Sıfırdan İleri Seviyeye Kapsamlı Rehber

Python'da veri saklamak için kullanılan temel veri yapılarından biri de Tuple (Demet) yapısıdır. İlk bakışta listelere çok benzese de Tuple'ların çok önemli bir farkı vardır:

Tuple oluşturulduktan sonra değiştirilemez (Immutable).

Bu özellik sayesinde Tuple'lar:

Daha hızlı çalışır
Daha az bellek tüketir
Veri bütünlüğünü korur
Dictionary anahtarı olarak kullanılabilir
Büyük veri işleme uygulamalarında performans avantajı sağlar

Gerçek hayatta:

GPS koordinatları
Veritabanı kayıtları
API dönüşleri
Konfigürasyon bilgileri
RGB renk tanımları
Matematiksel koordinatlar

gibi değişmemesi gereken veriler çoğunlukla Tuple ile temsil edilir.

Tuple Nedir?

Birden fazla veriyi tek değişken altında saklayan ancak oluşturulduktan sonra değiştirilemeyen veri yapısıdır.

koordinat = (40.9876, 29.1234)

print(koordinat)

Çıktı:

(40.9876, 29.1234)

Liste ve Tuple Arasındaki Fark

Liste:

liste = [1, 2, 3]

Tuple:

tuple_veri = (1, 2, 3)

Liste değiştirilebilir.

liste[0] = 100

Tuple değiştirilemez.

tuple_veri[0] = 100

Hata:

TypeError:
'tuple' object does not support item assignment

Tuple Oluşturma

Temel Kullanım

personel = (
    1001,
    "Ali",
    "Yazılım Uzmanı"
)

print(personel)

Farklı Veri Tipleri

veri = (
    "Python",
    3.14,
    42,
    True
)

print(veri)

Boş Tuple

bos = ()

Tek Elemanlı Tuple

En sık yapılan hata budur.

Yanlış:

x = (5)

print(type(x))

Çıktı:

<class 'int'>

Doğru:

x = (5,)

print(type(x))

Çıktı:

<class 'tuple'>

Tuple Elemanlarına Erişim

meyveler = (
    "Elma",
    "Armut",
    "Muz"
)

print(meyveler[0])
print(meyveler[1])

Çıktı:

Elma
Armut

Negatif İndeksler

meyveler = (
    "Elma",
    "Armut",
    "Muz"
)

print(meyveler[-1])

Çıktı:

Muz

Tuple Uzunluğu

veriler = (
    10,
    20,
    30,
    40
)

print(len(veriler))

Çıktı:

Tuple Üzerinde Döngü

renkler = (
    "Kırmızı",
    "Mavi",
    "Yeşil"
)

for renk in renkler:
    print(renk)

Tuple Dilimleme (Slicing)

sayilar = (
    10,
    20,
    30,
    40,
    50
)

print(sayilar[1:4])

Çıktı:

(20, 30, 40)

Tuple Birleştirme

a = (1, 2, 3)
b = (4, 5, 6)

c = a + b

print(c)

Çıktı:

(1, 2, 3, 4, 5, 6)

Tuple Çoğaltma

sayilar = (1, 2, 3)

print(sayilar * 3)

Çıktı:

(1, 2, 3, 1, 2, 3, 1, 2, 3)

Tuple İçinde Arama

in Operatörü

renkler = (
    "Kırmızı",
    "Mavi",
    "Yeşil"
)

print("Mavi" in renkler)

Çıktı:

True

index()

renkler = (
    "Kırmızı",
    "Mavi",
    "Yeşil"
)

print(
    renkler.index("Mavi")
)

Çıktı:

count()

sayilar = (
    1,
    2,
    2,
    3,
    2
)

print(
    sayilar.count(2)
)

Çıktı:

Tuple Packing

Python'ın en güçlü özelliklerinden biridir.

personel = (
    1001,
    "Ali",
    75000
)

Aslında Python bunu şöyle yorumlar:

personel = 1001, "Ali", 75000

Tuple Unpacking

id,
isim,
maas = personel

print(id)
print(isim)
print(maas)

Çıktı:

1001
Ali
75000

Hands-On 1: Koordinat Sistemi

istanbul = (
    41.0082,
    28.9784
)

print(
    "Enlem:",
    istanbul[0]
)

print(
    "Boylam:",
    istanbul[1]
)

Hands-On 2: RGB Renk Sistemi

mavi = (
    0,
    0,
    255
)

print(
    f"R:{mavi[0]}"
)

print(
    f"G:{mavi[1]}"
)

print(
    f"B:{mavi[2]}"
)

Hands-On 3: Veritabanı Kaydı

kayit = (
    1001,
    "Ali",
    "Yazılım Uzmanı",
    85000
)

id,
isim,
gorev,
maas = kayit

print(
    f"{isim} - {maas}"
)

Hands-On 4: Çoklu Değer Döndürme

Fonksiyonlardan çok sık kullanılır.

def hesapla(a, b):

    toplam = a + b
    fark = a - b

    return (
        toplam,
        fark
    )

sonuc = hesapla(20, 10)

print(sonuc)

Çıktı:

(30, 10)

Hands-On 5: Sonucu Parçalamak

toplam,
fark = hesapla(20, 10)

print(toplam)
print(fark)

Swap (Yer Değiştirme)

Python'ın ünlü özelliği.

C#'ta:

int temp = a;
a = b;
b = temp;

Python'da:

a = 10
b = 20

a, b = b, a

print(a, b)

Çıktı:

20 10

İç İçe Tuple

matris = (
    (1, 2, 3),
    (4, 5, 6),
    (7, 8, 9)
)

print(
    matris[1][2]
)

Çıktı:

Liste İçinde Tuple

Çok yaygındır.

personeller = [
    (1, "Ali"),
    (2, "Ayşe"),
    (3, "Mehmet")
]

for id, isim in personeller:
    print(id, isim)

Tuple İçinde Liste

Dikkat edilmesi gereken önemli bir konu.

veri = (
    1,
    2,
    [3, 4]
)

veri[2].append(5)

print(veri)

Çıktı:

(1, 2, [3, 4, 5])

Tuple değişmezdir ancak içindeki mutable nesneler değişebilir.

NamedTuple

Daha okunabilir tuple yapıları oluşturur.

from collections import namedtuple

Personel = namedtuple(
    "Personel",
    [
        "id",
        "isim",
        "maas"
    ]
)

p = Personel(
    1,
    "Ali",
    75000
)

print(p.isim)

Çıktı:

Ali

Hands-On 6: NamedTuple ile Personel Sistemi

from collections import namedtuple

Personel = namedtuple(
    "Personel",
    [
        "id",
        "isim",
        "departman"
    ]
)

personeller = [
    Personel(
        1,
        "Ali",
        "Yazılım"
    ),
    Personel(
        2,
        "Ayşe",
        "Muhasebe"
    )
]

for p in personeller:
    print(
        p.isim,
        p.departman
    )

Tuple ve Set İlişkisi

Tuple hashlenebilir olduğu için Set içinde kullanılabilir.

koordinatlar = {
    (40.1, 29.1),
    (40.2, 29.2),
    (40.3, 29.3)
}

print(koordinatlar)

Tuple Dictionary Anahtarı Olarak Kullanmak

sicaklik = {
    ("İzmir", "Ocak"): 12,
    ("İzmir", "Şubat"): 13,
    ("İzmir", "Mart"): 17
}

print(
    sicaklik[
        ("İzmir", "Mart")
    ]
)

Çıktı:

Performans Karşılaştırması

Bellek Kullanımı

import sys

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

print(
    sys.getsizeof(liste)
)

print(
    sys.getsizeof(tuple_veri)
)

Tuple daha az bellek kullanır.

Büyük Veri Performansı

import timeit

liste = [x for x in range(1000)]
tuple_veri = tuple(range(1000))

print(
    timeit.timeit(
        lambda: liste[500],
        number=1000000
    )
)

print(
    timeit.timeit(
        lambda: tuple_veri[500],
        number=1000000
    )
)

Tuple genellikle biraz daha hızlıdır.

Gerçek Hayat Kullanım Senaryoları

Tuple kullanın:

GPS koordinatları
RGB renkleri
Tarih bilgileri
Sabit konfigürasyonlar
Fonksiyon dönüşleri
Veritabanı kayıtları
Cache anahtarları

Liste kullanın:

Veri değişecekse
Eleman eklenecekse
Silme işlemleri yapılacaksa

Python ve C# Karşılaştırması

Python

personel = (
    1,
    "Ali",
    75000
)

C

var personel =
(
    1,
    "Ali",
    75000m
);

Console.WriteLine(
    personel.Item2
);

İleri Seviye Hands-On: Satış Analizi

satislar = [
    ("Laptop", 45000),
    ("Mouse", 500),
    ("Laptop", 45000),
    ("Monitör", 12000),
    ("Mouse", 500)
]

toplam = {}

for urun, fiyat in satislar:

    toplam[urun] = (
        toplam.get(
            urun,
            0
        )
        + fiyat
    )

print(toplam)

Çıktı:

{
 'Laptop':90000,
 'Mouse':1000,
 'Monitör':12000
}

Özet

Tuple, Python'ın en önemli veri yapılarından biridir ve özellikle değişmemesi gereken verileri saklamak için tasarlanmıştır.

İyi bir Python geliştiricisi;

Tuple oluşturmayı
Packing ve Unpacking işlemlerini
Çoklu dönüş değerlerini
NamedTuple kullanımını
Tuple ile performans avantajlarını
Dictionary anahtarı olarak kullanımını
Veri modelleme tekniklerini

çok iyi seviyede bilmelidir.

Özellikle veri analizi, yapay zeka, API geliştirme, büyük veri sistemleri ve yüksek performanslı uygulamalarda Tuple kullanımı kodun hem daha güvenilir hem de daha verimli çalışmasını sağlar. Python ekosistemindeki birçok kütüphane, veri aktarımı ve fonksiyon dönüşlerinde Tuple yapısını yoğun olarak kullanmaktadır.

Python Dictionary (Sözlük) Yapısı: Sıfırdan İleri Seviyeye Kapsamlı Rehber

Vebende Akademi — Sun, 21 Jun 2026 08:51:00 +0000

Python Dictionary (Sözlük) Yapısı: Sıfırdan İleri Seviyeye Kapsamlı Rehber

Python'da veri yönetiminin temel taşlarından biri Dictionary (Sözlük) veri yapısıdır. Listeler verileri sıralı şekilde saklarken, dictionary yapıları verileri anahtar (key) - değer (value) mantığıyla saklar.

Gerçek dünyadaki birçok uygulamada dictionary kullanılır:

Kullanıcı bilgileri
JSON verileri
API yanıtları
Konfigürasyon dosyaları
Yapay zeka modellerinin parametreleri
Ürün katalogları
Cache sistemleri
Log kayıtları

Bir Python geliştiricisinin Dictionary yapısını çok iyi bilmesi gerekir çünkü modern Python uygulamalarının önemli bir bölümü dictionary temellidir.

Dictionary Nedir?

Dictionary, verileri anahtar ve değer çiftleri şeklinde saklayan veri yapısıdır.

ogrenci = {
    "ad": "Ahmet",
    "soyad": "Yılmaz",
    "yas": 22
}

print(ogrenci)

Çıktı:

{'ad': 'Ahmet', 'soyad': 'Yılmaz', 'yas': 22}

Dictionary Özellikleri

Dictionary:

Sıralıdır (Python 3.7+)
Değiştirilebilir (Mutable)
Anahtarlar benzersizdir
Değerler tekrar edebilir
Çok hızlı erişim sağlar

Dictionary Oluşturma

Temel Kullanım

personel = {
    "id": 1001,
    "ad": "Mehmet",
    "maas": 75000
}

Boş Dictionary

veriler = {}

veya

veriler = dict()

Veri Okuma

kullanici = {
    "isim": "Ali",
    "yas": 30
}

print(kullanici["isim"])

Çıktı:

Ali

get() Kullanımı

Anahtar bulunamazsa hata vermez.

kullanici = {
    "isim": "Ali"
}

print(
    kullanici.get(
        "telefon",
        "Bulunamadı"
    )
)

Çıktı:

Bulunamadı

Veri Güncelleme

urun = {
    "ad": "Laptop",
    "fiyat": 25000
}

urun["fiyat"] = 30000

print(urun)

Çıktı:

{'ad': 'Laptop', 'fiyat': 30000}

Yeni Alan Eklemek

urun = {
    "ad": "Laptop"
}

urun["stok"] = 50

print(urun)

Çıktı:

{'ad': 'Laptop', 'stok': 50}

Veri Silmek

del

urun = {
    "ad": "Laptop",
    "stok": 50
}

del urun["stok"]

print(urun)

pop()

urun = {
    "ad": "Laptop",
    "stok": 50
}

urun.pop("stok")

print(urun)

Tüm İçeriği Temizlemek

urun = {
    "ad": "Laptop",
    "stok": 50
}

urun.clear()

print(urun)

Çıktı:

{}

Dictionary Uzunluğu

kisi = {
    "ad": "Ali",
    "yas": 25,
    "sehir": "İzmir"
}

print(len(kisi))

Çıktı:

Anahtarların Listelenmesi

kisi = {
    "ad": "Ali",
    "yas": 25,
    "sehir": "İzmir"
}

print(kisi.keys())

Çıktı:

dict_keys(['ad', 'yas', 'sehir'])

Değerlerin Listelenmesi

print(kisi.values())

Çıktı:

dict_values(['Ali', 25, 'İzmir'])

Anahtar-Değer Çiftleri

print(kisi.items())

Çıktı:

dict_items([
 ('ad', 'Ali'),
 ('yas', 25),
 ('sehir', 'İzmir')
])

Dictionary Üzerinde Dönmek

Anahtarlar

for key in kisi:
    print(key)

Anahtar ve Değer

for key, value in kisi.items():
    print(key, value)

Çıktı:

ad Ali
yas 25
sehir İzmir

İç İçe Dictionary

Gerçek projelerde çok sık kullanılır.

firma = {
    "id": 1,
    "ad": "ABC Yazılım",
    "adres": {
        "sehir": "İzmir",
        "ulke": "Türkiye"
    }
}

print(
    firma["adres"]["sehir"]
)

Çıktı:

İzmir

Dictionary İçinde Liste

ogrenci = {
    "ad": "Ayşe",
    "notlar": [
        80,
        90,
        100
    ]
}

print(
    ogrenci["notlar"][1]
)

Çıktı:

Liste İçinde Dictionary

Veritabanı kayıtlarının temel yapısıdır.

personeller = [
    {
        "id": 1,
        "ad": "Ali"
    },
    {
        "id": 2,
        "ad": "Ayşe"
    }
]

print(personeller[1]["ad"])

Çıktı:

Ayşe

Dictionary Comprehension

List Comprehension kadar güçlüdür.

Kareler Tablosu

kareler = {
    x: x*x
    for x in range(1,11)
}

print(kareler)

Çıktı:

{
1:1,
2:4,
3:9,
...
}

Filtreleme

ciftler = {
    x: x*x
    for x in range(20)
    if x % 2 == 0
}

print(ciftler)

Hands-On 1: Öğrenci Bilgi Sistemi

ogrenci = {
    "ad": "Mehmet",
    "soyad": "Demir",
    "yas": 21,
    "notlar": [70,85,95]
}

ortalama = (
    sum(ogrenci["notlar"])
    / len(ogrenci["notlar"])
)

print(
    f"Ortalama: {ortalama}"
)

Hands-On 2: Kelime Frekans Analizi

metin = """
python veri bilimi python
yapay zeka python
"""

frekans = {}

for kelime in metin.split():

    if kelime in frekans:
        frekans[kelime] += 1
    else:
        frekans[kelime] = 1

print(frekans)

Çıktı:

{
 'python':3,
 'veri':1,
 'bilimi':1,
 'yapay':1,
 'zeka':1
}

Hands-On 3: Ürün Stok Takibi

stok = {
    "Laptop": 10,
    "Mouse": 25,
    "Klavye": 15
}

urun = "Mouse"

stok[urun] -= 1

print(stok)

Hands-On 4: Maaş Hesaplama Sistemi

maaslar = {
    "Ali": 50000,
    "Ayşe": 70000,
    "Mehmet": 60000
}

ortalama = (
    sum(maaslar.values())
    /
    len(maaslar)
)

print(ortalama)

Hands-On 5: API Yanıtı Simülasyonu

response = {
    "success": True,
    "data": {
        "id": 100,
        "ad": "Laptop",
        "fiyat": 35000
    }
}

print(
    response["data"]["ad"]
)

Hands-On 6: Log Analizi

loglar = [
    "INFO",
    "ERROR",
    "INFO",
    "WARNING",
    "ERROR",
    "ERROR"
]

sonuc = {}

for log in loglar:

    sonuc[log] = (
        sonuc.get(log,0)
        + 1
    )

print(sonuc)

Çıktı:

{
 'INFO':2,
 'ERROR':3,
 'WARNING':1
}

setdefault()

Anahtar yoksa oluşturur.

ayarlar = {}

ayarlar.setdefault(
    "tema",
    "dark"
)

print(ayarlar)

Çıktı:

{'tema': 'dark'}

update()

Birden fazla alan güncellemek için kullanılır.

kisi = {
    "ad": "Ali"
}

kisi.update({
    "yas": 30,
    "sehir": "İzmir"
})

print(kisi)

fromkeys()

alanlar = [
    "ad",
    "soyad",
    "email"
]

kayit = dict.fromkeys(
    alanlar,
    ""
)

print(kayit)

Çıktı:

{
 'ad':'',
 'soyad':'',
 'email':''
}

collections.defaultdict

Çok büyük projelerde sık kullanılır.

from collections import defaultdict

sayac = defaultdict(int)

sayac["python"] += 1

print(sayac)

JSON ve Dictionary İlişkisi

Modern API dünyasının temelidir.

import json

kullanici = {
    "ad": "Ali",
    "yas": 30
}

json_veri = json.dumps(
    kullanici
)

print(json_veri)

Çıktı:

{"ad":"Ali","yas":30}

JSON'dan Dictionary'e

import json

veri = '''
{
    "ad":"Ali",
    "yas":30
}
'''

sonuc = json.loads(veri)

print(sonuc)

Performans Bilgileri

İşlem	Ortalama Karmaşıklık
Okuma	O(1)
Yazma	O(1)
Güncelleme	O(1)
Silme	O(1)
Arama	O(1)
keys()	O(n)
values()	O(n)
items()	O(n)

Dictionary yapısının bu kadar yaygın kullanılmasının temel nedeni Hash Table tabanlı olmasıdır.

Gerçek Hayat Kullanım Örneği

Bir e-ticaret sisteminde ürünler:

urunler = {
    1001: {
        "ad": "Laptop",
        "fiyat": 45000,
        "stok": 15
    },
    1002: {
        "ad": "Mouse",
        "fiyat": 450,
        "stok": 100
    }
}

print(
    urunler[1001]["fiyat"]
)

İleri Seviye: Sıralama

Fiyata göre sıralama:

urunler = {
    "Laptop": 45000,
    "Mouse": 500,
    "Monitör": 12000
}

sirali = sorted(
    urunler.items(),
    key=lambda x: x[1]
)

print(sirali)

İleri Seviye: Merge Operatörü (Python 3.9+)

a = {
    "ad": "Ali"
}

b = {
    "yas": 30
}

c = a | b

print(c)

Çıktı:

{
 'ad':'Ali',
 'yas':30
}

Profesyonel Geliştirici Tavsiyeleri

Dictionary kullanın:

Anahtar üzerinden hızlı erişim gerekiyorsa
Veriler ilişkilendirilecekse
JSON ile çalışılıyorsa
API geliştiriliyorsa
Cache sistemi kuruluyorsa
Konfigürasyon yönetiliyorsa

Dictionary kullanmayın:

Sürekli sıralı indeks erişimi gerekiyorsa
Sadece pozisyon bazlı veri tutuluyorsa

Özet

Dictionary, Python ekosisteminin en önemli veri yapılarından biridir. Modern web uygulamaları, REST API'ler, mikro servisler, veri analizi projeleri, yapay zeka sistemleri ve otomasyon uygulamalarının büyük bölümü dictionary temelli çalışır.

İyi bir Python geliştiricisi;

Dictionary oluşturmayı
Veri okumayı
Güncellemeyi
Silmeyi
İç içe sözlükleri
Dictionary comprehension kullanımını
JSON dönüşümlerini
defaultdict ve setdefault yapılarını

çok iyi seviyede bilmelidir.

Dictionary hakimiyeti kazanan bir geliştirici, API geliştirme, veri işleme, log analizi, ETL süreçleri, yapay zeka veri hazırlama ve büyük ölçekli Python uygulamalarında çok daha verimli çalışabilir.

Python Listeleri (List): Sıfırdan İleri Seviyeye Kapsamlı Rehber

Vebende Akademi — Sun, 21 Jun 2026 08:44:07 +0000

Python Listeleri (List): Sıfırdan İleri Seviyeye Kapsamlı Rehber

Python programlama dilinde en çok kullanılan veri yapılarından biri liste (list) yapısıdır. Bir Python geliştiricisinin günlük çalışmalarında verilerin büyük bölümü listeler içerisinde tutulur, işlenir, filtrelenir, sıralanır ve dönüştürülür.

Bir e-ticaret sistemindeki ürünler, bir CRM sistemindeki müşteriler, bir sensör ağından gelen veriler veya bir yapay zeka modelinin eğitim verileri çoğu zaman listeler içerisinde bulunur.

Bu makalede Python listelerini bol örnek ve uygulama ile detaylı şekilde inceleyeceğiz.

Liste Nedir?

Liste, birden fazla veriyi tek değişken altında saklamamızı sağlayan veri yapısıdır.

meyveler = ["Elma", "Armut", "Muz"]

print(meyveler)

Çıktı:

['Elma', 'Armut', 'Muz']

Listenin Özellikleri

Listeler:

Sıralıdır
Değiştirilebilir (Mutable)
Tekrarlı veri tutabilir
Farklı veri tiplerini aynı anda saklayabilir

veriler = [
    "Ahmet",
    25,
    1.82,
    True
]

print(veriler)

Çıktı:

['Ahmet', 25, 1.82, True]

Liste Oluşturma

Boş Liste

liste = []

veya

liste = list()

Veri ile Liste Oluşturma

sayilar = [10, 20, 30, 40]

isimler = ["Ali", "Veli", "Ayşe"]

Liste Elemanlarına Erişim

Python'da indeksler 0'dan başlar.

isimler = ["Ali", "Veli", "Ayşe"]

print(isimler[0])
print(isimler[1])
print(isimler[2])

Çıktı:

Ali
Veli
Ayşe

Negatif İndeks Kullanımı

isimler = ["Ali", "Veli", "Ayşe"]

print(isimler[-1])
print(isimler[-2])

Çıktı:

Ayşe
Veli

Liste Uzunluğu

urunler = [
    "Laptop",
    "Mouse",
    "Klavye",
    "Monitör"
]

print(len(urunler))

Çıktı:

Listeyi Döngü ile Gezmek

For Döngüsü

meyveler = ["Elma", "Armut", "Muz"]

for meyve in meyveler:
    print(meyve)

İndeks ile Gezmek

meyveler = ["Elma", "Armut", "Muz"]

for i in range(len(meyveler)):
    print(i, meyveler[i])

Listeye Eleman Ekleme

append()

Listenin sonuna ekler.

sayilar = [10, 20]

sayilar.append(30)

print(sayilar)

Çıktı:

[10, 20, 30]

insert()

Belirli pozisyona ekler.

sayilar = [10, 30]

sayilar.insert(1, 20)

print(sayilar)

Çıktı:

[10, 20, 30]

Listeye Çoklu Eleman Eklemek

extend()

liste1 = [1, 2, 3]
liste2 = [4, 5, 6]

liste1.extend(liste2)

print(liste1)

Çıktı:

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

Listeden Eleman Silmek

remove()

isimler = ["Ali", "Veli", "Ayşe"]

isimler.remove("Veli")

print(isimler)

pop()

sayilar = [10, 20, 30]

sayilar.pop()

print(sayilar)

Çıktı:

[10, 20]

Belirli İndeksi Silmek

sayilar = [10, 20, 30]

sayilar.pop(1)

print(sayilar)

Çıktı:

[10, 30]

del

sayilar = [10, 20, 30]

del sayilar[1]

print(sayilar)

Liste Temizleme

sayilar = [1, 2, 3, 4]

sayilar.clear()

print(sayilar)

Çıktı:

[]

Liste Sıralama

sort()

sayilar = [50, 10, 90, 30]

sayilar.sort()

print(sayilar)

Çıktı:

[10, 30, 50, 90]

Ters Sıralama

sayilar.sort(reverse=True)

print(sayilar)

Çıktı:

[90, 50, 30, 10]

sorted()

Orijinal listeyi bozmaz.

sayilar = [50, 10, 90]

yeni = sorted(sayilar)

print(yeni)
print(sayilar)

Liste Ters Çevirme

sayilar = [1, 2, 3, 4]

sayilar.reverse()

print(sayilar)

Çıktı:

[4, 3, 2, 1]

Dilimleme (Slicing)

İlk 3 Eleman

sayilar = [10,20,30,40,50]

print(sayilar[:3])

Çıktı:

[10, 20, 30]

Son 2 Eleman

print(sayilar[-2:])

Çıktı:

[40, 50]

Ortadaki Elemanlar

print(sayilar[1:4])

Çıktı:

[20, 30, 40]

Liste Kopyalama

Hatalı Yöntem

liste1 = [1,2,3]

liste2 = liste1

Bu durumda iki değişken aynı nesneyi gösterir.

Doğru Yöntem

liste1 = [1,2,3]

liste2 = liste1.copy()

veya

liste2 = liste1[:]

Listelerde Arama

in Operatörü

meyveler = ["Elma","Muz","Armut"]

print("Muz" in meyveler)

Çıktı:

True

index()

meyveler = ["Elma","Muz","Armut"]

print(meyveler.index("Muz"))

Çıktı:

count()

sayilar = [1,2,3,2,2,4]

print(sayilar.count(2))

Çıktı:

Liste Birleştirme

a = [1,2,3]
b = [4,5,6]

c = a + b

print(c)

Çıktı:

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

List Comprehension

Python geliştiricilerinin vazgeçilmez aracıdır.

Karelerini Almak

sayilar = [1,2,3,4,5]

kareler = [x*x for x in sayilar]

print(kareler)

Çıktı:

[1,4,9,16,25]

Çift Sayıları Filtrelemek

sayilar = range(20)

ciftler = [x for x in sayilar if x % 2 == 0]

print(ciftler)

İç İçe Listeler

matris = [
    [1,2,3],
    [4,5,6],
    [7,8,9]
]

Matris Elemanına Erişim

print(matris[1][2])

Çıktı:

Hands-On 1: Öğrenci Not Sistemi

notlar = [70, 85, 90, 65, 100]

ortalama = sum(notlar) / len(notlar)

print("Ortalama:", ortalama)
print("En Yüksek:", max(notlar))
print("En Düşük:", min(notlar))

Hands-On 2: Satış Analizi

satislar = [
    1200,
    1500,
    1800,
    1300,
    2100,
    1700
]

print("Toplam:", sum(satislar))
print("Ortalama:", sum(satislar)/len(satislar))

Hands-On 3: Kelime Frekans Analizi

metin = """
python veri bilimi python yapay zeka
python programlama veri analizi
"""

kelimeler = metin.split()

benzersiz = set(kelimeler)

for kelime in benzersiz:
    print(kelime, kelimeler.count(kelime))

Hands-On 4: En Çok Satan Ürün

urunler = [
    "Laptop",
    "Mouse",
    "Laptop",
    "Klavye",
    "Laptop",
    "Mouse"
]

en_cok = max(
    set(urunler),
    key=urunler.count
)

print(en_cok)

Hands-On 5: İlk 10 Fibonacci Sayısı

fibonacci = [0, 1]

for i in range(8):
    fibonacci.append(
        fibonacci[-1] +
        fibonacci[-2]
    )

print(fibonacci)

Çıktı:

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

İleri Seviye: enumerate()

isimler = [
    "Ali",
    "Ayşe",
    "Mehmet"
]

for index, isim in enumerate(isimler):
    print(index, isim)

İleri Seviye: zip()

isimler = [
    "Ali",
    "Ayşe",
    "Mehmet"
]

notlar = [
    70,
    80,
    95
]

for isim, notu in zip(isimler, notlar):
    print(isim, notu)

İleri Seviye: Lambda ile Sıralama

personeller = [
    ("Ali", 45000),
    ("Ayşe", 65000),
    ("Mehmet", 55000)
]

sirali = sorted(
    personeller,
    key=lambda x: x[1]
)

print(sirali)

Performans Bilgileri

İşlem	Karmaşıklık
append()	O(1)
pop()	O(1)
index()	O(n)
remove()	O(n)
in	O(n)
sort()	O(n log n)
len()	O(1)

Profesyonel Geliştirici Tavsiyeleri

Liste kullanın:

Sıralama önemliyse
Veri sayısı orta büyüklükteyse
İndeks erişimi gerekiyorsa

Set kullanın:

Benzersiz veri gerekiyorsa
Hızlı arama gerekiyorsa

Dictionary kullanın:

Anahtar-değer yapısı gerekiyorsa

Tuple kullanın:

Veri değişmeyecekse

Özet

Python listeleri, dilin en temel ve en güçlü veri yapılarından biridir. Bir Python geliştiricisi;

Liste oluşturmayı
Eleman eklemeyi/silmeyi
Sıralamayı
Dilimlemeyi
List comprehension kullanımını
İç içe listeleri
enumerate ve zip fonksiyonlarını

çok iyi seviyede bilmelidir. Veri analizi, web geliştirme, yapay zeka, otomasyon ve sistem programlama projelerinin büyük bölümü listeler üzerine kuruludur. Listeleri etkin kullanabilen bir geliştirici, Python ekosistemindeki diğer veri yapıları olan Set, Tuple, Dictionary, NumPy Array ve Pandas DataFrame yapılarını da çok daha hızlı öğrenebilir.

SQLite: Dünyanın En Yaygın Veritabanı Motoru

Vebende Akademi — Sun, 21 Jun 2026 08:25:40 +0000

SQLite: Dünyanın En Yaygın Veritabanı Motoru

Veritabanları denildiğinde çoğu geliştiricinin aklına ilk olarak PostgreSQL, MySQL, Oracle veya Microsoft SQL Server gelir. Ancak günlük hayatta en fazla kullanılan veritabanı motoru büyük ihtimalle bunlardan hiçbiri değildir.

Bugün milyarlarca cihazın içerisinde çalışan, internet bağlantısı gerektirmeyen, sunucu kurmadan kullanılabilen ve tek bir dosyada tüm verileri saklayan teknoloji:

SQLite'tır.

Cep telefonlarından web tarayıcılarına, gömülü sistemlerden masaüstü uygulamalarına kadar sayısız platformda çalışan SQLite, yazılım dünyasının en başarılı mühendislik projelerinden biri olarak kabul edilmektedir.

SQLite Nedir?

SQLite, gömülü (Embedded) çalışan, sunucusuz (Serverless), açık kaynak kodlu ve ilişkisel (Relational) bir veritabanı motorudur.

Diğer veritabanlarının aksine:

Ayrı bir servis kurulmaz
Sunucu çalıştırılmaz
Yönetim paneli gerekmez
Ağ bağlantısı kullanılmaz

Veritabanı doğrudan uygulamanın içerisine gömülür.

Çoğu durumda tüm veriler yalnızca tek bir dosyada saklanır.

Örneğin:

musteriler.db

Bu dosya;

Tabloları
İndeksleri
Verileri
Triggerları
View'leri

içerir.

SQLite Neden Bu Kadar Popüler?

SQLite'in başarısının arkasında üç temel neden vardır:

1. Kurulum Gerektirmez

PostgreSQL kurarken:

Servis kurulur
Kullanıcı oluşturulur
Port açılır
Yetkilendirme yapılır

SQLite'ta ise:

import sqlite3

conn = sqlite3.connect("uygulama.db")

satırı veritabanını oluşturmak için yeterlidir.

2. Tek Dosya Yapısı

Tüm veriler tek bir dosyada tutulur.

uygulama.db

Bu dosya:

Kopyalanabilir
Yedeklenebilir
E-posta ile gönderilebilir
USB belleğe taşınabilir

3. Son Derece Kararlıdır

SQLite yaklaşık yirmi beş yıldır geliştirilmektedir.

Milyarlarca cihazda kullanılmasına rağmen hata geçmişi son derece düşüktür.

Bu nedenle:

Havacılık
Savunma
Mobil cihazlar
Endüstriyel sistemler

gibi alanlarda güvenle kullanılmaktadır.

SQLite Nerelerde Kullanılır?

Birçok geliştirici SQLite'in sadece eğitim amaçlı kullanıldığını düşünür.

Gerçekte ise dünyanın en yaygın veritabanı motorlarından biridir.

Mobil Uygulamalar

Android cihazların büyük kısmında SQLite bulunur.

iOS uygulamalarının önemli bölümü de SQLite kullanır.

Web Tarayıcıları

Google Chrome

Yerel verilerin bir kısmını SQLite içerisinde saklar.

Mozilla Firefox

Profil bilgileri ve geçmiş kayıtlarında SQLite kullanır.

Masaüstü Yazılımları

Muhasebe programları
ERP sistemleri
CRM uygulamaları
CAD yazılımları

sıklıkla SQLite kullanır.

IoT ve Gömülü Sistemler

Akıllı sayaçlar
Endüstriyel PLC sistemleri
Sensör ağları
Araç takip sistemleri

hafif yapısı nedeniyle SQLite tercih eder.

Yapay Zekâ Uygulamaları

Son yıllarda:

AI Agent sistemleri
RAG uygulamaları
Yerel LLM çözümleri
Edge AI cihazları

SQLite kullanmaktadır.

SQLite Mimarisi

Klasik veritabanlarında mimari şöyledir:

Uygulama
     ↓
Network
     ↓
Database Server
     ↓
Disk

SQLite'ta ise:

Uygulama
     ↓
SQLite Library
     ↓
Database File

Bu nedenle ağ gecikmesi yoktur.

SQLite Nasıl Çalışır?

Örneğin:

import sqlite3

conn = sqlite3.connect("urunler.db")

komutu çalıştırıldığında:

urunler.db

dosyası oluşturulur.

Tüm SQL işlemleri doğrudan bu dosya üzerinde gerçekleştirilir.

Python ve SQLite

Python geliştiricileri için SQLite'in en büyük avantajı standart kütüphane içerisinde gelmesidir.

Ek kurulum gerekmez.

import sqlite3

hemen kullanılabilir.

İlk SQLite Uygulaması

Veritabanı Oluşturma

import sqlite3

conn = sqlite3.connect("okul.db")
cursor = conn.cursor()

Tablo Oluşturma

cursor.execute("""
CREATE TABLE ogrenciler (
    id INTEGER PRIMARY KEY,
    ad TEXT,
    soyad TEXT
)
""")

Veri Ekleme

cursor.execute("""
INSERT INTO ogrenciler
(ad, soyad)
VALUES
('Ahmet', 'Yılmaz')
""")

conn.commit()

Veri Okuma

cursor.execute("""
SELECT *
FROM ogrenciler
""")

for row in cursor.fetchall():
    print(row)

Çıktı:

(1, 'Ahmet', 'Yılmaz')

Parametreli Sorgular

Yeni başlayanların yaptığı en büyük hata:

ad = input()

sql = f"""
SELECT *
FROM kullanicilar
WHERE ad = '{ad}'
"""

şeklinde sorgu oluşturmaktır.

Bu yaklaşım SQL Injection saldırılarına açıktır.

Doğru yöntem:

cursor.execute(
    """
    SELECT *
    FROM kullanicilar
    WHERE ad = ?
    """,
    (ad,)
)

şeklindedir.

SQLite Veri Tipleri

SQLite veri tipi konusunda oldukça esnektir.

Temel veri tipleri:

Veri Tipi	Açıklama
INTEGER	Tamsayı
REAL	Ondalıklı sayı
TEXT	Metin
BLOB	Binary veri
NULL	Boş değer

İndeksler

Büyük veri kümelerinde indeks kullanmak kritik öneme sahiptir.

Tablo:

CREATE TABLE musteriler(
    id INTEGER,
    email TEXT
);

İndeks:

CREATE INDEX idx_email
ON musteriler(email);

Bu sayede:

SELECT *
FROM musteriler
WHERE email='test@test.com';

çok daha hızlı çalışır.

Transaction Yönetimi

SQLite ACID özelliklerini destekler.

ACID:

Atomicity
Consistency
Isolation
Durability

özelliklerinin tamamını sunar.

Örnek:

conn.execute("BEGIN")

try:
    cursor.execute(...)
    cursor.execute(...)
    conn.commit()

except:
    conn.rollback()

SQLite ve ORM Sistemleri

SQLite birçok ORM tarafından desteklenmektedir.

Python tarafında:

SQLAlchemy

Django ORM

Peewee

Tortoise ORM

SQLite ile doğrudan çalışabilir.

SQLite ve Django

Django varsayılan olarak SQLite kullanır.

Yeni proje oluşturduğunuzda:

django-admin startproject okul

otomatik olarak:

db.sqlite3

dosyası oluşur.

Bu nedenle milyonlarca Python geliştiricisi SQLite ile çalışmaya başlamaktadır.

SQLite ve Veri Bilimi

SQLite veri bilimi projelerinde de sıkça kullanılır.

Örneğin Pandas ile:

import pandas as pd
import sqlite3

conn = sqlite3.connect("satis.db")

df = pd.read_sql(
    "SELECT * FROM satislar",
    conn
)

print(df.head())

SQLite ve DuckDB Karşılaştırması

Özellik	SQLite	DuckDB
Amaç	Uygulama Veritabanı	Analitik Veritabanı
Mimari	Satır Bazlı	Kolon Bazlı
CRUD	Çok Güçlü	Orta
Dashboard Analitiği	Orta	Çok Güçlü
Transaction	Güçlü	Sınırlı
Mobil Kullanım	Mükemmel	Uygun Değil
Embedded Sistemler	Mükemmel	Sınırlı

Özetle:

Uygulama geliştiriyorsanız → SQLite
Analitik yapıyorsanız → DuckDB

tercih edilmelidir.

SQLite'in Güçlü Yanları

Son Derece Küçük

SQLite kütüphanesi birkaç megabayttan küçüktür.

Kurulum Gerektirmez

Sunucu yönetimi yoktur.

Hızlıdır

Yerel disk erişimi sayesinde birçok senaryoda oldukça yüksek performans sunar.

Taşınabilirdir

Tek dosya yapısı büyük avantaj sağlar.

Ücretsizdir

Herhangi bir lisans maliyeti bulunmaz.

SQLite'in Sınırlamaları

Çok Kullanıcılı Sistemler

Binlerce eşzamanlı yazma işlemi için tasarlanmamıştır.

Büyük Kurumsal Sistemler

Milyarlarca satırlık ve yüksek trafik alan sistemlerde:

PostgreSQL
MySQL
Microsoft SQL Server

daha uygun seçeneklerdir.

Dağıtık Yapılar

Cluster mimarileri için tasarlanmamıştır.

Yazılım Dünyasında SQLite'in Önemi

SQLite çoğu zaman "küçük veritabanı" olarak görülse de gerçekte yazılım dünyasının temel taşlarından biridir. Mobil cihazlardan masaüstü uygulamalarına, IoT sistemlerinden yapay zekâ çözümlerine kadar milyarlarca cihazda çalışmaktadır.

Python geliştiricileri için ise SQLite, veritabanı dünyasına giriş yapmak için en ideal teknolojidir. Kurulum gerektirmemesi, standart kütüphane içerisinde gelmesi, SQL öğrenimini kolaylaştırması ve üretim ortamlarında dahi kullanılabilecek kadar kararlı olması nedeniyle her Python geliştiricisinin mutlaka öğrenmesi gereken teknolojiler arasında yer alır.

Bir yazılım geliştiricisi için SQLite yalnızca bir veritabanı değil, aynı zamanda veriyi yönetmenin, saklamanın ve ilişkisel modellemeyi öğrenmenin en pratik yoludur. Modern yazılım ekosisteminde PostgreSQL, MySQL veya büyük veri platformlarına geçmeden önce edinilecek SQLite bilgisi, veritabanı mühendisliğinin sağlam temellerini oluşturur.