Python Liste (list) Metotları ve Dilimleme Rehberi

Liste oluşturma

Boş bir liste [] ile, elemanları belli bir liste virgülle ayrılmış değerlerle yazılır. list() yapıcısı ise herhangi bir yinelenebilir (iterable) nesneyi alıp aynı sırayla elemanlarından yeni bir liste kurar: bir string harflerine, bir range sayılarına, bir sözlük anahtarlarına ayrılır. Bir listenin içinde farklı tipte değerler bulunabilir, hatta başka listeler de olabilir. Belgeler listelerin genellikle "benzer türden" öğeleri tutmak için kullanıldığını söyler; farklı türden ve sabit sayıda alanı bir arada tutmak için tuple daha uygundur.

bos = []
sayilar = [3, 1, 4, 1, 5]
karisik = ['elma', 42, 3.14, None, [1, 2]]
harfler = list('kedi')

print(len(sayilar))      # çıktı: 5
print(harfler)           # çıktı: ['k', 'e', 'd', 'i']
print(karisik[4][1])     # çıktı: 2
print(list(range(5)))    # çıktı: [0, 1, 2, 3, 4]
print(bos == list())     # çıktı: True

Liste kurmanın dördüncü yolu list comprehension'dır: [x * 2 for x in sayilar]. Bu söz dizimi ayrı bir konu olduğu için list comprehension rehberinde ayrıntılı anlatılıyor. Listeyle aynı işi gören ama değiştirilemeyen kardeş tip için tuple ve unpacking yazısına göz atabilirsiniz.

İndeksleme: pozitif ve negatif indeks

Listenin ilk elemanı liste[0], ikincisi liste[1]'dir. Negatif indeks sondan saymayı sağlar: liste[-1] son eleman, liste[-2] sondan ikinci elemandır. Python negatif indeksi içeride len(liste) + i olarak hesaplar. Var olmayan bir indekse erişmeye çalışırsanız IndexError alırsınız; dilimlemenin aksine tek eleman erişimi sınırı aşmayı affetmez.

gunler = ['Pzt', 'Sal', 'Çar', 'Per', 'Cum']
print(gunler[0])     # çıktı: Pzt
print(gunler[-1])    # çıktı: Cum
print(gunler[-2])    # çıktı: Per

try:
    gunler[5]
except IndexError as hata:
    print(hata)      # çıktı: list index out of range

gunler[0] = 'Pazartesi'   # liste değiştirilebilir
print(gunler)        # çıktı: ['Pazartesi', 'Sal', 'Çar', 'Per', 'Cum']

Dilimleme (slicing) kuralları

liste[i:j] ifadesi i indeksinden başlayıp j indeksine kadar (j dahil değil) olan elemanlardan yeni bir liste üretir. Üçüncü sayı adım (step) değeridir: liste[i:j:k]. Belgelerdeki kurallar özetle şöyledir: i yazılmazsa 0, j yazılmazsa listenin uzunluğu kullanılır; sınırların dışına taşan değerler sessizce listenin sınırına çekilir; i, j'ye eşit ya da ondan büyükse sonuç boş listedir. Adım negatif olduğunda varsayılan başlangıç ve bitiş uçları yer değiştirir, bu yüzden liste[::-1] listenin ters çevrilmiş bir kopyasını verir. Adım sıfır olamaz.

s = [0, 10, 20, 30, 40, 50, 60]
print(s[2:5])     # çıktı: [20, 30, 40]
print(s[:3])      # çıktı: [0, 10, 20]
print(s[4:])      # çıktı: [40, 50, 60]
print(s[-3:])     # çıktı: [40, 50, 60]
print(s[::2])     # çıktı: [0, 20, 40, 60]
print(s[::-1])    # çıktı: [60, 50, 40, 30, 20, 10, 0]
print(s[5:100])   # çıktı: [50, 60]
print(s[5:2])     # çıktı: []

