Python Programlama Dili

Bölüm 3

Veri Tipleri

Top Navigasyon

Ders 17

3 - Veri Tipleri

Python programlama dilinde, veri tipleri çok çeşitlidir. Python dokümentasyonu, başlıca veri tiplerini, numerics (sayısal) , sequences (sekans), mappings, classes (sınıf), instances (sınıf örneği) and exceptions (istisna) lar olarak tanımlar. Bu çalışmada, sadece çok kullanılan sayısal, sözel, sekansiyel tiplerde veri tanımaya çalışacağız. Sınıf, sınıf örneği, istisna tipi verileri daha önce tanımış durumdayız.

Sayısal veri tipleri, int (tamsayı), float (gerçel sayı), complex (kompleks sayı) veri tipleridir. Bunlar üzerinde çeşitli uygulamalar yapmış durumdayız.

Sekansiyel veri tipleri, string (sözel), list (liste), tuple (topluluk), dictionary (sözlük), set (küme), frozenset (donmuş küme) veri tipleridir.

Python programlama dilinin sayısal, sözel, topluluk ve donmuş küme veri tipleri, bir kez atandıktan sonra kısmen değiştirilemeyen (immutable) veri tipleridir. Bu tip veriler bir kez atandıktan sonra, değiştirmek istenirse, verinin tümü tahrip edici yöntemle silinip yeniden atanmalıdır.

