# Python'da listeler (list): metotlar, dilimleme, sıralama, append, demetler ve kümeler

URL: https://skillaria.top/tr/guides/python/python-listeler

Python'da liste (list), köşeli parantez içinde yazılan, sıralı ve değiştirilebilir bir koleksiyondur; örneğin [250, 1200, 99]. Elemanlar append ile eklenebilir, araya sokulabilir, silinebilir, dilimlerle alınabilir ve sıralanabilir. sort listeyi yerinde sıralayıp None döndürür; sorted ise yeni, sıralanmış bir liste verir.

Python'da liste (`list`), köşeli parantez içinde yazılan, sıralı ve değiştirilebilen bir değer koleksiyonudur: sonuna eleman eklenebilir, ortasına sokulabilir, silinebilir, sıralanabilir. Dildeki en yaygın koleksiyon budur: dosyanın satırları, bir aylık harcamalar, API yanıtları, neredeyse her şey bir liste olarak başlar. Python list'ini baştan sona ele alalım: oluşturma, metotlar, dilimleme, sıralama, liste üretimi, kopyalama ve sonunda demetler ile kümeler.

## Python'da liste nedir

Liste, elemanları verdiğiniz sırayla tutar ve elemanlara sıfırdan başlayan indekslerle erişilir. Aynı listede farklı türde değerler de bulunabilir, ama pratikte genellikle benzer veriler tutulur.

```
amounts = [250, 1200, 99]
print(amounts[0])     # 250 — ilk eleman
print(amounts[-1])    # 99 — son eleman
amounts[1] = 1300     # liste değiştirilebilir
print(len(amounts))   # 3 — liste uzunluğu
```

Listenin boyutunu `len()` fonksiyonu verir. Olmayan bir indekse erişmek `IndexError: list index out of range` hatasına yol açar.

## Liste oluşturmak

```
empty = []                       # boş liste
also_empty = list()              # aynısı list fonksiyonuyla
nums = [1, 2, 3]
chars = list("abc")              # ['a', 'b', 'c']
digits = list(range(5))          # [0, 1, 2, 3, 4]
zeros = [0] * 4                  # [0, 0, 0, 0]
```

`list()` fonksiyonu, dolaşılabilen her nesneyi listeye çevirir: bir metni, `range` aralığını, kümeyi, sözlüğün anahtarlarını.

## append ve diğer liste metotları

`append` metodu listenin sonuna tek bir eleman ekler; Python'da en sık kullanılan metottur. Listeyi yerinde değiştirir ve `None` döndürür.

```
amounts = [250, 1200]
amounts.append(450)          # [250, 1200, 450]
amounts.extend([10, 20])     # [250, 1200, 450, 10, 20]
amounts.insert(0, 5)         # [5, 250, 1200, 450, 10, 20]
amounts.remove(1200)         # ilk 1200 değerini sil
last = amounts.pop()         # 20 — son elemanı sil ve döndür
```

Sık yapılan hata: `a.append([10, 20])` tek bir eleman ekler; o eleman iç içe bir listedir, iki sayı değildir. Birden fazla eleman eklemek için `extend` kullanın.

| Metot | Ne yapar |
| --- | --- |

| `append(x)` | x'i sona ekler |

| `extend(iter)` | dizinin tüm elemanlarını ekler |

| `insert(i, x)` | x'i i indeksinden önce ekler |

| `remove(x)` | x'in ilk geçişini siler (yoksa ValueError) |

| `pop(i=-1)` | indeksteki elemanı siler ve döndürür |

| `index(x)` | ilk geçtiği indeks |

| `count(x)` | x kaç kez geçiyor |

| `sort()` | yerinde sıralar |

| `reverse()` | yerinde ters çevirir |

| `copy()` | yüzeysel kopya |

| `clear()` | listeyi temizler |

Bir elemanı indeksle ya da bir aralığı `del` operatörüyle de silebilirsiniz: `del a[0]`, `del a[1:3]`. Listelerle birlikte kullanılan yararlı yerleşik fonksiyonlar: `len`, `sum`, `min`, `max`, `sorted`, `reversed`, `enumerate`, `zip`.

## Python'da dilimleme

Dilim, listenin bir parçasını `a[başlangıç:bitiş:adım]` biçiminde alır: başlangıç dahil, bitiş hariç, adım kadar ilerleyerek. Her kısım atlanabilir. Dilim her zaman yeni bir liste döndürür.

```
a = [0, 1, 2, 3, 4, 5]
print(a[1:4])     # [1, 2, 3]
print(a[:2])      # [0, 1] — ilk iki eleman
print(a[-2:])     # [4, 5] — son iki eleman
print(a[::2])     # [0, 2, 4] — her ikinci eleman
print(a[::-1])    # [5, 4, 3, 2, 1, 0] — ters çevrilmiş
print(a[:])       # tüm listenin kopyası
```

İndeksin aksine, liste sınırlarının dışındaki bir dilim hata vermez: `a[10:20]` sadece `[]` döndürür. Bir dilime değer atayarak listenin bir parçasını değiştirebilirsiniz: `a[1:3] = ["x", "y", "z"]`.