try:
    s[::0]
except ValueError as hata:
    print(hata)   # çıktı: slice step cannot be zero

Dilimler yalnızca okumak için değil, değiştirmek için de kullanılabilir. Bir dilime atama yaptığınızda o aralıktaki elemanlar sağ taraftaki yinelenebilirin elemanlarıyla değiştirilir ve iki tarafın uzunluğu farklı olabilir; liste buna göre uzar ya da kısalır. Boş bir dilime (s[1:1]) atama araya eleman eklemek, bir dilime boş liste atamak ise o aralığı silmek demektir. Adımlı (extended) dilimlerde durum farklıdır: adım 1 değilse sağ taraf, değiştirdiği dilimle aynı uzunlukta olmak zorundadır.

s = [1, 2, 3, 4, 5]
s[1:3] = ['a', 'b', 'c', 'd']
print(s)          # çıktı: [1, 'a', 'b', 'c', 'd', 4, 5]
s[1:5] = []
print(s)          # çıktı: [1, 4, 5]
s[1:1] = [2, 3]
print(s)          # çıktı: [1, 2, 3, 4, 5]
del s[::2]
print(s)          # çıktı: [2, 4]

t = [1, 2, 3, 4]
try:
    t[::2] = [9]
except ValueError as hata:
    print(hata)   # çıktı: attempt to assign sequence of size 1 to extended slice of size 2

Tüm liste metotları bir bakışta

Resmî belgelerdeki liste metotlarının hepsi aşağıdaki tabloda. Dikkat edilmesi gereken ortak nokta şu: listeyi yerinde değiştiren metotlar (append, insert, sort, reverse vb.) yeni bir liste döndürmez, None döndürür. Belgeler bunu Python'daki tüm değiştirilebilir veri yapıları için geçerli bir tasarım ilkesi olarak tanımlar.

append, extend ve insert ile ekleme

append() verdiğiniz nesneyi tek bir eleman olarak sona ekler; bir liste verirseniz o liste iç içe tek bir eleman olur. extend() ise verdiğiniz yinelenebilirin içini açar ve elemanlarını tek tek ekler. Bu fark en sık karıştırılan konulardan biridir: bir stringi extend() ile eklerseniz harflerine ayrılır. insert(i, x) elemanı i indeksindeki elemanın önüne koyar; insert(0, x) başa ekler, liste uzunluğundan büyük bir indeks verirseniz eleman hata vermeden sona eklenir, çünkü belgelere göre bu işlem s[i:i] = [x] dilim atamasına denktir.

a = [1, 2]
a.append([3, 4])
print(a)       # çıktı: [1, 2, [3, 4]]

b = [1, 2]
b.extend([3, 4])
print(b)       # çıktı: [1, 2, 3, 4]
b.extend('ab')
print(b)       # çıktı: [1, 2, 3, 4, 'a', 'b']

c = ['b', 'd']
c.insert(0, 'a')
c.insert(2, 'c')
c.insert(100, 'e')
print(c)       # çıktı: ['a', 'b', 'c', 'd', 'e']

remove, pop, del ve clear ile silme

Silmenin dört yolu vardır ve hangisini seçeceğiniz elinizde değerin mi yoksa indeksin mi olduğuna bağlıdır. remove(x) değere göre çalışır ve yalnızca ilk eşleşmeyi siler; değer yoksa ValueError fırlatır. pop() indekse göre çalışır ve sildiği elemanı size geri verir; indeks vermezseniz son elemanı alır. del liste[i] de indekse göre siler ama değer döndürmez; dilimlerle birlikte bir aralığı tek seferde silebilir. clear() ise listeyi boşaltır, liste nesnesi yerinde kalır.

renkler = ['kırmızı', 'mavi', 'yeşil', 'mavi']
renkler.remove('mavi')
print(renkler)          # çıktı: ['kırmızı', 'yeşil', 'mavi']

