Python Programlama Diline Giriş II

 

Python Programlama Diline Giriş II

            Merhaba Arkadaşlar bugün ise size Python Programlama dilinden bahsedeceğim. Bu ders biraz teorik kalacak ama ikinci dersten Python örneklerini yapmaya başlarız. Peki bugün kısaca ne öğreneceğiz.

1 Dolaşılabilir (iterable) Nesne Kavramı

2 Listeler (Lists)

3 Dilimleme Yoluyla Liste Elemanlarının Güncellenmesi

4 Range Fonksiyonu

5 Listelerde in ve not in Operatörleri

6 List Sınıfının Metotları

7 Listelerin Açılması (List Unpacking)

8 Listelerle Matris Oluşturmak

9 tuple Sınıfının Metotları

10 Demetlerle Listeler Arasındaki Farklılıklar

11 Kümeler (Sets)

12 Değiştirilemez Kümeler

13 Sözlükler (Dictionaries)

14 del Deyimi

15 Farklı Temel Türlerin Birbirleriyle İşleme Sokulması

16 Farklı Türlerin Birbirleriyle Karşılaştırılması

17 Aynı Türden Veri Yapılarının Birbirleriyle Karşılaştırılması

 

Dolaşılabilir (iterable) Nesne Kavramı

            Python'da bu bölümde göreceğimiz gibi görevi başka nesneleri tutmak olan çeşitli nesneler vardır. Bu tür nesnelere Java ve C# dillerinde "collection", C++'ta ise "container" denilmektedir. Python'da bir nesnenin dolaşılabilir olması demek elemanlarının tek tek türden bağımsız biçimde elde edilebilmesi demektir. Gerçekten de bu bölümde göreceğimiz listeler, demetler, kümeler, sözlükler ve string'ler dolaşılabilir türlerdir.

Bir fonksiyon ya da metot dolaşılabilir bir parametre alıyorsa biz o fonksiyona ya da metoda burada göreceğimiz veri yapılarını argüman olarak geçirebiliriz. Dolaşılabilir nesneleri biz fonksiyonlara ve metotlara geçirdiğimizde o fonksiyonlar ve metotlar onların içerisindeki elemanların hepsini elde edebilmektedir. Tabii dolaşılabilir nesneler yalnızca liste, demet, sözlük ve string nesneleri değildir. Başka pek çok sınıfın dolaşılabilir olma özelliği bulunabilmektedir. Sınıflar kısmında kendi sınıflarımızın nasıl dolaşılabilir (iterable) hale getirilebileceğini göreceğiz.

 

Listeler (Lists)

            Veri yapıları dünyasında "aralarında öncelik-sonralık ilişkisinin bulunduğu bir grup nesnenin oluşturduğu topluluğa" liste (list) denilmektedir. Bu bakımdan diziler, bağlı listeler birer listedir. Python'daki listeler diğer dillerdeki dizilere oldukça benzemektedir. Bir liste Python'da "list" isimli sınıf ile temsil edilmektedir. Belli bir liste de aslında Python'da "list" sınıfı türünden bir nesnedir.

Pyhon'da listeler çeşitli biçimlerde yaratılabilirler. En doğal yöntem köşeli parantez operatörünü kullanmaktadır. Köşeli parantezlerle liste yaratmanın genel biçimi şöyledir: [<[liste elemanları]>] Liste elemanları aralarına ',' atomu yerleştirilerek oluşturulur. Örneğin:

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

>>> a

[1, 2, 3]

>>> type(a)

<class 'list'>

Bir liste yaratılıp bir değişkene atandığında aslında tüm atamalarda olduğu gibi liste nesnesinin adresi değişkene atanmaktadır.

Örneğin:

>>> names = [Kıvanç, ‘Murat’, ‘Pelin’, 'Ayşe', Ceren’]

>>> names

['Kıvanç', Murat’, Pelin’, 'Ayşe', Ceren’]

>>> type(names)

<class 'list'>

 

