Döngüler (Loops) #1

**Yetrox** · (Son Düzenleme: 09-06-2015, 04:55 PM, Düzenleyen: Yetrox.)

Ş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:
tuttuğum_sayı = 23

bilbakalım = int(input("Aklımdan bir sayı tuttum. Bil bakalım kaç tuttum? "))

if bilbakalım == tuttuğum_sayı:
print("Tebrikler! Bildiniz...")

else:
print("Ne yazık ki tuttuğum sayı bu değildi...")

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:

Kod:

while

ve

Kod:

for

Dilerseniz işe

Kod:

while

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

Kod:

while

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

Kod:

while

döngüsünün ne olduğunu ve ne işe yaradığını anlamaya çalışacağız. Öncelikle

Kod:

while

döngüsünün temellerini kavrayarak işe başlayalım.
Basit bir

Kod:

while

döngüsü kabaca şuna benzer:
a = 1

while a == 1:

Burada a adlı bir değişken oluşturduk. Bu değişkenin değeri 1. Bir sonraki satırda ise

Kod:

while a == 1:

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

Kod:

while a == 1

ifadesi programımıza şöyle bir anlam katıyor:

Alıntı: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

Kod:

while

ifadesinin sonundaki : işaretinden anladığımız gibi, bundan sonra gelecek satır girintili yazılacak. Devam edelim:
a = 1

while a == 1:
print("bilgisayar çıldırdı!")

Burada Python’a şu emri vermiş olduk:

Alıntı: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:
a = 1

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

while a < 10:

Kod:

while

ile verdiğimiz ilk örnekte

Kod:

while a == 1

gibi bir ifade kullanmıştık. Bu ifade;

Alıntı:a‘nın değeri 1 olduğu müddetçe...

gibi bir anlama geliyordu.

Kod:

while a < 10

ifadesi ise;

Alıntı: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:
a = 1

while a < 10:
print("bilgisayar yine çıldırdı!")

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:

Alıntı: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:
a = 1

while a < 10:
a += 1
print("bilgisayar yine çıldırdı!")

Burada

Kod:

a += 1

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ü

Kod:

while

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:

Python öncelikle
a = 1
satırını görüyor ve a‘nın değerini 1 yapıyor.
Daha sonra a‘nın değeri 10‘dan küçük olduğu müddetçe... (
while a < 10
) satırını görüyor.
Ardından a‘nın değerini, 1 artırıyor (
a += 1
) ve a‘nın değeri 2 oluyor.
a‘nın değeri (yani 2) 10‘dan küçük olduğu için Python ekrana ilgili çıktıyı veriyor.
İlk döngüyü bitiren Python başa dönüyor ve a‘nın değerinin 2 olduğunu görüyor.
a‘nın değerini yine 1 artırıyor ve a‘yı 3 yapıyor.
a‘nın değeri hâlâ 10‘dan küçük olduğu için ekrana yine ilgili çıktıyı veriyor.
İ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.
Yukarıdaki adımları tekrar eden Python, a‘nın değeri 9 olana kadar ilerlemeye devam ediyor.
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.
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:
a = 1

while a < 10:
a += 1
print(a)

Burada Python’un arkada ne işler çevirdiğini daha net görebiliyoruz. Kodlarımız içine eklediğimiz

Kod:

while

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

Kod:

while

döngüsünü daha önce yazdığımız hesap makinemize uygulayalım:
giriş = """
(1) topla
(2) çıkar
(3) çarp
(4) böl
(5) karesini hesapla
(6) karekök hesapla
"""

print(giriş)

anahtar = 1

while anahtar == 1:
soru = input("Yapmak istediğiniz işlemin numarasını girin (Çıkmak için q): ")

if soru == "q":
print("çıkılıyor...")
anahtar = 0

elif soru == "1":
sayı1 = int(input("Toplama işlemi için ilk sayıyı girin: "))
sayı2 = int(input("Toplama işlemi için ikinci sayıyı girin: "))
print(sayı1, "+", sayı2, "=", sayı1 + sayı2)

elif soru == "2":
sayı3 = int(input("Çıkarma işlemi için ilk sayıyı girin: "))
sayı4 = int(input("Çıkarma işlemi için ikinci sayıyı girin: "))
print(sayı3, "-", sayı4, "=", sayı3 - sayı4)

