← Kursa Dön
📄 Text · 18 min

Liste (List) Kullanımı

Liste, Python'un en temel ve en çok kullanılan veri yapısı. Sıralı, değiştirilebilir (mutable) ve her tür veriyi barındırabilen bir koleksiyon. Eğer Python'da tek bir veri yapısı öğrenecek olsan, bu liste olmalı — diğer her şeyin temeli burada.

Bir alışveriş listesi düşün. Üzerine yeni ürün eklersin, ürün silersin, sırasını değiştirirsin, kaçıncı sırada ne var diye bakarsın. Python'daki list tam olarak bu — dijital bir alışveriş listesi, ama içine sayıdan string'e, listeden fonksiyona kadar her şeyi koyabilirsin.

Liste Oluşturma

# Boş liste
bos = []
bos2 = list()

# Elemanlarla oluşturma
meyveler = ["elma", "armut", "muz"]
sayilar = [1, 2, 3, 4, 5]
karisik = [42, "merhaba", 3.14, True, None]

# list() ile dönüştürme
harfler = list("Python")       # ['P', 'y', 't', 'h', 'o', 'n']
sayilar2 = list(range(1, 6))   # [1, 2, 3, 4, 5]
kume_den = list({3, 1, 2})     # [1, 2, 3] (sıra garanti değil)

# Tekrarlı liste
sifirlar = [0] * 5             # [0, 0, 0, 0, 0]
abc = ["ab"] * 3               # ['ab', 'ab', 'ab']

⚠️ Tekrarlı Liste Tuzağı

# ❌ Dikkat: iç içe listede * operatörü referans kopyalar!
matris = [[0] * 3] * 3
print(matris)  # [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

matris[0][0] = 1
print(matris)  # [[1, 0, 0], [1, 0, 0], [1, 0, 0]] — Hepsi değişti!

# ✅ Doğru yol: list comprehension
matris = [[0] * 3 for _ in range(3)]
matris[0][0] = 1
print(matris)  # [[1, 0, 0], [0, 0, 0], [0, 0, 0]] — Sadece ilki değişti

Bu çok yaygın bir hata. [[0] * 3] * 3 yazdığında, 3 satırın hepsi aynı liste nesnesine işaret eder. Birini değiştirince hepsi değişir.

İndeksleme (Indexing)

Python'da indeksler 0'dan başlar. Son elemanın indeksi len(liste) - 1'dir.

meyveler = ["elma", "armut", "muz", "çilek", "kivi"]

# Pozitif indeks (baştan)
print(meyveler[0])   # elma (ilk)
print(meyveler[1])   # armut (ikinci)
print(meyveler[4])   # kivi (beşinci)

# Negatif indeks (sondan)
print(meyveler[-1])  # kivi (son)
print(meyveler[-2])  # çilek (sondan ikinci)
print(meyveler[-5])  # elma (sondan beşinci = ilk)
 Pozitif:    0       1       2       3       4
          ["elma", "armut", "muz", "çilek", "kivi"]
 Negatif:   -5      -4      -3      -2      -1

IndexError

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

# ❌ Var olmayan indeks
print(meyveler[5])   # IndexError: list index out of range
print(meyveler[-4])  # IndexError: list index out of range

Dilimleme (Slicing)

Dilimleme, listenin bir alt kümesini almanı sağlar. Söz dizimi: liste[start:stop:step]

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

# Temel dilimleme: [start:stop] (stop hariç)
print(sayilar[2:5])    # [2, 3, 4]
print(sayilar[:3])     # [0, 1, 2] — baştan 3 eleman
print(sayilar[7:])     # [7, 8, 9] — 7'den sona kadar
print(sayilar[:])      # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] — kopya

# Step ile dilimleme
print(sayilar[::2])    # [0, 2, 4, 6, 8] — ikişer atlayarak
print(sayilar[1::2])   # [1, 3, 5, 7, 9] — tek indeksler
print(sayilar[::-1])   # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] — ters

# Negatif indekslerle
print(sayilar[-3:])    # [7, 8, 9] — son 3 eleman
print(sayilar[:-2])    # [0, 1, 2, 3, 4, 5, 6, 7] — son 2 hariç

Dilimleme ile Değiştirme

harfler = ["a", "b", "c", "d", "e"]

# Bir aralığı değiştir
harfler[1:3] = ["X", "Y"]
print(harfler)  # ['a', 'X', 'Y', 'd', 'e']