Listenin elemanlarına ayrı ayrı köşeli parantez operatörüyle erişilebilir. Listenin ilk elemanı 0'ıncı indekstedir. Her elemanın sıfırdan itibaren bir indeks numarası vardır. Köşeli parantez operatörünün içerisine int türden bir ifade yerleştirebiliriz. Bu durumda o ifadenin önce değeri hesaplanır sonra listenin o indeksli elemanına erişilir. Örneğin:

>>> i = 0

>>> x[i + 1]

[2, 3]

 

Dilimleme Yoluyla Liste Elemanlarının Güncellenmesi

            Dilimleme yoluyla liste elemanları güncellenebilir. Bu durumda önce dilimlenen elemanlar silinir. Sonra bunların yerine atanan elemanlar getirilir. Yani dilimleme yoluyla işlem yaparken bu işlem hem silme hem de insert etme işlemlerini barındırmaktadır.

Örneğin:

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

>>> a[2:4] = [100, 200, 300]

>>> a

[1, 2, 100, 200, 300, 5]

Burada önce a [2:4] elemanları silinmiş sonra da bunların yerine [100, 200, 300] elemanları insert edilmiştir. Silinen ve insert edilen kısmın eşit uzunlukta olmasının gerekmediğine dikkat ediniz. Örneğin:

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

>>> a[2:4] = [100]

>>> a

[1, 2, 100, 5]

 

Burada listenin 2 ve 3 indeskli elemanları silinmiş yerine 100 değeri insert edilmiştir. Dilimlenmiş kısma boş liste atamaya çalışırsak o elemanları silmiş oluruz. Örneğin:

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

>>> a[1:3] = []

>>> a

[1, 4, 5]

Hiç eleman silmeden de insert işlemi yapabiliriz. Bunun için dilimlemede ':' operatörünün solundaki indisin sağındaki indis ile aynı değerde ya da ondan küçük bir değerde olması gerekir. Bu durumda zaten bir eleman seçilemeyecektir. O halde yalnızca insert işlemi yapılacaktır. Örneğin:

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

>>> a[2:2] = [100, 200]

>>> a

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

 

Range Fonksiyonu

range built-in bir fonksiyondur. Bu fonksiyonun amacı belli aralıkta düzenli tam sayısal değerlerden oluşan dolaşılabilir (iterable) bir nesne elde etmektir. range fonksiyonu bir, iki ya da üç argüman girilerek çağrılabilmektedir. Bu üç parametreye sırasıyla start, stop ve step parametreleri denilmektedir. Eğer fonksiyon tek parametreyle çağrılırsa bu parametre stop anlamına gelir. Bu durumda default olarak start = 0 ve step = 1 alınmaktadır. Eğer fonksiyon iki argümanla çağrılırsa bu durumda ilk argüman start, sonraki argüman stop değeri olur. Bu durumda step = 1 kabul edilir. Nihayet fonksiyon üç argümanla da çağrılabilir. Bu durumda ilk argüman start, ikinci argüman stop ve üçüncü argüman da step anlamına gelir. Start değeri aralığa dahil fakat stop değeri aralığa dahil değildir.

range fonksiyonu bize geri dönüş değeri olarak bir liste vermez. Bize bu fonksiyon range isimli bir sınıf türünden bir nesne verir. range sınıfı dolaşılabilir (iterable) bir sınıftır. Biz de elde ettiğimiz bu sınıf nesnesini list sınıfının başlangıç metoduna parametre yaparsak istediğimiz aralıktaki listeyi elde edebiliriz.

Listelerde in ve not in Operatörleri

in operatörü yalnızca listelerde değil diğer biçimlerdeki dizilimlerde (sequences) de kullanılan iki operandlı araek genel bir operatördür. Belli bir değerin dizilimde olup olmadığını kontrol eder. Eğer ilgili değer dizilimde varsa True değerini yoksa False değerini üretir. not in operatörü de tam ters işlem yapmaktadır.

Örneğin:

>>> a = [3, 13, 18, 'Kıvanç', 4.38]

>>> 13 in a

True

>>> 23 in a

False

>>> 'Kıvanç' in a

True

>>> 'Murat' in a

False

>>> 'Murat' not in a

True

 

List Sınıfının Metotları

