Python programlama dilinde, birden fazla öğeyi tek bir değişken altında toplamak ve yönetmek için çeşitli veri yapıları bulunur. Bu yapıların en temel, en çok yönlü ve en sık kullanılanlarından biri şüphesiz listelerdir (Lists). Listeler, farklı türdeki verileri sıralı bir şekilde saklamamıza, bu verilere kolayca erişmemize ve programın çalışması sırasında bu veri koleksiyonunu dinamik olarak değiştirmemize olanak tanır.

Bu kapsamlı rehberde, Python listelerinin ne olduğunu, temel özelliklerini, nasıl oluşturulup kullanıldığını detaylı bir şekilde inceleyeceğiz. Listeler üzerinde işlem yapmamızı sağlayan güçlü liste metotlarını tek tek ele alacak, her birinin ne işe yaradığını, nasıl kullanıldığını ve hangi durumlarda tercih edilmesi gerektiğini örneklerle açıklayacağız. Listeleri anlamak ve etkin kullanmak, Python’da veri işleme ve algoritma geliştirme becerilerinizin temelini oluşturacaktır.

Bölüm 1: Liste Nedir ve Temel Özellikleri
Python’da bir liste, köşeli parantezler [] içine alınan ve virgülle ayrılmış, sıralı bir öğeler koleksiyonudur. Listelerin temel özellikleri şunlardır:

Sıralıdır (Ordered): Listeye eklenen öğelerin belirli bir sırası vardır ve bu sıra korunur. Her öğeye, 0'dan başlayan konumu (indeksi) kullanılarak erişilebilir. Bu sıra, siz listeyi değiştirmediğiniz sürece sabit kalır.
liste1 = [10, 20, 30] liste2 = [30, 10, 20] print(liste1 == liste2) # False (Öğeler aynı olsa da sıraları farklı)
Değiştirilebilirdir (Mutable): Listeler oluşturulduktan sonra içerikleri değiştirilebilir. Mevcut öğeleri güncelleyebilir, yeni öğeler ekleyebilir veya var olan öğeleri silebilirsiniz. Bu, listelerin en önemli ve onları tuple’lardan ayıran temel özelliğidir.
sayilar = [1, 2, 3] print(f"Başlangıç: {sayilar}") sayilar[0] = 99 # İlk öğeyi değiştir sayilar.append(4) # Sonuna öğe ekle print(f"Değişim sonrası: {sayilar}") # Çıktı: Değişim sonrası: [99, 2, 3, 4]
Farklı Veri Tiplerini İçerebilir (Heterogeneous): Bir liste, içinde tam sayılar (int), ondalıklı sayılar (float), metinler (str), boolean değerler (bool) ve hatta başka listeler veya diğer veri yapıları gibi farklı türden öğeleri bir arada barındırabilir.
karma_liste = [1, "Merhaba", 3.14, True, [10, 20], {"anahtar": "değer"}] print(f"Karma Liste: {karma_liste}")
Dinamiktir (Dynamic): Listelerin boyutu sabit değildir. Programın çalışması sırasında ihtiyaç duyuldukça öğe eklenerek büyüyebilir veya öğe silinerek küçülebilirler.
Yinelenen Öğelere İzin Verir (Allows Duplicates): Aynı değere sahip birden fazla öğe bir listede bulunabilir.
tekrarli_liste = [1, 2, 2, 3, 1, 4, 2] print(f"Tekrarlı Liste: {tekrarli_liste}")
Bölüm 2: Liste Oluşturma
Python’da liste oluşturmanın birkaç yolu vardır:

2.1. Köşeli Parantez Kullanarak ([])
En yaygın yöntem, öğeleri köşeli parantezler içine virgülle ayırarak yazmaktır.

Boş liste oluşturma

bos_liste = []
print(f"Boş Liste: {bos_liste}, Tipi: {type(bos_liste)}")

Öğelerle dolu liste oluşturma

rakamlar = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
isimler = ["Ali", "Veli", "Ayşe"]
karisik = [10, "Elma", 3.5]
print(f"Rakamlar: {rakamlar}")
print(f"İsimler: {isimler}")
print(f"Karışık: {karisik}")
2.2. list() Yapıcı Fonksiyonu (Constructor) Kullanarak
list() fonksiyonu, başka bir yinelenebilir (iterable) nesneyi (örneğin tuple, string, set, range veya başka bir liste) argüman olarak alıp yeni bir liste oluşturmak için kullanılabilir. Argüman verilmezse boş bir liste oluşturur.

