Python Da While Döngüsü

Python'da Döngüler

• while Döngüsü
• for Döngüsü

while Döngüsü

continue Deyimi

else Deyimi

Ne Öğreneceğiz ?

• Döngü nedir, mantığı nasıl işler, Python'da nasıl kullanılır ?
• fonksiyonu
• komutu
• komutu

Gereksinimler

Zorluk Seviyesi

Ders İçeriği

Döngü Nedir ?
Arkadaşlar öncelikle öğreneceğimiz bu fonksiyonun mantığını oturtmamız gerekir. Benim için programlama da en temel ve önemli şey döngülerdir. Eğer döngü mantığını tam oturtursanız kalan şeyler sadece ezber niteliğinde olacaktır. Döngü'yü Bir olayın istediğiniz sonuca varana kadar tekrar etmesi diye tanımlayabilirim.

Basit bir örnek üzerinde 'ı anlamaya çalışalım.
Mesela programımız 1'den 10'a kadar saysın:

Gördüğünüz gibi programımız 1'den başlayarak 1 artırarak ekrana yazdı:

Hatırlarsanız değişkenleri anlatırken size değişken ile ilgili son komut ne olursa değişken o komuta bağlı olur demiştim. Burada da işte o mantık devreye giriyor, while döngüsü içerisinde 'yi 'e eşitledik. Son komutumuz olduğundan artık 'miz 2 ye eşit, bu şekilde döngü devam ediyor(başa sarıyor), peki nereye kadar ? koşulunun yanında belirttiğimiz yere yani koşulu devam edene kadar.
Kısacası biz programa dedikki; 1'den başlayarak 10'dan küçük sayıları yaz.
Herhangi bir hatada veya i'nin artırımı yapılmadığı gibi durumlarda, yani koşulun sürekli saglandığı durumlarda program sonsuz döngüye girebilir, bu çalışma ortamınızın veya programınızın kilitlenmesine neden olabilir.

Size while içerisinde kullanılan bir komuttan bahsedeyim:
komutu döngüyü sonlandırmaya yarar. Mesela yukarıda ki örneğin aynısını yazalım fakat i değeri 7 sayısına ulaşınca program dursun diyelim;

Gördüğünüz gibi 1'den başladı, 7'ye ulaşınca komutu devreye girdi ve program durdu.

Bir de komutumuz var, bu da verdiğimiz koşulun olması durumunda döngüyü direk başa sarıyor. Şöyle ki, diyelim bizim 5 tane koşulumuz var while döngüsünün altında. 3. koşulumuzun sağlanması durumunda başa sarmasını istiyoruz döngünün, burada işte komutu devreye giriyor. Bu komutu da kullanabileceğimiz toplu bir örnek yapalım şimdi:

Çalıştıracak olduğumuzda;

Gördüğünüz gibi 15 sayısını girdim ve program 5'den büyük koşuluna uyarak istediğimiz yazıyı yazdı ve daha sonra döngü komutu ile sonlandı. Peki bir de komutu ile başa saracak mı bakalım, bunun için negatif değer giriyoruz;

Bakın yine 5'den küçük sonucunu verdi, halbu ki biz ile tekrar etmesini bekliyorduk programın. Peki neden böyle oldu derseniz, hatırlarsanız değişkenler için son komut neyse o hali alır demiştik, hatta yukarda da bahsettim. Döngülerde ise bu durum tam tersidir, yani koşulu ilk sağlayan durum döngümüzün sonucudur, isterseniz birinci ve sonuncu satırın yerini değiştirerek bunu test edelim, o halde programımızın ile tekrar etmesi gerekir:

Gördüğünüz gibi, program kendini tekrar etti. Döngü mantığını ve 'ı, ve 'yi anlamış olduk. Şimdi daha güzel bir örnek yapalım tüm bu öğrendiklerimiz ile.

Çok klasik olacak ama artık kullanıcı giriş programı yazmanın zamanı geldi :) Bir admin panel girişi yazalım mesela arkadaşlar tüm öğrendiklerimizi kullanarak.

• Arkadaşlar şimdi düşündüğümüzde, bir kullanıcı girişine (kullanıcı adı, şifre) kaç farklı giriş(ihtimal) olabilir ?
  • Kullanıcı adı doğru şifre yanlış, şifre doğru kullanıcı adı yanlış, ikisi de yanlış
  • Kullanıcı adı veya şifre veya ikisi de boş
  • Kullanıcı adı ve şifre doğru
    Bu ihtimalleri göz önünde bulunarak ben şöyle yazmak istiyorum;
• Kullanıcı adı ve şifrenin doğru olduğu ihtimali if ile yazdırmak
• Kullanıcı adı veya şifreden herhangi birinin yanlış olması durumu (boşta olabilir)
  Yani iki duruma düşürdüm tüm bu olayları, koda döktüğümde kullanıcı adı ve şifre doğru veya diğer tüm ihtimaller (doğru olmayan tüm ihtimaller benim için yanlıştır) veya kullanıcı adı veya şifrenin yanlış olması (yine bu koşulda da geriye başka ihtimal kalmıyor)
  Bakalım:
  

Çalıştırdığımızda:

Gördüğünüz gibi ilk deneme de yanlış girdim, ikinci de boş girdim, üçüncü de doğru girdim.

Yukarıda kurduğumuz ikinci mantığı deneyelim ( ile):

Çalıştıralım:

Gördüğünüz gibi, yine aynı şekilde çalıştı. Yani programımız şunu yaptı;
Kullanıcı adı ve şifreler zaten bizim tarafımızdan belirlenmiş (cryptoadamc,utopian), döngüsü altında bizden kullanıcı adı ve şifre girmemizi istedi, girdik, ilk koşuluna baktı eğer belirlenen kullanıcı adı ve şifre ile eşleşmediyse diğer koşula geçti, o koşulumuz veya baktı zaten ilk koşul ile eşleşmeyen bu koşul ile eşleşmek zorunda çünkü başka bir ihtimal yok, ile istediğimiz metni yazdırdı ve komutu ile döngüyü başa aldı, tekrar kullanıcı adı ve şifre istedi bizden. Böylece yanlış eşleşme durumunda giriş yapmayıp, doğru eşleşme durumunda başarı ile giriş yapmış olduk.

Bu örneğimiz ile dersimizin de sonuna geldik, tekrar etmeyi ve alıştırmalar yapmayı unutmayın.
Selametle..

Önce ki Dersler

Şimdiye kadar öğrendiklerimiz sayesinde Python’la ufak tefek programlar yazabilecek düzeye geldik. Mesela öğrendiğimiz bilgiler yardımıyla bir önceki bölümde çok basit bir hesap makinesi yazabilmiştik. Yalnız o hesap makinesinde farkettiyseniz çok önemli bir eksiklik vardı. Hesap makinemizle hesap yaptıktan sonra programımız kapanıyor, yeni hesap yapabilmek için programı yeniden başlatmamız gerekiyordu.

Hesap makinesi programındaki sorun, örneğin, aşağıdaki program için de geçerlidir:

Burada tuttuğum_sayı adlı bir değişken belirledik. Bu değişkenin değeri 23. Kullanıcıdan tuttuğumuz sayıyı tahmin etmesini istiyoruz. Eğer kullanıcının verdiği cevap tuttuğum_sayı değişkeninin değeriyle aynıysa (yani 23 ise), ekrana ‘Tebrikler!…’ yazısı dökülecektir. Aksi halde ‘Ne yazık ki…’ cümlesi ekrana dökülecektir.

Bu program iyi, hoş, ama çok önemli bir eksiği var. Bu programı yalnızca bir kez kullanabiliyoruz. Yani kullanıcı yalnızca bir kez tahminde bulunabiliyor. Eğer kullanıcı bir kez daha tahminde bulunmak isterse programı yeniden çalıştırması gerekecek. Bunun hiç iyi bir yöntem olmadığı ortada. Halbuki yazdığımız bir program, ilk çalışmanın ardından kapanmasa, biz bu programı tekrar tekrar çalıştırabilsek, programımız sürekli olarak başa dönse ve program ancak biz istediğimizde kapansa ne iyi olurdu değil mi? Yani mesela yukarıdaki örnekte kullanıcı bir sayı tahmin ettikten sonra, eğer bu sayı bizim tuttuğumuz sayıyla aynı değilse, kullanıcıya tekrar tahmin etme fırsatı verebilsek çok hoş olurdu…

Yukarıda açıklamaya çalıştığımız süreç, yani bir sürecin tekrar tekrar devam etmesi Python’da ‘döngü’ (loop) olarak adlandırılır.

İşte bu bölümde, programlarımızın sürekli olarak çalışmasını nasıl sağlayabileceğimizi, yani programlarımızı bir döngü içine nasıl sokabileceğimizi öğreneceğiz.

Python’da programlarımızı tekrar tekrar çalıştırabilmek için döngü adı verilen bazı ifadelerden yararlanacağız.