elif soru == "3":
sayı5 = int(input("Çarpma işlemi için ilk sayıyı girin: "))
sayı6 = int(input("Çarpma işlemi için ikinci sayıyı girin: "))
print(sayı5, "x", sayı6, "=", sayı5 * sayı6)

elif soru == "4":
sayı7 = int(input("Bölme işlemi için ilk sayıyı girin: "))
sayı8 = int(input("Bölme işlemi için ikinci sayıyı girin: "))
print(sayı7, "/", sayı8, "=", sayı7 / sayı8)

elif soru == "5":
sayı9 = int(input("Karesini hesaplamak istediğiniz sayıyı girin: "))
print(sayı9, "sayısının karesi =", sayı9 ** 2)

elif soru == "6":
sayı10 = int(input("Karekökünü hesaplamak istediğiniz sayıyı girin: "))
print(sayı10, "sayısının karekökü = ", sayı10 ** 0.5)

else:
print("Yanlış giriş.")
print("Aşağıdaki seçeneklerden birini giriniz:", giriş)

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

while anahtar == 1:
soru = input("Yapmak istediğiniz işlemin numarasını girin (Çıkmak için q): ")

if soru == "q":
print("çıkılıyor...")
anahtar = 0

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

Kod:

while

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

Kod:

if

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:
anahtar = "hoyda bre!"

#anahtar'ın değeri 'hoyda bre!' olduğu müddetçe aşağıdaki bloğu
#çalıştırmaya devam et.
while anahtar == "hoyda bre!":
soru = input("Yapmak istediğiniz işlemin numarasını girin (Çıkmak için q): ")

if soru == "q":
print("çıkılıyor...")
anahtar = "dur yolcu!"
#anahtar'ın değeri artık 'hoyda bre!' değil, 'dur yolcu'
#olduğu için döngüden çık ve böylece programı sona erdirmiş ol.

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,

Kod:

while

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:
while True:
soru = input("Yapmak istediğiniz işlemin numarasını girin (Çıkmak için q): ")

if soru == "q":
print("çıkılıyor...")
break

Bu yapıyı hesap makinemize uygulayalım:
giriş = """
(1) topla
(2) çıkar
(3) çarp
(4) böl
(5) karesini hesapla
(6) karekök hesapla
"""

print(giriş)

while True:
soru = input("Yapmak istediğiniz işlemin numarasını girin (Çıkmak için q): ")

if soru == "q":
print("çıkılıyor...")
break

elif soru == "1":
sayı1 = int(input("Toplama işlemi için ilk sayıyı girin: "))
sayı2 = int(input("Toplama işlemi için ikinci sayıyı girin: "))
print(sayı1, "+", sayı2, "=", sayı1 + sayı2)

elif soru == "2":
sayı3 = int(input("Çıkarma işlemi için ilk sayıyı girin: "))
sayı4 = int(input("Çıkarma işlemi için ikinci sayıyı girin: "))
print(sayı3, "-", sayı4, "=", sayı3 - sayı4)

elif soru == "3":
sayı5 = int(input("Çarpma işlemi için ilk sayıyı girin: "))
sayı6 = int(input("Çarpma işlemi için ikinci sayıyı girin: "))
print(sayı5, "x", sayı6, "=", sayı5 * sayı6)

elif soru == "4":
sayı7 = int(input("Bölme işlemi için ilk sayıyı girin: "))
sayı8 = int(input("Bölme işlemi için ikinci sayıyı girin: "))
print(sayı7, "/", sayı8, "=", sayı7 / sayı8)

elif soru == "5":
sayı9 = int(input("Karesini hesaplamak istediğiniz sayıyı girin: "))
print(sayı9, "sayısının karesi =", sayı9 ** 2)

elif soru == "6":
sayı10 = int(input("Karekökünü hesaplamak istediğiniz sayıyı girin: "))
print(sayı10, "sayısının karekökü = ", sayı10 ** 0.5)

else:
print("Yanlış giriş.")
print("Aşağıdaki seçeneklerden birini giriniz:", giriş)

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:

Alıntı:True olduğu müddetçe...

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:

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

Eğer yukarıdaki açıklamayı biraz bulanık bulduysanız şu örneği inceleyebilirsiniz:
while True:
print("Bilgisayar çıldırdı!")

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;

Alıntı: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:
if soru == "q":
print("çıkılıyor...")
break

Dikkat ederseniz burada

Kod:

break

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,

Kod:

while True

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:
#Aksi belirtilmediği sürece kullanıcıya
#aşağıdaki soruyu sormaya devam et!
while True:
soru = input("Nasılsınız, iyi misiniz?")

