• Elimizdeki verileri gruplamak bir yapı altında tutmak isteyebiliriz

• Mesela bir sınıftaki öğrencilerin notlarını tutmak istiyorum. 5 farklı öğrenci var, şimdiye kadar öğrendiklerimizle şöyle yapabilirdim:

ogrenci_1 = 78
ogrenci_2 = 80
ogrenci_3 = 43
ogrenci_4 = 65
ogrenci_5 = 90

• Bunların hepsi bir sınıftaki notları ifade ediyor. Bunları bir veri tipi olarak bir arada tutsak daha mantıklı olmaz mı?

• list veri tipi de tam burada devreye giriyor. Birden çok veriyi gruplayıp bir arada tutmak istediğimizde kullanabileceğimiz bir yapı

• listler belirtirken köşeli parantezle belirtiyoruz: [element1, element2,...].

• listler içsel yapı içerdikleri için non-scalar veri tipidir

• Elemanları arasına virgül koyarak farklı eleman belirtmeye başladığımı ifade ediyorum

notlar = [78, 80, 43, 65, 90]

# bunun aynısını şu şekilde de tutabilirdik:

notlar = [ogrenci_1, ogrenci_2, ogrenci_3, ogrenci_4, ogrenci_5]

• Bu oluşturduğumuz yapının ilk elemanı ilk öğrencinin notu, ikinci elemanı ikinci öğrencinin notunu belirtiyor (bu mantık böyle devam ediyor). Böylece öğrencilerin notlarını farklı 5 değişkende tutmak yerine bir veri tipi altında düzenli tutabilmiş olduk

• Nasıl ki stringlerde elemanlarına indexleme yaparak [0] gibi değerlerle ulaşabiliyorsak, listlerde de aynı

• notlar listesinin ilk elemanına ulaşmak için:

# ogrenci_1 in notu
notlar[0]

• listlerin içine istediğimiz veri tipini koyabiliriz. listleri sadece verilerimi içine koyduğumuz bir kutu olarak düşünün, listlerin tek yaptığı şey bunları bir arada tutmak. Elemanları istediğim veri objesi olabilir. int, float, string, hatta listler bile!

["a","b"]

[True, False]

[[1,2], [3,4,5]]

• Aynı list'in içine farklı tipte veri tipleri koyabiliriz

l = [1, 2, "a", "b", True, 4.5, [1,2,3]]

l

• String konusunda yaptığımız indexleme mantığı ve slicing mantığı tamamen listler için de geçerli

notlar

notlar[0]

notlar[-1]

notlar[10]

notlar[-1]

notlar[1:]

notlar[1:3]

notlar[:200]

notlar[:3000]

• Listler mutable veri tipleridir. Elemanlarını güncelleyebiliriz

notlar

• Diyelim ki ikinci öğrencinin notunu eksik okuduk. 5 puan yükseltmek istiyoruz:

notlar[1] += 5 # notlar[1] = notlar[1] + 5

notlar

• Birden çok elemanı da değiştirebiliriz

l = [1, 2, 3, 4]

l[0:3]

l[0:3] = 30, 40, 60

l

• Eşit sayıda vermemiz de gerekmez, l[0:3] olacak yere solda yazdığımız yazılır sadece

l[0:3] = 30, 40

l

l = [1, 2, 3, 4]

l[0:3] = 30

• Slicing in sonucuna tek bir değer yazacaksak bile direk tek olarak veremeyiz, iterable olması gerekir. Bunun ayrıntısını ileride göreceğiz şimdilik sol tarafı list olarak verebileceğimizi bilmeniz yeterli

l[0:3] = [30]

l

• Bize list'te kaç eleman olduğunu verir

l

len(l)

• İçine yazılan elemanı listenin sonuna ekler

l = [1,2,3]

l.append(200)

l

• İçine yazılan birden çok elemanı listenin sonuna ekler

l = [1,2,3]

l.extend([100,200,300])

l

• Belki list'in sonuna değil, spesifik bir indexine eleman eklemek istiyoruz. Bunu inser() ile yapabiliriz

l = [1, 2, 3, 4, 5]

l[0] = 100

l

l = [1, 2, 3, 4, 5]

l.insert(0, 100) # is not l[0] = 100

• eğer l[0] = 100 yazmış olsaydık, liste 100,2,3,4,5 e dönerdi, ama ben 1->100 dönüşümü yapmak istemiyorum, ilk indexe 100 ü eklemek istiyorum. l.insert(0,100) tam da istediğimi yapıyor. 0. indexe 100 değerini yazıyor ve 1 değerini sağa kaydırıyor, listeden silmemiş oluyor

l

l.insert(3,44)

l

• Belirli bir elemanı listeden silmemize yarar. Eğer yazılan eleman listede yoksa error verir

l = [1,2,3,4]

l.remove(40)

Bunu try-except ile çözebiliriz ama daha o konuyu görmedik. Yine de aşağıya kodu ekliyorum

try:
    l.remove(40)
except ValueError:
    pass
    

• remove() sadece ilk gördüğü değeri siler. l.remove(40) dersem ve listte 1 den çok 40 varsa ilk gördüğünü siler

l = [1,2,3,40,30,40]

l.remove(40)

l

• listenin belirli indexindeki elemanı silmeye ve o değeri döndürmeye yarar