Python’da iki tane döngü bulunur: ve

Dilerseniz işe döngüsü ile başlayalım.

while Döngüsü¶

İngilizce bir kelime olan while, Türkçede ‘… iken, … olduğu sürece’ gibi anlamlara gelir. Python’da bir döngüdür. Bir önceki bölümde söylediğimiz gibi, döngüler sayesinde programlarımızın sürekli olarak çalışmasını sağlayabiliriz.

Bu bölümde Python’da döngüsünün ne olduğunu ve ne işe yaradığını anlamaya çalışacağız. Öncelikle döngüsünün temellerini kavrayarak işe başlayalım.

Basit bir döngüsü kabaca şuna benzer:

Burada a adlı bir değişken oluşturduk. Bu değişkenin değeri 1. Bir sonraki satırda ise gibi bir ifade yazdık. En başta da söylediğimiz gibi while kelimesi, ‘… iken, olduğu sürece’ gibi anlamlar taşıyor. Python programlama dilindeki anlamı da buna oldukça yakındır. Burada ifadesi programımıza şöyle bir anlam katıyor:

a değişkeninin değeri 1 olduğu sürece…

Gördüğünüz gibi cümlemiz henüz eksik. Yani belli ki bunun bir de devamı olacak. Ayrıca ifadesinin sonundaki : işaretinden anladığımız gibi, bundan sonra gelecek satır girintili yazılacak. Devam edelim:

Burada Python’a şu emri vermiş olduk:

a değişkeninin değeri 1 olduğu sürece, ekrana ‘bilgisayar çıldırdı!’ yazısını dök!

Bu programı çalıştırdığımızda Python verdiğimiz emre sadakatle uyacak ve a değişkeninin değeri 1 olduğu müddetçe de bilgisayarımızın ekranına ‘bilgisayar çıldırdı!’ yazısını dökecektir. Programımızın içinde a değişkeninin değeri 1 olduğu ve bu değişkenin değerini değiştirecek herhangi bir şey bulunmadığı için Python hiç sıkılmadan ekrana ‘bilgisayar çıldırdı!’ yazısını basmaya devam edecektir. Eğer siz durdurmazsanız bu durum sonsuza kadar devam edebilir. Bu çılgınlığa bir son vermek için klavyenizde Ctrl+C veya Ctrl+Z tuşlarına basarak programı durmaya zorlayabilirsiniz.

Burada programımızı sonsuz bir döngüye sokmuş olduk (infinite loop). Esasında sonsuz döngüler genellikle bir program hatasına işaret eder. Yani çoğu durumda programcının arzu ettiği şey bu değildir. O yüzden doğru yaklaşım, döngüye soktuğumuz programlarımızı durduracak bir ölçüt belirlemektir. Yani öyle bir kod yazmalıyız ki, a değişkeninin 1 olan değeri bir noktadan sonra artık 1 olmasın ve böylece o noktaya ulaşıldığında programımız dursun. Kullanıcının Ctrl+C tuşlarına basarak programı durdurmak zorunda kalması pek hoş olmuyor. Gelin isterseniz bu soyut ifadeleri biraz somutlaştıralım.

Öncelikle şu satırı yazarak işe başlıyoruz:

Burada normal bir şekilde a değişkenine 1 değerini atadık. Şimdi devam ediyoruz:

ile verdiğimiz ilk örnekte gibi bir ifade kullanmıştık. Bu ifade;

a’nın değeri 1 olduğu müddetçe…

gibi bir anlama geliyordu.

ifadesi ise;

a’nın değeri 10’dan küçük olduğu müddetçe…

anlamına gelir. İşte burada programımızın sonsuz döngüye girmesini engelleyecek bir ölçüt koymuş olduk. Buna göre, a değişkeninin şimdiki değeri 1’dir. Biz, a’nın değeri 10’dan küçük olduğu müddetçe bir işlem yapacağız. Devam edelim:

Ne oldu? İstediğimizi elde edemedik, değil mi? Programımız yine sonsuz döngüye girdi. Bu sonsuz döngüyü kırmak için Ctrl+C (veya Ctrl+Z)’ye basmamız gerekecek yine…

Sizce buradaki hata nereden kaynaklandı? Yani neyi eksik yaptık da programımız sonsuz döngüye girmekten kurtulamadı? Aslında bunun cevabı çok basit. Biz yukarıdaki kodları yazarak Python’a şu emri vermiş olduk:

a’nın değeri 10’dan küçük olduğu müddetçe ekrana ‘bilgisayar yine çıldırdı!’ yazısını bas!

a değişkeninin değeri 1. Yani 10’dan küçük. Dolayısıyla Python’ın ekrana o çıktıyı basmasını engelleyecek herhangi bir şey yok…

Şimdi bu problemi nasıl aşacağımızı görelim:

Burada satırını ekledik kodlarımızın arasına. += işlecini anlatırken söylediğimiz gibi, bu satır, a değişkeninin değerine her defasında 1 ekliyor ve elde edilen sonucu tekrar a değişkenine atıyor. En sonunda a’nın değeri 10’a ulaşınca da, Python ekrana ‘bilgisayar yine çıldırdı!’ cümlesini yazmayı bırakıyor. Çünkü döngüsü içinde belirttiğimiz ölçüte göre, programımızın devam edebilmesi için a değişkeninin değerinin 10’dan küçük olması gerekiyor. a’nın değeri 10’a ulaştığı anda bu ölçüt bozulacaktır. Gelin isterseniz bu kodları Python’ın nasıl algıladığına bir bakalım:

1. Python öncelikle satırını görüyor ve a’nın değerini 1 yapıyor.

2. Daha sonra a’nın değeri 10’dan küçük olduğu müddetçe… () satırını görüyor.

3. Ardından a’nın değerini, 1 artırıyor () ve a’nın değeri 2 oluyor.

4. a’nın değeri (yani 2) 10’dan küçük olduğu için Python ekrana ilgili çıktıyı veriyor.

5. İlk döngüyü bitiren Python başa dönüyor ve a’nın değerinin 2 olduğunu görüyor.

6. a’nın değerini yine 1 artırıyor ve a’yı 3 yapıyor.

7. a’nın değeri hâlâ 10’dan küçük olduğu için ekrana yine ilgili çıktıyı veriyor.

8. İkinci döngüyü de bitiren Python yine başa dönüyor ve a’nın değerinin 3 olduğunu görüyor.

9. Yukarıdaki adımları tekrar eden Python, a’nın değeri 9 olana kadar ilerlemeye devam ediyor.

10. a’nın değeri 9’a ulaştığında Python a’nın değerini bir kez daha artırınca bu değer 10’a ulaşıyor.

11. Python a’nın değerinin artık 10’dan küçük olmadığını görüyor ve programdan çıkıyor.

Yukarıdaki kodları şöyle yazarsak belki durum daha anlaşılır olabilir:

Burada Python’un arkada ne işler çevirdiğini daha net görebiliyoruz. Kodlarımız içine eklediğimiz döngüsü sayesinde Python her defasında a değişkeninin değerini kontrol ediyor ve bu değer 10’dan küçük olduğu müddetçe a değişkeninin değerini 1 artırıp, yeni değeri ekrana basıyor. Bu değişkenin değeri 10’a ulaştığında ise, bu değerin artık 10’dan küçük olmadığını anlayıp bütün işlemleri durduruyor.

Gelin isterseniz bu döngüsünü daha önce yazdığımız hesap makinemize uygulayalım:

Burada ilave olarak şu satırları görüyorsunuz:

Bu kodlarda yaptığımız şey aslında çok basit. Öncelikle değeri 1 olan anahtar adlı bir değişken tanımladık. Bir alt satırda ise, programımızın sürekli olarak çalışmasını sağlayacak olan döngümüzü yazıyoruz. Programımız, anahtar değişkeninin değeri 1 olduğu müddetçe çalışmaya devam edecek. Daha önce de dediğimiz gibi, eğer bu anahtar değişkeninin değerini programın bir noktasında değiştirmezsek programımız sonsuza kadar çalışmaya devam edecektir. Çünkü biz programımızı anahtar değişkeninin değeri 1 olduğu sürece çalışmaya ayarladık. İşte programımızın bu tür bir sonsuz döngüye girmesini önlemek için bir bloğu oluşturuyoruz. Buna göre, eğer kullanıcı klavyede q tuşuna basarsa programımız önce çıkılıyor… çıktısı verecek, ardından da anahtar değişkeninin 1 olan değerini 0 yapacaktır. Böylece artık anahtar’ın değeri 1 olmayacağı için programımız çalışmaya son verecektir.

Buradaki mantığın ne kadar basit olduğunu görmenizi isterim. Önce bir değişken tanımlıyoruz, ardından bu değişkenin değeri aynı kaldığı müddetçe programımızı çalışmaya ayarlıyoruz. Bu döngüyü kırmak için de başta tanımladığımız o değişkene başka bir değer atıyoruz. Burada anahtar değişkenine atadığımız 1 ve 0 değerleri tamamen tesadüfidir. Yani siz bu değerleri istediğiniz gibi değiştirebilirsiniz. Mesela yukarıdaki kodları şöyle de yazabilirsiniz:

Gördüğünüz gibi, amaç herhangi bir değişkene herhangi bir değer atamak ve o değer aynı kaldığı müddetçe programın çalışmaya devam etmesini sağlamak. Kurduğumuz bu döngüyü kırmak için de o değişkene herhangi başka bir değer atamak…

Yukarıda verdiğimiz son örnekte önce anahtar adlı bir değişken atayıp, döngüsünün işleyişini bu değişkenin değerine göre yapılandırdık. Ama aslında yukarıdaki kodları çok daha basit bir şekilde de yazabiliriz. Dikkatlice bakın:

Bu yapıyı hesap makinemize uygulayalım:

Bu yapı sayesinde anahtar gibi bir değişken atama zorunluluğundan kurtulmuş olduk. Yukarıdaki kodların nasıl çalıştığını açıklayalım:

while True ifadesi şöyle bir anlama gelir:

Peki ne True olduğu müddetçe? Burada neyin True olması gerektiğini belirtmediğimiz için, aslında bu kod parçası şu anlama geliyor:

Aksi belirtilmediği sürece çalışmaya devam et!

Eğer yukarıdaki açıklamayı biraz bulanık bulduysanız şu örneği inceleyebilirsiniz:

Bu kodları çalıştırdığınızda ekrana sürekli olarak Bilgisayar çıldırdı! çıktısı verilecektir. Bu döngüden çıkabilmek için Ctrl+C tuşlarına basmanız gerekiyor. Yukarıdaki kodların sonsuz döngüye girmesinin sorumlusu while True satırıdır. Çünkü burada biz Python’a;

Aksi belirtilmediği sürece çalışmaya devam et!

emri veriyoruz. Python da bu emrimizi sadakatle yerine getiriyor. Böyle bir durumda sonsuz döngüyü engellemek için programımızın bir yerinde Python’a bu döngüden çıkmasını sağlayacak bir emir vermemiz gerekiyor. Biz hesap makinesi programımızda bu döngüyü şu şekilde kırdık:

Dikkat ederseniz burada adlı yeni bir araç görüyoruz. Bu aracın tam olarak ne işe yaradığını ilerleyen sayfalarda inceleyeceğiz. Şimdilik yalnızca şunu bilelim: break kelimesi İngilizce’de ‘kırmak, koparmak, bozmak’ gibi anlamlara gelir. Bu aracın yukarıdaki görevi döngüyü ‘kırmak’tır. Dolayısıyla kullanıcı klavyede q tuşuna bastığında, ifadesi ile çalışmaya başlayan döngü kırılacak ve programımız sona erecektir.

Bu yapıyı daha iyi anlayabilmek için şöyle basit bir örnek daha verelim:

Görüyorsunuz, aslında mantık gayet basit:

Bir döngü oluştur ve bu döngüden çıkmak istediğinde, programın bir yerinde bu döngüyü sona erdirecek bir koşul meydan getir.

Bu mantığı yukarıdaki örneğe şu şekilde uyguladık:

while True: ifadesi yardımıyla bir döngü oluştur ve kullanıcı bu döngüden çıkmak istediğinde (yani q tuşuna bastığında), döngüyü kır ve programı sona erdir.

Gelin isterseniz bu konuyu daha net kavramak için bir örnek daha verelim:

Burada programımız kullanıcıya üç kez ‘Nasılsınız, iyi misiniz?’ sorusunu soracak ve ardından kapanacaktır. Bu kodlarda döngüsünü nasıl kullandığımıza dikkat edin. Aslında programın mantığı çok basit:

1. Öncelikle değeri 1 olan tekrar adlı bir değişken tanımlıyoruz.

2. Bu değişkenin değeri 3’e eşit veya 3’ten küçük olduğu müddetçe () değişkenin değerine 1 ekliyoruz ().

3. Başka bir deyişle ifadesi True olduğu müddetçe değişkenin değerine 1 ekliyoruz.

4. tekrar değişkenine her 1 ekleyişimizde kullanıcıya ‘Nasılsınız, iyi misiniz?’ sorusunu soruyoruz ().

5. tekrar değişkeninin değeri 3’ü aştığında ifadesi artık False değeri verdiği için programımız sona eriyor.

Yukarıdaki uygulamada Python’ın alttan alta neler çevirdiğini daha iyi görmek için bu uygulamayı şöyle yazmayı deneyin:

Daha önce de dediğimiz gibi, bir Python programının nasıl çalıştığını anlamanın en iyi yolu, program içinde uygun yerlere fonksiyonları yerleştirerek arka planda hangi kodların hangi çıktıları verdiğini izlemektir. İşte yukarıda da bu yöntemi kullandık. Yani tekrar değişkenininin değerini ve ifadesinin çıktısını ekrana yazdırarak arka tarafta neler olup bittiğini canlı canlı görme imkanına kavuştuk.

Yukarıdaki programı çalıştırdığımızda şuna benzer çıktılar görüyoruz:

Gördüğünüz gibi, tekrar değişkeninin değeri her döngüde 1 artıyor. ifadesinin bool değeri, tekrar adlı değişkenin değeri 3’ü aşana kadar hep True olacaktır. Bu değişkenin değeri 3’ü aştığı anda ifadesinin bool değeri False’a dönüyor ve böylece döngüsü sona eriyor.

Peki size şöyle bir soru sorsam: Acaba döngüsünü kullanarak 1’den ’e kadar olan aralıktaki çift sayıları nasıl bulursunuz?

Çok basit:

Gördüğünüz gibi, döngüsünün içine bir adet bloğu yerleştirdik.

Yukarıdaki kodları şu şekilde Türkçeye çevirebiliriz:

a değişkeninin değeri ’den küçük olduğu müddetçe a değişkeninin değerini 1 artır. Bu değişkenin değerini her artırışında yeni değerin 2’ye tam bölünüp bölünmediğini kontrol et. Eğer değeri 0 ise (), yani a’nın değeri bir çift sayı ise, bu değeri ekrana yazdır.

Gördüğünüz gibi, döngüsü son derece kullanışlı bir araçtır. Üstelik kullanımı da son derece kolaydır. Bu döngüyle bol bol pratik yaparak bu döngüyü rahatça kullanabilecek duruma gelebilirsiniz.

En başta da söylediğimiz gibi, Python’da dışında bir de döngüsü vardır. En az kadar önemli bir döngü olan döngüsünün nasıl kullanıldığını anlamaya çalışalım şimdi de.

for Döngüsü¶

Etrafta yazılmış Python programlarının kaynak kodlarını incelediğinizde, içinde döngüsü geçmeyen bir program kolay kolay bulamazsınız. Belki döngüsünün kullanılmadığı programlar vardır. Ancak döngüsü Python’da o kadar yaygındır ve o kadar geniş bir kullanım alanına sahiptir ki, hemen hemen bütün Python programları bu döngüsünden en az bir kez yararlanır.

Peki nedir bu döngüsü denen şey?

da tıpkı gibi bir döngüdür. Yani tıpkı döngüsünde olduğu gibi, programlarımızın birden fazla sayıda çalışmasını sağlar. Ancak döngüsü döngüsüne göre biraz daha yeteneklidir. döngüsü ile yapamayacağınız veya yaparken çok zorlanacağınız şeyleri döngüsü yardımıyla çok kolay bir şekilde halledebilirsiniz.

Yalnız, söylediğimiz bu cümleden, döngüsünün döngüsüne bir alternatif olduğu sonucunu çıkarmayın. Evet, ile yapabildiğiniz bir işlemi ile de yapabilirsiniz çoğu zaman, ama bu döngülerin, belli vakalar için tek seçenek olduğu durumlar da vardır. Zira bu iki döngünün çalışma mantığı birbirinden farklıdır.

Şimdi gelelim döngüsünün nasıl kullanılacağına…

Dikkatlice bakın:

Burada öncelikle tr_harfler adlı bir değişken tanımladık. Bu değişken Türkçeye özgü harfleri tutuyor. Daha sonra bir döngüsü kurarak, tr_harfler adlı değişkenin her bir öğesini tek tek ekrana yazdırdık.

Peki bu döngüsünü nasıl kurduk?

döngülerinin söz dizimi şöyledir:

Bu söz dizimini Türkçe olarak şöyle ifade edebiliriz:

Bu soyut yapıları kendi örneğimize uygulayarak durumu daha net anlamaya çalışalım:

Yukarıdaki örnekte bir döngüsü yardımıyla tr_harfler adlı değişken içindeki her bir öğeyi ekrana yazdırdık. Esasında döngüsünün yeteneklerini düşündüğümüzde bu örnek pek heyecan verici değil. Zira aynı işi aslında fonksiyonu ile de yapabilirdik:

Aslında bu işlemi ile de yapmak mümkün (Bu kodlardaki, henüz öğrenmediğimiz kısmı şimdilik görmezden gelin):

döngüsü kullanıldığında işi uzattığımızı görüyorsunuz. Dediğimiz gibi, döngüsü döngüsüne göre biraz daha yeteneklidir ve ile yapması daha zor (veya uzun) olan işlemleri döngüsü ile çok daha kolay bir şekilde yapabiliriz. Ayrıca döngüsü ile döngüsünün çalışma mantıkları birbirinden farklıdır. döngüsü, üzerinde döngü kurulabilecek veri tiplerinin her bir öğesinin üzerinden tek tek geçer ve bu öğelerin her biri üzerinde bir işlem yapar. döngüsü ise herhangi bir ifadenin bool değerini kontrol eder ve bu değerin bool değeri False olana kadar, belirlenen işlemi yapmayı sürdürür.

Bu arada, biraz önce ‘üzerinde döngü kurulabilecek veri tipleri’ diye bir kavramdan söz ettik. Örneğin karakter dizileri, üzerinde döngü kurulabilecek bir veri tipidir. Ama sayılar öyle değildir. Yani sayılar üzerinde döngü kuramayız. Mesela:

Buradaki hata mesajından da göreceğiniz gibi int (tam sayı) türündeki nesneler üzerinde döngü kuramıyoruz. Hata mesajında görünen not iterable (üzerinde döngü kurulamaz) ifadesiyle kastedilen de budur.

Gelin isterseniz döngüsü ile bir örnek daha vererek durumu iyice anlamaya çalışalım:

Burada sayılar adlı değişkenin her bir öğesini sayı olarak adlandırdıktan sonra, fonksiyonu yardımıyla bu öğeleri tek tek sayıya çevirdik ve her bir öğeyi 2 ile çarptık.

döngüsünün mantığını az çok anlamış olmalısınız. Bu döngü bir değişken içindeki her bir öğeyi tek tek ele alıp, iki nokta üst üste işaretinden sonra yazdığımız kod bloğunu bu öğelere tek tek uyguluyor.

for kelimesi İngilizcede ‘için’ anlamına gelir. Döngünün yapısı içinde geçen in ifadesini de tanıyorsunuz. Biz bu ifadeyi ‘Aitlik İşleçleri’ konusunu işlerken de görmüştük. Hatırlarsanız in işleci bir öğenin bir veri tipi içinde bulunup bulunmadığını sorguluyordu. Mesela:

“h” öğesi “seafoodplus.info” adlı karakter dizisi içinde geçtiği için kodu True çıktısı veriyor. Bir de şuna bakın:

“b” öğesi “seafoodplus.info” karakter dizisi içinde bulunmuyor. Dolayısıyla sorgulaması False çıktısı veriyor.

in kelimesi İngilizcede ‘içinde’ anlamına geliyor. Dolayısıyla yazdığımızda aslında şöyle bir şey demiş oluyoruz:

filanca içinde falanca adını verdiğimiz her bir öğe için…

Yani şu kod:

Şu anlama geliyor:

“istihza” karakter dizisi içinde s adını verdiğimiz her bir öğe için:

s öğesini ekrana basma işlemi gerçekleştir!

Ya da şu kod:

Şu anlama geliyor:

sayılar değişkeni içinde i adını verdiğimiz her bir öğe için:

eğer sayıya dönüştürülmüş i değeri 3’ten büyükse:

i öğesini ekrana basma işlemi gerçekleştir!

Yukarıdaki temsili kodların Türkçesi bozuk olsa da döngüsünün çalışma mantığını anlamaya yardımcı olacağını zannediyorum. Ama yine de, eğer bu döngünün mantığını henüz kavrayamadıysanız hiç endişe etmeyin. Zira bu döngüyü oldukça sık bir biçimde kullanacağımız için, siz istemeseniz de bu döngü kafanızda yer etmiş olacak.

Bu döngüsünü biraz daha iyi anlayabilmek için son bir örnek yapalım:

Bu program, kullanıcıya bir parola soruyor. Eğer kullanıcının girdiği parola içinde Türkçe karakterlerden herhangi biri varsa kullanıcıyı Türkçe karakter kullanmaması konusunda uyarıyor. Buradaki döngüsünü nasıl kurduğumuzu görüyorsunuz. Aslında burada şu Türkçe cümleyi Pythonca’ya çevirmiş olduk:

parola değişkeni içinde karakter adını verdiğimiz her bir öğe için:

eğer karakter değişkeni tr_harfler adlı değişken içinde geçiyorsa:

‘parolada Türkçe karakter kullanılamaz’ uyarısını göster!

Burada kullandığımız döngüsü sayesinde kullanıcının girdiği parola adlı değişken içindeki bütün karakterlere tek tek bakıp, eğer bakılan karakter tr_harfler adlı değişken içinde geçiyorsa kullanıcıyı uyarıyoruz.

Aslında döngüsüyle ilgili söyleyeceklerimiz bu kadar değil. Ama henüz bu döngüyle kullanılan önemli araçları tanımıyoruz. Gerçi zaten bu döngüyü bundan sonra sık sık kullandığımızı göreceksiniz.

Gelin isterseniz yeni bir konuya geçmeden önce döngülerle ilgili ufak bir örnek verelim:

Örneğin kullanıcıya bir parola belirletirken, belirlenecek parolanın 8 karakterden uzun, 3 karakterden kısa olmamasını sağlayalım:

Burada öncelikle, programınızın sürekli olarak çalışmasını sağlamak için bir döngüsü oluşturduk. Buna göre, aksi belirtilmedikçe () programımız çalışmaya devam edecek.

döngüsünü kurduktan sonra kullanıcıya bir parola soruyoruz ()

Eğer kullanıcı herhangi bir parola belirlemeden doğrudan Enter tuşuna basarsa, yani parola değişkeninin bool değeri False olursa (), kullanıcıya ‘parola bölümü boş geçilemez!’ uyarısı veriyoruz.

Eğer kullanıcı tarafından belirlenen parolanın uzunluğu 8 karakterden fazlaysa ya da 3 karakterden kısaysa, ‘parola 8 karakterden uzun 3 karakterden kısa olmamalı’ uyarısı veriyoruz.

Yukarıdaki koşullar harici durumlar için ise (), belirlenen yeni parolayı kullanıcıya gösterip döngüden çıkıyoruz ().

Bu arada, hatırlarsanız fonksiyonunu anlatırken şöyle bir örnek vermiştik:

Bu programdaki eksiklikleri ve riskleri biliyorsunuz. Böyle bir program yazdığınızda, fonksiyonunu kontrolsüz bir şekilde kullandığınız için önemli bir güvenlik açığına sebep olmuş oluyorsunuz. Gelin isterseniz bu derste öğrendiğimiz bilgileri de kullanarak yukarıdaki fonksiyonu için basit bir kontrol mekanizması kuralım:

Burada öncelikle programımızı bir döngüsü içine aldık. Böylece programımızın ne zaman sona ereceğini kendimiz belirleyebileceğiz. Buna göre eğer kullanıcı klavyede ‘q’ tuşuna basarsa döngüsü sona erecek.

Bu programda bizi özellikle ilgilendiren kısım şu:

Gördüğünüz gibi, ilk olarak izinli_karakterler adlı bir değişken tanımladık. Program içinde kullanılmasına izin verdiğimiz karakterleri bu değişken içine yazıyoruz. Buna göre kullanıcı yalnızca 0, 1, 2, 3, 4, 5, 6, 7, 8 ve 9 sayılarını, +, -, /, * ve = işleçlerini, ayrıca boşluk karakterini (’ ‘) kullanabilecek.

Kullanıcının girdiği veri üzerinde bir döngüsü kurarak, veri içindeki her bir karakterin izinli_karakterler değişkeni içinde yer alıp almadığını denetliyoruz. İzin verilen karakterler dışında herhangi bir karakterin girilmesi Neyin peşindesin?! çıktısının verilip programdan tamamen çıkılmasına () yol açacaktır.

Eğer kullanıcı izinli karakterleri kullanarak bir işlem gerçekleştirmişse kodu aracılığıyla, kullanıcının yaptığı işlemi fonksiyonuna gönderiyoruz.

Böylece fonksiyonunu daha güvenli bir hale getirebilmek için basit bir kontrol mekanizmasının nasıl kurulabileceğini görmüş olduk. Kurduğumuz kontrol mekanizmasının esası, kullanıcının girebileceği veri türlerini sınırlamaya dayanıyor. Böylece kullanıcı mesela şöyle tehlikeli bir komut giremiyor:

Çünkü bu komutu yazabilmesi için gereken karakterler izinli_karakterler değişkeni içinde tanımlı değil. Kullanıcı yalnızca basit bir hesap makinesinde kullanılabilecek olan sayıları ve işleçleri girebiliyor.

İlgili Araçlar¶