#Eğer kullanıcı 'q' tuşuna basarsa...
if soru == "q":
break #döngüyü kır ve programdan çık.

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

Alıntı: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:

Alıntı: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:
tekrar = 1

while tekrar <= 3:
tekrar += 1
input("Nasılsınız, iyi misiniz?")

Burada programımız kullanıcıya üç kez ‘Nasılsınız, iyi misiniz?’ sorusunu soracak ve ardından kapanacaktır. Bu kodlarda

Kod:

while

döngüsünü nasıl kullandığımıza dikkat edin. Aslında programın mantığı çok basit:

Öncelikle değeri 1 olan tekrar adlı bir değişken tanımlıyoruz.
Bu değişkenin değeri 3‘e eşit veya 3‘ten küçük olduğu müddetçe (
while tekrar <= 3
) değişkenin değerine 1 ekliyoruz (
tekrar += 1
).
Başka bir deyişle
bool(tekrar <= 3)
ifadesi True olduğu müddetçe değişkenin değerine 1 ekliyoruz.
tekrar değişkenine her 1 ekleyişimizde kullanıcıya ‘Nasılsınız, iyi misiniz?’ sorusunu soruyoruz (
input("Nasılsınız, iyi misiniz?")
).
tekrar değişkeninin değeri 3‘ü aştığında
bool(tekrar <= 3)
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:
tekrar = 1

while tekrar <= 3:
print("tekrar: ", tekrar)
tekrar += 1
input("Nasılsınız, iyi misiniz?")
print("bool değeri: ", bool(tekrar <= 3))

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

Kod:

print()

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

Kod:

bool(tekrar <= 3)

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:
tekrar: 1
Nasılsınız, iyi misiniz? evet
bool değeri: True
tekrar: 2
Nasılsınız, iyi misiniz? evet
bool değeri: True
tekrar: 3
Nasılsınız, iyi misiniz? evet
bool değeri: False

Gördüğünüz gibi, tekrar değişkeninin değeri her döngüde 1 artıyor.

Kod:

tekrar <= 3

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

Kod:

tekrar <= 3

ifadesinin bool değeri False‘a dönüyor ve böylece

Kod:

while

döngüsü sona eriyor.
Peki size şöyle bir soru sorsam: Acaba

Kod:

while

döngüsünü kullanarak 1‘den 100‘e kadar olan aralıktaki çift sayıları nasıl bulursunuz?
Çok basit:
a = 0

while a < 100:
a += 1
if a % 2 == 0:
print(a)

Gördüğünüz gibi,

Kod:

while

döngüsünün içine bir adet

Kod:

if

bloğu yerleştirdik.
Yukarıdaki kodları şu şekilde Türkçeye çevirebiliriz:

Alıntı:a değişkeninin değeri 100‘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

Kod:
a modülüs 2
değeri 0 ise (

Kod:
if a % 2 == 0
), yani a‘nın değeri bir çift sayı ise, bu değeri ekrana yazdır.

Gördüğünüz gibi,

Kod:

while

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

Kod:

while

dışında bir de

Kod:

for

döngüsü vardır. En az

Kod:

while

kadar önemli bir döngü olan

Kod:

for

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

Kod:

for

döngüsü geçmeyen bir program kolay kolay bulamazsınız. Belki

Kod:

while

döngüsünün kullanılmadığı programlar vardır. Ancak

Kod:

for

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

Kod:

for

döngüsünden en az bir kez yararlanır.
Peki nedir bu

Kod:

for

döngüsü denen şey?

Kod:

for

da tıpkı

Kod:

while

gibi bir döngüdür. Yani tıpkı

Kod:

while

döngüsünde olduğu gibi, programlarımızın birden fazla sayıda çalışmasını sağlar. Ancak

Kod:

for

döngüsü

Kod:

while

döngüsüne göre biraz daha yeteneklidir.

Kod:

while

döngüsü ile yapamayacağınız veya yaparken çok zorlanacağınız şeyleri

Kod:

for

döngüsü yardımıyla çok kolay bir şekilde halledebilirsiniz.
Yalnız, söylediğimiz bu cümleden,

Kod:

for

döngüsünün

Kod:

while

döngüsüne bir alternatif olduğu sonucunu çıkarmayın. Evet,

Kod:

while

ile yapabildiğiniz bir işlemi

Kod:

for

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

Kod:

for