Python'da aslında bütün türler birer sınıf (class) belirtmektedir. Python'da sınıfın içerisinde olmayan alt programlara fonksiyon, sınıfın içerisinde bulunan alt programlara ise metot denilmektedir. Daha önceden de belirtildiği gibi bir sınıfın metodu (yani sınıfın içindeki fonksiyonu) o sınıf türünden değişken ve '.' operatörüyle çağrılır. Örneğin:

a.foo()

Burada biz a değişkeni hangi sınıf türündense o sınıfın foo metodunu çağırıyoruz. Halbuki:

foo()

Burada hiçbir sınıfın içerisinde olmayan global foo fonksiyonu çağrılmaktadır.

list sınıfının append metodu listenin sonuna yeni tek bir elemanı eklemek için kullanılır. Örneğin:

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

>>> a.append(10)

>>> a

[1, 2, 3, 10]

Örneğin:

>>> a = list(range(1, 11))

>>> a

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> a.append(100)

>>> a

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100]

append metodunun eklemeyi çağrıldığı liste üzerinde yaptığına dikkat ediniz. append metodu tek bir elemanı sona eklemektedir. Bu tek eleman bir liste olsa bile eleman bir liste olarak listenin sonuna eklenir. Örneğin:

>>> a = list(range(10))

>>> a

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> a.append([10, 20, 30])

>>> a

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, [10, 20, 30]]

 

Listelerin Açılması (List Unpacking)

Bir listenin elemanları köşeli parantez sentaksıyla değişkenlere pratik biçimde atanabilir. Buna listenin açılması ("unpack" yapılması) denilmektedir. Örneğin:

>>> x = [1, 2, 3]

>>> [a, b, c] = x

>>> a

1

>>> b

2

>>> c

3

Liste açım işleminin genel biçimi şöyledir:

[[<değişken listesi>[]] = <dolaşılabilir bir nesne>

Örneğin:

>>> names = [Kıvanç, 'Murat', 'Seyit']

>>> [kıvanç, murat, seyit] = names

>>> kıvanç

'Kıvanç'

>>> murat

'Murat'

>>> seyit

'Seyit'

Açım işleminde sağdaki listenin eleman uzunluğunun soldaki değişken listesinin uzunluğu ile aynı olması gerekir.

Örneğin:

>>> x = [1, 2, 3]

>>> [a, b] = x

Traceback (most recent call last):

 

Listelerle Matris Oluşturmak

Pek çok programlama dilinde çok boyutlu diziler vardır. Örneğin iki boyutlu diziler yani matrisler pek çok dilde özel bir sentaksla desteklenmektedir. Halbuki Python'da çok boyutlu dizi diye bir kavram yoktur. Listeler zaten çok boyutlu dizi olarak da kullanılabilirler. Örneğin:

>>> m = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]

Burada aslında m listesi 4x3'lük bir matris gibidir. Onun istediğimiz elemanına yan yana iki köşeli parantezle erişebiliriz.

Örneğin:

>>> m[3][2]

12

>>> m[1][0]

4

Örneğin:

>>> a = [[10, 20], [5, 3], [5, 8]]

>>> a.sort()

>>> a

[[5, 3], [5, 8], [10, 20]]

Burada listenin elemanlarının da aslında list türünden olduğuna dikkat ediniz.

 

tuple Sınıfının Metotları

tuple sınıfının yalnızca iki metodu vardır: index ve count. Bu metotları list sınıfından da anımsıyorsunuz. index metodu bir elemanı arar, bukursa onun indeks numarası ile geri döner. Örneğin:

>>> a = (10, 20, 30, 40, 50)

>>> a.index(30)

2

index metodu tıpkı list sınıfında olduğu gibi demet içerisinde elemanı bulamazsa exception oluşturmaktadır. Örneğin:

>>> a.index(100)

Traceback (most recent call last):

File "<pyshell#17>", line 1, in <module>

a.index(100)

ValueError: tuple.index(x): x not in tuple

count metodu da listelerde olduğu gibi bir elemanın demet içerisinde yinelenme sayısına geri dönmektedir. Örneğin:

>>> a = (1, 2, 3, 1, 2, 1, 5, 7, 1)

>>> a.count(1)

 