Elbette döngüler tek başlarına bir şey ifade etmezler. Döngülerle işe yarar kodlar yazabilmemiz için bazı araçlara ihtiyacımız var. İşte bu bölümde döngüleri daha verimli kullanmamızı sağlayacak bazı fonksiyon ve deyimlerden söz edeceğiz. İlk olarak adlı bir fonksiyondan bahsedelim.

range Fonksiyonu¶

range kelimesi İngilizcede ‘aralık’ anlamına gelir. Biz Python’da fonksiyonunu belli bir aralıkta bulunan sayıları göstermek için kullanıyoruz. Örneğin:

Gördüğünüz gibi, kodu sayesinde ve döngüsünü de kullanarak, 0 ile 10 (10 hariç) aralığındaki sayıları ekrana yazdırdık.

Yukarıdaki kodda fonksiyonuna 0 ve 10 olmak üzere iki adet parametre verdiğimizi görüyorsunuz. Burada 0 sayısı, aralıktaki ilk sayıyı, 10 sayısı ise aralıktaki son sayıyı gösteriyor. Yani fonksiyonunun formülü şöyledir:

Bu arada, kodunun verdiği çıktıya ilk_sayının dahil olduğuna, ama son_sayının dahil olmadığına dikkat edin.

Eğer fonksiyonunun ilk parametresi 0 olacaksa, bu parametreyi belirtmesek de olur. Yani mesela 0’dan 10’a kadar olan sayıları listeleyeceksek fonksiyonunu şöyle yazmamız yeterli olacaktır:

fonksiyonunun ilk_sayı parametresi verilmediğinde Python ilk parametreyi 0 olarak alır. Yani gibi bir kodu Python olarak algılar. Elbette, eğer aralıktaki ilk sayı 0’dan farklı olacaksa bu sayıyı açık açık belirtmek gerekir:

Burada 3’ten itibaren 20’ye kadar olan sayılar ekrana dökülecektir.

Hatırlarsanız, biraz önce, kullanıcının 3 karakterden kısa, 8 karakterden uzun parola belirlemesini engelleyen bir uygulama yazmıştık. O uygulamayı fonksiyonunu kullanarak da yazabiliriz:

Bu fonksiyonu kullanarak bir döngünün kaç kez çalışacağını da belirleyebilirsiniz. Aşağıdaki kodları dikkatlice inceleyin:

Burada kodu sayesinde döngüsü içinde belirttiğimiz i adlı değişkenin değeri 2 olduğu anda ‘parolayı 3 kez yanlış girdiniz…’ uyarısı gösterilecektir. Daha önce de birkaç yerde ifade ettiğimiz gibi, eğer yukarıdaki kodların çalışma mantığını anlamakta zorlanıyorsanız, programın uygun yerlerine fonksiyonu yerleştirerek arka planda Python’ın neler çevirdiğini daha net görebilirsiniz. Örneğin:

Gördüğünüz gibi, i değişkeninin başlangıçtaki değeri 0. Bu değer her döngüde 1 artıyor ve bu değişkenin değeri 2 olduğu anda bloğu devreye giriyor.

fonksiyonunun yetenekleri yukarıda anlattıklarımızla sınırlı değildir. Bu fonksiyonun bazı başka maharetleri de bulunur. Hatırlarsanız yukarıda bu fonksiyonun formülünü şöyle vermiştik:

Buna göre fonksiyonu iki parametre alıyor. Ama aslında bu fonksiyonun üçüncü bir parametresi daha vardır. Buna göre formülümüzü güncelleyelim:

Formüldeki son parametre olan atlama_değeri, aralıktaki sayıların kaçar kaçar ilerleyeceğini gösterir. Yani:

Gördüğünüz gibi, son parametre olarak verdiğimiz 2 sayısı sayesinde 0’dan 10’a kadar olan sayılar ikişer ikişer atlayarak ekrana dökülüyor.

Bu arada, bir şey dikkatinizi çekmiş olmalı:

fonksiyonu üç farklı parametre alan bir fonksiyon. Eğer ilk parametre 0 olacaksa bu parametreyi belirtmek zorunda olmadığımızı biliyoruz. Yani:

Python bu kodu olarak algılayıp buna göre değerlendiriyor. Ancak eğer fonksiyonunda üçüncü parametreyi de kullanacaksak, yani gibi bir komut vereceksek, üç parametrenin tamamını da belirtmemiz gerekiyor. Eğer burada bütün parametreleri belirtmezsek Python hangi sayının hangi parametreye karşılık geldiğini anlayamaz. Yani mesela 0’dan 10’a kadar olan sayıları ikişer ikişer atlayarak ekrana dökmek için şöyle bir şey yazmaya çalıştığımızı düşünün:

Burada Python ne yapmaya çalıştığınızı anlayamaz. Parantez içinde ilk değer olarak 10, ikinci değer olarak ise 2 yazdığınız için, Python bu 10 sayısını başlangıç değeri; 2 sayısını ise bitiş değeri olarak algılayacaktır. Dolayısıyla da Python bu durumda sizin 10’dan 2’ye kadar olan sayıları listelemek istediğinizi zannedecek, fonksiyonuyla bu şekilde geriye doğru sayamayacağımız için de boş bir çıktı verecektir. Bu yüzden, Python’un şaşırmaması için yukarıdaki örneği şu şekilde yazmalıyız:

Kısacası, eğer fonksiyonunun kaçar kaçar sayacağını da belirtmek istiyorsak, parantez içinde, gerekli bütün parametreleri belirtmeliyiz.

Gördüğünüz gibi, fonksiyonunu kullanarak belirli bir aralıktaki sayıları alabiliyoruz. Peki bu sayıları tersten alabilir miyiz? Elbette:

Burada fonksiyonunu nasıl yazdığımıza çok dikkat edin. Sayıları tersten alacağımız için, ilk parametre 10, ikinci parametre ise 0. Üçüncü parametre olarak ise eksi değerli bir sayı veriyoruz. Eğer sayıları hem tersten, hem de mesela 3’er 3’er atlayarak yazmak isterseniz şöyle bir komut verebilirsiniz:

Bu arada, etkileşimli kabukta gibi bir komut verdiğinizde range(0, 10) çıktısı aldığınızı görüyorsunuz. Bu çıktı, verdiğimiz komutun 0 ile 10 arası sayıları elde etmemizi sağlayacağını belirtiyor, ama bu sayıları o anda bize göstermiyor. Daha önce verdiğimiz örneklerden de anlaşılacağı gibi, 0-10 aralığındaki sayıları görebilmek için ifadesi üzerinde bir döngüsü kurmamız gerekiyor. ifadesinin taşıdığı sayıları görebilmek için döngüsü kurmak tek seçenek değildir. Bu işlem için yıldızlı parametrelerden de yararlanabiliriz. fonksiyonunu incelediğimiz derste yıldızlı parametrelerin nasıl kullanıldığını göstermiştik. Dilerseniz şimdi bu parametre tipini fonksiyonuna nasıl uygulayabileceğimizi görelim:

fonksiyonunun sep parametresi yardımıyla bu çıktıyı istediğiniz gibi düzenleyebileceğinizi biliyorsunuz. Mesela çıktıdaki sayıları birbirlerinden virgülle ayırmak için şöyle bir komut verebiliyoruz:

Böylece fonksiyonunu enine boyuna incelemiş ve bu fonksiyonun ne işe yaradığını, nasıl kullanılacağını anlamamızı sağlayan örnekler vermiş olduk. Artık başka bir konuyu geçebiliriz.

pass Deyimi¶

pass kelimesi İngilizcede ‘geçmek, pas geçmek’ gibi anlamlara gelir. Python’daki kullanımı da bu anlama oldukça yakındır. Biz bu deyimi Pyhon’da ‘görmezden gel, hiçbir şey yapma’ anlamında kullanacağız.

Dilerseniz deyimini tarif etmeye çalışmak yerine bu deyimi bir örnek üzerinde açıklamaya çalışalım.

Hatırlarsanız yukarıda şöyle bir örnek vermiştik:

Burada mesela eğer kullanıcı parolayı boş bırakırsa ‘parola bölümü boş geçilemez!’ uyarısı gösteriyoruz. Şimdi o bloğunu şöyle yazdığımızı düşünün:

Burada, eğer kullanıcı parolayı boş bırakırsa programımız hiçbir şey yapmadan yoluna devam edecektir. Yani burada deyimi yardımıyla programımıza şu emri vermiş oluyoruz:

Eğer kullanıcı parolayı boş geçerse görmezden gel. Hiçbir şey yapmadan yoluna devam et!

Başka bir örnek daha verelim:

Burada eğer kullanıcı 0 sayısını girerse programımız sona erer ( deyimini biraz sonra inceleyeceğiz). Eğer kullanıcı 0’dan küçük bir sayı girerse, yani kullanıcının girdiği sayı eksi değerli ise, deyimininin etkisiyle programımız hiçbir şey yapmadan yoluna devam eder. Bu koşulların dışındaki durumlarda ise programımız kullanıcının girdiği sayıları ekrana yazdıracaktır.

