Ne Aramıştınız?
Makaleler, projeler ve kaynaklar arasında arama yaparak size özel fikirler, bilgiler ve ilham kaynakları keşfedin.
Takip et
Ne Aramıştınız?
Makaleler, projeler ve kaynaklar arasında arama yaparak size özel fikirler, bilgiler ve ilham kaynakları keşfedin.
Takip et
Kategoriler
Son Yazılar

Python Listeleri (5): Kapsamlı Bir Rehber

Python’daki listeler, programlama dünyasının temel taşlarından biridir ve verileri düzenlemenin, saklamanın ve üzerinde işlem yapmanın en esnek yollarını sunar. Bu kapsamlı rehberde, listelerin derinliklerine inecek, temelden ileri düzeye tüm kullanımlarını keşfedecek, gerçek dünya senaryolarıyla pekiştirecek ve bu güçlü veri yapısını ustalıkla kullanmak için gereken tüm bilgiyi edineceksiniz. Hazırsanız, Python listelerinin büyüleyici dünyasına adım atalım!

Python, veri yönetimi için birçok farklı yapı sunsa da, listeler bu yapıların en sık kullanılan ve en esnek olanlarından biridir. Peki, listeleri bu kadar vazgeçilmez kılan nedir ve programlama yolculuğunuzda neden bu kadar merkezi bir rol oynarlar? Öncelikle, bir listenin ne olduğunu tanımlayarak başlayalım. Python’da liste, elemanların sıralı bir koleksiyonudur. Diğer dillerdeki dizilere (array) benzerler, ancak çok daha fazla esneklik sunarlar. Örneğin, bir liste farklı veri tiplerini aynı anda barındırabilir – sayılar, metinler, hatta başka listeler bile! Bu, onu inanılmaz derecede çok yönlü kılar ve geliştiricilerin karmaşık veri setlerini kolayca yönetmelerine olanak tanır.

Listelerin en belirgin özelliklerinden biri, onların “değiştirilebilir” (mutable) olmasıdır. Bu ne anlama geliyor? Basitçe söylemek gerekirse, bir liste oluşturulduktan sonra bile içindeki elemanları değiştirebilir, ekleyebilir veya silebilirsiniz. Bu dinamik yapı, programların çalışma zamanında verilere göre adapte olmasını sağlar. Ayrıca, listeler “sıralıdır”; yani elemanların belirli bir sırası vardır ve bu sıra korunur. Her elemanın bir indeksi (konumu) bulunur ve bu indeks aracılığıyla elemanlara erişim sağlanır. Bu sıralı yapı, veri üzerinde mantıksal operasyonlar yaparken büyük kolaylık sağlar.

Günlük hayattan bir benzetme yapmak gerekirse, bir alışveriş listesi düşünün. Bu listede hem gıda ürünleri (ekmek, süt) hem de ev eşyaları (deterjan, ampul) gibi farklı türde öğeler bulunabilir. Listeye yeni ürünler ekleyebilir, aldıklarınızı üzerini çizerek çıkarabilir veya bir ürünün miktarını değiştirebilirsiniz. Python listeleri de tam olarak bu esnekliği ve dinamizmi sunar. Bu özellikleri sayesinde listeler, web uygulamalarından veri analizine, oyun geliştirmeden yapay zekaya kadar hemen her alanda karşımıza çıkar. Örneğin, bir e-ticaret sitesinde kullanıcının sepetindeki ürünleri, bir veri analiz aracında okunmuş satırları veya bir oyunun envanterindeki eşyaları listelerle temsil edebiliriz. Anlaşılacağı üzere, listeler Python’da sadece bir veri depolama aracı olmaktan öte, problemleri çözmek için güçlü bir yapı taşıdır. Şimdi, listelerin nasıl oluşturulduğuna ve elemanlarına nasıl erişildiğine daha yakından bakalım.

Bir Python Listesi Nasıl Oluşturulur ve Elemanlara Nasıl Erişilir?

Python’da liste oluşturmak son derece basit ve sezgiseldir. Köşeli parantezler ([]) kullanarak bir liste tanımlayabiliriz. İster boş bir liste oluşturun, ister başlangıçta birkaç elemanla dolu olsun, her ikisi de aynı kolaylıkla yapılabilir. Boş bir liste, genellikle programın ilerleyen aşamalarında eleman eklemek için bir başlangıç noktası olarak kullanılırken, önceden tanımlanmış elemanlara sahip listeler, sabit veri setlerini temsil etmek için idealdir. Aşağıdaki kod örnekleri, bu temel oluşturma yöntemlerini açıkça göstermektedir. 


# Boş bir liste oluşturma
bos_liste = []
print(f"Boş Liste: {bos_liste}")

# Elemanlarla dolu bir liste oluşturma
urunler = ["Elma", "Muz", "Portakal", "Çilek"]
print(f"Ürünler Listesi: {urunler}")

# Farklı veri tiplerini içeren bir liste
karisik_liste = [1, "Merhaba", 3.14, True, [5, 6]]
print(f"Karışık Liste: {karisik_liste}")

Listelerdeki elemanlara erişim, indeksleme (indexing) adı verilen bir yöntemle yapılır. Python'da indeksler 0'dan başlar, yani ilk elemanın indeksi 0, ikincinin 1 ve bu şekilde devam eder. Negatif indeksleme de mümkündür; bu, listenin sonundan itibaren elemanlara erişmek için kullanılır. Örneğin, -1 son elemanı, -2 sondan ikinci elemanı temsil eder. Bu esneklik, özellikle listenin uzunluğunu bilmediğimiz durumlarda son elemanlara kolayca ulaşmak için çok kullanışlıdır. 


meyveler = ["Elma", "Muz", "Portakal", "Çilek", "Kiraz"]

# İlk elemana erişim
print(f"İlk meyve: {meyveler[0]}") # Çıktı: Elma

# Üçüncü elemana erişim
print(f"Üçüncü meyve: {meyveler[2]}") # Çıktı: Portakal

# Son elemana erişim (negatif indeksleme)
print(f"Son meyve: {meyveler[-1]}") # Çıktı: Kiraz

# Sondan ikinci elemana erişim
print(f"Sondan ikinci meyve: {meyveler[-2]}") # Çıktı: Çilek