son = renkler.pop()
print(son, renkler)     # çıktı: mavi ['kırmızı', 'yeşil']
ilk = renkler.pop(0)
print(ilk, renkler)     # çıktı: kırmızı ['yeşil']

try:
    renkler.remove('mor')
except ValueError as hata:
    print(hata)         # çıktı: list.remove(x): x not in list

renkler.clear()
print(renkler)          # çıktı: []
try:
    renkler.pop()
except IndexError as hata:
    print(hata)         # çıktı: pop from empty list

index, count ve in ile arama

count(x) değerin kaç kez geçtiğini sayar, değer hiç yoksa 0 döndürür. index(x) ilk geçtiği yerin indeksini verir ve bulamazsa hata fırlatır; isteğe bağlı start ve stop parametreleri aramayı bir alt aralıkla sınırlar ama dönen indeks yine listenin başına göredir. Bir değerin listede olup olmadığını öğrenmek için index()'i try içine almak yerine in işlecini kullanmak daha okunaklıdır. Çok sayıda üyelik sorgusu yapacaksanız listeyi bir kümeye çevirmeyi düşünün; ayrıntılar set ve küme işlemleri yazısında.

meyveler = ['portakal', 'elma', 'armut', 'muz', 'kivi', 'elma', 'muz']
print(meyveler.count('elma'))      # çıktı: 2
print(meyveler.count('ayva'))      # çıktı: 0
print(meyveler.index('muz'))       # çıktı: 3
print(meyveler.index('muz', 4))    # çıktı: 6
print('kivi' in meyveler)          # çıktı: True
print('ayva' not in meyveler)      # çıktı: True

try:
    meyveler.index('ayva')
except ValueError as hata:
    print(hata)                    # çıktı: list.index(x): x not in list

sort() ve sorted(): yerinde ve yeni liste

liste.sort() listeyi yerinde sıralar ve None döndürür. Yerleşik sorted() fonksiyonu ise herhangi bir yinelenebilirden yeni bir sıralı liste üretir ve kaynağa dokunmaz. Sıralama belgelerine göre orijinal listeye ihtiyacınız yoksa sort() biraz daha verimlidir; ama sorted() tuple, string, sözlük gibi her yinelenebilirle çalıştığı için çoğu durumda daha kullanışlıdır. En yaygın hata, sort()'un sonucunu bir değişkene atayıp None ile karşılaşmaktır.

notlar = [70, 45, 90]
sonuc = notlar.sort()
print(sonuc)                # çıktı: None
print(notlar)               # çıktı: [45, 70, 90]

print(sorted((3, 1, 2)))    # çıktı: [1, 2, 3]
print(sorted('python'))     # çıktı: ['h', 'n', 'o', 'p', 't', 'y']
notlar.reverse()
print(notlar)               # çıktı: [90, 70, 45]

Her iki fonksiyon da yalnızca anahtar kelimeyle verilebilen iki parametre alır. key, her elemandan karşılaştırma anahtarı üreten tek argümanlı bir fonksiyondur ve her eleman için yalnızca bir kez çağrılır. reverse=True sıralamayı tersine çevirir. Python'un sıralaması kararlıdır (stable): anahtarı eşit olan elemanlar orijinal sıralarını korur. Bu sayede önce ikincil, sonra birincil anahtara göre iki ayrı sıralama yaparak çok kriterli sıralama elde edebilirsiniz; aynı işi tek seferde yapmak için anahtarı bir tuple olarak döndürmek de yaygındır.

from operator import itemgetter

ogrenciler = [('Ayşe', 'B', 17), ('Mehmet', 'A', 16), ('Can', 'B', 15), ('Zeynep', 'A', 17)]

print(sorted(ogrenciler, key=lambda o: o[2]))
# çıktı: [('Can', 'B', 15), ('Mehmet', 'A', 16), ('Ayşe', 'B', 17), ('Zeynep', 'A', 17)]