Yukarıda anlatılan durumların dışında, deyimini kodlarınız henüz taslak aşamasında olduğu zaman da kullanabilirsiniz. Örneğin, diyelim ki bir kod yazıyorsunuz. Programın gidişatına göre, bir noktada yapmanız gereken bir işlem var, ama henüz ne yapacağınıza karar vermediniz. Böyle bir durumda deyiminden yararlanabilirsiniz. Mesela birtakım deyimleri yazmayı düşünüyor olun:

Burada henüz bloğunda ne yapılacağına karar vermemiş olduğunuz için, oraya bir koyarak durumu şimdilik geçiştiriyorsunuz. Program son haline gelene kadar oraya bir şeyler yazmış olacaksınız.

Sözün özü, deyimlerini, herhangi bir işlem yapılmasının gerekli olmadığı durumlar için kullanıyoruz. İlerde işe yarar programlar yazdığınızda, bu deyiminin göründüğünden daha faydalı bir araç olduğunu anlayacaksınız.

break Deyimi¶

Python’da özel bir deyimdir. Bu deyim yardımıyla, devam eden bir süreci kesintiye uğratabiliriz. Bu deyimin kullanıldığı basit bir örnek verelim:

Burada, eğer kullanıcının girdiği parolanın uzunluğu 5 karakterden azsa, Parola 5 karakterden az olmamalı! uyarısı gösterilecektir. Eğer kullanıcı 5 karakterden uzun bir parola belirlemişse, kendisine ‘Parolanız belirlendi!’ mesajını gösterip, deyimi yardımıyla programdan çıkıyoruz.

Gördüğünüz gibi, ifadesinin temel görevi bir döngüyü sona erdirmek. Buradan anlayacağımız gibi, ifadesinin her zaman bir döngü içinde yer alması gerekiyor. Aksi halde Python bize şöyle bir hata verecektir:

Yani:

continue Deyimi¶

ilginç bir deyimdir. İsterseniz deyimini anlatmaya çalışmak yerine bununla ilgili bir örnek verelim:

Burada eğer kullanıcı klavyede iptal yazarsa programdan çıkılacaktır. Bunu;

satırıyla sağlamayı başardık.

Eğer kullanıcı tarafından girilen sayı üç haneli veya daha az haneli bir sayı ise, ifadesinin etkisiyle:

satırı es geçilecek ve döngünün en başına gidilecektir.

Eğer kullanıcının girdiği sayıdaki hane üçten fazlaysa ekrana:

cümlesi yazdırılacaktır.

Dolayısıyla buradan anladığımıza göre, deyiminin görevi kendisinden sonra gelen her şeyin es geçilip döngünün başına dönülmesini sağlamaktır. Bu bilgiye göre, yukarıdaki programda eğer kullanıcı, uzunluğu üç karakterden az bir sayı girerse deyiminin etkisiyle programımız döngünün en başına geri gidiyor. Ama eğer kullanıcı, uzunluğu üç karakterden fazla bir sayı girerse, ekrana ‘En fazla üç haneli bir sayı girebilirsiniz,’ cümlesinin yazdırıldığını görüyoruz.

else Deyimi¶

Biz deyimini koşullu durumlarda da görmüştük, ancak deyimi döngüler ile de kullanılabilmektedir. Tabii döngüler ile kullanıldığında farklı bir işi üstlenmektedir. deyimi döngüler ile birlikte kullanılırken deyimi ile birlikte bir anlam kazanır. Şöyle bir kodumuz olduğunu varsayalım:

Kodumuzu kaydedip çalıştırdığımızda bu çıktıyı alıyoruz:

Peki şimdi ifadesi ne işe yaradı? Aslında pek de işe yaramadı, ifadesini yazmadan da aynı çıktıları alabilirdik. Dediğimiz gibi Python’da ifadesi döngüler ile birlikte kullanılacaksa ifadesi ile birlikte bir anlam kazanır. Eğer döngü ifadesi kullanılarak sonlandırıldı ise çalışmaz, döngü ifadesi ile sonlandırılmadı ise bölümü çalışır. Yukarıdaki örneğimizde zaten deyimi bulunmadığı için bölümü çalıştı. Şimdi çalışmayacağı bir örnek verelim:

Şimdi programımızı çalıştırdığımızda şu sonucu almaktayız:

Gördüğünüz gibi değişkenimiz olduğunda döngümüz ifadesi ile kırılıyor ve bu yüzden çalışmıyor. ifadesini hem hem de döngüsü ile kullanabileceğimizi unutmayalım.

Şimdi bu konu ile ilgili işe yarar bir örnek verelim. Bir karakter dizimiz var ve harfinin bu dizide bulunup bulunmadığını kontrol etmek istiyoruz. Eğer bulunuyorsa ekrana bunu belirten bir yazı yazacağız:

Ancak bu programı çalıştırdığımızda şöyle bir sonuçla karşılaşıyoruz:

Gördüğünüz gibi her harfi için bir defa yazılıyor. Eğer biz bir defa harfine rastladığımızda döngüden çıkmak istiyorsak bunu şu şekilde yazabiliriz:

Kodumuzu çalıştırıyoruz:

Peki şimdi harfinin bulunmadığı durumda da yazmak istersek bunu nasıl yaparız? Bazı değişkenler oluşturup ifadesi ile bunu yapmak mümkündür ancak ifadesi ile de bu işi hemen halledebiliyoruz:

Kodumuzu çalıştırdığımızda ifadesi hiç çalışmadığı için ifadesinin çalıştığını görebiliriz:

Evet, ifadesi de Python’da döngüler ile bu şekilde kullanılabiliyor. Peki olmasa da olur muydu? Olurdu. ifadesinin bu kullanım şekli de Python’daki çoğu kolaylıklardan biri sadece…

Konu ile alakalı daha çok örnek için buraya bakabilirsiniz.

Örnek Uygulamalar¶

Python programlama dilinde döngülerin neye benzediğini öğrendik. Bu bölümde ayrıca döngülerle birlikte kullanabileceğimiz başka araçları da tanıdık. Şimdi dilerseniz bu öğrendiklerimizi pekiştirmek için birkaç ufak çalışma yapalım.

Karakter Dizilerinin İçeriğini Karşılaştırma¶

Diyelim ki elinizde şöyle iki farklı metin var:

Siz burada, ilk_metin adlı değişken içinde bulunan, ama ikinci_metin adlı değişken içinde bulunmayan öğeleri ayıklamak istiyorsunuz. Yani bu iki metnin içeriğini karşılaştırıp, farklı öğeleri bulmayı amaçlıyorsunuz. Bu işlem için, bu bölümde öğrendiğimiz döngülerden ve daha önce öğrendiğimiz başka araçlardan yararlanabilirsiniz. Şimdi dikkatlice bakın:

Bu kodları bir dosyaya kaydedip çalıştırdığımızda şu çıktıyı alıyoruz:

Demek ki ilk_metin adlı değişkende olup da ikinci_metin adlı değişkende olmayan öğeler bunlarmış…

Bu kodlarda anlayamayacağınız hiçbir şey yok. Ama dilerseniz biz yine de bu kodları tek tek inceleyelim.

İlk olarak değişkenlerimizi tanımladık:

Amacımız ilk_metin’de olan, ama ikinci_metin’de olmayan öğeleri görmek. Bunun için ilk_metin’deki öğeleri tek tekikinci_metin’deki öğelerle karşılaştırmamız gerekiyor. Tahmin edebileceğiniz gibi, bir metnin bütün öğelerine tek tek bakabilmenin en iyi yolu döngülerini kullanmaktır. O halde döngümüzü yazalım:

Gördüğünüz gibi, döngüleri (), bool işleçlerini (not) ve aitlik işleçlerini (in) kullanarak, istediğimiz şeyi rahatlıkla yapabiliyoruz. Burada kullandığımız deyimi, bir önceki satırda döngüsü ile üzerinden geçtiğimiz öğeleri süzmemizi sağlıyor. Burada temel olarak şu üç işlemi yapıyoruz:

1. ilk_metin içindeki bütün öğelerin üzerinden geçiyoruz,

2. Bu öğeleri belli bir ölçüte göre süzüyoruz,

3. Ölçüte uyan öğeleri ekrana basıyoruz.

Elbette yukarıda yaptığımız işlemin tersini yapmak da mümkündür. Biz yukarıdaki kodlarda ilk_metin’de olan, ama ikinci_metin’de olmayan öğeleri süzdük. Eğer istersek ikinci_metin’de olan, ama ilk_metin’de olmayan öğeleri de süzebiliriz. Mantığımız yine aynı:

Bu da bize şu çıktıyı veriyor:

Gördüğünüz gibi, yaptığımız tek şey, ilk_metin ile ikinci_metin’in yerlerini değiştirmek oldu. Kullandığımız mantık ise değişmedi.

