Ş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)
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)
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
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
Artık Python programlama dilinde belli bir noktaya geldik sayılır. Ama eğer farkettiyseniz, yine de elimizi kolumuzu bağlayan, istediğimiz şeyleri yapmamıza engel olan bir şeyler var. İşte bu bölümde, Python programlama dilinde hareket alanımızı bir hayli genişletecek araçları tanıyacağız.
Aslında sadece bu bölümde değil, bu bölümü takip eden her bölümde, hareket alanımızı kısıtlayan duvarları tek tek yıktığımıza şahit olacaksınız. Özellikle bu bölümde inceleyeceğimiz ‘koşullu durumlar’ konusu, tabir yerindeyse, Python’da boyut atlamamızı sağlayacak.
O halde hiç vakit kaybetmeden yola koyulalım...
Şimdiye kadar öğrendiğimiz Python bilgilerini kullanarak şöyle bir program yazabileceğimizi biliyorsunuz:
yaş = 15
print("""Programa hoşgeldiniz!
Programımızı kullanabilmek için en az
13 yaşında olmalısınız.""")
print("Yaşınız: ", yaş)
Burada yaptığımız şey çok basit. Öncelikle, değeri 15 olan, yaş adlı bir değişken tanımladık. Daha sonra, programımızı çalıştıran kullanıcılar için bir hoşgeldin mesajı hazırladık. Son olarak da yaş değişkeninin değerini ekrana yazdırdık.
Bu programın özelliği tek sesli bir uygulama olmasıdır. Yani bu programda kullanıcıyla herhangi bir etkileşim yok. Burada bütün değerleri/değişkenleri programcı olarak kendimiz belirliyoruz. Bu programın ne kadar yavan olduğunu herhalde söylemeye gerek yok.
Ancak yine önceki derslerde öğrendiğimiz
Kod:
input()
fonksiyonu yardımıyla yukarıdaki programın üzerindeki yavanlığı bir nebze de olsa atabilir, bu programı rahatlıkla çok sesli bir hale getirebilir, yani kullanıcıyla etkileşim içine girebiliriz.
Yukarıdaki tek sesli uygulamayı,
Kod:
input()
fonksiyonunu kullanarak çok sesli bir hale nasıl getireceğimizi gayet iyi bildiğinize eminim:
print("""Programa hoşgeldiniz!
Programımızı kullanabilmek için en az
13 yaşında olmalısınız.""")
print("Lütfen yaşınızı girin.\n")
yaş = input("Yaşınız: \t")
print("Yaşınız: ", yaş)
Tıpkı bir önceki uygulamada olduğu gibi, burada da yaptığımız şey çok basit. İlk örnekte yaş değişkeninin değerini kendimiz elle yazmıştık. İkinci örnekte ise bu yaş değişkenini kullanıcıdan alıyoruz ve tıpkı ilk örnekte olduğu gibi, bu değişkenin değerini ekrana yazdırıyoruz.
Bu arada, yukarıdaki uygulamada yer verdiğimiz \n ve \t adlı kaçış dizileri de artık sizin için oldukça tanıdık. \n kaçış dizisi yardımıyla bir alt satıra geçtiğimizi, \t adlı kaçış dizisi yardımıyla da bir sekmelik boşluk bıraktığımızı biliyorsunuz.
Gördüğünüz gibi, şu ana kadar öğrendiklerimizle ancak kullanıcıdan gelen yaş bilgisini ekrana yazdırabiliyoruz. Öğrendiğimiz
Kod:
input()
fonksiyonu bize kullanıcıdan bilgi alma imkanı sağlıyor. Ama kullanıcıdan gelen bu bilgiyi şimdilik ancak olduğu gibi kullanabiliyoruz. Yani mesela yukarıdaki örneği dikkate alarak konuşacak olursak, kullanıcının yaşı eğer 13’ün üzerindeyse onu programa kabul edecek, yok eğer 13 yaşın altındaysa da programdan atacak bir mekanizma üretemiyoruz. Yapabildiğimiz tek şey, kullanıcının girdiği veriyi ekrana yazdırmak.
Yukarıda verdiğimiz örneklerle nereye varmaya çalıştığımızı az çok tahmin etmişsinizdir. Dikkat ederseniz yukarıda sözünü ettiğimiz şey koşullu bir durum. Yani aslında yapmak istediğimiz şey, kullanıcının yaşını denetleyip, onun programa kabul edilmesini 13 yaşından büyük olma koşuluna bağlamak.
İsterseniz tam olarak neden bahsettiğimizi anlayabilmek için, birkaç vaka örneği verelim.
Diyelim ki Google’ın Gmail hizmeti aracılığıyla bir e.posta hesabı aldınız. Bu hesaba gireceğiniz zaman Gmail size bir kullanıcı adı ve parola sorar. Siz de kendinize ait kullanıcı adını ve parolayı sayfadaki kutucuklara yazarsınız. Eğer yazdığınız kullanıcı adı ve parola doğruysa hesabınıza erişebilirsiniz. Ama eğer kullanıcı adınız ve parolanız doğru değilse hesabınıza erişemezsiniz. Yani e.posta hesabınıza erişmeniz, kullanıcı adı ve parolayı doğru girme koşuluna bağlıdır.
Ya da şu vaka örneğini düşünelim: Diyelim ki Pardus’ta komut satırı aracılığıyla güncelleme işlemi yapacaksınız.
Kod:
sudo pisi up
komutunu verdiğiniz zaman güncellemelerin listesi size bildirilecek, bu güncellemeleri yapmak isteyip istemediğiniz sorulacaktır. Eğer evet cevabı verirseniz güncelleme işlemi başlar. Ama eğer hayır cevabı verirseniz güncelleme işlemi başlamaz. Yani güncelleme işleminin başlaması kullanıcının evet cevabı vermesi koşuluna bağlıdır.
İşte bu bölümde biz bu tür koşullu durumlardan söz edeceğiz.
Koşul Deyimleri
Hiç kuşkusuz, koşula bağlı durumlar Python’daki en önemli konulardan biridir. Giriş bölümünde bahsettiğimiz koşullu işlemleri yapabilmek için ‘koşul deyimleri’ adı verilen birtakım araçlardan yararlanacağız. Gelin şimdi bu araçların neler olduğunu görelim.
if
Python programlama dilinde koşullu durumları belirtmek için üç adet deyimden yararlanıyoruz:
ifelifelse
İsterseniz önce
Kod:
if
deyimi ile başlayalım...
Eğer daha önceden herhangi bir programlama dilini az da olsa kurcalama fırsatınız olduysa, bir programlama dilinde
Kod:
if
deyimlerinin ne işe yaradığını az çok biliyorsunuzdur. Daha önceden hiç programcılık deneyiminiz olmamışsa da ziyanı yok. Zira bu bölümde
Kod:
if
deyimlerinin ne işe yaradığını ve nerelerde kullanıldığını enine boyuna tartışacağız.
İngilizce bir kelime olan ‘if‘, Türkçede ‘eğer’ anlamına gelir. Anlamından da çıkarabileceğimiz gibi, bu kelime bir koşul bildiriyor. Yani ‘eğer bir şey falanca ise...‘ ya da ‘eğer bir şey filanca ise...‘ gibi... İşte biz Python’da bir koşula bağlamak istediğimiz durumları
Kod:
if
deyimi aracılığıyla göstereceğiz.
Gelin isterseniz bu deyimi nasıl kullanacağımıza dair ufacık bir örnek vererek işe başlayalım:
Öncelikle elimizde şöyle bir değişken olsun:
n = 255
Yukarıda verdiğimiz değişkenin değerinin bir karakter dizisi değil, aksine bir sayı olduğunu görüyoruz. Şimdi bu değişkenin değerini sorgulayalım:
if n > 10:
Burada sayının 10’dan büyük olup olmadığına bakıyoruz.
Burada gördüğümüz > işaretinin ne demek olduğunu açıklamaya gerek yok sanırım. Hepimizin bildiği ‘büyüktür’ işareti Python’da da aynen bildiğimiz şekilde kullanılıyor. Mesela ‘küçüktür’ demek isteseydik, < işaretini kullanacaktık. İsterseniz hemen şurada araya girip bu işaretleri yeniden hatırlayalım:
Alıntı: İşleç
Anlamı>
büyüktür
<
küçüktür
>=
büyük eşittir
<=
küçük eşittir
==
eşittir
!=
eşit değildir
Gördüğünüz gibi hiçbiri bize yabancı gelecek gibi değil. Yalnızca en sondaki ‘eşittir’ (==) ve ‘eşit değildir’ (!=) işaretleri biraz değişik gelmiş olabilir. Burada ‘eşittir’ işaretinin = olmadığına dikkat edin. Python’da = işaretini değer atama işlemleri için kullanıyoruz. == işaretini ise iki adet değerin birbirine eşit olup olmadığını denetlemek için... Mesela:
>>> a = 26
Burada değeri 26 olan a adlı bir değişken belirledik. Yani a değişkenine değer olarak 26 sayısını atadık. Ayrıca burada, değer atama işleminin ardından Enter tuşuna bastıktan sonra Python hiçbir şey yapmadan bir alt satıra geçti. Bir de şuna bakalım:
>>> a == 26
True
Burada ise yaptığımız şey a değişkeninin değerinin 26 olup olmadığını sorgulamak
Kod:
a == 26
komutunu verdikten sonra Python bize True diye bir çıktı verdi. Bu çıktının anlamını biraz sonra öğreneceğiz. Ama şimdi isterseniz konuyu daha fazla dağıtmayalım. Biz şimdilik sadece = ve == işaretlerinin birbirinden tamamen farklı anlamlara geldiğini bilelim yeter.
Ne diyorduk?
if n > 10:
Bu ifadeyle Python’a şöyle bir şey demiş oluyoruz:
Alıntı:Eğer n sayısının değeri 10’dan büyükse...
Burada kullandığımız işaretlere dikkat edin. En sonda bir adet : işaretinin olduğunu gözden kaçırmıyoruz. Bu tür işaretler Python için çok önemlidir. Bunları yazmayı unutursak Python gözümüzün yaşına bakmayacaktır.
Dedik ki,
Kod:
if n > 10:
ifadesi, ‘eğer n değişkeninin değeri 10’dan büyükse...’ anlamına gelir. Bu ifadenin eksik olduğu apaçık ortada. Yani belli ki bu cümlenin bir de devamı olması gerekiyor. O halde biz de devamını getirelim:
if n > 10:
print("sayı 10'dan büyüktür!")
Burada çok önemli bir durumla karşı karşıyayız. Dikkat ederseniz, ikinci satırı ilk satıra göre girintili yazdık. Elbette bunu şirinlik olsun diye yapmadık. Python programlama dilinde girintiler çok büyük önem taşır. Hatta ne kadarlık bir girinti verdiğiniz bile önemlidir. Eğer Python kodlarına duyarlı bir metin düzenleyici kullanıyorsanız, kullandığınız metin düzenleyici çoğu durumda sizin yerinize uygun bir şekilde girintilemeyi yapacaktır. Mesela IDLE adlı geliştirme ortamını kullananlar, ilk satırdaki : işaretini koyup Enter tuşuna bastıklarında otomatik olarak girinti verildiğini farkedeceklerdir. Eğer kullandığınız metin düzenleyici, satırları otomatik olarak girintilemiyorsa sizin bu girintileme işlemini elle yapmanız gerekecektir. Yalnız elle girintilerken, ne kadar girinti vereceğimize dikkat etmeliyiz. Genel kural olarak 4 boşlukluk bir girintileme uygun olacaktır. Girintileme işlemini klavyedeki sekme (Tab) tuşuna basarak da yapabilirsiniz. Ama aynı program içinde sekmelerle boşlukları karıştırmayın. Yani eğer girintileme işlemini klavyedeki boşluk (Space) tuşuna basarak yapıyorsanız, program boyunca aynı şekilde yapın. (Ben size girinti verirken Tab tuşu yerine Space tuşunu kullanmanızı tavsiye ederim). Kısaca söylemek gerekirse; Python’da girintileme ve girintilemede tutarlılık çok önemlidir. Özellikle büyük programlarda, girintilemeler açısından tutarsızlık gösterilmesi programın çalışmamasına sebep olabilir.
Python’da girintileme konusuyla ilgili daha ayrıntılı bilgi için: http://www.istihza.com/blog/python-ve-me...iler.html/
Eğer yukarıdaki
Kod:
if
bloğunu bir metin düzenleyici içine değil de doğrudan etkileşimli kabuğa yazmışsanız bazı şeyler dikkatinizi çekmiş olmalı. Etkileşimli kabukta
Kod:
if sayı > 10:
satırını yazıp Enter tuşuna bastığınızda şöyle bir görüntüyle karşılaşmış olmalısınız:
>>> if n > 10:
...
Dikkat ederseniz, >>> işareti, ... işaretine dönüştü. Eğer bu noktada herhangi bir şey yazmadan Enter tuşuna basacak olursanız Python size şöyle bir hata mesajı verecektir:
File "<stdin>", line 2
^
IndentationError: expected an indented block
Hata mesajında da söylendiği gibi, Python bizden girintilenmiş bir blok beklerken, biz onun bu beklentisini karşılamamışız. Dolayısıyla bize yukarıdaki hata mesajını göstermiş. ... işaretini gördükten sonra yapmamız gereken şey, dört kez boşluk (Space) tuşuna basarak girinti oluşturmak ve
Kod:
if
bloğunun devamını yazmak olmalıydı. Yani şöyle:
>>> if n > 10:
... print("sayı 10'dan büyüktür!")
...
Gördüğünüz gibi,
Kod:
print()
fonksiyonunu yazıp Enter tuşuna bastıktan sonra yine ... işaretini gördük. Python burada bizden yeni bir satır daha bekliyor. Ama bizim yazacak başka bir kodumuz olmadığı için tekrar Enter tuşuna basıyoruz ve nihai olarak şöyle bir görüntü elde ediyoruz:
>>> if n > 10:
... print("sayı 10'dan büyüktür!")
...
sayı 10'dan büyüktür!
>>>
Demek ki 250 sayısı 10‘dan büyükmüş! Ne büyük bir buluş! Merak etmeyin, daha çok şey öğrendikçe daha mantıklı programlar yazacağız. Burada amacımız işin temelini kavramak. Bunu da en iyi, (çok mantıklı olmasa bile) basit programlar yazarak yapabiliriz.
Şimdi metin düzenleyicimizi açarak daha mantıklı şeyler yazmaya çalışalım. Zira yukarıdaki örnekte değişkeni kendimiz belirlediğimiz için, bu değişkenin değerini
Kod:
if
deyimleri yardımıyla denetlemek pek akla yatkın görünmüyor. Ne de olsa değişkenin değerinin ne olduğunu biliyoruz. Dolayısıyla bu değişkenin 10 sayısından büyük olduğunu da biliyoruz! Bunu
Kod:
if
deyimiyle kontrol etmek çok gerekli değil. Ama şimdi daha makul bir iş yapacağız. Değişkeni biz belirlemek yerine kullanıcıya belirleteceğiz:
sayı = int(input("Bir sayı giriniz: "))
if sayı > 10:
print("Girdiğiniz sayı 10'dan büyüktür!")
if sayı < 10:
print("Girdiğiniz sayı 10'dan küçüktür!")
if sayı == 10:
print("Girdiğiniz sayı 10'dur!")
Gördüğünüz gibi, art arda üç adet
Kod:
if
bloğu kullandık. Bu kodlara göre, eğer kullanıcının girdiği sayı 10‘dan büyükse, ilk
Kod:
if
bloğu işletilecek; eğer sayı 10‘dan küçükse ikinci
Kod:
if
bloğu işletilecek; eğer sayı 10’a eşit ise üçüncü
Kod:
if
bloğu işletilecektir. Peki ya kullanıcı muziplik yapıp sayı yerine harf yazarsa ne olacak? Böyle bir ihtimal için programımıza herhangi bir denetleyici yerleştirmedik. Dolayısıyla eğer kullanıcı sayı yerine harf girerse programımız hata verecek, yani çökecektir. Bu tür durumlara karşı nasıl önlem alacağımızı ilerleyen derslerimizde göreceğiz. Biz şimdilik bildiğimiz yolda yürüyelim.
Yukarıdaki örnekte
Kod:
input()
ile gelen karakter dizisini,
Kod:
int()
fonksiyonu yardımıyla bir sayıya dönüştürdüğümüze dikkat edin. Kullanıcıdan gelen veriyi büyüklük-küçüklük ölçütüne göre inceleyeceğimiz için, gelen veriyi bir sayıya dönüştürmemiz gerekiyor. Bunu da
Kod:
int()
fonksiyonu ile yapabileceğimizi biliyorsunuz.
Elbette yukarıdaki dönüştürme işlemini şöyle de yapabilirdik:
sayı = input("Bir sayı giriniz: ")
sayı = int(sayı)
Burada önce
Kod:
input()
fonksiyonuyla veriyi aldık, daha sonra bu veriyi ayrı bir yerde sayıya dönüştürüp tekrar sayı adlı değişkene atadık.
Kod:
if
deyimlerini kullanıcı adı veya parola denetlerken de kullanabiliriz. Mesela şöyle bir program taslağı yazabiliriz:
print("""
Dünyanın en gelişmiş e.posta hizmetine
hoşgeldiniz. Yalnız hizmetimizden
yararlanmak için önce sisteme giriş
yapmalısınız.
""")
parola = input("Parola: ")
if parola == "12345678":
print("Sisteme Hoşgeldiniz!")
Gördüğünüz gibi, programın başında üç tırnak işaretlerinden yararlanarak uzun bir metni kullanıcıya gösterdik. Bu bölümü, kendiniz göze hoş gelecek bir şekilde süsleyebilirsiniz de. Eğer kullanıcı, kendisine parola sorulduğunda cevap olarak “12345678” yazarsa kullanıcıyı sisteme alıyoruz.
Yukarıdaki örnekte, kullanıcının girdiği parola “12345678” ise kendisine “Sisteme Hoşgeldiniz!” mesajını gösteriyoruz. Mantık olarak bunun tersini yapmak da mümkündür. Yani:
if parola != "12345678":
print("Ne yazık ki yanlış parola girdiniz!")
Burada ise bir önceki örneğin mantığını ters çevirdik. Önceki örnekte parola değişkeni “12345678” adlı karakter dizisine eşitse (
Kod:
if parola == "12345678"
) bir işlem yapıyorduk. Yukarıdaki örnekte ise parola değişkeni “12345678” adlı karakter dizisine eşit değilse (
Kod:
if parola != "12345678"
) bir işlem yapıyoruz.
Bu iki örneğin de aslında aynı kapıya çıktığını görüyorsunuz. Tek değişiklik, kullanıcıya gösterilen mesajlardadır.
Böylece Python’daki koşullu durumlar üzerindeki incelememizin ilk ve en önemli aşamasını geride bırakmış olduk. Dikkat ettiyseniz
Kod:
if
deyimi sayesinde programlarımıza karar vermeyi öğrettik. Bu deyim yardımıyla, kullanıcıdan aldığımız herhangi bir verinin niteliği üzerinde kapsamlı bir karar verme işlemi yürütebiliyoruz. Yani artık programlarımız kullanıcıdan alınan veriyi olduğu gibi kabul etmekle yetinmiyor. Kullanıcının girdiği verinin ne olduğuna bağlı olarak programlarımızın farklı işlemler yapmasını da sağlayabiliyoruz.
Daha önce de söylediğimiz gibi,
Kod:
if
deyimi dışında Python’da koşullu durumları ifade etmek için kullandığımız,
Kod:
elif
ve
Kod:
else
adlı iki deyim daha vardır. Bunlar
Kod:
if
ile birlikte kullanılırlar. Gelin isterseniz bu iki deyimden, adı
Kod:
elif
olana bakalım.
elif
Python’da,
Kod:
if
deyimleriyle birlikte kullanılan ve yine koşul belirten bir başka deyim de
Kod:
elif
deyimidir. Buna şöyle bir örnek verebiliriz:
yaş = int(input("Yaşınız: "))
if yaş == 18:
print("18 iyidir!")
elif yaş < 0:
print("Yok canım, daha neler!...")
elif yaş < 18:
print("Genç bir kardeşimizsin!")
elif yaş > 18:
print("Eh, artık yaş yavaş yavaş kemale eriyor!")
Yukarıdaki örneği şöyle yazmayı da deneyebilirsiniz:
yaş = int(input("Yaşınız: "))
if yaş == 18:
print("18 iyidir!")
if yaş < 0:
print("Yok canım, daha neler!...")
if yaş < 18:
print("Genç bir kardeşimizsin!")
if yaş > 18:
print("Eh, artık yaş yavaş yavaş kemale eriyor!")
Bu iki programın da aynı işlevi gördüğünü düşünebilirsiniz. Ancak ilk bakışta pek belli olmasa da, aslında yukarıdaki iki program birbirinden farklı davranacaktır. Örneğin ikinci programda eğer kullanıcı eksi değerli bir sayı girerse hem
Kod:
if yaş < 0
bloğu, hem de
Kod:
if yaş < 18
bloğu çalışacaktır. İsterseniz yukarıdaki programı çalıştırıp, cevap olarak eksi değerli bir sayı verin. Ne demek istediğimiz gayet net anlaşılacaktır.
Bu durum
Kod:
if
ile
Kod:
elif
arasındaki çok önemli bir farktan kaynaklanır. Buna göre
Kod:
if
bize olası bütün sonuçları listeler,
Kod:
elif
ise sadece doğru olan ilk sonucu verir. Bu soyut tanımlamayı biraz daha somutlaştıralım:
a = int(input("Bir sayı giriniz: "))
if a < 100:
print("verdiğiniz sayı 100'den küçüktür.")
if a < 50:
print("verdiğiniz sayı 50'den küçüktür.")
if a == 100:
print("verdiğiniz sayı 100'dür.")
if a > 100:
print("verdiğiniz sayı 100'den büyüktür.")
if a > 150:
print("verdiğiniz sayı 150'den büyüktür.")
Yukarıdaki kodları çalıştırdığımızda, doğru olan bütün sonuçlar listelenecektir. Yani mesela kullanıcı 40 sayısını girmişse, ekrana verilecek çıktı şöyle olacaktır:
verdiğiniz sayı 100'den küçüktür.
verdiğiniz sayı 50'den küçüktür.
Burada 40 sayısı hem 100‘den, hem de 50‘den küçük olduğu için iki sonuç da çıktı olarak verilecektir. Ama eğer yukarıdaki kodları şöyle yazarsak:
a = int(input("Bir sayı giriniz: "))
if a < 100:
print("verdiğiniz sayı 100'den küçüktür.")
elif a < 50:
print("verdiğiniz sayı 50'den küçüktür.")
elif a == 100:
print("verdiğiniz sayı 100'dür.")
elif a > 150:
print("verdiğiniz sayı 150'den büyüktür.")
elif a > 100:
print("verdiğiniz sayı 100'den büyüktür.")
Kullanıcının 40 sayısını girdiğini varsaydığımızda, bu defa programımımız yalnızca şu çıktıyı verecektir:
verdiğiniz sayı 100'den küçüktür.
Gördüğünüz gibi,
Kod:
elif
deyimlerini kullandığımız zaman, ekrana yalnızca doğru olan ilk sonuç veriliyor. Yukarıda 40 sayısı hem 100‘den hem de 50‘den küçük olduğu halde, Python bu sayının 100‘den küçük olduğunu görür görmez sonucu ekrana basıp, öteki koşul bloklarını incelemeyi bırakıyor.
Kod:
if
deyimlerini arka arkaya sıraladığımızda ise, Python bütün olasılıkları tek tek değerlendirip, geçerli olan bütün sonuçları ekrana döküyor.
Bir sonraki bölümde
Kod:
else
deyimini öğrendiğimiz zaman,
Kod:
elif
‘in tam olarak ne işe yaradığını çok daha iyi anlamanızı sağlayacak bir örnek vereceğiz.
Şimdiye kadar verdiğimiz örneklerden de rahatlıkla anlayabileceğiniz gibi, ilk koşul bloğunda asla
Kod:
elif
deyimi kullanılamaz. Bu deyimin kullanılabilmesi için kendisinden önce en az bir adet
Kod:
if
bloğu olmalıdır. Yani Python’da koşullu durumları ifade ederken ilk koşul bloğumuz her zaman
Kod:
if
deyimi ile başlamalıdır.
Kod:
elif
‘i de incelediğimize göre, koşul bildiren deyimlerin sonuncusuna göz atabiliriz:
Kod:
else
else
Şimdiye kadar Python’da koşul bildiren iki deyimi öğrendik. Bunlar
Kod:
if
ve
Kod:
elif
idi. Bu bölümde ise koşul deyimlerinin sonuncusu olan
Kod:
else
deyimini göreceğiz. Öğrendiğimiz şeyleri şöyle bir gözden geçirecek olursak, temel olarak şöyle bir durumla karşı karşıya olduğumuzu görürüz:
if falanca:
bu işlemi yap
if filanca:
şu işlemi yap
Veya şöyle bir durum:
if falanca:
bu işlemi yap
elif filanca:
şu işlemi yap
Kod:
if
ile
Kod:
elif
arasındaki farkı biliyoruz. Eğer
Kod:
if
deyimlerini art arda sıralayacak olursak, Python doğru olan bütün sonuçları listeleyecektir. Ama eğer
Kod:
if
deyiminden sonra
Kod:
elif
deyimini kullanırsak, Python doğru olan ilk sonucu listelemekle yetinecektir.
Bu bölümde göreceğimiz
Kod:
else
deyimi, yukarıdaki tabloya bambaşka bir boyut kazandırıyor. Dikkat ederseniz şimdiye kadar öğrendiğimiz deyimleri kullanabilmek için ilgili bütün durumları tanımlamamız gerekiyordu. Yani:
eğer böyle bir durum varsa:
bunu yap
eğer şöyle bir durum varsa:
şunu yap
eğer filancaysa:
şöyle git
eğer falancaysa:
böyle gel
gibi...
Ancak her durum için bir
Kod:
if
bloğu yazmak bir süre sonra yorucu ve sıkıcı olacaktır. İşte bu noktada devreye
Gelin isterseniz bununla ilgili şöyle bir örnek verelim:
soru = input("Bir meyve adı söyleyin bana:")
if soru == "elma":
print("evet, elma bir meyvedir...")
elif soru == "karpuz":
print("evet, karpuz bir meyvedir...")
elif soru == "armut":
print("evet, armut bir meyvedir...")
else:
print(soru, "gerçekten bir meyve midir?")
Eğer kullanıcı soruya ‘elma’, ‘karpuz’ veya ‘armut’ cevabı verirse, evet, ... bir meyvedir çıktısı verilecektir. Ama eğer kullanıcı bu üçü dışında bir cevap verirse, ... gerçekten bir meyve midir? çıktısını görürüz. Burada
Kod:
else
deyimi, programımıza şu anlamı katıyor:
Alıntı:Eğer kullanıcı yukarıda belirlenen meyve adlarından hiç birini girmez, bunların yerine bambaşka bir şey yazarsa, o zaman
Kod:
else
bloğu içinde belirtilen işlemi gerçekleştir.
Dikkat ederseniz yukarıdaki kodlarda
Kod:
if
deyimlerini art arda sıralamak yerine ilk
Kod:
if
‘ten sonra
Kod:
elif
ile devam ettik. Peki şöyle bir şey yazarsak ne olur?
soru = input("Bir meyve adı söyleyin bana:")
if soru == "elma":
print("evet, elma bir meyvedir...")
if soru == "karpuz":
print("evet, karpuz bir meyvedir...")
if soru == "armut":
print("evet, armut bir meyvedir...")
else:
print(soru, "gerçekten bir meyve midir?")
Bu kodlar beklediğiniz sonucu vermeyecektir. İsterseniz yukarıdaki kodları çalıştırıp ne demek istediğimizi daha iyi anlayabilirsiniz. Eğer yukarıda olduğu gibi
Kod:
if
deyimlerini art arda sıralar ve son olarak da bir
Kod:
else
bloğu tanımlarsak, ekrana ilk bakışta anlamsız gibi görünen bir çıktı verilecektir:
evet, elma bir meyvedir...
elma gerçekten bir meyve midir?
Burada olan şey şu:
Soruya ‘elma’ cevabını verdiğimizi düşünelim. Bu durumda, Python ilk olarak ilk
Kod:
if
bloğunu değerlendirecek ve soruya verdiğimiz cevap ‘elma’ olduğu için evet, elma bir meyvedir... çıktısını verecektir.
Kod:
if
ile
Kod:
elif
arasındaki farkı anlatırken, hatırlarsanız art arda gelen
Kod:
if
bloklarında Python’ın olası bütün sonuçları değerlendireceğini söylemiştik. İşte burada da böyle bir durum söz konusu. Gördüğünüz gibi, ilk
Kod:
if
bloğundan sonra yine bir
Kod:
if
bloğu geliyor. Bu nedenle Python olası bütün sonuçları değerlendirebilmek için blokları okumaya devam edecek ve sorunun cevabı ‘karpuz’ olmadığı için ikinci
Kod:
if
bloğunu atlayacaktır.
Sonraki blok yine bir
Kod:
if
bloğu olduğu için Python kodları okumaya devam ediyor. Ancak sorunun cevabı ‘armut’ da olmadığı için, Python sonraki
Kod:
if
bloğunu da geçiyor ve böylece
Kod:
else
bloğuna ulaşıyor.
Yukarıda verdiğimiz örnekteki gibi art arda
Kod:
if
deyimlerinin sıralanıp en sona
Kod:
else
deyiminin yerleştirildiği durumlarda
Kod:
else
deyimi sadece bir önceki
Kod:
if
deyimini dikkate alarak işlem yapar. Yani yukarıdaki örnekte kullanıcının verdiği cevap ‘armut’ olmadığı için
Kod:
else
deyiminin olduğu blok çalışmaya başlar. Yukarıdaki örneğe ‘armut’ cevabını verirseniz ne demek istediğimi biraz daha iyi anlayabilirsiniz. ‘armut’ cevabı verilmesi durumunda sadece
Kod:
if soru == "armut"
ifadesinin olduğu blok çalışır,
Kod:
else
bloğu ise çalışmaz. Çünkü dediğim gibi, eğer
Kod:
else
bloğundan önce art arda gelen
Kod:
if
blokları varsa,
Kod:
else
deyimi yalnızca kendisinden önceki son
Kod:
if
bloğunu dikkate alır ve sanki yukarıdaki örnek şöyleymiş gibi davranır:
if soru == "armut":
print("evet, armut bir meyvedir...")
else:
print(soru, "gerçekten bir meyve midir?")
Bu tür durumlarda
Kod:
else
deyimi bir önceki
Kod:
if
bloğundan önce gelen bütün
Kod:
if
bloklarını görmezden gelir ve böylece şu anlamsız görünen çıktı elde edilir:
evet, elma bir meyvedir...
elma gerçekten bir meyve midir?
Sözün özü, kullanıcının cevabı ‘elma’ olduğu için, yukarıdaki çıktıda yer alan ilk cümle ilk
Kod:
if
bloğunun çalışması sonucu ekrana basılıyor. İkinci cümle ise
Kod:
else
bloğundan bir önceki
Kod:
if
bloğu kullanıcının cevabıyla uyuşmadığı için ekrana basılıyor.
Yalnız bu dediğimizden,
Kod:
else
ifadesi
Kod:
if
ile birlikte kullanılmaz, anlamı çıkarılmamalı. Mesela şöyle bir örnek yapılabilir:
soru = input("Programdan çıkmak istediğinize emin misiniz? \
Eminseniz 'e' harfine basın : ")
if soru == "e":
print("Güle güle!")
else:
print("Peki, biraz daha sohbet edelim!")
Burada eğer kullanıcının cevabı ‘e’ ise
Kod:
if
bloğu işletilecek, eğer cevap ‘e’ dışında herhangi bir şey ise
Kod:
else
bloğu çalışacaktır. Gayet mantıklı bir süreç. Ama eğer yukarıdaki örneğe bir
Kod:
if
bloğu daha eklerseniz işler beklediğiniz gibi gitmez:
soru = input("Programdan çıkmak istediğinize emin misiniz? \
Eminseniz 'e' harfine basın : ")
if soru == "e":
print("Güle güle!")
if soru == "b":
print("Kararsız kaldım şimdi!")
else:
print("Peki, biraz daha sohbet edelim!")
Bu soruya ‘e’ cevabı verdiğimizi düşünelim. Bu cevap ilk
Kod:
if
bloğuyla uyuşuyor ve böylece ekrana Güle güle! çıktısı veriliyor. İlk
Kod:
if
bloğundan sonra tekrar bir
Kod:
if
bloğu daha geldiği için Python bütün olasılıkları değerlendirmek amacıyla blokları okumaya devam ediyor ve cevap ‘b’ olmadığı için ikinci
Kod:
if
bloğunu atlıyor ve böylece
Kod:
else
bloğuna ulaşıyor. Bir önceki örnekte de söylediğimiz gibi,
Kod:
else
bloğu art arda gelen
Kod:
if
blokları gördüğünde sadece bir önceki
Kod:
if
bloğunu dikkate aldığı ve kullanıcının cevabı da ‘b’ olmadığı için ekrana Peki, biraz daha sohbet edelim! çıktısını veriyor ve ilk bakışta tuhaf görünen şöyle bir çıktı üretiyor:
Güle güle!
Peki, biraz daha sohbet edelim!
Dolayısıyla, eğer programınızda bir
Kod:
else
bloğuna yer verecekseniz, ondan önce gelen koşullu durumların ilkini
Kod:
if
ile sonrakileri ise
Kod:
elif
ile bağlayın. Yani:
if koşul_1:
sonuç_1
elif koşul_2:
sonuç_2
elif koşul_3:
sonuç_3
else:
sonuç_4
Ama eğer
Kod:
else
bloğundan önce sadece tek bir koşul bloğu yer alacaksa bunu
Kod:
if
ile bağlayın. Yani:
if koşul_1:
sonuç_1
else:
sonuç_2
Programlarımızın doğru çalışması ve istediğimiz sonucu verebilmesi için bu tür ayrıntılara olabildiğince dikkat etmemiz gerekiyor. Neticede koşullu durumlar mantıkla ilgilidir. Dolayısıyla koşullu durumlarla muhatap olurken mantığınızı hiçbir zaman devre dışı bırakmamalısınız.
Bir önceki bölümde
Kod:
elif
deyiminin tam olarak ne işe yaradığını anlamamızı sağlayacak bir örnek vereceğimizi söylemiştik. Şimdi bu örneğe bakalım:
boy = int(input("boyunuz kaç cm?"))
if boy < 170:
print("boyunuz kısa")
elif boy < 180:
print("boyunuz normal")
else:
print("boyunuz uzun")
Yukarıda yedi satırla hallettiğimiz işi sadece
Kod:
if
deyimleriyle yapmaya çalışırsanız bunun ne kadar zor olduğunu göreceksiniz. Diyelim ki kullanıcı ‘165’ cevabını verdi. Python bu 165 sayısının 170‘ten küçük olduğunu görünce boyunuz kısa cevabını verecek, öteki satırları değerlendirmeyecektir. 165 sayısı,
Kod:
elif
ile gösterdiğimiz koşullu duruma da uygun olduğu halde (
Kod:
165 < 180
), koşul ilk blokta karşılandığı için ikinci blok değerlendirmeye alınmayacaktır.
Kullanıcının ‘175’ cevabını verdiğini varsayalım: Python 175 sayısını görünce önce ilk koşula bakacak, verilen 175 sayısının ilk koşulu karşılamadığını görecektir (
Kod:
175 > 170
). Bunun üzerine Python kodları incelemeye devam edecek ve
Kod:
elif
bloğunu değerlendirmeye alacaktır. 175 sayısının 180‘den küçük olduğunu görünce de çıktı olarak boyunuz normal cevabını verecektir.
Peki ya kullanıcı ‘190’ cevabını verirse ne olacak? Python yine önce ilk
Kod:
if
bloğuna bakacak ve 190 cevabının bu bloğa uymadığını görecektir. Dolayısıyla ilk bloğu bırakıp ikinci bloğa bakacaktır. 190 cevabının bu bloğa da uymadığını görünce, bir sonraki bloğu değerlendirmeye alacaktır. Bir sonraki blokta ise
Kod:
else
deyimimiz var. Bu bölümde öğrendiğimiz gibi,
Kod:
else
deyimi, ‘eğer kullanıcının cevabı yukarıdaki koşulların hiçbirine uymazsa bu bloğu çalıştır,’ anlamına geliyor. Kullanıcının girdiği 190 cevabı ne birinci ne de ikinci bloktaki koşula uyduğu için, normal bir şekilde
Kod:
else
bloğu işletilecek, dolayısıyla da ekrana boyunuz uzun çıktısı verilecektir.
Böylece Python’da
Kod:
if
,
Kod:
elif
ve
Kod:
else
deyimlerini incelemiş olduk. Ancak tabii ki bu deyimlerle işimiz henüz bitmedi. Elimizdeki bilgiler şimdilik bu deyimleri ancak bu kadar incelememize yetiyor, ama ilerleyen sayfalarda bazı başka araçları da bilgi dağarcığımıza kattıktan sonra bu deyimlerin daha farklı yönlerini öğrenme imkanına kavuşacağız.
Örnek Uygulama
Önceki derslerimizde
Kod:
len()
fonksiyonunu anlatırken şöyle bir program tasarısından bahsetmiştik hatırlarsanız:
Alıntı:Diyelim ki sisteme kayıt için kullanıcı adı ve parola belirlenmesini isteyen bir program yazıyorsunuz. Yazacağınız bu programda, belirlenebilecek kullanıcı adı ve parolanın toplam uzunluğu 40 karakteri geçmeyecek.
O zaman henüz koşullu durumları öğrenmemiş olduğumuz için, yukarıda bahsettiğimiz programın ancak şu kadarlık kısmını yazabilmiştik:
kullanıcı_adı = input("Kullanıcı adınız: ")
parola = input("Parolanız : ")
toplam_uzunluk = len(kullanıcı_adı) + len(parola)
Burada yapabildiğimiz tek şey, kullanıcıdan kullanıcı adı ve parola bilgilerini alıp, bu bilgilerin karakter uzunluğunu ölçebilmekti. Ama artık koşullu durumları öğrendiğimize göre bu programı eksiksiz olarak yazabiliriz. Şu kodları dikkatlice inceleyin:
kullanıcı_adı = input("Kullanıcı adınız: ")
parola = input("Parolanız : ")
toplam_uzunluk = len(kullanıcı_adı) + len(parola)
mesaj = "Kullanıcı adı ve parolanız toplam {} karakterden oluşuyor!"
print(mesaj.format(toplam_uzunluk))
if toplam_uzunluk > 40:
print("Kullanıcı adınız ile parolanızın ",
"toplam uzunluğu 40 karakteri geçmemeli!")
else:
print("Sisteme hoşgeldiniz!")
Burada öncelikle kullanıcıdan kullanıcı adı ve parola bilgilerini alıyoruz. Daha sonra da kullanıcıdan gelen bu bilgilerin toplam karakter uzunluğunu hesaplıyoruz. Bunun için
Kod:
len()
fonksiyonundan yararlanmamız gerektiğini hatırlıyor olmalısınız.
Eğer toplam uzunluk 40 karakterden fazla ise,
Kod:
if
bloğunda verilen mesajı gösteriyoruz. Bunun dışındaki bütün durumlarda ise
Şimdiye kadar Python programlama dili ile ilgili epey bilgi edindik. Ama muhtemelen buraya kadar öğrendiklerimiz sizi heyecanlandırmaktan bir hayli uzaktı. Zira şu ana kadar hep tek yönlü bir programlama faaliyeti yürüttük.
Mesela şimdiye kadar öğrendiklerimizi kullanarak ancak şöyle bir program yazabildik:
isim = "Mübeccel"
print("Merhaba", isim, end="!\n")
Bu programı çalıştırdığımızda şöyle bir çıktı alacağımızı biliyorsunuz:
Merhaba Mübeccel!
Bu programın ne kadar sıkıcı olduğunu herhalde söylemeye gerek yok. Bu programda isim değişkenini doğrudan kendimiz yazdığımız için programımız hiçbir koşulda Merhaba Mübeccel dışında bir çıktı veremez. Çünkü bu program, tek yönlü bir programlama faaliyetinin ürünüdür.
Halbuki bu değişkenin değerini kendimiz yazmasak, bu değeri kullanıcıdan alsak ne hoş olurdu, değil mi?
Python’da kullanıcıdan herhangi bir veri alıp, yazdığımız programları tek taraflı olmaktan kurtarmak için
Kod:
input()
adlı bir fonksiyondan faydalanıyoruz.
İşte biz bu bölümde, programcılık maceramızı bir üst seviyeye taşıyacak çok önemli bir araç olan bu
Kod:
input()
fonksiyonunu derinlemesine inceleyeceğiz. Ama bu bölümde sadece bu fonksiyonu ele almayacağız elbette. Burada kullanıcıdan veri almanın yanısıra, aldığımız bu veriyi nasıl dönüştüreceğimizi ve bu veriyi, yazdığımız programlarda nasıl kullanacağımızı da derin derin inceleyeceğiz.
İlkin
Kod:
input()
fonksiyonunu anlatarak yola koyulalım.
input() Fonksiyonu
Kod:
input()
da daha önce öğrendiğimiz
Kod:
type()
,
Kod:
len()
ve
Kod:
print()
gibi bir fonksiyondur. Esasında biz bu fonksiyonu ilk kez burada görmüyoruz. Windows ve GNU/Linux kullanıcıları, yazdıkları bir programı çift tıklayarak çalıştırabilmek için bu fonksiyonu kullandıklarını hatırlıyor olmalılar. Mesela şu programı ele alalım:
#!/usr/bin/env python3
Bu programı yazıp kaydettikten sonra bu programın simgesi üzerine çift tıkladığımızda siyah bir komut ekranının çok hızlı bir şekilde açılıp kapandığını görürüz. Aslında programımız çalışıyor, ama programımız yapması gereken işi yaptıktan hemen sonra kapandığı için biz program penceresini görmüyoruz.
Programımızın çalıştıktan sonra hemen kapanmamasını sağlamak için son satıra bir
Kod:
input()
fonksiyonu yerleştirmemiz gerektiğini biliyoruz:
#!/usr/bin/env python3
Bu sayede programımız kullanıcıdan bir giriş bekleyecek ve o girişi alana kadar da kapanmayacaktır. Programı kapatmak için Enter düğmesine basabiliriz.
Kod:
input()
bir fonksiyondur dedik. Henüz fonksiyon kavramının ayrıntılarını öğrenmemiş olsak da, şimdiye kadar pek çok fonksiyon gördüğümüz için artık bir fonksiyonla karşılaştığımızda bunun nasıl kullanılacağını az çok tahmin edebiliyoruz. Tıpkı düşündüğünüz ve yukarıdaki örnekten de gördüğünüz gibi, birer fonksiyon olan
Kod:
type()
,
Kod:
print()
,
Kod:
len()
ve
Kod:
open()
fonksiyonlarını nasıl kullanıyorsak
Kod:
input()
fonksiyonunu da öyle kullanacağız.
Dilerseniz lafı daha fazla uzatmadan örnek bir program yazalım:
isim = input("İsminiz nedir? ")
print("Merhaba", isim, end="!\n")
Bu programı kaydedip çalıştırdığınızda, sorulan soruya verdiğiniz cevaba göre çıktı farklı olacaktır. Örneğin eğer bu soruya ‘Niyazi’ cevabını vermişseniz çıktınız Merhaba Niyazi! şeklinde olacaktır.
Görüyorsunuz ya, tıpkı daha önce gördüğümüz fonksiyonlarda olduğu gibi,
Kod:
input()
fonksiyonunda da parantez içine bir parametre yazıyoruz. Bu fonksiyona verilen parametre, kullanıcıdan veri alınırken kullanıcıya sorulacak soruyu gösteriyor. Gelin isterseniz bir örnek daha yapalım elimizin alışması için:
yaş = input("Yaşınız: ")
print("Demek", yaş, "yaşındasın.")
print("Genç mi yoksa yaşlı mı olduğuna karar veremedim.")
Kod:
input()
fonksiyonunun ne kadar kullanışlı bir araç olduğu ortada. Bu fonksiyon sayesinde, şimdiye kadar tek sesli bir şekilde yürüttüğümüz programcılık faaliyetlerimizi çok sesli bir hale getirebileceğiz. Mesela önceki bölümlerden birinde yazdığımız, daire alanı hesaplayan programı hatırlarsınız. O zaman henüz dosyalarımızı kaydetmeyi ve
Kod:
input()
fonksiyonunu öğrenmediğimiz için o programı etkileşimli kabukta şu şekilde yazmıştık:
>>> çap = 16
>>> yarıçap = çap / 2
>>> pi = 3.14159
>>> alan = pi * (yarıçap * yarıçap)
>>> alan
201.06176
Ama artık hem dosyalarımızı kaydetmeyi biliyoruz, hem de
Kod:
input()
fonksiyonunu öğrendik. Dolayısıyla yukarıdaki programı şu şekilde yazabiliriz:
#Kullanıcıdan dairenin çapını girmesini istiyoruz.
çap = input("Dairenin çapı: ")
#Kullanıcının verdiği çap bilgisini kullanarak
#yarıçapı hesaplayalım. Buradaki int() fonksiyonunu
#ilk kez görüyoruz. Biraz sonra bunu açıklayacağız
yarıçap = int(çap) / 2
#pi sayımız sabit
pi = 3.14159
#Yukarıdaki bilgileri kullanarak artık
#dairenin alanını hesaplayabiliriz
alan = pi * (yarıçap * yarıçap)
#Son olarak, hesapladığımız alanı yazdırıyoruz
print("Çapı", çap, "cm olan dairenin alanı: ", alan, "cm2'dir")
Gördüğünüz gibi,
Kod:
input()
fonksiyonunu öğrenmemiz sayesinde artık yavaş yavaş işe yarar programlar yazabiliyoruz.
Ancak burada, daha önce öğrenmediğimiz bir fonksiyon dikkatinizi çekmiş olmalı. Bu fonksiyonun adı
Kod:
int()
. Bu yeni fonksiyon dışında, yukarıdaki bütün kodları anlayabilecek kadar Python bilgisine sahibiz.
Kod:
int()
fonksiyonunun ne işe yaradığını anlamak için isterseniz ilgili satırı
Kod:
yarıçap = çap / 2
şeklinde yazarak çalıştırmayı deneyin bu programı.
Dediğim gibi, eğer o satırdaki
Kod:
int()
fonksiyonunu kaldırarak programı çalıştırdıysanız şuna benzer bir hata mesajı almış olmalısınız:
Traceback (most recent call last):
File "deneme.py", line 8, in <module>
yarıçap = çap / 2
TypeError: unsupported operand type(s) for /: 'str' and 'int'
Gördüğünüz gibi programımız bölme işlemini yapamadı. Buradan anlıyoruz ki, bu
Kod:
int()
fonksiyonu programımızdaki aritmetik işlemin düzgün bir şekilde yapılabilmesini sağlıyor. Gelelim bu fonksiyonun bu işlevi nasıl yerine getirdiğini incelemeye.
Tip Dönüşümleri
Bir önceki bölümün sonunda verdiğimiz örnek programda
Kod:
int()
adlı bir fonksiyon görmüş, bu fonksiyonu anlatmayı o zaman ertelemiştik. Çok gecikmeden, bu önemli fonksiyonun ne işe yaradığını öğrenmemiz gerekiyor. İsterseniz bir örnek üzerinden gidelim.
Diyelim ki kullanıcıdan aldığı sayının karesini hesaplayan bir program yazmak istiyoruz. Öncelikle şöyle bir şey deneyelim:
sayı = input("Lütfen bir sayı girin: ")
#Girilen sayının karesini bulmak için sayı değişkeninin 2.
#kuvvetini alıyoruz. Aynı şeyi pow() fonksiyonu ile de
#yapabileceğimizi biliyorsunuz. Örn.: pow(sayı, 2)
print("Girdiğiniz sayının karesi: ", sayı ** 2)
Bu kodları çalıştırdığımız zaman, programımız kullanıcıdan bir sayı girmesini isteyecek, ancak kullanıcı bir sayı girip Enter tuşuna bastığında şöyle bir hata mesajıyla karşılaşacaktır:
Traceback (most recent call last):
File "test.py", line 5, in <module>
print("Girdiğiniz sayının karesi: ", sayı ** 2)
TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'
Hata mesajına baktığınızda, ‘TypeError’ ifadesinden, bunun veri tipine ilişkin bir hata olduğunu tahmin edebilirsiniz. Eğer İngilizce biliyorsanız yukarıdaki hata mesajının anlamını rahatlıkla çıkarabilirsiniz. İngilizce bilmeseniz de en sondaki ‘str’ ve ‘int’ kelimeleri size karakter dizisi ve sayı adlı veri tiplerini hatırlatacaktır. Demek ki ortada veri tiplerini ilgilendiren bir sorun var...
Peki burada tam olarak neler dönüyor?
Hatırlayacaksınız, geçen derslerden birinde
Kod:
len()
fonksiyonunu anlatırken şöyle bir şey söylemiştik:
Alıntı:Biz henüz kullanıcıdan nasıl veri alacağımızı bilmiyoruz. Ama şimdilik şunu söyleyebiliriz: Python’da kullanıcıdan herhangi bir veri aldığımızda, bu veri bize bir karakter dizisi olarak gelecektir.
Gelin isterseniz yukarıda anlattığımız durumu teyit eden bir program yazalım:
#Kullanıcıdan herhangi bir veri girmesini istiyoruz
sayı = input("Herhangi bir veri girin: ")
#Kullanıcının girdiği verinin tipini bir
#değişkene atıyoruz
tip = type(sayı)
#Son olarak kullanıcının girdiği verinin tipini
#ekrana basıyoruz.
print("Girdiğiniz verinin tipi: ", tip)
Bu programı çalıştırdığımızda ne tür bir veri girersek girelim, girdiğimiz verinin tipi str, yani karakter dizisi olacaktır. Demek ki gerçekten de, kullanıcıdan veri almak için kullandığımız
Kod:
input()
fonksiyonu bize her koşulda bir karakter dizisi veriyormuş.
Geçen derslerde şöyle bir şey daha söylemiştik:
Alıntı:Python’da, o anda elinizde bulunan bir verinin hangi tipte olduğunu bilmek son derece önemlidir. Çünkü bir verinin ait olduğu tip, o veriyle neler yapıp neler yapamayacağınızı belirler.
Şu anda karşı karşıya olduğumuz durum da buna çok güzel bir örnektir. Eğer o anda elimizde bulunan verinin tipini bilmezsek tıpkı yukarıda olduğu gibi, o veriyi programımızda kullanmaya çalışırken programımız hata verir ve çöker.
Her zaman üstüne basa basa söylediğimiz gibi, aritmetik işlemler yalnızca sayılarla yapılır. Karakter dizileri ile herhangi bir aritmetik işlem yapılamaz. Dolayısıyla,
Kod:
input()
fonksiyonundan gelen veri bir karakter dizisi olduğu için ve biz de programımızda girilen sayının karesini hesaplamak amacıyla bu fonksiyondan gelen verinin 2. kuvvetini, yani karesini hesaplamaya çalıştığımız için programımız hata verecektir.
Yukarıdaki programda neler olup bittiğini daha iyi anlayabilmek için Python’ın etkileşimli kabuğunda şu işlemleri yapabiliriz:
>>> "23" ** 2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'
Gördüğünüz gibi, programımızdan aldığımız hata ile yukarıdaki hata tamamen aynı (hata mesajlarında bizi ilgilendiren kısım en son satırdır). Tıpkı burada olduğu gibi, hata veren programda da ‘Lütfen bir sayı girin: ‘ sorusuna örneğin 23 cevabını verdiğimizde programımız aslında
Kod:
"23" ** 2
gibi bir işlem yapmaya çalışıyor. Bir karakter dizisinin kuvvetini hesaplamak mümkün olmadığı, kuvvet alma işlemi yalnızca sayılarla yapılabileceği için de hata vermekten başka çaresi kalmıyor.
Ancak bazen öyle durumlarla karşılaşırsınız ki, programınız hiçbir hata vermez, ama elde edilen sonuç aslında tamamen beklentinizin dışındadır. Mesela şu basit örneği inceleyelim:
sayı1 = input("Toplama işlemi için ilk sayıyı girin: ")
sayı2 = input("Toplama işlemi için ikinci sayıyı girin: ")
print(sayı1, "+", sayı2, "=", sayı1 + sayı2)
Bu kodları çalıştırdığımızda şöyle bir manzarayla karşılaşırız:
Kod:
input()
fonksiyonunun alttan alta neler çevirdiğini bu örnek yardımıyla çok daha iyi anladığınızı zannediyorum. Gördüğünüz gibi yukarıdaki program herhangi bir hata vermedi. Ama beklediğimiz çıktıyı da vermedi. Zira biz programımızın iki sayıyı toplamasını istiyorduk. O ise kullanıcının girdiği sayıları yan yana yazmakla yetindi. Yani bir aritmetik işlem yapmak yerine, verileri birbiriyle bitiştirdi. Çünkü, dediğim gibi,
Kod:
input()
fonksiyonunun kullanıcıdan aldığı şey bir karakter dizisidir. Dolayısıyla bu fonksiyon yukarıdaki gibi bir durumla karşılaştığı zaman karakter dizileri arasında bir birleştirme işlemi gerçekleştirir. Tıpkı ilk derslerimizde etkileşimli kabukta verdiğimiz şu örnekte olduğu gibi:
>>> "23" + "23"
2323
Bu son örnekten ayrıca şunu çıkarıyoruz: Yazdığınız bir programın herhangi bir hata vermemesi o programın doğru çalıştığı anlamına gelmeyebilir. Dolayısıyla bu tür durumlara karşı her zaman uyanık olmanızda fayda var.
Peki yukarıdaki gibi durumlarla karşılaşmamak için ne yapacağız?
İşte bu noktada devreye tip dönüştürücü adını verdiğimiz birtakım fonksiyonlar girecek.
int()
Dediğimiz gibi,
Kod:
input()
fonksiyonundan gelen veri her zaman bir karakter dizisidir. Dolayısıyla bu fonksiyondan gelen veriyle herhangi bir aritmetik işlem yapabilmek için öncelikle bu veriyi bir sayıya dönüştürmemiz gerekir. Bu dönüştürme işlemi için
Kod:
int()
adlı özel bir dönüştürücü fonksiyondan yararlanacağız. Gelin isterseniz Python’ın etkileşimli kabuğunda bu fonksiyonla bir kaç deneme yaparak bu fonksiyonun ne işe yaradığını ve nasıl kullanıldığını anlamaya çalışalım. Zira etkileşimli kabuk bu tür deneme işlemleri için biçilmiş kaftandır:
>>> karakter_dizisi = "23"
>>> sayı = int(karakter_dizisi)
>>> print(sayı)
23
Burada öncelikle “23” adlı bir karakter dizisi tanımladık. Ardından da
Kod:
int()
fonksiyonunu kullanarak bu karakter dizisini bir tamsayıya (integer) dönüştürdük. İsminden de anlayacağınız gibi
Kod:
int()
fonksiyonu İngilizce integer (tamsayı) kelimesinin kısaltmasıdır ve bu fonksiyonun görevi bir veriyi tamsayıya dönüştürmektir.
Ancak burada dikkat etmemiz gereken bir şey var. Herhangi bir verinin sayıya dönüştürülebilmesi için o verinin sayı değerli bir veri olması gerekir. Örneğin “23”, sayı değerli bir karakter dizisidir. Ama mesela “elma” sayı değerli bir karakter dizisi değildir. Bu yüzden “elma” karakter dizisi sayıya dönüştürülemez:
>>> karakter_dizisi = "elma"
>>> sayı = int(karakter_dizisi)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'elma'
Gördüğünüz gibi, sayı değerli olmayan bir veriyi sayıya dönüştürmeye çalıştırdığımızda Python bize bir hata mesajı gösteriyor. Yazdığımız programlarda bu duruma özellikle dikkat etmemiz gerekiyor.
Şimdi bu bölümün başında yazdığımız ve hata veren programımıza dönelim yine:
sayı = input("Lütfen bir sayı girin: ")
print("Girdiğiniz sayının karesi: ", sayı ** 2)
Bu kodların hata vereceğini biliyoruz. Ama artık, öğrendiğimiz
Kod:
int()
dönüştürücüsünü kullanarak programımızı hata vermeyecek şekilde yeniden yazabiliriz:
veri = input("Lütfen bir sayı girin: ")
#input() fonksiyonundan gelen karakter dizisini
#sayıya dönüştürüyoruz.
sayı = int(veri)
print("Girdiğiniz sayının karesi: ", sayı ** 2)
Artık programımız hatasız bir şekilde çalışıyor.
Bir de öteki örneğimizi ele alalım:
sayı1 = input("Toplama işlemi için ilk sayıyı girin: ")
sayı2 = input("Toplama işlemi için ikinci sayıyı girin: ")
print(sayı1, "+", sayı2, "=", sayı1 + sayı2)
Bu kodların beklediğimiz çıktıyı vermeyeceğini biliyoruz. Ama eğer bu kodları şöyle yazarsak işler değişir:
v1 = input("Toplama işlemi için ilk sayıyı girin: ")
v2 = input("Toplama işlemi için ikinci sayıyı girin: ")
sayı1 = int(v1) #v1 adlı karakter dizisini sayıya dönüştürüyoruz.
sayı2 = int(v2) #v2 adlı karakter dizisini sayıya dönüştürüyoruz.
print(sayı1, "+", sayı2, "=", sayı1 + sayı2)
Gördüğünüz gibi,
Kod:
input()
fonksiyonundan gelen karakter dizilerini sayıya dönüştürerek istediğimiz çıktıyı alabiliyoruz.
str()
Python’daki tip dönüştürücüleri elbette sadece
Kod:
int()
fonksiyonuyla sınırlı değildir. Gördüğünüz gibi,
Kod:
int()
fonksiyonu sayı değerli verileri (mesela karakter dizilerini) tam sayıya dönüştürüyor. Bunun bir de tersi mümkündür. Yani karakter dizisi olmayan verileri karakter dizisine dönüştürmemiz de mümkündür. Bu işlem için
Kod:
str()
adlı başka bir tip dönüştürücüden yararlanıyoruz:
>>> sayı = 23
>>> kardiz = str(sayı)
>>> print(kardiz)
23
>>> print(type(kardiz))
<class 'str'>
Gördüğünüz gibi, bir tam sayı olan 23‘ü
Kod:
str()
adlı bir fonksiyondan yararlanarak karakter dizisi olan “23” ifadesine dönüştürdük. Son satırda da, elde ettiğimiz şeyin bir karakter dizisi olduğundan emin olmak için
Kod:
type()
fonksiyonunu kullanarak verinin tipini denetledik.
Yukarıdaki örneklerden gördüğümüz gibi, aritmetik işlemler yapmak istediğimizde karakter dizilerini sayıya çevirmemiz gerekiyor. Peki acaba hangi durumlarda bunun tersini yapmamız, yani sayıları karakter dizilerine çevirmemiz gerekir? Python bilginiz ve tecrübeniz arttıkça bunların hangi durumlar olduğunu kendiniz de göreceksiniz. Mesela biz daha şimdiden, sayıları karakter dizisine çevirmemiz gereken bir durumla karşılaştık. Hatırlarsanız,
Kod:
len()
fonksiyonunu anlatırken, bu fonksiyonun sayılarla birlikte kullanılamayacağını söylemiştik:
>>> len(12343423432)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: object of type 'int' has no len()
Peki ya yazdığınız programda bir sayının kaç haneden oluştuğunu hesaplamanız gerekirse ne yapacaksınız? Yani mesela yukarıdaki sayının 11 haneli olduğunu bilmeniz gerekiyorsa ne olacak?
İşte böyle bir durumda
fonksiyonu, şu ana kadar öğrendiğimiz veri tipleri içinde sadece karakter dizileri üzerinde işlem yapabiliyor. Biz de bu yüzden, sayımızın kaç haneli olduğunu öğrenebilmek için, öncelikle bu sayıyı bir karakter dizisine çeviriyoruz. Daha sonra da elde ettiğimiz bu karakter dizisini
Kod:
len()
fonksiyonuna parametre olarak veriyoruz. Böylece sayının kaç haneli olduğu bilgisini elde etmiş oluyoruz.
Bu arada elbette yukarıdaki işlemi tek satırda da halledebilirsiniz:
>>> len(str(12343423432))
11
Bu şekilde iç içe geçmiş fonksiyonlar yazdığımızda, Python fonksiyonları içten dışa doğru tek tek değerlendirecektir. Mesela yukarıdaki örnekte Python önce
Kod:
str(12343423432)
ifadesini değerlendirecek ve çıkan sonucu
Kod:
len()
fonksiyonuna gönderecektir. İç içe geçmiş fonksiyonları yazarken dikkat etmemiz gereken önemli bir nokta da, açtığımız her bir parantezi tek tek kapatmayı unutmamaktır.
float()
Hatırlarsanız ilk bölümlerde sayılardan söz ederken tamsayıların (integer) dışında kayan noktalı sayıların (float) da olduğundan söz etmiştik. İşte eğer bir tamsayıyı veya sayı değerli bir karakter dizisini kayan noktalı sayıya dönüştürmek istersek
Kod:
float()
adlı başka bir dönüştürücüden yararlanacağız:
>>> a = 23
>>> type(a)
<class 'int'>
>>> float(a)
23.0
Gördüğünüz gibi, 23 tamsayısı,
Kod:
float()
fonksiyonu sayesinde 23.0‘a yani bir kayan noktalı sayıya dönüştü.
Aynı şeyi, sayı değerli karakter dizileri üzerine uygulamak da mümkündür:
>>> b = "23"
>>> type(b)
<class 'str'>
>>> float(b)
23.0
complex()
Sayılardan söz ederken, eğer matematikle çok fazla içli dışlı değilseniz pek karşılaşmayacağınız, ‘karmaşık sayı’ adlı bir sayı türünden de bahsetmiştik. Karmaşık sayılar Python’da ‘complex’ ifadesiyle gösteriliyor. Mesela şunun bir karmaşık sayı olduğunu biliyoruz:
>>> 12+0j
Kontrol edelim:
>>> type(12+0j)
<class 'complex'>
İşte eğer herhangi bir sayıyı karmaşık sayıya dönüştürmeniz gerekirse
Kod:
complex()
adlı bir fonksiyondan yararlanabilirsiniz. Örneğin:
>>> complex(15)
(15+0j)
Böylece Python’daki bütün sayı dönüştürücüleri öğrenmiş olduk.
Gelin isterseniz, bu bölümde anlattığımız konuları şöyle bir tekrar ederek bilgilerimizi sağlamlaştırmaya çalışalım.
>>> a = 56
Bu sayı bir tamsayıdır. İngilizce olarak ifade etmek gerekirse, integer. Bunun bir tamsayı olduğunu şu şekilde teyit edebileceğimizi gayet iyi biliyorsunuz:
>>> type(a)
<class 'int'>
Burada aldığımız <class int> çıktısı, bize a değişkeninin tuttuğu sayının bir tamsayı olduğunu söylüyor. ‘int’ ifadesi, integer (tamsayı) kelimesinin kısaltmasıdır.
Bir de şu sayıya bakalım:
>>> b = 34.5
>>> type(b)
<class 'float'>
Bu çıktı ise bize 34.5 sayısının bir kayan noktalı sayı olduğunu söylüyor. float kelimesi Floats veya Floating Point Number ifadesinin kısaltmasıdır. Yani ‘kayan noktalı sayı’ demektir.
Bu arada, bu
Kod:
type()
adlı fonksiyonu sadece sayılara değil, başka şeylere de uygulayabileceğimizi biliyorsunuz. Mesela bir örnek vermek gerekirse:
>>> meyve = "karpuz"
>>> type(meyve)
<class 'str'>
Gördüğünüz gibi,
Kod:
type()
fonksiyonu bize meyve adlı değişkenin değerinin bir ‘str’ yani string yani karakter dizisi olduğunu bildirdi.
Bu veri tipleri arasında, bazı özel fonksiyonları kullanarak dönüştürme işlemi yapabileceğimizi öğrendik. Mesela:
>>> sayı = 45
sayı adlı değişkenin tuttuğu verinin değeri bir tamsayıdır. Biz bu tamsayıyı kayan noktalı sayıya dönüştürmek istiyoruz. Yapacağımız işlem çok basit:
>>> float(sayı)
45.0
Gördüğünüz gibi, 45 adlı tamsayıyı, 45.0 adlı bir kayan noktalı sayıya dönüştürdük. Şimdi
Kod:
type(45.0)
komutu bize <class ‘float’> çıktısını verecektir.
Eğer kayan noktalı bir sayıyı tamsayıya çevirmek istersek şu komutu veriyoruz. Mesela kayan noktalı sayımız, 56.5 olsun:
>>> int(56.5)
56
Yukarıdaki örneği tabii ki şöyle de yazabiliriz:
>>> a = 56.5
>>> int(a)
56
Dönüştürme işlemini sayılar arasında yapabileceğimiz gibi, sayılar ve karakter dizileri arasında da yapabiliriz. Örneğin şu bir karakter dizisidir:
>>> nesne = "45"
Yukarıdaki değeri tırnak içinde belirttiğimiz için bu değer bir karakter dizisidir. Şimdi bunu bir tamsayıya çevireceğiz:
>>> int(nesne)
45
Dilersek, aynı karakter dizisini kayan noktalı sayıya da çevirebiliriz:
>>> float(nesne)
45.0
Hatta bir sayıyı karakter dizisine de çevirebiliriz. Bunun için string (karakter dizisi) kelimesinin kısaltması olan str ifadesini kullanacağız:
>>> s = 6547
>>> str(s)
'6547'
Bir örnek de kayan noktalı sayılarla yapalım:
>>> s = 65.7
>>> str(s)
'65.7'
Yalnız şunu unutmayın: Bir karakter dizisinin sayıya dönüştürülebilmesi için o karakter dizisinin sayı değerli olması lazım. Yani “45” değerini sayıya dönüştürebiliriz. Çünkü “45” değeri, tırnaklardan ötürü bir karakter dizisi de olsa, neticede sayı değerli bir karakter dizisidir. Ama mesela “elma” karakter dizisi böyle değildir. Dolayısıyla, şöyle bir maceraya girişmek bizi hüsrana uğratacaktır:
>>> nesne = "elma"
>>> int(nesne)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'elma'
Gördüğünüz gibi, Python böyle bir işlem denemesi karşısında hata veriyor...
Bu bölümde pek çok yeni şey öğrendik. Bu bölümün en önemli getirisi
Kod:
input()
fonksiyonunu öğrenmemiz oldu. Bu fonksiyon sayesinde kullanıcıyla iletişim kurmayı başardık. Artık kullanıcıdan veri alıp, bu verileri programlarımız içinde işleyebiliyoruz.
Yine bu bölümde dikkatinizi çektiğimiz başka bir konu da sayılar ve karakter dizileri arasındaki ilişkiydi.
Kod:
input()
fonksiyonuyla elde edilen çıktının bir karakter dizisi olduğunu öğrendik. Bildiğimiz gibi, aritmetik işlemler ancak sayılar arasında yapılabilir. Dolayısıyla
Kod:
input()
fonksiyonuyla gelen karakter dizisini bir sayıyla çarpmaya kalkarsak hata alıyoruz. Burada yapmamız gereken şey, elimizdeki verileri dönüştürmek. Yani
Kod:
input()
fonksiyonundan gelen karakter dizisini bir sayıyla çarpmak istiyorsak, öncelikle aldığımız karakter dizisini sayıya dönüştürmemiz gerekiyor. Dönüştürme işlemleri için kullandığımız fonksiyonlar şunlardı:
Alıntı:
Kod:
int()
Sayı değerli bir karakter dizisini veya kayan noktalı sayıyı tamsayıya (integer) çevirir.
Kod:
float()
Sayı değerli bir karakter dizisini veya tamsayıyı kayan noktalı sayıya (float) çevirir.
Kod:
str()
Bir tamsayı veya kayan noktalı sayıyı karakter dizisine (string) çevirir.
Kod:
complex()
Herhangi bir sayıyı veya sayı değerli karakter dizisini karmaşık sayıya (complex) çevirir.
Ayrıca bu bölümde öğrendiklerimiz, şöyle önemli bir tespitte bulunmamıza da olanak tanıdı:
Alıntı:Her tamsayı ve/veya kayan noktalı sayı bir karakter dizisine dönüştürülebilir. Ama her karakter dizisi tamsayıya ve/veya kayan noktalı sayıya dönüştürülemez.
Örneğin, 5654 gibi bir tamsayıyı veya 543.34 gibi bir kayan noktalı sayıyı
Kod:
str()
fonksiyonu yardımıyla karakter dizisine dönüştürebiliriz:
>>> str(5654)
>>> str(543.34)
“5654” veya “543.34” gibi bir karakter dizisini
Kod:
int()
veya
Kod:
float()
fonksiyonu yardımıyla tamsayıya ya da kayan noktalı sayıya da dönüştürebiliriz:
>>> int("5654")
>>> int("543.34")
>>> float("5654")
>>> float("543.34")
Ama “elma” gibi bir karakter dizisini ne
Kod:
int()
ne de
Kod:
float()
fonksiyonuyla tamsayıya veya kayan noktalı sayıya dönüştürebiliriz! Çünkü “elma” verisi sayı değerli değildir.
Bu bölümü kapatmadan önce, dilerseniz şimdiye kadar öğrendiklerimizi de içeren örnek bir program yazalım. Bu program, Python maceramız açısından bize yeni kapılar da açacak.
Önceki derslerimizin birinde verdiğimiz doğalgaz faturası hesaplayan programı hatırlarsınız. İşte artık
Kod:
input()
fonksiyonu sayesinde bu doğalgaz faturası hesaplama programını da daha ilginç bir hale getirebiliriz:
#Her bir ayın kaç gün çektiğini tanımlıyoruz
ocak = mart = mayıs = temmuz = ağustos = ekim = aralık = 31
nisan = haziran = eylül = kasım = 30
şubat = 28
#Doğalgazın vergiler dahil metreküp fiyatı
birimFiyat = 0.79
#Kullanıcı ayda ne kadar doğalgaz tüketmiş?
aylıkSarfiyat = input("Aylık doğalgaz sarfiyatınızı metreküp olarak giriniz: ")
#Kullanıcı hangi aya ait faturasını öğrenmek istiyor?
dönem = input("""Hangi aya ait faturayı hesaplamak istersiniz?
(Lütfen ay adını tamamı küçük harf olacak şekilde giriniz)\n""")
#Yukarıdaki input() fonksiyonundan gelen veriyi
#Python'ın anlayabileceği bir biçime dönüştürüyoruz
ay = eval(dönem)
#Kullanıcının günlük doğalgaz sarfiyatı
günlükSarfiyat = int(aylıkSarfiyat) / ay
#Fatura tutarı
fatura = birimFiyat * günlükSarfiyat * ay
Burada yine bilmediğimiz bir fonksiyonla daha karşılaştık. Bu fonksiyonun adı
Kod:
eval()
. Biraz sonra
Kod:
eval()
fonksiyonunu derinlemesine inceleyeceğiz. Ama bu fonksiyonu anlatmaya geçmeden önce dilerseniz yukarıdaki kodları biraz didikleyelim.
İlk satırların ne işe yaradığını zaten biliyorsunuz. Bir yıl içindeki bütün ayların kaç gün çektiğini gösteren değişkenlerimizi tanımladık. Burada her bir değişkeni tek tek tanımlamak yerine değişkenleri topluca tanımladığımıza dikkat edin. İsteseydik tabii ki yukarıdaki kodları şöyle de yazabilirdik:
#Her bir ayın kaç gün çektiğini tanımlıyoruz
ocak = 31
şubat = 28
mart = 31
nisan = 30
mayıs = 31
haziran = 30
temmuz = 31
ağustos = 31
eylül = 30
ekim = 31
kasım = 30
aralık = 31
#Doğalgazın vergiler dahil m3 fiyatı
birimFiyat = 0.79
#Kullanıcı ayda ne kadar doğalgaz tüketmiş?
aylıkSarfiyat = input("Aylık doğalgaz sarfiyatınızı m3 olarak giriniz: ")
#Kullanıcı hangi aya ait faturasını öğrenmek istiyor?
dönem = input("""Hangi aya ait faturayı hesaplamak istersiniz?
(Lütfen ay adını tamamı küçük harf olacak şekilde giriniz)\n""")
#Yukarıdaki input() fonksiyonundan gelen veriyi
#Python'ın anlayabileceği bir biçime dönüştürüyoruz
ay = eval(dönem)
#Kullanıcının günlük doğalgaz sarfiyatı
günlükSarfiyat = int(aylıkSarfiyat) / ay
#Fatura tutarı
fatura = birimFiyat * günlükSarfiyat * ay
Ama tabii ki, değişkenleri tek tek tanımlamak yerine topluca tanımlamak, daha az kod yazmanızı sağlamasının yanısıra, programınızın çalışma performansı açısından da daha iyidir. Yani değişkenleri bu şekilde tanımladığınızda programınız daha hızlı çalışır.
Programımızı incelemeye devam edelim...
Değişkenleri tanımladıktan sonra doğalgazın vergiler dahil yaklaşık birim fiyatını da bir değişken olarak tanımladık. 0.79 değerini zaten birkaç bölüm önce hesaplayıp bulduğumuz için, aynı işlemleri tekrar programımıza eklememize gerek yok. Doğrudan nihai değeri programımıza yazsak yeter...
Birim fiyatı belirledikten sonra kullanıcıya aylık doğalgaz sarfiyatını soruyoruz. Kullanıcının bu değeri m3 olarak girmesini bekliyoruz. Elbette bu veriyi kullanıcıdan alabilmek için
Kod:
input()
fonksiyonunu kullanıyoruz.
Daha sonra kullanıcıya hangi aya ait doğalgaz faturasını ödemek istediğini soruyoruz. Bu bilgi, bir sonraki satırda günlük doğalgaz sarfiyatını hesaplarken işimize yarayacak. Çünkü kullanıcının girdiği ayın çektiği gün sayısına bağlı olarak günlük sarfiyat değişecektir. Günlük sarfiyatı hesaplamak için aylık sarfiyatı, ilgili ayın çektiği gün sayısına bölüyoruz. Bu arada bir önceki satırda dönem değişkenini
Kod:
eval()
adlı bir fonksiyonla birlikte kullandığımızı görüyorsunuz. Bunu biraz sonra inceleyeceğiz. O yüzden bu satırları atlayıp son satıra gelelim.
Son satırda
Kod:
print()
fonksiyonunu kullanarak, kullanıcıdan aldığımız verileri düzgün bir şekilde kendisine gösteriyoruz. Programımız kullanıcıya günlük doğalgaz sarfiyatını ve ay sonunda karşılaşacağı tahmini fatura tutarını bildiriyor.
Kod:
print()
fonksiyonu içinde kullandığımız kaçış dizilerine özellikle dikkatinizi çekmek istiyorum. Burada düzgün bir çıktı elde etmek için \t ve \n adlı kaçış dizilerinden nasıl yararlandığımızı görüyorsunuz. Bu kaçış dizilerinin buradaki işlevini tam olarak anlayabilmek için, bu kodları bir de bu kaçış dizileri olmadan yazmayı deneyebilirsiniz.
Bu bilgileri, önemlerinden ötürü aklımızda tutmaya çalışalım. Buraya kadar anlatılan konular hakkında zihnimizde belirsizlikler varsa veya bazı noktaları tam olarak kavrayamadıysak, şimdiye kadar öğrendiğimiz konuları tekrar gözden geçirmemiz bizim için epey faydalı olacaktır. Zira bundan sonraki bölümlerde, yeni bilgilerin yanısıra, buraya kadar öğrendiğimiz şeyleri de yoğun bir şekilde pratiğe dökeceğiz. Bundan sonraki konuları takip edebilmemiz açısından, buraya kadar verdiğimiz temel bilgileri iyice sindirmiş olmak işimizi bir hayli kolaylaştıracaktır.
eval() ve exec() Fonksiyonları
Bir önceki bölümün son örnek programında
Kod:
eval()
adlı bir fonksiyonla karşılaşmıştık. İşte şimdi bu önemli fonksiyonun ne işe yaradığını anlamaya çalışacağız. Ancak
Kod:
eval()
fonksiyonunu anlatmaya başlamadan önce şu uyarıyı yapalım:
eval() ŞEYTANİ GÜÇLERİ OLAN BİR FONKSİYONDUR!
Bunun neden böyle olduğunu hem biz anlatacağız, hem de zaten bu fonksiyonu tanıdıkça neden
Kod:
eval()
‘e karşı dikkatli olmanız gerektiğini kendiniz de anlayacaksınız.
Dilerseniz işe basit bir
Kod:
eval()
örneği vererek başlayalım:
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)
İngilizcede evaluate diye bir kelime bulunur. Bu kelime, ‘değerlendirmeye tabi tutmak, işleme sokmak, işlemek’ gibi anlamlar taşır. İşte
Kod:
eval()
fonksiyonundaki eval kelimesi bu evaluate kelimesinin kısaltmasıdır. Yani bu fonksiyonun görevi, kendisine verilen karakter dizilerini değerlendirmeye tabi tutmak ya da işlemektir. Peki bu tam olarak ne anlama geliyor?
Aslında yukarıdaki örnek programı çalıştırdığımızda bu sorunun yanıtını kendi kendimize verebiliyoruz. Bu programı çalıştırarak, “İşleminiz: “ ifadesinden sonra, örneğin,
Kod:
45 * 76
yazıp Enter tuşuna basarsak programımız bize 3420 çıktısı verecektir. Yani programımız hesap makinesi işlevini yerine getirip 45 sayısı ile 76 sayısını çarpacaktır. Dolayısıyla, yukarıdaki programı kullanarak her türlü aritmetik işlemi yapabilirsiniz. Hatta bu program, son derece karmaşık aritmetik işlemlerin yapılmasına dahi müsaade eder.
Peki programımız bu işlevi nasıl yerine getiriyor? İsterseniz kodların üzerinden tek tek geçelim.
Öncelikle programımızın en başına kullanım kılavuzuna benzer bir metin yerleştirdik ve bu metni
Kod:
print()
fonksiyonu yardımıyla ekrana bastık.
Daha sonra kullanıcıdan alacağımız komutları veri adlı bir değişkene atadık. Tabii ki kullanıcıyla iletişimi her zaman olduğu gibi
Kod:
input()
fonksiyonu yardımıyla sağlıyoruz.
Ardından, kullanıcıdan gelen veriyi
Kod:
eval()
fonksiyonu yardımıyla değerlendirmeye tabi tutuyoruz. Yani kullanıcının girdiği komutları işleme sokuyoruz. Örneğin, kullanıcı
Kod:
46 / 2
gibi bir veri girdiyse, biz
Kod:
eval()
fonksiyonu yardımıyla bu
Kod:
46 / 2
komutunu işletiyoruz. Bu işlemin sonucunu da hesap adlı başka bir değişken içinde depoluyoruz.
Eğer burada
Kod:
eval()
fonksiyonunu kullanmazsak, programımız, kullanıcının girdiği
Kod:
45 * 76
komutunu hiçbir işleme sokmadan dümdüz ekrana basacaktır. Yani:
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: ")
print(veri)
Eğer programımızı yukarıdaki gibi,
Kod:
eval()
fonksiyonu olmadan yazarsak, kullanıcımız
Kod:
45 * 76
gibi bir komut girdiğinde alacağı cevap dümdüz bir 45 * 76 çıktısı olacaktır. İşte
Kod:
eval()
fonksiyonu, kullanıcının girdiği her veriyi bir Python komutu olarak algılar ve bu veriyi işleme sokar. Yani
Kod:
45 * 76
gibi bir şey gördüğünde, bu şeyi doğrudan ekrana yazdırmak yerine, işlemin sonucu olan 3420 sayısını verir.
Kod:
eval()
fonksiyonunun, yukarıda anlattığımız özelliklerini okuduktan sonra, ‘Ne güzel bir fonksiyon! Her işimi görür bu!’ dediğinizi duyar gibiyim. Ama aslında durum hiç de öyle değil. Neden mi?
Şimdi yukarıdaki programı tekrar çalıştırın ve “İşleminiz: “ ifadesinden sonra şu cevabı verin:
print("Merhaba Python!")
Bu komut şöyle bir çıktı vermiş olmalı:
Merhaba Python!
None
Buradaki None değerini görmezden gelin. Bunu fonksiyonlar konusunu anlatırken inceleyeceğiz.
Gördüğünüz gibi, yazdığımız program, kullanıcının girdiği Python komutunun işletilmesine sebep oldu. Bu noktada, ‘Eee, ne olmuş!’ demiş olabilirsiniz. Gelin bir de şuna bakalım. Şimdi programı tekrar çalıştırıp şu cevabı verin:
open("deneme.txt", "w")
Bu cevap, bilgisayarınızda deneme.txt adlı bir dosya oluşturulmasına sebep oldu. Belki farkındasınız, belki farkında değilsiniz, ama aslında şu anda kendi yazdığınız program sizin kontrolünüzden tamamen çıktı. Siz aslında bir hesap makinesi programı yazmıştınız. Ama
Kod:
eval()
fonksiyonu nedeniyle kullanıcıya rastgele Python komutlarını çalıştırma imkanı verdiğiniz için programınız sadece aritmetik işlemleri hesaplamak için kullanılmayabilir. Böyle bir durumda kötü niyetli (ve bilgili) bir kullanıcı size çok büyük zarar verebilir. Mesela kullanıcının, yukarıdaki programa şöyle bir cevap verdiğini düşünün:
__import__("os").system("dir")
Burada anlamadığınız şeyleri şimdilik bir kenara bırakıp, bu komutun sonuçlarına odaklanın. Gördüğünüz gibi, yukarıdaki programa bu cevabı vererek mevcut dizin altındaki bütün dosyaları listeleyebildik. Yani programımız bir anda amacını aştı. Artık bu aşamadan sonra bu programı şeytani bir amaca yönelik olarak kullanmak tamamen programı kullanan kişiye kalmış... Bu programın, bir web sunucusu üzerinde çalışan bir uygulama olduğunu ve bu programı kullananların yukarıdaki gibi masumane bir şekilde dizin içindeki dosyaları listeleyen bir komut yerine, dizin içindeki dosyaları ve hatta sabit disk üzerindeki her şeyi silen bir komut yazdığını düşünün... Yanlış yazılmış bir program yüzünden bütün verilerinizi kaybetmeniz işten bile değildir. (Bahsettiğim o, ‘bütün sabit diski silen komutu’ kendi sisteminizde vermemeniz gerektiğini söylememe gerek yok, değil mi?)
Eğer SQL Injection kavramını biliyorsanız, yukarıdaki kodların yol açtığı güvenlik açığını gayet iyi anlamış olmalısınız. Zaten internet üzerinde yaygın bir şekilde kullanılan ve web sitelerini hedef alan SQL Injection tarzı saldırılar da aynı mantık üzerinden gerçekleştiriliyor. SQL Injection metoduyla bir web sitesine saldıran cracker‘lar, o web sitesini programlayan kişinin (çoğunlukla farkında olmadan) kullanıcıya verdiği rastgele SQL komutu işletme yetkisini kötüye kullanarak gizli ve özel bilgileri ele geçirebiliyorlar. Örneğin SQL Injection metodu kullanılarak, bir web sitesine ait veritabanının içeriği tamamen silinebilir. Aynı şekilde, yukarıdaki
Kod:
eval()
fonksiyonu da kullanıcılarınıza rastgele Python komutlarını çalıştırma yetkisi verdiği için kötü niyetli bir kullanıcının programınıza sızmasına yol açabilecek potansiyele sahiptir.
Peki
Kod:
eval()
fonksiyonunu asla kullanmayacak mıyız? Elbette kullanacağız. Bu fonksiyonun kullanımını gerektiren durumlarla da karşılaşabilirsiniz. Ama şunu asla aklınızdan çıkarmayın:
Kod:
eval()
fonksiyonu her ne kadar son derece yetenekli ve güçlü bir araç da olsa yanlış ellerde yıkıcı sonuçlar doğurabilir. Program yazarken, eğer
Kod:
eval()
kullanmanızı gerektiren bir durumla karşı karşıya olduğunuzu düşünüyorsanız, bir kez daha düşünün.
Kod:
eval()
ile elde edeceğiniz etkiyi muhtemelen başka ve çok daha iyi yöntemlerle de elde edebilirsiniz. Üstelik performans açısından
Kod:
eval()
pek iyi bir tercih değildir, çünkü bu fonksiyon (çoğu durumda farketmeseniz de) aslında yavaş çalışır. O yüzden,
Kod:
eval()
fonksiyonunu kullanacağınız zaman, bunun artı ve eksilerini çok iyi tartın: Bu fonksiyonu kullanmak size ne kazandırıyor, ne kaybettiriyor?
Ayrıca
Kod:
eval()
fonksiyonu kullanılacağı zaman, kullanıcıdan gelen veri bu fonksiyona parametre olarak verilmeden önce sıkı bir kontrolden geçirilir. Yani kullanıcının girdiği veri
Kod:
eval()
aracılığıyla doğrudan değerlendirmeye tabi tutulmaz. Araya bir kontrol mekanizması yerleştirilir. Örneğin, yukarıdaki hesap makinesi programında kullanıcının gireceği verileri sadece sayılar ve işleçlerle sınırlandırabilirsiniz. Yani kullanıcınızın, izin verilen değerler harici bir değer girmesini engelleyebilirsiniz. Bu durumu somutlaştırmak için şöyle bir diyagram çizebiliriz:
Yukarıdaki diyagram
Kod:
eval()
fonksiyonunun yanlış uygulanış biçimini gösteriyor. Gördüğünüz gibi, veri doğrudan
Kod:
eval()
fonksiyonuna gidiyor ve çıktı olarak veriliyor. Böyle bir durumda,
Kod:
eval()
fonksiyonu kullanıcıdan gelen verinin ne olduğuna bakmadan, veriyi doğrudan komut olarak değerlendirip işleteceği için programınızı kullanıcının insafına terketmiş oluyorsunuz.
Aşağıdaki diyagram ise
Kod:
eval()
fonksiyonunun doğru uygulanış biçimini gösteriyor:
Burada ise, veri
Kod:
eval()
fonksiyonuna ulaşmadan önce kontrolden geçiriliyor. Eğer veri ancak kontrol aşamasından geçerse
Kod:
eval()
fonksiyona ulaşabilecek ve oradan da çıktı olarak verilebilecektir. Böylece kullanıcıdan gelen komutları süzme imkanına sahip oluyoruz.
Gördüğünüz gibi, Python
Kod:
eval()
gibi bir fonksiyon yardımıyla karakter dizileri içinde geçen Python kodlarını ayıklayıp bunları çalıştırabiliyor. Bu sayede, mesela bize
Kod:
input()
fonksiyonu aracılığıyla gelen bir karakter dizisi içindeki Python kodlarını işletme imkanına sahip olabiliyoruz. Bu özellik, dikkatli kullanıldığında, işlerinizi epey kolaylaştırabilir.
Python’da
Kod:
eval()
fonksiyonuna çok benzeyen
Kod:
exec()
adlı başka bir fonksiyon daha bulunur.
Kod:
eval()
ile yapamadığımız bazı şeyleri
Kod:
exec()
ile yapabiliriz. Bu fonksiyon yardımıyla, karakter dizileri içindeki çok kapsamlı Python kodlarını işletebilirsiniz.
Örneğin
Kod:
eval()
fonksiyonu bir karakter dizisi içindeki değişken tanımlama işlemini yerine getiremez. Yani
Kod:
eval()
ile şöyle bir şey yapamazsınız:
>>> eval("a = 45")
Ama
Kod:
exec()
ile böyle bir işlem yapabilirsiniz:
>>> exec("a = 45")
Böylece a adlı bir değişken tanımlamış olduk. Kontrol edelim:
>>> print(a)
45
Kod:
eval()
ve
Kod:
exec()
fonksiyonları özellikle kullanıcıdan alınan verilerle doğrudan işlem yapmak gereken durumlarda işinize yarar. Örneğin bir hesap makinesi yaparken
Kod:
eval()
fonksiyonundan yararlanabilirsiniz.
Aynı şekilde mesela insanlara Python programlama dilini öğreten bir program yazıyorsanız
Kod:
exec()
fonksiyonunu şöyle kullanabilirsiniz:
d1 = """
Python'da ekrana çıktı verebilmek için print() adlı bir
fonksiyondan yararlanıyoruz. Bu fonksiyonu şöyle kullanabilirsiniz:
>>> print("Merhaba Dünya")
Şimdi de aynı kodu siz yazın!
>>> """
girdi = input(d1)
exec(girdi)
d2 = """
Gördüğünüz gibi print() fonksiyonu, kendisine
parametre olarak verilen değerleri ekrana basıyor.
Böylece ilk dersimizi tamamlamış olduk. Şimdi bir
sonraki dersimize geçebiliriz."""
print(d2)
Burada
Kod:
exec()
ile yaptığımız işi
Kod:
eval()
ile de yapabiliriz. Ama mesela eğer bir sonraki derste ‘Python’da değişkenler’ konusunu öğretecekseniz,
Kod:
eval()
yerine
Kod:
exec()
fonksiyonunu kullanmak durumunda kalabilirsiniz.
Kod:
eval()
fonksiyonunu anlatırken güvenlik ile ilgili olarak söylediğimiz her şey
Kod:
exec()
fonksiyonu için de geçerlidir. Dolayısıyla bu iki fonksiyonu çok dikkatli bir şekilde kullanmanız ve bu fonksiyonların doğurduğu güvenlik açığının bilincinde olmanız gerekiyor.
Henüz Python bilgilerimiz çok kısıtlı olduğu için
Kod:
eval()
ve
Kod:
exec()
fonksiyonlarını bütün ayrıntılarıyla inceleyemiyoruz. Ama bilgimiz arttıkça bu fonksiyonların ne kadar güçlü (ve tehlikeli) araçlar olduğunu siz de göreceksiniz.
format() Metodu
Python programlama dili içindeki çok temel bazı araçları incelediğimize göre, bu noktada Python’daki küçük ama önemli bir konuya değinelim bu bölümü kapatmadan önce.
İnternette dolaşırken mutlaka şuna benzer bir sayfayla karşılaşmış olmalısınız:
Burada belli ki adres çubuğuna fdkgd.com diye bir URL yazmışız, ama böyle bir internet adresi olmadığı için, kullandığımız internet tarayıcısı bize şöyle bir mesaj vermiş:
Hata! Google Chrome fdkgd.com sitesini bulamadı
Şimdi de dadasdaf.com adresini arayalım...
Yine böyle bir adres olmadığı için, bu defa tarayıcımız bize şöyle bir uyarı gösterecek:
Hata! Google Chrome dadasdaf.com sitesini bulamadı
Gördüğünüz gibi, hata mesajlarında değişen tek yer, aradığımız sitenin adresi. Yani internet tarayıcımız bu hata için şöyle bir taslağa sahip:
Hata! Google Chrome ... sitesini bulamadı
Burada ... ile gösterdiğimiz yere, bulunamayan URL yerleştiriliyor. Peki böyle bir şeyi Python programlama dili ile nasıl yapabiliriz?
Çok basit:
#Öncelikle kullanıcıdan bir internet adresi girmesini istiyoruz
url = input("Lütfen ulaşmak istediğiniz sitenin adresini yazın: ")
#Şimdi de bu adresin bulunamadığı konusunda kullanıcıyı bilgilendiriyoruz
print("Hata! Google Chrome", url, "sitesini bulamadı")
Gördüğünüz gibi, şimdiye kadar öğrendiğimiz bilgileri kullanarak böyle bir programı rahatlıkla yazabiliyoruz.
Peki ya biz kullanıcının girdiği internet adresini mesela tırnak içinde göstermek istersek ne olacak? Yani örneğin şöyle bir çıktı vermek istersek:
Hata! Google Chrome 'fdsfd.com' sitesini bulamadı
Bunun için yine karakter dizisi birleştirme yönteminden yararlanabilirsiniz:
#Öncelikle kullanıcıdan bir internet adresi girmesini istiyoruz
url = input("Lütfen ulaşmak istediğiniz sitenin adresini yazın: ")
#Şimdi de bu adresin bulunamadığı konusunda kullanıcıyı bilgilendiriyoruz
print("Hata! Google Chrome", "'" + url + "'", "sitesini bulamadı")
Burada, + işaretlerini kullanarak, kullanıcının girdiği adresin sağına ve soluna birer tırnak işaretini nasıl yerleştirdiğimize dikkat edin.
Gördüğünüz gibi bu yöntem işe yarıyor, ama ortaya çıkan karakter dizisi de oldukça karmaşık görünüyor. İşte bu tür ‘karakter dizisi biçimlendirme’ işlemleri için Python bize çok faydalı bir araç sunuyor. Bu aracın adı
Kod:
format()
.
Bu aracı şöyle kullanıyoruz:
#Öncelikle kullanıcıdan bir internet adresi girmesini istiyoruz
url = input("Lütfen ulaşmak istediğiniz sitenin adresini yazın: ")
#Şimdi de bu adresin bulunamadığı konusunda kullanıcıyı bilgilendiriyoruz
print("Hata! Google Chrome {} sitesini bulamadı".format(url))
Bir de bulunamayan internet adresini tırnak içine alalım:
print("Hata! Google Chrome '{}' sitesini bulamadı".format(url))
Görüyorsunuz ya, biraz önce karakter dizisi birleştirme yöntemini kullanarak gerçekleştirdiğimiz işlemi, çok daha basit bir yolla gerçekleştirme imkanı sunuyor bize bu
Kod:
format()
denen araç...
Peki
Kod:
format()
nasıl çalışıyor?
Bunu anlamak için şu basit örneklere bir bakalım:
>>> print("{} ve {} iyi bir ikilidir".format("Python", "Django"))
>>> metin = "{} {} yaşında bir {}dur"
>>> metin.format("Ahmet", "18", "futbolcu")
'Ahmet 18 yaşında bir futbolcudur'
Burada taslak metni doğrudan
Kod:
format()
metoduna parametre olarak vermeden önce bir değişkene atadık. Böylece bu metni daha kolay bir şekilde kullanabildik.
Bu örneklerin,
Kod:
format()
denen aracı anlamak konusunda size epey fikir verdiğini zannediyorum. Ama isterseniz bu aracın ne olduğunu ve nasıl çalıştığını daha ayrıntılı olarak incelemeye geçmeden önce başka bir örnek daha verelim.
Varsayalım ki kullanıcıdan aldığı bilgiler doğrultusunda, özel bir konu üzerine dilekçe oluşturan bir program yazmak istiyorsunuz.
Dilekçe taslağımız şu şekilde olsun:
tarih:
T.C.
... ÜNİVERSİTESİ
... Fakültesi Dekanlığına
Fakülteniz ..........Bölümü ......... numaralı öğrencisiyim. Ekte sunduğum
belgede belirtilen mazeretim gereğince ....... Eğitim-Öğretim Yılı .........
yarıyılında öğrenime ara izni (kayıt dondurma) istiyorum.
Amacınız bu dilekçedeki boşluklara gelmesi gereken bilgileri kullanıcıdan alıp, eksiksiz bir dilekçe ortaya çıkarmak.
Kullanıcıdan bilgi alma kısmı kolay.
Kod:
input()
fonksiyonunu kullanarak gerekli bilgileri kullanıcıdan alabileceğimizi biliyorsunuz:
tarih = input("tarih: ")
üniversite = input("üniversite adı: ")
fakülte = input("fakülte adı: ")
bölüm = input("bölüm adı: ")
öğrenci_no = input("öğrenci no. :")
öğretim_yılı = input("öğretim yılı: ")
yarıyıl = input("yarıyıl: ")
ad = input("öğrencinin adı: ")
soyad = input("öğrencinin soyadı: ")
tc_kimlik_no = input("TC Kimlik no. :")
adres = input("adres: ")
tel = input("telefon: ")
ekler = input("ekler: ")
Bilgileri kullanıcıdan aldık. Peki ama bu bilgileri dilekçe taslağı içindeki boşluklara nasıl yerleştireceğiz?
Şu ana kadar öğrendiğimiz
Kod:
print()
fonksiyonunu ve \t ve \n gibi kaçış dizilerini kullanarak istediğiniz çıktıyı elde etmeyi deneyebilirsiniz. Ama denediğinizde siz de göreceksiniz ki, bu tür yöntemleri kullanarak yukarıdaki dilekçe taslağını doldurmak inanılmaz zor ve vakit alıcı olacaktır. Halbuki bunların hiçbirine gerek yok. Çünkü Python bize bu tür durumlarda kullanılmak üzere çok pratik bir araç sunuyor. Şimdi çok dikkatlice inceleyin şu kodları:
dilekçe = """
tarih: {}
T.C.
{} ÜNİVERSİTESİ
{} Fakültesi Dekanlığına
Fakülteniz {} Bölümü {} numaralı öğrencisiyim. Ekte sunduğum belgede
belirtilen mazeretim gereğince {} Eğitim-Öğretim Yılı {}.
yarıyılında öğrenime ara izni (kayıt dondurma) istiyorum.
fonksiyonu yardımıyla metni tam bir şekilde ekrana çıktı olarak verdik.
Şimdi son tespitimizi biraz açıklayalım. Gördüğünüz gibi,
Kod:
print()
fonksiyonu içinde
Kod:
dilekçe.format()
gibi bir yapı var. Burada dilekçe değişkenine nokta işareti ile bağlanmış
Kod:
format()
adlı, fonksiyon benzeri bir araç görüyoruz. Bu araca teknik dilde ‘metot’ adı verilir.
Kod:
format()
metodunun parantezleri içinde ise, kullanıcıdan alıp birer değişkene atadığımız veriler yer alıyor.
Dilerseniz yukarıda olan biteni daha net anlayabilmek için bu konunun başına verdiğimiz örneklere geri dönelim.
İlk olarak şöyle bir örnek vermiştik:
#Öncelikle kullanıcıdan bir internet adresi girmesini istiyoruz
url = input("Lütfen ulaşmak istediğiniz sitenin adresini yazın: ")
#Şimdi de bu adresin bulunamadığı konusunda kullanıcıyı bilgilendiriyoruz
print("Hata! Google Chrome {} sitesini bulamadı".format(url))
Burada kullanıcının gireceği internet adresinin yerini tutması için {} işaretlerinden yararlanarak şöyle bir karakter dizisi oluşturduk:
"Hata! Google Chrome {} sitesini bulamadı"
Gördüğünüz gibi, {} işareti karakter dizisi içinde URL’nin geleceği yeri tutuyor. Bu {} işaretinin yerine neyin geleceğini
Kod:
format()
metodunun parantezleri içinde belirtiyoruz. Dikkatlice bakın:
print("Hata! Google Chrome {} sitesini bulamadı".format(url))
Elbette eğer istersek yukarıdaki örneği şöyle de yazabilirdik:
url = input("Lütfen ulaşmak istediğiniz sitenin adresini yazın: ")
#Kullanıcıya gösterilecek hata için bir taslak metin oluşturuyoruz
hata_taslağı = "Hata! Google Chrome {} sitesini bulamadı"
print(hata_taslağı.format(url))
Burada hata metnini içeren karakter dizisini doğrudan
Kod:
format()
metoduna bağlamak yerine, bunu bir değişkene atayıp,
Kod:
format()
metodunu bu değişkene bağladık.
Bunun dışında şu örnekleri de vermiştik:
>>> metin = "{} ve {} iyi bir ikilidir"
>>> metin.format("Python", "Django")
>>> metin = "{} {} yaşında bir {}dur"
>>> metin.format("Ahmet", "18", "futbolcu")
'Ahmet 18 yaşında bir futbolcudur'
Burada da, gördüğüz gibi, öncelikle bir karakter dizisi tanımlıyoruz. Bu karakter dizisi içindeki değişken değerleri ise {} işaretleri ile gösteriyoruz. Daha sonra
Kod:
format()
metodunu alıp bu karakter dizisine bağlıyoruz. Karakter dizisi içindeki {} işaretleri ile gösterdiğimiz yerlere gelecek değerleri de
Kod:
format()
metodunun parantezleri içinde gösteriyoruz. Yalnız burada şuna dikkat etmemiz lazım: Karakter dizisi içinde kaç tane {} işareti varsa,
Kod:
format()
metodunun parantezleri içinde de o sayıda değer olması gerekiyor.
Bu yapının, yazdığımız programlarda işimizi ne kadar kolaylaştıracağını tahmin edebilirsiniz. Kısa karakter dizilerinde pek belli olmayabilir, ama özellikle çok uzun ve boşluklu karakter dizilerini biçimlendirirken
Kod:
format()
metodunun hayat kurtardığına kendiniz de şahit olacaksınız.
İlerleyen derslerimizde
Kod:
format()
metodunu ve karakter dizisi biçimlendirme konusunu çok daha ayrıntılı bir şekilde inceleyeceğiz. Ancak yukarıda verdiğimiz bilgiler
Kod:
format()
metodunu verimli bir şekilde kullanabilmenizi sağlamaya yetecek düzeydedir.
Python’la ilgili şimdiye kadar öğrendiğimiz bilgileri kullanarak yazabileceğimiz en karmaşık programlardan biri herhalde şöyle olacaktır:
isim = "Fırat"
soyisim = "Özgül"
işsis = "Ubuntu"
şehir = "İstanbul"
Yukarıdaki kodları rahatlıkla anlayabildiğinizi zannediyorum. Ama isterseniz yine de bu kodları satır satır inceleyelim:
İlk olarak isim, soyisim, işsis ve şehir adında dört farklı değişken tanımladık. Bu değişkenlerin değeri sırasıyla Fırat, Özgül, Ubuntu ve İstanbul.
Daha sonra da tanımladığımız bu değişkenleri belli bir düzen içinde kullanıcılarımıza gösterdik, yani ekrana yazdırdık. Elbette bu iş için
Kod:
print()
fonksiyonunu kullandık. Bildiğiniz gibi,
Kod:
print()
birden fazla parametre alabilen bir fonksiyondur. Yani
Kod:
print()
fonksiyonunun parantezleri içine istediğimiz sayıda öğe yazabiliriz.
Eğer
Kod:
print()
fonksiyonunun yukarıdaki kullanımı ilk bakışta gözünüze anlaşılmaz göründüyse, fonksiyonda geçen ve ne işe yaradığını anlayamadığınız öğeleri, bir de çıkartarak yazmayı deneyebilirsiniz bu fonksiyonu.
Python’la yazılmış herhangi bir programın tam olarak nasıl işlediğini anlamanın en iyi yolu program içindeki kodlarda bazı değişiklikler yaparak ortaya çıkan sonucu incelemektir. Örneğin
Kod:
print()
fonksiyonunda sep parametresinin değerini boş bir karakter dizisi yapmamızın nedenini anlamak için, fonksiyondaki bu sep parametresini kaldırıp, programı bir de bu şekilde çalıştırmayı deneyebilirsiniz.
Yukarıdaki örnekte bütün öğeleri tek bir
Kod:
print()
fonksiyonu içine yazdık. Ama tabii eğer isterseniz birden fazla
Kod:
print()
fonksiyonu da kullanabilirsiniz. Şöyle:
isim = "Fırat"
soyisim = "Özgül"
işsis = "Ubuntu"
şehir = "İstanbul"
Yukarıdaki kodlarla ilgili birkaç noktaya daha dikkatinizi çekmek istiyorum:
Birincisi, gördüğünüz gibi kodları yazarken biraz şekil vererek yazdık. Bunun sebebi kodların görünüş olarak anlaşılır olmasını sağlamak. Daha önce de dediğimiz gibi, Python’da doğru kod yazmak kadar, yazdığınız kodların anlaşılır olması da önemlidir. Bu sebepten, Python’la kod yazarken, mesela kodlarımızdaki her bir satırın uzunluğunun 79 karakteri geçmemesine özen gösteriyoruz. Bunu sağlamak için, kodlarımızı yukarıda görüldüğü şekilde belli noktalardan bölmemiz gerekebilir.
Esasında yukarıdaki kodları şöyle de yazabilirdik:
isim = "Fırat"
soyisim = "Özgül"
işsis = "Ubuntu"
şehir = "İstanbul"
Ancak bu şekilde kod yapısı biraz karmaşık görünüyor. Ayrıca parantez içindeki öğeleri yan yana yazdığımız için, isim:, soyisim:, işletim sistemi: ve şehir: ifadelerini alt alta düzgün bir şekilde hizalamak da kolay olmayacaktır.
Belki bu basit kodlarda çok fazla dikkati çekmiyordur, ama özellikle büyük boyutlu programlarda kodlarımızı hem yapı hem de görüntü olarak olabildiğince anlaşılır bir hale getirmek hem kodu okuyan başkaları için, hem de kendimiz için büyük önem taşır. Unutmayın, bir programı yazdıktan 5-6 ay sonra geri dönüp baktığınızda kendi yazdığınız kodlardan siz dahi hiçbir şey anlamadığınızı farkedebilirsiniz!
Bir program yazarken kodların olabildiğince okunaklı olmasını sağlamanın bir kaç yolu vardır. Biz bunlardan bazılarını yukarıda gördük. Ancak bir programı okunaklı hale getirmenin en iyi yolu kodlar içine bazı yorum cümleleri ekleyerek kodları açıklamaktır.
İşte bu bölümde, Python programlama dili ile yazdığımız kodlara nasıl yorum ve açıklama cümleleri ekleyeceğimizi inceleyeceğiz.
Yorum İşareti
Programcılıkta en zor şey başkasının yazdığı kodları okuyup anlamaktır. Hatta yazılmış bir programı düzeltmeye çalışmak, bazen o programı sıfırdan yazmaktan daha zor olabilir. Bunun nedeni, program içindeki kodların ne işe yaradığını anlamanın zorluğudur. Programı yazan kişi kendi düşünüşüne göre bir yol izlemiş ve programı geliştirirken karşılaştığı sorunları çözmek için kimi yerlerde enteresan çözümler üretmiş olabilir. Ancak kodlara dışarıdan bakan birisi için o programın mantık düzenini ve içindeki kodların tam olarak ne yaptığını anlamak bir hayli zor olacaktır. Böyle durumlarda, kodları okuyan programcının en büyük yardımcısı, programı geliştiren kişinin kodlar arasına eklediği notlar olacaktır. Tabii programı geliştiren kişi kodlara yorum ekleme zahmetinde bulunmuşsa...
Python’da yazdığımız kodları başkalarının da anlayabilmesini sağlamak için, programımızın yorumlarla desteklenmesi tavsiye edilir. Elbette programınızı yorumlarla desteklemeseniz de programınız sorunsuz bir şekilde çalışacaktır. Ama programı yorumlarla desteklemek en azından nezaket gereğidir.
Ayrıca işin başka bir boyutu daha var. Sizin yazdığınız kodları nasıl başkaları okurken zorlanıyorsa, kendi yazdığınız kodları okurken siz bile zorlanabilirsiniz. Özellikle uzun süredir ilgilenmediğiniz eski programlarınızı gözden geçirirken böyle bir sorunla karşılaşabilirsiniz. Programın içindeki bir kod parçası, programın ilk yazılışının üzerinden 5-6 ay geçtikten sonra size artık hiçbir şey ifade etmiyor olabilir. Kodlara bakıp, ‘Acaba burada ne yapmaya çalışmışım?’ diye düşündüğünüz zamanlar da olacaktır. İşte bu tür sıkıntıları ortadan kaldırmak veya en aza indirmek için kodlarımızın arasına açıklayıcı notlar ekleyeceğiz.
Python’da yorumlar # işareti ile gösterilir. Mesela bu bölümün ilk başında verdiğimiz kodları yorumlarla destekleyelim:
isim = "Fırat"
soyisim = "Özgül"
işsis = "Ubuntu" #işletim sistemi
şehir = "İstanbul"
#isim, soyisim, işsis ve şehir adlı değişkenleri
#alt alta, düzgün bir şekilde ekrana basıyoruz.
#Uygun yerlerde alt satıra geçebilmek için "\n"
#adlı kaçış dizisini kullanıyoruz.
print("isim : ", isim, "\n",
"soyisim : ", soyisim, "\n",
"işletim sistemi: ", işsis, "\n",
"şehir : ", şehir, "\n",
sep="") #parametreler arasında boşluk bırakmıyoruz.
Burada dikkat edeceğimiz nokta her yorum satırının başına # işaretini koymayı unutmamaktır.
Yazdığımız yorumlar Python’a hiç bir şey ifade etmez. Python bu yorumları tamamen görmezden gelecektir. Bu yorumlar bilgisayardan ziyade kodları okuyan kişi için bir anlam taşır.
Elbette yazdığınız yorumların ne kadar faydalı olacağı, yazdığınız yorumların kalitesine bağlıdır. Dediğimiz gibi, yerli yerinde kullanılmış yorumlar bir programın okunaklılığını artırır, ama her tarafı yorumlarla kaplı bir programı okumak da bazen hiç yorum girilmemiş bir programı okumaktan daha zor olabilir! Dolayısıyla Python’da kodlarımıza yorum eklerken önemli olan şey, kaş yapmaya çalışırken göz çıkarmamaktır. Yani yorumlarımızı, bir kodun okunaklılığını artırmaya çalışırken daha da bozmayacak şekilde yerleştirmeye dikkat etmeliyiz.
Yorum İşaretinin Farklı Kullanımları
Yukarıda yorum (#) işaretini kullanarak, yazdığımız Python kodlarını nasıl açıklayacağımızı öğrendik. Python’da yorum işaretleri çoğunlukla bu amaç için kullanılır. Yani kodları açıklamak, bu kodları hem kendimiz hem de kodları okuyan başkaları için daha anlaşılır hale getirmek için... Ama Python’da # işareti asıl amacının dışında bazı başka amaçlara da hizmet edebilir.
Etkisizleştirme Amaçlı
Dediğimiz gibi, yorum işaretinin birincil görevi, tabii ki, kodlara açıklayıcı notlar eklememizi sağlamaktır. Ama bu işaret başka amaçlar için de kullanılabilir. Örneğin, diyelim ki yazdığımız programa bir özellik eklemeyi düşünüyoruz, ama henüz bu özelliği yeni sürüme eklemek istemiyoruz. O zaman şöyle bir şey yapabiliriz:
isim = "Fırat"
soyisim = "Özgül"
işsis = "Ubuntu"
şehir = "İstanbul"
#uyruğu = "T.C"
Burada, programa henüz eklemek istemediğimiz bir özelliği, yorum içine alarak şimdilik iptal ediyoruz yani etkisizleştiriyoruz (İngilizcede bu yorum içine alma işlemine comment out deniyor). Python yorum içinde bir kod bile yer alsa o kodları çalıştırmayacaktır. Çünkü Python # işareti ile başlayan satırların içeriğini görmez (
Kod:
#!/usr/bin/env python3
ve
Kod:
# -*- coding: utf-8 -*-
satırları hariç).
Peki eklemek istemediğimiz özelliği yorum içine almaktansa doğrudan silsek olmaz mı? Elbette olur. Ama programın daha sonraki bir sürümüne ilave edeceğimiz bir özelliği yorum içine almak yerine silecek olursak, vakti geldiğinde o özelliği nasıl yaptığımızı hatırlamakta zorlanabiliriz! Hatta bir süre sonra programımıza hangi özelliği ekleyeceğimizi dahi unutmuş olabiliriz. ‘Hayır, ben hafızama güveniyorum!’ diyorsanız karar sizin.
Yorum içine alarak iptal ettiğiniz bu kodları programa ekleme vakti geldiğinde yapacağınız tek şey, kodların başındaki # işaretlerini kaldırmak olacaktır. Hatta bazı metin düzenleyiciler bu işlemi tek bir tuşa basarak da gerçekleştirme yeteneğine sahiptir. Örneğin IDLE ile çalışıyorsanız, yorum içine almak istediğiniz kodları fare ile seçtikten sonra Alt+3 tuşlarına basarak ilgili kodları yorum içine alabilirsiniz. Bu kodları yorumdan kurtarmak için ise ilgili alanı seçtikten sonra Alt+4 tuşlarına basmanız yeterli olacaktır (yorumdan kurtarma işlemine İngilizcede uncomment diyorlar).
Süsleme Amaçlı
Bütün bunların dışında, isterseniz yorum işaretini kodlarınızı süslemek için dahi kullanabilirsiniz:
#######################################################
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#
# FALANCA v.1 #
# Yazan: Keramet Su #
# Lisans: GPL v2 #
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#
#######################################################
isim = "Fırat"
soyisim = "Özgül"
işsis = "Ubuntu"
şehir = "İstanbul"
Yani kısaca, Python’un görmesini, çalıştırmasını istemediğimiz her şeyi yorum içine alabiliriz. Unutmamamız gereken tek şey, yorumların yazdığımız programların önemli bir parçası olduğu ve bunları mantıklı, makul bir şekilde kullanmamız gerektiğidir.
Kısmet bu forumda bu yarışmayı yapmak oldu. Şimdiden katılacaklara başarılar dilerim..
Katılım Şartları: http://mediamarjin.10tr.net/adresinde üyeliğiniz bulunması
10 Konu ve 20 mesajınızın olması..
Ödül: 1. olan kişinin kazanacağı ödüldür. 2,ve 3'cüye yarışma bittikten sonra hediyeleri belirlenecek..
-Premıum bir tema çizimi
-Benim ve sitemizdeki grafiker arkadaşların sizler için toplayacağı özel grafik malzemeleri paketi.
-Destek sitesinde 50 rep
-Sitemizde 1 aylık onursal üyelik.
Ne Yapıcaksınız? -Avatar
-Logo
-Avatar; 150X150
Yazı: Media Marjin
Gerisi sizin hayal gücünüze göre şekillenecek.
-Logo 320X98
Yazı: Media Marjin
Gerisi sizin hayal gücünüze göre şekillenecek.
Katılmak İstiyenler bu konunun altına yaptığı tasarımlarını atabilirler.
Bu bölümde, Python programları geliştirirken rahat bir çalışma ortamı elde edebilmek için yapmanız gerekenleri sıralayacağız. Öncelikle Windows kullanıcılarından başlayalım.
Windows Kullanıcıları
Windows’ta bir Python programı yazıp kaydettikten sonra bu programı komut satırından çalıştırabilmek için, MS-DOS’u açıp, öncelikle
Kod:
cd
komutuyla programın bulunduğu dizine ulaşmamız gerekir. İlgili dizine ulaştıktan sonra programımızı
Kod:
python program_adı
komutuyla çalıştırabiliriz. Ancak bir süre sonra, programı çalıştırmak için her defasında programın bulunduğu dizine ulaşmaya çalışmak sıkıcı bir hal alacaktır. Ama bu konuda çaresiz değiliz.
Windows 7, istediğimiz dizin altında bir MS-DOS ekranı açabilmemiz için bize çok güzel bir kolaylık sunuyor. Normal şartlar altında mesela masaüstünde bir MS-DOS ekranı açabilmek için şu yolu izlemeniz gerekiyor:
Windows logolu tuşa ve R tuşuna birlikte bas,
Açılan pencereye
cmd
yazıp Enter düğmesine bas,
Bu şekilde ulaştığın MS-DOS ekranında
cd Desktop
komutunu ver.
Bu üç adımla, MS-DOS ekranı üzerinden masaüstüne ulaşmış oluyoruz. Ama aslında bunun çok daha kolay bir yolu var: Masaüstüne sağ tıklarken Shift tuşunu da basılı tutarsanız, sağ-tık menüsünde ‘Komut penceresini burada aç’ adlı bir satır görürsünüz. İşte bu satıra tıklayarak, MS-DOS komut satırını tek harekette masaüstü konumunda çalıştırabilirsiniz. Elbette bu özellik sadece masaüstü için değil, bütün konumlar için geçerlidir. Yani bilgisayarınızda herhangi bir yere sağ tıklarken Shift tuşunu da basılı tutarak o konumda bir MS-DOS penceresi açabilirsiniz.
Ayrıca, herhangi bir klasör açıkken dosya tarayıcısının adres çubuğuna
Kod:
cmd
yazıp Enter düğmesine basarak da, o klasörün bulunduğu konumda bir komut ekranı açabilirsiniz. Örneğin eğer o anda önünüzde ‘İndirilenler’ (veya ‘Karşıdan Yüklenenler’) dizini açıksa, adres çubuğuna (aşağıdaki resimde kırmızı ile gösterilen bölge)
Kod:
cmd
yazarak C:\Users\Kullanıcı\Downloads> konumunda bir komut ekranı açabilirsiniz.
İkinci olarak, çalışma kolaylığı açısından Windows’ta dosya uzantılarının her zaman görünmesini sağlamanızı da tavsiye ederim. Windows ilk kurulduğunda hiçbir dosyanın uzantısı görünmez. Yani mesela deneme.txt adlı bir dosya Windows ilk kurulduğunda deneme şeklinde görünecektir. Bu durumda, bir dosyanın uzantısını değiştirmek istediğinizde bazı sıkıntılar yaşarsınız. Örneğin, masaüstünde bir metin dosyası oluşturduğunuzu varsayalım. Diyelim ki amacınız bu dosyanın içine bir şeyler yazıp daha sonra mesela bu dosyanın uzantısını .bat veya .py yapmak olsun. Böyle bir durumda, dosya uzantılarını göremediğiniz için, metin dosyasının uzantısını değiştirmeye çalıştığınızda deneme.bat.txt gibi bir dosya adı elde edebilirsiniz. Tabii ki bu dosya bir .bat dosyası değil, bir .txt, yani metin dosyasıdır. Dolayısıyla aslında dosya uzantısını değiştirememiş oluyorsunuz.
Yukarıdaki nedenlerden ötürü, ben size şu yolu takip ederek dosya uzantılarını her zaman görünür hale getirmenizi öneririm:
Başlat > Denetim Masası yolunu takip ederek denetim masasına ulaşın,
Denetim masasında ‘Görünüm ve Kişiselleştirme’ seçeneğine tıklayın,
Açılan menünün sağ tarafında ‘Klasör Seçenekleri’ satırına tıklayın,
Açılan pencerede ‘Görünüm’ sekmesine tıklayın,
‘Gelişmiş Ayarlar’ listesinde ‘Bilinen dosya türleri için uzantıları gizle’ seçeneğinin yanındaki onay işaretini kaldırın,
Uygula ve Tamam düğmelerine basarak bütün pencereleri kapatın,
Artık bütün dosyalarınızın uzantısı da görüneceği için, uzantı değiştirme işlemlerini çok daha kolay bir şekilde halledebilirsiniz.
GNU/Linux Kullanıcıları
Eğer KDE temelli bir GNU/Linux dağıtımı kullanıyorsanız, yazıp kaydettiğiniz Python programını barındıran dizin açıkken F4 tuşuna bastığınızda, komut satırı o dizin altında açılacaktır.
Unity ve GNOME kullanıcılarının ise benzer bir kolaylığa ulaşmak için nautilus-open-terminal adlı betiği sistemlerine kurmaları gerekiyor. Eğer Ubuntu kullanıyorsanız bu betiği şu komutla kurabilirsiniz:
sudo apt-get install nautilus-open-terminal
Bu betiği kurduktan sonra bilgisayarınızı yeniden başlatın veya şu komutu verin:
killall nautilus
Artık komut satırını hangi dizin altında başlatmak istiyorsanız o dizine sağ tıklayın. Menüler arasında Open in Terminal [Uçbirimde aç] adlı bir seçenek göreceksiniz. Buna tıkladığınızda o dizin altında bir komut satırı penceresi açılacaktır.
Metin Düzenleyici Ayarları
Daha önce de söylediğimiz gibi, Python ile program yazmak için istediğiniz metin düzenleyiciyi kullanabilirsiniz. Ama kodlarınızın kusursuz görünmesi ve hatasız çalışması için kullandığınız metin düzenleyicide birtakım ayarlamalar yapmanız gerekir. İşte bu bölümde bu ayarların neler olduğunu göstereceğiz.
Eğer programlarınızı IDLE ile yazıyorsanız aslında bir şey yapmanıza gerek yok. IDLE Python ile program yazmak üzere tasarlanmış bir düzenleyici olduğu için bu programın bütün ayarları Python ile uyumludur. Ama eğer IDLE dışında bir metin düzenleyici kullanıyorsanız bu düzenleyicide temel olarak şu ayarları yapmanız gerekir:
Sekme genişliğini [TAB width] 4 olarak ayarlayın.
Girinti genişliğini [Indent width] 4 olarak ayarlayın.
Girintilemede sekme yerine boşluk kullanmayı tercih edin [Use spaces instead of tabs]
Tercih edilen kodlama biçimini [Preferred encoding] utf-8 olarak ayarlayın.
Özellikle son söylediğimiz ‘kodlama biçimi’ ayarı çok önemlidir. Bu ayarın yanlış olması halinde, yazdığınız programı çalıştırmak istediğinizde şöyle bir hata alabilirsiniz:
SyntaxError: Non-UTF-8 code starting with '\xfe' in file deneme.py on line 1,
but no encoding declared; see http://python.org/dev/peps/pep-0263/ for details
Eğer yazdığınız bir program böyle bir hata mesajı üretiyorsa, ilk olarak metin düzenleyicinizin kodlama biçimi (encoding) ayarlarını kontrol edin. Metin düzenleyiciler genellikle tercih edilen kodlama biçimini aşağıdaki örnek resimde görüldüğü gibi, durum çubuğunda sürekli olarak gösterir.
Ancak kodlama biçimi doğru bir şekilde utf-8 olarak ayarlanmış metin düzenleyicilerde, özellikle internet üzerinden kod kopyalanıp yapıştırılması sırasında bu ayar siz farkında olmadan değişebilir. Böyle bir durumda da program çalışırken yukarıda bahsedilen hatayı alabilirsiniz. Dolayısıyla, programınızı yazdığınız metin düzenleyicinin kodlama ayarlarının siz farkında olmadan değişme ihtimaline karşı uyanık olmanız gerekir.
Elbette piyasada yüzlerce metin düzenleyici olduğu için yukarıda bahsedilen ayarların her metin düzenleyicide nasıl yapılacağını tek tek göstermemiz mümkün değil. Ancak iyi bir metin düzenleyicide yukarıdaki ayarların hepsi bulunur. Tek yapmanız gereken, bu ayarların, kullandığınız metin düzenleyicide nereden yapıldığını bulmak. Eğer kullandığınız metin düzenleyiciyi ayarlamakta zorlanıyorsanız, her zamanki gibi istihza.com/forum adresinde sıkıntınızı dile getirebilirsiniz.
‘Kodlama biçimi’ kavramından söz etmişken, Python’la ilgili önemli bir konuya daha değinelim. En başta da söylediğimiz gibi, şu anda piyasada Python iki farklı seri halinde geliştiriliyor. Bunlardan birinin 2.x serisi, öbürünün de 3.x serisi olduğunu biliyoruz. Python’ın 2.x serisinde Türkçe karakterlerin gösterimi ile ilgili çok ciddi problemler vardı. Örneğin Python’ın 2.x serisinde şöyle bir kod yazamıyorduk:
print("Günaydın Şirin Baba!")
Bu kodu bir dosyaya kaydedip, Python’ın 2.x serisine ait bir sürümle çalıştırmak istediğimizde Python bize şöyle bir hata mesajı veriyordu:
SyntaxError: Non-ASCII character '\xc3' in file
test.py on line 1, but no encoding declared;
see http://www.python.org/peps/pep-0263.html for details
Bunun sebebi, Python’ın 2.x sürümlerinde ASCII adlı kodlama biçiminin kullanılıyor olmasıdır. Zaten hata mesajına baktığımızda da, Python’ın ASCII olmayan karakterlerin varlığından şikayet ettiğini görüyoruz.
Yukarıdaki kodların çalışabilmesi için programımıza şöyle bir ekleme yapmamız gerekiyordu:
# -*- coding: utf-8 -*-
print("Günaydın Şirin Baba!")
Buradaki ilk satıra dikkat edin. Bu kodlarla yaptığımız şey, Python’ın ASCII adlı kodlama biçimi yerine UTF-8 adlı kodlama biçimini kullanmasını sağlamaktır. ASCII adlı kodlama biçimi Türkçe karakterleri gösteremez, ama UTF-8 adlı kodlama biçimi Türkçe karakterleri çok rahat bir şekilde gösterebilir.
Kodlama biçimlerinden, ileride ayrıntılı bir şekilde söz edeceğiz. O yüzden bu anlattıklarımızda eğer anlamadığınız yerler olursa bunlara takılmanıza gerek yok.
Python’ın 3.x serisinin gelişi ile birlikte Python’da öntanımlı olarak ASCII yerine UTF-8 kodlama biçimi kullanılmaya başlandı. Dolayısıyla yazdığımız programlara
Kod:
# -*- coding: utf-8 -*-
satırını eklememize gerek kalmadı. Çünkü zaten Python UTF-8 kodlama biçimini öntanımlı olarak kendisi kullanıyor. Ama eğer UTF-8 dışında başka bir kodlama biçimine ihtiyaç duyarsanız yine bu satırdan yararlanabilirsiniz.
Örneğin GNU/Linux dağıtımlarının geleneksel olarak UTF-8 kodlama biçimi ile arası iyidir. Dolayısıyla eğer GNU/Linux üzerinde Python programları geliştiriyorsanız bu satırı hiç yazmadan bir ömür geçirebilirsiniz. Ama Windows işletim sistemleri UTF-8‘i desteklemekle birlikte, bu destek GNU/Linux’taki kadar iyi değildir. Dolayısıyla zaman zaman Windows’ta UTF-8 dışında başka bir kodlama biçimini kullanmanız gerekebilir. Örneğin yazdığınız bir programda Türkçe karakterleri göremiyorsanız, programınızın ilk satırını şöyle düzenleyebilirsiniz:
# -*- coding: cp1254 -*-
Burada UTF-8 yerine cp1254 adlı kodlama biçimini kullanmış oluyoruz. Windows işletim sisteminde cp1254 adlı kodlama biçimi UTF-8‘e kıyasla daha fazla desteklenir.
MS-DOS Komut Satırı Ayarları
Eğer yukarıda anlattığımız bütün ayarları doğru bir şekilde yapmanıza rağmen, özellikle MS-DOS komut satırında hala Türkçe karakterleri düzgün görüntüleyemiyorsanız, kullandığınız Windows sürümünün komut satırı, öntanımlı olarak Türkçe karakterleri gösteremeyen bir yazı tipine ayarlanmış olabilir. Dolayısıyla Türkçe karakterleri gösterebilmek için öncelikle uygun bir yazı tipi seçmeniz gerekir. Bunun için şu basamakları takip ediyoruz:
Komut satırını açıyoruz,
Açılan pencerenin başlık çubuğuna sağ tıklayarak, ‘özellikler’ menüsüne giriyoruz,
‘Yazı tipi’ sekmesinde yazı tipi olarak ‘Lucida Console’u (veya varsa ‘Consolas’ı) seçiyoruz,
‘Tamam’ düğmesine basıyoruz.
Eğer önünüze bir onay penceresi açılırsa, ‘Özellikleri aynı başlıkla ileride oluşturulacak pencereler için kaydet’ seçeneğini işaretleyip ‘Tamam’a bastıktan sonra çıkıyoruz.
Böylece MS-DOS komut satırı için Türkçe karakterleri gösterebilen bir yazı tipi belirlemiş olduk. Ancak bu, Türkçe karakterleri düzgün görüntülemeye yetmeyebilir. Eğer Türkçe karakterler hala düzgün görünmüyorsa, kullandığınız sistemde MS-DOS’un dil kodlaması Türkçe karakterleri görüntülemeye uygun olmayabilir. Türkçe karakterleri gösterebilen bir dil kodlaması belirlemek için komut satırında şu komutu verin:
chcp 1254
CP1254, Türkçe karakterleri de içeren bir dil kodlamasıdır. Bu komutu verdikten sonra artık Türkçe karakterleri düzgün görüntüleyebiliyor olmanız lazım.
Program Örnekleri
Yukarıda Python ve programlamaya ilişkin pek çok teknik bilgi verdik. Bunları öğrenmemiz, işlerimizi kuru kuruya ezberleyerek değil, anlayarak yapmamızı sağlaması açısından büyük önem taşıyordu. Ancak yukarıda pratiğe yönelik pek bir şey sunamadık. İşte bu bölümde pratik eksikliğimizi biraz olsun kapamaya dönük örnekler yapacağız.
Hatırlarsanız Python’la tanışmamızı sağlayan ilk örneğimiz ekrana basit bir “Merhaba Zalim Dünya!” cümlesi yazdırmaktı. Bu ilk örneği etkileşimli kabukta verdiğimizi hatırlıyorsunuz:
>>> "Merhaba Zalim Dünya!"
Ama artık programlarımızı dosyaya kaydetmeyi öğrendiğimize göre bu kodları etkileşimli kabuğa yazmak yerine bir dosyaya yazmayı tercih edebiliriz. Bu sayede yazdığımız kodlar kalıcılık kazanacaktır.
Hemen bir deneme yapalım. Boş bir metin belgesi açıp oraya şu satırı yazalım:
"Merhaba Zalim Dünya!"
Şimdi de bu dosyayı daha önce anlattığımız şekilde masaüstüne deneme.py adıyla kaydedip programımızı çalıştıralım.
Ne oldu? Programınız hiçbir çıktı vermeden kapandı, değil mi?
Hemen hatırlayacağınız gibi,
Kod:
print()
fonksiyonu içine alınmayan ifadelerin ekrana çıktı olarak verilebilmesi sadece etkileşimli kabuğa özgü bir durumdur. Programlarımızı dosyadan çalıştırırken,
Kod:
print()
fonksiyonu içine alınmayan ifadeler ekranda görünmeyecektir. Yukarıdaki örnek bu durumun bir göstergesidir. Dolayısıyla yukarıdaki ifadenin ekrana çıktı olarak verilebilmesi için o kodu şöyle yazmamız gerekiyor:
print("Merhaba Zalim Dünya!")
Programınızı bu şekilde tekrar çalıştırdığınızda şöyle bir çıktı alıyoruz:
Merhaba Zalim Dünya!
Bu oldukça basit bir örnekti. Şimdi biraz daha karmaşık bir örnek verelim.
Yine hatırlayacağınız gibi, önceki bölümlerden birinde aylık yol masrafımızı hesaplayan bir program yazmıştık.
Orada elimizdeki verilerin şunlar olduğunu varsaymıştık:
Cumartesi-Pazar günleri çalışmıyoruz.
Dolayısıyla ayda 22 gün çalışıyoruz.
Evden işe gitmek için kullandığımız vasıtanın ücreti 1.5 TL
İşten eve dönmek için kullandığımız vasıtanın ücreti 1.4 TL
Elimizdeki bu bilgilere göre aylık yol masrafımızı hesaplamak için de şöyle bir formül üretmiştik:
masraf = gün sayısı x (gidiş ücreti + dönüş ücreti)
Gelin şimdi yukarıdaki bilgileri kullanarak programımızı dosyaya yazalım:
gün = 22
gidiş_ücreti = 1.5
dönüş_ücreti = 1.4
masraf = gün * (gidiş_ücreti + dönüş_ücreti)
print(masraf)
Tıpkı öncekiler gibi, bu programı da masaüstüne deneme.py adıyla kaydedelim ve komut satırında masaüstünün bulunduğu konuma giderek
Kod:
python3 deneme.py
komutuyla programımızı çalıştıralım. Programı çalıştırdığımızda şöyle bir çıktı alıyoruz:
63.8
Programımız gayet düzgün çalışıyor. Ancak gördüğünüz gibi, elde ettiğimiz çıktı çok yavan. Ama eğer isterseniz yukarıdaki programa daha profesyonel bir görünüm de kazandırabilirsiniz. Dikkatlice inceleyin:
gün = 22
gidiş_ücreti = 1.5
dönüş_ücreti = 1.4
masraf = gün * (gidiş_ücreti + dönüş_ücreti)
print("-"*30)
print("çalışılan gün sayısı\t:", gün)
print("işe gidiş ücreti\t:", gidiş_ücreti)
print("işten dönüş ücreti\t:", dönüş_ücreti)
print("-"*30)
print("AYLIK YOL MASRAFI\t:", masraf)
Bu defa programımız şöyle bir çıktı verdi:
------------------------------
çalışılan gün sayısı : 22
işe gidiş ücreti : 1.5
işten dönüş ücreti : 1.4
------------------------------
AYLIK YOL MASRAFI : 63.8
Gördüğünüz gibi, bu kodlar sayesinde kullanıcıya daha ayrıntılı bilgi vermiş olduk. Üstelik elde ettiğimiz çıktı daha şık görünüyor.
Yukarıdaki kodlarda şimdiye kadar öğrenmediğimiz hiçbir şey yok. Yukarıdaki kodların tamamını anlayabilecek kadar Python bilgimiz var. Bu kodlarda çok basit parçaları bir araya getirerek istediğimiz çıktıyı nasıl elde ettiğimizi dikkatlice inceleyin. Mesela elde etmek istediğimiz çıktının görünüşünü güzelleştirmek için iki yerde şu satırı kullandık:
print("-"*30)
Böylece 30 adet - işaretini yan yana basmış olduk. Bu sayede elde ettiğimiz çıktı daha derli toplu bir görünüme kavuştu. Ayrıca kodlarımız içinde \t adlı kaçış dizisinden de yararlandık. Böylelikle ekrana basılan çıktılar alt alta düzgün bir şekilde hizalanmış oldu.
Bu arada, yukarıdaki kodlar sayesinde değişken kullanımının işlerimizi ne kadar kolaylaştırdığına da birebir tanık olduk. Eğer değişkenler olmasaydı yukarıdaki kodları şöyle yazacaktık:
print("-"*30)
print("çalışılan gün sayısı\t:", 22)
print("işe gidiş ücreti\t:", 1.5)
print("işten dönüş ücreti\t:", 1.4)
print("-"*30)
print("AYLIK YOL MASRAFI\t:", 22 * (1.5 + 1.4))
Eğer günün birinde mesela çalışılan gün sayısı değişirse yukarıdaki kodların iki farklı yerinde değişiklik yapmamız gerekecekti. Bu kodların çok büyük bir programın parçası olduğunu düşünün. Kodların içinde değer arayıp bunları tek tek değiştirmeye kalkışmanın ne kadar hataya açık bir yöntem olduğunu tahmin edebilirsiniz. Ama değişkenler sayesinde, sadece tek bir yerde değişiklik yaparak kodlarımızı güncel tutabiliriz. Mesela çalışılan gün sayısı 20‘ye düşmüş olsun:
gün = 20
gidiş_ücreti = 1.5
dönüş_ücreti = 1.4
print("-"*30)
print("çalışılan gün sayısı\t:", gün)
print("işe gidiş ücreti\t:", gidiş_ücreti)
print("işten dönüş ücreti\t:", dönüş_ücreti)
print("-"*30)
print("AYLIK YOL MASRAFI\t:", masraf)
Gördüğünüz gibi, sadece en baştaki gün adlı değişkenin değerini değiştirerek istediğimiz sonucu elde ettik.
Kendiniz isterseniz yukarıdaki örnekleri çeşitlendirebilirsiniz.
Gördüğünüz gibi, Python’da az da olsa işe yarar bir şeyler yazabilmek için çok şey bilmemize gerek yok. Sırf şu ana kadar öğrendiklerimizi kullanarak bile ufak tefek programlar yazabiliyoruz.
Python programlarını nasıl çalıştıracağımızı bir önceki bölümde anlatmıştık. Gerçekten de Python’da bir programı çalıştırmanın en temel yöntemi bir önceki bölümde anlattığımız gibidir. Ama bunlar Python programlarını çalıştırmanın tek yolu değildir. Python programlarını çalıştırmanın alternatif yöntemleri de bulunur. İşte biz bu bölümde farklı işletim sistemlerine göre bu alternatif yöntemlerden söz edeceğiz.
Dilerseniz önce GNU/Linux ile başlayalım.
GNU/Linux
Elimizde şöyle bir program olduğunu düşünelim:
kartvizit = """
İstihza Anonim Şirketi
Fırat Özgül
Tel: 0212 123 23 23
Faks: 0212 123 23 24
e.posta: kistihza@yahoo.com"""
print(kartvizit)
Bu programı çalıştırabilmek için, önce programımızı masaüstüne kartvizit.py adı ile kaydediyoruz. Sonra da, daha önce gösterdiğimiz şekilde
Kod:
python3 kartvizit.py
komutunu vererek programımızı çalıştırıyoruz.
Daha önce de söylediğimiz gibi, Python programlarını çalıştırmanın temel yöntemidir bu. Bu temel yöntemde, yazdığımız Python programını çalıştırabilmek için Python’ı başlatan komut + program dosyasının adı (
Kod:
python3 kartvizit.py
) yapısını kullanıyoruz.
Peki başa
Kod:
python3
gibi bir komut getirmeden, sadece program adını vererek (yani sadece
Kod:
kartvizit
komutuyla) programımızı çalıştıramaz mıyız? Elbette çalıştırabiliriz. Ancak bunun için programımız üzerinde bazı değişiklikler yapmamız gerekiyor. Gelin bu değişikliklerin neler olduğuna bakalım.
Programları Sadece İsmi ile Çalıştırmak
Elimizdeki programa tekrar bir bakalım:
kartvizit = """
İstihza Anonim Şirketi
Fırat Özgül
Tel: 0212 123 23 23
Faks: 0212 123 23 24
e.posta: kistihza@yahoo.com"""
print(kartvizit)
Programımızın adının kartvizit.py olduğunu varsayarsak, bu programı
Kod:
python3 kartvizit.py
komutuyla çalıştırabileceğimizi biliyoruz. Ama şimdi biz bu programı komut satırında sadece
Kod:
kartvizit
komutunu vererek çalıştıracağız.
Dediğimiz gibi, programımızı sadece
Kod:
kartvizit
gibi bir komutla çalıştırabilmek için programımız üzerinde bazı değişiklikler yapmamız gerekiyor.
Peki nedir bu değişiklikler?
Dedik ki programımızın adı kartvizit.py. Şimdi ilkin programımızın adını kartvizit olarak değiştirelim. Yani uzantısını silelim.
Daha önce de söylediğimiz gibi, GNU/Linux’ta dosyalar üzerinde öntanımlı olarak çalıştırma yetkisine sahip değiliz. Yani o dosya bir program da olsa, bu programı çalıştırabilmemiz için, program dosyasını çalıştırma yetkisine sahip olmamız gerekiyor.
Kod:
chmod
adlı bir sistem komutu yardımıyla gereken bu çalıştırma yetkisini nasıl alabileceğimizi öğrenmiştik:
sudo chmod +x kartvizit
Kod:
chmod
komutunun bir Python komutu olmadığını biliyorsunuz. Bu komut bir sistem komutudur. Dolayısıyla Python’ın etkileşimli kabuğunda değil, işletim sisteminin komut satırında çalıştırılır.
Program dosyasını çalıştırabilmemiz için gereken yetkileri elimize aldık. Ama yapmamız gereken birkaç işlem daha var.
Öncelikle program dosyamızı açarak ilk satıra şu ibareyi ekleyelim:
#!/usr/bin/python3
Yani programımız tam olarak şöyle görünsün:
#!/usr/bin/python3
çıktısında görünen dizinlerden herhangi birinin içine kopyalayalım. Mesela /usr/bin dizini bu iş için en uygun yerdir:
sudo cp kartvizit /usr/bin/kartvizit
Artık komut satırında sadece
Kod:
kartvizit
komutu vererek programımızı çalıştırabiliriz.
Eğer kullandığımız sistemde root haklarına sahip değilsek, /usr/bin dizinine herhangi bir şey kopyalayamayız. Böyle bir durumda $HOME dizini altında bin adlı bir dizin oluşturup, daha sonra bu dizini YOL’a ekleyebilir, programınızı da bu $HOME/bin dizini içine atabiliriz.
Peki, kodların en başına yerleştirdiğimiz
Kod:
#!/usr/bin/python3
satırı ne anlama geliyor?
Şöyle düşünün: Bir Python programı yazdınız. Bu programı
Kod:
python3 kartvizit.py
gibi bir komut ile çalıştırdığınızda bunun bir Python programı olduğu ve bu programın da Python tarafından çalıştırılacağı anlaşılıyor. Ancak baştaki python3 ifadesini kaldırdığımızda işletim sistemi bu programla ne yapması gerektiğine karar veremez. İşte en başa yerleştirdiğimiz
Kod:
#!/usr/bin/python3
satırı yazdığımız kodların birer Python kodu olduğunu ve bu kodların da /usr/bin/ dizini altındaki python3 adlı program ile çalıştırılacağını gösteriyor.
GNU/Linux sistemlerinde Python’ın çalıştırılabilir dosyası genellikle /usr/bin dizini altındadır. Dolayısıyla yukarıdaki satırı şöyle yazabiliyoruz:
#!/usr/bin/python3
Böylece işletim sistemimiz Python’ı /usr/bin dizini altında arayacak ve yazdığımız programı Python’la çalıştırması gerektiğini anlayacaktır.
Ancak bazı GNU/Linux sistemlerinde, Python’ın nasıl kurulduğuna bağlı olarak Python’ın çalıştırılabilir dosyası başka bir dizinin içinde de olabilir. Mesela eğer Python programlama dilini yetkisiz kullanıcı olarak ev dizininin altındaki python adlı bir dizin içine kurduysak, çalıştırılabilir dosya $HOME/python/bin/ dizini altında olacaktır. Bu durumda, çalıştırılabilir dosya /usr/bin altında bulunamayacağı için, sistemimiz yazdığımız programı çalıştıramaz.
Python’ın çalıştırılabilir dosyasının her sistemde aynı dizin altında bulunmama ihtimalinden ötürü yukarıdaki gibi sabit bir dizin adı vermek iyi bir fikir olmayabilir. Bu tür sistem farklılıklarına karşı önlem olarak GNU/Linux sistemlerindeki env adlı bir betikten yararlanabiliriz. /usr/bin dizini altında bulunduğunu varsayabileceğimiz bu env betiği, YOL dizinlerini tek tek tarayarak, Python’ın hangi YOL dizini içinde olduğunu bulabilir. Böylece yazdığımız bir programın, Python’ın /usr/bin dizini haricinde bir konuma kurulduğu sistemlerde çalıştırılması konusunda endişe etmemize gerek kalmaz. Bunun için programımızın en başına eklediğimiz satırı şöyle yazıyoruz:
#/usr/bin/env python3
Yani programımız tam olarak şöyle görünüyor:
#!/usr/bin/env python3
İlk satırı bu şekilde yazmamız sayesinde Python YOL içinde nereye kurulmuş olursa olsun kolaylıkla tespit edilebilecektir.
Uzun lafın kısası,
Kod:
#!/usr/bin/python3
yazdığımızda sisteme şu emri vermiş oluyoruz: ‘Python’ı /usr/bin dizini içinde ara!’
Kod:
#!/usr/bin/env python3
yazdığımızda ise şu emri: ‘Python’ı YOL içinde nereye saklandıysa bul!’
Eğer bu satırı
Kod:
#!/usr/bin/python3
şeklinde yazarsanız ve eğer kullandığımız sistemde Python’ın çalıştırılabilir dosyası /usr/bin/ dizini altında değilse, programınızı çalıştırmak istediğimizde şuna benzer bir hata çıktısı alırız:
bash: deneme: /usr/bin/python3: bad interpreter: No such file or directory
Böyle bir hata almamak için, o satırı
Kod:
#!/usr/bin/env python3
şeklinde yazmaya özen gösteriyoruz. Böylece Python YOL içindeki dizinler arasında nereye kurulmuş olursa olsun işletim sistemimiz Python’ı tespit edebiliyor.
Bu noktada size şöyle bir soru sormama izin verin: Acaba Python’ın python3 adıyla değil de, mesela python34 (veya
Kod:
py3
) adıyla kurulu olduğu sistemlerde
Kod:
#!/usr/bin/env python3
satırı görevini yerine getirebilir mi?
Elbette getiremez...
Çünkü bu satır yardımıyla biz sistemde python3 adlı bir dosya aratıyoruz aslında. Ama eğer sistemde Python3’ü çalıştıran dosyanın adı ‘python3’ değil de, mesela ‘py3’ ise tabii ki o satır bir işe yaramayacaktır. Programımızın böyle bir sistemde çalışabilmesi için bu satırın
Kod:
#!/usr/bin/env
Kod:
python3.4
şeklinde yazılması gerekir.
Bu manzara karşısında aklınıza şöyle bir soru gelmiş olabilir:
Alıntı:GNU/Linux sistemlerinde Python3’ü çalıştırmanın standart ve tek bir yolu yok. Çünkü Python3’ü çalıştıran dosyanın adı farklı dağıtımlarda farklı ada sahip olabiliyor. Böyle bir durumda ben yazdığım bir Python programının bütün GNU/Linux dağıtımlarında çalışabileceğinden nasıl emin olacağım?
Bu sorunun cevabı, ‘Emin olamazsınız,’ olacaktır...
GNU/Linux’ta sadece Python için değil başka programlama dilleriyle yazılmış programlar için de aynı sorun geçerlidir. Çünkü GNU/Linux dağıtımları arasında bir uyumluluktan bahsetmek mümkün değil. Sistem farklılıklarından ötürü, bir GNU/Linux dağıtımında çalışan bir program başka bir GNU/Linux dağıtımında çalışmayabilir.
GNU/Linux işletim sistemine yönelik programlar yazan bir Python programcısı olarak sizin sorumluluğunuz programınızı yazıp bitirmekten ibarettir. Bu programın herhangi bir GNU/Linux dağıtımında çalışabilmesi o dağıtımın geliştiricilerinin sorumluluğu altındadır. Yani mesela siz kendiniz Ubuntu dağıtımını kullanıyorsanız programlarınızı Ubuntu’yu temel alarak yazarsınız. Burada sizin sorumluluğunuz, yazdığınız programın Ubuntu altında çalışmasını sağlamaktan ibarettir. Aynı programın mesela Pardus altında çalışabilmesi Pardus’a uygun paket yazan geliştiricilerin görevidir. Tabii ki siz isterseniz programınız için hem Ubuntu paketini (DEB), hem de Pardus paketini (PISI) ayrı ayrı hazırlayabilirsiniz. Ama elbette bütün dağıtımlara uygun paketleri tek tek hazırlamanız mümkün değil.
Ayrıca programlarınızın kaynak kodlarını yayımlarken, programın nasıl çalıştırılacağına ilişkin ayrıntılı açıklamaları README yada BENİOKU adlı bir dosya içine yazabilirsiniz. Böylece farklı dağıtımların kullanıcıları, yazdığınız programı kendi dağıtımlarında nasıl çalıştırmaları gerektiği konusunda bir fikir sahibi olabilir. Kullanıcılar, yazdığınız açıklamalardan yola çıkarak programınızı çalıştırabilirse ne âlâ! Ama eğer çalıştıramazsa, bu doğrudan sizin sorununuz değil. Böyle bir durumda zaten GNU/Linux kullanıcıları da sizi suçlamayacak, kendi kullandıkları dağıtımın geliştiricilerinden sizin yazdığınız program için paket isteğinde bulunacaktır.
Programları Çift Tıklayarak Çalıştırmak
GNU/Linux işletim sistemlerinde, özellikle grafik bir arayüze sahip olmayan, yani yalnızca komut satırı üzerinde çalışabilen bir programı başlatmak için program simgesi üzerine çift tıklamak pek uygulanan bir yol değildir. Eğer bir programın grafik arayüzü varsa .desktop dosyaları veya menü girdileri aracılığıyla programa ulaşabilirsiniz. Ama komut satırı üzerinden çalışan uygulamalar genellikle komut satırı üzerinden çalıştırılır. Dolayısıyla elimizde şöyle bir program olduğunu varsayarsak:
kartvizit = """
İstihza Anonim Şirketi
Fırat Özgül
Tel: 0212 123 23 23
Faks: 0212 123 23 24
e.posta: kistihza@yahoo.com"""
print(kartvizit)
Bu program GNU/Linux üzerinde komut satırı aracılığıyla şu komut verilerek çalıştırılır:
python3 kartvizit.py
Veya eğer isterseniz, daha önce gösterdiğimiz yöntemleri uygulayarak, programı yalnızca ismiyle de çalıştırabilirsiniz.
GNU/Linux dağıtımlarında, yalnızca komut arayüzüne sahip bir programı çift tıklayarak çalıştırmanın önündeki bir başka engel, bütün GNU/Linux dağıtımlarının, simge üzerine çift tıklamaya aynı tepkiyi vermemesidir. Ama teorik olarak, GNU/Linux’ta komut satırı üzerinde çalışabilen bir programın dosyası üzerine çift tıklayarak çalıştırabilmek için şu yolu takip edebilirsiniz:
Öncelikle programımızın ilk satırına, programımızı hangi Python sürümü ile çalıştırmak istediğimizi belirten şu kodu ekliyoruz:
#!/usr/bin/env python3
Daha sonra, program kodlarının en son satırına da şu kodu ekliyoruz:
input()
Eğer bu satırı eklemezseniz, program dosyasına çift tıkladığınızda programınız çok hızlı bir şekilde açılıp kapanır. Bunu engellemek için yukarıda gördüğümüz bu
Kod:
input()
adlı fonksiyonu kullanıyoruz. Bu fonksiyonu eklememiz sayesinde programımız açıldıktan sonra kapanmayacak, kapanmak için bizim Enter düğmesine basmamızı bekleyecektir.
Bu arada bu
Kod:
input()
fonksiyonuna şimdilik takılmayın. Birkaç bölüm sonra bu fonksiyonu da bütün ayrıntılarıyla inceleyeceğiz.
Programımızın son hali şöyle:
#!/usr/bin/env python3
Bütün bu işlemlerin ardından programımızı çalıştırılabilir olarak işaretliyoruz:
chmod +x kartvizit.py
Artık program dosyası üzerine çift tıklayarak programımızı çalıştırmayı deneyebiliriz. Ama dediğimiz gibi, farklı GNU/Linux dağıtımlarında çift tıklama işlemi farklı yanıtlar verebilir. O yüzden komut satırı uygulamalarını çift tıklayarak başlatmak pek tercih edilen bir yöntem değildir.
GNU/Linux işletim sistemi altında bir Python programını çalıştırmanın alternatif yöntemlerini öğrendiğimize göre, aynı işlemi Windows altında nasıl yapabileceğimizi tartışmaya geçebiliriz. Bu arada siz GNU/Linux kullanıcıları da yukarıda verdiğimiz bilgileri iyice sindirebilmek için kendi kendinize örnek programlar yazıp bunları farklı şekillerde çalıştırmayı deneyebilirsiniz.
Bu arada, her zaman söylediğimiz gibi, yukarıda anlatılanları ezberlemeye çalışmak yerine, neyi neden yaptığımızı anlamaya çalışmak çok daha faydalı bir iş olacaktır. Örneğin bir programı adıyla çağırabilmek için bütün o işlemleri yaparken nereye varmaya çalışıyoruz? Amacımız ne? Her bir adım hangi maksada yönelik? Mesela programımıza neden çalıştırma izni veriyoruz? env betiği ne işe yarar? Programımızın konumunu neden değiştiriyoruz?
Yukarıda anlatılanları okurken kendinize bu tür sorular sorup cevaplamanız, süreci ezberlemek yerine sürecin mantığını kavramanızı sağlayacaktır. Unutmayın, buradaki bilgiler sadece Python programları için geçerli değildir. Burada sözü edilen program çalıştırma mantığı, etrafta gördüğünüz bütün programlar için geçerlidir. Dolayısıyla, eğer buradaki bilgileri hakkıyla öğrenirseniz, bir taşla iki kuş vurmuş olursunuz.
Windows
Bir önceki bölümde, yazdığımız bir Python programını IDLE üzerinden nasıl çalıştırabileceğimizi gördük. Eğer IDLE adlı metin düzenleyiciyi kullanıyorsanız, Python programlarınızı çalıştırmak için muhtemelen çoğunlukla bu yöntemi kullanacaksınız. Ama elbette bir Python programını çalıştırmanın tek yöntemi bu değildir. İşte biz bu bölümde, Windows’ta Python programlarını çalıştırmanın alternatif yöntemlerinden söz edeceğiz.
Programları Komut Satırından Çalıştırmak
Python programlarınızı yazmak için kullandığınız metin düzenleyiciler, tıpkı IDLE’da olduğu gibi, F5 benzeri kısayollar aracılığıyla programlarınızı çalıştırmanızı sağlayabilir. Ama bazı metin düzenleyicilerde bu tür kolaylıklar bulunmaz. Yazdığınız Python programlarını her koşulda çalıştırabilmek için, bu programları komut satırı üzerinden nasıl çalıştıracağınızı da bilmeniz gerekir. Bunun için şu adımları takip ediyoruz.
Öncelikle daha önce öğrendiğimiz yöntemlerden birini kullanarak MS-DOS komut satırına ulaşın.
MS-DOS komut satırına ulaştıktan sonra, daha önce öğrendiğimiz şekilde, komut satırı üzerinden masaüstüne, yani dosyayı kaydettiğiniz yere gelin. (Bu işlemin nasıl yapılacağını hatırladığınızı varsayıyorum.)
Masaüstüne geldikten sonra şu komutu vererek programınızı çalıştırabilirsiniz:
python program_adı.py
Elbette burada Python’ın etkileşimli kabuğuna ulaşmak için hangi komutu kullanıyorsanız onu kullanacaksınız. Ben sizin Python’ın etkileşimli kabuğuna ulaşmak için
Kod:
python
komutunu kullandığınızı varsaydım.
Yukarıdaki gibi
Kod:
python
komutunu vermek yerine, aynı işlev için önceki derslerde öğrendiğimiz ‘py’ adlı betiği de kullanabilirsiniz:
py program_adı.py
Unutmayın ki ben burada
Kod:
py
komutunun Python3’ü başlattığını varsayıyorum. Eğer sisteminizde hem Python2 hem de Python3 kurulu ise
Kod:
py
komutunu tek başına kullandığınızda Python2 de başlıyor olabilir.
Dolayısıyla farklı Python sürümlerinin bir arada bulunduğu sistemlerde programınızı Python3 ile çalıştırabilmek için yukarıdaki komutu şu şekilde vermeniz de gerekebilir:
py -3 program_adı.py
py adlı betiği çalıştırırken, istediğiniz Python sürümünün çalışmasını temin etmek için, yukarıda gösterdiğimiz şekilde sürüm numarasını da belirtmenin yanısıra, yazdığınız bir programın istediğiniz Python sürümü ile çalışmasını sağlamanın bir yolu daha var:
Bunun için öncelikle boş bir metin düzenleyici açıp şu kodları yazın:
#! python3
print("Merhaba Zalim Dünya!")
Dosyayı zalim.py adıyla kaydedip şu komutu verin:
py zalim.py
Programınız normal bir şekilde çıktı verir. Şimdi aynı kodları bir de şöyle yazın:
#! python2
print("Merhaba Zalim Dünya!")
Bu defa programınız çalıştırma esnasında hata verecektir. Peki neden?
Yazdığımız programların ilk satırlarına dikkat edin. İlk programda şöyle bir satır yazdık:
#! python3
İşte bu satır, Python programımızı Python’ın 3.x sürümlerinden biri ile çalıştırmamızı sağladı. Python’ın 3.x sürümlerinde öntanımlı karakter kodlama biçimi UTF-8 olduğu için (yani Python3’te Türkçe desteği daha kuvvetli olduğu için) Merhaba Zalim Dünya karakter dizisindeki Türkçe karakterler düzgün bir şekilde gösterilebildi ve programımız düzgün bir şekilde çalıştı.
İkinci programda ise şu şatırı kullandık:
#! python2
Bu satır ise programımızı Python’ın 2.x sürümlerinden biri ile çalıştırmamızı sağlıyor. Python’ın 2.x sürümlerinde öntanımlı karakter kodlama biçimi ASCII olduğundan, Türkçe karakterler içeren bir programı çalıştırabilmek için ilave işlemler yapmamız gerekir. Yukarıdaki program dosyası bu ilave işlemleri içermediği için programımız Python’ın 2.x sürümlerinde hata verecektir.
Bu satırların oluşturduğu etkiyi daha net bir şekilde görebilmek için şu kodları da kullanabilirsiniz:
#! python3
import sys
print(sys.version)
Hatırlarsanız,
Kod:
print()
fonksiyonunu anlatırken Python’da ‘modül’ diye bir şey olduğundan söz etmiş, örnek olarak da sys adlı modülden bahsetmiştik. Orada bu sys modülü içindeki stdout adlı bir değişkeni incelemiştik. Burada da yine sys modülünü görüyoruz. Bu defa bu modülün içindeki version adlı bir değişkeni kullandık. İsterseniz etkileşimli kabuğu açıp şu komutları vererek kendi kendinize denemeler yapabilirsiniz:
>>> import sys
>>> sys.version
Gördüğünüz gibi bu değişken, kullandığımız Python’ın sürümünü gösteriyor.
Burada ilk satır yardımıyla sys modülünü içe aktardığımızı, ikinci satır yardımıyla da bu modül içindeki version adlı değişkeni kullandığımızı biliyorsunuz. İşte yukarıda gösterdiğimiz program örneğinde de bu sys modülünü ve bunun içindeki version değişkenini kullanıyoruz:
#! python3
import sys
print(sys.version)
Şimdi bu programı kaydedip çalıştırın. Şuna benzer bir çıktı alacaksınız:
'Python 3.4.3 (default, 04.09.2015, 12:24:55)
[GCC 4.4.7 20120313 (Red Hat 4.4.7-3)] on linux'
Gördüğünüz gibi, elde ettiğimiz şey bir karakter dizisi. Bu karakter dizisinin ilk satırlarına bakarak programımızın Python’ın 3.4.3 sürümü ile çalışmış olduğunu anlıyoruz.
Aynı kodları bir de şöyle yazalım:
#! python2
import sys
print(sys.version)
Bu da bize şöyle bir çıktı verecek:
'Python 2.7.10 (default, 04.09.2015, 12:24:55)
[GCC 4.4.7 20120313 (Red Hat 4.4.7-3)] on linux2'
Demek ki bu defa programımız Python’ın 2.7.10 sürümü ile çalışmış...
Elbette ben yukarıdaki kodları anlatırken, sisteminizde Python3 ile birlikte Python2’nin de kurulu olduğunu varsaydım. Eğer sisteminizde Python2 kurulu değilse, aldığınız hata mesajının sebebi, doğal olarak, kodlarda Türkçe karakterlerin bulunması değil, Python2’nin kurulu olmaması olacaktır...
Gördüğünüz gibi, programlarımızın ilk satırına eklediğimiz bu kodlar, programlarımızı çalıştırmak istediğimiz sürümleri kontrol etmemizi sağlıyor. Bu satırları kullanarak, programlarımızın istediğimiz Python sürümüyle çalışmasını temin edebiliriz.
Hatırlarsanız buna benzer bir satırın GNU/Linux işletim sistemleri için de geçerli olduğunu söylemiştik. GNU/Linux’ta bu satırı şöyle yazıyorduk:
#!/usr/bin/env python3
Eğer Windows kullanıcıları olarak, Windows’ta yazdığınız programların GNU/Linux dağıtımları altında da çalışmasını istiyorsanız Windows’ta
Kod:
#! python3
şeklinde yazdığınız satırı tıpkı GNU/Linux’ta olduğu gibi
Kod:
#!/usr/bin/env python3
şeklinde yazmayı da tercih edebilirsiniz. Çünkü Python Windows’ta yazdığınız satırın sadece python3 kısmıyla ilgilenecek, dolayısıyla
Kod:
#!/usr/bin/env python3
şeklinde yazdığınız kod hem Windows’ta hem de GNU/Linux’ta çalışacaktır.
Programları Sadece İsmi ile Çalıştırmak
Peki yazdığımız programı, başa
Kod:
python
gibi bir komut getirmeden çalıştırma imkanımız var mı?
Python Windows’a kurulurken kendini kütüğe (Registry) kaydeder. Dolayısıyla Windows Python programlarını nasıl çalıştırması gerektiğini bilir. Bu sayede Windows üzerinde yazdığımız Python programlarını, programın bulunduğu dizin içinde sadece ismini kullanarak çalıştırmamız da mümkündür. Yani yazdığımız programı masaüstüne kaydettiğimizi varsayarsak, masaüstüne geldikten sonra şu komutu vererek programımızı çalıştırma imkanına sahibiz:
program_adı.py
Tıpkı bir önceki konuda da anlattığımız gibi, programımızı hangi Python sürümünün çalıştıracağını yine program dosyasının ilk satırına yazacağımız
Kod:
#! python3
gibi bir kod yardımıyla kontrol edebiliriz.
Burada hemen şöyle bir soru akla geliyor: Windows’ta mesela Notepad ve Calc gibi programları, hiç .EXE uzantısını belirtmeden doğrudan isimleriyle çağırabiliyoruz. Yani örneğin MS-DOS komut satırında
Kod:
notepad
komutu verirsek Notepad programı,
Kod:
calc
komutu verirsek de Hesap Makinesi programı çalışmaya başlayacaktır. Ama mesela deneme.py adlı programımızı çalıştırabilmek için .PY uzantısını da belirtmemiz gerekti. Peki bu durumun nedeni nedir?
Windows’ta PATHEXT adlı bir çevre değişkeni vardır. Bu değişken, sistemin çalıştırılabilir kabul ettiği uzantıları tutar. MS-DOS ekranında şu komutu verelim:
echo %PATHEXT%
Buradan şu çıktıyı alıyoruz:
.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH
Windows’ta eğer bir program yukarıda görülen uzantılardan birine sahipse çalıştırılabilir olarak kabul edilecektir. Gördüğünüz gibi, EXE de bu uzantılardan biri. Dolayısıyla bu uzantıya sahip bir dosyayı, uzantısını belirtmeden de çağırabiliyoruz. Eğer isterseniz bu listeye .PY uzantısını da ekleyebilirsiniz. Bunun için şu işlemleri yapabilirsiniz:
Alıntı:
Başlat > Denetim Masası > Sistem ve Güvenlik > Sistem > Gelişmiş Sistem Ayarları yolunu takip edin.
Açılan pencerede ‘Gelişmiş’ sekmesine tıklayın ve ‘Ortam Değişkenleri’ düğmesine basın.
‘Sistem Değişkenleri’ bölümünde PATHEXT öğesini bulup buna çift tıklayın.
En son girdi olan .WSH‘den sonra ;.PY girdisini ekleyin.
TAMAM‘a basıp çıkın.
Böylece artık .PY uzantılı dosyaları da, uzantı belirtmeden çalıştırabilirsiniz. Ancak bu komutun işe yarayabilmesi için, MS-DOS’ta o anda programın bulunduğu dizin içinde olmamız gerek. Yani eğer programınız Belgeler dizini içinde ise ve siz de MS-DOSta C:/Users/Kullanici_adi/Desktop dizini altındaysanız bu komut bir işe yaramayacaktır. Eğer yazdığınız programı konum farketmeksizin her yerden çağırabilmek istiyorsanız, programınızın bulunduğu dizini daha önce anlattığımız şekilde YOL’a eklemelisiniz.
Programları Çift Tıklayarak Çalıştırmak
PY uzantılı Python programları üzerine çift tıklanarak da bu programlar çalıştırılabilir. Ama öncelikle şunu söylemeliyiz: Python programları geliştirirken takip etmemiz gereken yöntem, program simgeleri üzerine çift tıklayarak bunları çalıştırmak değil, bu programları komut satırından çalıştırmak olmalıdır. Çünkü programları çift tıklayarak çalıştırdığınızda programların hangi hataları verdiğini göremezsiniz. Program geliştirirken, programınızın verdiği olası hata ve uyarıları görebilmek ve bunları düzeltebilmek için programlarınızı komut satırından çalıştırmalısınız. Dolayısıyla program geliştirirken simge üzerine çift tıklayarak bunları çalıştırmak tamamen anlamsızdır.
Ama yine de en azından bir Python programının üzerine çift tıklanarak nasıl çalıştırılabileceğini öğrenmeniz için biz burada bu konuyu da ele alacağız.
Şimdi elimizde şöyle bir program olsun:
kartvizit = """
İstihza Anonim Şirketi
Fırat Özgül
Tel: 0212 123 23 23
Faks: 0212 123 23 24
e.posta: kistihza@yahoo.com"""
print(kartvizit)
Kullandığımız işletim sisteminde birden fazla Python sürümü kurulu olabilir. O yüzden, programımızın hangi Python sürümüyle çalışmasını istiyorsak ona uygun şekilde bir ilk satır yazmamız gerekiyor öncelikle. Biz programımızı Python3 ile çalıştırmak istediğimizi varsayalım ve ilk satıra şunu ekleyelim:
#! python3
Böylece Windows, programımızı hangi Python sürümü ile çalıştırması gerektiğini bilecek.
Şimdi program simgesi üzerine iki kez tıklayalım.
Biz bu programın simgesi üzerine çift tıkladığımızda siyah bir komut ekranının çok hızlı bir şekilde açılıp kapandığını görürüz. Aslında programımız çalışıyor, ama programımız yapması gereken işi yaptıktan hemen sonra kapandığı için biz program penceresini görmüyoruz. Programımızın çalıştıktan sonra hemen kapanmamasını sağlayacak bir yol bulmamız gerekiyor. Bunun için dosyamızın en sonuna bir adet
Kod:
input()
satırı ekleyeceğiz. Yani programımız şöyle görünecek:
#! python3
Şimdi programı bu şekilde kaydedip simgesi üzerine çift tıkladığımızda program penceresi açılacak ve biz Enter düğmesine basana kadar da açık kalacaktır. Burada şimdilik
Kod:
input()
fonksiyonunun ne olduğuna takılmayın. Birkaç bölüm sonra bu fonksiyonu bütün ayrıntılarıyla inceleyeceğiz.
Bu arada, elbette en sona eklediğimiz
Kod:
input()
satırının görevini yerine getirebilmesi için, ondan önce gelen bütün kodların doğru ve hatasız olması gerekiyor. Eğer bu satırdan önceki kısımda herhangi bir hata yapmışsanız, programın akışı hiçbir zaman
Kod:
input()
satırına ulaşmayacağı için yine siyah bir komut ekranının hızla yanıp söndüğünü görürsünüz. O yüzden programlarınızı çift tıklayarak çalıştırmadan önce, komut satırında test ederek hatasız olduğundan emin olmalısınız.
Programları .EXE Haline Dönüştürmek
Şimdiye kadar anlattıklarımızdan anlayacağınız gibi, bir Python programını çalıştırabilmek için Python programlama dilinin bilgisayarımızda kurulu olması gerekiyor. Bir program yazdıktan sonra o programı dağıtırken kullanıcılarınızdan Python programlama dilini de kurmalarını isteyebilirsiniz. Ama eğer bilgisayarlarında Python programlama dili kurulu olmayanların da Python ile yazdığınız programları çalıştırabilmelerini istiyorsanız, bu programı çeşitli araçlar yardımıyla bir .EXE dosyası haline getirmeniz de mümkündür. Böylelikle bilgisayarında Python kurulu olmayan kişiler de yazdığınız programı çalıştırma imkanına sahip olabilir.
cx_Freeze
Python3 programlarını .EXE haline dönüştürmek için cx_Freeze adlı bir programdan yararlanacağız.
Bu programı kurmak için şu komutu verin:
pip3 install cx_Freeze
Bu komut başarıyla tamamlandıktan sonra, önceki derslerde öğrendiğimiz şekilde, C:\Python34\Scripts adlı dizini yola (PATH) ekleyin.
Daha sonra işletim sisteminizde bu C:\Python34\Scripts adlı dizinin içine girin. Bu konumdayken bir komut satırı açın ve şu komutu verin:
python3 cxfreeze-postinstall
Tabii ben burada sizin Python’ı çalıştırmak için
Kod:
python3
komutunu kullandığınızı varsaydım. Eğer Python’ı çalıştırmak için başka bir komut kullanıyorsanız, yukarıda o komutun adını yazmalısınız.
Eğer cx_Freeze programını kuramazsanız http://www.istihza.com/forum adresinden yardım isteyebilirsiniz.
cx_Freeze Nasıl Kullanılır?
cx_Freeze adlı programı indirip kurduktan sonra, kendi yazdığınız Python programının bulunduğu dizin altında şu komutu verin:
cxfreeze kartvizit.py
Bu komutu verdiğinizde dist adlı bir dizinin oluştuğunu göreceksiniz. Şimdi bu dizinin içine girin. İşte orada kartvizit.exe adlı dosya, sizin yazdığınız Python programının .EXE‘ye dönüştürülmüş hali. Programınızı dağıtırken sadece .exe uzantılı dosyayı değil, dist adlı dizini bütün içeriğiyle birlikte dağıtacaksınız.
Dizin adını kendiniz sonradan elle değiştirebileceğiniz gibi, daha .EXE dosyasını oluştururken de değiştirebilirsiniz. Bunun için yukarıdaki komutu şu şekilde verebilirsiniz:
cxfreeze kartvizit.py --install-dir=program_adı
Burada program_adı değerinin yerine, program dizininin adının ne olmasını istiyorsanız onu yazacaksınız.
Cxfreeze oldukça kapsamlı ve ayrıntılı bir programdır. Elbette yazdığınız programlar karmaşıklaştıkça, programınızı .EXE haline getirmek için yukarıdaki gösterdiğimiz
Kod:
cxfreeze
komutunu daha farklı parametrelerle çalıştırmanız gerektiğini göreceksiniz. Biz şimdilik sizi sadece cxfreeze adlı bu programın varlığından haberdar etmekle yetiniyoruz.
Bu noktaya kadar bütün işlerimizi Python’ın etkileşimli kabuğu üzerinden hallettik. Her ne kadar etkileşimli kabuk son derece kullanışlı bir ortam da olsa, bizim asıl çalışma alanımız değildir. Daha önce de dediğimiz gibi, etkileşimli kabuğu genellikle ufak tefek Python kodlarını test etmek için kullanacağız. Ama asıl programlarımızı tabii ki etkileşimli kabuğa değil, program dosyasına yazacağız.
Ne dedik? Özellikle küçük kod parçaları yazıp bunları denemek için etkileşimli kabuk mükemmel bir ortamdır. Ancak kodlar çoğalıp büyümeye başlayınca bu ortam yetersiz gelmeye başlayacaktır. Üstelik tabii ki yazdığınız kodları bir yere kaydedip saklamak isteyeceksiniz. İşte burada metin düzenleyiciler devreye girecek.
Python kodlarını yazmak için istediğiniz herhangi bir metin düzenleyiciyi kullanabilirsiniz. Hatta Notepad bile olur. Ancak Python kodlarını ayırt edip renklendirebilen bir metin düzenleyici ile yola çıkmak her bakımdan hayatınızı kolaylaştıracaktır.
Python kodlarınızı yazmak için Microsoft Word veya OpenOffice.Org OOWriter gibi, belgeleri ikili (binary) düzende kaydeden programlar uygun değildir. Kullanacağınız metin düzenleyici, belgelerinizi düz metin (plain text) biçiminde kaydedebilmeli.
Biz bu bölümde farklı işletim sistemlerinde, metin düzenleyici kullanılarak Python programlarının nasıl yazılacağını ve bunların nasıl çalıştırılacağını tek tek inceleyeceğiz.
Daha önce de söylediğimiz gibi, hangi işletim sistemini kullanıyor olursanız olun, hem Windows hem de GNU/Linux başlığı altında yazılanları okumalısınız.
Dilerseniz önce GNU/Linux ile başlayalım:
GNU/Linux
Eğer kullandığınız sistem GNU/Linux’ta Unity veya GNOME masaüstü ortamı ise başlangıç düzeyi için Gedit adlı metin düzenleyici yeterli olacaktır.
Eğer kullandığınız sistem GNU/Linux’ta KDE masaüstü ortamı ise Kwrite veya Kate adlı metin düzenleyicilerden herhangi birini kullanabilirsiniz. Şu aşamada kullanım kolaylığı ve sadeliği nedeniyle Kwrite önerilebilir.
İşe yeni bir Gedit belgesi açarak başlayalım. Yeni bir Gedit belgesi açmanın en kolay yolu Alt+F2 tuşlarına bastıktan sonra çıkan ekranda:
gedit
yazıp Enter düğmesine basmaktır.
Eğer Gedit yerine mesela Kwrite kullanıyorsanız, yeni bir Kwrite belgesi oluşturmak için Alt+F2 tuşlarına bastıktan sonra:
kwrite
komutunu vermelisiniz. Elbette kullanacağınız metin düzenleyiciye, komut vermek yerine, dağıtımınızın menüleri aracılığıyla da ulaşabilirsiniz.
Python kodlarımızı, karşımıza çıkan bu boş metin dosyasına yazıp kaydedeceğiz.
Aslında kodları metin dosyasına yazmakla etkileşimli kabuğa yazmak arasında çok fazla fark yoktur. Dilerseniz hemen bir örnek vererek ne demek istediğimizi anlatmaya çalışalım:
1. Boş bir Gedit ya da Kwrite belgesi açıyoruz ve bu belgeye şu kodları eksiksiz bir şekilde yazıyoruz:
tarih = "02.01.2012"
gün = "Pazartesi"
vakit = "öğleden sonra"
print(tarih, gün, vakit, "buluşalım", end=".\n")
2. Bu kodları yazıp bitirdikten sonra dosyayı masaüstüne randevu.py adıyla kaydedelim.
3. Sonra işletim sistemimize uygun bir şekilde komut satırına ulaşalım.
4. Ardından komut satırı üzerinden masaüstüne gelelim. (Bunun nasıl yapılacağını hatırlıyorsunuz, değil mi?)
5. Son olarak şu komutla programımızı çalıştıralım:
python3 randevu.py
Şöyle bir çıktı almış olmalıyız:
02.01.2012 Pazartesi öğleden sonra buluşalım.
Eğer bu çıktı yerine bir hata mesajı alıyorsanız bunun birkaç farklı sebebi olabilir:
Kodlarda yazım hatası yapmış olabilirsiniz. Bu ihtimali bertaraf etmek için yukarıdaki kodlarla kendi yazdığınız kodları dikkatlice karşılaştırın.
Kodlarınızı kaydettiğiniz randevu.py adlı dosyanın adını yanlış yazmış olabilirsiniz. Dolayısıyla
python3 randevu.py
komutu, var olmayan bir dosyaya atıfta bulunuyor olabilir.
python3 randevu.py
komutunu verdiğiniz dizin konumu ile randevu.py dosyasının bulunduğu dizin konumu birbirinden farklı olabilir. Yani siz randevu.py dosyasını masaüstüne kaydetmişsinizdir, ama
python3 randevu.py
komutunu yanlışlıkla başka bir dizin altında veriyor olabilirsiniz. Bu ihtimali ortadan kaldırmak için, önceki derslerde öğrendiğimiz yöntemleri kullanarak hangi dizin altında bulunduğunuzu kontrol edin. O anda içinde bulunduğunuz dizinin içeriğini listeleyerek, randevu.py dosyasının orada görünüp görünmediğini kontrol edebilirsiniz. Eğer program dosyanız bu listede görünmüyorsa, elbette
python3 randevu.py
komutu çalışmayacaktır.
Geçen derslerde anlattığımız şekilde Python3’ü kaynaktan root haklarıyla derlemenize rağmen, derleme sonrasında /usr/bin/ dizini altına python3 adlı bir sembolik bağ oluşturmadığınız için
python3
komutu çalışmıyor olabilir.
Eğer Python3’ü yetkisiz kullanıcı olarak derlediyseniz, $HOME/python/bin/ dizini altında hem
python3
adlı bir sembolik bağ oluşturmuş, hem de $HOME/python/bin/ dizinini YOL’a (PATH) eklemiş olmanız gerekirken bunları yapmamış olabilirsiniz.
Asla unutmayın, Python’ın etkileşimli kabuğunu başlatmak için hangi komutu kullanıyorsanız, randevu.py dosyasını çalıştırmak için de aynı komutu kullanacaksınız. Yani eğer Python’ın etkileşimli kabuğunu
python3.4
gibi bir komutla çalıştırıyorsanız, programınızı da
python3.4randevu.py
şeklinde çalıştırmanız gerekir. Aynı şekilde, eğer etkileşimli kabuğu mesela
python
(veya
py3
) gibi bir komutla çalıştırıyorsanız, programınızı da
python randevu.py
(veya
py3 randevu.py
) şeklinde çalıştırmalısınız. Neticede etkileşimli kabuğu çalıştırırken de, bir program dosyası çalıştırırken de aslında temel olarak Python programlama dilini çalıştırmış oluyorsunuz. Python programını çalıştırırken bir dosya adı belirtmezseniz, yani Python’ı başlatan komutu tek başına kullanırsanız etkileşimli kabuk çalışmaya başlar. Ama eğer Python’ı başlatan komutla birlikte bir program dosyası ismi de belirtirseniz, o belirttiğiniz program dosyası çalışmaya başlar.
Kodlarınızı düzgün bir şekilde çalıştırabildiğinizi varsayarak yolumuza devam edelim...
Gördüğünüz gibi, kod dosyamızı çalıştırmak için
Kod:
python3
komutundan yararlanıyoruz. Bu arada tekrar etmekte fayda var: Python’ın etkileşimli kabuğunu çalıştırmak için hangi komutu kullanıyorsanız, dosyaya kaydettiğiniz programlarınızı çalıştırmak için de aynı komutu kullanacaksınız.
Gelelim Windows kullanıcılarına...
Windows
Daha önce de söylediğimiz gibi, Python kodlarımızı yazmak için istediğimiz bir metin düzenleyiciyi kullanabiliriz. Hatta Notepad’i bile kullansak olur. Ancak Notepad’den biraz daha gelişmiş bir metin düzenleyici ile başlamak işinizi kolaylaştıracaktır.
Python programlama dilini öğrenmeye yeni başlayan Windows kullanıcıları için en uygun metin düzenleyici IDLE’dır. Başlat > Tüm Programlar > Python3.4 > IDLE (Python GUI) yolunu takip ederek IDLE’a ulaşabilirsiniz.
IDLE’ı açtığınızda şöyle bir ekranla karşılaşacaksınız:
Alıntı:
Aslında bu ekran size bir yerlerden tanıdık geliyor olmalı. Dikkat ederseniz beyaz ekranın en sonunda bordo renkli bir >>> işareti var. Evet, tahmin ettiğiniz gibi, burası aslında Python’ın etkileşimli kabuğudur. Yani o siyah etkileşimli kabuk ekranında ne yapabilirseniz burada da aynı şeyi yapabilirsiniz. Dilerseniz kendi kendinize bazı denemeler yapın. Ama şu anda biz IDLE’ın bu özelliğini değil, metin düzenleyici olma özelliğini kullanacağız. O yüzden yolumuza devam ediyoruz.
Dediğimiz gibi, yukarıda görünen ekran aslında Python’ın etkileşimli kabuğudur. Dolayısıyla biraz sonra göstereceğimiz kodları buraya yazmayacağız. Python programlama diline yeni başlayanların en sık yaptığı hatalardan biri de, kaydetmek istedikleri kodları yukarıda görünen ekrana yazmaya çalışmalarıdır. Unutmayın, Python’ın etkileşimli kabuğunda ne yapabiliyorsanız, IDLE’ı açtığınızda ilk karşınıza çıkan ekranda da onu yapabilirsiniz. Python’ın etkileşimli kabuğunda yazdığınız kodlar etkileşimli kabuğu kapattığınızda nasıl kayboluyorsa, yukarıdaki ekrana yazdığınız kodlar da IDLE’ı kapattığınızda kaybolur...
Bir önceki ekranda sol üst köşede File [Dosya] menüsü görüyorsunuz. Oraya tıklayın ve menü içindeki New Window [Yeni Pencere] düğmesine basın. Şöyle bir ekranla karşılaşacaksınız:
Alıntı:
İşte Python kodlarımızı bu beyaz ekrana yazacağız. Şimdi bu ekrana şu satırları yazalım:
tarih = "02.01.2012"
gün = "Pazartesi"
vakit = "öğleden sonra"
print(tarih, gün, vakit, "buluşalım", end=".\n")
Bu noktadan sonra yapmamız gereken şey dosyamızı kaydetmek olacak. Bunun için File > Save as yolunu takip ederek programımızı masaüstüne randevu.py adıyla kaydediyoruz.
Şu anda programımızı yazdık ve kaydettik. Artık programımızı çalıştırabiliriz. Bunun için IDLE’da Run > Run Module yolunu takip etmeniz veya kısaca F5 tuşuna basmanız yeterli olacaktır. Bu iki yöntemden birini kullanarak programınızı çalıştırdığınızda şöyle bir çıktı elde edeceksiniz:
02.01.2012 Pazartesi öğleden sonra buluşalım.
Tebrikler! İlk Python programınızı yazıp çalıştırdınız... Eğer çalıştıramadıysanız veya yukarıdaki çıktı yerine bir hata mesajı aldıysanız muhtemelen kodları yazarken yazım hatası yapmışsınızdır. Kendi yazdığınız kodları buradaki kodlarla dikkatlice karşılaştırıp tekrar deneyin.
Şimdi gelin isterseniz yukarıda yazdığımız kodları şöyle bir kısaca inceleyelim.
Programımızda üç farklı değişken tanımladığımıza dikkat edin. Bu değişkenler tarih, gün ve vakit adlı değişkenlerdir. Daha sonra bu değişkenleri birbiriyle birleştiriyoruz. Bunun için
Kod:
print()
fonksiyonundan nasıl yararlandığımızı görüyorsunuz. Ayrıca
Kod:
print()
fonksiyonunu kullanış biçimimize de dikkat edin. Buradaki end parametresinin anlamını ve bunun ne işe yaradığını artık gayet iyi biliyorsunuz. end parametresi yardımıyla cümlenin en sonuna bir adet nokta yerleştirip, \n adlı kaçış dizisi yardımıyla da bir alt satıra geçiyoruz.
Böylece basit bir Python programının temel olarak nasıl yazılıp bir dosyaya kaydedileceğini ve bu programın nasıl çalıştırılacağını öğrenmiş olduk.
öğesini ekrana basma işlemi gerçekleştir! 