döngüsünün nasıl kullanılacağına...
Dikkatlice bakın:
tr_harfler = "şçöğüİı"

for harf in tr_harfler:
print(harf)

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

Kod:

for

döngüsü kurarak, tr_harfler adlı değişkenin her bir öğesini tek tek ekrana yazdırdık.
Peki bu

Kod:

for

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

Kod:

for

döngülerinin söz dizimi şöyledir:
for değişken_adı in değişken:
yapılacak_işlem

Bu söz dizimini Türkçe olarak şöyle ifade edebiliriz:
değişken içindeki herbir öğeyi değişken_adı olarak adlandır:
ve bu öğelerle bir işlem yap.

Bu soyut yapıları kendi örneğimize uygulayarak durumu daha net anlamaya çalışalım:
tr_harfler adlı değişken içindeki herbir öğeyi harf olarak adlandır:
ve harf olarak adlandırılan bu öğeleri ekrana yazdır.

Yukarıdaki örnekte bir

Kod:

for

döngüsü yardımıyla tr_harfler adlı değişken içindeki herbir öğeyi ekrana yazdırdık. Esasında

Kod:

for

döngüsünün yeteneklerini düşündüğümüzde bu örnek pek heyecan verici değil. Zira aynı işi aslında

Kod:

print()

fonksiyonu ile de yapabilirdik:
tr_harfler = "şçöğüİı"
print(*tr_harfler, sep="\n")

Aslında bu işlemi

Kod:

while

ile de yapmak mümkün (Bu kodlardaki, henüz öğrenmediğimiz kısmı şimdilik görmezden gelin):
tr_harfler = "şçöğüİı"
a = 0

while a < len(tr_harfler):
print(tr_harfler[a], sep="\n")
a += 1

Kod:

while

döngüsü kullanıldığında işi uzattığımızı görüyorsunuz. Dediğimiz gibi,

Kod:

for

döngüsü

Kod:

while

döngüsüne göre biraz daha yeteneklidir ve

Kod:

while

ile yapması daha zor (veya uzun) olan işlemleri

Kod:

for

döngüsü ile çok daha kolay bir şekilde yapabiliriz. Ayrıca

Kod:

for

döngüsü ile

Kod:

while

döngüsünün çalışma mantıkları birbirinden farklıdır.

Kod:

for

döngüsü, üzerinde döngü kurulabilecek veri tiplerinin herbir öğesinin üzerinden tek tek geçer ve bu öğelerin herbiri üzerinde bir işlem yapar.

Kod:

while

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:
>>> sayılar = 123456789
>>> for sayı in sayılar:
... print(sayı)
...
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

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

Kod:

for

döngüsü ile bir örnek daha vererek durumu iyice anlamaya çalışalım:
sayılar = "123456789"

for sayı in sayılar:
print(int(sayı) * 2)

Burada sayılar adlı değişkenin herbir öğesini sayı olarak adlandırdıktan sonra,

Kod:

int()

fonksiyonu yardımıyla bu öğeleri tek tek sayıya çevirdik ve herbir öğeyi 2 ile çarptık.

Kod:

for

döngüsünün mantığını az çok anlamış olmalısınız. Bu döngü bir değişken içindeki herbir öğ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:
>>> a = "istihza.com"
>>> "h" in a

True

“h” öğesi “istihza.com” adlı karakter dizisi içinde geçtiği için

Kod:

"h" in a

kodu True çıktısı veriyor. Bir de şuna bakın:
>>> "b" in a

False

“b” öğesi “istihza.com” karakter dizisi içinde bulunmuyor. Dolayısıyla

Kod:

"b" in a

sorgulaması False çıktısı veriyor.
in kelimesi İngilizcede ‘içinde’ anlamına geliyor. Dolayısıyla

Kod:

for falanca in filanca:

yazdığımızda aslında şöyle bir şey demiş oluyoruz:

Alıntı:filanca içinde falanca adını verdiğimiz herbir öğe için...

Yani şu kod:
for s in "istihza":
print(s)

Şu anlama geliyor:

Alıntı:“istihza” karakter dizisi içinde s adını verdiğimiz herbir öğe için öğesini ekrana basma işlemi gerçekleştir!

Ya da şu kod:
sayılar = "123456789"

for i in sayılar:
if int(i) > 3:
print(i)

Şu anlama geliyor:

Alıntı:sayılar değişkeni içinde i adını verdiğimiz herbir öğ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

Kod:

for

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

Kod:

for