Sadece tek bir elemana erişmekle kalmayız, aynı zamanda listenin bir bölümünü "dilimleyebiliriz" (slicing). Dilimleme, bir listenin belirli bir aralığındaki elemanları yeni bir liste olarak almanızı sağlar. Genel sözdizimi liste[başlangıç:bitiş:adım] şeklindedir. Bitiş indeksi dahil edilmez (yani, bitiş-1 elemanına kadar alınır). Adım (step) parametresi isteğe bağlıdır ve elemanları belirli aralıklarla seçmek için kullanılır. Bu, büyük veri setleriyle çalışırken veya listelerin belirli bölümlerini filtrelerken oldukça güçlü bir araçtır. 


sayilar = [10, 20, 30, 40, 50, 60, 70, 80, 90]

# İlk 3 elemanı al
print(f"İlk 3 sayı: {sayilar[0:3]}") # Çıktı: [10, 20, 30]
# Veya kısa yoldan:
print(f"İlk 3 sayı (kısa): {sayilar[:3]}") # Çıktı: [10, 20, 30]

# 3. indeksten sonuna kadar
print(f"3. indeksten sonrası: {sayilar[3:]}") # Çıktı: [40, 50, 60, 70, 80, 90]

# Belirli bir aralık (2. indeksten 6. indekse kadar)
print(f"Aralık: {sayilar[2:7]}") # Çıktı: [30, 40, 50, 60, 70]

# Her 2 elemandan birini al
print(f"Adımlı dilimleme: {sayilar[::2]}") # Çıktı: [10, 30, 50, 70, 90]

# Listeyi ters çevirmenin kısa yolu
print(f"Ters liste: {sayilar[::-1]}") # Çıktı: [90, 80, 70, 60, 50, 40, 30, 20, 10]

Son olarak, bir listenin kaç eleman içerdiğini öğrenmek için len() fonksiyonunu kullanırız. Bu, listenin boyutunu dinamik olarak kontrol etmek ve döngülerde veya koşullu ifadelerde sıklıkla ihtiyaç duyulan bir bilgidir. Örneğin, bir alışveriş sepetinde kaç farklı ürün olduğunu hızlıca öğrenmek için len() fonksiyonu oldukça pratik bir çözüm sunar. 


alisveris_listesi = ["Ekmek", "Süt", "Yumurta", "Peynir"]
print(f"Alışveriş listesindeki ürün sayısı: {len(alisveris_listesi)}") # Çıktı: 4

Listeleri Dinamik Olarak Yönetme: Ekleme, Silme ve Değiştirme Operasyonları Nelerdir?

Python listelerinin en güçlü yönlerinden biri, dinamik doğasıdır. Yani, bir listeyi oluşturduktan sonra bile içeriğini kolayca değiştirebilirsiniz. Bu bölüm, listelere eleman eklemenin, mevcut elemanları silmenin ve değerlerini güncellemenin çeşitli yollarını detaylı bir şekilde açıklayacaktır. Bu operasyonlar, interaktif uygulamalar geliştirirken veya veritabanlarından çekilen bilgileri işlerken vazgeçilmezdir. Özellikle, bir envanter yönetim sistemi veya kullanıcıların tercihlerine göre güncellenen bir öneri listesi gibi senaryolarda bu dinamikliği yoğun bir şekilde kullanırız.

Listeye Eleman Ekleme Yöntemleri

Listeye eleman eklemenin birkaç farklı yolu vardır ve her birinin kendine özgü kullanım senaryosu bulunur:

  • append() metodu: Yeni bir elemanı listenin sonuna ekler. En sık kullanılan ekleme metodudur ve basit ekleme işlemleri için idealdir.

    
urun_kategorileri = ["Elektronik", "Giyim", "Kitap"]
urun_kategorileri.append("Ev & Yaşam")
print(f"append sonrası: {urun_kategorileri}")
# Çıktı: ['Elektronik', 'Giyim', 'Kitap', 'Ev & Yaşam']

  • insert(index, eleman) metodu: Belirli bir indekse yeni bir eleman ekler. Bu metod, elemanları listenin istediğiniz bir konumuna yerleştirmek istediğinizde kullanışlıdır.

    
haftanin_gunleri = ["Pazartesi", "Salı", "Perşembe", "Cuma"]
haftanin_gunleri.insert(2, "Çarşamba") # 2. indekse "Çarşamba" ekle
print(f"insert sonrası: {haftanin_gunleri}")
# Çıktı: ['Pazartesi', 'Salı', 'Çarşamba', 'Perşembe', 'Cuma']

  • extend() metodu: Bir başka liste veya yinelenebilir (iterable) bir nesnedeki tüm elemanları mevcut listenin sonuna ekler. Birden fazla elemanı tek seferde eklemek için etkilidir.

    
liste1 = [1, 2, 3]
liste2 = [4, 5, 6]
liste1.extend(liste2)
print(f"extend sonrası: {liste1}")
# Çıktı: [1, 2, 3, 4, 5, 6]

  • Liste birleştirme (+ operatörü): İki listeyi birleştirerek yeni bir liste oluşturur. Var olan listeleri doğrudan değiştirmez, yeni bir liste döndürür.

    
liste_a = ["A", "B"]
liste_b = ["C", "D"]
birlesik_liste = liste_a + liste_b
print(f"birleştirme sonrası: {birlesik_liste}")
# Çıktı: ['A', 'B', 'C', 'D']

Listeden Eleman Silme Yöntemleri

Listeden eleman silmenin de çeşitli yolları vardır. Hangi yöntemi seçeceğiniz, elemanı indeksine göre mi yoksa değerine göre mi silmek istediğinize bağlıdır:

  • remove(deger) metodu: Belirtilen değere sahip ilk elemanı listeden siler. Eğer değer listede yoksa hata (ValueError) fırlatır.

    
gorevler = ["Toplantı", "Rapor Yaz", "E-posta Gönder", "Toplantı"]
gorevler.remove("Toplantı") # İlk "Toplantı"yı siler
print(f"remove sonrası: {gorevler}")
# Çıktı: ['Rapor Yaz', 'E-posta Gönder', 'Toplantı']

  • pop(index) metodu: Belirtilen indeksteki elemanı listeden siler ve sildiği elemanı döndürür. Eğer indeks belirtilmezse, listenin sonundaki elemanı siler ve döndürür. Bu, listenin hem bir elemanını silmek hem de silinen elemanı kullanmak istediğinizde çok kullanışlıdır.

    