Sekansiyel veri tipleri, liste (list), topluluk (tuple), sözlük (dictionary), küme (set9 ve donmuş küme (frozenset) tipi veriler, birbiri ardına (contigious) yerleştirilmiş veri yığınları (aglomerat) lardır. Bu veri yığınlarını oluşturan ve değişik tipte olabilen veriler, bu aglomeratların elemanları olarak adlandırılır. Veri aglomeratlarının elemanları birbiri ardınca (sekansiyel) olarak taranarak üzerlerinde işlem yapılabilir. Bu yönteme "iterasyon", üzerinde iterasyon yapılabilen veri tiplerine, "iterasyon yapılabilen (iterable)" veri tipleri adı verilir. Tüm aglomerat tipi veriler, üzerlerinde iterasyon yapılabilen veri tipleridir. Buna bir de kısmen değiştirilemeyen bir veri tipi olan sözel (string) veri tipi eklenir. özel veriler, sıralı olarak yerleştirilmiş karakterlerden oluşur. Bu karakterlerin sıralı nitelikleri, bunlar üzerinde iterasyon yapılabilmesine olanak sağlar.

Bu bölümde, sözel ve diğer sıralı verilerin elemanlarına teker teker ve sıralı erişim (traversal) (iterasyon), güncellenebilen tiplerin, güncellenme yöntemleri üzerinde duracağız. Elde edeceğimiz bilgiler, her türlü projenin gerçekleştirilmesine olanak verecek nitelikte olacaktır.

3.1 -Liste Tipi Veriler

Liste tipi veriler, değişik tipte verilerin birbiri ardında (sekansiyel) (contigious) olarak sıralandığı ve elemanlarına indeks sayıları ile erişilebildiği (indeks değerleri ile sıralı erişim) (indexed sequential access) tipi verilerdir. Liste tipi verilerin elemanları her veri tipinde olabilir. Eleman değerleri belirli bir düzende sıralanmamışır ama homojen elemanlı listelerin sıralanmasına olanak sağlanmıştır.

Listeler köşeli, topluluklar normal parantez arasında gösterilir. Elemanların erişim indisleri sıfırdan başlar. Elemanlar her veri tipinde olabilir. Bunlara sekansiyel veri tipleri de dahildir. Bazı liste örnekleri aşağıda görülmektedir.

[1, 2, 3, 4]    

["Çamlıca", 2, "Dolmabahçe", 1]    

[24, 11, [36,12,83], 24]

Liste ve topluluk tipi veriler, diğer programlama dillerindeki dizilere benzer. Elemanlardan bazıları liste veya başka bir aglomerat (yığın) tipinde olursa, bunlar iki boyutlu dizilere denk gelir. Buna rağmen, günümüzde nesne yönelimli programlama çok gelişmiş olduğundan, iki ve daha çok boyutlu diziler yerine nesne sınıfları kullanılmaktadır. Bu çalışmada, örneklerimizde sadece tek boyutlu liste verileri üzerinde duracağız.

3.1.1 -Liste Tipi Verilerin İndekslenmesi

İndeksleme yöntemi, sadece liste tipi veriler için değil, tüm iterasyon yapılabilien veri tipleri (String, List, Tuple, Dict, Set, Frozenset) için aynıdır.İndeksleme, verinin ilk elemanının indisi 0 olarak başlar. Her elemanda bir artarak son elemana kadar gider. İndisler son elemandan da başlayabiir. Son elemanın indisi -1 olarak kabul edilir ve sondan birinci, -2, sondan ikinci -3, birer eksilerek ilk elemana kadar iner.

Bir liste örneği,

liste = ['birinci', 'ikinci', 'üçüncü', 'dördüncü']

olarak tanımlanmış olsun. Tüm iterasyona uygun veri tipleri için eleman sayısı yani veri uzunluğu (length), len() hazır fonksiyonundan yararlanılarak bulunabilir. Bu listede eleman sayısı len = 4 dür. Maximum indis sayısı imax = (n-1) = 4 olarak hesaplanır. ilk elemanın erişim indisi, i = 0 dır. İlk elemana erişim liste[0] olarak gerçekleştirilir. Diğer elemanlara erişim, aynı ilk elemana erişim gibidir. Aşağıdaki tablo, bu liste örneğinde indis değerlerinin dağılımını açıklamaktadır.

İndis Değerleri
Liste Elemanı	'birinci'	'ikinci'	'üçüncü'	'dördüncü'
Pozitif İndis	0	1	2	3
Negatif İndis	-4	-3	-2	-1

3.1.2 - Listelerin Güncellenmesi

Liste elemanlarının bir kısmı, listeden çıkartılabilir. Örnek olarak,

d = [1, 2, 3, 4]

listesi tanımlanmış olsun,

d[1:-1]

bildirimi, d listesinin indisi 1 olan elemanı (2) (dahil) ile indisi -1 olan elemandan bir önceki eleman (3) (dahil) arasındaki tüm elemanları içeren bir alt listenin belleğe alındığını belirtir. Bu bildirim ile orijinal d listesi değişmemiştir. Belleğe alınmış olan alt liste başka herhangibir liste verisine atanabileceği gibi, rekürsif olarak kendi kendisine de atanabilir. Bu şekilde,

d = d[1:-1]

bildirimi, orijinal d listesini günceller ve d listenin yeni değeri,

[2, 3]

olur.

Aşağıdaki tablo, çeşitli alt liste oluşturma işlemleri sonunda, oluşan alt listeleri açıklamaktadır.

Alt Listelerin Oluşturulması
İşlem Sıra Numarası	d Listesinin Elemanları	Alt Liste Oluşturma İşlemi	b Listesinin Elemanları
1	1, 2, 3, 4	b = d[1:-1]	2, 3
2	1, 2, 3, 4	b = d[0:4]	1, 2, 3, 4
3	1, 2, 3, 4	b = d[0:5]	1, 2, 3, 4
4	1, 2, 3, 4	b = d[0:]	1, 2, 3, 4
5	1, 2, 3, 4	b = d[:-1]	1, 2, 3
6	1, 2, 3, 4	b = d[0:-1]	1, 2, 3
7	1, 2, 3, 4	b = d[-2:-1]	3
8	1, 2, 3, 4	b = d[-1:2]	[]
9	1, 2, 3, 4	b = d[0:3]	1, 2, 3
10	1, 2, 3, 4	b = d[:3]	1, 2, 3
11	1, 2, 3, 4	b = d[:]	1, 2, 3, 4
12	1, 2, 3, 4	b = d[0:len(d)-1]	1, 2, 3

İşlem 1 :  d[n:m] , n = 1 , m = -1
İlk indis değeri :  1
Alt listenin ilk elemanı : d[1] (d[1] =2)
Son indis değeri : -1
Alt listenin son elemanı : d[-1-1] = d[-2] (d[-2] = 3)
Alt liste = [2, 3]

Not : Burada, elemanların indis değerleri geçerli, alt liste oluşturma bildirimi, " indis değeri 1 olan liste elemanından başlayarak, indis değeri -1-1 =-2 (dahil) aralığındaki elemanları içeren bir alt liste oluştur" şeklindedir. Eleman indislerinin pozitif veya negatif olarak belirtilmesi önemli değildir. Önemli olan, pozitif indisler olarak, listenin başlangıç değerinin küçük, listenin bitiş elemanının büyük indis değerine sahip olmasıdır. Aksi halde boş bir alt liste oluşur. (İşlem 8 de olduğu gibi)

İşlem 2 :  d[n:m] , n = 0 , m = 4
İlk indis değeri : 0
Alt listenin ilk elemanı : d[0] (d[0] =1 )
Son indis değeri : 4.
Alt listenin son elemanı : d[4-1] = d[3] (d[3] = 4)
Alt liste = [1, 2, 3, 4]

Not : Listenin eleman sayısı len(d) = 4, enbüyük indis = len(d) -1 = 4 - 1 = 3 olmasına karşın, alt listenin en büyük indisi, 4 olarak belirtilmiş. Bu değer, orijinal listenin en son elemanının indisinden daha büyük olmasına karşın, yasal bir değerdir ve alt listenin en büyük elemanının orijinal listenin en büyük elemanı olmasını sağlar. Son indis değeri olarak daha büyük değerler de kullanılabilir, fakat hepsinin etkisi aynıdır. Yani, son indis değeri olarak, listedeki en yüksek indis değerinden daha yüksek bir indis belirtilirse, alt listenin en son elemanı, orijinal listenin en son elemanı olur.

İşlem 3 :  d[n:m] , n = 0 , m = 5
İlk indis değeri : 0
Alt listenin ilk elemanı : d[0] (d[0] =1 )
Son indis değeri : 5
Alt listenin son elemanı : d[5-1] = d[4] (Listenin
en büyük indisinden daha büyük)
Alt liste = [1, 2, 3, 4]

Not : Aynı durum burada da görülüyor. Bu sefer daha da büyük indis belirtilmiş fakat sonuç aynı olmuştur.

İşlem 4 :  d[n:] , n = 0 
İlk indis değeri : 0
Alt listenin ilk elemanı : d[0] (d[0] =1 )
Son indis değeri: yok
Alt listenin son elemanı : d listesinin son elemanı d[3] = 4
Alt liste = [1, 2, 3, 4]

Not : Burada d[n:] şeklinde belirtilen alt dizi oluşturma yönteminde, n değeri alt listenin ilk elemanının seçiminde belirleyici olur. Alt listenin son elemanı bu durumda, daima orijinal listenin son elemanı olur.

İşlem 5 :  d[:-1] , m = -1 
İlk indis değeri : yok
Alt listenin ilk elemanı : d[0] (d[0] = 1 )
Son indis değeri: -1
Alt listenin son elemanı : d listesinin son elemanı d[-1] = 4
Alt liste = [1, 2, 3, 4]

Not : Burada d[:m] şeklinde belirtilen alt dizi oluşturma yönteminde, m değeri sadece alt listenin son elemanının seçiminde belirleyici olur. Alt listenin ilk elemanı, daima orijinal listenin ilk elemanı olur.

İşlem 6 :  d[n:m] , n=0 m = -1 
İlk indis değeri : 0
Alt listenin ilk elemanı : d[0] (d[0] = 1 )
Son indis değeri: -1
Alt listenin son elemanı : d listesinin sondan ikinci elemanı d[-1 -1] = d[-2] (d[-2] = 3)
Alt liste = [1, 2, 3]

Not : Alt dizi elemanları, indis sayıları n (dahil) ve m-1 (dahil)arasında kalan elemanlardan oluşur. Burada bu elemanlar, indis değerleri, d[0] (dahil) ile d[-2] (dahil) arasında kalan 1, 2, 3 elemanlarıdır.

İşlem 7 :  d[n:m] , n=-2 m = -1 
İlk indis değeri : -2
Alt listenin ilk elemanı : d[-2] (d[-2] = 3 )
Son indis değeri: -1
Alt listenin son elemanı : d listesinin sondan ikinci elemanı d[-2] = 3
Alt liste = [3]

Not : Burada d[0:-1] şeklinde belirtilen alt dizi oluşturma yönteminde, alt liste elemanları n(dahil)...m-1(dahil) arasında olur. Burada indis değerleri 0 ile -1 -1 = -2 olan, d[0] ... d[-2] arasında olan elemanlar, yeni alt diziyi oluşturacaklardır. Burada, alt liste sadece bir elemandan oluşuyor. Alt lisye girecek olan eleman, orijinal listenin sondan ikinci elemanı olan 3 dür.

İşlem 8 :  d[n:m] , n=-1 m = 2 
İlk indis değeri : -1
Alt listenin ilk elemanı : d[-1-1 = -2] (d[-2] = 3 )
Son indis değeri: 2
Alt listenin son elemanı : d listesinin son elemanı d[2] = 3
Alt liste = []

Not : Burada Alt listenin başlangıç elemanı ile son elemanının indisleri aynı, yanibir aralık tanımlanmıyor. Python derleyicisi bu durumda alt listenin hiç eleman olmadan açılmasını öngörüyor.

İşlem 9 :  d[n:m] , n=0 m = 3 
İlk indis değeri : 0
Alt listenin ilk elemanı : d[0] (d[0] = 1 )
Son indis değeri: 3
Alt listenin son elemanı : m=3, son indis = m-1 = 3-1 = 2
                           son eleman = d[2] = 3
Alt liste = [1, 2, 3]

Not :Alt liste d listesinin, indis değerleri 0 (dahil) ile (3-1 = 2) dahil arasındaki elemanlarını içeriyor. Orijinal d listesinin, indis değerleri 0, 1, 2 olan, 1, 2, 3 elemanları, alt llisteyi oluştuyor.

İşlem 10 :  d[n:m] , m = 3 
İlk indis değeri : yok
Alt listenin ilk elemanı : d[0] (d[0] = 1 )
Son indis değeri: 3
Alt listenin son elemanı : d[3-1] = d[2] (d[2] = 3)
Alt liste = [1, 2, 3]

Not : Burada d[:m] şeklinde belirtilen alt dizi oluşturma yönteminde, m değeri alt listenin sadece son elemanının seçiminde belirleyici olur. Alt listenin son elemanı bu durumda, orijinal listenin sondan ikinci elemanı olacaktır. Bu yöntemle, alt listenin ilk elemanı, daima orijinal listenin ilk elemanı olur.

İşlem 11 :  d[:]  
İlk indis değeri : yok
Alt listenin ilk elemanı :  d listesinin ilk elemanı  1
Son indis değeri: yok
Alt listenin son elemanı : d listesinin son elemanı  4
Alt liste = [1, 2, 3, 4]

Not : Burada d[:] şeklinde belirtilen alt liste oluşturma yönteminde, orijinal listenin tüm elemanları, yeni alt dizinin elemanları olur. Bu yöntem bir listeyi başka bir değişkene kopyalamak için kullanışlı bir yöntemdir.

İşlem 12 :  d[n:m] , n=0 m = len(d)-1 
İlk indis değeri : 0
Alt listenin ilk elemanı : d[0] (d[0] = 1 )
Son indis değeri: len(d) = 4 (listenin uzunluğu = listenin eleman sayısı = 4
                           len(d)-1 = 4-1 = 3
Alt listenin son elemanı : d listesinin sondan ikinci elemanı d[3] = 3
Alt liste = [1, 2, 3]

Not : len() hazır bir Python fonksiyonudur. Bu fonksiyon ile tüm iterasyon yapılabilen veri tiplerinin eleman sayılarının saptanması olasıdır. Bu fonksiyondan yararlanılarak, listelerden alt listeler oluşturulmasında, yukarıdaki örnekte görüldüğü gibi, indis belirtilmesi yapılabilir.

Listenin bir elemanına erişmek için, elemanın listedeki yerini belirten indis değerinden yararlanılabilir. Bu elemanı listeden çıkarmak, del bildirimi ile gerçekleştirilebilir. Aşağıdaki program bu işlemi görüntülemektedir.

        
# -*- coding: utf-8 -*-
# ders17program1.py

liste = [12, 23, 'Özel Giyim', '0 416 311 89 56', 4, 2]

del (liste[4]) # liste[-2]  aynı elemana işaret eder!

print(liste)

---------Program----Sonucunun----Görüntülenmesi-----------------------
[12, 23, 'Özel Giyim', '0 416 311 89 56', 2]

Görüldüğü gibi, listenin 4 üncü, yani sondan ikinci elemanı, listeden çıkarılmış ve liste isimli liste tipi değişkenin değeri güncellenmiştir.

Listelerin güncellenmesi, Python programlama dilinde, diğer program dillerine göre alışılmamış bir yöntem uygulanarak da gerçekleştirilebilir. Bu yöntem, atama işlemcisinin sol tarafına liste değişkeninin yerleştirilmesidir. Bu şekilde, aşağıdaki işlemler gerçekleştirilebilir.

Listeye Eleman Eklenmesi

    
>>>listeA = [12, 2, 5, 45, 47]
>>>listeA[4] = 35
>>>listeA
>>>[12, 2, 5, 45, 35]

Görüldüğü gibi, basit tek bir atama ile, ListeA liste tipi değişkenden en son eleman çıkarılmış ve yerine yeni bir eleman eklenmiştir. Bu işlem, tahrip edici bir rekürsif atama değildir. Yani, listeA nın değeri olan hex bellek işaretçisi, f değişkenine aktarıldıktan sonra, gerek f gerekse listeA değişkenleri aynı bellek alanına işaret eder duruma gelmişlerdir. Yukarıda uygulanan yöntemle, eleman ekleme işlemi, bir tahrip edici rekürsif atama değildir. Yani, listeA değişkeni, atama işlemcisinin sadece sol işlenen kısmında oldukça, işlem sırasında listeA değişkeninin işaret ettiği bellek alanı değişmemektedir. BU durumda, f değişkenin de aynı bellek alanına işaret etmekte olduğu gözönüne alınırsa, ListeA da yapılan bir değişikliğin aynen f değişkenine yansıyacağı yadsınamaz. Aslında sadece bir tek veri alanı vardır ve bu alana hem listeA, hem de f değişkeni ile erişim sağlanmaktadır. Veri alanındaki veri değişirse ve her iki değişkenin de aynı veri alanına erişim sağlaması devam ederse, hangi değişken ile çağrılırsa çağrılsın, çağrılan aynı bellek alanında saklı olan aynı veri kümesi olduğundan, nedereden çağrılırsa çağrılsın, alınacak olan sonuç aynı olacaktır. Dolayısı ile bu olay, bir güncelleme olayıdır ve bunun kanıtı da aşağıda görülmektedir.

>>>listeA = [12, 2, 5, 45, 47]
>>>f = listeA
>>>f
>>>[12, 2, 5, 45, 47]
>>> #f ile listeA aynı bellek alanına işaret ediyor!
>>>listeA[4] = 35
>>>listeA
>>>[12, 2, 5, 45, 35]
>>>f
>>>[12, 2, 5, 45, 35]
>>>sonuç aynı !

Yukarıda uygulanan günceleme yöntemi, del() gibi, biraz sonra göreceğimiz, insert(), append() hazır fonksiyonları gibi, veriyi güncelleyen uygulamalardır. Bu durumda kendi ekleme, çıkartma, gibi güncelleme fonksiyonlarımızı yazabiliriz. Aşağıda bu konuda bir uygulama görülmektedir.

    
# -*- coding: utf-8 -*-
# ders17program2.py

listeQ = [16, 34, 2, 56, 44, 23]
f = listeQ

print('listeQ =',listeQ)
print('f =     ', f)
    
listeP = [3, 6]
print('listeP =', listeP)

def önüneEkle(listeA, listeB):
    listeA[:0] = listeB

def sonunaEkle(listeA, listeB):
    listeA[len(listeA):] = listeB

print('\nlisteP yi liste \' nün önüne ekle !\n')

önüneEkle(listeQ, listeP)

print('listeQ =', listeQ)
print('f =     ', f)

print('\nBaşlangıç durumuna getir !\n')

listeQ = [16, 34, 2, 56, 44, 23]
f = listeQ

print('listeQ =',listeQ)
print('f =     ', f)


sonunaEkle(listeQ, listeP)

print('listeQ =', listeQ)
print('f =     ', f)    

print('\nBaşlangıç durumuna getir !\n')

listeQ = [16, 34, 2, 56, 44, 23]
f = listeQ

print('listeQ =',listeQ)
print('f =     ', f)

print('\nlisteP yi liste \' nün sonuna ekle !\n')

print('Dikkat rekürsif atama!!! !\n')

listeQ = listeQ + listeP #Dikkat rekürsif atama!!!

print('listeQ =', listeQ)
print('f =     ', f)
    
print('\nRekürsif atama listeQ ile f\'in ilişkisini koparır!!!\n')

---------Program----Sonucunun----Görüntülenmesi-----------------------

listeQ = [16, 34, 2, 56, 44, 23]
f =      [16, 34, 2, 56, 44, 23]
listeP = [3, 6]

listeP yi liste ' nün önüne ekle !

listeQ = [3, 6, 16, 34, 2, 56, 44, 23]
f =      [3, 6, 16, 34, 2, 56, 44, 23]

Başlangıç durumuna getir !

listeQ = [16, 34, 2, 56, 44, 23]
f =      [16, 34, 2, 56, 44, 23]

listeP yi liste ' nün sonuna ekle !

listeQ = [16, 34, 2, 56, 44, 23, 3, 6]
f =      [16, 34, 2, 56, 44, 23, 3, 6]

Başlangıç durumuna getir !

listeQ = [16, 34, 2, 56, 44, 23]
f =      [16, 34, 2, 56, 44, 23]

listeP yi liste ' nün sonuna ekle !

Dikkat rekürsif atama!!! !

listeQ = [16, 34, 2, 56, 44, 23, 3, 6]
f =      [16, 34, 2, 56, 44, 23]

Rekürsif atama listeQ ile f'in ilişkisini koparır!!!

Yukarıdaki program sonuçları son derece açık ve aydınlatıcıdır. İlk önce listeQ değişkenine bir liste literali atanmıştır. Bu atama, bellekte bir alana listeQ literalini yerleştirmiş ve bu alana erişim kodunu (bir hex tamsayı) listeQ değişkenine atamıştır. Bir f değişkenine de listeQ nün, listeQ literaline erişim kodu atanmıştır. Gerek listeQ gerekse f değişkenlerinin erişebildikleri bellek alanlarında veriler kontrol edildiğinde, her ikisinin de aynı verilere erişilebildikleri görülmüştür. Bu sonuç hem listeQ, hem de f değişkenlerinin aynı veri alanına erişim yaptıklarını kanıtlamaktadır, çünkü erişim yaptıkları alanın geri döndürdüğü sonuç aynı ise, her iki değişkenin de bellek erişim kodları aynı olmalıdır.

Bundan sonra önüneEkle(listeQ, listeP) ve sonunaEkle(listeQ, listeP)adında, argüman olarak iki tane liste tipi veri alan iki fonksiyon tanımlanmıştır. Bu fonksiyonların içeriğinde, her iki fonksiyonun da ilk argümanları olan listenin, atama işlemcisinin sadece sol işleneninde bulunduğu ve her iki fonksiyonun da argümanlarını sadece güncellediği görülmektedir.

Bu fonksiyonların argüman olarak listeQ ve f değişkenleri ile çağrılmaları durumunda, argümanlarında sadece güncelleme yapacakları, bu fonsiyonlara argüman olarak uygulanmaları durumunda, her iki argüman arasındaki ilişkinin kopmayacağı görülmektedir. Programın yürğyüşünde bu olgu açıkça görülmektedir.

Bundan sonra listeQ verisine hem sol hem de sağ işlenende listeQ değişkeni bulunan, x = x + a şeklinde bir rekürsif atama yapılmıştır. Bu atama sonucunda, listeQ değişkeni bellekte ayrı bir yerde saklanan, başka bir alana işaret eder duruma gelmiş, f değişkeni ile aralarındaki ilişki kopmuş, listeQ üzerinde yapılan değişikliklerin artık f değişkenine yansımadığı görülmüştür.

Özet olarak, güncellenebilen tipte bir verinin sadece sol işlenende bulunduğu bir atama işlemi, veriyi güncellemekte, yani önceden işaret ettiği bellek alanını değiştirmemektedir. Aksi halde, yani hem sol hem de sağ işlenende bulunduğu bir atamanın, işaret ettiği bellek alanını değiştirdiği ve eski veri alanına işaret eden diğer değişkenlerle ilgisini koprdığı görülmektedir.

Python programlama dilinde, güncelenebilir tipte değişkenlerin güncellenebilmeleri için, özel ekleme , çıkarma, araya yeni veri yerleştirme rutinlerine gerek duyulur. Bir kez atanmış liste elemanlarına atama ile ek elemanlar eklenemez. Sadece mevcut elemanlar atama ile değiştirilebilir. Yeni atama ile yeni indis değerleri yaratılamaz. Sadece mevcut indis değerleri ile işlemler yapılabilir. Aşağıdaki atama başarısızlıkla sonuçlanır

    
>>> a = [2, 3]
>>>a[2] = 5

Güncellenebilen bir verinin güncellenebilmesi için, ya öntanımlı, append() fonksiyonu veya kullanıcı tanımlı sonunaEkle() gibi bir fonksiyonun uygulanması veya mevcut indis değerlerinden birine sahip olan elemanın doğrudan atama ile değiştirilmesi gerekir. Aşağıdaki uygulama bu konunun açıklanması için yararlı olacaktır.

    
# -*- coding: utf-8 -*-
# ders17program3.py

listA = [23, 16, 57]
    
f = listA

print('listA =', listA)
print('f =     ', f)
    
listA [2] = 'Güneş'

print('listA =', listA)
print('f =     ', f)
    
---------Program----Sonucunun----Görüntülenmesi-----------------------
listA =  [23, 16, 57]
f      = [23, 16, 57]
listA =  [23, 16, 'Güneş']
f      = [23, 16, 'Güneş']

Yukarıdaki programdan, atanmış bir listeden eleman değişiminin, bir güncelleme olduğu ve değişkenin işaret ettiği bellek alanının değişmediği görülmektedir.

Çok önemli olduğu ve programlamanın anahtarı olduğu için, aktarım mekanizmalarını yeniden tekrarlayacağız.

Değerle aktarım veya referansla aktarım terimleri, standart olmayan ve herkes için başka bir mekanizmayı çağrıştıran terimlerdir. Bunların kullanılmaması daha yerinde olacaktır.

Değiştirilemeyen Veri Tipleri

Değiştirilemeyen (immutable) tek veri tipleri (sayılar, sözel değerler, mantıksal değerler) bir değişkene atandıklarında değerleri değişkene atanır ve değişken program belleğinin sık değişebilen bir kısmına yerleştirilir. Örnek:

p = 5

Bu değer başka bir değişkene aktarılmak istendiğindiğinde, değerin kopyası, ikinci değişkene aktarılır. İkinci değişken başka bir bellek bölgesine yerleştirilir. altarım gerçekleştiğinde, birinci ve ikinci değişken arasında bir ilişki kalmaz. Birinci değişkene yeni bir değer atandığında, ikinci değişken etkilenmez. İkinci değişkene yeni bir değer atandığında, birinci değişken etkilenmez. Örnek:

    
      a = 12 # (a nın değeri 12)
      b = a  # (b nin değeri 12)
      a = 35 # (a nın değeri 35, fakat b nin değeri hâlâ 12)

Fonkisyonlarda argüman olarak kullanıldıklarında, argüman olarak kopyaları kullanılır. Bu yüzden fonksiyon içindeki değişimler fonksiyon dışına yansımaz. Örnek :

    
def değiş (x:
x = 12

a = 23

değiş(a) # (anın değeri hâlâ 23, değişen değer fonksiyonun içinde geçerli)

Güncellenebilen Veri Tipleri

Güncellenebilen yığın veri tipleri (listeler, sözlükler, kümeler) yeni bir değişkene atandığında veriler bir bir bellek bölgesine yerleştirilir. Bu bölgeye erişim kodu değişkene atanır.

Bu değişkenin değeri, başka bir değişkene atandığında, atanan sadece veriye erişimi sağlayan erişim kodudur.

Aktarım sona erdiğinde, her iki değişken de aynı veri yığınına erişirler. Birisi veriyi güncellerse, diğeri de aynı güncellenmiş veriye erişir.

Değişkenlerden birine yeni veri atanması durumunda, bu değişkenin eski veri yığını ile ilgisi kesilir. Yeni değer, yeni bir bellek alanına yerleştirilir. Bu yeni bellek alanına sadece değeri yeniden atanmış değişken erişebilir. Eski veri yığınına sadece değeri değişmemiş diğer değişkenler erişebilirler. Bu konuda örnekler, yukarıdaki uygulamalarda görülebilir.

Listeden bir elemanın çıkarılması için, remove() öntanımlı fonksiyonundan yararlanılabilir. Bu fonksiyonun uygulanma yöntemi x bir atanmış liste değişkeni ve m de bu listenin bir elemanı olmak üzere,

x.remove(m)

şeklindedir. Bu bir veri güncelleme metodudur. Bu metot, listede bulunan değeri m olan elemanlardan, ilk uyuşanı listeden çıkarır. Listede olan elemanlardan hiçbirisi ile uyuşma sağlanamazsa, bir ValueError hatası oluşur. Bu konuda bir uygulama aşağıda görülmektedir.

    
# -*- coding: utf-8 -*-
# ders17program4.py

try:
listE = [16,5,45]

f = listE

m = 5

listE.remove(m)

print('listeE = {0}'.format(listE))
print('f = {0:>13}'.format(f))

except :
    print('Hiçbir elemanla uyuşma sağlanamadı !')

else:
print('Uyuşma Sağlandı ve \
eleman {0} listeden çıkarıldı!'.format(m))
    
    ---------Program----Sonucunun----Görüntülenmesi-----------------------
listeE = [16, 45]
f =      [16, 45]
Uyuşma Sağlandı ve eleman 5 listeden çıkarıldı!

Yukarıdaki kullanıcı tanımlı fonksiyonlarımızdan yararlanarak, remove() metodununa eşdeğer bir fonksiyon yazabiliriz. Fakat, okunabilirliği yüksek bir kod için, bu metodun kullanımı daha uygun olacaktır.

Liste sonuna eleman eklenmesi için append() metodundan yararlanabiliriz. Bu metot, tanımlı bir a listesinin sonuna, tanımlı bir x listesini ekleyen a[len(a):] = [x] metoduna benzer, fakat bu sonuncusu daha yeteneklidir. Bu iki metodun kullanımları ve aralarındaki fark, aşağıdaki uygulamada görülmektedir.

    
# -*- coding: utf-8 -*-
# ders17program5.py

a  =  [2, 3, 4]

x  = [2 ,9]

print('a =', a)

a.append(12)
print('a =', a)

a  =  [2, 3, 4]
print('a =', a)

a.append(x)
print('a =', a)

a  =  [2, 3, 4]
print('a =', a)

a.append([x])
print('a =', a)

a  =  [2, 3, 4]
print('a =', a)

a  [len(a) :] = x]
print('a =', a)

a  [len(a) :] = [x]
print('a =', a)

---------Program----Sonucunun----Görüntülenmesi-----------------------
a = [2, 3, 4]
a = [2, 3, 4, 12]
a = [2, 3, 4]
a = [2, 3, 4, [2, 9]]
a = [2, 3, 4]
a = [2, 3, 4, [[2, 9]]]
a = [2, 3, 4]
a = [2, 3, 4, 2, 9]
a = [2, 3, 4, 2, 9, [2, 9]]

Yukarıdaki programda görülen kodların kullanılması ile istenilen şekilde bir eklemenin gerçekleştirilmesi sağlanabilir.

Bir listenin elemanlarına başka bir liste elemanlarının eklenmesi için listeA. extend(listeB) metodu da kullanılabilir. Bu metot, a[len(a):] = L işlemine eşdeğerdir. Bu metot, eklenecek olan listedeki elemanları, orijinal listenin sonuna eklemektedir.Bu konuda bir uygulama, aşağıda görülmektedir.

    
# -*- coding: utf-8 -*-
# ders17program6.py

a  =  [2, 3, 4]

x  = [2 ,9]

print('a =', a)

a.append(12)
print('a =', a)

a  =  [2, 3, 4]
print('a =', a)

a  [len(a) :] = x]
print('a =', a)

---------Program----Sonucunun----Görüntülenmesi-----------------------
a = [2, 3, 4]
a = [2, 3, 4, 2, 9]
a = [2, 3, 4]
a = [2, 3, 4, 2, 9]

Yukarıdaki uygulamada görüldüğü gibi, gerek hazır fonksiyon, gerekse kullanıcı tanımlı ifade aynı sonucu vermektedir.

Bir listeye belirli bir elemandan sonra yeni elemanlar eklenmesi için list.insert(i,x) hazır metodu kullanılabilir. Burada i, ekleme yapılacak elemanın indisi, x de eklenecek listedir. Bu metod, list.insert(0,x) şeklinde uygulanırsa, eklenecek liste elemenları, liste başına eklenir. Bu metot, list.insert(len(list),x) şeklinde uygulanırsa, eklenecek liste elemanları, liste sonuna eklenir. Eklemeler tek elemanlar halinde değil, liste elemanı olarak eklenir. Bu konuda bir uygulama aşağıda görülmektedir.

        
# -*- coding: utf-8 -*-
# ders17program7.py

a  =  [2, 3, 4]

x  = [2 ,9]

print('a =', a)

a.insert(0, x)
    
print('a =', a)

a  =  [2, 3, 4]
    
print('a =', a)

a.insert(len(a), x)
    
print('a =', a)

---------Program----Sonucunun----Görüntülenmesi-----------------------
a = [2, 3, 4]
a = [[2, 9], 2, 3, 4]
a = [2, 3, 4]
a = [2, 3, 4, [2, 9]]

Bu metodun uygulanması ile eklenen listedeki tek tek elemanların değil, tüm listenin tek bir eleman olarak eklendiğine dikkat edilmelidir.

Bir listenin indis sayısı belli bir elemanını listeden çıkarmak için listeDeğişkeni.pop([i]) metodu uygulanabilir. Burada [i] notasyonu i değerinin isteğe bağlı olduğunu belirtmek için kullanılmıştır. Metodun kullanımı, listeDeğişkeni.pop(i) veya veya listeDeğişkeni.pop() şeklindedir. Eğer bir indis numarası belirtilmemişse, listenin en son elemanı listeden silinir.

Bir listeden tüm elemanların silinmesi için listeDeğişkeni.clear() metodu uygulanabilir. Bu metot, del liste değişkeni.[:] ifadesine eşdeğerdir.

Bir listeden bir elemanın indis değerini sorgulamak için, listeDeğişkeni.index(listeElemanı) metodu kullanılabilir. Bu metot listeElemanı 'nın listedeki ilk yerleşim yerinin indisini döndürür. Eğer böyle bir eleman listede yoksa, bir hata oluşur.

Bir listede, herhangibir elemanın listede bulunduğu sayı, yani belirli bir değerin, bir listeye kaç kez yerleşmiş olduğunu sorgulamak için, listeDeğişkeni.count(listeElemanı) metodu kullanılabilir. Bu metot, istenilen liste elemanını listede bulamazsa, hata vermez, sadece [0] değerini döndürür.

Bir liste prensip olarak, değişik tipte ve değişik büyüklükte değerlerin, sırasız olarak toplandıkları bir konteyner gibidir. Bu değerler, listeDeğişkeni.sort() metodu ile sıralanabilir. bu metot sadece uygun veri tiplerinin yerleştirilmiş olduğu bir listede sıralama yapabiir. Veriler sıralanamaz nitelikte ise, bir hata oluşur.

Bir listeye elemanların yerleşim sıraları, tersine çeverilebilir. Bunun için, listeDeğişkeni.reverse() metodu kullanılabilir. Bu metot listeyi sıralamaz, sadece en son elemanı en başa alarak liste yerleşimini yeniden düzenler. Python dokümantasyonunda verilen, bu metotların bir uygulama örneği, aşağıda görülmektedir.

>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]