Demetlerin Açılması (Tuple Unpacking)

Bir demet listelerde olduğu gibi açılabilir. Açma (unpack) işlemi yine atama yoluyla yapılmaktadır. Örneğin:

>>> point = (10, 2)

>>> point

(10, 2)

>>> (x, y) = point

>>> x

10

>>> y

2

Bu işlem adeta point[0] değerinin x'e, point[1] değerinin y'ye atanmasıyla eşdeğerdir.

Örneğin:

>>> t = (10, 'Ali', 20.3)

>>> (a, b, c) = t

>>> a

10

>>> b

'Ali'

>>> c

20.3

Açılımın liste sentaksıyla ya da demet sentaksıyla yapılması arasında hiçbir farklılık yoktur. Demetlerde de açım yaparken parantezler de kullanılmayabilir. Örneğin:

>>> a = 10; b = 20

>>> b, a = a, b

>>> a

20

>>> b

10

Örneğin:

>>> point = 3, 5

>>> x, y = point

>>> a

20

>>> y

5

O halde açım işlemlerinin genel biçimleri şöyledir:

(<değişken listesi>) = <dolaşılabilir nesne>

<değişken listesi> = <dolaşılabilir nesne>

[<değişken listesi>] = <dolaşılabilir nesne>

Demet açma işlemini sembolik olarak açıklarsak:

t = (a, b, c)

(x, y, z) = t

işleminin eşdeği şöyledir:

x = t[0]

y = t[1]

z = t[2]

Gerçekten de Python'da bir fonksiyon birden fazla değere geri döndürüyorsa onun geri dönüş değerinin bir demet yapılması sık karşılaşılan bir durumdur.

Demetler kategorik olarak değiştirilemez türler olduğu için bir demete eleman eklemek, demetten eleman silmek, demet elemanını güncellemek gibi işlemler demetlerde yapılamamaktadır.

 

Demetlerle Listeler Arasındaki Farklılıklar

            Demetlerin veri yapısı olarak temsil edilmesi listelerden çok daha yalın ve etkin biçimde gerçekleştirilebilmektedir. Yani demetlerle işlemler listelerle işlemlere göre hem daha hızlı hem de daha az yer kaplayan biçimde gerçekleştirilme eğilimindedir. Dolayısıyla eğer programcı veri yapısı üzerinde bir ekleme çıkartma yapmayacaksa listeler yerine demetleri tercih etmelidir. Tabii bazen programcı veri yapısına eleman eklemek ya da ondan eleman silmek isteyebilir.

Bu durumda listeleri kullanmak zorundadır. Çünkü demetler değiştirilebilir türler değildir. Demetlerin bir avantajı da bazı koşullar sağlandığında hash'lenebilir (hashable) olmalarıdır. Örneğin biz duruma göre bir demeti sözlüğe anahtar yapabiliriz. Ancak hiçbir biçimde listeleri sözlüklere anahtar yapamayız.

 

Kümeler (Sets)

            Kümeler matematiğin en temel konularından biridir. Farklı elemanlardan oluşan toplulukları belirtir. Python'da da kümeler matematik tanımındaki gibi "farklı elemanlardan oluşan" topluluklardır. Bir küme tipik olarak küme parantezleri ile aşağıdaki gibi oluşturulur:

{<[eleman listesi]>}

Küme elemanları ',' atomu ile birbirinden ayrılmaktadır. Örneğin:

>>> s = {1, 2, 3, 4, 5}

>>> s

{1, 2, 3, 4, 5}

>>> type(s)

<class 'set'>

Python'da kümeler set isimli sınıfla temsil edilmiştir.

Bir küme oluştururken aynı elemandan birden fazla kez yazmak bir error oluşturmaz. Fazla elemanların yalnızca bir tanesi alınarak küme oluşturulmaktadır. Örneğin:

>>> s = {1, 2, 1, 1, 1, 3, 4, 3, 5, 5, 5, 4}

>>> s

{1, 2, 3, 4, 5}

Tabii küme elemanları da farklı türlerden olabilir. Örneğin:

>>> s = {1, 'Kıvanç', (3, 4), 12.3}