siradaki_kisiler = ["Ali", "Ayşe", "Mehmet", "Fatma"]
silinen_kisi = siradaki_kisiler.pop(1) # 1. indeksteki 'Ayşe'yi siler
print(f"pop sonrası: {siradaki_kisiler}")
print(f"Silinen kişi: {silinen_kisi}")
# Çıktı: ['Ali', 'Mehmet', 'Fatma']
# Silinen kişi: Ayşe

  • del anahtar kelimesi: Belirli bir indeksteki elemanı veya bir dilimi (slice) listeden siler. Bir değer döndürmez.

    
notlar = [85, 92, 78, 95, 88]
del notlar[2] # 2. indeksteki 78'i siler
print(f"del sonrası (tek eleman): {notlar}")
# Çıktı: [85, 92, 95, 88]

del notlar[1:3] # 1. indeksten 3. indekse kadar olanları siler (92 ve 95)
print(f"del sonrası (dilim): {notlar}")
# Çıktı: [85, 88]

  • clear() metodu: Listenin tüm elemanlarını siler ve boş bir liste haline getirir.

    
gecici_veriler = [10, 20, 30]
gecici_veriler.clear()
print(f"clear sonrası: {gecici_veriler}")
# Çıktı: []

Listelerdeki Elemanları Değiştirme

Mevcut bir elemanın değerini değiştirmek, onun indeksini kullanarak yeni bir değer atamak kadar basittir. Bu, bir listedeki bir kaydı güncellemeniz gerektiğinde oldukça faydalıdır. 


oyuncu_skorlari = ["Ahmet": 150, "Büşra": 200, "Cem": 120] # Hatalı örnek, bu bir liste değil, dictionary olmalıydı.
# Doğru Liste Örneği:
oyuncu_skorlari = [150, 200, 120]
print(f"Orijinal skorlar: {oyuncu_skorlari}")

# İkinci oyuncunun skorunu güncelle
oyuncu_skorlari[1] = 250
print(f"Güncel skorlar: {oyuncu_skorlari}")
# Çıktı: [150, 250, 120]

# Birden fazla elemanı aynı anda değiştirmek (dilimleme ile)
not_listesi = [60, 70, 80, 90, 100]
not_listesi[1:4] = [75, 85, 95] # 1'den 3'e kadar olanları değiştir
print(f"Güncel notlar: {not_listesi}")
# Çıktı: [60, 75, 85, 95, 100]

Bu operasyonlar sayesinde Python listeleri, hem basit hem de karmaşık veri yönetim görevleri için son derece esnek ve güçlü bir araç haline gelir. Hangi metodu kullanacağınız, spesifik ihtiyacınıza ve elemanları indeksine göre mi yoksa değerine göre mi yönetmek istediğinize bağlı olacaktır.

Listelerle Çalışırken Sık Kullanılan Metotlar ve Fonksiyonlar Nelerdir?

Python listeleri, sadece temel ekleme/silme/değiştirme işlemleriyle sınırlı değildir. Python'ın yerleşik fonksiyonları ve listelerin kendi metotları sayesinde, listeler üzerinde birçok gelişmiş operasyonu kolayca gerçekleştirebiliriz. Bu metotlar, verileri sıralamaktan, elemanların sayısını bulmaya veya belirli bir elemanın konumunu öğrenmeye kadar geniş bir yelpazede işlevsellik sunar. Bu araçları bilmek, kodunuzu daha okunaklı, verimli ve Pythonik hale getirmenin anahtarıdır. Özellikle veri işleme, raporlama veya kullanıcı arayüzleri oluşturma gibi senaryolarda bu metotlara sıkça başvurulur.

Listeleri Sıralama ve Tersine Çevirme

  • sort() metodu: Listeyi yerinde (in-place) sıralar, yani orijinal listeyi değiştirir ve hiçbir değer döndürmez. Varsayılan olarak artan sırada sıralama yapar. reverse=True parametresi ile azalan sırada sıralama yapılabilir.

    
sayilar = [3, 1, 4, 1, 5, 9, 2, 6]
sayilar.sort()
print(f"Sıralanmış liste (artan): {sayilar}")
# Çıktı: [1, 1, 2, 3, 4, 5, 6, 9]

kelimeler = ["elma", "muz", "portakal", "çilek"]
kelimeler.sort(reverse=True)
print(f"Sıralanmış liste (azalan): {kelimeler}")
# Çıktı: ['çilek', 'portakal', 'muz', 'elma']

  • sorted() fonksiyonu: Listeyi sıralar, ancak orijinal listeyi değiştirmez. Bunun yerine, sıralanmış elemanları içeren yeni bir liste döndürür. Bu, orijinal veriyi korumak istediğinizde tercih edilen yöntemdir.

    
notlar = [85, 92, 78, 95, 88]
sirali_notlar = sorted(notlar)
print(f"Orijinal notlar: {notlar}")
print(f"Sıralanmış yeni notlar: {sirali_notlar}")
# Çıktı:
# Orijinal notlar: [85, 92, 78, 95, 88]
# Sıralanmış yeni notlar: [78, 85, 88, 92, 95]

  • reverse() metodu: Listenin elemanlarının sırasını yerinde tersine çevirir. Listenin elemanlarını alfabetik veya sayısal olarak sıralamaz, sadece mevcut sırayı tersine çevirir.

    
alfabe = ["A", "B", "C", "D"]
alfabe.reverse()
print(f"Ters çevrilmiş liste: {alfabe}")
# Çıktı: ['D', 'C', 'B', 'A']

Listelerdeki Elemanları Arama ve Sayma

  • count(deger) metodu: Belirtilen değerin listede kaç kez geçtiğini sayar.

    
puanlar = [10, 20, 10, 30, 20, 10]
on_sayisi = puanlar.count(10)
yirmi_sayisi = puanlar.count(20)
kirk_sayisi = puanlar.count(40)
print(f"10 sayısı: {on_sayisi}")   # Çıktı: 3
print(f"20 sayısı: {yirmi_sayisi}") # Çıktı: 2
print(f"40 sayısı: {kirk_sayisi}") # Çıktı: 0

  • index(deger, başlangıç, bitiş) metodu: Belirtilen değerin listedeki ilk oluşumunun indeksini döndürür. Eğer değer listede yoksa hata (ValueError) fırlatır. İsteğe bağlı başlangıç ve bitiş parametreleri ile arama aralığı belirlenebilir.

    
