4. Listeler¶

4.1. Giriş¶

Bu bölümde yine Python’un çok önemli bir öğesinden bahsedeceğiz. Bu dersimizin konusu “Python’da Listeler”.

Aslında biz range() fonksiyonunu incelerken, ucundan da olsa listeleri görmüştük. Mesela şu örneği hatırlıyorsunuz:

list(range(10))

Bu komut şöyle bir çıktı veriyordu:

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

İşte yukarıda gördüğümüz bu çıktı aslında bir “liste”dir... Teknik bir dille ifade etmek gerekirse, “listeler” Python’daki “veri tipleri”nden (data types) yalnızca bir tanesidir. Şimdiye kadar gördüğümüz veri tipleri arasında “sayılar” ve “karakter dizileri” vardı... Dolayısıyla, “sayılar”, “karakter dizileri” ve “listeler” Python’da “veri tipi” adı verilen bir grubun üyesidir. Bu teknik terimleri elbette ezberlemek zorunda değilsiniz. Ama bilmenin zararını değil faydasını görürsünüz.

Python’da “listeler” konusuna kısa bir giriş yaptığımıza göre artık yavaş yavaş ayrıntılara inmeye başlayabiliriz.

4.2. Listeleri Tanımlamak¶

Python’da listeleri kullanabilmek için öncelikle bunları tanımlamamız gerekir. Endişelenmeyin. “Liste tanımlamak” ifadesinin kendisi biraz fantastik duruyor olsa da, aslında liste tanımlamak çok kolaydır!

Listeleri şöyle tanımlıyoruz:

liste = []

Burada hiç bir öğe içermeyen boş bir liste tanımladık. Bunu ekrana basmak istersek şöyle yapmamız gerektiğini biliyorsunuz:

print(liste)

Tabii boş bir liste tanımladığımız için elde ettiğimiz çıktı da boş bir liste oldu... Burada şaşılacak bir şey yok. Şimdi isterseniz gelin boş bir liste yerine, içinde birkaç öğe barındıran daha işlevli bir liste yapalım:

diller = ["python", "php", "perl", "C++"]

Gördüğünüz gibi, programlama dillerinin bazılarını sıraladığımız, “diller” adlı bir liste oluşturduk. Dikkat ederseniz, liste tanımlamak, değişken veya karakter dizisi tanımlamaya çok benziyor. Listeleri başka veri tiplerinden ayıran en önemli özellik, “[]” işaretidir. Bu işaret, arka arkaya dizilmiş öğelerin bir “liste” olduğunu gösterir. Yani “[]” işareti Python’da listelerin ayırt edici özelliğidir. Gelin isterseniz elimiz alışsın diye bir başka liste daha tanımlayalım:

alışveriş = ["elma", "armut", "kabak", "ekmek", "çilek", "şeker", "şeftali"]

Burada da basit bir alışveriş listesi tanımladık. Dikkat ederseniz, listenin bütün öğeleri birer karakter dizisi. Bunu tırnak içine alınmış olmalarından anlıyoruz. Listelerin ayırt edici özelliği nasıl “[]” işareti ise, karakter dizilerinin ayırt edici özelliği de tırnak işaretleridir... Elbette sadece karakter dizilerinden oluşan listeler tanımlamak zorunda değiliz. İstersek, öğeleri sayılardan oluşmuş bir liste de tanımlayabiliriz:

çift_sayılar = [2, 4, 6, 8, 10]

Bu listemizin öğeleri ise tamsayılardan (integers) oluşmuş. Hatta istersek, farklı veri tiplerinden oluşmuş melez bir liste dahi tanımlayabiliriz:

liste1 = ["kedi", 4, 3.5]

Hatta inanmayacaksınız ama, tanımladığımız bir listenin öğesi başka bir liste dahi olabilir:

liste2 = ["kuzu", 12, 15.4, ["salam", "sucuk"], liste1]

Sonuncu listemizi dikkatlice inceleyin. Burada bildiğimiz bütün veri tiplerini tek bir listeye yerleştirdik. Bu listeyi ekrana bastığımızda şöyle bir çıktı elde ederiz:

>>> print(liste2)

['kuzu', 12, 15.4, ['salam', 'sucuk'], ['kedi', 4, 3.5]]

Bu listede bir önceki “liste1” adlı listenin kendisinin de yer aldığına dikkat edin...

Gördüğünüz gibi Python’da bir liste tanımlamak hem çok kolay, hem de öğelerin çeşitliliği açısından oldukça özgürüz. İsterseniz şimdi bu listelerle neler yapabileceğimize bakalım biraz.

4.3. Listelerin Öğelerine Erişmek¶

Bir önceki bölümde güzel güzel tanımladık listelerimizi. Peki bu listeleri tanımladık da ne oldu? Biz bu listeleri tanımladıktan sonra ne yapacağız? İşte bu bölümde bu sorulara cevap vermeye çalışacağız.

Öncelikle tanımladığımız listelerin öğelerine nasıl erişebileceğimize bakalım...

Hemen bir liste tanımlamakla başlayalım işe:

sistemler = ["GNU/Linux", "Mac Os X", "Windows"]

Böylece işletim sistemlerinin adlarını içeren bir liste tanımlamış olduk. Bir önceki derste öğrendiğimize göre bu listeyi şu şekilde ekrana basabiliriz:

print(sistemler)

Peki biz bu listenin bütün öğelerini değil de sadece istediğimiz bir öğesini yazdırmak istersek ne olacak?

Python’da liste öğelerinin her birinin bir sırası vardır. Liste öğelerine, öğenin sırasını kullanarak ulaşabiliriz. Formülümüz şöyle olacak:

liste[öğenin_sırası]

Buna hemen bir örnek verelim. Diyelim ki “sistemler” adlı listedeki “GNU/Linux” öğesini almak istiyoruz. Şöyle bir şey deneyelim:

>>> print(sistemler[1])

'Mac Os X'

Ne oldu? “GNU/Linux” yerine, listenin ikinci öğesi olan “Mac Os X”i verdi bu komut bize, değil mi? Ama bizim istediğimiz bu değildi... Gelin bir de şöyle bir şey deneyelim:

>>> print(sistemler[0])

'GNU/Linux'

Bu sefer oldu. Buradan anlıyoruz ki Python saymaya sıfırdan başlıyor. Yani listemizin ilk öğesine ulaşmak için “1” değil, “0” sayısını kullanmamız gerekiyor. Bu kuralı göz önüne alarak sırasıyla bütün öğelerimizi yazdıralım:

>>> print(sistemler[0])

'GNU/Linux'

>>> print(sistemler[1])

'Mac Os X'

>>> print(sistemler[2])

'Windows'

Eğer sıra numarası olarak pozitif bir sayı yerine negatif bir sayı kullanırsak, liste soldan sağa değil, sağdan sola, yani geriye doğru taranacaktır:

>>> print(sistemler[-1])

'Windows'

>>> print(sistemler[-2])

'Mac Os X'

>>> print(sistemler[-3])

'GNU/Linux'

Burada listenin en son öğesine, “-0” diye bir şey olamayacağı için “-1” ifadesiyle erişiyoruz... Eğer listede olmayan bir öğenin sırasını sorgularsak hata mesajı alırız. Yani “print(sistemler[5])” veya “print(sistemler[-4])” gibi komutlar hata verecektir. Çünkü “sistemler” adlı listede “beşinci” veya “eksi dördüncü” bir öğe yok...

Python’daki listelerin bir başka özelliği ise, yukarıdaki sıra numaralarının, bir aralık belirtecek şekilde kullanılabilmesidir. Bu ne demek? Yani bir listeden her defasında sadece tek bir öğe almak zorunda değiliz. İstersek bir kaç öğeyi birden de alabiliriz. Bununla ilgili hemen bir örnek verelim. Şöyle bir listemiz olsun:

>>> isimler = ["Udith Narayan", "Sonu Nigam", "Kajol Devgan",
... "Rani Mukherjee", "Preity Zinta", "Lata Mangeshkar"]

Şimdi mesela yukarıdaki listeden 1-3 arası öğeleri alalım:

>>> print(isimler[1:3])

['Sonu Nigam', 'Kajol Devgan']

Burada “0-3” arası öğeleri değil, “1-3” arası öğeleri aldığımıza dikkat edin. Bildiğiniz gibi, listelerin ilk öğesinin sırası “0”dır. Ayrıca “1-3” şeklinde bir aralık belirttiğimizde sadece birinci ve ikinci öğelerin alındığına dikkat edin. Yani isimler[1:3] dediğimizde, alacağımız sonuç 1. öğeyi içerirken 3. öğeyi içermez... Bu arada, bu işleme Python’cada “dilimleme” (slicing) adı verilir. Gerçekten de burada yaptığımız şey bir listeyi “dilimlemekten” ibarettir...