Bir listenin kopyalanması için, sığ kopyalama (shallow copy) veya derin kopyalama (deep copy) yontemleri uygulanabilir. Sığ kopyalama yönteminde, kopyaların birbirine bağımlı kalabilmeleri olasılığı vardır. Sığ kopyalama, güncellenemeyen veri tipleri için derin kopyalama ile aynıdır. Çünkü, sığ kopyalama sadece bellek refereranslarını kopyalar ve günceleleneyen veri tipleri ancak toptan değişebilir ve toptan değişme de, bellek referansları da değişir. Güncellenebilien veri tipleri sığ kopyalama ile kopyalandıklarında, kopyalar birbirine bağlı kalırlar ve birindeki güncelleme diğerine de yansır. Güncellenebilien veriler ile, ancak derin kopyalama yöntemi ile birbirinden bağımsız kopyalar yaratılabilir. Örnek:

>>> d = [4,6,[9,6,[7,7]]]
>>> r = d.[2,2].copy()
>>>d.append(78)
>>>r
[4, 6, [9, 6, [7, 7], 78]]

Yukarıdaki programdaki kopyalama metodu bir sığ kopyalama metodudur ve oluşan kopya, orijinaline bağlıdır. Program bunu açıkça belirtmektedir. Derin kopyalama için, topluluklar (tuples) incelenirken örnek verilecektir.

Bir listenin sıralanmış bir sürümünü başka bir listeye kopyalamak için, sorted() metodundan yararlanılabilir. Kullanılışı, aşağıdaki gibidir.

>>> a = [34, 5, 66, 3, 7]
>>> b = sorted(a)
>>&g[3, 5, 7, 34, 66]

Bir elemanın, bir listede olup olmadığının saptanması için, in işlemcisinden yararlanılabilir. Bir elemanın listede olup olmadığı ise, not in işlemcisi ile sorgulanabilir. Buna aidiyet testi adı verilir. Örnek:

>>> listeA = [3, 4]
>>> 3 in listeA
True
>>> 4 not in listeA
False

Bir listenin değeri en büyük olan elemanı max(), değeri en düşük olan elemanı ise, min() metotlarından yararlanılarak saptanabilir. Eğer listedeki elemanlar, farklı tiplerde ise, değeri maksimum veya minimum olan bir eleman saptanamaz. Bu durumda, TypeError istisnası yükseltilir.

>>> min([9,555,8])