harfler = ["a", "b", "c", "a", "d", "e"]
ilk_a_indeksi = harfler.index("a")
print(f"İlk 'a' indeksi: {ilk_a_indeksi}") # Çıktı: 0

ikinci_a_indeksi = harfler.index("a", ilk_a_indeksi + 1) # İkinci 'a'yı ilk 'a'dan sonra ara
print(f"İkinci 'a' indeksi: {ikinci_a_indeksi}") # Çıktı: 3

List Comprehension (Liste Anlayışı) ile Daha Etkin Çalışma

List comprehension, Python'da listeler oluşturmanın veya mevcut listeleri dönüştürmenin kısa, okunaklı ve genellikle daha verimli bir yoludur. Tek bir satırda karmaşık listeler oluşturmanıza olanak tanır ve döngülerle yapılan aynı işlemi çok daha özlü bir şekilde ifade eder. Bu yapı, genellikle veri manipülasyonu ve filtreleme işlemlerinde tercih edilir. 


# Bir listedeki sayıların karelerini alma
sayilar = [1, 2, 3, 4, 5]
kareler = [x**2 for x in sayilar]
print(f"Kareler listesi: {kareler}")
# Çıktı: [1, 4, 9, 16, 25]

# Belirli bir koşulu sağlayan elemanları filtreleme
cift_sayilar = [x for x in sayilar if x % 2 == 0]
print(f"Çift sayılar: {cift_sayilar}")
# Çıktı: [2, 4]

# İç içe listelerden tek bir liste oluşturma
matris = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
duz_liste = [eleman for satir in matris for eleman in satir]
print(f"Düzleştirilmiş liste: {duz_liste}")
# Çıktı: [1, 2, 3, 4, 5, 6, 7, 8, 9]

Uzman İpucu: List comprehension sadece kodunuzu kısaltmakla kalmaz, aynı zamanda geleneksel for döngülerine göre genellikle daha hızlı çalışır, özellikle büyük listelerle işlem yaparken performans avantajı sağlar. Karmaşık işlemlerde okunaklılığı korumak adına çok uzun tek satırlardan kaçınmak önemlidir.

Bu metotlar ve list comprehension gibi güçlü yapılar, Python'da listelerle çalışmayı keyifli ve üretken hale getirir. Bu araçları etkili bir şekilde kullanarak, veri manipülasyonu görevlerinizi çok daha verimli bir şekilde gerçekleştirebilirsiniz.

Gerçek Dünya Senaryolarında Python Listeleri: Vaka Analizleri

Teorik bilgileri pekiştirmenin en iyi yolu, onları gerçek dünya problemlerine uygulamaktır. Python listeleri, sundukları esneklik ve dinamizm sayesinde sayısız pratik senaryoda karşımıza çıkar. Aşağıda, listelerin gücünü ve çok yönlülüğünü gösteren üç farklı vaka analizi bulunmaktadır. Bu örnekler, bir e-ticaret uygulamasında ürün sepetini yönetmekten, veri analizinde ham bilgiyi işlemeye ve hatta bir oyunun envanter sistemini tasarlamaya kadar geniş bir yelpazeyi kapsamaktadır. Her bir vaka, listelerin nasıl yapılandırıldığını ve hangi metotların ne amaçla kullanılabileceğini somut bir şekilde gözler önüne serecektir.

Vaka 1: Bir E-ticaret Sepet Yönetimi Sistemi

Online alışveriş siteleri, kullanıcıların beğendikleri ürünleri geçici olarak saklayabildikleri bir "alışveriş sepeti" özelliğine sahiptir. Bu sepet, genellikle bir Python listesi kullanılarak kolayca modellenebilir. Her ürün, listenin bir elemanı olarak tutulur ve bu eleman, ürün adı, fiyatı ve adedi gibi bilgileri içeren bir sözlük (dictionary) veya başka bir liste olabilir. 


# Başlangıçta boş bir alışveriş sepeti
alisveris_sepeti = []

# Sepete ürün ekleme fonksiyonu
def urun_ekle(sepet, urun_adi, fiyat, adet=1):
    for urun in sepet:
        if urun["ad"] == urun_adi:
            urun["adet"] += adet
            print(f"{urun_adi} adedi güncellendi. Yeni adet: {urun['adet']}")
            return
    sepet.append({"ad": urun_adi, "fiyat": fiyat, "adet": adet})
    print(f"{urun_adi} sepete eklendi.")

# Sepetten ürün çıkarma fonksiyonu
def urun_cikar(sepet, urun_adi):
    initial_len = len(sepet)
    sepet[:] = [urun for urun in sepet if urun["ad"] != urun_adi] # List comprehension ile silme
    if len(sepet) < initial_len:
        print(f"{urun_adi} sepetten çıkarıldı.")
    else:
        print(f"{urun_adi} sepette bulunamadı.")

# Sepeti görüntüleme
def sepeti_goster(sepet):
    toplam_tutar = 0
    print("\n--- Alışveriş Sepetiniz ---")
    if not sepet:
        print("Sepetiniz boş.")
        return
    for urun in sepet:
        urun_toplam = urun["fiyat"] * urun["adet"]
        print(f"- {urun['ad']} ({urun['adet']} adet) - {urun['fiyat']:.2f} TL/adet = {urun_toplam:.2f} TL")
        toplam_tutar += urun_toplam
    print(f"--------------------------")
    print(f"Toplam Tutar: {toplam_tutar:.2f} TL")
    print("--------------------------")

# Uygulama akışı
urun_ekle(alisveris_sepeti, "Laptop", 12000.00)
urun_ekle(alisveris_sepeti, "Mouse", 150.00)
urun_ekle(alisveris_sepeti, "Klavye", 300.00, 2)
urun_ekle(alisveris_sepeti, "Laptop", 12000.00) # Aynı ürünü tekrar ekleme

sepeti_goster(alisveris_sepeti)

urun_cikar(alisveris_sepeti, "Mouse")
urun_cikar(alisveris_sepeti, "Monitör")