>>> s

{(3, 4), 1, 'Kıvanç', 12.3}

Kümeler indekslenebilir bir dizilim (sequence) belirtmezler. Bu nedenle bir kümenin elemanlarının bizim onu oluşturduğumuz sırada gösterilmesi ya da bize geri verilmesi de garanti değildir. Ayrıca küme elemanlarına [...] operatörü ile bir indeks belirterek de erişemeyiz. Yani bir kümenin tıpkı matematikte olduğu gibi n'inci elemanı diye bir kavramı yoktur. Başka bir deyişle küme elemanlarında öncelik sonralık ilişkisi yoktur. Tabii bu nedenlerden dolayı kümeler dilimlenemezler de.

Kümelerde '*' operatörü kullanılamamaktadır. Çünkü zaten küme elemanları birbirinden farklı olacağı için bunun da bir anlamı yoktur. Benzer biçimde iki küme de '+' operatörü ile toplanamamaktadır. (Ancak ileride görüleceği gibi iki küme üzerinde kesişim, birleşim gibi işlemler yapılabilmektedir.)

Python'da boş bir küme {} biçiminde yaratılamamaktadır. Çünkü {} işlemi Python'da boş bir sözlük (dictionary) oluşturmaktadır. Boş kümeler set fonksiyonun argümansız çağrılmasıyla oluşturulabilmektedir. Örneğin:

>>> s = set()

>>> s

set()

>>> type(s)

<class 'set'>

Değiştirilemez Kümeler

    Normal kümeler set sınıfıyla temsil edilmektedir ve değiştirilebilir (mutable) nesnelerdir. Ancak bir de değiştirilemez

(immutable) kümeler vardır. Bunlar frozenset sınıfıyla temsil edilmektedir. Bir değiştirilemez küme küme parantezleriyle değil doğrudan sınıfın başlangıç metodu olan frozenset fonksiyonuyla oluşturulmaktadır. Örneğin:

>>> fs = frozenset([1, 'Ali', 2, 'Veli'])

>>> fs

frozenset({'Veli', 1, 2, 'Ali'})

frozenset fonksiyonu yine dolaşılabilir herhangi bir nesneyi parametre olarak alabilmektedir. frozenset sınıfı da set sınıfı gibi ve set sınıfıyla temel küme işlemlerine sokulabilmektedir. Fakat frozenset sınıfında elemanları değiştiren add gibi, update gibi, clear gibi metotlar yoktur.

 

Sözlükler (Dictionaries)

            Sözlükler arama amaçlı kullanılan veri yapılarıdır. Başka dillerde bunlara "look up table", "hash table" ya da "map" denilebilmektedir. Sözlük daha genel bir isim olarak Python'da tercih edilmiştir.

 Sözlükler anahtardan değeri elde etmek için kullanılan built-in veri yapılarıdır. dict isimli sınıfla temsil edilmişlerdir. Bir sözlük yaratmanın çeşitli yolları varsa da en çok kullanılan yöntem yine kümelerde olduğu gibi küme parantezi sentaksıdır. Bu sentaksın genel biçimi şöyledir:

{ <anahtar>: <değer>, <anahtar>: <değer>, <anahtar>: <değer>, ... }

Örneğin:

>>> d = {'Ali': 123, 'Veli': 345, 'Selami': 34, 'Ayşe': 65, 'Fatma': 79}

>>> d

{'Ali': 123, 'Veli': 345, 'Selami': 34, 'Ayşe': 65, 'Fatma': 79}

>>> type(d)

<class 'dict'>

Burada isimler anahtar onlara karşı gelen numaralar da değer olarak kullanılmıştır. Sözlük nesneleri de aslında anahtar ve değerlerin kendilerini değil onların adreslerini tutmaktadır.

 

del Deyimi

Python'da değişkenler ve bazı veri yapılarının elemanları del deyimi ile silinebilmektedir. del deyiminin genel biçimi şöyledir:

del <değişken listesi>

del deyimi ile biz global ya da yerel değişkenleri silebiliriz. (Yerel değişkenler konusu sonraki bölümlerde ele alınmaktadır.) Örneğin:

>>> x = 10

>>> del x

>>> print(x)

Traceback (most recent call last):

File "<pyshell#21>", line 1, in <module>

print(x)

NameError: name 'x' is not defined

Gördüğünüz gibi bir değişken del deyimi ile silindiğinde o değişken hiç yaratılmamış gibi bir durum oluşmaktadır. Tek bir del deyimi ile birden fazla değişkeni silebiliriz. Örneğin:

>>> a = 10; b = 20

>>> del a, b

del deyimi nesneleri değil değişkenleri silmektedir. Örneğin:

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

>>> b = a

>>> del a

Burada a ve b değişkenleri aynı list nesnesini gösteriyor durumdadır. del a işlemi ile a değişkeninin gösterdiği list nesnesi değil, a değişkeni silinmiştir. Kursumuzun ilerleyen bölümümlerinde bir nesnenin hiçbir değişken tarafından gösterilmediği durumda Python'ın çöp toplayıcı (garbage collector)" mekanizmasının değişkeni sildiğini göreceksiniz. del deyimi ile değiştirilebilir (mutable) bazı veri yapılarının elemanları da silinebilmektedir. Örneğin listelerin elemanlarını del deyimi ile silebiliriz:

>>> del a[0], a[3]

>>> a

[2, 3, 4]

>>> 

Farklı Temel Türlerin Birbirleriyle İşleme Sokulması

            Python'da genel olarak farklı türler birbirleriyle işleme sokulamazlar. Örneğin biz bir string ile bir int değeri işleme sokamayız. Tabii farklı türleri işleme sokabilmek için operator metodu denilen özel metotlar kullanılabilmektedir. Bu konu sınıfların anlatıldığı bölümde ele alınacaktır. Python'da istisna olarak aşağıdaki farklı türler bir arada işleme sokulabilmektedir:

- int ile float türü beraber işleme sokulabilir. Sonuç float türden çıkar. Örneğin:

>>> 10 + 20.2

30.2

- bool türü ile int ve float türleri beraber işleme sokulabilir. Bu durumda bool türü eğer belirttiği değer True ise 1 olarak False ise 0 olarak işleme sokulmaktadır. Örneğin:

>>> b = True

>>> i = 10 + b

>>> i

11

>>> f = 10.1 + b

>>> f

11.1

Tabii buradaki işlem karşılaştırma işlemi de olabilir. Örneğin:

>>> 1 == True

True

>>> 0 == False

True

>>> 1.0 == True

True

>>> 10 > True

True

>>> 0.4 > True

False

 

Farklı Türlerin Birbirleriyle Karşılaştırılması

            Python'da farklı türler her zaman birbirleriyle == ve != operatörü kullanılarak karşılaştırma işlemine sokulabilir. int ve float türlerinin dışında farklı türlerin == operatörüyle karşılaştırılmaları her zaman False, != operatörüyle karşılaştırılmaları ise True değerini vermektedir. Örneğin:

>>> 3 == 3.0

True

>>> 'ali' == 45

False

>>> 10 == [1, 2, 3, 4]

False

>>> 10 != [1, 2, 3, 4]

True

 

Aynı Türden Veri Yapılarının Birbirleriyle Karşılaştırılması

            Aynı türden iki listenin ya da demetin karşılaştırılması string karşılaştırmasında olduğu gibi leksikografik biçimde yapılmaktadır. Yani elemanlar aynı olduğu sürece ilerlenir. İlk farklı elemanın büyüklük küçüklük durumuna bakılır.

Örneğin:

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

>>> b = [1, 2, 3]

>>> a == b

True

>>> a != b

False

Örneğin:

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

>>> b = [1, 2, 4]

>>> a == b

False

>>> a > b

False

>>> b > a

True

Örneğin:

>>> a = (1, 2, 3)

>>> b = (1, 2, 3, 4)

>>> a > b

False

>>> b > a

True

Örneğin:

>>> [10, 20, 30] > [10, 20, 35]

False

Karşılaştırma sırasında liste ya da demet uzunluklarının eşit olması gerekmemektedir. Örneğin:

>>> [10, 20, 30, 40] > [10, 20, 30]

True