print(sorted(ogrenciler, key=lambda o: o[2], reverse=True))
# çıktı: [('Ayşe', 'B', 17), ('Zeynep', 'A', 17), ('Mehmet', 'A', 16), ('Can', 'B', 15)]

# Önce sınıfa (artan), sonra yaşa (azalan) göre:
print(sorted(ogrenciler, key=lambda o: (o[1], -o[2])))
# çıktı: [('Zeynep', 'A', 17), ('Mehmet', 'A', 16), ('Ayşe', 'B', 17), ('Can', 'B', 15)]

print(sorted(ogrenciler, key=itemgetter(1, 2)))
# çıktı: [('Mehmet', 'A', 16), ('Zeynep', 'A', 17), ('Can', 'B', 15), ('Ayşe', 'B', 17)]

Bu örnekte 17 yaşındaki Ayşe ile Zeynep'in ilk iki sıralamadaki göreli konumları, kararlılık sayesinde orijinal listedeki gibi kalır. operator.itemgetter ve attrgetter, lambda yazmadan anahtar fonksiyonu üretmenin hızlı yoludur; lambda, map, filter ve sorted yazısında bu araçları daha ayrıntılı bulabilirsiniz.

Türkçe kelimeleri sıralarken dikkat

Stringler karşılaştırılırken her karakterin Unicode kod noktası kullanılır. Bu yüzden büyük harfler küçük harflerden önce gelir ve Türkçeye özgü ç, ğ, ı, ö, ş, ü harfleri İngiliz alfabesindeki tüm harflerden sonra sıralanır. key=str.casefold büyük/küçük harf farkını ortadan kaldırır ama Türkçe harflerin yerini düzeltmez. Kendi alfabe sıranızı uygulamak için her kelimeyi harflerinin alfabe içindeki konumlarından oluşan bir listeye çeviren basit bir anahtar fonksiyonu yazabilirsiniz; listeler sözlük sırasıyla karşılaştırıldığı için bu yeterlidir.

kelimeler = ['çay', 'zeytin', 'armut', 'ılık', 'incir', 'Elma', 'şeker', 'üzüm', 'ödev']
print(sorted(kelimeler))
# çıktı: ['Elma', 'armut', 'incir', 'zeytin', 'çay', 'ödev', 'üzüm', 'ılık', 'şeker']
print(sorted(kelimeler, key=str.casefold))
# çıktı: ['armut', 'Elma', 'incir', 'zeytin', 'çay', 'ödev', 'üzüm', 'ılık', 'şeker']

ALFABE = 'abcçdefgğhıijklmnoöprsştuüvyz'

def tr_anahtar(kelime):
    return [ALFABE.find(harf) for harf in kelime.lower()]

print(sorted(kelimeler, key=tr_anahtar))
# çıktı: ['armut', 'çay', 'Elma', 'ılık', 'incir', 'ödev', 'şeker', 'üzüm', 'zeytin']

Karşılaştırılamayan tipleri bir arada sıralamaya çalışırsanız TypeError alırsınız. Belgelerin uyarısına göre böyle bir hatada sıralama yarıda kalır ve liste kısmen değişmiş halde bırakılabilir. Python 3'te sayı ile stringin, ya da None ile başka bir değerin büyüklük karşılaştırması tanımlı değildir.

try:
    [3, 'a', 1].sort()
except TypeError as hata:
    print(hata)   # çıktı: '<' not supported between instances of 'str' and 'int'

Kopyalama: atama kopya değildir

Python'da atama nesneyi kopyalamaz, yalnızca aynı nesneye yeni bir isim bağlar. b = a dedikten sonra b üzerinden yaptığınız her değişiklik a'da da görünür, çünkü ikisi aynı listedir. Bağımsız bir liste için kopya almanız gerekir: a.copy(), a[:] ve list(a) üçü de sığ kopya (shallow copy) üretir. Sığ kopya yeni bir dış liste oluşturur ama içerideki nesnelere aynı referansları koyar; iç içe listelerde iç listeler hâlâ paylaşılır. Tamamen bağımsız bir kopya için copy modülündeki deepcopy() kullanılır.