sepeti_goster(alisveris_sepeti)

Bu senaryoda, alisveris_sepeti bir Python listesidir ve her bir eleman, ürün bilgilerini tutan bir Python sözlüğüdür. urun_ekle fonksiyonu, ürünün zaten sepette olup olmadığını kontrol etmek için liste üzerinde döner ve varsa adetini günceller, yoksa append() ile yeni bir eleman olarak ekler. urun_cikar fonksiyonu ise, list comprehension kullanarak belirli bir ürünü sepetten çıkarır.

Vaka 2: Veri Analizinde Listelerin Rolü: Sensör Verilerini İşleme

Bilimsel veya endüstriyel uygulamalarda, sensörlerden sürekli olarak veri toplanır. Bu veriler genellikle listeler halinde saklanır ve üzerinde analizler yapılır. Örneğin, bir sıcaklık sensöründen alınan son 10 ölçümü bir listede tutabilir ve ortalamasını hesaplayabiliriz. 


# Başlangıçta boş sıcaklık ölçümleri listesi
sicaklik_olcumu_gecmisi = []
MAX_OLCUM_SAYISI = 10

# Yeni ölçüm ekleme fonksiyonu
def yeni_olcum_ekle(gecmis, olcum):
    gecmis.append(olcum)
    if len(gecmis) > MAX_OLCUM_SAYISI:
        del gecmis[0] # En eski ölçümü sil
    print(f"Yeni ölçüm eklendi: {olcum}°C. Geçmiş: {gecmis}")

# Ortalama sıcaklığı hesaplama
def ortalama_sicaklik_hesapla(gecmis):
    if not gecmis:
        return 0.0
    return sum(gecmis) / len(gecmis)

# Uygulama akışı
yeni_olcum_ekle(sicaklik_olcumu_gecmisi, 22.5)
yeni_olcum_ekle(sicaklik_olcumu_gecmisi, 23.1)
yeni_olcum_ekle(sicaklik_olcumu_gecmisi, 22.9)
for i in range(7): # 7 ölçüm daha ekle
    yeni_olcum_ekle(sicaklik_olcumu_gecmisi, 22.0 + i * 0.1)

print(f"\nSon {MAX_OLCUM_SAYISI} ölçüm: {sicaklik_olcumu_gecmisi}")
print(f"Ortalama sıcaklık: {ortalama_sicaklik_hesapla(sicaklik_olcumu_gecmisi):.2f}°C")

yeni_olcum_ekle(sicaklik_olcumu_gecmisi, 24.0) # Yeni bir ölçüm, en eskisini çıkaracak
print(f"Güncel son {MAX_OLCUM_SAYISI} ölçüm: {sicaklik_olcumu_gecmisi}")
print(f"Güncel ortalama sıcaklık: {ortalama_sicaklik_hesapla(sicaklik_olcumu_gecmisi):.2f}°C")

Bu örnekte, sicaklik_olcumu_gecmisi listesi, son 10 sıcaklık ölçümünü tutan döngüsel bir tampon görevi görür. Yeni bir ölçüm geldiğinde append() ile eklenir ve liste boyutu MAX_OLCUM_SAYISI'nı aşarsa del gecmis[0] ile en eski eleman silinerek liste boyutu sabit tutulur. Bu, akışkan veriyi sınırlı bir geçmişle yönetmek için tipik bir yaklaşımdır.

Vaka 3: Oyun Geliştirmede Envanter Sistemi

Video oyunlarında oyuncuların topladığı eşyaları, silahları ve diğer kaynakları yöneten bir envanter sistemi bulunur. Bu da Python listeleri kullanılarak kolayca tasarlanabilir. 


oyuncu_envanteri = []

def esya_ekle(envanter, esya_adi, miktar=1):
    for esya in envanter:
        if esya["ad"] == esya_adi:
            esya["miktar"] += miktar
            print(f"{esya_adi} miktarı güncellendi. Yeni miktar: {esya['miktar']}")
            return
    envanter.append({"ad": esya_adi, "miktar": miktar})
    print(f"{esya_adi} envantere eklendi.")

def esya_kullan(envanter, esya_adi, miktar=1):
    for esya in envanter:
        if esya["ad"] == esya_adi:
            if esya["miktar"] >= miktar:
                esya["miktar"] -= miktar
                print(f"{miktar} adet {esya_adi} kullanıldı. Kalan: {esya['miktar']}")
                if esya["miktar"] == 0:
                    envanter.remove(esya) # Miktar 0 olursa eşyayı envanterden çıkar
                    print(f"{esya_adi} envanterden tamamen kalktı.")
                return True
            else:
                print(f"Yeterli {esya_adi} yok. Kalan: {esya['miktar']}")
                return False
    print(f"{esya_adi} envanterde bulunamadı.")
    return False

def envanteri_goster(envanter):
    print("\n--- Oyuncu Envanteri ---")
    if not envanter:
        print("Envanteriniz boş.")
        return
    for esya in envanter:
        print(f"- {esya['ad']}: {esya['miktar']} adet")
    print("------------------------")

# Uygulama akışı
esya_ekle(oyuncu_envanteri, "Kılıç")
esya_ekle(oyuncu_envanteri, "İksir", 3)
esya_ekle(oyuncu_envanteri, "Ok", 10)
esya_ekle(oyuncu_envanteri, "İksir") # İksir miktarını artırır

envanteri_goster(oyuncu_envanteri)

esya_kullan(oyuncu_envanteri, "İksir", 2)
esya_kullan(oyuncu_envanteri, "Ok", 5)
esya_kullan(oyuncu_envanteri, "İksir", 2) # İksir biter ve envanterden kalkar

envanteri_goster(oyuncu_envanteri)

Bu senaryo da önceki örneğe benzer şekilde, oyuncu_envanteri listesini kullanarak eşya yönetimini gösterir. esya_ekle ve esya_kullan fonksiyonları, listedeki sözlük elemanlarının "miktar" anahtarını güncelleyerek çalışır. Bir eşyanın miktarı sıfıra düştüğünde, remove() metodu ile tamamen envanterden çıkarılır. Bu tür senaryolar, listelerin yalnızca basit veri depoları değil, aynı zamanda karmaşık uygulama mantığına entegre olabilen dinamik bileşenler olduğunu kanıtlar.