# Farklı uzunlukta atama (liste büyür/küçülür)
harfler[1:3] = ["B", "C", "D", "E"]
print(harfler)  # ['a', 'B', 'C', 'D', 'E', 'd', 'e']

# Silme (boş liste atama)
harfler[1:5] = []
print(harfler)  # ['a', 'd', 'e']

Dilimleme Asla IndexError Vermez

sayilar = [1, 2, 3]

print(sayilar[10:20])  # [] — hata yok, boş liste döner
print(sayilar[-100:2]) # [1, 2] — sınırlar otomatik ayarlanır

Bu, indekslemeden farklı! sayilar[10] hata verir ama sayilar[10:20] boş liste döndürür.

Liste Metodları

Eleman Ekleme

meyveler = ["elma", "armut"]

# append: Sona tek eleman ekle
meyveler.append("muz")
print(meyveler)  # ['elma', 'armut', 'muz']

# extend: Sona birden fazla eleman ekle (iterable)
meyveler.extend(["çilek", "kivi"])
print(meyveler)  # ['elma', 'armut', 'muz', 'çilek', 'kivi']

# insert: Belirli pozisyona ekle
meyveler.insert(1, "portakal")  # 1. indekse
print(meyveler)  # ['elma', 'portakal', 'armut', 'muz', 'çilek', 'kivi']

append vs extend

a = [1, 2, 3]

# append: Nesneyi olduğu gibi ekler
a.append([4, 5])
print(a)  # [1, 2, 3, [4, 5]] — liste içinde liste!

b = [1, 2, 3]

# extend: Iterable'ın elemanlarını ekler
b.extend([4, 5])
print(b)  # [1, 2, 3, 4, 5] — düz liste

+ Operatörü vs extend

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

# + ile yeni liste oluşturur (orijinaller değişmez)
c = a + b
print(c)  # [1, 2, 3, 4, 5, 6]
print(a)  # [1, 2, 3] — değişmedi

# extend ile orijinal listeyi değiştirir
a.extend(b)
print(a)  # [1, 2, 3, 4, 5, 6] — değişti!

Eleman Silme

meyveler = ["elma", "armut", "muz", "çilek", "armut"]

# remove: İlk eşleşeni sil (değere göre)
meyveler.remove("armut")
print(meyveler)  # ['elma', 'muz', 'çilek', 'armut'] — ilk armut silindi

# pop: Belirli indeksten sil ve değeri döndür
silinen = meyveler.pop(1)  # 1. indeks
print(silinen)    # muz
print(meyveler)   # ['elma', 'çilek', 'armut']

# pop: Parametresiz → son elemanı sil
son = meyveler.pop()
print(son)        # armut
print(meyveler)   # ['elma', 'çilek']

# clear: Tüm elemanları sil
meyveler.clear()
print(meyveler)   # []

# del: İndeks veya dilim sil
sayilar = [0, 1, 2, 3, 4, 5]
del sayilar[0]     # İlk elemanı sil
print(sayilar)     # [1, 2, 3, 4, 5]
del sayilar[1:3]   # 1. ve 2. indeksi sil
print(sayilar)     # [1, 4, 5]

Arama ve Sayma

meyveler = ["elma", "armut", "muz", "elma", "çilek", "elma"]

# index: İlk bulunduğu indeks
print(meyveler.index("armut"))  # 1
print(meyveler.index("elma"))   # 0 (ilk eşleşme)

# index hata verebilir!
# meyveler.index("kivi")  # ValueError: 'kivi' is not in list

# Güvenli arama: önce in ile kontrol et
if "kivi" in meyveler:
    idx = meyveler.index("kivi")
else:
    idx = -1

# count: Kaç kez geçtiği
print(meyveler.count("elma"))   # 3
print(meyveler.count("kivi"))   # 0

Sıralama ve Ters Çevirme

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

# reverse: Yerinde ters çevir
sayilar.reverse()
print(sayilar)  # [6, 2, 9, 5, 1, 4, 1, 3]

# sort: Yerinde sırala
sayilar.sort()
print(sayilar)  # [1, 1, 2, 3, 4, 5, 6, 9]

# sort — azalan sıra
sayilar.sort(reverse=True)
print(sayilar)  # [9, 6, 5, 4, 3, 2, 1, 1]