import copy

a = [1, 2, 3]
b = a
b.append(4)
print(a)          # çıktı: [1, 2, 3, 4]
print(a is b)     # çıktı: True

c = a.copy()      # a[:] veya list(a) da olur
c.append(5)
print(a)          # çıktı: [1, 2, 3, 4]
print(c)          # çıktı: [1, 2, 3, 4, 5]

matris = [[1, 2], [3, 4]]
sig = matris.copy()
derin = copy.deepcopy(matris)
matris[0].append(99)
print(sig)        # çıktı: [[1, 2, 99], [3, 4]]
print(derin)      # çıktı: [[1, 2], [3, 4]]

Aynı mantık * ile çoğaltmada da karşınıza çıkar ve belgeler bunu yeni başlayanları en çok şaşırtan durumlardan biri olarak özellikle anar. [[]] * 3 üç ayrı boş liste değil, aynı boş listeye üç referans içeren bir liste üretir. İki boyutlu bir tablo kurarken her satırı ayrı oluşturmak için comprehension kullanın.

yanlis = [[]] * 3
yanlis[0].append('x')
print(yanlis)    # çıktı: [['x'], ['x'], ['x']]

dogru = [[] for _ in range(3)]
dogru[0].append('x')
print(dogru)     # çıktı: [['x'], [], []]

Bir de += ile + arasındaki fark var. Listelerde x += [3] aslında extend() gibi çalışır ve listeyi yerinde değiştirir; aynı listeye bakan başka isimler değişikliği görür. x = x + [4] ise yeni bir liste oluşturup x ismini ona bağlar, eski liste olduğu gibi kalır.

x = [1, 2]
y = x
x += [3]
print(y)    # çıktı: [1, 2, 3]
x = x + [4]
print(y)    # çıktı: [1, 2, 3]
print(x)    # çıktı: [1, 2, 3, 4]

Listeyi yığın (stack) ve kuyruk (queue) olarak kullanmak

Liste metotları, listeyi "son giren ilk çıkar" (LIFO) mantığıyla çalışan bir yığın olarak kullanmayı çok kolaylaştırır: append() ile üste ekler, argümansız pop() ile üstten alırsınız. Tarayıcıdaki geri tuşu ya da geri al (undo) geçmişi bu yapıya iyi bir örnektir.

gecmis = []
gecmis.append('ana sayfa')
gecmis.append('ürünler')
gecmis.append('sepet')
print(gecmis.pop())   # çıktı: sepet
print(gecmis)         # çıktı: ['ana sayfa', 'ürünler']

"İlk giren ilk çıkar" (FIFO) kuyrukta ise durum değişir. Belgeler listenin bu iş için verimli olmadığını açıkça belirtir: sondan ekleme ve çıkarma hızlıdır ama baştan çıkarmak (pop(0)) ya da başa eklemek (insert(0, x)) diğer tüm elemanların bir konum kaydırılmasını gerektirir. CPython'da liste, nesne referanslarından oluşan bitişik bir dizi olarak uygulanır; indeksle erişimin maliyeti listenin boyutundan bağımsızdır, ama baştaki değişiklikler her şeyi kaydırır. Kuyruk için iki uçtan da hızlı ekleme ve çıkarma yapan collections.deque tasarlanmıştır.

from collections import deque

kuyruk = deque(['Ali', 'Banu', 'Cem'])
kuyruk.append('Deniz')        # Deniz sıraya girdi
print(kuyruk.popleft())       # çıktı: Ali
print(kuyruk.popleft())       # çıktı: Banu
print(kuyruk)                 # çıktı: deque(['Cem', 'Deniz'])