Boş liste oluşturma

bos_liste_2 = list()
print(f"Boş Liste (list() ile): {bos_liste_2}")

String'den liste oluşturma (her karakter bir öğe olur)

harfler = list("Python")
print(f"String'den Liste: {harfler}") # Çıktı: ['P', 'y', 't', 'h', 'o', 'n']

Tuple'dan liste oluşturma

sayi_tuple = (10, 20, 30)
sayi_listesi = list(sayi_tuple)
print(f"Tuple'dan Liste: {sayi_listesi}") # Çıktı: [10, 20, 30]
sayi_listesi.append(40) # Artık değiştirilebilir
print(f"Değiştirilmiş Liste: {sayi_listesi}") # Çıktı: [10, 20, 30, 40]

range() objesinden liste oluşturma

beserli_sayilar = list(range(0, 21, 5)) # 0'dan 20'ye kadar 5'er artan sayılar
print(f"Range'den Liste: {beserli_sayilar}") # Çıktı: [0, 5, 10, 15, 20]
2.3. Liste Üreteçleri (List Comprehensions)
List Comprehensions, mevcut bir yinelenebilir nesneden yeni listeler oluşturmanın kısa, okunaklı ve verimli bir yoludur. Genellikle for döngüsü ve isteğe bağlı olarak if koşulu içeren tek satırlık ifadelerdir.

Sözdizimi: [ifade for öğe in yinelenebilir if koşul]

0'dan 9'a kadar sayıların karelerini içeren liste oluşturma

kareler = [x**2 for x in range(10)]
print(f"Kareler (List Comp): {kareler}") # Çıktı: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

0'dan 9'a kadar çift sayıların kareleri

cift_kareler = [x**2 for x in range(10) if x % 2 == 0]
print(f"Çift Kareler (List Comp): {cift_kareler}") # Çıktı: [0, 4, 16, 36, 64]

Bir listedeki isimleri büyük harfe çevirme

isimler = ["ali", "ayşe", "mehmet"]
buyuk_isimler = [isim.upper() for isim in isimler]
print(f"Büyük İsimler (List Comp): {buyuk_isimler}") # Çıktı: ['ALI', 'AYŞE', 'MEHMET']
List comprehensions, aynı işi yapan geleneksel for döngülerine göre genellikle daha hızlı ve daha “Pythonic” (Python’a özgü ve şık) kabul edilir.

Bölüm 3: Liste Öğelerine Erişim
Listeler sıralı olduğu için, içindeki öğelere konumlarını (indekslerini) kullanarak erişebiliriz.

3.1. İndeksleme (Indexing)
Tek bir öğeye erişmek için öğenin indeks numarası köşeli parantezler içinde belirtilir.

Pozitif İndeksleme: İlk öğenin indeksi 0'dır, ikinci öğenin 1'dir ve bu şekilde devam eder. Son öğenin indeksi len(liste) - 1'dir.
Negatif İndeksleme: Son öğeye -1 indeksi ile, sondan ikinci öğeye -2 indeksi ile erişilebilir ve bu şekilde geriye doğru devam eder. İlk öğenin negatif indeksi -len(liste)'dir.
Geçersiz bir indeks (listenin sınırları dışında) kullanılmaya çalışılırsa IndexError hatası alınır.

renkler = ["kırmızı", "mavi", "yeşil", "sarı", "mor"]

0 1 2 3 4

-5 -4 -3 -2 -1

Pozitif İndeksleme

print(f"İlk renk (indeks 0): {renkler[0]}") # kırmızı
print(f"Üçüncü renk (indeks 2): {renkler[2]}") # yeşil

Negatif İndeksleme

print(f"Son renk (indeks -1): {renkler[-1]}") # mor
print(f"Sondan ikinci renk (indeks -2): {renkler[-2]}") # sarı

Hatalı indeks denemesi

print(renkler[5]) # IndexError: list index out of range

print(renkler[-6]) # IndexError: list index out of range

3.2. Dilimleme (Slicing)
Listenin belirli bir bölümünü (alt liste) almak için dilimleme kullanılır. Dilimleme, yeni bir liste oluşturur (orijinal listeyi değiştirmez).

Temel Sözdizimi: liste[başlangıç:bitiş:adım]