### String dilimleme

Dilimler, listeler ve demetlerle olduğu gibi stringlerde de aynı şekilde çalışır:

```
s = "Python 3.15"
print(s[:6])      # Python
print(s[-4:])     # 3.15
print(s[::-1])    # 51.3 nohtyP
```

Dilimle bir stringi değiştiremezsiniz; stringler değiştirilemezdir, dilim yeni bir string üretir.

## Liste sıralama: sort ve sorted

Yeni başlayanların en çok karıştırdığı konu budur. `sort` metodu elemanları listenin kendisinde yeniden dizer ve `None` döndürür. `sorted` fonksiyonu ise orijinal listeye dokunmaz, sıralanmış yeni bir liste verir.

```
amounts = [250, 1200, 99]
amounts.append(450)
print(sorted(amounts))     # [99, 250, 450, 1200] — yeni kopya
print(amounts)             # [250, 1200, 99, 450] — orijinal duruyor

result = amounts.sort()    # yerinde sıralar
print(result, amounts)     # None [99, 250, 450, 1200]
```

Buradan klasik "neden None çıktı" sorunu doğar: `a = a.sort()` listeyi `None` değeriyle üzerine yazar. Ya `a.sort()` yazın ya da `a = sorted(a)`.

### Anahtar ve ters sıra

İki yöntem de `key` ve `reverse` parametrelerini kabul eder. `key`, elemanların hangi değere göre karşılaştırılacağını belirleyen bir fonksiyondur.

```
words = ["kahve", "Taksi", "abonelik"]
print(sorted(words, key=len))               # ['kahve', 'Taksi', 'abonelik']
print(sorted(words, key=str.lower))         # büyük-küçük harf farkı olmadan
print(sorted([3, 1, 2], reverse=True))      # [3, 2, 1]

expenses = [("Yiyecek", 650), ("Sinema", 120), ("Taksi", 300)]
expenses.sort(key=lambda e: e[1])           # tutara göre
```

Python'daki sıralama kararlıdır: aynı anahtara sahip elemanlar özgün sıralarını korur. Fark ayrıca uygulanabilirlikte de ortaya çıkar: `sorted` her dizide (metin, sözlük, küme) çalışır; `sort` ise yalnızca listelerde vardır.

## Listeyi ters çevirmek

Üç yol var, davranışları farklıdır:

- `a.reverse()` — yerinde ters çevirir, `None` döndürür;
- `a[::-1]` — ters çevrilmiş yeni bir liste verir;
- `reversed(a)` — tembel bir yineleyicidir, döngüde kullanışlıdır: `for x in reversed(a):`.

## Liste üzerinde dolaşmak

```
items = ["kahve", "metro", "sinema"]
for item in items:
    print(item)

for i, item in enumerate(items, start=1):
    print(i, item)          # 1 kahve, 2 metro, 3 sinema

print("sinema" in items)    # True — eleman var mı kontrolü
```

Üzerinde döngü dönen listeden eleman silmeyin; bazı elemanlar atlanır. Yeni bir liste üretin ya da kopya `a[:]` üzerinde dolaşın.

## Liste üretimi (list comprehension)

Liste üretimi, yeni bir listeyi tek satırda kurar: bir ifade, bir döngü ve isteğe bağlı bir koşul.

```
squares = [n * n for n in range(6)]              # [0, 1, 4, 9, 16, 25]
big = [a for a in [250, 1200, 99] if a > 200]    # [250, 1200]
names = [s.strip().title() for s in [" ayşe ", "ali"]]
```

Liste üretimleri genellikle `append` kullanan bir döngüden daha hızlı ve daha okunaklıdır. Ama mantık tek ve anlaşılır bir satıra sığmıyorsa, düzgün bir döngü daha iyidir.

## Listeleri birleştirmek, toplamak ve çıkarmak

```
a = [1, 2, 3]
b = [3, 4]
print(a + b)       # [1, 2, 3, 3, 4] — yeni liste
a += b             # a.extend(b) ile aynı
print([*a, *b])    # açarak yeni listeye koymak
```

Listeleri `-` operatörüyle çıkaramazsınız. Bir listeden başka bir listenin elemanlarını çıkarmak için liste üretimi kullanın: `[x for x in a if x not in set(b)]`. İki listenin kesişimini kümeler üzerinden bulmak en kolayıdır: `set(a) & set(b)` (ancak sıra ve tekrarlar bu durumda kaybolur).

## İç içe ve iki boyutlu listeler

Liste içinde liste, bir tabloyu ya da matrisi saklamanın basit yoludur:

```
matrix = [[1, 2, 3], [4, 5, 6]]
print(matrix[1][2])     # 6
grid = [[0] * 3 for _ in range(2)]   # doğrusu
bad = [[0] * 3] * 2                  # tuzak: aynı listeye iki referans
bad[0][0] = 9
print(bad)              # [[9, 0, 0], [9, 0, 0]]
```

## Liste açmak (unpacking)

