Python Listeleri, Python programlarında yaygın olarak kullanılan genel bir veri yapısıdır. Diğer dillerde genellikle dinamik diziler olarak adlandırılar. Her ikisi de kesilebilir ve indexlenebilirdirler. Ayrıca dilimlenebilir ve içerikleri değiştirilebilirler. Listeler, diğer liste nesneleri de dahil olmak üzere farklı nesne türlerini içerebilirler.
list belirli bir yineleme türüdür, ancak Python’da bulunan tek tür değildir. Bazen set, demet veya sözlük türlerini kullanmak daha iyi olabilir. list Python’da dinamik dizilere (C++’ta vector<void*> veya Java’da ArrayList<Object>‘e benzer) verilen addır.
List öğelerine erişim çok hızlıdır. Yeni öğelerin listenin sonuna eklenmesi bazen tüm listenin kopyalamasını gerektirir.
Sözdizimi
Liste öğelerine erişme
Python listeleri sıfır indexi ile başlar ve diğer dillerdeki diziler gibi davranır.
lst = [1, 2, 3, 4] lst[0] # 1 lst[1] # 2
Listenin sınırları dışında bir dizine erişmeye çalışmak bir IndexError hatası verir
lst[4] # IndexError: list index out of range
Negatif indeksler listenin sonundan itibaren sayım olarak yorumlanır.
lst[-1] # 4 lst[-2] # 3 lst[-5] # IndexError: list index out of range
Bu işlevsel olarak aşağıdakine eşdeğerdir
lst[len(lst)-1] # 4
Listeler dilim notasyonunu kullanmaya izin verir; liste[başlangıc:son:adım]. Dilim notasyonunun çıktısı, başlangıç indexinden son‘a öğeleri içeren yeni bir listedir. başlangıç, son ve adım değerleri verilmezse, varsayılan olarak başlangıç listenin başına, son listenin sonuna ve adım 1’e eşit olur.
lst[1:] # [2, 3, 4] lst[:3] # [1, 2, 3] lst[::2] # [1, 3] lst[::-1] # [4, 3, 2, 1] lst[-1:0:-1] # [4, 3, 2] lst[5:8] # [] başlangıç listenin uzunluğundan büyük olduğu için boş liste döndürür lst[1:10] # [2, 3, 4] son indexinin verilmemesi ile eşdeğerdir
Bunu göz önünde bulundurarak, dilimleme ile listenin ters çevrilen bir sürümünü yazdırabilirsiniz
lst[::-1] # [4, 3, 2, 1]
Negatif adım uzunlukları kullanırken başlangıç dizininin bitiş dizininden büyük olması gerekir, aksi takdirde sonuç boş bir liste olur.
lst[3:1:-1] # [4, 3]
Yukarıdaki negatif adım örneği aşağıdaki koda eşdeğerdir:
reversed(lst)[0:2] # 0 = 1 -1
# 2 = 3 -1Burada kullanılan indeksler, negatif indekslemede kullanılan indexlerden 1 daha azdır.
Gelişmiş dilimleme
Listeler dilimlendiğinde, __getitem__() yöntemi slice ile birlikte çağrılır. Python, dilim nesneleri oluşturmak için yerleşik bir dilim yöntemine sahiptir. Böylece dilimleri saklayabilir ve daha sonra yeniden kullanabiliriz.
data = 'chandan purohit 22 2000' name_slice = slice(0,19) age_slice = slice(19,21) salary_slice = slice(22,None) print(data[name_slice]) #chandan purohit print(data[age_slice]) #'22' print(data[salary_slice]) #'2000'
İç içe geçmiş listedeki değerlere erişme
Üç boyutlu bir listeyle başlayalım:
alist = [[[1,2],[3,4]], [[5,6,7],[8,9,10], [12, 13, 14]]]
Listedeki öğelere aşağıdaki gibi erişebiliriz:
print(alist[0][0][1]) # 2 # İlk listedeki ilk listenin ikinci öğesine ulaşır print(alist[1][1][2]) # 10 # İkinci listedeki ikinci listenin üçüncü öğesine ulaşır
Ekleme işlemlerinin gerçekleştirilmesi:
alist[0][0].append(11) print(alist[0][0][2]) # 11 # 11 öğesini ilk listedeki ilk listenin son öğesi olarak ekler
İç içe geçmiş listelerde listeyi yazdırma:
for sira in alist: #İç içe geçmiş listeleri döndürme yöntemlerinden biri
for sutun in sira:
print(sutun)
# [1, 2, 11]
# [3, 4]
# [5, 6, 7]
# [8, 9, 10]
# [12, 13, 14]Bu işlemin verimlilik düşünüldüğünde bir liste üreteci veya bir generator üretmek için de kullanılabileceğini de unutmayın, örneğin:
[sutun for sira in alist for sutun in sira] # [[1, 2, 11], [3, 4], [5, 6, 7], [8, 9, 10], [12, 13, 14]]
Dış listelerdeki tüm öğelerin kendilerinin de liste olması gerekmez:
alist[1].insert(2, 15) # 15 öğesini ikinci listedeki üçüncü konuma yerleştirir
İç içe geçmiş döngüleri kullanmanın başka bir yolu da aşağıdaki gibidir. Diğer yollar daha iyi olsa da zaman zaman aşağıdakini de kullanmak gerekebilir:
for sira in range(len(alist)): #Liste döndürmenin daha az Pythonic yolu
for sutun in range(len(alist[sira])):
print(alist[sira][sutun])
# [1, 2, 11]
# [3, 4]
# [5, 6, 7]
# [8, 9, 10]
# 15
# [12, 13, 14]İç içe geçmiş listede dilimlemeyi kullanma:
print(alist[1][1:]) # [[8, 9, 10], 15, [12, 13, 14]]
Dilimlemeden sonraki son liste:
print(alist) # [[[1, 2, 11], [3, 4]], [[5, 6, 7], [8, 9, 10], 15, [12, 13, 14]]]
Listenin uzunluğu
Listenin tek boyutlu uzunluğunu almak için len() kullanabiliriz:
len(['one', 'two']) # çıktı: 2 len(['one', [2, 3], 'four']) # çıktı 3 olacaktır, 4 değil
len() ayrıca dizeler, sözlükler ve listelere benzer diğer veri yapıları üzerinde de çalışır.
len()‘in liste nesnesinin bir yöntemi değil de, yerleşik bir işlev olduğunu unutmayın.
Ayrıca, len()‘i çağırmanın maliyetinin O(1) olduğunu, yani uzunluğuna bakılmaksızın herhangi bir listenin uzunluğunu almanın aynı miktarda zaman alacağını unutmayın.
Bir Listeyi Sabit Sayıda Öğe ile Başlatma
Değişmez öğeler için (örneğin, None veya dize değişmez değerleri gibi):
my_list = [None] * 10 my_list = ['test'] * 10
Değiştirilebilir öğeler için aynı yapı kullanıldığında, listenin tüm öğeleri aynı nesneye, örneğin bir kümeye işaret eder:
>>> my_list=[{1}] * 10
>>> print(my_list)
[{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}]
>>> my_list[0].add(2)
>>> print(my_list)
[{1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}]Yukarıda 2 öğesini listenin sadece birinci öğesine eklemek istesek de, tüm öğeler aynı nesneye işaret ettikleri için 2 öğesi tüm öğelerde göründü.
Bunun yerine, listeyi sabit sayıda farklı değiştirilebilir nesneyle başlatmak için aşağıdakini kullanabiliriz:
my_list=[{1} for _ in range(10)]Liste öğelerini tersine çevirme
reversed işlevi listeyi tersine döndürür ve yinelenebilen bir nesne döndürür.
In [3]: rev = reversed(sayi) In [4]: rev Out[4]: [9, 8, 7, 6, 5, 4, 3, 2, 1]
“sayi” listesinin bu işlem tarafından değişmediğini ve başlangıçta olduğu gibi kaldığını unutmayın.
Ayrıca, dilimlemeyi kullanarak da listeyi tersine çevirebilirsiniz (aslında bir kopya elde ederiz ve özgün liste etkilenmez) :
In [1]: sayi = [1, 2, 3, 4, 5, 6, 7, 8, 9] In [2]: sayi[::-1] Out[2]: [9, 8, 7, 6, 5, 4, 3, 2, 1]
Listenin boş olup olmadığını denetleme
Bir listenin boş olup olmaması boolean ile ilişkilidir. Bu nedenle listenin uzunluğunu, len(lst) == 0, kontrol etmek zorunda kalmazsınız. Sadece lst veya not lst yapmak yeterrlidir:
lst = []
if not lst:
print("list boş")
# Çıktı: liste boşListe üzerinde yineleme
Python, listede doğrudan bir for döngüsü kullanmayı destekler:
my_list = ['foo', 'bar', 'baz']
for oge in my_list:
print(oge)# Çıktı: foo # Çıktı: bar # Çıktı: baz
Her öğenin konumunu da aynı anda enumerate ile alabilirsiniz:
for (konum, oge) in enumerate(my_list):
print('Öğe pozisyonu {}, öğe: {}'.format(konum, oge))
# Çıktı: Öğe pozisyonu 0, öğe: foo
# Çıktı: Öğe pozisyonu 1, öğe: bar
# Çıktı: Öğe pozisyonu 2, öğe: bazDizin değerine göre listeyi yinelemenin diğer bir yolu da aşağıdaki gibi olabilir:
for i in range(0,len(my_list)):
print(my_list[i])
#Çıktı:
>>>
foo
bar
bazListedeki öğeleri yineleme yaparken değiştirmenin beklenmeyen sonuçlara neden olabileceğini unutmayın:
for oge in my_list:
if oge == 'foo':
del my_list[0]
print(oge)
# Output: foo
# Output: bazBu son örnekte, yineleme yaparken ilk öğeyi sildik, ancak bu ikinci öğenin, bar, atlanmasına neden oldu.
Listelerin karşılaştırılması
Karşılaştırma işleçleri ile listeleri ve diğer dizileri sözlüksel olarak karşılaştırmak mümkündür. Ancak, her iki işlenen öğe de aynı türde olmalıdır.
[1, 10, 100] < [2, 10, 100] # True, çünkü 1 < 2 [1, 10, 100] < [1, 10, 100] # False, çünkü listeler eşit [1, 10, 100] <= [1, 10, 100] # True, çünkü listeler eşit [1, 10, 100] < [1, 10, 101] # True, çünkü 100 < 101 [1, 10, 100] < [0, 10, 100] # False, çünkü 0 < 1
Listelerden biri diğerini kapsıyorsa, en kısa liste kazanır.
[1, 10] < [1, 10, 100] # True
Listeleri birleştirme ve birbirine ekleme
+ operatörü
Birleştirmenin en basit yolu:
merged = list1 + list2
zip
zip bir demete (tuple) döndürür. Döndürülen demetlerde n. sıradaki demet, birinci listenin n. öğesini ve ikinci listenin n. öğesini içerir.
alist = ['a1', 'a2', 'a3']
blist = ['b1', 'b2', 'b3']
for a, b in zip(alist, blist):
print(a, b)
# çıktı:
# a1 b1
# a2 b2
# a3 b3Listelerin uzunlukları farklıysa, çıktı yalnızca en kısa öğe kadar öğe içerir:
alist = ['a1', 'a2', 'a3']
blist = ['b1', 'b2', 'b3', 'b4']
for a, b in zip(alist, blist):
print(a, b)
# Çıktı:
# a1 b1
# a2 b2
# a3 b3
alist = []
len(list(zip(alist, blist)))
# Çıktı:
# 0
Kısa olan listelere None öğesi ekleyerek beslemek istiyorsak `itertools.zip_longest` kullanabiliriz. (Python 2'de `itertools.izip_longest`)
alist = ['a1', 'a2', 'a3']
blist = ['b1']
clist = ['c1', 'c2', 'c3', 'c4']
for a,b,c in itertools.zip_longest(alist, blist, clist):
print(a, b, c)
# Çıktı:
# a1 b1 c1
# a2 None c2
# a3 None c3
# None None c4.insert()
Belirli bir dizin değerlerine ekleme:
alist = [123, 'xyz', 'zara', 'abc']
alist.insert(3, [2009])
print("Final List :", alist)Çıktı:
Final List : [123, 'xyz', 'zara', 2009, 'abc']
Listedeki yinelenen değerleri kaldırma
Bir listedeki yinelenen değerleri kaldırmak, listeyi bir set‘e (nesnelerin sıralanmamış bir koleksiyonu) dönüştürerek yapılabilir. Sonuçta bir list yapısına ihtiyaç duyulursa, set tekrar list() işlevi kullanılarak bir listeye geri dönüştürülebilir:
names = ["aixk", "duke", "edik", "tofp", "duke"] list(set(names)) # Çıktı: ['duke', 'tofp', 'aixk', 'edik']
Bir listeyi sete dönüştürdüğünüzde orijinal sıralamanın kaybolduğunu unutmayın.
Listenin sırasını korumak için OrderedDict kullanılabilir:
import collections >>> collections.OrderedDict.fromkeys(names).keys() # Çıktı: ['aixk', 'duke', 'edik', 'tofp']
Python listelerde Any ve All fonksiyonları
Listedeki tüm öğelerin True olarak değerlendirilip değerlendirilmeyeceğini belirlemek için all() metodunu kullanabiliriz:
nums = [1, 1, 0, 1] all(nums) # False chars = ['a', 'b', 'c', 'd'] all(chars) # True
Aynı şekilde, bir veya daha fazla öğenin True olarak değerlendirilip değerlendirilmediğini any() belirler:
nums = [1, 1, 0, 1] any(nums) # True vals = [None, None, None, False] any(vals) # False
Yukarıdaki örneklerde yinelenebilir olarak bir liste kullandık. Ancak, any() ve all() üreteçler de dahil olmak üzere herhangi bir yinelemeyle de çalışır:
vals = [1, 2, 3, 4] any(val > 12 for val in vals) # False any((val * 2) > 6 for val in vals) # True
Liste metotları ve desteklenen işleçler
Bir a listesiyle başlayalım:
a = [1, 2, 3, 4, 5]
append(değer)
listenin sonuna yeni bir öğe ekler.
# Append 6, 7, ve 7'yi listenin sonuna ekler a.append(6) a.append(7) a.append(7) # a: [1, 2, 3, 4, 5, 6, 7, 7] # Diğer bir listeyi listeye ekler b = [8, 9] a.append(b) # a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]] # Farklı türden bir öğeyi listeye ekler, liste öğelerinin aynı türden olmasına gerek yoktur my_string = "hello world" a.append(my_string) # a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9], "hello world"] **Not: `append()` metodu listenin listenin sonuna sadece bir öğe ekler. Eğer eklediğimiz öğe de bir listeyse, bu eklenen öğe tek bir liste öğesi olarak eklenir. # Listeye liste öğesi ekleme a = [1, 2, 3, 4, 5, 6, 7, 7] b = [8, 9] a.append(b) # a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]] a[8] # Çıktı: [8,9]
extend(sıralanabilir_tür)
başka bir sıralandırılabilir öğeyi alarak listeyi genişletir.
a = [1, 2, 3, 4, 5, 6, 7, 7] b = [8, 9, 10] # b'deki öğeleri a'ya ekler a.extend(b) # a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10] # liste olmayan sıralanabilir bir türü alarak listeyi genişletir: a.extend(range(3)) # a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10, 0, 1, 2] Listeler aynı zamanda `+` operatörü ile de birbirlerine eklenebilirler. Bu orijinal listeyi değiştirmez: a = [1, 2, 3, 4, 5, 6] + [7, 7] + b # a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
index(değer, [başlangıç_indexi])
değer parametresinin listedeki ilk karşılığının indexini alır. değer listede yoksa, bir ValueError özel durum hatası oluşturur. İkinci bir bağımsız değişken sağlanırsa, arama belirtilen dizinde başlatılır.
a.index(7) # Çıktı: 6 a.index(49) # ValueError, 49 a listesinde yok. a.index(7, 7) # Çıktı: 7 a.index(7, 8) # ValueError, 8. indexten itibaren 7 değeri yok
insert(index, değer)
insert(index, değer)belirtilen değeri belirtilen indexten hemen öncesine ekler. Böylece eklemeden sonra yeni öğe index konumunda olur kaplar.
a.insert(0, 0) # 0 değerini 0. pozisyonna ekler a.insert(2, 5) # 5 değerini 2. pozisyona ekler # a: [0, 1, 5, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
pop([index])
index’deki öğeyi kaldırır ve döndürür. Bağımsız değişken index verilmezse listenin son öğesini kaldırır ve döndürür.
a.pop(2) # Çıktı: 5 # a: [0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10] a.pop(8) # Çıktı: 7 # a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] a.pop() # Çıktı: 10 # a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
remove(değer)
belirtilen değerin ilk karşılığını kaldırır. Sağlanan değer bulunamazsa, ValueError hatası verir
a.remove(0) a.remove(9) # a: [1, 2, 3, 4, 5, 6, 7, 8] a.remove(10) # ValueError, 10 listede yok
reverse()
listeyi yerinde tersine çevirir ve None döndürür.
a.reverse() # a: [8, 7, 6, 5, 4, 3, 2, 1] Not: Bir listeyi tersine çevirmenin başka yolları da bulunur.
count(değer)
listedeki değerden kaç tane olduğunu sayar.
a.count(7) # Çıktı: 2
sort()
listeyi sayısal ve sözcükbilimsel olarak sıralar ve None döndürür.
a.sort() # a = [1, 2, 3, 4, 5, 6, 7, 8] # listeyi sıralar
Listeler, ‘sort()’ yönteminde paramatre olarak ‘reverse=True’ ile sıralanırsa sıralama tersine çevrilebilir.
a.sort(reverse=True) # a = [8, 7, 6, 5, 4, 3, 2, 1]
Öğelerin özniteliklerine göre sıralamak istiyorsanız ‘key’ anahtar sözcüğünü kullanabilirsiniz:
import datetime
class Person(object):
def __init__(self, name, birthday, height):
self.name = name
self.birthday = birthday
self.height = height
def __repr__(self):
return self.name
l = [Person("John Cena", datetime.date(1992, 9, 12), 175),
Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
Person("Jon Skeet", datetime.date(1991, 7, 6), 185)]
l.sort(key=lambda item: item.name)
# l: [Chuck Norris, John Cena, Jon Skeet]
l.sort(key=lambda item: item.birthday)
# l: [Chuck Norris, Jon Skeet, John Cena]
l.sort(key=lambda item: item.height)
# l: [John Cena, Chuck Norris, Jon Skeet]Dict listesi olduğunda da benzer şey söz konusudur. Her ne kadar dict ile liste farklı veri türleri olsa da, dict için de bir örnek verelim:
import datetime
l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'height': 175},
{'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'height': 180},
{'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'height': 185}]
l.sort(key=lambda item: item['name'])
# l: [Chuck Norris, John Cena, Jon Skeet]
l.sort(key=lambda item: item['birthday'])
# l: [Chuck Norris, Jon Skeet, John Cena]
l.sort(key=lambda item: item['height'])
# l: [John Cena, Chuck Norris, Jon Skeet]alt dict öğelerine göre sıralama :
import datetime
l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'size': {'height': 175, 'weight': 100}},
{'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'size' : {'height': 180, 'weight': 90}},
{'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'size': {'height': 185, 'weight': 110}}]
l.sort(key=lambda item: item['size']['height'])
# l: [John Cena, Chuck Norris, Jon Skeet]attrgetter ve itemgetter kullanarak sıralamanın daha iyi yolu:
Listeler, operatör modülündeki işlevler kullanılarak da sıralanabilir. Bu yöntem okunabilirliği ve yeniden kullanılabilirliği artırmaya yardımcı olabilir.
from operator import itemgetter,attrgetter
people = [{'isim':'chandan','yaş':20,'maaş':2000},
{'isim':'chetan','yaş':18,'maaş':5000},
{'isim':'guru','yaş':30,'maaş':3000}]
yasa_gore = itemgetter('yaş')
maasa_gore = itemgetter('maaş')
people.sort(key=yasa_gore)
people.sort(key=maasa_gore) itemgetter‘a ayrıca bir index’de verilebilir. Böylece bir dizinin indexlerine göre sıralama yapabiliriz.
list_of_tuples = [(1,2), (3,4), (5,0)] list_of_tuples.sort(key=itemgetter(1)) print(list_of_tuples) #[(5, 0), (1, 2), (3, 4)]
Bir nesnenin özniteliklerine göre sıralamak istiyorsanız attrgetter kullanabiliriz:
persons = [Person("John Cena", datetime.date(1992, 9, 12), 175),
Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
Person("Jon Skeet", datetime.date(1991, 7, 6), 185)] #yukarıdaki Person classını tekrar kullanıyoruz
person.sort(key=attrgetter('name')) #isme göre sırala
by_birthday = attrgetter('birthday')
person.sort(key=by_birthday) #birthday'e göre sıralaclear()
listedeki tüm öğeleri siler
a.clear() # a = []
Çoğaltma
varolan bir listeyi tamsayı ile çarpmak, özgün öğenin tamsayı kadar çok kopyasından oluşan daha büyük bir liste oluşturur:
b = ["şey"] * 3 # b = ["şey", "şey", "şey"] b = [1, 3, 5] * 5 # [1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5]
Öğe silme
del anahtar sözcüğü ve dilim notasyonunu kullanarak listedeki birden çok öğeyi silmek mümkündür:
a = list(range(10)) del a[::2] # a = [1, 3, 5, 7, 9] del a[-1] # a = [1, 3, 5, 7] del a[:] # a = []
Kopyalama
b = aYukarıdaki gibi bir işlemde, varsayılan atama işareti, “=”, özgün listenin referansını yeni isme atar. Bu şekilde: eski ad ve yeni ad aynı liste nesnesine işaret eder. Bunlardan herhangi biri aracılığıyla yapılan değişiklikler diğerine de yansıtılır. Bu çoğu zaman istediğiniz şey olmayabilir.
b = a
a.append(6)
# b: [1, 2, 3, 4, 5, 6]Listenin bir kopyasını oluşturmak istiyorsak:
Dilimleyebilirsiniz:
new_list = old_list[:]
Yerleşik list() işlevini kullanabilirsiniz:
new_list = list(old_list)
copy.copy():
import copy
new_list = copy.copy(old_list) Bu list()’e göre biraz daha yavaştır, çünkü önce old_list veri türünü bulması gerekir. Liste nesneler içeriyorsa ve bunları da kopyalamak istiyorsanız, copy.deepcopy() kullanmalısınız:
import copy new_list = copy.deepcopy(old_list)
Açıkçası en yavaş ve en çok hafızaya ihtiyaç duyan yöntem budur, ama bazen kaçınılmaz olabilir.
copy() – Listenin sığ bir kopyasını verir
aa = a.copy() # aa = [1, 2, 3, 4, 5]