Aynı listeden devam edelim:

>>> print(isimler[2:5])

['Kajol Devgan', 'Rani Mukherjee', 'Preity Zinta']

Liste öğelerine tek tek erişirken yaptığımız gibi, burada da negatif sayılardan yararlanabiliriz:

>>> print(isimler[0:-1])

Gördüğünüz gibi, yukarıdaki komut bir listenin son öğesini kırpmak için gayet etkili bir yoldur. Burada farklı sayılarla kendi kendinize deneme yaparsanız Python’daki dilimleme mekanizmasını daha iyi kavrayabilirsiniz.

Listelerdeki bu sıra sayılarının bazı varsayılan değerleri vardır. Mesela, eğer ilk sayıyı belirtmezseniz, Python ilk sayıyı “0” varsayacaktır. Yani:

>>> print(isimler[:4])

['Udith Narayan', 'Sonu Nigam', 'Kajol Devgan', 'Rani Mukherjee']

Gördüğünüz gibi, ilk sayıyı belirtmediğimizde Python sanki “isimler[0:4]” yazmışız gibi davrandı. Peki ya ikinci sayıyı belirtmezsek ne olur?

>>> print(isimler[0:])

['Udith Narayan', 'Sonu Nigam', 'Kajol Devgan', 'Rani Mukherjee',
 'Preity Zinta', 'Lata Mangeshkar']

Burada da Python sanki “isimler[0:6]” yazmışız gibi davrandı. Yani listenin sonuna kadar gitti.

Listelerle yapabileceklerimiz bunlarla sınırlı değildir. Yukarıda gördüğümüz gibi, listelere iki farklı sıra sayısı vererek liste öğelerine teker teker veya topluca erişebiliyoruz. Eğer iki farklı sıra sayısıyla birlikte üçüncü bir sayı daha verirsek, liste öğelerini, bu verdiğimiz üçüncü sayı kadar atlayarak ekrana yazdırabiliriz. Bu tarif bir örnekle daha kolay anlaşılacaktır:

>>> print(isimler[0:6:2])

['Udith Narayan', 'Kajol Devgan', 'Preity Zinta']

Gördüğünüz gibi, üçüncü sayı olarak verdiğimiz “2” sayesinde liste öğelerini birer atlayarak ekrana yazdırdık. Burada farklı sayılar deneyerek sistemi daha iyi anlayabilirsiniz.

Aslında yukarıdaki son örneği, listelerin varsayılan değerlerinden yararlanarak daha basit bir şekilde yazabilirsiniz:

>>> print(isimler[::2])

['Udith Narayan', 'Kajol Devgan', 'Preity Zinta']

Bildiğiniz gibi, eğer ilk sayıyı belirtmezseniz Python “0” demek istediğinizi, ikinci sayıyı belirtmezseniz de listedeki öğe sayısını kullanmak istediğinizi varsayacaktır. Dolayısıyla bizim “0” ve “6”yı ayrıca belirtmemiz şart değil.

Şimdi vereceğimiz örneği dikkatlice inceleyin:

>>> print(isimler[::-1])

['Lata Mangeshkar', 'Preity Zinta', 'Rani Mukherjee', 'Kajol Devgan',
 'Sonu Nigam', 'Udith Narayan']

Gördüğünüz gibi, üçüncü sayı olarak negatif bir değer de verebiliyoruz. Üçüncü sayı olarak “-1” verdiğimiz zaman Python listeyi geriye doğru sıralayacaktır. Dolayısıyla yukarıdaki komutu kullanarak, herhangi bir listeyi ters çevirebiliriz. Bu özellik bir yerlerde mutlaka işinize yarayacaktır.

Hatırlarsanız bir önceki bölümde şöyle iki tane listemiz vardı:

>>> liste1 = ["kedi", 4, 3.5]

>>> liste2 = ["kuzu", 12, 15.4, ["salam", "sucuk"], liste1]

Burada “liste1” adlı ilk listemizi doğrudan “liste2” adlı ikinci listemizin içinde kullanmıştık. “liste2” adlı listeyi yazdırdığımızda şöyle bir çıktı alıyorduk:

>>> print(liste2)

['kuzu', 12, 15.4, ['salam', 'sucuk'], ['kedi', 4, 3.5]]

Bu liste biraz karışık görünüyor. Bakalım bu listelerin öğelerine nasıl ulaşabiliriz... Sırasıyla deneyelim:

>>> print(liste2[0])

'kuzu'

>>> print(liste1[1])

12

>>> print(liste1[2])

15.4

>>> print(liste1[3])

['salam', 'sucuk']

Gördüğünüz gibi, son örnekte tek bir öğe değil, listenin kendisini alıyoruz. Çünkü “liste2” adlı listenin üçüncü öğesi bir listedir. ([“salam”, “sucuk”]). Mesela sadece “salam” öğesini almak istersek şöyle bir yol izlememiz gerekir:

>>> print(liste2[3][0])

'salam'

Yani burada kabaca şöyle bir şey söylemiş olduk:

“Bana liste2 adlı listenin üçüncü öğesinin sıfırıncı öğesini ver!“

Aynı listenin bir sonraki öğesi de bir listedir ([“kedi”, 4, 3.5]). Bu listedeki “3.5” öğesine ulaşmak için şöyle bir şey yazmamız gerekir:

>>> print(liste2[4][2])

3.5

Eğer liste2 listesinin dördüncü öğesini tersten sıralamak isterseniz şöyle bir şey yazmanız gerektiğini tahmin edebilirsiniz:

>>> print(liste2[4][::-1])

[3.5, 4, 'kedi']

Böylelikle listelere ilişkin önemli bir konuyu geride bırakmış olduk. Bu noktada sizin yapmanız gereken, yukarıdaki örneklere bağlı kalmadan kendi kendinize bazı örnek kodlar yazmaktır. Kendiniz olabildiğince büyük bir liste oluşturun ve başlayın bu listenin öğelerine erişmeye... Oluşturduğunuz bu listeye değişik sayılar verin. Bakın bakalım ne tür sonuçlar elde ediyorsunuz...

4.4. len() Fonksiyonu¶

Bir önceki bölümde gördüğünüz gibi, bir listenin kaç öğeden oluştuğunu bilmek önemli bir konu. Bir listedeki öğeleri elle saymaya çalışmak tabii ki hiç pratik bir yol değil. Neyse ki Python bize bu tür işlemler için işimize yarayacak bir fonksiyon sunuyor. Bu fonksiyonun adı len(). “len” ifadesi, İngilizce’deki “length” (uzunluk) kelimesinin kısaltmasıdır. Bu fonksiyon yardımıyla Python’da uzunluk ölçme işlemlerini yapacağız. Hemen bir örnek verelim:

>>> liste = ["kitap", "defter", "kalem", "silgi", "tebeşir",
... "tahta", "sıra", "öğrenci", "okul", "önlük"]

>>> print(len(liste))

10

Demek ki listemizde 10 tane öğe varmış. Peki bu listenin sonuncu öğesinin sırası kaçtır? Tabii ki 10 değildir. Hemen deneyip görelim:

>>> print(liste[10])

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Gördüğünüz gibi, listemizde 10. öğe diye bir şey yok. Çünkü bildiğiniz gibi listelerde saymaya 0’dan başlıyoruz. Yalnız farkettiyseniz len() fonksiyonu doğal olarak saymaya sıfırdan başlamıyor. Çünkü bu fonksiyon liste öğelerinin sırasıyla ilgilenmiyor. Bu fonksiyonun ilgilendiği şey listedeki öğelerin sayısı.. len() fonksiyonu bir listedeki öğenin sırasıyla ilgili herhangi bir bilgi vermez bize. Bu fonksiyonu kullanarak o listenin kaç adet öğesi olduğunu öğreniriz. Burada uyguladığımız len() fonksiyonuna göre bizim listemizin 10 adet öğesi varmış. Bu öğeleri sıralarken 0’dan başladığımız için sonuncu öğe doğal olarak 10-1 olacaktır. Yani sonuncu öğemizin sırası 9’dur:

>>> print(liste[9])

önlük

Herhangi bir listenin sonuncu öğesine kısa yoldan şöyle ulaşabileceğimizi bir önceki bölümde görmüştük:

>>> print(liste[-1])