Uzman İpucu: Büyük listelerde eleman arama veya silme performansı kritiktir. Eğer listenizde çok sık arama yapıyorsanız, liste yerine sözlük (dictionary) veya küme (set) gibi veri yapılarını değerlendirebilirsiniz. Listeler sıralı erişim ve indeksleme için mükemmeldir, ancak belirli bir elemanı bulmak için tüm listeyi taramaları gerekebilir.

Performans İpuçları ve İleri Düzey Teknikler: Büyük Listelerle Nasıl Daha Verimli Çalışılır?

Python listeleri şüphesiz esnek ve kullanımı kolaydır, ancak büyük veri setleriyle çalışırken performans konusunda dikkatli olmak gerekir. Milyonlarca eleman içeren listelerle yapılan bazı işlemler beklenmedik derecede yavaş çalışabilir veya aşırı bellek tüketimine yol açabilir. Bu bölümde, listelerle çalışırken performansı artırmanın yollarını, ileri düzey teknikleri ve hangi durumlarda başka veri yapılarını tercih etmeniz gerektiğini inceleyeceğiz. Kodunuzun hem hızlı hem de kaynakları verimli kullanmasını sağlamak için bu ipuçlarını öğrenmek kritik öneme sahiptir.

List Comprehension'ın Gücü ve Jeneratör İfadeleri

Önceki bölümlerde list comprehension'ın ne kadar pratik olduğunu görmüştük. Sadece okunaklılığı değil, aynı zamanda performansı da artırabilir. Bir for döngüsüyle eleman eklemek yerine list comprehension kullanmak, Python yorumlayıcısının daha optimize kod üretmesini sağlar. 


import time

# Geleneksel döngü ile liste oluşturma
start_time = time.time()
buyuk_liste_dongu = []
for i in range(1000000):
    buyuk_liste_dongu.append(i * 2)
end_time = time.time()
print(f"Döngü ile süre: {end_time - start_time:.4f} saniye")

# List comprehension ile liste oluşturma
start_time = time.time()
buyuk_liste_comprehension = [i * 2 for i in range(1000000)]
end_time = time.time()
print(f"List comprehension ile süre: {end_time - start_time:.4f} saniye")

Yukarıdaki örnekte göreceğiniz gibi, list comprehension genellikle daha hızlıdır. Ancak, eğer oluşturduğunuz liste çok büyükse ve tüm elemanlarına aynı anda ihtiyacınız yoksa, belleği aşırı derecede tüketebilirsiniz. İşte bu noktada "jeneratör ifadeleri" (generator expressions) devreye girer. Jeneratör ifadeleri, list comprehension'a benzer şekilde çalışır ancak köşeli parantezler yerine yuvarlak parantezler kullanılır (()). En önemli fark, jeneratörlerin listeyi bellekte tamamen oluşturmamasıdır; bunun yerine, elemanları ihtiyaç duyulduğunda "üretirler". Bu, özellikle büyük veri setleriyle çalışırken bellek verimliliği açısından muazzam bir avantaj sağlar. 


# Jeneratör ifadesi ile bellek dostu işlem
start_time = time.time()
buyuk_jenerator = (i * 2 for i in range(1000000))
# Jeneratör elemanlarına erişmek için bir döngü veya next() kullanılmalı
# Örneğin, sum() fonksiyonu ile toplamı bulmak
toplam = sum(buyuk_jenerator)
end_time = time.time()
print(f"Jeneratör ifadesi ile süre: {end_time - start_time:.4f} saniye (sadece işlem süresi)")
# print(toplam) # jeneratör bir kez tüketildikten sonra boşalır

Jeneratörler, tüm listenin belleğe yüklenmesini gerektirmeyen durumlarda (örneğin, yalnızca bir kez üzerinden geçilecek veya bir agrega fonksiyonuyla işlenecek verilerde) performans ve bellek tasarrufu sağlar.

Listelerin Kopyalanması: Yüzeysel ve Derin Kopyalama

Bir listeyi kopyalarken dikkatli olmak önemlidir, çünkü Python'da atama (=) işlemi yeni bir kopya oluşturmaz, sadece aynı listeye işaret eden yeni bir referans yaratır. Bu, orijinal listeyi yanlışlıkla değiştirebileceğiniz anlamına gelir. Listeleri kopyalamanın birkaç yolu vardır:

  • Dilimleme (Slicing): yeni_liste = eski_liste[:] en yaygın ve Pythonik yöntemdir. Bu, "yüzeysel bir kopya" (shallow copy) oluşturur.

  • list() constructor: yeni_liste = list(eski_liste) da yüzeysel bir kopya oluşturur.

  • copy() metodu: yeni_liste = eski_liste.copy() Python 3'ten itibaren kullanılabilen, yüzeysel kopya oluşturan bir metottur.

"Yüzeysel kopya" ne anlama geliyor? Eğer listeniz sadece sayı veya metin gibi değişmez (immutable) elemanlar içeriyorsa, bu yöntemler mükemmel çalışır. Ancak, liste başka listeler (veya sözlükler gibi değiştirilebilir nesneler) içeriyorsa, yüzeysel kopya sadece iç içe geçmiş nesnelerin referanslarını kopyalar. Yani, iç içe geçmiş listenin orijinalini ve kopyasını değiştirirseniz, her ikisi de etkilenecektir. Bu durumda "derin kopya"ya (deep copy) ihtiyacınız vardır. 


import copy

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

# Yüzeysel kopya
liste_shallow = liste_orijinal[:]
liste_shallow[0] = 100 # Sadece kendi elemanını etkiler
liste_shallow[1][0] = 200 # Hem orijinaldeki hem de kopyadaki iç listeyi etkiler!

print(f"Orijinal (shallow sonrası): {liste_orijinal}") # [1, [200, 3], 4]
print(f"Shallow Kopya: {liste_shallow}")      # [100, [200, 3], 4]

# Derin kopya
liste_derin = copy.deepcopy(liste_orijinal) # 'copy' modülü gereklidir
liste_derin[1][1] = 300 # Sadece derin kopyadaki iç listeyi etkiler

print(f"Orijinal (derin sonrası): {liste_orijinal}") # [1, [200, 3], 4] (hala shallow'dan etkilenmiş hali)
print(f"Derin Kopya: {liste_derin}")      # [1, [200, 300], 4] (yeni bir kopya)