```
first, second, third = [10, 20, 30]
head, *rest = [1, 2, 3, 4]      # head=1, rest=[2, 3, 4]
print(*["a", "b"], sep=", ")    # a, b — listeyi parantezsiz yazdırmak
```

Değişken sayısı listenin uzunluğuyla eşleşmezse `ValueError` alırsınız; yıldızlı değişken bu durumda işinizi görür.

## Listeyi kopyalamak

`b = a` bir listeyi kopyalamaz, aynı nesneye ikinci bir ad verir: `b` üzerinden yapılan değişiklikler `a`'da da görünür. Bağımsız bir kopya için açıkça yazın: `a.copy()`, `list(a)` ya da `a[:]`. İç içe verilerde bu yeterli değildir; iç listeler yine ortak kalır, `copy.deepcopy(a)` gerekir.

```
import copy
a = [[1, 2], [3]]
b = a.copy()
b[0].append(99)
print(a)                 # [[1, 2, 99], [3]] — iç liste ortak
c = copy.deepcopy(a)     # tamamen bağımsız kopya
```

## Demetler: değiştirilemeyen liste

Demet (`tuple`) listeye benzer, ama oluşturulduktan sonra değiştirilemez. Bu, okuyana açık bir işarettir: karşınızda sabit alanları olan tek bir kayıt vardır, büyüyen bir koleksiyon değil. Demetler kolayca açılır; fonksiyonların birden fazla değer döndürmesi de genellikle demetle olur.

```
expense = (250, "Kahve")
amount, item = expense
expense[0] = 300
# TypeError: 'tuple' object does not support item assignment
```

Değiştirilemeyen değerlerden oluşan bir demet özetlenebilir (hashable), bu yüzden sözlüğe anahtar olarak konabilir. Tek elemanlı bir demet virgülle yazılır: `(5,)`.

## Kümeler: yalnızca benzersiz değerler

Küme (`set`) yalnızca benzersiz değerleri tutar ve sırayı hatırlamaz. Tekrarları temizlemenin ve "bu eleman var mı" diye sormanın en hızlı yoludur; ayrıca kesişim, birleşim ve fark işlemlerini de yapar.

```
jan = {"Yiyecek", "Taksi", "Sinema"}
feb = {"Yiyecek", "Abonelikler"}
print(jan & feb)    # {'Yiyecek'}
print(feb - jan)    # {'Abonelikler'}
unique = list(dict.fromkeys([3, 1, 3, 2]))   # [3, 1, 2] — tekrarsız, sıra korunmuş
empty = set()       # {} boş bir dict'tir!
```

## Hangi koleksiyonu seçmeli

| Görev | Koleksiyon |
| --- | --- |

| Sıra ve değişiklik | `list` |

| Sabit kayıt | `tuple` |

| Anahtarla arama | `dict` |

| Benzersizlik, "var mı" kontrolü | `set` |

| Değiştirilemeyen ayarlar | `frozendict` (Python 3.15) |

`x in list` kontrolü elemanları sırayla gezer; `x in set` ise neredeyse anında çalışır. Bir döngüde büyük bir listede defalarca arama yapıyorsanız, listeyi kümeye çevirin.

## Özet

Python listesi sıralı ve değiştirilebilir bir koleksiyondur: `append` ve `extend` ekler, `pop` ve `remove` siler, `a[başlangıç:bitiş:adım]` dilimleri alır, `sort` yerinde sıralayıp `None` döndürür, `sorted` ise yeni bir liste verir. Kopyayı açıkça oluşturun; sabit kayıtlar için demet, benzersiz değerler için küme kullanın. Listeler, demetler, sözlükler ve kümeler, "Python 3.15: sıfırdan uzmanlığa" kursunda uygulamalı olarak işlenir.

## FAQ

**Python'da liste ile dizi (array) arasındaki fark nedir?**

Python'da diğer dillerdeki gibi yerleşik bir dizi yoktur; bunun yerini farklı türde değerler tutabilen liste alır. Sayısal ve sıkı tipli diziler için array modülü ya da NumPy kullanılır.

**Listede bir elemanın indeksini nasıl bulurum?**

a.index(x) metodu ilk geçtiği indeksi döndürür; eleman yoksa ValueError verir. Bu yüzden çağırmadan önce x in a ile kontrol edin.

**Listeden tekrarları sırayı bozmadan nasıl silerim?**

list(dict.fromkeys(a)) kullanın: sözlük anahtarları benzersiz tutar ve ekleme sırasını korur. list(set(a)) de tekrarları siler, ama sırayı korumaz.

**Bir liste elemanlarını tek stringe nasıl birleştiririm?**

String metodu join ile: ", ".join(["a", "b", "c"]) sonucu "a, b, c" olur. Tüm elemanlar string olmalıdır; sayıları önce map(str, a) ile çevirin.

**Bir listede farklı türde elemanlar tutabilir miyim?**

Evet; bir liste aynı anda sayı, string, başka listeler ve farklı nesneler içerebilir. Ancak key parametresi olmadan böyle bir listeyi sıralamak genellikle mümkün değildir: sayı ile stringin karşılaştırılması TypeError verir.


---
Source: Skillaria.Top (https://skillaria.top)