Ders 13
Ders 13
2.2 - Tekrarlı işlemler
Bir blok içeriğinde tanımlanmış olan bildirimlerin, belirli bir koşul doğrulanıncaya kadar tekrar edilmesine, tekrarlı (iteratif) işlemler adı verilir. Tekrarlı işlemler, matematikte bir çok kuramsal problemin, sayısal çözümlerinin sağlanmasında, büyük rol oynamaktadırlar. Özellikle, bilgisayarların güvenirliklerinin arttığı ve uygulamalarının yaygınlaştığı 1950 lerden sonra bu konuda çalışmalar yoğunlaşmıştır.
Tekrarlı işlemlerin, matematikte başarabileceği çalışmaların önemine ilk olarak, on dokuzuncu asrın ikinci yarısında, Lord Byron'un kızı Ve Lord Lovelace'in eşi, ilk sayısal hesap matematikçisi Lady Ada Lovelace olmuştur. Lady Ada Lovelace, büyük matematikçi Charles Babbage tarafından düşünülen ve ilk bilgisayar olarak adlandırılan "Analytical Machine" cihazının çalışma yöntemi açıklandığında, özellikle tekrarlı (iteratif) işlemlerden etkilenerek yazmış olduğu iki makale, günümüzün "Sayısal Analiz" bilim dalının ilk çalışmaları olarak kabul edilir. Ne yazık ki günün teknik olanaklarının yetersizliği, "Analytical Machine" nin yapımına olanak vermemiş, ilk bilgisayarlar 1940 yıllarında Nazi Almanyasında Konrad Zuse tarafından gerçekleştirilmiş, fakat ilk güvenilir modeller 1950 den sonra A.B.D ve Ingilterede yapılabilmiştir. Lady Ada Lovelace'in çalışmalarına bir cemile olarak, en gelişmiş bilgisayar diline Ada Program dili adı verilmiştir. Algol - Pascal - Modula program dilleri ailesinin en son ve en gelişmiş üyesi olan Ada program dilinin öğrenimi için Türkçe dersler yine bu satırların yazarı tarafından hazırlanmıştır ve bu sitenin Ada Pogramlama Dili konusunda sitede izlenebilir. Ada program dili ile oluşturulan programların sağlamlığı en üst düzeydedir ve onun için, Hava Trafik Kontrolü, Demiyolu İşetmeleri, Askeri Cihazlar gibi kritik çalışma alanlarında Ada programları kullanılır.
Python programlama dilinde, iteratif işlemleri, for ve while blokları ile, fonksiyonların kendi kendilerine çağırmaları anlamına gelen rekürsiyon yöntemleri ile gerçekleşir.
İlk olarak, tüm programlama dillerinde tekrarlı işlemlerin sistematiği üzerinde duralım. Tekrarlı işlemler, belirli bir mantıksal kriteryum sağlanıncaya kadar (belirli bir değişkenin değeri False oluncaya kadar) tekrarlanan bir grup program adımının bulunduğu bir program alanıdır. Bu alandaki program adımları sürekli tekrarlandığı için, bu alan bir döngü (loop) olarak da adlandırılır.
Her döngüde iki tane değeri yenilenen değişken bulunur. Bu değişkenlerden birisi döngü sayacı, diğeri döngü sonu belirleyicisidir.
Döngü sayacı bir tamsayıdır. Başlangıç değeri, program dilinin dizi elemanlarının indislerinin başlangıç değeridir. Bu değer her program diline göre değişir. Örnek olarak Java, JavaScript dizi indisleri 0 dan başlarken, Ada dizileri 1 den başlar. Bu değer Python için 0 dan başlar. Bir döngü, döngü bloğundaki program adımlarının yukarıdan başlayarak blok sonuna kadar bir kez çalıştırılmasıdır. Her döngüde, döngü sayacının değeri, bir tamsayı artar. Döngü sayacının işlevi, döngü sayısının saptanmasıdır. Bu değişken, Python dahil modern bilgisayar dillerinde bir tamsayı atanmış her geçerli değişken olabilirse de, FORTRAN günlerinden kalan ve bugüne kadar uygulanan bir geleneğe göre, i , j , k , l , m, n harfleri, i den başlayarak kullanılır.
Döngü sonu kontrolu her türlü mantıksal ifade atanabilen bir değişkendir. Bu ifadenin değeri daima True değeri ile başlar. Bu değer, her döngüde bir kez değişecek şekilde programlanır ve döngünün yapısına göre ya döngü başına, ya da döngü sonuna konulur. Bu mantıksal ifadenin değeri döngü içinde False değerine dönüşmüş ise, program kontrolü, döngüden çıkar ve program akışı, döngüden bir sonraki program adımı ile devam eder.
Python programlama dili için, döngü sonu kontrolü, hem for hem de while döngülerinde, döngü başındadır. Bu ifadenin değeri daha başlangıçta False ise, program kontrolü, for veya while döngüsüne hiç giremez ve program akışı, for döngüsünden bir sonraki program adımı ile devam eder.
Bazı döngü tasarımlarımda, döngü sayacı ve döngü sonu belirleyicisi aynı değişkende toplanır. Değişkenin değeri yanlışa dönüşünce, program kontrolü döngüyü terkeder. Bu durumlarda, döngü sonu değişkeninin değeri bir tamsayıdır ve bu değişkenin değeri aynı zamanda döngü tekrarını belirten bir sayaç işlevini de görür.
Bazı durumlarda, döngü sonu kontrolü hem döngü sonu kontrol değişkenine atanmış olan mantıksal ifadenin sonucunun True değerinden False değerine dönüşmesi, hem de, döngü sayacının belirli bir değere ulaşması ile kontrol edilir. Bunlardan hangisi daha önce sağlanırsa, program kontrolü döngüyü terkeder.
Programcılar, döngü tasarımlarına çok dikkat etmeli ve döngü yapısını, program kontrolünün şu veya bu şekilde, ama mutlaka döngüyü terkedebilmesine olanak sağlayacak şekilde düzenlemelidirler. Sonu belli olmayan döngülerde, daima döngünün ne olursa olsun tamamlanacağı bir güvenlik kontrolu konulmalıdır. Bunun en kolay şekli, döngü sayacının belirli bir değerinden sonra döngünün terkedilmesini sağlayacak bir kontrolün konulmasıdır. Aksi takdirde, program sonsuz döngüye girer ve sonucu bazen felaket olabilir.
Örnek olarak, sayısal analizde çoğu zaman bir fonksiyonun yakınsaması sağlanmaya çalışılır. Yakınsama, bir fonksiyonun değerinin belirli bir ε değerinden daha küçük olmasıdır. Bu, bir hedef belli olmadan, rastgele atıştır. Bazı fonksiyonlar, iyi huylu fonksiyonlar olarak tanımlanır, bu fonksiyonlar kolayca yakınsar. Bu durumlarda, döngü sonunun sınanması amacı ile uygulanan değişkenin değeri fonksiyonun kolay yakınsamasından dolayı kolayca False değerine dönüşebilir ve program kontrolü döngüyü sorunsuzca terkedebilir. Fakat, bazı fonksiyonlar kötü huylu fonksiyonlar olarak tanımlanır. Bunlar ya çok yavaş yakınsar, veya daha da kötüsü, osilasyon yaparak hiçbir zaman yakınsamaz. Bu durumda, döngü çıkış kriteryumu sadece yakınsama sınanmasına bırakılırsa, program akış kontrolü hiçbir zaman döngüyü terkedemez ve sonsuz döngüye girilir. Bunun önlenmesi için, sonucu önceden kestirilemeyen mantıksal ifadelere bağlı olarak çalışan döngülerin yapılarında, daima ek bir çıkış sigortası bulunmalıdır.
2.2.1 - Döngü Çıkış Bildirimleri
2.2.1.1 - pass Bildirimi
pass Bildirimi, program kontrolüne, döngüye girmeden pas geçmesini bildirir. Bu bildirim ile program kontrolü, döngüden bir sonraki program adımını çalıştırır.
2.2.1.2 - continue Bildirimi
bu bildirim, program kontrolüne çalışılmakta olan iterasyondan çıkılarak, döngüye bir sonraki iterasyondan devam edilmesini bildirir.
2.2.1.3 - break Bildirimi
Bu biildirim, program kontrolüne döngüden derhal çıkılarak, programa döngüden bir sonraki program adımından itibaren devam edilmesini bildirir. İçiçe döngüler ile çalışıldığında, break bildirimine rastlandığı anda, iç döngüden çıkılır ve dış döngü çalıştırılmaya devam edilir.
Bazen bir döngü else bildirimini de içerebilir. Bu durumda döngü çıkışında bu else bloğunun içeriği çalıştırılır. Fakat break bildirimi bunu da önler ve program kontrolüne döngüden else bloğu dahil derhal çıkılarak, programa döngüden bir sonraki program adımından itibaren devam edilmesini bildirir.
2.2.2 - for Döngüsü
Python programlarında, for döngüsü, diğer programlama dillerinden değişik ve çok daha dar kapsamlıdır. Python programlama dilindeki, for döngüsü sadece iterasyon yapılabilien veri tipleri için uygulanabilir. Bu tanımla, Python programlama dilindeki, for döngüsü, JavaScript, PERL gibi programlama dillerinin foreach döngüleri ile aynıdır.yani sözel veriler, (string), listeler (list), topluluklar (tuples), sözlükler (dictionary), kümeler (set) tipi veriler ile uygulanabilir.
Python programlama dilinde, iterasyon yapılabilen veriler, sıra ile dizilmiş ve aralarında bir ayraç karakteri ile ayrılmış verilerdir. İterasyon yapılabilen veriler sekansiyel veri tiplerini oluştururlar. Sekans, bir işlemin başlaması, sona ermesi ve ardından yeni bir işelmin başlatılmasıdır. Bir sekans tamamlanmadan, bir başka sekans başlatılamaz. Sekansiyel veri tiplerine, konteyner tipli veriler, depo tipi veri tipleri, iterabl (iterasyon yapılabilen) veri tipleri adları verilir.
Python programlama dilinde, sekansiyel veri tipleri, sözel veriler (String), listeler (list), topluluklar (tuple), sözlükler(dictionary), kümeler (set), donmuş kümeler (frozenset) veri tipleridir. Sekansiyel veri tipleri değişik veri tiplerinde elemanlar içerebilirler. Bu elemanlar, belirli bir sıralanma (ordering) düzenine uymazlar.
Bazı sekansiyel veri tiplerinin, atandıktan sonra elemanları değiştirilemez, yeni elemanlar eklenemez veya bazı elemanları çıukarırılamaz. Bunlara, değiştirilemez, kesilemez (immutable) sekansiyel veri tipleri adı verilir.
Kesilemez veriler, aynen sayısal tipler gibi, bir defada atanabilir ve ancak toptan değiştirilebilir. Python programlama dilinde, kesilemez sekansiyel veri tipleri, sözel veriler, topluluklar ve donmuş kümelerdir. Kesilebilen sekansiyel veri tipleri ise, listeler, sözlükler ve kümelerdir.
Python programlama dilinde, for döngüsü, kesilebilir olsun kesilemez olsun, tüm sekansiyel veri türleri için uygulanabilir. Bu döngü, sekans boyunca, ilk yerleşim sırasından başlayarak, son yerleşmiş veriye kadar iterasyon (birbiri ardından erişim) yapar ve her iterasyonda, sekansiyel veri tipinin yeni bir elemanına erişim sağlar. Örnek:
# Program : Ders13program1.py for s in ["Ahmet" , "Hasan" , "Zübeyde"]: print(s); ---------Program----Sonucunun----Görünntülenmesi---------------------------- Ahmet Hasan Zübeyde
Burada, for döngüsü bir iteratör bildirimidir, s iterasyon tanımlayıcısıdır. Iterasyon tanımlayıcısına iterasyon değişkeni adı da verilir. İterasyon değişkeni, her döngüde, iterasyon yaptığı sekansiyel veri tipinin bir elemanına erişir, onun değerini alır ve onunla önceden tanımlanmış bir işlem gerçekleştirir. İterasyon, sekansiyel veri tipinin ilk elemanı ile başlar, tüm elemanlara birer birer erişilir, her elemanla işlem gerçekleştirilir. İterasyon yapılan sekansiyel veri tipinin son elemanı ile işlem tamamlandığında, bir sonraki eleman aranır, bu elemanın bulunmadığı algılanırsa, sekans sonu sinyali oluşurv e iterasyon sonlandırılır. İterasyon sonlandırıldığında, döngü değişkeni, program kontrolüne döngünün tamamlandığını ve bir sonraki program adımına geçilmesini bildirir. Bu şekilde, program kontrolü, döngüden bir sonraki program adımını uygulamaya başlar.
Python programlama dilinde, for in döngüleri sadece konteyner tipi verilerin nesne örneklerine uygulanabilir. Her iterasyonda sadece nesne örneğinin elemanlarına erişilebilir. Bu döngü ile elemanların indis değerlerine erişilemez. İndisler nesne örneklerinin elemanları arasında değildir, bir yere kayıtlı değillerdir ve her iterasyonda ayrı olarak belirli kurallara uyularak oluşturulan (arbitrary) sayılardır. Python programlama dilinde, for in döngülerinde indis değerlerini Python derleyicisi bir iç değer olarak tutar ve dışarıya aksettirmez. İndis değerlerinin ayrı programlar tarafından oluşturulup görüntülenmeleri gerekir. Bunu biraz ileride Python for in döngülerinin yardımcı programları konusunda göreceğiz.
Yukarıdaki programdaki döngü sayacı s olarak isimlendirilmiştir. Bu isimlendirme tamamı ile isteğe bağlıdır ve bu tür döngülerde, her geçerli değişken adı, döngü değişkeni adı olarak kullanılabilir. Örnek olarak, continue bildiriminin etkisinin görüldüğü bir sonraki programda döngü sayacı, t olarak uygulanmıştır.
# Program : Ders13program2.py for t in ("Ahmet" , "Hasan" , "Zübeyde"): if t == "Ahmet": continue; print(t); ---------Program----Sonucunun----Görünntülenmesi---------------------------- Hasan Zübeyde
Yukarıdaki programda, döngü başlayıp ilk döngü uygulandığında, döngü değişkeni t, topluluğun(tuple) ilk elemanı ile eşleşip değerini kendi üzerine kopyalıyor. Döngünün ikinci program satırında, eğer döngü değişkeninin işaret ettiği değer "Ahmet" ise, bu iterasyonun pas geçilmesi bildirimi olan continue bildirimi ile karşılaşıyor. Bu bildirime uyarak derhal iterasyonu terkediyor ve bu durumda işaret ettiği bellek alanında saklı değeri görüntüleyemiyor. İkinci ve üçüncü iterasyonlarda böyle bir bildirim olmadığından, eşleştiği değeri görüntüleyerek iterasyonu tamamlıyor. Üçüncü iterasyon tamamlandığında, döngü de tamamlanıyor.
Aşağıdaki uygulamada break bildiriminin etkisi görülüyor. Bu uygulamada kullanılan, iterasyon yapılabilir veri tipi, bir sözlük (dictionary) tipi veridir. Döngü değişkeni olarak da, q değişken ismi kullanılılıyor.
# Program : Ders13program3.py for q in {1:"Ocak",2:"Şubat",3:"Mart"}: if q == 3: break; print(q); ---------Program----Sonucunun----Görünntülenmesi---------------------------- 1 2
Yukarıdaki programda döngü değişkeni q, bir sözlük tipi verinin elemanlarının anahtar kısımları ile eşleşiyor ve anahtar değeri 3 olunca, break bildirimi ile karşılaşarak döngüden acele çıkış yapıyor. Döngüden çıkış gerçekleşince, program kontrolü, döngüden sonraki ilk program adımına geçiyor. Görüntülenen sonuçlar, bu program akışını doğrulamaktadır.
Bütün bu bilgiler, Python for in döngülerinin sadece nesne örnekleri ile çalışabildiğini ve sadece elemanlara erişebildiğini belirtmektedir. Aşağıda görülen range() ve enumerate() fonksiyonları, for in döngülerine yardımcı olmak amacı ile, öntanımlı olarak sağlanmaktadır.
2.2.2.1- range() Fonksiyonu
Öntanımlı range() fonksiyonu,
range([başlangıç değeri],sonuç değeri,[artım değeri]);
olarak uygulanır. Başlangıç değeri belirtilmezse, varsayılan değer olarak 0 kullanılır ve sondeğer n ise, n-1 değerine kadar sayma yapılır. Öntanımlı range() fonksiyonun tüm argümanları tamsayılar olmalıdır. Bu fonksiyon, kalıcı bir liste oluşturmaz.Sadece sayı sayar, fakat, oluşturduğu sayılar, Python programlama dilinde 0 dan başlayarak sayılan indis değerlerine denk gelir. İlk örneği inceleyelim.
# Program : Ders13program4.py for i in range(5): # iterasyon program adımları ... print(" i = " , i , " | " , end = ""); print('\n\nDöngü Sonu'); ---------Program----Sonucunun----Görünntülenmesi---------------------------- i = 0 | i = 1 | i = 2 | i = 3 | i = 4 | Döngü Sonu
Yukarıda programda, iterasyon sayacı i değişkeni olarak tanımlanmıştır. Yani i değişkeninin değeri her iterasyonda belirli bir değer almaktadır. Burada döngü sayısı (range() fonksiyonun argümanı) 4 olarak belirtilmiştir. Yani döngü, 4 iterasyon sonunda tamamlanacaktır. İterasyon sayacı i nin ilk değeri belirtilmemiş olduğundan, varsayılan olarak 0 dan başlayacaktır. Artım değeri verilmediğinden, varsayılan olarak i nin değeri, her iterasyonda 1 artacak ve n = 5 olduğuna göre, i nin değeri, n - 1 = 4 olunca son iterasyon tamamlanacak ve döngüden çıkılacaktır. Yukarıdaki programın sonucu incelendiğinde, bu program yürüyüşü doğrulanmaktadır.
Bir başka programda, tamsayılar kümesinin (matematik açısından tamsayılar yapılanmasının) ilk 100 elemanının toplamını hesaplayalım.
# Program : Ders13program5.py s=0; for i in range(101): s = s + i;
print('s = ', s , '\n\nDöngü Sonu');
---------Program----Sonucunun----Görünntülenmesi---------------------------- s = 5050 Döngü Sonu
Yukarıdaki programda iterasyon değişkeni i nin değeri varsayılan olarak 0 dan başlamakta, varsayılan olarak 1 artarak, n - 1 = 100 değerini aldıktan sonra, son iterasyon tamamlanarak döngüden çıkılmaktadır. Burada s değişkenine toplayıcı (akümülatör) adı verilmektedir. Her iterasyonda, s değişkeninin işaret ettiği değer değişmekte ve yeni değer, s değişkeninin işaret ettiği bellek alanında saklanmaktadır. Toplayıcı, değiştirilemez bir veri tipi olan tamsayı veri tipi topladığından her iterasyonda eski değerin bir kısımı güncellenememekte, eski değer tümden silinip yerine yeni değer yerleştirilmektedir. Döngü sonunda, toplayıcının topladığı değer görüntülenmektedir.
Bu programın önemi, range() fonksiyonun, Pythom programlama dilinin for in döngülerine, diğer programlma dilerine koşut bir yetenek kazandırabilmesidir. Programlama dillerinde, döngü değişkeni bir hazine gibidir. Bu sabit değer, yukarıdaki programda olduğu gibi bir akümülatöre eklenerek toplama yapılabilir, bir fonksiyonun argümanı olarak bir değer hesaplatabilir ve daha birçok işlem gerçekleştirilebilir. Yukarıdaki uygulama bunun yöntemini belirtmektedir.
Aşağıdaki programda, range() fonksiyonu, belirlenen bir değerden başlamaktadır.
# Program : Ders13program6.py for i in range(2,5): print(i , " " , sep = " | " , end =""); print('\n\nDöngü Sonu'); ---------Program----Sonucunun----Görünntülenmesi---------------------------- 2 | 3 | 4 | Döngü Sonu
Yukarıdaki programda, toplam iterasyon sayısı 5 - 2 = 3 dür. İterasyon sayacının başlangıç değeri daima belirtilen başlangıç değeri (burada 2), son değeri ise belirtilen son değerin 1 eksiğidir (burada 5 - 1 = 4). Artım belirtilmediğinden, varsayılan artım olan 1 alınmaktadır.
Yeni bir programda, range() fonksiyonu, belirlenen bir değerden başlamakta, belirli bir son değere kadar iterasyon yapmakta ve iterasyon değişkeninin değeri, belirtildiği kadar değişmektedir.
# Program : Ders13program7.py for i in range(5, 3,-1): print(i , " " , sep = " | " , end =""); print('\n\nDöngü Sonu'); ---------Program----Sonucunun----Görünntülenmesi---------------------------- 5 | 4 | Döngü Sonu
Bu programda range() fonksiyonu, yüksek bir değerden başlıyor ve düşük bir değere kadar iterasyon yaptırıyor. İterasyon değişkeni i nin değeri her zaman belirtilen ilk değerle başlıyor (burada 5) ikinci iterasyonda i nin değeri 4 oluyor. Bu son iterasyondur. Çünkü, bir kez daha iterasyona girerse, inin değerinin 4 - 1 = 3 olması gerek, oysa son değer olarak 3-1 =4 verilmiş. Yani i nin son değeri 4 dür ve bu değerden sonra döngü tamamlanacaktır. Program çıktısı da bu yürüyüşü doğrulamaktadır. Bu arada, range() fonsiyonun sadece tamsayılarla çalışabildiğini yineleyelim. Ondalıklı sayılarla iterasyonlar while() döngüleri ile gerçekleştirilebilir.
Yeni bir programda, range() fonksiyonu yardımı ile sözel bir verinin karakterlerinin taranması yapılmaktadır.
# Program : Ders13program8.py p = "pazar"; uzunluk = len(p); for i in range(uzunluk): print(p[i] , " " , end = ""); ---------Program----Sonucunun----Görünntülenmesi---------------------------- p a z a r
Yukarıdaki program, range() fonksiyonu yardımı ile, bir konteyner tipi nesne örneğinin elemanlarına indis değeri ile erişimin sağlanması için ilk örneği oluşturuyor. Burada string tipi bir veri örneği, bir bir p değişkenine atanmıştır. Bu sözel verinin uzunluğu yani, toplam karakter sayısı, len() öntanımlı fonksiyonu ile saptanıyor ve bu değer uzunluk adlı bir değişkene atanıyor. Burada tanımlanmış olan uzunluk değişkeninin değeri tamsayı tipi bir veridir ve değeri pazar sözcüğünün toplam karakter sayısı olan 5 dir. Burada, "pazar" sözel verisinin karakterlerinin tümünün saptanabilmesi için 5 iterasyon yapılması gereklidir. Bu programda, range fonksiyonun 0 (dahil) (5 - 1 = 4) dahil arası iterasyon yapılırsa, incelenen sözel verinin karakter uzunluğuna eşit sayıda, yani 5 ayrı iterasyon yapılmış ve böylelikle, karakterlerinin tümü taranmış olur.
Burda dikkate değer olan bir nokta, sözel verilerinin değiştirilemez olmasına karşın iterasyon yapılabilecek veriler arasında olmasıdır. Bunun nedeninin sözel veri tipi (string) adeta bir liste gibi organize olmasıdır. Sözel verilerin ilk karakteri, listelerin ilk elemanlarının indisi gibi 0 dan başlar ve her karakterde bir artarak son karaktere kadar gider. Bu yüzden, sözel veriler değiştirilemez (immutable) olmalarına karşın itere edilebilir (iterabl) olan tek basit Python veri tipidir. İterabl olan liste, topluluk gibi veri tiplerinden, örnek olarak topluluk (tuple) de immütabl (kısmen değiştirilemez) olmasına karşın basit değil bileşik (agglomeratif) (topluluk tipi) veri tipleridir.
Yukarıdaki programda, iterasyon değişkeni i nin değeri, varsayılan değer olan 0 dan başlıyor ve veri uzunluğu olan 5 sayısından 1 eksiği olan 4 değerine kadar eşleşme yapıyor. İterasyon değişkeni i nin değeri 4 olduğunda, iterasyon 5 inci kez tekrarlanıyor ve son karakter de eşleşmiş olduğundan döngü tamamlanmış oluyor. Program çıktısından, programın izlediği yol da görülebiliyor.
İterasyon yapılabilen bir konteyner tipinin eleman indislerine erişim, range() fonksiyonu yardımı ile gerçekleştirilebilir. Aşağıda, bu konuda bir uygulama görülmektedir.
# Program : Ders13program9.py L = [4, 5, 6] for indis in range(len(L)): print ('indis = ', indis) ---------Program----Sonucunun----Görünntülenmesi---------------------------- indis = 0 indis = 1 indis = 2
Öntanımlı range() fonksiyonu yardımı ile, indislenebilen koleksiyon tipi verilerin elemanları, indis değerlerine göre taranabilir. Örnek :
# Program : Ders13program10.py L = [4, 5, 6] for indis in range(0, len(L)): print ('indis = {0} L[{0}] = {1} '.format(indis , L[indis])) ---------Program----Sonucunun----Görünntülenmesi---------------------------- indis = 0 L[0] = 4 indis = 1 L[1] = 5 indis = 2 L[2] = 6
Yukarıda görülen program, for in döngülerinde eleman indislerine göre tarama yapılabileceğini kanıtlayan bir programdır ve değeri büyüktür. Yine de elemanlara indislerine göre erişim, aşağıda belirtilen öntanımlı enumerate() fonksiyonu ile daha kolay olarak gerçekleştirilir.
2.2.2.2- enumerate() Fonksiyonu
Öntanımlı enumerate() fonksiyonu, iterasyon yapılabilecek bir koleksiyon veri tipi (sekansiyel bir tip) üzerinde, indis ve eleman değerlerini verebilen öntanımlı bir fonksiyondur. Kullanımı,
enumerate(sekans[, start = x])
şeklindedir. Bu fonksiyonda, start argümanı isteğe bağlıdır. Bu argüman, üretilecek olan indis değerlerinin başlayacağı sayıyı belirtir. Normal olarak 0 dan başlayacak olan indis değerleri için, start argümanını vermeye gerek yoktur. Bu argüman sadece enümerasyonun başlayacağı indis değerinin sıfırdan farklı olması istendiğinde kullanılır. Öntanımlı enumerate() fonksiyonu, sekansiyel bir veri tipinin elemanlarına sekansiyel olarak erişim (traversal) sırasında, elemanların hem indis, hem de değerlerine gereksinme duyulduğunda kullanılır. Bunlardan sadece indis değerine gereksinme olduğunda, öntanımlı range() fonksiyonu, sadece eleman değerine gereksinme olduğunda ise, for in döngüleri yeterli olacaktır. Örnek bir uygulama aşağıda verilmiştir.
# Program : Ders13program11.py L = [45, 78, 33] for indis, eleman in enumerate(L, start=2): print(indis, eleman)
---------Program----Sonucunun----Görünntülenmesi----------------------------
2 45
3 78
4 33
Yukarıdaki programda, bir konteyner tipinin elemanlarına normal bir sıralı erişimde, sadece ya eleman, ya da indis değerine erişilebilirken, enumerate() fonksiyonu uygulandığında, her ikisine birden erişilebildiği görülmektedir. Bu programda, indis enümerasyonu 2 den başlatılmıştır. Burada amaç start argümanının işleyişinin belirtilmesidir. Program çıkışından, start argümanının değeri ne olursa olsun, eleman değerinin listede bulunan elemanların tümünü kapsadığı ve erişimin elemanların yerleşim sırasına göre başladığı görülmektedir. Yine dikkat edilecek bir özellik, normal bir sıralı erişimde tek iterasyon değişkeni kullanılmasına karşın, burada indis ve eleman adında iki ayrı iterasyon değişkeni kullanıldığıdır.
2.2.3 - while Döngüsü
while Döngüsünün uygulanması aşağıda görüldüğü şekildedir.
while mantıksal ifade : ... program adımları... ... #iterasyon sonu [else:
...
program adımları...
...]
while Döngüsü, Python programlama dilinin ikinci ve son döngüsüdür. while Döngülerinde, döngü çıkış değişkeninin değeri, iterasyon başında kontrol edilir. Bu değer False ise, eğer varsa else bildirimi çalıştırılır, yoksa, program kontrolü bir sonraki program adımına geçer.
Eğer varsa else bloğu, break bidirimi dışında daima çalıştırılır.
while Döngüsü, Python programlama dilinin en esnek ve kullanıcının isteklerine açık olan döngü tipidir. Bu tip döngülerle her türlü iteratif işlem kolaylıkla programlanabilir. Bir örnek program, aşağıda görülmektedir.
# Program : Ders13program12.py L = [22, 44, 56, 77, 55, 44] i = 0
while i<6 : print ('i', L[i] ) if i == 1: i = i + 1
i = i + 1
---------Program----Sonucunun----Görünntülenmesi----------------------------0 0 22 1 44 3 77 4 55 5 44
Bu programda, bir while döngüsü ile bir tanımlı liste değişkenin elemanlarına indis değerleri üzerinden erişim sağlanıyor. Bilindiği gibi Python programlama dilinde, liste elemanlarına sadece while döngükeri ile indisleri üzerinden erişim sağlanabilmektedir. Yukarıdaki program da bunun bir örneğini oluşturmaktadır.
Python programlama dilinde, bir sekansiyel veri nesne örneği yaratıldığında, bu nesne örneğinin elemanlarının indis değerleri, Python derleyicisince belirlenir. Bu değerler, ilk eleman için 0 değerinden başlar ve bir artarak son elemana kadar devam eder. Yukarıdaki programda, bir döngü içinde, indis değerlerinden yararlanılarak, liste elemanlarına erişim sağlanmakta ve liste elemanlarından birisi atlanaraki liste geçişi (list traversal) bir sonraki elemandan itibaren devam edilmektedir.
Tüm programlama dillerinde while döngüleri çok esnek olmalarına karşın programlamaları çok hassastır. Döngü değişkenleri otomatik olarak değil el ile (manuel) arttırılmalıdır. Döngü çıkışının düzgün olarak sağlanamaması durumunda sonsuz döngüye girilmesi kaçınılmaz. Bu döngünün uygulanmasında çok dikkatli olmak gerekir.
Python programlama dilinde, set (küme) tipindeki koleksiyon nesneleri indislenemz ve bunun sonucunda da while döngüleri ile, elemanları, indis değerlerine göre taranamaz. Bunun için enumerate() fonksiyonundan yararlanmak gerekir.