3. Python’da Döngüler (loops)

Şimdiye kadar Python’la bazı ufak programlar yazabilecek düzeye geldik. Mesela öğrendiğimiz bilgiler yardımıyla bir önceki bölümde çok basit bir hesap makinesi yapabilmiş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...

Mesela bununla ilgili şöyle bir örnek daha verelim:

#!/usr/bin/env python3.0

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 (else) “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. Programımız sürekli olarak başa dönse ne iyi olurdu, değil mi? Yani 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...

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

3.1. while Döngüsü (while loop)

İngilizce bir kelime olan “while”, Türkçe’de “... iken, ... olduğu sürece” gibi anlamlara gelir. Python’da 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 dersimizde Python’da while döngüsünün ne olduğunu ve ne işe yaradığını öğrenmeye çalışacağız. Öncelikle while döngüsünün temellerini kavrayarak işe başlayalım.

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

#!/usr/bin/env python3.0

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 “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 “while a == 1” 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 while ifadesinin sonundaki “:” işaretinden anladığımız gibi, bundan sonra gelecek satır girintili yazılacak. Devam edelim:

#!/usr/bin/env python3.0

a = 1

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

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 iki satırı yazarak işe başlıyoruz:

#!/usr/bin/env python3.0

a = 1

İlk satırı geçelim. İkinci satırda, normal bir şekilde “a” değişkenine “1” değerini atadık. Şimdi devam ediyoruz:

#!/usr/bin/env python3.0

a = 1

while a < 10:

while ile verdiğimiz ilk örnekte “while a == 1” gibi bir ifade kullanmıştık. Bu ifade, “a’nın değeri 1 olduğu müddetçe...” gibi bir anlama geliyordu. “while a < 10” 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:

#!/usr/bin/env python3.0

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+D’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’un ekrana o çıktıyı basmasını engelleyecek herhangi bir şey yok... Şimdi bu problemi nasıl aşacağımızı göreceğiz:

#!/usr/bin/env python3.0

a = 1

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

Burada “a = a + 1” diye bir şey ekledik kodlarımızın arasına. Bu satır, a’nın değerine her defasında “1” ekliyor. 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ü while ifadesi içinde belirttiğimiz ölçüte göre, programımızın devam edebilmesi için a’nın 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’un nasıl algıladığına bir bakalım:

• Python öncelikle a = 1 satırını görüyor.
• Daha sonra “a’nın değeri 10’dan küçük olduğu müddetçe...” satırını görüyor.
• Ardından a’nın değerini, 1 artırıyor (a = 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ğerini 9 yapana kadar geliyor.
• 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:

#!/usr/bin/env python3.0

a = 1

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

Burada Python’un arkada ne işler çevirdiğini daha net görebiliyoruz. Kodlarımız içine eklediğimiz 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 while döngüsünü daha önce yazdığımız hesap makinemize uygulayalım:

#!/usr/bin/env python3.0

a = 1

while a < 10:
    a = a + 1

    giriş = """
    (1) topla
    (2) çıkar
    (3) çarp
    (4) böl
    (5) karesini hesapla"""

    print(giriş)

    soru = input("Yapmak istediğiniz işlemin numarasını girin: ")

    if 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ı giriniz: "))
        print(sayı9, "sayısının karesi =", sayı9 ** 2)

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

Burada girintilere özellikle dikkat ediyoruz. while döngüsünün kendisi zaten girintili bir kod yazmayı gerektirdiği için kendisinden sonra gelen bütün kodları da bir seviye sağa kaydırdık. Ayrıca burada yaptığımız şey aslında kullanıcıya 9 kez hesap yapma hakkı vermek oldu... “a” değişkeninin ilk değeri “1” olduğu ve ölçüt olarak belirlediğimiz sayı 10 olduğu için kullanıcı ancak 9 kez art arda hesap yapabilir bu kodlara göre...

Aslında burada bir problem var. Kullanıcıya 9 kez art arda hesap yapma hakkı veriyoruz, ama ona istediği zaman programdan çıkma hakkı tanımıyoruz. Bu kodları çalıştıran bir kullanıcı programdan çıkmak için 9 kez hesap yapmak zorunda kalacaktır! Bunun iyi bir yöntem olmadığı açık. O halde gelin bu soruna bir çare bulalım. Mesela kullanıcı klavyedeki “ç” harfine bastığında programdan çıkabilsin... Aşağıdaki kodları dikkatlice inceleyin:

#!/usr/bin/env python3.0

a = 1

while a == 1:

    giriş = """
    (1) topla
    (2) çıkar
    (3) çarp
    (4) böl
    (5) karesini hesapla

    Programdan çıkmak için "ç" harfine basınız...
    """

    print(giriş)

    soru = input("Yapmak istediğiniz işlemin numarasını girin: ")

    if 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ı giriniz: "))
        print(sayı9, "sayısının karesi =", sayı9 ** 2)

    elif soru == "ç":
        print("Tekrar görüşmek üzere!")
        a = 0

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

Bu kodlar bir öncekine göre çok daha sağlıklı oldu. Bir defa artık kullanıcıya istediği kadar hesap yapma imkanı sunuyoruz. Ayrıca kullanıcımız artık programdan istediği zaman çıkabilecek. Giriş paragrafımıza, programdan nasıl çıkılacağını anlatan bir cümle de ekledik. Buna göre eğer kullanıcı program çalışırken “ç” harfine basarsa programdan çıkılacak... Programımız içinde bunu sağlayan kodumuz şu:

elif soru == "ç":
    print("Tekrar görüşmek üzere!")
    a = 0

Programımızın en başındaki while döngüsünü nasıl kurduğumuza dikkat edin. Şöyle dedik:

a = 1

while a == 1:

Önce a’nın değerini “1” olarak belirledik ve şu emri verdik:

“a değişkeninin değeri “1” olduğu müddetçe aşağıdaki kodları çalıştır...

Dikkat ederseniz burada “a = a + 1” gibi bir şey yazmadık. Çünkü buna gerek kalmadı. “a” değişkeninin değerini her döngüde “1” artırmak yerine, a değişkenin değerini, yeni eklediğimiz elif bloğu içinde değiştirdik. Farkettiyseniz, bu yeni elif bloğu içinde “a = 0” diye bir satır var. İşte bu satır sayesinde, kullanıcı “ç” harfine bastığında “a” değişkeninin değeri de “0” olarak belirleniyor. Bizim en başta belirlediğimiz, programın çalışmaya devam etme şartı “a = 1” olduğu için, Python artık “a” değişkeninin değerinin “1” değil “0” olduğunu görünce programdan çıkıyor... Ayrıca programımızın en sonundaki else bloğunda da ufak bir kozmetik değişiklik yaptık. Daha önce else bloğunu şöyle yazmıştık:

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

Ama artık bu sondaki “giriş” değişkenini kaldırıyoruz. Çünkü artık programımız sürekli olarak en başa döndüğü ve programın en başında da giriş değişkeni ekrana yazdırıldığı için, programın sonunda bir kez daha bu değişkeni ekrana yazdırmamıza gerek yok. İsterseniz programın sonunda “giriş” değişkenini tekrar yazdırarak nasıl bir görüntü elde edildiğini kontrol edebilirsiniz...

Şimdilik while döngüsü ile ilgili olarak söyleyeceklerimiz bu kadar. Bundan sonra da bu döngüyü sık sık kullanıp farklı özelliklerini incelemeye devam edeceğiz. Ama şimdi başka bir döngüden bahsedeceğiz: Python’da for döngüsü.

3.2. for Döngüsü (for loop)

Python’da işleyeceğimiz ikinci döngü, for döngüsüdür. for döngüsü, Python’daki en sık kullanılan öğelerden biridir desek abartmış olmayız. Bu döngünün Python programlama dilinde oldukça geniş bir kullanım alanı vardır. Bu döngünün ne işe yaradığını ve nasıl kullanıldığını öğrendikten sonra, Python’da yapabildiklerimizin epey arttığını göreceksiniz. Ayrıca bu bölümde for döngüsünü işlerken bir yandan da çok önemli bazı başka yeni araçlar da öğreneceğiz. O halde hiç vakit kaybetmeden bu döngünün ne olup ne olmadığına bir bakalım:

İsterseniz for döngüsünü doğrudan tarif etmeye çalışmak yerine, basit bir örnek yardımıyla bu döngüyü kavramaya çalışalım:

isim = "istihza"

for harfler in isim:
    print(harfler)

Bu kodları incelemeye başlamadan önce, isterseniz kodlarımızı çalıştırıp ne iş yaptığına bir bakalım. Bu kodları çalıştırdığımız zaman şöyle bir çıktı elde edeceğiz:

i
s
t
i
h
z
a

Gördüğünüz gibi, yazdığımız kodlar, “isim” değişkeninin değerini alıp her bir harfi alt alta ekrana yazdırdı. Peki bu nasıl oldu? Hemen, yazdığımız kodları incelemeye koyulalım.

Öncelikle, her zaman yaptığımız gibi, bir değişken tanımlıyoruz:

isim = "istihza"

Burada herhangi bir gariplik yok. Devam edelim.

Değişkenimizi tanımladıktan sonra bir for döngüsü kuruyoruz:

for harfler in isim:
    print(harfler)

Burada, Python’a kabaca şöyle bir emir vermiş oluyoruz:

“isim” adlı değişkenin içindeki öğelerin her birini tek tek “harfler” olarak adlandır! Ardından da bu “harfler” değişkenini ekrana bas!

Bu emrimizi duyan Python “istihza” adlı karakter dizisine şöyle bir bakacak, bu karakter dizisi içinde gördüğü bütün harfleri tek tek tarayacak, bu harflerin her birine “harfler” adını verecek ve “harfler” olarak adlandırdığı bu öğeleri tek tek ekrana basacaktır...

Burada neler olup bittiğini daha iyi anlamak için bir örnek daha verelim:

for harfler in "Python Programlama Dili":
    print(harfler)

Biraz önceki örnekte gördüğümüz gibi, yukarıdaki kodları çalıştırdığımızda da “Python Programlama Dili” adlı karakter dizisinin bütün harfleri tek tek ekrana basılacaktır. Ayrıca yine bu örnekte gördüğümüz gibi, karakter dizimizi, önce bir değişkene atamak zorunda kalmadan doğrudan for döngüsü içine de yerleştirebiliyoruz.

Hatırlarsanız, bir önceki bölümde while döngüsünü işlerken şuna benzer bir örnek vermiştik:

a = 0

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

Bu kodları çalıştırdığımız zaman, 1’den 10’a kadar olan sayıların ekrana basıldığını görürüz. Böyle bir şeyi for döngüsünü kullanarak, daha kolay bir şekilde yapabiliriz:

for sayılar in range(10):
    print(sayılar)

Burada elde ettiğimiz çıktı tabii ki while döngüsü ile elde ettiğimiz çıktıdan biraz farklı. while döngüsünde, 1’den 10’a kadar olan sayıları elde etmişken, yukarıdaki for döngüsünde 0’dan 10’a kadar olan sayıları elde ettik (10 hariç). Bu durum yukarıdaki kodlar içinde kullandığımız range() fonksiyonunun çalışma biçiminden kaynaklanıyor. Bu range() fonksiyonunu bir sonraki bölümde ayrıntılı olarak işleyeceğiz. Şimdilik bu fonksiyonun sadece yukarıda nasıl kullanıldığına dikkat etmemiz yeterli olacaktır...

for döngüsüyle şöyle bir örnek de yapabiliriz:

for araya_nokta in "PYTHON":
    print(araya_nokta, end=".")

Burada for döngüsü “PYTHON” karakter dizisinin bütün öğelerini tek tek tarıyor ve “end” parçacığıyla belirttiğimiz “.” işaretini her bir öğenin arasına yerleştiriyor...

Eğer yukarıdaki kodları çalıştırdığınızda komut ekranı yeni satıra geçmiyorsa, yani şöyle bir görüntü elde ediyorsanız:

P.Y.T.H.O.N.istihza@istihza:~/Desktop$

...yukarıdaki kodları şu şekilde yazabilirsiniz:

for araya_nokta in "PYTHON":
    print(araya_nokta, end=".")
print()

En son satıra yazdığımız boş print() fonksiyonu ekrana boş bir satır basarak, alt satıra geçilmesini sağlayacaktır...

Böylece temel olarak Python’daki döngüleri incelemiş olduk. Python’a ilişkin daha çok şey öğrendikçe bu döngüleri daha yetkin bir biçimde kullanabileceğiz. Şimdi isterseniz, biraz önce bahsettiğimiz range() fonksiyonuna bir göz atalım. Bu arada, Python’un 2.x sürümlerini kullanmış olanlar, bir sonraki bölümde işleyeceğimiz range() fonksiyonunun 2.x’e göre bazı farklılıklar içerdiğini göreceklerdir...

3.3. range() Fonksiyonu

Bir önceki bölümde range() fonksiyonuna kısaca değinmiş, konunun ayrıntısını bu bölüme bırakmıştık. İşte şimdi bu range() fonksiyonunun ne işe yaradığını, ne tür özellikleri olduğunu göreceğiz.

“range” kelimesi Türkçe’de “aralık” anlamına gelir. Adından da anlaşılacağı gibi, bu fonksiyon yardımıyla belli bir aralıktaki sayılar üzerinde işlem yapabileceğiz. Bu fonksiyonla birkaç örnek yaparak işe başlayalım. Mesela şu örneğe bakalım (Bu örneği etkileşimli kabukta yazabiliriz):

>>> range(10)

Bu komutu verdiğimizde şöyle bir çıktı alırız:

range(0, 10)

Buradan anladığımıza göre, “range(10)” komutu, içerisinde 0’dan 10’a kadar olan sayıları barındırıyor (10 sayısı hariç). Bu sayıları listelemek için şöyle bir komut vermemiz gerekir:

>>> list(range(10))

Burada, list() adlı yeni bir fonksiyon daha görüyoruz. Bu fonksiyonu bu derste incelemeyeceğiz. list() fonksiyonu daha sonraki bir dersimizin konusu olacak. Biz şimdilik bu fonksiyonun, “listeleme” görevi gördüğünü bilelim. list() fonksiyonunun buradaki görevi, range() fonksiyonu içindeki sayıları listelemektir. Yukarıdaki komutu işlettiğimizde şöyle bir çıktı alacağız:

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

Böylece range() fonksiyonu yardımıyla, 0’dan 10’a kadar olan sayıları listelemiş olduk. Burada 10 sayısının listede yer almadığına dikkat edin. Ayrıca, yukarıdaki komutu etkileşimli kabukta yazdığımız için başa print() komutunu eklemek zorunda kalmadık. Ama eğer bu kodları bir dosya içine yazıp kaydetmiş olsaydık, başa mutlaka print() fonksiyonunu eklememiz gerekecekti:

print(list(range(10)))

Burada, açtığımız bütün parantezleri satır sonunda kapatmayı unutmuyoruz... Eğer bütün parantezleri kapatmazsak programımız hata verecektir...

range() fonksiyonu bazı başka güzellikler de sunar bize. Mesela bu fonksiyonu kullanırken mutlaka 0’dan başlamak gibi bir mecburiyetimiz yoktur. Örneğin şöyle bir şey yazabiliriz:

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

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

Gördüğünüz gibi, yukarıdaki komut yardımıyla 1’den 10’a kadar olan sayıları yazdırabildik. Burada, range() fonksiyonunun saymaya kaçtan başlayacağını nasıl belirlediğimize dikkat edin. Eğer 2’den 10’a kadar olan bütün sayıları listelemek isteseydik şöyle bir şey yazacaktık:

>>> list(range(2, 11))

range() fonksiyonunun yetenekleri bunlarla sınırlı değildir. Bu fonksiyon yardımıyla yazdırdığımız sayılar birer birer artmak zorunda da değildir. Yani illa “1, 2, 3, 4...” şeklinde ilerlemek zorunda değiliz. İstersek “0, 2, 4, 6...” şeklinde de ilerleyebiliriz:

>>> list(range(0, 10, 2))

Burada bir nokta dikkatinizi çekmiş olmalı. Yukarıdaki kodda başlangıç sayısı olan 0’ı da belirttik. Normalde, eğer saymaya sıfırdan başlayacaksak, “0” sayısını ayrıca belirtmemize gerek yoktur. Ama yukarıdaki örnekte, yapmak istediğimiz şeyi gerçekleştirebilmek için parantez içinde üç adet sayı belirtmemiz gerekiyor. Çünkü range() fonksiyonunun formülü şu şekildedir:

range(başlangıç_değeri, bitiş_değeri, atlama_değeri)

Burada “başlangıç_değeri” olarak belirttiğimiz yere, saymaya kaçtan başlayacağımızı yazıyoruz. “bitiş_değeri”ne sayma işleminin hangi sayıya kadar devam edeceğini yazacağız. “atlama_değeri” şeklinde gösterdiğimiz ifadeye ise, range() fonksiyonunun, başlangıç değerinden bitiş değerine kadar olan sayıları sıralarken kaçar kaçar atlaması gerektiğini yazmamız gerekiyor. range() fonksiyonunda “başlangıç_değeri”nin varsayılan bir değeri vardır. Bu değer 0’dır. Yani eğer range() fonksiyonunu kullanarak 100’e kadar sayacaksanız ve “list(range(100))” gibi bir kod yazmışsanız, Python sizin 0’dan başlamak istediğinizi varsayacaktır. “bitiş_değeri”nin varsayılan bir değeri yoktur. Bunu bizim belirlememiz gerekir. “atlama_değeri”nin varsayılan değeri ise “1”dir. Yani eğer herhangi bir atlama değeri belirtmezseniz, Python sizin birer birer saymak istediğinizi varsayacaktır. Dolayısıyla, “list(range(100))” gibi bir kod yazdığımızda Python bunu alttan alta şu şekilde görecektir:

>>> list(range(0, 100, 1))

Eğer 0’dan 100’e kadar olan sayıları ikişer ikişer atlayarak listelemek istiyorsanız ve bu isteğinizi şu şekilde belirtirseniz Python’un kafasının karışmasına yol açarsınız:

>>> list(range(100, 2))

Burada Python sizin ne yapmaya çalıştığınızı anlayamaz. Parantez içinde ilk değer olarak “100”, ikinci değer olarak ise 2 yazdığınız için, Python bu 100 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 100’den 2’ye kadar olan sayıları listelemek istediğinizi zannedecek, 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:

>>> list(range(0, 100, 2))

Kısacası, eğer range() fonksiyonunun kaçar kaçar sayacağını da belirtmek istiyorsak, parantez içine, gerekli bütün sayıları yazmalıyız...

Bu arada, “range(100, 2)” gibi bir ifade yazarak sayıları geriye doğru listeleyemeyecek olmamız, hiç bir şekilde geriye doğru sayamayacağımız anlamına gelmiyor. Elbette “atlama_değeri” parametresine eksi değerli bir sayı vererek range() fonksiyonunun geriye doğru saymasını da sağlayabiliriz:

>>> list(range(100, 2, -1))

Hatta istersek range() fonksiyonunun geriye doğru kaçar kaçar sayacağını da belirtebiliriz:

>>> list(range(100, 2, -2))

...gibi...

Sanırım tekrar hatırlatmaya gerek yok. Yukarıdaki kodları eğer bir dosyaya yazıp çalıştıracaksanız, başlarına print() fonksiyonunu da eklemeniz gerekir. Dolayısıyla yukarıda en son verdiğimiz örnek bir dosya içinde şöyle görünecektir:

print(list(range(0, 100, 2)))

Gördüğünüz gibi, bir sürü parantez işareti oldu kodlarımız içinde. Esasında yukarıda yaptığımız işlemleri yapabilmek için farklı bir yol da izleyebiliriz. range() fonksiyonunu yukarıdaki şekillerde kullanmak yerine, bunu bir for döngüsü içine de alabiliriz:

for i in range(0, 100, 2):
    print(i)

Ayrıca range() fonksiyonunu bir for döngüsü içine aldığımızda, range() fonksiyonunun ürettiği sayılarla bazı yararlı işler de yapabiliriz. Örneğin şuna bir bakın:

for çarp in range(10):
    print(çarp * 2)

Bu kodları çalıştırdığımızda şöyle bir çıktı elde ederiz:

0
2
4
6
8
10
12
14
16
18

Burada Python’un yaptığı şey, 0’dan 10’a kadar olan bütün sayıları tek tek 2 ile çarpmak oldu... Ayrıca range() fonksiyonunu “for” döngüsü içinde kullandığımızda list() fonksiyonunu kullanmamıza gerek kalmadığına da dikkat edin.

for döngüsünü ve range() fonksiyonunu if deyimi ile birlikte kullanarak şöyle bir şey da yapabiliriz:

for çift_sayılar in range(10):
    if çift_sayılar % 2 == 0:
        print(çift_sayılar)

Burada gerçekleşen süreci kabaca şöyle ifade edebiliriz:

0’dan 10’a kadar olan bütün sayıları tek tek tara ve bunların her birini “çift_sayılar” olarak adlandır. Eğer çift_sayılar olarak adlandırdığımız bu sayılar içinde 2’ye tam bölünen sayılar varsa bunları ekrana yazdır...

“%” işlecinin ne işe yaradığını daha önceki derslerimizden hatırlıyorsunuz....