döngüsünü biraz daha iyi anlayabilmek için son bir örnek yapalım:
tr_harfler = "şçöğüİı"

parola = input("Parolanız: ")

for karakter in parola:
if karakter in tr_harfler:
print("parolada Türkçe karakter kullanılamaz")

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

Kod:

for

döngüsünü nasıl kurduğumuzu görüyorsunuz. Aslında burada şu Türkçe cümleyi Pythonca’ya çevirmiş olduk:

Alıntı:parola değişkeni içinde karakter adını verdiğimiz herbir öğ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

Kod:

for

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

Kod:

for

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:
while True:
parola = input("Bir parola belirleyin: ")

if not parola:
print("parola bölümü boş geçilemez!")

elif len(parola) > 8 or len(parola) < 3:
print("parola 8 karakterden uzun 3 karakterden kısa olmamalı")

else:
print("Yeni parolanız", parola)
break

Burada öncelikle, programınızın sürekli olarak çalışmasını sağlamak için bir

Kod:

while

döngüsü oluşturduk. Buna göre, aksi belirtilmedikçe (

Kod:

while True

) programımız çalışmaya devam edecek.

Kod:

while

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

Kod:

parola = input("Bir parola belirleyin: ")

)
Eğer kullanıcı herhangi bir parola belirlemeden doğrudan Enter tuşuna basarsa, yani parola değişkeninin bool değeri False olursa (

Kod:

if not parola

), 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 (

Kod:

else

), belirlenen yeni parolayı kullanıcıya gösterip döngüden çıkıyoruz (

Kod:

break

).
Bu arada, hatırlarsanız

Kod:

eval()

fonksiyonunu anlatırken şöyle bir örnek vermiştik:
print("""
Basit bir hesap makinesi uygulaması.

İşleçler:

+ toplama
- çıkarma
* çarpma
/ bölme

Yapmak istediğiniz işlemi yazıp ENTER
tuşuna basın. (Örneğin 23 ve 46 sayılarını
çarpmak için 23 * 46 yazdıktan sonra
ENTER tuşuna basın.)
""")

veri = input("İşleminiz: ")
hesap = eval(veri)

print(hesap)

Bu programdaki eksiklikleri ve riskleri biliyorsunuz. Böyle bir program yazdığınızda,

Kod:

eval()

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

Kod:

eval()

fonksiyonu için basit bir kontrol mekanizması kuralım:
izinli_karakterler = "0123456789+-/*= "

print("""
Basit bir hesap makinesi uygulaması.

İşleçler:

+ toplama
- çıkarma
* çarpma
/ bölme

Yapmak istediğiniz işlemi yazıp ENTER
tuşuna basın. (Örneğin 23 ve 46 sayılarını
çarpmak için 23 * 46 yazdıktan sonra
ENTER tuşuna basın.)
""")

while True:
veri = input("İşleminiz: ")
if veri == "q":
print("çıkılıyor...")
break

for s in veri:
if s not in izinli_karakterler:
print("Neyin peşindesin?!")
quit()

hesap = eval(veri)

print(hesap)

Burada öncelikle programımızı bir

Kod:

while

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

Kod:

while

döngüsü sona erecek.
Bu programda bizi özellikle ilgilendiren kısım şu:
izinli_karakterler = "0123456789+-/*= "

for s in veri:
if s not in izinli_karakterler:
print("Neyin peşindesin?!")
quit()

hesap = eval(veri)

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

Kod:

for

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 (

Kod:

quit()

) yol açacaktır.
Eğer kullanıcı izinli karakterleri kullanarak bir işlem gerçekleştirmişse

Kod:

hesap = eval(veri)

kodu aracılığıyla, kullanıcının yaptığı işlemi

Kod:

eval()

fonksiyonuna gönderiyoruz.
Böylece

Kod:

eval()

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:
__import__("os").system("dir")

Çü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

Kod:

range()

adlı bir fonksiyondan bahsedelim.
range Fonksiyonu
range kelimesi İngilizcede ‘aralık’ anlamına gelir. Biz Python’da

Kod:

range()

fonksiyonunu belli bir aralıkta bulunan sayıları göstermek için kullanıyoruz. Örneğin:
>>> for i in range(0, 10):
... print(i)
...
0
1
2
3
4
5
6
7
8
9

Gördüğünüz gibi,

Kod:

range(0, 10)

kodu sayesinde ve

Kod:

for