in Operatörü ile Arama

in operatörü bir elemanın listede olup olmadığını kontrol eder:

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

print("elma" in meyveler)      # True
print("kivi" in meyveler)      # False
print("kivi" not in meyveler)  # True

Performans Notu

# Listede in operatörü O(n) — her elemanı kontrol eder
buyuk_liste = list(range(1_000_000))

# ❌ Yavaş — 1 milyon eleman taranabilir
999_999 in buyuk_liste  # True ama yavaş

# ✅ Hızlı — set'te in operatörü O(1)
buyuk_set = set(range(1_000_000))
999_999 in buyuk_set    # True ve çok hızlı

Sık arama yapıyorsan listeyi set'e çevir. Bu konuyu B04_set dersinde detaylı göreceğiz.

Liste Kopyalama: Shallow vs Deep

Bu konu çok önemli ve yaygın hata kaynağı.

Sığ Kopya (Shallow Copy)

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

# 3 farklı yol — hepsi shallow copy
kopya1 = original.copy()
kopya2 = original[:]
kopya3 = list(original)

kopya1[0] = 999
print(original)  # [1, 2, 3, 4, 5] — değişmedi ✅
print(kopya1)    # [999, 2, 3, 4, 5]

Basit veri tiplerinde (int, str, float) sorun yok. Ama iç içe listelerde tuzak var:

# ⚠️ Shallow copy — iç listeler referans kopyalanır!
original = [[1, 2], [3, 4], [5, 6]]
kopya = original.copy()

kopya[0][0] = 999
print(original)  # [[999, 2], [3, 4], [5, 6]] — Orijinal de değişti!
print(kopya)     # [[999, 2], [3, 4], [5, 6]]

Neden? Çünkü shallow copy sadece birinci seviye referansları kopyalar. İç listeler hâlâ aynı nesneyi işaret eder.

Derin Kopya (Deep Copy)

import copy

original = [[1, 2], [3, 4], [5, 6]]
kopya = copy.deepcopy(original)

kopya[0][0] = 999
print(original)  # [[1, 2], [3, 4], [5, 6]] — Değişmedi! ✅
print(kopya)     # [[999, 2], [3, 4], [5, 6]]

deepcopy tüm iç içe nesneleri de kopyalar. Ama daha yavaştır — sadece gerçekten gerektiğinde kullan.

💡 İpucu: Kural basit: düz liste (int, str gibi basit elemanlar) → copy() veya [:] yeterli. İç içe liste (liste içinde liste, dict içinde liste vs.) → copy.deepcopy() kullan.

Nested Listeler (Matris)

İç içe listeler, 2D veri yapıları (matris, tablo) için kullanılır:

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

# Erişim: matris[satır][sütun]
print(matris[0][0])  # 1 (sol üst)
print(matris[1][2])  # 6 (2. satır, 3. sütun)
print(matris[2][1])  # 8 (3. satır, 2. sütun)

# Bir satırı al
print(matris[1])     # [4, 5, 6]

Matris İşlemleri

# Satır toplamları
for i, satir in enumerate(matris):
    print(f"Satır {i} toplamı: {sum(satir)}")

# Sütun toplamları
for j in range(len(matris[0])):
    sutun_toplam = sum(matris[i][j] for i in range(len(matris)))
    print(f"Sütun {j} toplamı: {sutun_toplam}")

# Köşegen elemanları
kosegen = [matris[i][i] for i in range(len(matris))]
print(f"Köşegen: {kosegen}")  # [1, 5, 9]

Düzleştirme (Flatten)

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

# List comprehension ile
duz = [eleman for satir in matris for eleman in satir]
print(duz)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# itertools ile
from itertools import chain
duz2 = list(chain.from_iterable(matris))
print(duz2)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

Liste Unpacking

Python'un güçlü unpacking (paket açma) mekanizması:

# Temel unpacking
koordinat = [3, 7]
x, y = koordinat
print(f"x={x}, y={y}")  # x=3, y=7

# Yıldızlı unpacking
sayilar = [1, 2, 3, 4, 5]
ilk, *orta, son = sayilar
print(ilk)    # 1
print(orta)   # [2, 3, 4]
print(son)    # 5

# İlk elemanı al, gerisini topla
bas, *geri = [10, 20, 30, 40, 50]
print(bas)    # 10
print(geri)   # [20, 30, 40, 50]