• remove() sadece siliyordu, pop() aynı zamanda o değeri döndürüyor

l = [1,2,3,4,5,6]

# It deletes and return the value, remove() just removes it
l.pop(1)

l

l = [1,2,3,4,5,6]

l.pop(1) + 4

l

# out of range error
l.pop(100)

• count() un içine yazdığımız değerin listede kaç defa göründüğünü döndürür

l = [1, 2, 44, 4, 5, 1]

l.count(1)

l.count(44)

l.count(1000)

• Evet. Geldik olayların ilginç bir hal aldığı yere.

• Listeler bilgisayarın hafızasında integer, float gibi veri tiplerinin tutulduğundan biraz daha farklı tutuluyor.

• a = 2 dediğimiz zaman hafızada a adında bir kutucuk oluşturuluyor demiştik

a = 2

• a direkt o kutunun adı oluyor.

• Ama listelerde durum böyle değil. l = [1,2,3] gibi bir liste yarattığımızda, l kutunun adı değil, kutuyu işaret eden etiketin adı oluyor

l = [1,2,3]

• Bu farkın getirdiği bazı yan etkiler var

• Mesela kutunun adı direkt değişken adı olduğunda ve aşağıdaki işlemi yaptığımızda:

a = 2

b = a

b

a = a + 1

a

b

• a yı güncellesek de b güncellenmiyor. b sadece a kutusunun değerine eşit olmuş oldu, kutunun kendisine değil

• Aynısını listlerde yaptığımızda:

l = [1,2,3]

l2 = l

l

l2

l[0] = 200

l

l2

• l2 de güncellendi!

• Çünkü l2 = l dediğimizde l2, l etiketinin değerine eşit oldu, iki etikette aynı kutuyu, veri objesini gösteriyor, o yüzden listeyi güncellemem ikisine de yansıyor.

• Git aynı değerle başka bir kutucuk yarat ve oraya etiket ol diyerek güncellenmemesini sağlayabilirim

• Bunu copy() ile yapacağız

l2 = l.copy()

l

l2

l[0] = 300

l

l2

• + operatörü listlerde concatenation yapar

l = [1,2,3]

l2 = [4,5,6]

l

l2

l + l2

l

l2

l3 = l + l2

l3

l = [1, 2, 3, 4, 3, 5, 6]

l

# İlk hangi indexte görünüyorsa onun değerini döndürür
l.index(3)

l.index(4)

# listede olmayan değerler için error verir
l.index(100)

l = [1,2,3,4]

l.reverse() # inplace: yani l'yi günceller

l

l = [1,2,3,4]

• Aynısını slicing mantığı ile de yapabilirdik

l[::-1]

l

l3 = l[::-1]

l3

l

• Orijinalini güncellemiyor, variable assignment yapmamız lazım güncellemesi için

l = l[::-1]

l

• sorted() orijinal listeyi güncellemez

• sorted() ve .sort() a bakacağız. İkisi de default olarak küçükten büyüğe sıralar. Sayısal verilerde sayısal değerine göre, stringlerde alfabetik sıraya göre sıralar

l = ["b","a","c"]

sorted(l)

['a', 'b', 'c']

l

['b', 'a', 'c']

l3 = sorted(l)

l3

['a', 'b', 'c']

• .sort() günceller

l = ["b","a","c"]

l.sort() # inplace

l

['a', 'b', 'c']

l = [1,2,10,3,-1]

sorted(l)

[-1, 1, 2, 3, 10]

l

[1, 2, 10, 3, -1]

# küçükten büyüğe sıralar
l.sort()

l

[-1, 1, 2, 3, 10]

l = ["b","a","c","1","3","4"]

l.sort()

l

['1', '3', '4', 'a', 'b', 'c']

l = [1,3.1,2,0.6]

l.sort()

l

[0.6, 1, 2, 3.1]

l = ["b","a","c",1,2]

l.sort()

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-152-fb07ac7c73ab> in <module>
----> 1 l.sort()


TypeError: '<' not supported between instances of 'int' and 'str'

l = ["b","a","c","1","3.5","4","5.6", "0.6"]

l.sort()

l

['0.6', '1', '3.5', '4', '5.6', 'a', 'b', 'c']

l = [[1,-20,3], [2,-200,-3]]

l.sort()

l

[[1, -20, 3], [2, -200, -3]]

l = [[10,-20,-3], [2,-2,3]]

l.sort()

l

[[2, -2, 3], [10, -20, -3]]

l = [[10,-20,-3], [10,-25,3]]

l.sort()

l

[[10, -25, 3], [10, -20, -3]]

l = [["a", "b", "c"], [2,-200,-3]]

l.sort()

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-169-fb07ac7c73ab> in <module>
----> 1 l.sort()


TypeError: '<' not supported between instances of 'int' and 'str'

l

[['a', 'b', 'c'], [2, -200, -3]]

l = [[200, "b", "c"], [2,-200,-3,10]]

l.sort()

l

[[2, -200, -3, 10], [200, 'b', 'c']]

l = [[200, "b", "c"], [200,-200,-3,10]]

l.sort()

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-175-fb07ac7c73ab> in <module>
----> 1 l.sort()


TypeError: '<' not supported between instances of 'int' and 'str'