Bu arada, yukarıdaki çıktıda bizi rahatsız eden bir durum var. Çıktıda bazı harfler birbirini tekrar ediyor. Aslında temel olarak sadece şu harfler var:

Ama metin içinde bazı harfler birden fazla sayıda geçtiği için, doğal olarak çıktıda da bu harfler birden fazla sayıda görünüyor. Ama tabii ki, eğer biz istersek farklı olan her harften yalnızca bir tanesini çıktıda görmeyi de tercih edebiliriz. Bunun için şöyle bir kod yazabiliriz:

Burada da anlayamayacağımız hiçbir şey yok. Bu kodlardaki bütün parçaları tanıyoruz. Her zamanki gibi öncelikle değişkenlerimizi tanımladık:

Daha sonra fark adlı boş bir karakter dizisi tanımlıyoruz. Metinler içindeki farklı karakter dizilerini fark adlı bu karakter dizisi içinde depolayacağız.

Ardından da döngümüzü yazıyoruz:

Uyguladığımız mantığın ne kadar basit olduğunu görüyorsunuz. Bu kodlarda basitçe şu işlemleri yapıyoruz:

1. ikinci_metin değişkeni içindeki bütün öğelerin üzerinden tek tek geç,

2. Eğer bu değişkendeki herhangi bir öğe ilk_metin’de ve fark’ta yoksa o öğeyi fark’a ekle.

3. Son olarak da fark’ı ekrana bas.

Bu kodlarda dikkatimizi çeken ve üzerinde durmamız gereken bazı noktalar var. Burada özellikle fark değişkenine öğe ekleme işlemini nasıl yaptığımıza dikkat edin.

Python programlama dilinde önceden oluşturduğumuz bir karakter dizisini başka bir karakter dizisi ile birleştirdiğimizde bu işlem ilk oluşturduğumuz karakter dizisini etkilemez. Yani:

Burada sanki a adlı özgün karakter dizisini değiştirmişiz ve ‘seafoodplus.info’ değerini elde etmişiz gibi görünüyor. Ama aslında a’nın durumunda hiçbir değişiklik yok:

Gördüğünüz gibi, a değişkeninin değeri hâlâ ‘istihza’. Bu durumun nedeni, birleştirme işlemlerinin bir değiştirme işlemi olmamasıdır. Yani mesela iki karakter dizisini birleştirdiğinizde birleşen karakter dizileri üzerinde herhangi bir değişiklik olmaz. Bu durumda yapabileceğimiz tek şey, karakter dizisine eklemek istediğimiz öğeyi de içeren yeni bir karakter dizisi oluşturmaktır. Yani:

Burada sanki değeri ‘istihza’ olan a adlı bir değişkene ‘.com’ değerini eklemişiz gibi görünüyor, ama aslında biz burada a değişkenini yok edip, ‘seafoodplus.info’ değerini içeren, a adlı başka bir değişken tanımladık. Bu durumu nasıl teyit edeceğinizi biliyorsunuz:

Burada fonksiyonunu kullanarak karakter dizilerinin kimliklerini sorguladık. Gördüğünüz gibi, isimleri aynı da olsa, aslında ortada iki farklı a değişkeni var. Kimlik numaralarının farklı olmasından anladığımıza göre, ilk başta tanımladığımız a değişkeni ile satırıyla oluşturduğumuz a değişkeni birbirinden farklı.

Bu arada, eğer istersek yukarıdaki değer atama işlemini, önceki bölümlerde öğrendiğimiz değer atama işleçleri yardımıyla kısaltabileceğimizi de biliyorsunuz:

İşte ilk_metin ile ikinci_metin değişkenleri arasındaki farklı harfleri yalnızca birer kez yazdırmak için kullandığımız kodlarda da yukarıdaki işlemi yaptık:

Gördüğünüz gibi, önce boş bir fark değişkeni oluşturduk. Daha sonra bu değişkene döngüsü içinde yeni değerler atayabilmek (daha doğrusu atarmış gibi yapmak) için gibi bir kod kullandık. Böylece for döngüsünün her dönüşünde s adını verdiğimiz her bir öğeyi tek tek fark değişkenine yolladık. Böylece program sonunda elimizde, farklı öğeleri yalnızca birer kez içeren fark adlı bir değişken olmuş oldu. Dediğimiz gibi, ilk başta tanımladığımız boş fark değişkeni ile, program sonunda farklı değerleri içeren fark değişkeni aslında aynı değil. Yani biz ilk fark değişkenine döngünün her dönüşünde yeni bir öğe eklemek yerine, döngünün her dönüşünde yeni bir fark değişkeni oluşturmuş oluyoruz. Ama programın sonunda sanki fark değişkenine her defasında yeni bir değer atamışız gibi görünüyor ve bu da bizim işimizi görmemize yetiyor…

Programın başındaki ve sonundaki fark değişkenlerinin aslında birbirinden farklı olduğunu teyit etmek için şu kodları kullanabilirsiniz:

Gördüğünüz gibi, gerçekten de ortada iki farklı fark değişkeni var. Bu durumu fonksiyonu yardımıyla doğrulayabiliyoruz.

Peki bu bilginin bize ne faydası var?

Şimdilik şu kadarını söyleyelim: Eğer o anda muhatap olduğunuz bir veri tipinin mizacını, huyunu-suyunu bilmezseniz yazdığınız programlarda çok kötü sürprizlerle karşılaşabilirsiniz. Birkaç bölüm sonra başka veri tiplerini de öğrendikten sonra bu durumu daha ayrıntılı bir şekilde inceleyeceğiz.

Bu arada, tahmin edebileceğiniz gibi yukarıdaki döngüsünü şöyle de yazabilirdik:

Burada iki farklı deyimini iki farklı satırda yazmak yerine, bu deyimleri and işleci ile birbirine bağladık.

Bu örnek ile ilgili söyleyeceklerimiz şimdilik bu kadar. Gelin biz şimdi isterseniz bilgilerimizi pekiştirmek için başka bir örnek daha yapalım.

Dosyaların İçeriğini Karşılaştırma¶

Bir önceki örnekte karakter dizilerinin içeriğini nasıl karşılaştırabileceğimizi gösteren bir örnek vermiştik. Şimdi de, gerçek hayatta karşınıza çıkması daha olası bir durum olması bakımından, dosyaların içeriğini nasıl karşılaştıracağımıza dair bir örnek verelim.

Esasında karakter dizilerinin içeriğini birbirleriyle nasıl karşılaştırıyorsak, dosyaların içeriğini de benzer şekilde karşılaştırabiliriz. Mesela içeriği şu olan seafoodplus.info adlı bir dosyamız olduğunu varsayalım:

Yine içeriği şu olan bir de seafoodplus.info adlı başka bir dosya daha olduğunu düşünelim:

Amacımız bu iki dosyanın içeriğini karşılaştırıp, farklı öğeleri ortaya sermek. Dediğimiz gibi, bir önceki örnekte izlediğimiz yolu burada da takip edebiliriz. Dikkatlice bakın:

Gerçekten de mantığın bir önceki örnekle tamamen aynı olduğunu görüyorsunuz. Biz henüz Python’da dosyaların nasıl işleneceğini öğrenmedik, ama daha önce gördüğümüz fonksiyonu yardımıyla en azından dosyaları açabilecek kadar biliyoruz dosya işlemlerinin nasıl yürütüleceğini…

Burada farklı olarak adlı bir metot görüyoruz. Biz burada bu metodun ayrıntılarına inmeyeceğiz, ama şimdilik dosya içeriğinin satırlar halinde okunmasını sağladığını bilelim yeter.

Bu arada, eğer çıktıda Türkçe karakterleri düzgün görüntüleyemiyorsanız fonksiyonunun encoding adlı bir parametresi vasıtasıyla içeriği UTF-8 olarak kodlayabilirsiniz:

Bu şekilde Türkçe karakterleri düzgün bir şekilde görüntüleyebiliyor olmanız lazım. Eğer Windows’ta Türkçe karakterleri hala düzgün görüntüleyemiyorsanız encoding parametresinde ‘utf-8’ yerine ‘cp’ adlı dil kodlamasını kullanmayı deneyebilirsiniz:

Yukarıdaki örneklerde bir içerik karşılaştırması yapıp, farklı öğeleri ayıkladık. Aynı şekilde benzer öğeleri ayıklamak da mümkündür. Bu işlemin nasıl yapılacağını az çok tahmin ettiğinizi zannediyorum:

Burada bir öncekinden farklı olarak kodu yerine, doğal olarak, kodunu kullandığımıza dikkat edin.

Dosyalar üzerinde yaptığımız işlemleri tamamladıktan sonra metodu ile bunları kapatmayı unutmuyoruz:

Karakter Dizisindeki Karakterleri Sayma¶

Yukarıdaki örneklerde içerik karşılaştırmaya ilişkin birkaç örnek verdik. Şimdi yine bilgilerimizi pekiştirmek için başka bir konuya ilişkin örnekler verelim.