döngüsünü de kullanarak, 0 ile 10 (10 hariç) aralığındaki sayıları ekrana yazdırdık.
Yukarıdaki kodda

Kod:

range()

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

Kod:

range()

fonksiyonunun formülü şöyledir:
range(ilk_sayı, son_sayı)

Bu arada,

Kod:

range(ilk_sayı, son_sayı)

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

Kod:

range()

fonksiyonunun ilk parametresi 0 olacaksa, bu parametreyi belirtmesek de olur. Yani mesela 0‘dan 10‘a kadar olan sayıları listeleyeceksek

Kod:

range()

fonksiyonunu şöyle yazmamız yeterli olacaktır:
>>> for i in range(10):
... print(i)

Kod:

range()

fonksiyonunun ilk_sayı parametresi verilmediğinde Python ilk parametreyi 0 olarak alır. Yani

Kod:

range(10)

gibi bir kodu Python

Kod:

range(0, 10)

olarak algılar. Elbette, eğer aralıktaki ilk sayı 0‘dan farklı olacaksa bu sayıyı açık açık belirtmek gerekir:
>>> for i in range(3, 20):
... print(i)

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ı

Kod:

range()

fonksiyonunu kullanarak da yazabiliriz:
while True:
parola = input("parola belirleyin: ")

if not parola:
print("parola bölümü boş geçilemez!")

elif len(parola) in range(3, 8): #eğer parolanın uzunluğu 3 ile 8 karakter
#aralığında ise...
print("Yeni parolanız", parola)
break

else:
print("parola 8 karakterden uzun 3 karakterden kısa olmamalı")

Bu fonksiyonu kullanarak bir döngünün kaç kez çalışacağını da belirleyebilirsiniz. Aşağıdaki kodları dikkatlice inceleyin:
for i in range(3):
parola = input("parola belirleyin: ")
if i == 2:
print("parolayı 3 kez yanlış girdiniz.",
"Lütfen 30 dakika sonra tekrar deneyin!")

elif not parola:
print("parola bölümü boş geçilemez!")

elif len(parola) in range(3, 8):
print("Yeni parolanız", parola)
break

else:
print("parola 8 karakterden uzun 3 karakterden kısa olmamalı")

Burada

Kod:

if i == 2

kodu sayesinde

Kod:

for

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

Kod:

print()

fonksiyonu yerleştirerek arka planda Python’ın neler çevirdiğini daha net görebilirsiniz. Örneğin:
for i in range(3):
print(i)
parola = input("parola belirleyin: ")
if i == 2:
print("parolayı 3 kez yanlış girdiniz.",
"Lütfen 30 dakika sonra tekrar deneyin!")

elif not parola:
print("parola bölümü boş geçilemez!")

elif len(parola) in range(3, 8):
print("Yeni parolanız", parola)
break

else:
print("parola 8 karakterden uzun 3 karakterden kısa olmamalı")

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

Kod:

if i == 2

bloğu devreye giriyor.

Kod:

range()

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

Buna göre

Kod:

range()

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:
range(ilk_sayı, son_sayı, atlama_değeri)

Formüldeki son parametre olan atlama_değeri, aralıktaki sayıların kaçar kaçar ilerleyeceğini gösterir. Yani:
>>> for i in range(0, 10, 2):
... print(i)
...

0
2
4
6
8

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ı:

Kod:

range()

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

Python bu kodu

Kod:

range(0, 10)

olarak algılayıp buna göre değerlendiriyor. Ancak eğer

Kod:

range()

fonksiyonunda üçüncü parametreyi de kullanacaksak, yani

Kod:

range(0, 10, 2)

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:
>>> for i in range(10, 2):
... print(i)

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,

Kod:

range()

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:
>>> for i in range(0, 10, 2):
... print(i)

Kısacası, eğer

Kod:

range()

fonksiyonunun kaçar kaçar sayacağını da belirtmek istiyorsak, parantez içinde, gerekli bütün parametreleri belirtmeliyiz.
Gördüğünüz gibi,

Kod:

range()

fonksiyonunu kullanarak belirli bir aralıktaki sayıları alabiliyoruz. Peki bu sayıları tersten alabilir miyiz? Elbette:
>>> for i in range(10, 0, -1):
... print(i)
...
10
9
8
7
6
5
4
3
2
1

Burada

Kod:

range()

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:
>>> for i in range(10, 0, -3):
... print(i)
...
10
7
4
1

KONUNUN DEVAMI İÇİN TIKLAYIN >>