başlangıç: Dilimin başlayacağı indeks (bu indeks dahil). Belirtilmezse listenin başından (indeks 0) başlar.
bitiş: Dilimin biteceği indeks (bu indeks dahil değil!). Belirtilmezse listenin sonuna kadar gider.
adım: Atlama miktarı (varsayılan olarak 1'dir). Pozitif veya negatif olabilir.
sayilar = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

0 1 2 3 4 5 6 7 8 9

Basit Dilimlemeler

print(f"İndeks 2'den 5'e kadar (5 dahil değil): {sayilar[2:5]}") # [12, 13, 14]
print(f"Baştan indeks 4'e kadar: {sayilar[:4]}") # [10, 11, 12, 13]
print(f"İndeks 6'dan sona kadar: {sayilar[6:]}") # [16, 17, 18, 19]
print(f"Tüm listenin kopyası: {sayilar[:]}") # [10, 11, ..., 19]

Negatif İndekslerle Dilimleme

print(f"Son 3 eleman: {sayilar[-3:]}") # [17, 18, 19]
print(f"Baştan sondan 2. elemana kadar: {sayilar[:-2]}") # [10, 11, ..., 17]
print(f"İndeks -5'ten -2'ye kadar: {sayilar[-5:-2]}") # [15, 16, 17]

Adım Kullanımı

print(f"Baştan sona 2'şer atlayarak: {sayilar[::2]}") # 10, 12, 14, 16, 18
print(f"İndeks 1'den 8'e 3'er atlayarak: {sayilar[1:8:3]}") # [11, 14, 17]

Listeyi Ters Çevirme (adım -1)

print(f"Listenin tersi: {sayilar[::-1]}") # [19, 18, ..., 11, 10]

Dilimleme yeni liste oluşturur

alt_liste = sayilar[2:5]
print(f"Alt Liste: {alt_liste}")
alt_liste[0] = 999 # Alt listeyi değiştirmek orijinali etkilemez
print(f"Değişen Alt Liste: {alt_liste}")
print(f"Orijinal Liste (değişmedi): {sayilar}")
Bölüm 4: Listeleri Değiştirme (Mutability)
Listelerin değiştirilebilir (mutable) olması, programlama sırasında büyük esneklik sağlar.

4.1. Tek Öğeyi Değiştirme
Belirli bir indeksteki öğeyi yeni bir değerle değiştirmek için indeksleme ve atama operatörü (=) kullanılır.

meyveler = ["elma", "armut", "muz"]
print(f"Önce: {meyveler}")
meyveler[1] = "çilek" # 1. indeksteki "armut" yerine "çilek" ata
print(f"Sonra: {meyveler}") # Çıktı: ['elma', 'çilek', 'muz']
4.2. Birden Fazla Öğeyi Değiştirme (Dilim Ataması)
Bir dilime yeni bir yinelenebilir (liste, tuple, string vb.) atayarak listenin o bölümünü değiştirebiliriz. Atanan yinelenebilirin uzunluğu, değiştirilen dilimin uzunluğuyla aynı olmak zorunda değildir; bu, listeye öğe eklemeye veya listeden öğe silmeye olanak tanır.

harfler = ['a', 'b', 'c', 'd', 'e', 'f']
print(f"Başlangıç: {harfler}")

İndeks 1 ve 2'yi ('b', 'c') değiştirme

harfler[1:3] = ['X', 'Y']
print(f"Değişim 1: {harfler}") # ['a', 'X', 'Y', 'd', 'e', 'f']

İndeks 3'ten 5'e kadar ('d', 'e') olanları tek elemanla değiştirme (silme gibi)

harfler[3:5] = ['Z']
print(f"Değişim 2: {harfler}") # ['a', 'X', 'Y', 'Z', 'f']

Belirli bir aralığa daha fazla eleman ekleme

harfler[1:1] = ['K', 'L'] # 1. indekse 'K' ve 'L' ekle ('X' öne kayar)
print(f"Değişim 3: {harfler}") # ['a', 'K', 'L', 'X', 'Y', 'Z', 'f']

Listenin sonunu değiştirme/ekleme

harfler[len(harfler):] = ['G', 'H'] # Listenin sonuna ekle (extend gibi)
print(f"Değişim 4: {harfler}") # ['a', 'K', 'L', 'X', 'Y', 'Z', 'f', 'G', 'H']

Bir dilimi boş liste ile değiştirerek silme

harfler[1:3] = [] # 'K' ve 'L' silinir
print(f"Değişim 5: {harfler}") # ['a', 'X', 'Y', 'Z', 'f', 'G', 'H']
4.3. Öğeleri Silme (del İfadesi)
del ifadesi, belirli bir indeksteki öğeyi veya bir dilimi listeden tamamen kaldırmak için kullanılır.

rakamlar = list(range(10)) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(f"Başlangıç: {rakamlar}")

Tek öğeyi silme (indeks 3'teki '3')

del rakamlar[3]
print(f"3. indeks silindi: {rakamlar}") # [0, 1, 2, 4, 5, 6, 7, 8, 9]

Bir dilimi silme (indeks 5'ten 7'ye kadar - '6' ve '7')

del rakamlar[5:7]
print(f"5-7 arası silindi: {rakamlar}") # [0, 1, 2, 4, 5, 8, 9]

Tüm listeyi silme (değişkeni tamamen kaldırır)

del rakamlar

print(rakamlar) # NameError: name 'rakamlar' is not defined

Bölüm 5: Liste Metotları
Python listeleri, üzerlerinde çeşitli işlemler yapmak için kullanabileceğimiz birçok yerleşik metoda sahiptir. Metotlar, bir nesneyle ilişkili fonksiyonlardır ve genellikle nesne.metot_adı(argümanlar) şeklinde çağrılırlar.

Önemli Not: Yerinde Değişiklik (In-place) vs. Yeni Nesne Döndürme
Liste metotlarını öğrenirken dikkat edilmesi gereken en önemli noktalardan biri, metodun listeyi yerinde (in-place) mi değiştirdiği yoksa yeni bir liste (veya başka bir değer) mi döndürdüğüdür. Yerinde değişiklik yapan metotlar (örneğin append, sort, reverse) genellikle None döndürürler. Bu nedenle, yeni_liste = eski_liste.append(5) gibi bir atama yapmak genellikle yanlıştır, çünkü yeni_liste None olur.

Aşağıda en sık kullanılan liste metotları detaylı olarak açıklanmıştır:

5.1. append(item)
Ne Yapar: Verilen item (öğeyi) listenin sonuna ekler.
Değişiklik: Listeyi yerinde (in-place) değiştirir.
Dönüş Değeri: None
hayvanlar = ["kedi", "köpek"]
print(f"Başlangıç: {hayvanlar}")
donus = hayvanlar.append("kuş")
print(f"Append sonrası: {hayvanlar}") # ['kedi', 'köpek', 'kuş']
print(f"Append dönüş değeri: {donus}") # None
hayvanlar.append(["balık", "hamster"]) # Liste de eklenebilir (tek bir öğe olarak)
print(f"Liste eklenince: {hayvanlar}") # ['kedi', 'köpek', 'kuş', ['balık', 'hamster']]
5.2. extend(iterable)
Ne Yapar: Verilen iterable (liste, tuple, string gibi yinelenebilir bir nesne) içindeki tüm öğeleri mevcut listenin sonuna ekler. append'den farkı, tek bir öğe olarak değil, öğeleri ayrı ayrı eklemesidir.
Değişiklik: Listeyi yerinde (in-place) değiştirir.
Dönüş Değeri: None
liste1 = [1, 2, 3]
liste2 = [4, 5, 6]
tuple1 = (7, 8)
metin1 = "abc"
print(f"Başlangıç liste1: {liste1}")
liste1.extend(liste2)
print(f"liste2 ile extend sonrası: {liste1}") # [1, 2, 3, 4, 5, 6]
liste1.extend(tuple1)
print(f"tuple1 ile extend sonrası: {liste1}") # [1, 2, 3, 4, 5, 6, 7, 8]
liste1.extend(metin1)
print(f"metin1 ile extend sonrası: {liste1}") # [1, 2, 3, 4, 5, 6, 7, 8, 'a', 'b', 'c']

'+' operatörü de benzer işi yapar ama YENİ bir liste oluşturur:

liste_a = [1, 1]
liste_b = [2, 2]
yeni_liste = liste_a + liste_b
print(f"Yeni Liste (+ ile): {yeni_liste}") # [1, 1, 2, 2]
print(f"Orijinal liste_a (+ sonrası): {liste_a}") # 1, 1
5.3. insert(index, item)
Ne Yapar: Verilen item'ı (öğeyi) belirtilen index konumuna ekler. O indekste ve sonrasında bulunan diğer tüm öğeler bir pozisyon sağa kaydırılır.
Değişiklik: Listeyi yerinde (in-place) değiştirir.
Dönüş Değeri: None
harfler = ['a', 'c', 'd']
print(f"Başlangıç: {harfler}")

İndeks 1'e 'b' ekle

harfler.insert(1, 'b')
print(f"1. indekse insert sonrası: {harfler}") # ['a', 'b', 'c', 'd']

Listenin başına ekle (indeks 0)

harfler.insert(0, 'X')
print(f"Başa insert sonrası: {harfler}") # ['X', 'a', 'b', 'c', 'd']

Listenin sonuna ekle (len(liste) indeksi kullanılırsa append gibi davranır)

harfler.insert(len(harfler), 'Z')
print(f"Sona insert sonrası: {harfler}") # ['X', 'a', 'b', 'c', 'd', 'Z']
5.4. remove(item)
Ne Yapar: Listede belirtilen item değerine sahip ilk öğeyi bulur ve siler. Eğer aynı değere sahip birden fazla öğe varsa, sadece baştan ilk bulunan silinir.
Değişiklik: Listeyi yerinde (in-place) değiştirir.
Dönüş Değeri: None
Hata: Eğer belirtilen item listede bulunamazsa ValueError hatası verir.
liste = ['elma', 'armut', 'kiraz', 'armut', 'muz']
print(f"Başlangıç: {liste}")
liste.remove('armut') # İlk bulunan 'armut' silinir
print(f"Remove('armut') sonrası: {liste}") # ['elma', 'kiraz', 'armut', 'muz']
liste.remove('armut') # Kalan 'armut' silinir
print(f"İkinci Remove('armut') sonrası: {liste}") # ['elma', 'kiraz', 'muz']

Olmayan bir öğeyi silmeye çalışmak:

try:
liste.remove('şeftali')
except ValueError as e:
print(f"Hata: {e}") # Hata: list.remove(x): x not in list
5.5. pop(index=-1)
Ne Yapar: Belirtilen index konumundaki öğeyi listeden siler ve o öğeyi döndürür. Eğer index belirtilmezse, varsayılan olarak listenin sonundaki öğeyi (-1 indeksi) siler ve döndürür.
Değişiklik: Listeyi yerinde (in-place) değiştirir.
Dönüş Değeri: Silinen öğe.
Hata: Eğer liste boşsa veya geçersiz bir index verilirse IndexError hatası verir.
sayilar = [10, 20, 30, 40, 50]
print(f"Başlangıç: {sayilar}")

Son elemanı sil ve al (varsayılan index=-1)

son_eleman = sayilar.pop()
print(f"Pop() sonrası liste: {sayilar}") # [10, 20, 30, 40]
print(f"Pop() ile dönen değer: {son_eleman}") # 50

İndeks 1'deki elemanı sil ve al

ikinci_eleman = sayilar.pop(1)
print(f"Pop(1) sonrası liste: {sayilar}") # [10, 30, 40]
print(f"Pop(1) ile dönen değer: {ikinci_eleman}") # 20

Boş listeye pop uygulamak:

bos = []
try:
bos.pop()
except IndexError as e:
print(f"Boş liste hatası: {e}") # Boş liste hatası: pop from empty list
pop() metodu, özellikle yığın (stack - LIFO: Last-In, First-Out) veya kuyruk (queue - FIFO: First-In, First-Out, pop(0) ile) gibi veri yapılarını simüle etmek için kullanışlıdır.

5.6. clear()
Ne Yapar: Listenin tüm öğelerini siler, listeyi boşaltır.
Değişiklik: Listeyi yerinde (in-place) değiştirir.
Dönüş Değeri: None
liste = [1, 'iki', 3.0]
print(f"Başlangıç: {liste}")
liste.clear()
print(f"Clear sonrası: {liste}") # []
del liste[:] ifadesi de aynı işlevi görür.

5.7. index(item, start=0, end=len(liste))
Ne Yapar: Listede belirtilen item değerine sahip ilk öğenin indeksini döndürür.
Değişiklik: Listeyi değiştirmez.
Dönüş Değeri: Bulunan ilk öğenin indeksi (int).
Hata: Eğer belirtilen item listede bulunamazsa ValueError hatası verir.
İsteğe Bağlı Argümanlar: Aramanın başlayacağı start indeksi ve biteceği (dahil olmayan) end indeksi belirtilebilir. Bu, listenin sadece belirli bir bölümünde arama yapmayı sağlar.
liste = ['a', 'b', 'c', 'a', 'd', 'a']
print(f"Liste: {liste}")

'a'nın ilk bulunduğu indeks

ilk_a_indeks = liste.index('a')
print(f"'a'nın ilk indeksi: {ilk_a_indeks}") # 0

İndeks 1'den başlayarak 'a'yı ara

ikinci_a_indeks = liste.index('a', 1) # 1. indeksten sonraki ilk 'a'
print(f"1. indeksten sonraki 'a'nın indeksi: {ikinci_a_indeks}") # 3

İndeks 4'ten başlayarak 'a'yı ara

ucuncu_a_indeks = liste.index('a', 4)
print(f"4. indeksten sonraki 'a'nın indeksi: {ucuncu_a_indeks}") # 5

İndeks 1 ile 3 arasında 'c'yi ara

c_indeks = liste.index('c', 1, 4) # 1 dahil, 4 dahil değil
print(f"1-4 arası 'c'nin indeksi: {c_indeks}") # 2

Olmayan bir öğeyi aramak:

try:
z_indeks = liste.index('z')
except ValueError as e:
print(f"Hata: {e}") # Hata: 'z' is not in list
5.8. count(item)
Ne Yapar: Listede belirtilen item değerinden kaç tane olduğunu sayar.
Değişiklik: Listeyi değiştirmez.
Dönüş Değeri: Öğenin listedeki tekrar sayısı (int). Eğer öğe listede yoksa 0 döndürür.
liste = [1, 2, 5, 2, 4, 2, 5, 1, 2]
print(f"Liste: {liste}")
count_2 = liste.count(2)
print(f"2'nin sayısı: {count_2}") # 4
count_5 = liste.count(5)
print(f"5'in sayısı: {count_5}") # 2
count_9 = liste.count(9) # Listede olmayan bir öğe
print(f"9'un sayısı: {count_9}") # 0
5.9. sort(*, key=None, reverse=False)
Ne Yapar: Listenin öğelerini yerinde (in-place) sıralar. Varsayılan olarak küçükten büyüğe (sayılar için) veya alfabetik olarak (string’ler için) sıralar.
Değişiklik: Listeyi yerinde (in-place) değiştirir.
Dönüş Değeri: None
Önemli Notlar: * sort() sadece karşılaştırılabilir öğeler içeren listelerde çalışır. Farklı tiplerde (örn: int ve str) karşılaştırılamayan öğeler içeren bir listeyi sıralamaya çalışmak TypeError hatası verir. * key argümanı: Sıralama yapmadan önce her öğeye uygulanacak tek argümanlı bir fonksiyon (genellikle lambda fonksiyonu) alır. Sıralama, bu fonksiyonun döndürdüğü değerlere göre yapılır. Örneğin, string listesini uzunluklarına göre sıralamak için key=len kullanılabilir. * reverse argümanı: True olarak ayarlanırsa, liste ters sırada (büyükten küçüğe veya ters alfabetik) sıralanır. Varsayılan değeri False'tur.

Sayısal Sıralama

sayilar = [5, 1, 4, 2, 8, 3]
print(f"Sayılar (orijinal): {sayilar}")
sayilar.sort()
print(f"Sayılar (sıralı): {sayilar}") # [1, 2, 3, 4, 5, 8]

Ters Sıralama

sayilar.sort(reverse=True)
print(f"Sayılar (ters sıralı): {sayilar}") # [8, 5, 4, 3, 2, 1]

String Sıralama (alfabetik)

isimler = ["Can", "Ali", "Zeynep", "Bora"]
print(f"\nİsimler (orijinal): {isimler}")
isimler.sort()
print(f"İsimler (sıralı): {isimler}") # ['Ali', 'Bora', 'Can', 'Zeynep']

Büyük/Küçük Harf Duyarlılığı

isimler_karma = ["can", "Ali", "Zeynep", "bora"]
isimler_karma.sort() # Büyük harfler küçük harflerden önce gelir (ASCII)
print(f"İsimler Karma (sıralı): {isimler_karma}") # ['Ali', 'Zeynep', 'bora', 'can']

Harf büyüklüğünü önemsemeden sıralama (key ile)

isimler_karma.sort(key=str.lower) # Sıralamadan önce her ismi küçük harfe çevir
print(f"İsimler Karma (key=str.lower ile sıralı): {isimler_karma}") # ['Ali', 'bora', 'can', 'Zeynep']

Uzunluğa göre sıralama (key ile)

isimler = ["Can", "Ali", "Zeynep", "Bora"]
isimler.sort(key=len) # Öğelerin uzunluğuna göre sırala
print(f"İsimler (uzunluğa göre sıralı): {isimler}") # ['Ali', 'Can', 'Bora', 'Zeynep']

Farklı tipleri sıralama hatası

karma = [3, "elma", 1]

karma.sort() # TypeError: '<' not supported between 'str' and 'int'

Orijinal listeyi değiştirmeden sıralanmış yeni bir liste elde etmek isterseniz, sorted(liste, key=..., reverse=...) yerleşik fonksiyonunu kullanın. sorted() fonksiyonu orijinal listeyi değiştirmez.

orijinal = [5, 1, 4]
sirali_yeni = sorted(orijinal)
print(f"Orijinal (sorted sonrası): {orijinal}") # 5, 1, 4
print(f"Sıralı Yeni Liste: {sirali_yeni}") # [1, 4, 5]
5.10. reverse()
Ne Yapar: Listenin öğelerinin sırasını yerinde (in-place) tersine çevirir. (İlk öğe sona, son öğe başa gelir vb.)
Değişiklik: Listeyi yerinde (in-place) değiştirir.
Dönüş Değeri: None
liste = [1, 2, 3, 4, 5]
print(f"Başlangıç: {liste}")
liste.reverse()
print(f"Reverse sonrası: {liste}") # [5, 4, 3, 2, 1]
Listeyi ters çevirmenin diğer yolları dilimleme (liste[::-1] - yeni liste oluşturur) veya reversed(liste) fonksiyonunu (bir iterator döndürür, list(reversed(liste)) ile listeye çevrilebilir) kullanmaktır.

5.11. copy()
Ne Yapar: Listenin sığ bir kopyasını (shallow copy) oluşturur ve döndürür.
Değişiklik: Orijinal listeyi değiştirmez.
Dönüş Değeri: Orijinal listenin sığ kopyası olan yeni bir liste.
Sığ Kopya (Shallow Copy) Ne Demek? Yeni bir liste nesnesi oluşturulur, ancak bu yeni liste orijinal listedeki öğelere referans içerir. Eğer öğeler sayılar veya stringler gibi değiştirilemez (immutable) ise sorun yoktur. Ancak, eğer öğeler listeler gibi değiştirilebilir (mutable) nesneler ise, kopyadaki referans üzerinden iç içe geçmiş listeyi değiştirmek, orijinal listedeki iç içe geçmiş listeyi de etkiler.

orijinal_liste = [1, 2, [10, 20]]
print(f"Orijinal Liste: {orijinal_liste}")

Sığ Kopya Oluşturma Yöntemleri

kopya1 = orijinal_liste.copy()
kopya2 = orijinal_liste[:] # Dilimleme de sığ kopya yapar
kopya3 = list(orijinal_liste) # list() yapıcısı da sığ kopya yapar

Kopya ve Orijinal farklı nesnelerdir:

print(f"Orijinal ID: {id(orijinal_liste)}")
print(f"Kopya1 ID: {id(kopya1)}")
print(f"Orijinal is Kopya1? {orijinal_liste is kopya1}") # False

Kopyadaki değiştirilemez öğeyi (1. indeks) değiştirelim:

kopya1[1] = 99
print(f"\nKopya1 (değişti): {kopya1}") # [1, 99, [10, 20]]
print(f"Orijinal (etkilenmedi): {orijinal_liste}") # [1, 2, [10, 20]]

Kopyadaki değiştirilebilir (iç içe liste) öğeyi değiştirelim:

kopya1[2].append(30)
print(f"\nKopya1 (iç liste değişti): {kopya1}") # [1, 99, [10, 20, 30]]
print(f"Orijinal (ETKİLENDİ!): {orijinal_liste}") # [1, 2, [10, 20, 30]] -> İç liste aynı nesne!
print(f"Orijinal iç liste ID: {id(orijinal_liste[2])}")
print(f"Kopya1 iç liste ID: {id(kopya1[2])}") # ID'ler aynı!
İç içe geçmiş listeler dahil olmak üzere tamamen bağımsız bir kopya oluşturmak istiyorsanız (derin kopya — deep copy), copy modülünün deepcopy() fonksiyonunu kullanmanız gerekir:

import copy
orijinal_liste_2 = [1, [100, 200]]
derin_kopya = copy.deepcopy(orijinal_liste_2)
print(f"\nOrijinal 2: {orijinal_liste_2}")
print(f"Derin Kopya: {derin_kopya}")

Derin kopyadaki iç listeyi değiştirelim

derin_kopya[1].append(300)
print(f"\nDerin Kopya (iç liste değişti): {derin_kopya}") # [1, [100, 200, 300]]
print(f"Orijinal 2 (ETKİLENMEDİ): {orijinal_liste_2}") # [1, [100, 200]]
print(f"Orijinal 2 iç liste ID: {id(orijinal_liste_2[1])}")
print(f"Derin Kopya iç liste ID: {id(derin_kopya[1])}") # ID'ler farklı!
Bölüm 6: Diğer Liste İşlemleri
Metotların yanı sıra listelerle sık kullanılan bazı operatörler ve fonksiyonlar da vardır:

Birleştirme (Concatenation) +: İki listeyi birleştirerek yeni bir liste oluşturur.
Tekrarlama (Repetition) *: Bir listeyi belirtilen sayıda tekrarlayarak yeni bir liste oluşturur.
Üyelik Testi (Membership) in / not in: Bir öğenin listede olup olmadığını kontrol eder (True/False döndürür).
Uzunluk (Length) len(): Listenin öğe sayısını döndürür.
Minimum/Maksimum min() / max(): Listedeki en küçük veya en büyük öğeyi döndürür (öğeler karşılaştırılabilir olmalıdır).
Toplam sum(): Listedeki tüm sayısal öğelerin toplamını döndürür (öğeler sayısal olmalıdır).
Döngü ile Gezinme (Iteration): for döngüsü ile listenin her bir öğesi üzerinde işlem yapılabilir.
liste_x = [1, 2, 3]
liste_y = [4, 5, 6]

Birleştirme

birlesik = liste_x + liste_y
print(f"Birleşik Liste: {birlesik}") # [1, 2, 3, 4, 5, 6]

Tekrarlama

tekrarlı = liste_x * 3
print(f"Tekrarlı Liste: {tekrarlı}") # [1, 2, 3, 1, 2, 3, 1, 2, 3]

Üyelik

print(f"3 listede var mı? {3 in liste_x}") # True
print(f"7 listede yok mu? {7 not in liste_y}") # True

Uzunluk

print(f"Birleşik listenin uzunluğu: {len(birlesik)}") # 6

Min/Max/Sum

sayilar = [10, 5, 25, 15, 20]
print(f"En küçük: {min(sayilar)}") # 5
print(f"En büyük: {max(sayilar)}") # 25
print(f"Toplam: {sum(sayilar)}") # 75

Döngü ile Gezinme

print("\nListe Elemanları:")
for eleman in sayilar:
print(f"- {eleman}")
Sonuç
Python listeleri, programlamada veri koleksiyonlarını yönetmek için temel ve son derece güçlü bir araçtır. Sıralı, değiştirilebilir (mutable) ve heterojen yapıları sayesinde çok çeşitli görevler için uygundurlar. Öğelere indeksleme ve dilimleme ile kolayca erişebilir, listeyi append, extend, insert, remove, pop gibi metotlarla dinamik olarak değiştirebiliriz. sort, reverse, count, index gibi metotlar ise listeler üzerinde sorgulama ve düzenleme yapmamızı sağlar.

Listelerin nasıl çalıştığını, metotlarının ne işe yaradığını (özellikle yerinde değişiklik yapıp yapmadıklarını) ve sığ/derin kopya gibi kavramları anlamak, Python’da verimli ve hatasız kod yazmak için kritik öneme sahiptir. List comprehensions gibi daha gelişmiş teknikler ise listelerle çalışmayı daha da pratik ve “Pythonic” hale getirir.

Esneklikleri ve zengin metot setleri sayesinde listeler, Python’da veri manipülasyonu, algoritma uygulamaları ve genel programlamada en sık başvuracağınız veri yapılarından biri olmaya devam edecektir.

Abdulkadir Güngör - Kişisel WebSite
Abdulkadir Güngör - Kişisel WebSite
Abdulkadir Güngör - Özgeçmiş
Github
Github
Linkedin