Bu komut da bir öncekinde olduğu gibi “önlük” çıktısını verecektir. İsterseniz herhangi bir listenin son öğesine şu şekilde de ulaşabilirsiniz:

>>> print(liste[len(liste)-1])

önlük

Bu son komut gözünüze biraz karışık görünmüş olabilir, ama aslında hiç de karışık değildir. Şöyle düşünelim:

Listemizin 10 adet öğesi var. Python’da saymaya 0’dan başladığımız için, mantık olarak son öğe liste uzunluğunun bir eksiği olacaktır. Yani bizim örneğimizde son öğe “10-1” şeklinde gösterilebilir... Yani aslında yukarıdaki kodu şöyle de yazabiliriz:

>>> print(liste[10-1])

önlük

Ama böyle bir kod yazabilmek için listenin uzunluğunu tam olarak biliyor olmamız lazım. Listenin uzunluğunu önceden bilmediğimizi varsayarsak, yukarıdaki kodda “10” yerine bir formül yazmamız gerekir. Bize liste uzunluğunu tam olarak verebilecek kodun şu olduğunu biliyoruz:

>>> len(liste)

Dolayısıyla, bir listenin son öğesini bulmak için liste uzunluğunun bir eksiğini almamız, yani liste uzunluğundan “1” çıkarmamız yeterli olacaktır...

len() fonksiyonunu, daha önce öğrendiğimiz range() fonksiyonuyla birlikte de kullanabiliriz:

>>> print(list(range(len(liste))))

Yukarıdaki kod şununla eşdeğerdir:

>>> print(list(range(10))

Hatta istersek for döngüsünü kullanarak da benzer bir sonuç elde edebiliriz:

>>> for i in range(len(liste)):
...    print(i)

Gelin isterseniz şimdiye kadar öğrendiklerimizle az çok yararlı bir program yazalım. Mesela yukarıdaki listemizin öğelerini tek tek ekrana basalım ve her öğenin solunda birer numara gösterelim. Yani elde etmek istediğimiz çıktı şöyle bir şey olsun:

kitap
defter
kalem
silgi
tebeşir
tahta
sıra
öğrenci
okul
önlük

Öncelikle şöyle bir şeyler deneyelim:

>>> for eleman in liste:
...     print(eleman)

kitap
defter
kalem
silgi
tebeşir
tahta
sıra
öğrenci
okul
önlük

Liste öğelerini başarıyla ekrana yazdırdık. Ama bu çıktı bizim yapmaya çalıştığımız şeyden biraz uzak oldu. Demek ki kodlarımızda bazı değişiklikler yapmamız gerekiyor. Bir defa, bu öğelerin her birinin sırasını da ekrana basabilmeliyiz. Yani “1. defter”, “2. kalem”, gibi...

>>> for i in range(len(liste)):
...     print(i, liste[i])

kitap
defter
kalem
silgi
tebeşir
tahta
sıra
öğrenci
okul
önlük

Biraz karışık mı göründü gözünüze? Hiç endişelenmeyin. Burada ne yaptığımızı tane tane anlatacağız şimdi... Öncelikle şu satıra bakalım:

>>> for i in range(len(liste)):
...

Burada yaptığımız şey, listedeki öğe sayısını range() fonksiyonuna atamak. Yani aslında şöyle bir şey yazmış olduk:

>>> for i in range(10):
...

Elbette buraya her zaman “10” gibi sabit bir sayı yazamayabiliriz. Çünkü burada kullandığımız listeyi kendimiz oluşturduk ve kaç öğeden meydana geldiğini biliyoruz, ama gerçek hayatta bir listeyi her zaman kendiniz hazırlamamış olabilirsiniz. Mesela başkasının oluşturduğu bir listeyi alıp üzerinde işlem yapmanız gerekebilir. Öyle bir durumda o listenin kaç öğeden oluştuğunu kesin olarak bilemezsiniz. Hatta yazdığınız bir programın işleyişi sırasında sürekli olarak büyüyen bir liste de söz konusu olabilir. Bu tür durumlar için en uygun yol, sabit bir sayı yazmaya çalışmak yerine, bir formül kullanmak olacaktır. Bir listenin uzunluğunu bize verecek en uygun formül “len(liste)” formülüdür... Dolayısıyla şöyle bir şey yazmamız gerekir:

>>> for i in range(len(liste)):
...

Şimdi yazdığımız kodları incelemeye devam edelim. İlk satırla beraber, ikinci satır olarak şöyle bir şey yazdık:

>>> for i in range(len(liste)):
...     print(i, liste[i])

İlk satırı biraz önce açıklamıştık. Gelelim ikinci satıra... Burada öncelikle “i” değişkenini ekrana yazdırıyoruz. Şöyle bir şey yazarak resmi basitleştirelim:

>>> for i in range(len(liste)):
...    print(i)

0
1
2
3
4
5
6
7
8
9

Gördüğünüz gibi, bu kodlar, elimizdeki listenin uzunluğu kadar sayıyı ekrana basıyor. Yani sanki şöyle bir şey yazmışız gibi:

>>> for i in range(10):
...     print(i)

Şimdi de kodlarımızın geri kalanına bakalım. Önce tekrar topluca görelim kodlarımızı:

>>> for i in range(len(liste)):
...     print(i, liste[i])

Bir önceki bölümden hatırlayacağınız gibi, listelerin öğelerine tek tek ulaşmak istediğimizde şöyle bir yol izliyorduk:

>>> print(liste[0])

...veya...

>>> print(liste[2])

...gibi...

İşte yukarıda da aslında bu kalıba uygun bir kod yazdık... Birazcık sadeleştirelim:

>>> for i in range(len(liste)):
...     print(liste[i])

kitap
defter
kalem
silgi
tebeşir
tahta
sıra
öğrenci
okul
önlük

Sanırım ne yaptığımızı artık anladınız. Gördüğünüz gibi, range(len(liste)) komutu, listenin uzunluğu kadar olan sayıları ekrana basıyor. İşte biz bu sayıları liste[i] şeklinde tek tek kullanıyoruz. Buradaki for döngüsü sayesinde range(len(liste)) komutunun ürettiği her bir sayı tek tek liste[i] komutuna atanıyor. liste[0], liste[1], liste[2], liste[3], gibi...

Çıktıda görünen liste öğelerinin sol tarafında her birinin sırasının da görünmesi için kodlarımızı tabii ki şöyle yazdık:

>>> for i in range(len(liste)):
...     print(i, liste[i])

kitap
defter
kalem
silgi
tebeşir
tahta
sıra
öğrenci
okul
önlük

Yalnız, gördüğünüz gibi kodlarımız henüz elde etmek istediğimiz çıktıdan hâlâ biraz farklı... Bizim elde etmek istediğimiz çıktı şöyle bir şeydi:

kitap
defter
kalem
silgi
tebeşir
tahta
sıra
öğrenci
okul
önlük

Demek ki kodlarımıza hâlâ bazı eklemeler yapmamız gerekiyor. Gelin şimdi son darbeyi vuralım:

>>> for sondarbe in range(len(liste)):
...     print(sondarbe, liste[sondarbe], sep=". ")

kitap
defter
kalem
silgi
tebeşir
tahta
sıra
öğrenci
okul
önlük

“sep” parçacığını önceki derslerimizden hatırlıyorsunuz. Bu parçacık sayesinde öğeler arasına istediğimiz ifadeyi yerleştirebiliyorduk. Biz yukarıdaki örnekte her bir öğenin arasına “.” işareti koymak için kullandık bu parçacığı...

Yalnız, her ne kadar yukarıdaki kodlarla son darbeyi vurduğumuzu söylesek de aslında son darbeyi henüz vuramadık... Neden mi? Çünkü çıktıda saymaya sıfırdan başlanıyor. Bizim istediğimiz şey saymaya “0”dan değil, “1”den başlamaktı. Saymaya 0’dan başlamak Python için doğal olsa da son kullanıcı açısından biraz tuhaf gelebilecek bir şeydir... İyi bir programcı, yazdığı programlarda mutlaka son kullanıcıyı da düşünmelidir. Sonuçta sizin yazdığınız programı sizden çok, programlamadan hiç bir şey anlamayan insanlar kullanacaktır. O yüzden son kullanıcıyı düşünmeniz gerekir... Bu sorunu da ufak bir kodla halledeceğiz:

>>> for sondarbe in range(len(liste)):
...     print(sondarbe+1, liste[sondarbe], sep=". ")

kitap
defter
kalem
silgi
tebeşir
tahta
sıra
öğrenci
okul
önlük

Gördüğünüz gibi, “sondarbe+1” şeklinde bir kod yazarak sorunumuzu çözebildik. Böylece Python her bir sayıya “1” ekleyecek, dolayısıyla her bir öğenin sırası “1” sayı artırılacaktır. Bu da bize yukarıdaki gibi, kullanıcı açısından daha doğal görünen bir çıktı verecektir.

Böylece len() fonksiyonunu enine boyuna incelemiş olduk. Yalnız bir noktayı özellikle vurgulamakta fayda var: len() fonksiyonu sadece listelerle kullanılabilecek bir fonksiyon değildir. len() fonksiyonunu, uzunluğu ölçülebilecek her şey için kullanabiliriz. Mesela karakter dizilerinin de bir uzunluğu vardır. Hemen bir örnek verelim:

>>> a = "Kahramanmaraşlı Abdullah"

>>> print(len(a))

24

Demek ki “Kahramanmaraşlı Abdullah” karakter dizisinde 24 adet karakter varmış. Bu 24 sayısına iki kelime arasındaki boşluk karakterinin de dahil olduğunu unutmayın. Çünkü boşluğun kendisi de bir karakterdir...

Hatta listelerin bir özelliği olarak gördüğümüz “dilimleme” tekniği, karakter dizilerine de uygulanabilir. Buna da bir örnek verelim:

>>> a = "Kahramanmaraşlı Abdullah"

>>> print(a[0])

K

Şimdilik burada bir nokta koyup konuyu kapatalım. Daha sonraki derslerimizde “Karakter Dizileri” konusunu yeniden ve oldukça ayrıntılı bir şekilde ele alacağız. O zaman karakter dizilerinin bütün özelliklerine tek tek bakacağız. Biz listeleri incelemeye devam edelim...

4.5. Liste Öğelerinde Değişiklik Yapmak¶

Şimdiye kadar listelerle ilgili pek çok şey öğrendik sayılır. Ama henüz bir listenin öğelerini nasıl değiştirebileceğimizi bilmiyoruz. İşte bu derste bu eksiğimizi kapatacağız. Yani bir listedeki tanımlanmış öğeleri nasıl değiştireceğimizi göreceğiz. İşe bir liste tanımlayarak başlayalım:

>>> met = ["Kwrite", "Kate", "Emacs", "Vi", "Notepad"]

Diyelim ki biz bu listenin ilk öğesini değiştirmek istiyoruz. Listemizin ilk öğesi olan “Kwrite” yerine “Vim” yazalım:

>>> met[0] = "Vim"

Şimdi listemizin son halini kontrol edelim:

>>> print(met)

['Vim', 'Kate', 'Emacs', 'Vi', 'Notepad']

Gördüğünüz gibi, listemizin ilk öğesi olan “Kwrite” gitti, onun yerine “Vim” geldi. Python’da liste öğelerini değiştirmenin ne kadar kolay olduğunu görüyorsunuz. Siz de bu listenin başka öğelerini değiştirerek pratik yapabilirsiniz...

Bu noktada listelerin ilginç bir özelliğinden söz edeceğiz. Şimdi “met” adlı listemizi başka bir değişkene atayalım:

>>> yeni_liste = met

>>> print(met)

['Vim', 'Kate', 'Emacs', 'Vi', 'Notepad']

>>> print(yeni_liste)

['Vim', 'Kate', 'Emacs', 'Vi', 'Notepad']

Gördüğünüz gibi “yeni_liste” ve “met” aynı nesneye atıfta bulunuyor. Dolayısıyla ikisi de aynı çıktıyı veriyor. Şimdi şöyle bir işlem yapalım:

>>> yeni_liste[0] = "IDLE"

Şimdi iki listeyi de yazdıralım:

>>> print(yeni_liste)

['IDLE', 'Kate', 'Emacs, 'Vi', 'Notepad']

>>> print(met)

['IDLE', 'Kate', 'Emacs', 'Vi', 'Notepad']

Gördüğünüz gibi, biz sadece “yeni_liste” adlı listede değişiklik yaptığımız halde, bu değişiklik “met” adlı listeyi de etkiledi... Buradan şu sonucu çıkarıyoruz: Bir listeyi başka bir değişkene atadığınız zaman, aslında o listeyi kopyalamış olmuyorsunuz. Yaptığınız şey, varolan bir nesneye, yani listeye başka bir ad daha vermekten ibaret... Dolayısıyla burada hem “yeni_liste” hem de “met” aynı nesneyi gösteriyor. Eğer amacınız bir listeyi kopyalamaksa en basit şekilde şöyle bir yol izleyebilirsiniz:

>>> yeni_liste = met[:]

Artık bu listelerden birinde yaptığınız değişiklik ötekini etkilemeyecektir. Çünkü bu şekilde “met” adlı listenin bütün öğelerini baştan sona kopyalayıp yeni_liste adlı değişkene atadınız...

Yalnız şu ayrıma dikkat etmek gerekir:

Bir listenin öğeleri üzerinde değişiklik yapmakla, yeni bir liste oluşturmak farklı şeylerdir. Bu ne demek? Yani şöyle:

>>> yeni_liste = met

>>> print(met)

['Vim', 'Kate', 'Emacs', 'Vi', 'Notepad']

>>> print(yeni_liste)

['Vim, 'Kate', 'Emacs','Vi', 'Notepad']

Tıpkı biraz önce yaptığımız gibi, met adlı listeyi, yeni_liste adlı değişkene atadık. Artık elimizde, aynı nesneye işaret eden iki farklı değişken var. Şimdi şöyle bir işlem yapıyoruz:

>>> yeni_liste = ["falanca", "filanca", "şu", "bu", "o"]

Burada yeni_liste adlı listenin öğeleri üzerinde değişiklik yapmıyoruz. Yaptığımız şey, “yeni_liste” adını taşıyan, tamamen yeni bir liste tanımlamak... Şimdi bu yeni tanımladığımız listeyi yazdıralım:

>>> print(yeni_liste)

['falanca', 'filanca', 'şu', 'bu', 'o']

Bir de “met” adlı listenin durumuna bakalım:

>>> print(met)

['Vim', 'Kate', 'Emacs', 'Vi', 'Notepad']

Gördüğünüz gibi, burada “met” adlı listeyi kopyalamadan yeni_liste adlı değişkene atadığımız halde, yeni_liste’de sonradan yaptığımız değişiklik metin_düzenleyici’yi etkilemedi. Çünkü dediğimiz gibi, yukarıdaki yeni_liste’yi değiştirirken aslında bir liste üzerinde değişiklik yapmadık. Biz burada bambaşka bir liste oluşturduk. O yüzden iki listeden birinde yapılan değişiklik ötekini etkilemedi... Ama eğer yeni_liste[1] = “falanfilan” şeklinde bir değişiklik yapsaydık, bu değişiklikten öteki liste de etkilenecekti. Çünkü burada zaten varolan bir liste üzerinde değişiklik yapmış oluyoruz. Bu ikisi arasındaki ayrıma çok dikkat etmek gerekir.

4.6. “in” Parçacığı ile Aitlik Kontrolü¶

Konu başlığımız biraz bulanık görünmüş olabilir gözünüze. Ama hiç endişelenmeyin. Zor bir konudan bahsetmeyeceğiz. Bu derste işleyeceğimiz konu hem zevkli hem de epey faydalıdır. Bu bölümde in parçacığını kullanarak bir öğenin listede bulunup bulunmadığını kontrol edeceğiz. Yani “aitlik kontrolü” yapacağız...

Diyelim ki şöyle bir listemiz var:

>>> liste = ["elma", "armut", "karpuz", "şeftali"]

Şimdi bir öğenin bu listede bulunup bulunmadığını sorgulayacağız:

>>> "elma" in liste

True

Çıktımız “True” oldu. Bu kelime İngilizce’de “doğru” anlamına gelir. Demek ki “elma” karakter dizisi listeye “ait”miş... Yani bu öğe listede varmış... Bir de şuna bakalım:

>>> "erik" in liste

False

Bu defa “False” çıktısı aldık. Bu kelime ise İngilizce’de “Yanlış” anlamına gelir. Demek ki “erik” listede yokmuş.

Bununla ilgili daha anlamlı bir örnek verelim:

üyeler = ["Ahmet", "Mehmet", "Selim", "Süleyman", "Ayşe",
          "Fatma", "Hale", "Jale", "Lale"]

ad = input("Lütfen adınızı giriniz:")

if ad in üyeler:
    print("Gizli derneğimizin üyelerindensiniz. Buyrun içeri!")

else:
    print("Üye değilsiniz!")

Bu in parçacığını for döngülerini işlerken de görmüştük. Bu parçacığın oradaki işleviyle buradaki işlevinin aslında birbirine çok benzer olduğunu görüyorsunuz... Bu parçacık her iki durumda da “içinde” anlamı katıyor cümleye...

Bu parçacığı elbette sadece listelerle birlikte kullanmak zorunda değiliz. Mesela bunu karakter dizileriyle de kullanabiliriz:

>>> a = "Mehmet"

>>> "e" in a

True

Bu in parçacığı ile birlikte kullanılan not parçacığını da burada anmamız oldukça faydalı olacaktır. not parçacığı kodlarımıza olumsuzluk anlamı katar. Mesela yukarıdaki örneği “not” kullanarak şöyle de yazabiliriz:

üyeler = ["Ahmet", "Mehmet", "Selim", "Süleyman", "Ayşe",
          "Fatma", "Hale", "Jale", "Lale"]

ad = input("Lütfen adınızı giriniz:")

if ad not in üyeler:
    print("Üye değilsiniz!")

else:
    print("Gizli derneğimize üyesiniz. Buyrun içeri!")

İlk örnekte “if ad in üyeler” ifadesiyle, “eğer ad üyeler listesi içinde varsa...” demiştik. Burada ise “eğer ad üyeler listesi içinde yoksa...” dedik... Yani cümlemize olumsuz bir anlam kattık.

4.7. Listelerin Metotları¶

Bu bölümde “metot” diye bir şeyden söz edeceğiz. Python’da bu “metot” denen şey bir hayli önem taşır ve epey de işe yarar. Metotlar yardımıyla pek çok karmaşık işlemi çok basit bir şekilde yerine getirebiliriz. Öncelikle elimizde kullanabileceğimiz hangi metotların olduğuna bir bakalım. Bu iş için Python’daki dir() fonksiyonundan yararlanabiliriz. Listelerin metotlarını sıralamak istersek, bu fonksiyonu şu şekilde kullanıyoruz:

>>> dir(list)

...veya şu da olur:

>>> a = []
>>> dir(a)

Yani önce herhangi bir liste tanımlayıp (burada biz boş bir liste tanımladık), daha sonra dir() fonksiyonunu bu liste üzerine de uygulayabiliriz.

Hangi yolu benimsersek benimseyelim, alacağımız çıktı şu olacaktır:

['__add__', '__class__', '__contains__', '__delattr__',
 '__delitem__', '__doc__', '__eq__', '__format__',
 '__ge__','__getattribute__', '__getitem__', '__gt__',
 '__hash__', '__iadd__', '__imul__', '__init__', '__iter__',
 '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__',
 '__reduce__', '__reduce_ex__', '__repr__', '__reversed__',
 '__rmul__', '__setattr__', '__setitem__', '__sizeof__',
 '__str__', '__subclasshook__', 'append', 'count', 'extend',
 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

Burada sağında solunda “__” işareti olmayanlar bizim ilgi alanımıza giren metotlardır. Ötekiler ise bizim şu anda konumuz dışında kalan “özel metotlar”dır. Onlarla şimdilik ilgilenmeyeceğiz. Peki dir(list) komutu ile aldığımız listeyi Python programlama bilgimizi kullanarak ayıklayabilir miyiz? Yani sağında solunda “__” işareti olan metotları hiç göstermeden sadece ilgi alanımıza giren metotları alabilir miyiz? Elbette alabiliriz. Bu örnek bize iyi bir pratik yapma imkanı sağlayacak:

>>> for i in dir(list):
...     if "_" not in i:
...         print(i)

append
count
extend
index
insert
pop
remove
reverse
sort

Burada yaptığımız şey Python’a şu komutu vermek:

“Ey Python! dir(list) komutunun çıktısını baştan sona tara ve her bir öğeyi “i” olarak adlandır. Ardından bu “i”ler içinde “_” işaretini barındırmayanları bul ve ekrana bas!”

Peki ilgilendiğimiz metotların kaç adet olduğunu nasıl bulursunuz? “Elle sayarım!” diyenleri şiddetle kınıyorum! Burada metot sayısı az olduğu için kod yazmak gereksiz görünebilir, ama ya yüzlerce öğe olsaydı saymamız gereken... Onları da elle mi sayacaktık? Elbette hayır! Gelin şimdi bu ilgilendiğimiz öğeleri numaralandıralım:

>>> a = dir(list)
>>> b = []
>>> for i in a:
...    if "_" not in i:
...        b.append(i)
...        print(len(b), i, sep=".")

1.append
2.count
3.extend
4.index
5.insert
6.pop
7.remove
8.reverse
9.sort

Bu kodlar içinde şimdiye kadar görmediğimiz tek şey append(). Öteki öğelerle daha önceki derslerimizde pek çok örnek yapmıştık.

Burada öncelikle a = dir(list) şeklinde bir değişken tanımladık. dir(list) komutunu “a” adlı bir değişkene atamak bize kullanım kolaylığı sağladı. Böylece dir(list) kodunu kullanmamız gereken yerlerde uzun uzun bu komutu yazmaktansa kısaca “a” değişkenini kullanabileceğiz.

Ardından b = [] diyerek boş bir liste oluşturduk. Bu boş liste içine ilgilendiğimiz metotları yerleştireceğiz.

Bir sonraki satırda ise basit bir for döngüsü yazdık. Bu döngü yardımıyla dir(list) komutunun çıktısını baştan sona tarayıp, içinde “_” işareti geçmeyen öğeleri bulduk.

Bu satırın ardından b.append(i) gibi bir kod görüyoruz. append() listelerin metotlarından biridir. Bu metodu ve diğerlerini bir sonraki bölümde ayrıntılı olarak inceleyeceğiz. Şimdilik şu kadarını söyleyelim: Bu metot bir listeye yeni öğeler eklememizi sağlar. Zaten burada yaptığı iş de budur. b.append(i) komutu yardımıyla, ilk başta oluşturduğumuz “b” adlı boş listeye bütün “i”leri ekliyoruz. Bu “i”lerin ne olduğunu biliyorsunuz: Bir önceki satırda for döngüsü ile belirlediğimiz, “_” işareti içermeyen öğeler... Yani dir(list) çıktısı içinde “_” işaretini taşımayan öğeleri b.append(i) komutu ile “b” adlı listeye eklemiş oluyoruz.

En son satırda ise “b” adlı listenin uzunluğunu ekrana basıyoruz. Bununla birlikte, “i”leri de tek tek yazdırıyoruz.

Buradaki “sep” parçacığının işlevini biliyorsunuz. Her bir öğe arasına “.” işareti koymak için bu parçacıktan yararlanıyoruz...

Kodlar arasındaki len(b)‘nin nasıl kullanıldığına dikkat edin. len(b)‘nin buradaki kullanımı Python’daki for döngülerinin işleyişi hakkında bize çok önemli bir bilgi veriyor. Dikkat ederseniz, burada len(b), ekrana yazdırdığımız öğelerin sol tarafına denk gelen numaraları gösteriyor. Yani yukarıdaki çıktıda elde ettiğimiz “1, 2, 3, 4, 5, 6, 7, 8 ve 9” sayılarının ekrana basılmasından bu kod sorumlu... Peki len(b) kodu nasıl oluyor da bu sayıları bu şekilde ekrana basabiliyor? Bunu anlamak için for döngüsünün nasıl işlediğini incelememiz gerekiyor. Yukarıdaki for döngüsünün işleyişini adım adım görelim:

“a” adlı değişken içindeki bütün öğeleri tek tek tara ve bu öğelerin her birine “i” adını ver.

Eğer “i” adını verdiğimiz bu öğeler arasında, içinde “_” işareti geçmeyenler varsa...

Bu öğeleri “b” adını verdiğimiz boş listeye ekle.

dir(list) çıktısı içinde, “_” işaretini içermeyen ilk öğe “append”. Dolayısıyla bunu hemen “b” adlı listeye ekle.

Şimdi “b” adlı listenin uzunluğunu ve öğenin kendisini ekrana bas. Bu ikisinin arasına da bir adet “.” işareti koy.

“b” adlı listenin içinde “1” adet öğe var. Bu öğe “append” Dolayısıyla ekrana basacağın ifade şu: “1.append”

Şimdi tekrar dir(list) çıktısını kontrol et. Orada “_” işaretini içermeyen başka bir öğe var mı?

Evet var. Bu öğenin adı “count”. Dolayısıyla hemen bunu da “b” adlı listeye ekle.

Listenin uzunluğu “2” oldu. Bu sayıyı ve yeni bulduğun öğeyi ekrana bas. Bunların arasına da bir adet “.” işareti koy.

Dolayısıyla ekrana basacağın ifade şu: “2.count”

Python bu işlemleri dir(list) çıktısının hepsini kontrol edip bitirinceye kadar sürdürür ve her defasında bir işlem yaparak bize şu çıktıyı verir:

append
count
extend
index
insert
pop
remove
reverse
sort

Burada append() metodunun kullanımıyla ilgili bir örnek verdik. Yukarıdaki çıktıdan da gördüğünüz gibi, append()‘den başka, listelerin daha pek çok metodu vardır. Bu metotlar bize yapacağımız işlerde büyük kolaylıklar sağlar. Bu dersimizde listelerin metotları konusuna sağlam bir giriş yaptığımıza göre, artık bu metotları tek tek incelemeye geçebiliriz...

4.7.1. append Metodu¶

Bir önceki bölümde append() metoduna değinmiştik. Orada söylediğimize göre bu metodun görevi bir listeye öğe eklemek idi. Zaten “append” kelimesi İngilizce’de “eklemek, iliştirmek” gibi anlamlara gelir. Hemen bu metodu nasıl kullanabileceğimizi gösteren bir örnek yapalım. Önce bir liste tanımlayalım. İsterseniz boş bir liste olsun bu:

>>> liste = []

Listemizi kontrol edelim:

>>> print(liste)

[]

Hakikaten listemiz boş!

Şimdi bu boş listeye bir öğe ekleyelim:

>>> liste.append("Ubuntu")

Şimdi listemizi tekrar kontrol edelim:

>>> print(liste)

['Ubuntu']

Bu listeye şimdi başka bir öğe daha ekleyelim:

>>> liste.append("Debian")

Listemize bakalım tekrar:

>>> print(liste)

['Ubuntu', 'Debian']

Listemizin öğelerine tek tek erişebileceğimizi biliyorsunuz:

>>> print(liste[0])

Ubuntu

...veya..

>>> print(liste[1])

Debian

Hatta liste öğelerini ters de çevirebiliriz:

>>> print(liste[::-1])

['Debian', 'Ubuntu']

Peki ya bir öğeyi değiştirmek istersek...

>>> liste[1] = "Gentoo"

>>> print(liste)

['Debian', 'Gentoo']

append() metodunu kullanarak bir listeye sadece tek bir öğe ekleyebiliriz. Yani şöyle bir şey mümkün değildir:

>>> liste.append("SuSe", "RedHat")

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: append() takes exactly one argument (2 given)

Bu hata çıktısına göre append() metodu yalnızca tek bir öğe alabiliyor. Biz ise 2 tane vermişiz...

Ama şöyle bir şey yapmak mümkündür:

>>> liste.append(["SuSe", "RedHat"])

Gördüğünüz gibi, “SuSe” ve “RedHat” öğelerini bir liste olarak ekledik. Yalnız, öğeleri bu şekilde eklediğimizde listenin durumu pek beklediğiniz gibi olmayabilir:

>>> print(liste)

['Debian', 'Gentoo', ['SuSe', 'RedHat']]

Gördüğünüz gibi, “SuSe” ve “RedHat” öğeleri listeye ayrı bir liste olarak eklendi. Yani aslında yine listeye tek bir öğe eklenmiş oldu:

>>> print(liste[2])

['SuSe', 'RedHat']

Demek ki listemizin üçüncü öğesi buymuş... Burada sadece “SuSe” öğesini almak isterseniz şöyle bir şey yazmanız gerektiğini biliyorsunuz:

>>> print(liste[2][0])

'SuSe'

“RedHat”i almak için ise:

>>> print(liste[2][1])

'RedHat'

Eğer append() metodunu kullanarak bir listeye birden fazla öğe eklemek isterseniz elbette çaresiz değilsiniz. for döngüsü ne güne duruyor?

>>> for s in ["Fedora", "Knoppix"]:
...     liste.append(s)

['Debian', 'Gentoo', ['SuSe', 'RedHat'], 'Fedora', 'Knoppix']

Dediğimiz gibi, for döngüsünü kullanarak bu şekilde birden fazla öğeyi listeye ekleyebilirsiniz. Ama isterseniz, bu işlem için üretilmiş ayrı bir metottan da yararlanabilirsiniz. Bu yeni metodun adı extend(). Bunu bir sonraki bölümde göreceğiz... Ama append() metodu ile ilgili olarak söylememiz gerekenler henüz bitmedi.

append() metodu liste metotları içinde en çok kullanılan metottur. Dolayısıyla listelerin başka hiçbir metodunu bilmeseniz de append() metodunu bilmeniz gerekir. Bu metodu kullanarak bazı örnekler vermeye devam edelim. Mesela şu programa bakalım:

tek_sayılar = []
çift_sayılar = []

başla = 1

bilgi = """Rastgele sayılar giriniz.
Her sayı girişte enter tuşuna basınız.
İşlemi bitirmek için "ç" tuşuna basınız:"""

print(bilgi)

while başla == 1:
    soru = input()

    if soru == "ç":
        başla = 0

    elif int(soru) % 2 == 0:
        çift_sayılar.append(soru)

    else:
        tek_sayılar.append(soru)

print("Girdiğiniz şu sayılar çifttir: ", çift_sayılar)
print("Girdiğiniz şu sayılar ise tektir: ", tek_sayılar)

Burada öncelikle “tek_sayılar” ve “çift_sayılar” adlı iki farklı liste oluşturduk. Kullanıcıdan gelecek tek ve çift sayıları ayrı ayrı listelerde depolayacağız.

Ardından “başla = 1” şeklinde bir kod yazarak “başla” değişkenini “1” olarak ayarlıyoruz. Bu değişken, programın bitişini kontrol etmemizi sağlayacak.

Daha sonra “bilgi” adlı başka bir değişken daha tanımlıyoruz. Burada kullanıcıyı programın nasıl çalıştırılacağı hakkında bilgilendiriyoruz. Buna göre kullanıcıdan rastgele sayılar girmesini, her sayıdan sonra da enter tuşuna basmasını istiyoruz. Eğer kullanıcı programdan çıkmak isterse “ç” tuşuna basacak.

Bir sonraki satırda bilgi adlı değişkeni ekrana yazdırıyoruz.

Daha sonra, programımızın sürekli olarak çalışmasını temin etmek için bir while döngüsü kuruyoruz. Programımızın sürekli olarak çalışması “başla” adlı değişkenin değerinin “1” olmasına bağlı. En başta, bu “başla” adlı değişkenin değerini “1” olarak ayarladığımız için programımız sürekli olarak çalışmaya devam edecektir.

Bir alttaki satırda kullanıcıdan veri almamızı sağlayacak olan input() fonksiyonunu yazıyoruz. Dikkat ederseniz input() fonksiyonunu boş bıraktık. Neden? Çünkü zaten kullanıcıya göstereceğimiz bilgiyi en başta “bilgi” adlı bir değişken tanımlayarak gösterdik. Elbette isteseydik bu input() fonksiyonuyla da kullanıcıya bilgi verebilirdik. Ama burada input() fonksiyonunu boş bırakmamızın nedeni biraz da estetik kaygılar.. Çünkü programımız içinde bir while döngüsü olduğu için, eğer burada input() fonksiyonunu boş bırakmazsak, kullanıcı her sayı girişinde bu input() fonksiyonu içinde tanımladığımız karakter dizisini de görecektir. İsterseniz, input() fonksiyonunu boş bırakmadan bir deneme yapın. Göreceğiniz gibi, kullanıcının her sayı girişinde tekrar tekrar aynı karakter dizisini görmesi pek hoş olmuyor...

Bir sonraki adımda programdan çıkış koşulumuzu belirliyoruz. Eğer kullanıcı “ç” harfine basarsa “başla” değişkeninin değeri “0” olarak ayarlanacaktır. Daha önce tanımladığımız while döngüsüne göre, programımızın sürekli olarak çalışması “başla” değişkeninin değerinin “1” olmasına bağlıydı. Kullanıcı “ç” tuşuna bastığında “başla” değişkeninin değeri “0” olacağı için programımız duracaktır.

Hemen ardından kullanıcıdan gelen sayıların çift olup olmadığına bakıyoruz. Burada “soru” değişkenini int() fonksiyonu yardımıyla sayıya çevirdiğimize dikkat edin. Bildiğiniz gibi, input() fonksiyonunun verdiği değerin tipi karakter dizisidir. Kullanıcıdan gelen bilgiyle aritmetik bir işlem yapabilmek için bu bilgiyi öncelikle sayıya dönüştürmemiz gerekir. Bir önceki satırda programdan çıkış koşulunu tanımlarken “soru” değişkenini sayıya dönüştürmediğimize dikkat edin. Aksi halde kullanıcı “ç” tuşuna bastığında Python “ç” harfini sayıya dönüştürmeye çalışacak, bunu başaramayınca da hata verecektir. O yüzden orada input() fonksiyonuna herhangi bir dönüştürme işlemi uygulamadık... Çift sayıları belirledikten sonra “çift_sayılar.append(soru)” komutu yardımıyla kullanıcıdan aldığımız çift sayıları “çift_sayılar” adlı listeye ekliyoruz.

Şimdi sıra geldi tek sayıları belirlemeye. Bunu da bir else: bloğu yardımıyla yapıyoruz. Eğer kullanıcıdan gelen bilgi bir çift sayı değilse veya kullanıcı “ç” harfine basmamışsa kullanıcının girdiği sayı bir tek sayıdır. Bunu da “tek_sayılar” adlı listeye ekliyoruz. Tabii kullanıcı “ç” harfi dışında başka bir harfe basarsa programımız hata verecektir. Henüz bu tür durumlara karşı önlem almayı bilmiyoruz. Ama ilerde bunu nasıl yapacağımızı da öğreneceğiz. Fakat şimdilik şöyle bir kod yazarak en azından bu tür bir problemi büyük ölçüde çözmüş olursunuz:

tek_sayılar = []
çift_sayılar = []

kontrol = "0123456789"

başla = 1

bilgi = """Rastgele sayılar giriniz.
Her sayı girişte enter tuşuna basınız.
İşlemi bitirmek için "ç" tuşuna basınız:"""

print(bilgi)

while başla == 1:
    soru = input()

    if soru == "ç":
        başla = 0

    elif soru[0] not in kontrol:
        print("lütfen bir sayı giriniz")

    elif "." in soru:
        print("yoksa ondalık bir sayı mı girdiniz?")

    elif int(soru) % 2 == 0:
        çift_sayılar.append(soru)

    else:
        tek_sayılar.append(soru)

print("Girdiğiniz şu sayılar çifttir: ", çift_sayılar)
print("Girdiğiniz şu sayılar ise tektir: ", tek_sayılar)

Burada bir önceki kodlara ilave olarak bir “kontrol” değişkeni tanımlıyoruz. Bu değişken 0’dan 9’a kadar olan bütün sayıları içeriyor. Daha sonra program içinde iki adet elif... bloğu oluşturarak bu kontrol değişkeninin içindeki sayılara göre bazı denetlemeler yapıyoruz. Burada daha önce öğrendiğimiz in ve not parçacıklarını kullandığımıza dikkat edin. Bu parçacıklar yardımıyla, kullanıcının girdiği verilerin kontrol değişkeni içinde olup olmadığını denetliyoruz. Yani “aitlik” kontrolü yapıyoruz... Burada ayrıca kontrol değişkenimizin bir karakter dizisi olduğuna dikkat edin. Daha önce de söylediğimiz gibi, in ve not parçacıkları sadece listelere özgü bir özellik değildir. Bunları Python’daki başka öğelerle birlikte de kullanabiliriz. Dediğimiz gibi, bu kodlar da karşı karşıya olduğumuz sorunu tam anlamıyla çözmeye yetmez. Bu sorunun kökten çözümünü birkaç ders sonra göreceğiz.

Şimdi artık bir sonraki metodumuzu incelemeye geçebiliriz.

4.7.2. extend Metodu¶

Hatırlarsanız bir önceki bölümde append() metodunu işlerken, bu metotla bir listeye birden fazla öğe eklenemeyeceğini söylemiştik. append() metodu yardımıyla, eklemek istediğimiz birden fazla öğeyi liste haline getirip o şekilde ekleyebiliyorduk. Ama eklenen bu liste de aslında tek bir öğe olarak ekleniyordu. Mutlaka birden fazla öğe eklemek istediğimizde ise for döngülerinden yararlanıyorduk. Ama aslında for döngüsüne hiç gerek olmadan, listelerin extend() adlı metodu yardımıyla da bu isteğimizi yerine getirebiliriz. Nasıl mı? Hemen bir örnek verelim. Şöyle bir listemiz vardı:

>>> liste = ["Debian", "Gentoo", "Fedora", "Knoppix"]

Şimdi extend() metodunu kullanarak, bu listeye yeni öğeler ekleyeceğiz:

>>> liste.extend(["Arch", "Ubuntu", "Kubuntu", "PCLinuxOs"])

['Debian', 'Gentoo', 'Fedora', 'Knoppix', 'Arch',
 'Ubuntu', 'Kubuntu', 'PCLinuxOs']

Gördüğünüz gibi, append metodunun aksine, extend metodu eklediğimiz öğeleri teker teker yerleştirdi listeye. Üstelik bizi herhangi bir for döngüsü kullanmak zorunda da bırakmadı.

Aslında extend() metodunun yaptığı işi sadece “+” işaretini kullanarak da yapabilirsiniz. Mesela şu örneğe bakalım:

>>> liste = ["Debian", "Gentoo", "Fedora", "Knoppix",
... "Arch", "Ubuntu", "Kubuntu", "PCLinuxOs"]

>>> yeni_liste = ["Mandriva", "Sabayon", "OpenSuSe"]

>>> liste = liste + yeni_liste

>>> print(liste)

['Debian', 'Gentoo', 'Fedora', 'Knoppix', 'Arch', 'Ubuntu',
 'Kubuntu', 'PCLinuxOs', 'Mandriva', 'Sabayon', 'OpenSuSe']

Hangi yöntem kolayınıza geliyorsa onu seçmekte özgürsünüz...

4.7.3. insert Metodu¶

Python’un bize sunduğu bir başka metot da insert() adlı metottur. Bu metot yardımıyla listenin herhangi bir noktasına öğe ekleyebiliyoruz. “insert” kelime anlamı olarak “yerleştirmek” demek... İşte bu metotla istediğimiz bir öğeyi bir listenin istediğiniz noktasına yerleştirebileceğiz. Mesela bu metot yardımıyla örnek bir listenin 1. sırasına (Dikkat edin, 0’ıncı sıraya demiyoruz) istediğimiz bir öğeyi yerleştirebiliriz:

>>> bir_liste = ["Debian", "Gentoo", "Fedora", "Knoppix",
... "Arch", "Ubuntu", "Kubuntu", "PCLinuxOs",
... "Mandriva", "Sabayon", "OpenSuSe"]

>>> bir_liste.insert(1, "Mint")

>>> print(bir_liste)

['Debian', 'Mint', 'Gentoo', 'Fedora', 'Knoppix', 'Arch', 'Ubuntu',
 'Kubuntu', 'PCLinuxOs', 'Mandriva', 'Sabayon', 'OpenSuSe']

Gördüğünüz gibi listemizin birinci sırasına “Mint” adlı öğeyi yerleştirdik. Bu metot da, tıpkı append() metodunda olduğu gibi tek bir öğe yerleştirmemize izin verir. Ama tabii ki for döngülerinden yararlanarak bu kısıtlamayı aşabileceğinizi biliyorsunuz:

>>> liste = ["elma", "armut", "kebap"]

>>> ekle = ["lahmacun", "pide", "şeftali"]

>>> for i in ekle:
...     liste.insert(0, i)

Burada liste’nin 0. sırasına üç adet yeni öğe yerleştiriyoruz. Yalnız burada yeni yerleştirilen öğelerin ters çevrildiğine dikkat edin...

4.7.4. remove Metodu¶

Python listelere öğe eklemenin yanısıra, bize listelerden öğe silme imkanı da sağlar. Bunun için listelerin remove() metodunu kullanacağız:

>>> bir_liste = ["Debian", "Gentoo", "Fedora", "Knoppix",
... "Arch", "Ubuntu", "Kubuntu", "PCLinuxOs",
... "Mandriva", "Sabayon", "OpenSuSe"]

>>> bir_liste.remove("Fedora")

Eğer listede birden fazla “Fedora” varsa, Python soldan sağa doğru, listede bulduğu ilk “Fedora”yı listeden çıkaracaktır.

Eğer listedeki bir öğeyi adına göre değil de sırasına göre çıkarmak isterseniz şöyle bir yol izleyebilirsiniz:

>>> bir_liste.remove(bir_liste[3])

Bu kod, “bir_liste” adlı listenin 3. sırasındaki öğeyi çıkaracaktır.

4.7.5. index Metodu¶

Bu metot, bir listedeki öğenin sırasını bulmamızı sağlar. Hemen bir örnek verelim:

>>> bir_liste = ["Debian", "Gentoo", "Fedora", "Knoppix",
... "Arch", "Ubuntu", "Kubuntu", "PCLinuxOs",
... "Mandriva", "Sabayon", "OpenSuSe"]

>>> bir_liste.index("Sabayon")

9

Eğer listede olmayan bir öğeyi sorgularsanız Python bir hata mesajı gösterecektir.

4.7.6. sort Metodu¶

sort() metodu ile liste öğelerini alfabe sırasına dizeceğiz. Yalnız bu metot Python listelerinin en “gıcık” metotlarından biridir. Neden böyle olduğunu biraz sonra göreceğiz. Ama önce sort() ile ilgili bir örnek yapalım:

>>> liste = ["Mehmet", "Ahmet", "Cemal", "Seval", "Kezban"]

>>> liste.sort()

>>> print(liste)

['Ahmet', 'Cemal', 'Kezban', 'Mehmet', 'Seval']

Gördüğünüz gibi, Python bu listemizi güzel güzel alfabe sırasına koydu. Yalnız bu listede bir şey dikkatinizi çekmiş olmalı. Listedeki hiçbir isim Türkçe karakter içermiyor! Bunu bilerek böyle yaptık. Çünkü içinde Türkçe karakterler geçen kelimeleri sıralamak o kadar kolay değildir. İsterseniz deneyelim:

>>> liste = ["Mehmet", "Ahmet", "Şevket", "Çetin",
... "Cemal", "Seval", "Kezban"]

>>> liste.sort()

>>> print(liste)

['Ahmet', 'Cemal', 'Kezban', 'Mehmet', 'Seval',
 'Çetin', 'Şevket']

Gördüğünüz gibi, Python bu defa liste öğelerini alfabe sırasına dizmekte başarısız oldu. Burada “Çetin” ve “Şevket”in yerleri yanlış... Peki bunu nasıl düzelteceğiz?

Bu sorunu düzeltmek için henüz öğrenmediğimiz bazı öğeler kullanmamız gerekecek:

>>> import locale
>>> locale.setlocale(locale.LC_ALL, "tr_TR.UTF8")

>>> liste = ["Mehmet", "Ahmet", "Şevket", "Çetin",
... "Cemal", "Seval", "Kezban"]

>>> liste.sort(key=locale.strxfrm)

>>> print(liste)

Buradaki bilmediğiniz öğelere takılmayın. Yeri geldiğinde bunları ayrıntılarıyla inceleyeceğiz. Burada bu kodu vermekteki amacım sort() metoduyla Türkçe karakter içeren sözcükleri de sıralayabileceğinizi göstermek. Yalnız yukarıda verdiğim yöntem GNU/Linux için geçerlidir. Windows’ta çalışmayabilir...

4.7.7. reverse Metodu¶

Bu bölümde göreceğimiz reverse() metodu, liste öğelerinin sırasını ters çevirmemizi sağlar. Yani bu metot yardımıyla liste öğelerini tersyüz edebiliriz:

>>> liste = list(range(11))

>>> print(liste)

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

Elbette 0’dan 10’a kadar olan sayıları içeren bir liste oluşturmak için sayıları tek tek elle yazmaya gerek yok. Bu iş için range() metodundan yararlanabiliyoruz... Şimdi range() fonksiyonundan da yardım alarak oluşturduğumuz bu listeyi ters çevirelim:

>>> liste.reverse()

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

Gördüğünüz gibi, reverse() metodu listedeki öğelerin sırasını tersine çeviriyor. Aslında biz bu işi reverse() metodunu kullanmadan da yapmayı öğrenmiştik:

>>> liste[::-1]

Yalnız bu yöntem ile reverse() metodunu kullanmak arasında önemli bir fark var. reverse() metodu, uygulandığı liste üzerinde derhal değişiklik yapıyor. Yani bir listeye reverse() metodunu uygulayıp liste öğelerinin sırasını değiştirdiğinizde eski listeyi kaybetmiş oluyorsunuz. Artık eski listeye tekrar ulaşmanızın imkanı yoktur. Tabii yeni listeye tekrar reverse() metodunu uygularsanız eski listeye benzeyen başka bir liste oluşturabilirsiniz. Bu durumun aksine, liste[::-1] komutu liste üzerinde herhangi bir değişiklik yapmaz. İsterseniz bu yöntemi uyguladıktan sonra “print(liste)” komutunu vererek bunu doğrulayabilirsiniz. Bu komutu verdiğinizde karşınıza öğeleri ters çevrilmemiş olan liste gelecektir. Eğer yukarıdaki yöntem yardımıyla listeyi değiştirmek isterseniz şöyle bir şey yapmanız gerekir:

>>> liste = liste[::-1]

Bu şekilde “liste” adlı listemizi değiştirebiliyoruz. Bu iki yöntem arasındaki fark önemli bir farktır. Bunu unutmamak gerekir.

4.7.8. count Metodu¶

Bu metot bir öğenin bir listede kaç kez geçtiğini bulmamızı sağlar. Kullanımı çok basittir:

>>> liste = ["elma", "armut", "elma", "kebap", "şeker",
... "armut", "çilek", "ağaç", "şeker", "kebap", "şeker"]

>>> liste.count("elma")

2

Peki yukarıdaki listede gördüğümüz her bir öğenin listede kaç kez geçtiğini nasıl buluruz? Tabii ki bir for döngüsü yardımıyla:

>>> for i in liste:
...     print(i, "öğesi listede", liste.count(i), "kez geçiyor...")

Fena değil... Ama bu kodların bir sorunu var. Her cümleyi, öğenin listede geçtiği sayı kadar tekrar ediyor. Her öğeyle ilgili cümleyi bir kez bassa ne iyi olurdu, değil mi?

Elbette bunu da yapmanın yolları vardır. Bunun en kolay yolu Python’daki set() fonksiyonunu kullanmaktır. Bu fonksiyonu daha sonraki bir bölümde detaylı olarak inceleyeceğiz. Şimdilik sadece nasıl kullanıldığına dikkat edelim yeter:

for i in set(liste):
    print(i, "öğesi listede", liste.count(i), "kez geçiyor...")

4.7.9. pop Metodu¶

pop() metodu listelerin ilginç ve sevimli bir metodudur! Bu metot bazı yönlerden remove() metoduna benzer. Tıpkı remove() metodunda olduğu gibi, pop() metoduyla da listeden öğe silebiliriz. Şu örneğe bakalım:

>>> liste = ["FVWM", "FVWM95", "TWM/VTWM", "MWM", "CTWM",
... "OLWM/OLVWM", "wm2/wmx", "AfterStep", "AmiWM",
... "Enlightenment", "WindowMaker", "SCWM", "IceWM",
... "Sawfish", "Blackbox", "Fluxbox", "Metacity"]

>>> liste.pop()

'Metacity'

Şimdi listeyi tekrar ekrana yazdırırsanız en sondaki “Metacity” öğesinin olmadığını göreceksiniz. pop() metodu bu öğeyi listeden sildi. Silerken de ekrana çıktı olarak verdi... Demek ki pop() metodu bir listedeki en son öğeyi silip, sildiği öğeyi ekranda gösteriyor. Elbette bu metodu kullanarak illa son öğeyi sileceğiz diye bir kaide yok. Eğer istersek, pop() metodu içinde, silmek istediğimiz liste öğesinin sırasını belirterek, belirli bir öğeyi de silebiliriz:

>>> liste.pop(0)

'FVWM'

Bu metodun remove() metodundan farkı, remove() metodunun liste öğelerinin adına göre, pop() metodunun ise liste öğelerinin sırasına göre öğe silmesidir... Yani şöyle:

>>> liste.remove("AmiWM")

>>> liste.pop(7)

Gördüğünüz gibi pop() metodunu kullanabilmek için sileceğimiz öğenin listede kaçıncı sırada bulunduğunu bilmemiz gerekiyor. Eğer sileceğiniz öğenin adını biliyor, ancak sırasını bilmiyorsanız şöyle bir şey yapabilirsiniz. (“IceWM” adlı öğeyi silmek istiyoruz...):

>>> liste.pop(liste.index("IceWM"))

Burada kullandığımız index() metodu “IceWM” adlı öğenin listedeki sırasını verecek, pop() metodu ise index metodundan gelen bu sayıyı kullanarak “IceWM” adlı öğeyi listeden çıkaracak ve ekrana basacaktır...

Python Programlama Dili