# Son elemanı al
*bas, son = [10, 20, 30, 40, 50]
print(bas)    # [10, 20, 30, 40]
print(son)    # 50

Swap (Değer Değiştirme)

# Python'da swap çok kolay!
a, b = 5, 10
a, b = b, a
print(a, b)  # 10, 5

# Listede iki elemanı swap
liste = [1, 2, 3, 4, 5]
liste[0], liste[4] = liste[4], liste[0]
print(liste)  # [5, 2, 3, 4, 1]

Fonksiyon Parametresinde Unpacking

def toplam_hesapla(a, b, c):
    return a + b + c

sayilar = [10, 20, 30]
sonuc = toplam_hesapla(*sayilar)  # * ile listeyi aç
print(sonuc)  # 60

sort() vs sorted()

Bu iki yöntem arasındaki fark kritik:

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

# sort(): Yerinde sıralar, None döndürür (orijinal değişir)
sonuc = sayilar.sort()
print(sonuc)    # None!
print(sayilar)  # [1, 1, 2, 3, 4, 5, 6, 9]

# sorted(): Yeni liste döndürür (orijinal değişmez)
sayilar2 = [3, 1, 4, 1, 5, 9, 2, 6]
yeni = sorted(sayilar2)
print(yeni)      # [1, 1, 2, 3, 4, 5, 6, 9]
print(sayilar2)  # [3, 1, 4, 1, 5, 9, 2, 6] — değişmedi
sort()sorted()
TipListe metoduBuilt-in fonksiyon
OrijinalDeğiştirirDeğiştirmez
DöndürürNoneYeni liste
ÇalışırSadece listedeHer iterable'da
# sorted() her iterable'da çalışır
print(sorted("python"))         # ['h', 'n', 'o', 'p', 't', 'y']
print(sorted({3, 1, 2}))       # [1, 2, 3]
print(sorted((5, 2, 8)))       # [2, 5, 8]
print(sorted({"c": 3, "a": 1}))  # ['a', 'c']

⚠️ Dikkat: sort() None döndürür! Bu yaygın bir hata kaynağıdır: ```python # ❌ YANLIŞ — sonuc None olur! sonuc = [3, 1, 2].sort() print(sonuc) # None

>

# ✅ DOĞRU sonuc = sorted([3, 1, 2]) print(sonuc) # [1, 2, 3] ```

key Parametresi ile Custom Sıralama

sort() ve sorted() fonksiyonlarının key parametresi, elemanların neye göre sıralanacağını belirler:

# String uzunluğuna göre sırala
kelimeler = ["python", "c", "javascript", "go", "rust"]

kelimeler.sort(key=len)
print(kelimeler)  # ['c', 'go', 'rust', 'python', 'javascript']

# Büyük/küçük harf duyarsız sıralama
isimler = ["ayşe", "Ahmet", "mehmet", "Barış"]
sirali = sorted(isimler, key=str.lower)
print(sirali)  # ['Ahmet', 'ayşe', 'Barış', 'mehmet']

Lambda ile Custom Key

ogrenciler = [
    {"isim": "Ahmet", "not": 85},
    {"isim": "Ayşe", "not": 92},
    {"isim": "Mehmet", "not": 78},
]

# Nota göre sırala (artan)
ogrenciler.sort(key=lambda x: x["not"])
for o in ogrenciler:
    print(f"{o['isim']}: {o['not']}")
# Mehmet: 78
# Ahmet: 85
# Ayşe: 92

# Nota göre sırala (azalan)
ogrenciler.sort(key=lambda x: x["not"], reverse=True)

Birden Fazla Kritere Göre Sıralama

ogrenciler = [
    ("Ahmet", 85, "A"),
    ("Ayşe", 85, "B"),
    ("Mehmet", 92, "A"),
    ("Zeynep", 78, "B"),
]

# Önce nota göre (azalan), sonra isme göre (artan)
sirali = sorted(ogrenciler, key=lambda x: (-x[1], x[0]))
for s in sirali:
    print(s)
# ('Mehmet', 92, 'A')
# ('Ahmet', 85, 'A')
# ('Ayşe', 85, 'B')
# ('Zeynep', 78, 'B')

operator.itemgetter ile Sıralama

from operator import itemgetter

veriler = [
    ("İstanbul", 16_000_000),
    ("Ankara", 5_700_000),
    ("İzmir", 4_400_000),
]