Gördüğünüz gibi, copy.deepcopy() iç içe geçmiş değiştirilebilir nesneleri de ayrı ayrı kopyalar, böylece orijinalden tamamen bağımsız bir yapı elde edersiniz.

Diğer Veri Yapılarıyla Karşılaştırma: Ne Zaman Hangisi Tercih Edilmeli?

Python'da listelerden başka veri saklama yapıları da bulunur. İhtiyacınıza göre doğru yapıyı seçmek, kodunuzun performansını ve anlaşılırlığını önemli ölçüde etkiler:

  • Tuple'lar: Listelere çok benzerler ancak değiştirilemezler (immutable). Bir tuple oluşturulduktan sonra elemanları değiştirilemez, eklenemez veya silinemez. Eğer verilerinizin sabit kalması gerekiyorsa (örneğin, bir koordinat çifti (x, y) veya bir renk RGB değeri (R, G, B)), tuple'lar listelere göre daha güvenli ve bazen daha performanslı bir seçenektir.

  • Kümeler (Sets): Sırasız eleman koleksiyonlarıdır ve her eleman benzersizdir (tekrarlayan eleman barındırmazlar). Hızlı üyelik testi (bir elemanın kümede olup olmadığını kontrol etme) ve matematiksel küme işlemleri (birleşim, kesişim, fark) için idealdirler. Eğer sıralama veya indeksleme sizin için önemli değilse ancak benzersizlik ve hızlı arama kritere ise küme tercih edilmelidir.

  • Sözlükler (Dictionaries): Anahtar-değer çiftlerinden oluşan sırasız (Python 3.7+ ile sıralı) koleksiyonlardır. Anahtarlar benzersiz olmalı ve değişmez (immutable) tiplerde olmalıdır. Eğer verilere bir anahtar (isim, ID vb.) aracılığıyla erişmeniz gerekiyorsa, sözlükler indekslemeye göre çok daha hızlı ve okunabilir bir çözüm sunar.

Özetle, listeler esneklikleri ve sıralı yapıları nedeniyle çoğu durum için harikadır. Ancak performans darboğazlarıyla karşılaştığınızda veya verinin özelliklerine daha uygun bir yapı aradığınızda, jeneratörler, tuple'lar, kümeler veya sözlükler gibi alternatifleri değerlendirmek, daha verimli ve optimize edilmiş çözümler üretmenizi sağlayacaktır.

Python Listeleri İçin Mobil Uyumluluk: HTML ve CSS İpuçları

Modern web uygulamaları ve teknik makaleler, farklı ekran boyutlarına sahip cihazlarda sorunsuz bir kullanıcı deneyimi sunmalıdır. Python listeleri hakkında yazdığımız bu makalenin HTML yapısı da mobil uyumlu olmalıdır. Python kod bloklarını ve genel içeriği mobil cihazlarda okunaklı hale getirmek için bazı HTML ve CSS tekniklerinden faydalanabiliriz. Bu, sadece görsel bir iyileştirme değil, aynı zamanda SEO performansı için de kritik bir faktördür, zira arama motorları mobil uyumlu siteleri ödüllendirir.

Duyarlı Tasarım İçin Temel Yaklaşımlar

  • Viewport Meta Etiketi: Her şeyden önce, HTML belgenizin bölümüne aşağıdaki meta etiketini eklemek, tarayıcının sayfayı cihazın genişliğine göre ölçeklendirmesini sağlar.

  • Esnek Resimler ve Medya: Eğer makalenizde resimler veya diğer medya elemanları olsaydı, bunların kapsayıcılarına göre ölçeklenmesini sağlamak için max-width: 100%; height: auto; gibi CSS kuralları kullanılırdı.

  • Anlamlı HTML Yapısı:

    ,

    ,
      ,
        gibi semantik etiketlerin doğru kullanımı, hem erişilebilirlik hem de farklı cihazlarda tarayıcıların içeriği doğru işlemesi için önemlidir.

      Kod Blokları ve Tablolar İçin Mobil İpuçları

      Kod blokları (

      ) ve tablolar () dar ekranlarda genellikle taşma sorunları yaratabilir. Bu sorunu çözmek için CSS kullanarak yatay kaydırma çubukları ekleyebiliriz:
    
    
      
/* Kod blokları için yatay kaydırma */
pre {
    white-space: pre-wrap;       /* Uzun satırları otomatik sar */
    word-wrap: break-word;       /* Kelime sarmalama */
    overflow-x: auto;            /* Yatay taşma durumunda kaydırma çubuğu */
    background-color: #f4f4f4;
    padding: 15px;
    border-radius: 5px;
    font-size: 0.9em;
    line-height: 1.4;
}

/* Tablolar için duyarlılık */
table {
    width: 100%;
    border-collapse: collapse;
    margin-bottom: 20px;
    display: block; /* Küçük ekranlarda tabloyu blok seviyesi yap */
    overflow-x: auto; /* Yatay kaydırma çubuğu ekle */
}