deque'nun maxlen, rotate() gibi diğer özellikleri collections modülü: Counter, defaultdict, deque yazısında anlatılıyor.

Döngüde listeyi değiştirmek

Bir listenin üzerinde for ile dönerken aynı listeden eleman silmek, beklenmedik sonuç veren klasik bir hatadır. Belgelere göre değiştirilebilir dizilerin yineleyicisi içeride bir indeks tutar ve bu indeks liste değişse bile ilerlemeye devam eder. Bir eleman silindiğinde arkasındaki eleman bir sola kayar ve yineleyici onu atlar. Aşağıdaki örnekte bütün 2'leri silmek isterken biri listede kalıyor:

sayilar = [1, 2, 2, 3, 2, 4]
for n in sayilar:
    if n == 2:
        sayilar.remove(n)
print(sayilar)    # çıktı: [1, 3, 2, 4]

# Doğrusu: yeni bir liste kurup dilim atamasıyla yerine koymak
sayilar = [1, 2, 2, 3, 2, 4]
sayilar[:] = [n for n in sayilar if n != 2]
print(sayilar)    # çıktı: [1, 3, 4]

Python SSS (Programming FAQ) birden çok elemanı silmek için tam olarak bu yöntemi, yani liste[:] = ... biçiminde dilim ataması yapmayı önerir. liste = [...] yazmak da çoğu zaman yeterlidir; fark, dilim atamasının aynı liste nesnesini değiştirmesi, dolayısıyla bu listeye başka yerlerden bakan referansların da güncel içeriği görmesidir.

Karşılaştırma, len, min, max ve sum

İki liste == ile karşılaştırıldığında elemanlar sırayla eşitse sonuç True olur. < ve > ise sözlük sırası (lexicographic) kullanır: ilk farklı elemana bakılır; bir liste diğerinin başlangıç kısmıysa kısa olan küçük sayılır. Farklı sayı tipleri değerleriyle karşılaştırıldığı için [1, 2, 3] == [1.0, 2.0, 3.0] doğrudur. len(), min(), max() ve sum() listelerle doğrudan çalışır; boş bir listede min() ve max() hata verir, bunu önlemek için default parametresi kullanılabilir.

print([1, 2, 3] < [1, 2, 4])          # çıktı: True
print([1, 2] < [1, 2, -1])            # çıktı: True
print([1, 2, 3] == [1.0, 2.0, 3.0])   # çıktı: True

fiyatlar = [120, 75, 310, 45]
print(len(fiyatlar), min(fiyatlar), max(fiyatlar), sum(fiyatlar))   # çıktı: 4 45 310 550
print(max([], default=0))             # çıktı: 0

Uygulamalı mini örnek: görev listesi

Şimdi bu metotları bir arada kullanalım. Küçük bir yapılacaklar listesi tutuyor, başa acil bir görev ekliyor, tamamlanan bir görevi çıkarıyor, birkaç görevi topluca ekliyor ve listeyi görev metninin uzunluğuna göre sıralıyoruz. enumerate() ile numaralı yazdırma for ve while döngüleri yazısında ayrıca anlatılıyor.

gorevler = ['fatura öde', 'rapor yaz']
gorevler.append('market')
gorevler.insert(0, 'acil: yedek al')
tamamlanan = gorevler.pop(1)
gorevler.extend(['spor', 'kitap oku'])
gorevler.sort(key=len)

for sira, gorev in enumerate(gorevler, start=1):
    print(sira, gorev)
print('Tamamlanan:', tamamlanan)
# çıktı: 1 spor
# çıktı: 2 market
# çıktı: 3 rapor yaz
# çıktı: 4 kitap oku
# çıktı: 5 acil: yedek al
# çıktı: Tamamlanan: fatura öde

Uzunluğu eşit olan "rapor yaz" ile "kitap oku" (ikisi de 9 karakter) sıralamadan sonra da listeye eklenme sıralarını korudu; bu yine sıralamanın kararlı olmasının sonucudur.