Mesela elimizde şöyle bir metin olduğunu varsayalım:

Yapmamız gereken bir istatistik çalışması gereğince bu metinde her harfin kaç kez geçtiğini hesaplamanız gerekiyor.

Bunun için şöyle bir program yazabiliriz:

Burada öncelikle metnimizi bir değişken olarak tanımladık. Ardından da kullanıcıya hangi harfi sorgulamak istediğini sorduk.

Bu kodlarda tanımladığımız sayı adlı değişken, sorgulanan harfi, metinde geçtiği sayıda içinde barındıracaktır. Yani mesela metin 5 tane a harfi varsa sayı değişkeninin değeri aaaaa olacaktır.

Sonraki satırlarda döngümüzü tanımlıyoruz:

Dediğimiz gibi, sayı değişkeni, sorgulanan harfi, metinde geçtiği sayıda barındırıyor. Dolayısıyla bir harfin metinde kaç kez geçtiğini bulmak için sayı değişkeninin uzunluğunu yazdırmamız yeterli olacaktır:

Dilerseniz yukarıdaki programı yazmak için daha farklı bir mantık da kullanabilirsiniz. Dikkatlice bakın:

Burada sayı değişkeninin ilk değeri 0 olarak belirledik. Döngü içinde de, sorgulanan harfin metin içinde her geçişinde sayı değişkeninin değerini 1 sayı artırdık. Dolayısıyla sorgulanan harfin metinde kaç kez geçtiğini bulmak için sayı değişkeninin son değerini yazdırmamız yeterli oldu.

Dosya içindeki Karakterleri Sayma¶

Dilerseniz bir önceki örnekte kullandığımız metnin program içinde bir değişken değil de, mesela bir dosyadan okunan bir metin olduğunu varsayalım şimdi:

Burada yaptığımız ilk iş elbette dosyamızı açmak oldu:

Bu komutla, hakkıseafoodplus.info adlı dosyayı UTF-8 kodlaması ile açtık. Daha sonra kullanıcıya, sorgulamak istediği harfi soruyoruz:

Ardından da sorgulanan harfin dosyada kaç kez geçtiği bilgisini tutacak olan sayı adlı bir değişken tanımlıyoruz:

Sıra geldi döngümüzü tanımlamaya:

Bu döngüyü anlamakta bir miktar zorlanmış olabilirsiniz. Her zaman söylediğimiz gibi, Python’da bir kod parçasını anlamanın en iyi yöntemi, gerekli yerlere fonksiyonları yerleştirerek, programın verdiği çıktıları incelemektir:

Gördüğünüz gibi, ilk döngüsünün hemen sonrasına bir fonksiyonu yerleştirerek bu döngünün verdiği çıktıları inceliyoruz. Bu arada, amacımıza hizmet etmeyen satırları da yorum içine alarak etkisizleştirdiğimize dikkat edin.

Çıktıya baktığımız zaman, şöyle bir durumla karşılaşıyoruz:

Burada her bir satır ayrı bir karakter dizisidir. Eğer her bir satırın ayrı bir karakter dizisi olduğunu daha net bir şekilde görmek istiyorsanız adlı özel bir fonksiyondan yararlanabilirsiniz:

Bu kodlar bu kez şöyle bir çıktı verir:

Bu çıktıya çok dikkatlice bakın. fonksiyonu sayesinde Python’ın alttan alta neler çevirdiğini bariz bir biçimde görüyoruz. Karakter dizisinin başlangıç ve bitişini gösteren tırnak işaretleri ve \n kaçış dizilerinin görünür vaziyette olması sayesinde her bir satırın ayrı bir karakter dizisi olduğunu daha net bir şekilde görebiliyoruz.

Biz yazdığımız kodlarda, kullanıcıdan bir harf girmesini istiyoruz. Kullandığımız algoritma gereğince bu harfi metindeki karakter dizileri içinde geçen her bir karakterle tek tek karşılaştırmamız gerekiyor. metodu aracılığıyla kullanıcıdan tek bir karakter alıyoruz. Kullandığımız döngüsü ise bize bir karakter yerine her satırda bir karakter dizisi veriyor. Dolayısıyla mesela kullanıcı ‘a’ harfini sorgulamışsa, ilk döngüsü bu harfin karşısına ‘Bu programlama dili Guido Van Rossum adlı Hollandalı bir programcın’ adlı karakter dizisini çıkaracaktır. Dolayısıyla bizim bir seviye daha alta inerek, ilk döngüsünden elde edilen değişken üzerinde başka bir döngüsü daha kurmamız gerekiyor. Bu yüzden şöyle bir kod yazıyoruz:

Böylece iç içe iki döngüsü oluşturmuş oluyoruz. İsterseniz bu anlattığımız şeyleri daha net görmek için yine fonksiyonundan yararlanabilirsiniz:

karakter değişkenin değerini ekrana yazdırarak Python’ın alttan alta neler çevirdiğini daha net görebiliyoruz.

Kodların geri kalanında ise, kullanıcının sorguladığı harfin, döngüsü ile üzerinden geçtiğimiz karakter_dizisi adlı değişken içindeki karakterlerle eşleşip eşleşmediğini denetliyoruz. Eğer eşleşiyorsa, her eşleşmede sayı değişkeninin değerini 1 sayı artırıyoruz. Böylece en elimizde sorgulanan harfin metin içinde kaç kez geçtiği bilgisi olmuş oluyor.

Son olarak da, ilk başta açtığımız dosyayı kapatıyoruz:

Nihayet bir konunun daha sonuna ulaştık. Döngüler ve döngülerle ilişkili araçları da epey ayrıntılı bir şekilde incelediğimize göre gönül rahatlığıyla bir sonraki konuya geçebiliriz.

Pythonda While Döngüsü

While döngülerinde belirttiğimiz bir koşul doğru olduğu sürece while bloğu içerisinde tanımladığımız kod satırlarını tekrarlatabiliriz.

Örnek

Ekran Çıktısı:

Belirttiğimiz koşul i' nin 5 den küçük olması ve bu koşul devam ettiği sürece (True) ekrana i değeri yazdırılmaya devam eder. Ancak burada dikkat etmemiz gereken her adımda i değerini değiştirmemiz gerektiği aksi halde sonsuz bir döngüye gireriz.

Dolayısıyla i değeri ekrana yazdırıldıktan sonra i' nin değerini 1 arttırmamız gerekiyor. i' nin değeri 5' e eşit olduğunda while koşulu bize False değer döndürür ve döngüden çıkılır.

Örnek

x değerini 1 den başlatırız ve ' den küçük mü kontrol ederiz. x, ' den küçük olduğu sürece while bloğundaki kodlar işletilir ve her adımda x' i 1 arttırırız ki sonsuz döngüye girmeyelim. 

Her adımda x%2==1 mi diye kontrol ediyoruz eğer bu ifade bize True bilgisi getirirse demek ki sayı tek olduğundan sayı tek aksi halde sayı çift mesajını yazdırıyoruz. Özetle arasındaki her sayı için tek ya da çift mesajlarını yazdırmış oluyoruz. En sonda ise bitti mesajı bir kere yazdırılır çünkü while döngüsünün dışında.

Break ve Continue 

break komutu döngüyü sonlandırır, continue ise döngünün o turunu sonlandırır ve bir sonraki turdan devam eder.

Örnek

x, 5' den küçük olduğu sürece ekrana yazdırılır ancak x' in 2 olduğu turda continue komutu çalışınca x ekrana yazdırılmaz ancak döngü sonraki turdan devam eder.

Ekran çıktısı;

Peki aynı örnekte continue yerine break yazarsak ne olur ?

Örnek

x, 5' den küçük olduğu sürece ekrana yazdırılır ancak x' in 2 olduğu turda break komutu çalışınca döngü biter ve ekrana sadece 1 yazdırılır.

Ekran çıktısı;

Örnek

1-  e kadar tek sayıların toplamını hesaplayalım.

x%2==0, True değer döndürdüğünde sayının çift olduğunu anlarız ve continue ile x değerini result içerisine eklemeyiz ancak sonraki turdan devam ederiz.

Python While Döngü Örnekleri

sayilar = [1,3,5,7,9,12,19,21]

1- Sayilar listesini while ile ekrana yazdırınız.

2- Başlangıç ve bitiş değerlerini kullanıcıdan alıp aradaki tüm tek sayıları ekrana yazdırınız.

3-  arasındaki sayıları azalan şekilde yazdırınız.

4: Kullanıcıdan alacağınız 5 sayıyı ekranda sıralı bir şekilde yazdırınız.

5: Kullanıcıdan alacağınız sınırsız ürün bilgisini urunler listesi içinde saklayınız.

   ** ürün sayısını kullanıcıya sorun.

   ** dictionary listesi yapısı (name, price) şeklinde olsun.

   ** ürün ekleme işlemi bittiğinde ürünleri ekranda while ile listeleyin.