# Nüfusa göre sırala (lambda yerine)
sirali = sorted(veriler, key=itemgetter(1), reverse=True)
for sehir, nufus in sirali:
    print(f"{sehir}: {nufus:,}")

Liste ile Yararlı Built-in Fonksiyonlar

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

print(len(sayilar))   # 9 — eleman sayısı
print(sum(sayilar))   # 45 — toplam
print(min(sayilar))   # 1 — en küçük
print(max(sayilar))   # 9 — en büyük
print(any(sayilar))   # True — en az biri truthy mi?
print(all(sayilar))   # True — hepsi truthy mi?

# any/all ile koşullu kontrol
notlar = [85, 72, 90, 68, 95]
print(any(n > 90 for n in notlar))  # True — en az biri 90'dan büyük
print(all(n >= 60 for n in notlar)) # True — hepsi 60'tan büyük

map() ve filter()

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

# map: her elemana fonksiyon uygula
kareler = list(map(lambda x: x ** 2, sayilar))
print(kareler)  # [1, 4, 9, 16, 25]

# filter: koşulu sağlayanları filtrele
ciftler = list(filter(lambda x: x % 2 == 0, sayilar))
print(ciftler)  # [2, 4]

Ama çoğu durumda list comprehension daha okunabilir:

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

Liste ile Yararlı Built-in Fonksiyonlar (Detaylı)

Python'un built-in fonksiyonları listelerle çok uyumlu çalışır:

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

print(len(sayilar))   # 9 — eleman sayısı
print(sum(sayilar))   # 45 — toplam
print(min(sayilar))   # 1 — en küçük
print(max(sayilar))   # 9 — en büyük

# Ortalama (built-in yok, hesapla)
ortalama = sum(sayilar) / len(sayilar)
print(f"Ortalama: {ortalama}")  # 5.0

any() ve all()

notlar = [85, 72, 90, 68, 95]

# any: En az biri True mu?
print(any(n > 90 for n in notlar))  # True — 95 var
print(any(n < 0 for n in notlar))   # False — negatif yok

# all: Hepsi True mu?
print(all(n >= 60 for n in notlar)) # True — hepsi 60+
print(all(n >= 80 for n in notlar)) # False — 72 ve 68 var

# Boş liste kontrolü
print(any([]))  # False
print(all([]))  # True — vacuous truth (boş kümede hepsi doğru)

map() ve filter()

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

# map: her elemana fonksiyon uygula
kareler = list(map(lambda x: x ** 2, sayilar))
print(kareler)  # [1, 4, 9, 16, 25]

# filter: koşulu sağlayanları filtrele
ciftler = list(filter(lambda x: x % 2 == 0, sayilar))
print(ciftler)  # [2, 4]

# map + filter zincirleme
sonuc = list(map(str, filter(lambda x: x > 2, sayilar)))
print(sonuc)  # ['3', '4', '5']

Ama çoğu durumda list comprehension daha okunabilir:

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

reduce() — Biriktirme

from functools import reduce

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

# Tüm elemanları çarp
carpim = reduce(lambda a, b: a * b, sayilar)
print(carpim)  # 120 (1*2*3*4*5)

# En büyük elemanı bul (max yerine)
en_buyuk = reduce(lambda a, b: a if a > b else b, sayilar)
print(en_buyuk)  # 5

Liste ile String Dönüşümleri

Listeler ve stringler arasında sık dönüşüm yapılır:

# String → Liste
metin = "Python çok güzel"
kelimeler = metin.split()
print(kelimeler)  # ['Python', 'çok', 'güzel']

# Özel ayraçla bölme
tarih = "2026-02-20"
parcalar = tarih.split("-")
print(parcalar)  # ['2026', '02', '20']

# Liste → String
kelimeler = ["Python", "çok", "güzel"]
birlesik = " ".join(kelimeler)
print(birlesik)  # Python çok güzel

# Virgülle birleştir
csv_satir = ",".join(["Ahmet", "25", "İstanbul"])
print(csv_satir)  # Ahmet,25,İstanbul

# Her karakteri ayır
harfler = list("Python")
print(harfler)  # ['P', 'y', 't', 'h', 'o', 'n']
tekrar = "".join(harfler)
print(tekrar)  # Python

Liste ile Performans Notu: String Birleştirme