Sık yapılan hatalar

• liste = liste.sort() yazmak: sort() None döndürür, listeniz kaybolur. sorted() kullanın ya da atamayı kaldırın.
• append() ile extend()'i karıştırmak: liste içinde liste oluşur ya da bir string harflerine bölünür.
• b = a ile kopya aldığını sanmak. Kopya için a.copy(), iç içe yapılar için copy.deepcopy().
• [[0] * 3] * 3 ile matris kurmak: satırların hepsi aynı listedir.
• Üzerinde dönülen listeden eleman silmek: yeni liste kurun veya liste[:] = ... kullanın.
• Kuyruk için pop(0) kullanmak: uzun listelerde yavaştır, collections.deque tercih edin.
• Başka dillerden gelen metot adlarını denemek: Python 3.15, push gibi adlar için doğru metodu önerir (aşağıya bakın).

Python 3.15 ile gelen yeniliklerden biri, yerleşik tiplerde bulunmayan bir metodu çağırdığınızda hata mesajının JavaScript, Java, Ruby ve C# gibi dillerdeki yaygın metot adlarını tanıyıp Python karşılığını önermesidir. Aşağıdaki çıktı Python 3.15.2'den alınmıştır; yalnızca dosya yolunu ornek.py olarak kısalttık. Benzer mesajların tam listesi için sık görülen hata mesajları, sürümün diğer yenilikleri için Python 3.15 yenilikleri yazısına bakabilirsiniz.

liste = [1, 2, 3]
liste.push(4)
# Traceback (most recent call last):
#   File "ornek.py", line 2, in <module>
#     liste.push(4)
#     ^^^^^^^^^^
# AttributeError: 'list' object has no attribute 'push'. Did you mean '.append'?

Sık Sorulan Sorular

Python'da liste ile dizi (array) aynı şey mi?

Python SSS'ye göre bir dizi ihtiyacı için liste kullanılır; listeler zaman karmaşıklığı açısından C veya Pascal dizilerine benzer, temel fark farklı tipte nesneleri bir arada tutabilmeleridir. Standart kütüphanedeki array modülü tek tipli ve daha sıkı yer kaplayan diziler sunar, ancak SSS bunların indekslemede listeden yavaş olduğunu da not eder.

Bir listedeki tekrar eden elemanları nasıl silerim?

Elemanlar hash'lenebilirse ve sıra önemli değilse list(set(liste)) en kısa yoldur. İlk görülme sırasını korumak istiyorsanız list(dict.fromkeys(liste)) kullanın; sözlükler ekleme sırasını koruduğu için sonuç orijinal sıradadır. Ayrıntılar sözlük metotları yazısında.

Liste metotları neden yeni liste döndürmüyor?

Belgeler bunu bilinçli bir tasarım ilkesi olarak açıklar: listeyi yerinde değiştiren metotlar, işlemin yan etkiyle yapıldığını hatırlatmak için None döndürür. Yeni bir liste istiyorsanız sorted(), reversed(), dilimleme veya comprehension gibi yeni nesne üreten araçları kullanın.

liste[-1] ile liste[len(liste) - 1] arasında fark var mı?

Sonuç aynıdır; Python negatif indeksi zaten len(liste) + i olarak çevirir. liste[-1] daha kısa ve okunaklıdır. Boş bir listede ikisi de IndexError verir; güvenli bir okuma için liste[-1:] dilimi boş liste döndürür.

Marka adları sahiplerine aittir. Bu yazı bağımsız bir teknik rehberdir; adı geçen kuruluşlarla bayilik veya ortaklık ilişkisi bulunduğu anlamına gelmez.

İlgili içerikler: Python öğrenme rehberi · Tuple ve unpacking · List comprehension · lambda ve sorted · collections modülü · for ve while döngüleri