/* Küçük ekranlar için özel ayarlamalar */
@media screen and (max-width: 768px) {
    body {
        font-size: 16px; /* Okunabilirliği artırmak için font boyutunu büyüt */
    }

    h2 {
        font-size: 1.5em;
    }

    h3 {
        font-size: 1.2em;
    }

    /* Örneğin, interaktif ipucu kutusunun boyutunu ayarla */
    .expert-tip {
        margin: 10px 0;
        padding: 10px;
        font-size: 0.9em;
    }
}
    
      
        Yukarıdaki CSS kodu, 
       etiketleri içerisindeki kod bloklarının dar ekranlarda yatay olarak kaydırılabilir olmasını sağlar. Ayrıca, @media screen and (max-width: 768px) kuralı, ekran genişliği 768 pikselin altına düştüğünde belirli CSS özelliklerini uygular. Bu, genellikle mobil cihazlar ve tabletler için font boyutlarını artırmak, kenar boşluklarını ayarlamak veya bazı elemanların düzenini değiştirmek gibi işlemler için kullanılır. Bu tür mobil uyumluluk adımları, teknik içeriğinizi çok daha geniş bir kitleye ulaştırırken, okuyucu deneyimini de önemli ölçüde iyileştirir.
    

      Sonuç: Python Listelerinin Gücü ve Esnekliği
      

      
        Bu kapsamlı rehber boyunca, Python listelerinin programlama dünyasındaki vazgeçilmez yerini ve geniş kullanım alanlarını detaylı bir şekilde inceledik. Listelerin temel tanımından, dinamik ekleme, silme ve değiştirme operasyonlarına; sıralama ve arama metotlarından, list comprehension gibi ileri düzey tekniklere kadar birçok konuya değindik. Ayrıca, e-ticaret sepet yönetimi, sensör verisi işleme ve oyun envanteri gibi gerçek dünya senaryolarında listelerin nasıl etkin bir şekilde kullanılabileceğini vaka analizleri ile pekiştirdik. Mobil uyumluluk üzerine eklediğimiz ipuçları ise, teknik içeriğinizi geniş bir kitleye ulaştırmanın önemini vurguladı.
    
      

      
        Python listeleri, şüphesiz ki öğrenilmesi gereken ilk ve en önemli veri yapılarından biridir. Sunduğu esneklik, farklı veri tiplerini barındırma yeteneği ve zengin metot kütüphanesi sayesinde, basit scriptlerden karmaşık kurumsal uygulamalara kadar her türlü projede temel bir yapı taşı olarak karşımıza çıkar. Büyük veri setleriyle çalışırken performans ve bellek verimliliği gibi konulara dikkat etmek, listelerin gücünü tam anlamıyla kullanmak için kritik öneme sahiptir.
    
      

      
        Unutmayın ki her aracın kendine özgü avantajları ve dezavantajları vardır. Python listeleri çoğu zaman mükemmel bir seçim olsa da, bazı durumlarda tuple'lar, kümeler veya sözlükler gibi diğer veri yapıları daha uygun çözümler sunabilir. Önemli olan, probleminizi doğru analiz etmek ve elinizdeki araçlar arasından en uygun olanı seçmektir. Bu rehberin, Python listelerine dair bilginizi derinleştirdiğini ve onları projelerinizde daha bilinçli ve etkili bir şekilde kullanmanız için size rehberlik ettiğini umuyoruz. Programlama yolculuğunuzda başarılar dileriz!
    
      

      Sıkça Sorulan Sorular (SSS)
      

        

      • 

        Bir liste ile tuple arasındaki temel fark nedir?
        

        Temel fark, listelerin değiştirilebilir (mutable) olması, yani oluşturulduktan sonra elemanlarının değiştirilebilir, eklenebilir veya silinebilir olmasıdır. Tuple'lar ise değiştirilemez (immutable) yapıdadır; bir kez oluşturulduktan sonra içerikleri sabittir ve değiştirilemez. Bu nedenle, sabit kalması gereken veri koleksiyonları için tuple'lar tercih edilirken, dinamik olarak değişecek veriler için listeler kullanılır.
        

        • 

      • 

        List Comprehension kullanmanın avantajları nelerdir?
        

        List Comprehension, listeler oluşturmanın veya dönüştürmenin daha kısa, daha okunaklı ve genellikle daha performanslı bir yoludur. Geleneksel for döngülerine kıyasla daha az satır kod yazmanızı sağlar, Python'ın iç optimizasyonlarından faydalanarak daha hızlı çalışabilir ve karmaşık döngüleri tek bir ifadeyle ifade etme olanağı sunar. Bu, özellikle veri manipülasyonu ve filtreleme işlemlerinde kodun anlaşılırlığını ve verimliliğini artırır.
        

        • 

      • 

        Büyük listelerde eleman aramanın en hızlı yolu nedir?
        

        Büyük listelerde belirli bir elemanı aramanın en hızlı yolu, listenin yapısına ve ihtiyacınıza göre değişir. Eğer listeniz sıralı ise, ikili arama (binary search) algoritmaları oldukça hızlıdır ancak Python'ın yerleşik listeleri için doğrudan ikili arama metodu yoktur, kendiniz uygulamanız gerekir. Eğer listenin sıralı olması sizin için önemli değilse ve yalnızca elemanların varlığını kontrol etmek istiyorsanız, bir liste yerine bir küme (set) kullanmak çok daha hızlı üyelik testi (in operatörü ile) sağlar. Sözlükler (dictionary) ise anahtara göre eleman arama için en verimli yoldur.
        

        • 

      • 

        Python listeleri thread-safe midir?
        

        Python'ın Küresel Yorumlayıcı Kilidi (GIL - Global Interpreter Lock) sayesinde, aynı anda yalnızca bir Python bayt kodu dizisi yürütülebilir. Bu durum, listeler gibi yerleşik veri yapılarının bazı temel operasyonlarının (örneğin append()) atomik olmasını ve birden fazla iş parçacığı tarafından güvenli bir şekilde kullanılmasını sağlar. Yani, temelde, bir iş parçacığı bir listenin içeriğini değiştirirken, başka bir iş parçacığı aynı anda aynı listeyi değiştirmeye çalışsa bile, tutarsız bir duruma düşülmez. Ancak, daha karmaşık, çok adımlı list işlemleri (örneğin, bir elemanı kontrol edip sonra silmek gibi) hala race condition'lara yol açabilir ve bu durumlarda kilitler (locks) veya diğer senkronizasyon mekanizmaları kullanılmalıdır.
        

        • 

      
	
      
		
      byFatih Soysal
      0
      	
      
	
      
		
		
      

			
			
				
			

			
				
			

			
				
			

			
				
			

		
      

			
      

      

	
      
		
      
			
      Yorumlar
      
			
      İçeriği beğendiniz mi? Bir tartışma başlatın veya görüşlerinizi paylaşın.
      
		
      
		
      
			
      
				
					Yorum Yaz
				
			
      
		
      

	
      

	
      

			
      
		
      Bir yanıt yazın 
      E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir
      


      

      Gönder  


      	
      
	
		
		


	
      


      
			
      
				Aşağıdaki içerikler de ilgilinizi çekebilir:			
      

			
      
									
										
										
										
								
      
		
      
	
      
					
      
									
      
						E-posta Bülteni					
      
													
      
						Yazılım Topluluğuna Katılın					
      
													
      
						En son güncellemeleri, yaratıcı ipuçlarını ve özel kaynakları doğrudan e-posta kutunuza alın. Tasarım ve inovasyonun geleceğini birlikte keşfedelim.