# ❌ Yavaş — her += yeni string oluşturur O(n²)
sonuc = ""
for kelime in kelimeler:
    sonuc += kelime + " "

# ✅ Hızlı — join O(n)
sonuc = " ".join(kelimeler)

join() tek geçişte belleği tahsis eder ve kopyalar. += ise her adımda yeni string yaratır. Büyük listelerde fark çok belirgin.

Pratik Örnekler

Örnek 1: En Büyük 3 Elemanı Bul

sayilar = [45, 12, 88, 33, 67, 91, 5, 73]

# Yol 1: Sırala ve son 3'ü al
en_buyuk_3 = sorted(sayilar, reverse=True)[:3]
print(en_buyuk_3)  # [91, 88, 73]

# Yol 2: heapq ile (büyük listelerde daha verimli)
import heapq
en_buyuk_3 = heapq.nlargest(3, sayilar)
print(en_buyuk_3)  # [91, 88, 73]

Örnek 2: Liste Döndürme (Rotate)

def rotate(liste, k):
    """Listeyi k adım sağa döndür."""
    k = k % len(liste)  # Taşmayı önle
    return liste[-k:] + liste[:-k]

sayilar = [1, 2, 3, 4, 5]
print(rotate(sayilar, 2))  # [4, 5, 1, 2, 3]
print(rotate(sayilar, 7))  # [4, 5, 1, 2, 3] (7 % 5 = 2)

Örnek 3: Matris Çarpımı (Basitleştirilmiş)

def matris_carp(A, B):
    """İki matrisin çarpımını hesapla."""
    satir_A = len(A)
    sutun_A = len(A[0])
    sutun_B = len(B[0])

    # Sonuç matrisi (sıfırlarla dolu)
    C = [[0] * sutun_B for _ in range(satir_A)]

    for i in range(satir_A):
        for j in range(sutun_B):
            for k in range(sutun_A):
                C[i][j] += A[i][k] * B[k][j]

    return C

A = [[1, 2], [3, 4]]
B = [[5, 6], [7, 8]]
sonuc = matris_carp(A, B)
print(sonuc)  # [[19, 22], [43, 50]]

Örnek 4: Sliding Window (Kayan Pencere)

def kayan_pencere_ortalama(sayilar, pencere_boyutu):
    """Her pencere konumundaki ortalamayı hesapla."""
    if len(sayilar) < pencere_boyutu:
        return []

    sonuc = []
    for i in range(len(sayilar) - pencere_boyutu + 1):
        pencere = sayilar[i:i + pencere_boyutu]
        ortalama = sum(pencere) / pencere_boyutu
        sonuc.append(round(ortalama, 2))

    return sonuc

veriler = [10, 20, 30, 40, 50, 60, 70]
print(kayan_pencere_ortalama(veriler, 3))
# [20.0, 30.0, 40.0, 50.0, 60.0]

Örnek 5: İki Sıralı Listeyi Birleştir (Merge)

def merge_sorted(a, b):
    """İki sıralı listeyi sıralı şekilde birleştir."""
    sonuc = []
    i = j = 0

    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            sonuc.append(a[i])
            i += 1
        else:
            sonuc.append(b[j])
            j += 1

    sonuc.extend(a[i:])
    sonuc.extend(b[j:])
    return sonuc

print(merge_sorted([1, 3, 5], [2, 4, 6]))
# [1, 2, 3, 4, 5, 6]

Özet

  • Liste Python'un en temel veri yapısıdır — sıralı, mutable, her tür veriyi barındırır. [] veya list() ile oluşturulur.

  • İndeksleme 0'dan başlar; negatif indeksler sondan sayar. Dilimleme [start:stop:step] söz dizimi ile alt liste alır ve asla IndexError vermez.

  • Temel metodlar: append() sona ekler, extend() birden fazla ekler, insert() pozisyona ekler; remove() değere göre, pop() indekse göre siler.

  • Kopyalama: Düz listelerde copy() veya [:] yeterli (shallow). İç içe yapılarda copy.deepcopy() kullan — yoksa iç nesneler paylaşılır.

  • `sort()` vs `sorted()`: sort() yerinde sıralar ve None döndürür, sorted() yeni liste döndürür. key parametresi ile custom sıralama yapılır.

  • Unpacking (a, *rest = liste) güçlü bir Python özelliği — swap, fonksiyon argümanı açma ve değişken atama için kullanılır.