9. Genel Tekrar¶
Bu noktaya kadar Python ile ilgili epey şey öğrendik. Buraya kadar öğrendiklerimizi kullanarak Python programlama dili ile önemli ve yararlı işler yapabiliriz. Bu bölümden sonra Python’un derinliklerine dalmaya başlayacağız. Ama dalışa geçmeden önce teçhizatımızı kontrol etmemiz, sonra da derin bir nefes almamız gerektiğini düşünüyorum. O yüzden bir adım daha ileriye gitmeden önce şimdiye kadar öğrendiğimiz kısımların şöyle bir üzerinden geçmemizin faydalı olacağını zannediyorum.
Yalnız bu “genel tekrar” başlığı sizi yanıltmasın. Bu bölümde zaten bildiğimiz konuları tekrar etmeyeceğiz. Daha doğrusu, yine bildiğimiz konulardan bahsedeceğiz, ama buraya kadar geldiğimiz noktada, konuyu okur açısından boğucu ve sıkıcı hale getirmemek için göz ardı ettiğimiz, atladığımız bilgileri tartışacağız bu bölümde. Dolayısıyla bu “genel tekrar” bölümü, okurların hem eski bilgilerini tazelemesini, hem de buraya kadar olan kısımda bahsetmeden geçtiğimiz bazı önemli ayrıntıları öğrenmesini sağlayacaktır. Bu bölümün en önemli amacı, şimdiye kadar öğrenilen konuları pekiştirmek ve öğrenilen konulara ilişkin yeni bilgiler vermektir. Bu bölümde, “Temel Bilgiler” kategorisinde bulunan, ama yukarıda bahsettiğimiz sebeplerden ötürü bahsetmeden veya derinlemesine incelemeden geçtiğimiz konuları öğreneceğiz.
9.1. Python’u Başlatma Seçenekleri¶
Eğer bu noktaya kadar gelmişseniz, Python’u başarıyla kurmuş ve çalıştırmışsınız demektir... O yüzden bu bölümde Python’un bilgisayarınıza nasıl kurulacağından ve Python’un nasıl çalıştırılacağından bahsetmek yerine, bu konuyla ilgili bazı ayrıntılara değinmeye çalışacağız. Bu bölümün konusu, Python’u başlatma seçenekleri (startup options)... Yani bu bölümde, Python’u çalıştırırken hangi seçenekleri kullanabileceğimizi ve bu seçeneklerin ne işe yaradığını öğreneceğiz.
Ben bu bölümde, sizin Python’un etkileşimli kabuğuna ulaşmak veya Python ile yazdığınız programları çalıştırmak için şu komutu kullandığınızı varsayacağım:
python3
Eğer siz kendi sisteminizde Python’u çalıştırmak için başka bir komut kullanıyorsanız (python3.0 gibi...), “python3” gördüğünüz yere, kendi kullandığınız komutu yerleştireceksiniz...
İlk seçeneğimizle başlayalım...
python3 -h
Python’u “-h” seçeneği ile başlattığımızda karşımıza Python’un yardım (help) ekranı gelir. Buradan, Python’u nasıl çalıştıracağınıza, çalıştırırken hangi seçenekleri kullanabileceğinize ve bu seçeneklerin ne işe yaradığına dair kısa bilgilere erişebilirsiniz. İşte biz de bu bölümde, bu yardım ekranında görünen seçeneklerin en önemli olanlarına ve şu aşamada bizi ilgilendirenlerine değineceğiz...
Bu yardım ekranına şu komut ile de erişebilirsiniz:
python --help
Burada “-” işaretinin çift olduğuna dikkat edin.
python3 -c
Bu seçenek, Python’u bir komutla çalıştırmamızı sağlar. Bu ne demek oluyor? Hemen şöyle bir örnek verelim:
python3 -c "print('Merhaba Dünya')"
Gördüğünüz gibi, Python’un etkileşimli kabuğunu hiç açmadan veya kodumuzu bir metin düzenleyiciyle yazıp kaydetmeye gerek kalmadan, kodlarımızı doğrudan komut satırı üzerinde çalıştırabiliyoruz. Burada önemli nokta, “-c” seçeneğinden sonra gelecek kodları tırnak içine almak... Ancak bunu yaparken, kodun kendisinin içinde yer alan öbür tırnaklarla bu ilk tırnağın birbirine karışmamasına dikkat ediyoruz. Eğer “-c” seçeneğinden sonra çift tırnak ile başlamışsak, “Merhaba Dünya” karakter dizisini tek tırnak içine almaya özen gösteriyoruz...
Eğer “-c” seçeneğine vereceğimiz komut birden fazla ise her bir komutu “;” işareti ile ayırıyoruz:
python3 -c "print('Merhaba Dünya'); print('Sana da merhaba canım!')"
Merhaba Dünya
Sana da merhaba canım!
python3 -v
“-v” seçeneğin görevi, Python’un çalışmaya başladığı anda ve kapanırken hangi işlemleri yaptığını ayrıntılı olarak göstermektir. Kullanımı şöyledir:
python3 -v
Bu komutu verdiğimizde Python’un etkileşimli kabuğu başlayacak, ama kabuk başlarken Python’un arkaplanda neler karıştırdığı da ekrana dökülecektir. Aynı şekilde, etkileşimli kabuğu “CTRL+Z” tuş bileşimiyle kapattığımızda da, arkaplanda olup biten her şey ekrana dökülecektir.
python3 -V
Bu seçenekteki “V”nin büyük harf olduğuna dikkat ediyoruz. Bu seçeneğin kullanımı şöyledir:
python3 -V
Görevi ise, sistemimizde kurulu olan Python sürümünü göstermektir.
python3 -x
Eğer Python’u bu seçenekle başlatırsak, Python kodlarımızın ilk satırını görmezden gelecektir. Mesela bir örnek verelim:
Şu kodları içeren bir dosyamız olsun:
print("Merhaba")
print("Gülegüle")
Eğer bu dosyayı şu komutla çalıştırırsak:
python3 -x dosya.py
‘print(“Merhaba”)’ satırı görmezden gelinecek, ekrana “Gülegüle” çıktısı verilecektir.
Böylelikle Python’u başlatma seçenekleri içinde şu an için işimize yarayabilecek seçenekleri görmüş olduk. Python’a ilişkin bilgilerimiz arttıkça öteki seçenekler de bizim için bir anlam ifade etmeye başlayacaktır...
9.2. print() Fonksiyonunun Gücü¶
Python’un 2.x sürümlerinde print() bir deyimdi... Yani 3.x öncesi sürümlerde ekrana bir şeyler yazdırmak istediğimizde şu yapıyı kullanıyorduk:
>>> print "bir şeyler..."
Ancak Python’un 3.x sürümüyle birlikte, “print” bir fonksiyon halini aldı. Dolayısıyla artık ekrana bir şeyler yazdırmak için şöyle yapıyoruz:
>>> print("bir şeyler...")
print() fonksiyonundaki bu değişiklik, Python’un 2.x’ten 3.x’e geçişinde yapılan en önemli yeniliklerden biridir. Ayrıca print()‘in bir fonksiyon haline gelmesi ile birlikte bu fonksiyon bazı güçlü özellikler de kazandı. İşte biz de bu bölümde yeni print() fonksiyonunun gücünü ortaya koymaya çalışacağız.
Diyelim ki elimizde şöyle bir liste var:
>>> liste = ["elma", "armut", "kebap"]
Eğer Python’un 2.x sürümlerinden birini kullanıyor olsaydık şöyle bir komut yazabilirdik:
>>> for i in liste:
... print i
Bu komut bize şöyle bir çıktı verir:
elma
armut
kebap
Aynı işlemi Python 3.x ile yaptığımızda da tıpatıp aynı sonucu elde ederiz.
Python 2.x’te, liste öğelerini böyle alt alta değil de yan yana dizmek istersek şöyle bir yol izliyorduk:
>>> for i in liste:
... print i,
...
elma armut kebap
Burada “i”nin yanına bir virgül işareti koyduğumuza dikkat edin. Aynı şeyi Python 3.x ile yapmaya çalıştığımızda ise beklentimizin karşılanmayacağını görüyoruz:
>>> for i in liste:
... print(i,)
...
elma
armut
kebap
Gördüğünüz gibi, “i”nin yanına koyduğumuz virgülün herhangi bir etkisi olmadı. Peki biz liste öğelerini Python 3.x’i kullanarak nasıl yan yana dizeceğiz? İşte burada print() fonksiyonunun gücü devreye girecek. Bakın bu işlemi sadece print() fonksiyonunu kullanarak nasıl da halledebiliyoruz:
>>> print(*liste)
elma armut kebap
Burada Python 3.x ile birlikte kullanım alanı genişletilen “yıldızlı ifadeler” (starred expressions) adlı bir özellikten faydalandık. Yıldızlı ifadeyi print() fonksiyonu içinde bir listeye uyguladığımızda, sanki liste öğeleri üzerinde bir for döngüsü oluşturulmuş gibi bir sonuç elde edilecektir. Yıldızlı ifadelerin farklı bir kullanımına demetler konusunu işlerken de değinmiştik...
Peki ya bu liste öğelerini ekrana hem böyle yan yana dizmek, hem de her öğenin arasına bir virgül koymak istersek ne yapacağız?
Önce bu işlemi Python 2.x ile nasıl yaptığımıza bakalım:
>>> for i in liste:
... print i + ", ",
elma, armut, kebap,
Bu kullanım en hafif tabiriyle “çirkin”dir. Ayrıca aslında istediğimiz şeyi de tam olarak yerine getirmez. Çünkü biz liste öğelerinin arasına birer virgül koymak istiyoruz, ama en son öğeden sonra virgül olmasını istemiyoruz. Bu isteğimizi Python 2.x ile gerçekleştirebilmek için karakter dizilerinin (henüz öğrenmediğimiz) join() adlı metodundan yararlanmamız gerekir:
>>> print ", ".join(liste)
elma, armut, kebap
Python 3.x’i kullanarak aynı şeyi yapmak istediğimizde ise print() fonksiyonunun gücünden yararlanmamız yeterli olacaktır:
>>> print(*liste, sep=", ")
elma, armut, kebap
Eğer kullandığınız konsol/terminal işlem sonunda yeni satıra geçmiyorsa bu komutu şöyle de yazabilirsiniz:
>>> print(*liste, sep=", ", end="\n")
Buradaki “sep” ve “end” parametreleri print() fonksiyonunun kıvraklığını artıran etkenler... “sep” parametresi print() fonksiyonuna yazılan öğelerin her birinin arasına istediğimiz bir karakter dizisini yerleştirme imkanı sağlıyor bize. Basit bir örnek verelim:
>>> print("elma", "armut", "kebap", sep=", ")
elma, armut, kebap
Bu örnekte, print() fonksiyonu içinde belirtilen karakter dizilerinin her birinin arasına, “sep” parametresi yardımıyla bir virgül işareti koyuyoruz...
“sep” parametresi ile birlikte öğrendiğimiz “end” adlı parametre ise, print() fonksiyonu içinde belirtilen ifadenin ne şekilde biteceğini gösteriyor. Biz yukarıdaki örnekte “n” işaretini kullandık. Böylece print() fonksiyonu yardımıyla ekrana bir şeyler yazdırdıktan sonra yeni satıra geçebiliyoruz...
print() fonksiyonu “sep” ve “end” dışında bir de “file” adlı bir parametre alır. Bu parametre yardımıyla, ekrana yazdıracağımız şeyleri ekran yerine bilgisayarımızdaki bir dosyaya yazdırabiliriz:
>>> print("Merhaba Dostlar!", file=open("pydeneme.txt", "w"))
Bu özelliğin ne kadar faydalı olabileceğini tahmin edebilirsiniz. Burada open() adlı bir fonksiyondan yararlandığımıza dikkat edin. Bu fonksiyonu “dosya işlemleri” konusunu işlerken daha detaylı olarak inceleyeceğiz. Aynı fonksiyona, “hata yakalama” konusunu işlerken de değinmiştik... Bu arada, bilginiz olması açısından, yukarıdaki open() fonksiyonu içinde kullandığımız “w” parametresinin, bilgisayarımızda yeni bir dosya oluşturmaya yaradığını söyleyelim... Hatırlarsanız, “hata yakalama” konusu içinde bu fonksiyona değinirken “w” yerine “r” adlı bir parametre kullanmıştık. O parametre dosyayı okumak üzere açmamızı sağlıyordu. “w” parametresi ise dosyayı yazmak üzere açmamızı sağlıyor.
Gelin isterseniz bu “file” parametresini kullanarak az çok yararlı bir uygulama yazalım:
ad = input("adınız: ")
soyad = input("soyadınız: ")
eposta = input("e.posta adresiniz: ")
print(ad, soyad, eposta, file=open("deneme.txt", "w"), sep="\n")
print("Girdiğiniz veriler dosyaya başarıyla işlendi!")
Burada kullanıcıya adını, soyadını ve e.posta adresini soruyoruz. Ardından kullanıcının girdiği bu verileri, “deneme.txt” adlı bir dosyaya kaydediyoruz. “sep” parametresini nasıl kullandığımıza dikkat edin. Kullanıcının girdiği her bir verinin dosya içinde ayrı bir satırda yer alması için, “sep” parametresine “n” değerini verdik...
9.3. Etkileşimli Kabuğun Hafızası¶
Python’daki “etkileşimli kabuk” denen şeyin ne olduğunu daha önce anlatmıştık. Etkileşimli kabuğun, Python’un gücüne güç katan en önemli özelliklerden birisi olduğunu söylesek abartmış olmayız. Özellikle böyle bir araca sahip olmayan diller üzerinde çalışmış arkadaşlarım ne demek istediğimi çok daha iyi anlayacaktır. Etkileşimli kabuk programcılar arasında o kadar hayranlık uyandırmıştır ki bazı yazarlar “sırf etkileşimli kabuğun bile Python’u Java’dan üstün kılmaya yeterli olduğunu” söylemekten çekinmemişlerdir.
Bu bölümde, etkileşimli kabuğun ufak ama oldukça pratik bir özelliğinden söz edeceğiz.
Diyelim ki etkileşimli kabukta bazı aritmetik işlemler yapıyorsunuz... Örneğin şöyle bir işlem yaptınız:
>>> 54345345 * 45
2445540525
Daha sonra da bu sayıyı 25’e bölmeye karar verdiniz... Bu işlemi yapmak için değişik yollar kullanabilirsiniz, ama bütün yollar içinde en kolayı “_” işlecinden yararlanmaktır. Bu işleç, yapılan en son işlemin değerini barındırır. Etkileşimli kabukta “54345345 * 45” işlemini yaptıktan ve sonucu aldıktan sonra şu komutu verin:
>>> _
2445540525
Gördüğünüz gibi b u komut size en son yaptığınız işlemin sonucu olan sayıyı veriyor. Dolayısıyla en son elde ettiğiniz sayıyı mesela 25’e bölmek için şöyle bir şey yapabilirsiniz:
>>> _ / 25
97821621.0
Burada “_” işareti “2445540525” sayısını hafızasında tuttuğu için bu sayıyı pratik bir şekilde başka bir işlem içinde kullanmamıza imkan sağlıyor. Üstelik bu işleci sadece sayılarla kullanmak zorunda da değiliz. “_” işleci her türlü işlemin sonucunu hafızasında tutabilir. Mesela:
>>> "elma" + " armut"
'elma armut'
>>> _
'elma armut'
Hatta isterseniz bu işleci bir değişkene dahi atayabilirsiniz:
>>> sondeger = _
elma
Yalnız bu özellik sadece etkileşimli kabuk için geçerlidir. Bunu yazdığımız bir program içinde kullanamayız... Bu işlecin görevi sadece etkileşimli kabuk üzerinde çalışan programcının işini biraz kolaylaştırmaktır.
9.4. abs(), round(), min() ve max() Fonksiyonları¶
Python bize matematik ve aritmetik işlemlerinde kullanabileceğimiz abs(), round(), min() ve max() adında dört adet pratik fonksiyon sunar. Bu dört fonksiyonun yaptığı işler ilk bakışta çok gerekliymiş gibi görünmese de aslında bazı durumlarda işlerimizi bir hayli kolaylaştırmamızı sağlar. Öncelikle abs() fonksiyonundan başlayalım...
abs()
“abs”, İngilizce “absolute” kelimesinin kısaltmasıdır. Bu kelime Türkçe’de “mutlak” anlamına gelir. Bunun abs() fonksiyonundaki kullanımı ise “mutlak değer” anlamındadır. Dolayısıyla abs() fonksiyonu bir sayının mutlak değerini almamızı sağlar.
abs() fonksiyonunun kullanımı şöyledir:
>>> a = -8
>>> abs(a)
8
round()
İkinci fonksiyonumuz ise round(). Bu kelime Türkçe’de “yuvarlamak” anlamına gelir. Dolayısıyla round() fonksiyonunu kullanarak sayıların değerini yuvarlayabiliyoruz. Örneğin:
>>> a = 59 / 23
>>> round(a)
3
Böylece normalde küsürlü çıkacak bir bölme işlemini round() metodu yardımıyla yuvarlamış oluyoruz...
Başka bir örnek:
>>> round(150/4)
38
Bu fonksiyonu kullanırken, istersek noktadan sonra kaç basamak istediğimizi de belirtebiliriz:
>>> print(round(59/23, 0))
3.0
>>> print(round(59/23, 1))
2.6
>>> print(round(59/23, 2))
2.57
>>> print(round(59/23, 3))
2.565
>>> print(round(59/23, 4))
2.5652
Burada daha düzgün bir çıktı alabilmek için print() fonksiyonundan da yararlandığımıza dikkat edin. Eğer burada print() fonksiyonunu kullanmazsak bölme işlemlerinin sonucu insan gözüne “yabancı” görünecektir... İsterseniz burada print() fonksiyonu yerine str() fonksiyonundan da yararlanabilirsiniz düzgün çıktı elde edebilmek için:
>>> str(round(59/23, 4))
'2.5652'
Tabii str() fonksiyonuyla yaptığımız şey aslında sayıyı karakter dizisine çevirme işlemi olduğu için, yukarıdaki çıktının bir karakter dizisi olduğuna, dolayısıyla bunu kullanarak herhangi bir aritmetik işlem yapamayacağımıza dikkat ediyoruz...
min()
“min” kelimesi, tahmin edeceğiniz gibi “minimum” kelimesinin kısaltmasıdır. Bu fonksiyon bir sayı dizisi içindeki en küçük sayıyı verir:
>>> min(45, 90, 43, 23, 3353)
23
Bu fonksiyonu listelerle birlikte de kullanabiliriz:
>>> liste = [4234, 343543, 23323, 6161, 54564, 65675,
... 34243243, 4324, 4234]
>>> min(liste)
4234
max()
Evet, bu fonksiyon min() fonksiyonunun tam tersidir. Bir sayı dizisi içindeki en büyük sayıyı verir:
>>> max(45, 90, 43, 23, 3353)
3353
...veya...
>>> liste = [4234, 343543, 23323, 6161, 54564, 65675,
... 34243243, 4324, 4234]
>>> max(liste)
34243243
9.5. pow(), divmod() ve sum() Fonksiyonları¶
Bu bölümde, Python’un işlerimizi kolaylaştırmamız için bize sunduğu üç adet fonksiyondan söz edeceğiz. Bu fonksiyonlar pow(), divmod() ve sum(). Öncelikle pow() fonksiyonuyla başlayalım:
pow()
Hatırlarsanız “sayılar” konusunu işlerken bir sayının kuvvetini almak için şöyle bir yöntem izleyebileceğimizi söylemiştik:
x ** y
Burada “x” kuvvetini alacağımız sayıyı, “y” ise bu x sayısının kaçıncı kuvvetini alacağımızı gösteriyor. Örneğin 2 sayısının 3. kuvvetini almak istersek şunu yazıyoruz:
>>> 2**3
8
Python bu yöntemin dışında, bir sayının kuvvetini almak için bize pow() adlı bir fonksiyon daha sunuyor. Yukarıdaki işlemi pow() fonksiyonunu kullanarak şöyle yazabiliriz:
>>> pow(2, 3)
8
Burada tahmin edeceğiniz gibi parantez içindeki ilk parametre kuvvetini alacağımız sayıyı, ikinci parametre ise bu sayının kaçıncı kuvvetini alacağımızı gösteriyor...
divmod()
Şöyle bir bölme işlemi yaptığımızı düşünelim:
>>> 10 / 2
5.0
Gördüğünüz gibi burada bir “ondalık sayı” elde ediyoruz. Eğer elde ettiğimiz sayının ondalık değil de tamsayı olmasını istersek “//” işlecinden yararlanmamız gerektiğini biliyoruz:
>>> 10 // 2
5
Bir de şöyle bir işlem yaptığımızı düşünelim:
>>> 10 % 2
0
Burada da 10 sayısının 2’ye bölümünden kalan sayıyı buluyoruz. Demek ki 10 sayısı 2’ye bölündüğünde kalan “0” oluyormuş. Burada “%” işlecinin ne işe yaradığını “sayılar” konusunu işlerken öğrenmiştik...
İşte divmod() fonksiyonu yukarıda bahsettiğimiz bu iki işlemi birleştiriyor. Hemen bir örnekle bunu somutlaştıralım:
>>> divmod(10, 2)
(5, 0)
Gördüğünüz gibi divmod() fonksiyonu aynı anda noktasız bölme işlemi yapıyor ve bölme işleminden kalan sayıyı gösteriyor...
sum()
Şimdi göreceğimiz sum() adlı fonksiyon oldukça yararlı bir araçtır. Bu fonksiyon bir sayı dizisini alıp bu dizinin toplamını verir bize. Örneğin:
>>> liste = [34, 43, 32, 23, 23232, 32]
>>> sum(liste)
23396
Bu fonksiyonun yalnızca sayılarla kullanılabileceğini aklımızdan çıkarmıyoruz...
sum() fonksiyonu ayrıca ikinci bir parametre daha alabilir:
>>> sum(liste, 2)
23398
sum() fonksiyonu, listenin elemanlarını topladıktan sonra, elde edilen toplam değere ikinci parametreyi de ekliyor...
9.6. Bool Değerleri ve bool() Fonksiyonu¶
Daha önceki derslerimizde, üzerinde fazla durmamış olsak da aslında Bool değerlerini kullanmıştık. “True” ve “False” olarak ifade edilen değerlere Bool değerleri adı verilir (George Boole adlı İngiliz matematikçi ve filozofun adından). “True” değeri sayısal olarak “1” ile gösterilirken, “False” değeri “0” ile gösterilir. Türkçe olarak söylemek gerekirse, “True” değerinin karşılığı “Doğru”, “False” değerinin karşılığı ise “Yanlış”tır... Biz bu değerleri mesela kümeler konusunu işlerken de görmüştük:
>>> a = set([1, 2, 3])
>>> b = set([1, 3, 4, 5])
>>> a.isdisjoint(b)
False
Burada a ve b ayrık kümeler olmadıkları için “Yanlış” anlamına gelen “False” değerini alıyoruz.
Bool değerleri temel olarak bir nesnenin doğruluk değerini sorgulamak için kullanılır. Yani bir şeyin doğru olup olmadığını anlamak için kullanıyoruz bu Bool değerlerini... Örneğin:
>>> a = 23
>>> if a == 23:
... print("a'nın değeri 23'tür")
Burada aslında bir doğruluk değeri sorgulaması yapıyoruz (“Eğer a 23’e eşitse...”). Gerçi burada karşılaştırma işlemini yapan asıl öğe “==” işlecidir, ama aslında bu yapı içinde temel olarak Bool kavramından yararlanılıyor. Bunu etkileşimli kabukta test edebiliriz:
>>> a = 23
>>> a == 23
True
>>> a == 4
False
Burada olduğu gibi Bool kavramından karşılaştırma işlemlerinde yararlanmanın yanısıra, bir şeyin herhangi bir değere sahip olup olmadığını denetlemek için de Bool değerlerinden faydalanabiliriz. Örneğin:
>>> a = 23
>>> if a:
... print("Evet, a'nın bir değeri var!..")
...
'Evet, a'nın bir değeri var!..'
Bir de şu örneğe bakalım:
>>> a = ""
>>> if a:
... print("Evet, a'nın bir değeri var!..")
... else:
... print("Hayır, a'nın herhangi bir değeri yok!")
...
'Hayır, a'nın herhangi bir değeri yok!"
Burada kullandığımız “if a:” ifadesi, “Eğer a doğru ise...” anlamına geliyor. Yani burada “Eğer a’nın Bool değeri True ise...” demiş oluyoruz. Bu durumu daha açık bir şekilde göstermek için Python’daki bool() adlı fonksiyondan yararlanabiliriz. Bu fonksiyon, bize herhangi bir şeyin değerinin “True” mi yoksa “False” mi olduğunu söyleyecektir:
>>> a = ""
>>> bool(a)
False
Bir de şuna bakalım:
>>> a = "karakter dizisi"
>>> bool(a)
True
Dolayısıyla yukarıdaki if deyimini şöyle de yazabiliriz:
>>> a = ""
>>> if bool(a):
... print("Evet, a'nın bir değeri var!..")
... else:
... print("Hayır, a'nın herhangi bir değeri yok!")
a = “” ifadesinin “False” değerini vermesi bize Python’daki Bool değerleri hakkında önemli bir bilgi veriyor. Python’da bazı şeyler her zaman “False” değeri verir. Örneğin bütün boş veritipleri “False” değerine sahiptir. Örneğin:
>>> liste = []
>>> bool(liste)
False
>>> sozluk = {}
>>> bool(sozluk)
False
>>> demet = ()
>>> bool(demet)
False
>>> kume = set()
>>> bool(kume)
False
Yukarıdaki veritiplerinin “True” değeri verebilmesi için en az bir öğeye sahip olmaları gerekir...
Daha önce de dediğimiz gibi, sayısal olarak “True”nin değeri 1; “False”nin değeri ise 0’dır. Bu durumu şu kodlarla daha net bir şekilde görebiliriz:
>>> True + 1
2
Burada “True”nin değeri 1 olduğu için, “True + 1” ifadesi “2” sonucunu veriyor. Bir de şuna bakalım:
>>> False + 1
1
Burada ise “False”nin değeri 0 olduğu için, “False + 1” işleminin sonucu 1 oluyor...
Bu bilgiye göre, değeri 0 olan bir değişken False; değeri 1 olan bir değişken ise True olacaktır:
>>> a = 0
>>> bool(a)
False
>>> b = 1
>>> bool(b)
True
Ancak bu durumun sadece değişkenler için geçerli olduğunu unutmuyoruz. Liste, sözlük, demet, vb. veri tiplerinde durum biraz farklıdır:
>>> liste = [0]
>>> bool(liste)
True
Bunun dışında özel olarak “None” değeri de her zaman “False”dir:
>>> a = None
>>> bool(a)
False
Boş veritiplerinin False, dolu veritiplerinin True değeri vermesinden yola çıkarak şöyle bir uygulama yazabiliriz:
liste = []
print("""
Lütfen bir sayı girin. Her veri girişinden sonra Enter
tuşuna basın. İşlemi bitirip programdan
çıkmak için ise yine Enter tuşuna basın.""")
while True:
veri = input("Sayı: ")
if veri:
try:
sayı = int(veri)
liste.append(sayı)
except ValueError:
continue
else:
toplam = sum(liste)
print("girdiğiniz sayıların toplamı: ", toplam)
print("tekrar görüşmek üzere!")
break
Şimdi bu kodları satır satır inceleyelim...
Öncelikle “liste = []” satırı yardımıyla boş bir liste oluşturuyoruz. Kullanıcıdan alacağımız verileri bu liste içinde toplayacağız.
Ardından bir print() fonksiyonu içinde programımızın ne iş yapacağını, kullanıcıdan ne beklediğimizi anlatan bir karakter dizisi oluşturuyoruz. Buna göre, kullanıcı ekrana bir sayı girecek ve her veri girişinden sonra Enter tuşuna basacak. Ayrıca işlemin sonucunu alıp programdan çıkmak için de yine Enter tuşuna basması gerekecek...
Daha sonra bir while döngüsü oluşturuyoruz. Burada kullandığımız “while True:” ifadesine dikkat edin. Bu ifade, bir kod dizisini sürekli bir döngüye sokmak için kullanabileceğimiz standart bir yoldur. Türkçe olarak söylemek gerekirse, “while True:” ifadesi “Doğru olduğu müddetçe...” anlamına gelir. Bu sayede programımıza şu komutu vermiş oluyoruz:
“Doğru olduğu müddetçe aşağıdaki komutları çalıştırmaya devam et...”
Peki ne doğru olduğu müddetçe? Neyin doğru olduğunu açıkça belirtmediğimiz için Python burada “her şeyi doğru” kabul ediyor... Yani bir nevi, “aksi belirtilmediği sürece aşağıdaki komutları çalıştırmaya devam et!” emrini yerine getiriyor.
Sonraki satırda “veri = input(“Sayı: “)” kodu ile kullanıcıdan veri alma işlemini başlatıyoruz. Burada henüz kullanıcıdan aldığımız veriyi int() fonksiyonu yardımıyla tamsayıya çevirmediğimize dikkat edin. Eğer daha bu aşamada dönüştürme işlemini yaparsak, daha sonra kullanıcının programdan çıkmak için kullanacağı Enter tuşunu yakalayamayız. Çünkü böyle bir durumda kullanıcı Enter tuşuna basarsa programımız hata verecektir.
Bundan sonraki adımda “if veri:” satırını yazıyoruz. Bunun, “eğer veri adlı karakter dizisi True değerine sahipse...” anlamına geldiğini biliyoruz. Zira bildiğiniz gibi, eğer veri adlı karakter dizisi hiçbir şey içermezse, yani boşsa, sahip olduğu Bool değeri “False” olacaktır. Yani eğer kullanıcımız hiçbir sayı girmeden Enter tuşuna basarsa, veri adlı karakter dizisinin içeriği boş olacağı için bu karakter dizisi “False” değerine sahip olacaktır. Dolayısıyla eğer kullanıcımız bir sayı girip Enter tuşuna basarsa, veri adlı karakter dizisinin Bool değeri True olacağı için “if veri:” bloğu içindeki kodlar işletilecektir. Yok eğer kullanıcımız herhangi bir sayı girmeden Enter tuşuna basarsa aşağıdaki “else:” bloğu içindeki kodlar çalıştırılacaktır...
“if veri:” kodunu yazdıktan sonra bir try... except... bloğu oluşturuyoruz. Sayıya dönüştürme işlemini bu blok içinde gerçekleştireceğiz. “sayı = int(veri)” satırı yardımıyla, kullanıcıdan aldığımız karakter dizisini sayıya çeviriyoruz. Hemen ardından gelen “liste.append(sayı)” satırı ise, kullanıcıdan alıp tamsayıya çevirdiğimiz veriyi, en başta oluşturduğumuz listeye eklememizi sağlıyor.
Sonraki satırda ise except... bloğumuzu yazıyoruz. Bir önceki try... bloğu içine yazdığımız int() fonksiyonunun, kullanıcının sayı yerine harf girmesi durumunda “ValueError” hatası vereceğini bildiğimiz için bu blok içinde bu hata tipini yakalıyoruz. Eğer kullanıcı sayı yerine harf girer ve ValueError hatası alınmasına yol açarsa, continue ifadesi yardımıyla döngünün en başına geri gidiyoruz.
Sıra geldi else: bloğumuzu yazmaya... Kodlarımızın başında “if veri:” şeklinde bir şey yazmıştık. Bu kod, kullanıcının ekrana bir veri girip girmediğini denetliyordu. İşte kullanıcının herhangi bir veri girmediği durumlar için bu else: bloğunu yazıyoruz. Eğer kullanıcı hiçbir veri girmeden “Enter” tuşuna basarsa bu blok içindeki kodlar işletilecektir.
else: bloğu içinde yaptığımız ilk iş, listeye eklediğimiz sayıların hepsini toplamak olacak... Bunu daha önce öğrendiğimiz sum() fonksiyonu yardımıyla yapıyoruz. Ardından da print() fonksiyonunu kullanarak bu toplam değeri kullanıcıya gösteriyoruz ve kendisine veda ettikten sonra break ifadesi yardımıyla da programdan çıkıyoruz.
9.7. Bool İşleçleri (Boolean Operators)¶
Bu bölümde Python’daki “Bool işleçleri” konusundan söz edeceğiz. Burada değineceğimiz işleçler and, or ve not adlı Bool işleçleridir... Bu işleçlere ayrıca “mantık işleçleri” (logical operators) adı da verilir.
and
Bu kelime Türkçe’de “ve” anlamına gelir. Şöyle bir örnek verelim:
>>> a = 4
>>> b = 12
>>> a == 4 and b == 12
True
Yukarıdaki örnekte and işleci, a ve b’nin her ikisinin de değeri “True” olursa, “True” sonucunu verecektir. Eğer karşılaştırma işlemlerinden herhangi birisi “False” ise, sonuç da “False” olacaktır:
>>> a == 3 and b == 12
False
Lisede Mantık dersleri almış olanlar bu işleci gayet iyi tanırlar. Eğer iki önerme birbirine “ve” ile bağlanmışsa, doğru sonuç elde edebilmemiz için bu iki önermenin her ikisinin de doğru olması gerekir.
and işleçlerini Python’da mesela parola ve kullanıcı adı denetlemek için kullanabiliriz. Bildiğiniz gibi, bir sisteme kullanıcı adı ve parola ile giriş yapabilmek için hem kullanıcı adının hem de parolanın doğru olması gerekir. Örnek olarak şöyle bir uygulama yazalım:
kullanıcı_adı = "istihza"
parola = "parola"
print("""Sitemize hoşgeldiniz! Hizmetlerimizden yararlanmak için
lütfen kullanıcı adınızı ve parolanızı giriniz.""")
while True:
kull = input("kullanıcı adı: ")
par = input("parola: ")
if kull == kullanıcı_adı and par == parola:
print("Sisteme hoşgeldiniz!")
break
else:
print("Kullanıcı adınız veya parolanız yanlış! Tekrar deneyin.")
continue
Burada kullanıcının sisteme girebilmesi için hem parolanın hem de kullanıcı adının önceden belirlediğimiz kullanıcı adı ve parolayla eşleşmesi lazım. Bunlardan herhangi biri eşleşmezse kullanıcı sisteme alınmayacaktır.
or
Bu kelime “veya” anlamına gelir. and işlecini anlatırken, bir sonucun “True” olabilmesi için her iki koşulun da “True” olması gerektiğini söylemiştik. or işlecinde ise, koşullardan herhangi birinin “True” olması, sonucun “True” olması için yeterli olacaktır. Mesela yukarıdaki örneği or işleci ile yazarsak, kullanıcı adı veya paroladan herhangi birinin doğru olması, kullanıcının sisteme girmesi için yeterli olacaktır:
kullanıcı_adı = "istihza"
parola = "parola"
print("""Sitemize hoşgeldiniz! Hizmetlerimizden yararlanmak için
lütfen kullanıcı adınızı ve parolanızı giriniz.""")
while True:
kull = input("kullanıcı adı: ")
par = input("parola: ")
if kull == kullanıcı_adı or par == parola:
print("Sisteme hoşgeldiniz!")
break
else:
print("Kullanıcı adınız ve parolanız yanlış! Lütfen tekrar deneyin.")
continue
Dediğimiz gibi, or işlecinin “True” sonucu verebilmesi için önermelerden herhangi birinin “True” olması yeterli olacaktır. Eğer önermelerden her ikisi de yanlış ise sonucumuz “False” olur:
>>> a = 12
>>> b = 2
>>> a == 12 or b == 4
True
>>> a == 5 or b == 43
False
not
Bu bölümde işleyeceğimiz son işlecimiz not adlı Bool işlecidir. Bu kelime “değil” anlamına gelir ve cümleye olumsuzluk anlamı katar. Örneğin:
try:
soru = int(input("bir çift sayı giriniz: "))
if not soru % 2 == 0:
print("Çift sayı girmediniz!")
else:
print("Çift sayı girdiniz!")
except ValueError:
print("Sayı... Sadece sayı...")
Burada “if not soru % 2 == 0:” ifadesiyle şöyle demiş oluyoruz:
Eğer soru değişkeninin değerini 2’ye böldüğümüzde kalan 0 değil ise...
Benzer bir şeyi etkileşimli kabuk üzerinde test edelim:
>>> a = 13
>>> not a % 2 == 0
True
Burada, “a değişkeninin değeri 2’ye bölündüğünde kalan 0 değildir” gibi bir önerme veriyoruz. Python da cevap olarak bize “True” (Doğru”) diyor... Çünkü gerçekten de a değişkeninin değeri olan 13 sayısını 2’ye böldüğümüzde kalan sayı 0 değildir... Bir de şuna bakalım:
>>> a = 34
>>> not a % 2 == 0
False
Burada da, a değişkeninin değeri olan 34 sayısı 2’ye bölündüğünde kalan sayı 0 olduğu için Python, “a 2’ye bölündüğünde kalan sayı 0 değildir” önermemize “False” (Yanlış) cevabını veriyor...
9.8. all() ve any() Fonksiyonları¶
Bir önceki bölümde and ve or işleçlerini öğrenmiştik. Python bize bu and ve or işleçlerinin kullanımı için bazı kolaylıklar sağlar. İşte bu bölümde Python’un bu konuda bize sunduğu kolaylıkların ne olduğunu göreceğiz.
all()
Bu fonksiyon bir dizi içindeki bütün değerlerin Bool değerlerine göre doğruluklarını aynı anda denetlememizi sağlar. Eğer o dizi içindeki bütün değerler “True” ise bu fonksiyon “True” sonucunu verecektir. Hatırlarsanız bir önceki bölümde kullanıcı adı ve parola soran bir uygulama yazmıştık. O uygulamayı all() fonksiyonunu kullanarak şöyle de yazabiliriz:
kullanıcı_adı = "istihza"
parola = "parola"
print("""Sitemize hoşgeldiniz! Hizmetlerimizden yararlanmak için
lütfen kullanıcı adınızı ve parolanızı giriniz.""")
while True:
kull = input("kullanıcı adı: ")
par = input("parola: ")
if all([kull == kullanıcı_adı, par == parola]):
print("Sisteme hoşgeldiniz!")
break
else:
print("Kullanıcı adınız veya parolanız yanlış!")
print("Tekrar deneyin.")
continue
Burada all() fonksiyonu içinde bir liste kullandığımıza dikkat edin. Çünkü all() fonksiyonu sadece tek bir parametre alır. Bu fonksiyona birden fazla parametre atayabilmek için parametreleri bir liste veya demet içinde toplamanız gerekir...
any()
any() fonksiyonu ise bir dizi içindeki herhangi bir öğenin doğruluk değeri “True” ise sonuç olarak “True” verecektir. Yine yukarıdaki örneği or ile yazmak yerine, istersek any() fonksiyonundan yararlanabiliriz:
kullanıcı_adı = "istihza"
parola = "parola"
print("""Sitemize hoşgeldiniz! Hizmetlerimizden yararlanmak için
lütfen kullanıcı adınızı ve parolanızı giriniz.""")
while True:
kull = input("kullanıcı adı: ")
par = input("parola: ")
if any([kull == kullanıcı_adı, par == parola]):
print("Sisteme hoşgeldiniz!")
break
else:
print("Kullanıcı adınız veya parolanız yanlış! Lütfen tekrar deneyin.")
continue
9.9. Liste Üreteçleri (List Comprehensions)¶
Hatırlarsanız, sözlükler konusunu işlerken şöyle bir kod kullanmıştık:
>>> [i for i in dir(dict) if "_" not in i]
Bu kod, birkaç satırda yapabileceğimiz işlemleri tek satıra indirmemizi sağlıyordu. Ayrıca bu yapının normal bir for döngüsüne göre daha performanslı ve hızlı olduğunu da söylemek gerek... Bu tür yapılara Python’da “Liste Üreteçleri” (List Comprehensions) adı verilir. Liste üreteçleri, Python’da bir değerler dizisinden liste oluşturmanın etkili bir yöntemidir.
Diyelim ki elimizde “elma” adlı bir karakter dizisi var. Yine diyelim ki biz bu karakter dizisinin bütün öğelerini bir liste haline getirmek istiyoruz. Yani elde etmek istediğimiz şey şu:
['e', 'l', 'm', 'a']
Liste üreteçlerini kullanmadan bu görevi şöyle halledebiliriz:
>>> liste = []
>>> a = "elma"
>>> for i in a:
... liste.append(i)
>>> print(liste)
['e', 'l', 'm', 'a']
Gördüğünüz gibi öncelikle boş bir liste oluşturuyoruz. Ardından da “a” adlı değişken üzerinde bir for döngüsü kurarak bunun bütün öğelerini append() metodu yardımıyla “liste”ye ekliyoruz. Ancak aynı işlemi yapmanın çok daha kolay ve verimli bir yolu vardır. Liste üreteçlerini kullanarak bu işlemi tek satırda halledebiliriz:
>>> [i for i in a]
['e', 'l', 'm', 'a']
Burada liste üreteçlerinin sözdizimi ile for döngülerinin sözdizimi arasındaki benzerliğe dikkat edin. Gerçekten de liste üreteçleri görünüm olarak for döngülerinin tek satıra indirilmiş hali gibi görünür. Şu for döngüsünün şöyle evrildiğini düşünün:
for döngümüz...
>>> for i in range(10):
... print(i)
liste üretecinin taslağı:
>>> print(i) for i in range(10)
liste üretecinin kendisi:
>>> [i for i in range(10)]
Elbette liste üreteçlerinin yapabildiği tek şey bu olsaydı dünya daha güzel bir yer olmazdı... Çünkü aynı şeyi sadece list() fonksiyonunu kullanarak da yapabiliriz!
>>> list(a)
['e', 'l', 'm', 'a']
...veya...
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Liste üreteçlerinin gücü daha karmaşık işlemlerde ortaya çıkar. Mesela bir öğe dizisini belli bir ölçüte göre süzmek istediğimizde liste üreteçlerinden yararlanabiliriz. Örneğin bir isim dizisi içindeki “A” harfi ile başlayan isimleri süzelim:
>>> isimler = ["Mehmet", "Ayşe", "Süleyman", "Ali", "Kenan",
... "Kerem", "Aycan", "Ayhan", "Metin", "Ayla"]
>>> [i for i in isimler if i[0] == "A"]
['Ayşe', 'Ali', 'Aycan', 'Ayhan', 'Ayla']
Eğer bunu bir for döngüsü ile halletmek isteseydik şöyle yazacaktık bu kodları:
>>> for i in isimler:
... if i[0] == "A":
... print(i)
...
Ayşe
Ali
Aycan
Ayhan
Ayla
Yalnız burada elde ettiğimiz şeyin bir liste olmadığına dikkat edin. Eğer süzülen öğeleri bir liste haline getirmek istersek aşağıdaki yazım tarzını benimsememiz gerekir:
>>> liste = []
>>> for i in isimler:
... if i[0] == "A":
... liste.append(liste)
>>> print(liste)
['Ayşe', 'Ali', 'Aycan', 'Ayhan', 'Ayla']
Liste üreteçlerini, bir önceki bölümde öğrendiğimiz all() ve any() fonksiyonlarıyla birlikte de kullanabiliriz. Mesela elimizde şöyle bir liste olsun:
>>> a = [10, 15, 6, 3, 32, 45, 25]
Diyelim ki bu listedeki sayıların hepsinin 20’den büyük olup olmadığını denetlememiz gerekiyor. O zaman şöyle bir kod yazabiliriz:
>>> all([i > 20 for i in a])
False
Yaptığımız işlemden “False” sonucunu aldık. Demek ki listedeki bütün sayılar 20’den büyük değilmiş...
Python’daki liste üreteçleri pek çok konuda işlerimizi kolaylaştırmamıza yardımcı olur. Mesela bir dizi içindeki bütün sayıları hızlı bir şekilde belli bir işleme tabi tutmak istersek liste üreteçlerinden yararlanabiliriz:
>>> liste = [1, 2, 3, 4, 5, 6]
>>> [pow(i, 3) for i in liste]
[1, 8, 27, 64, 125, 216]
Bu kodlar, liste içindeki bütün sayıların tek tek 3. kuvvetlerini hesaplamamızı sağladı.
9.10. Python’da Kodlara Yorum Eklemek¶
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ışardan 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ın 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. Yorumlarla desteklenmiş örnek bir kod parçası şöyle olabilir:
#Boş bir liste oluşturuyoruz. Bu liste
#kullanıcının girdiği verileri tutacak
liste = []
#Şimdi kullanıcıya adını soruyoruz...
ad = input("Lütfen adınızı giriniz: ")
#Kullanıcıdan aldığımız veriyi listeye ekliyoruz.
liste.append(ad)
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 programcı 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!...
Yukarıda olduğu gibi yorumlarımızı ilgili olduğu koddan önce yazmak yerine, yorumlarımızı kodlarımızın farklı yerlerine de ekleyebiliriz:
liste = [] #boş bir liste oluşturuyoruz...
Python’da 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...
Python’da yorumlar asıl amaçlarının dışında da bazı başka amaçlara hizmet edebilir.
Örneğin, 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:
#Boş bir liste oluşturuyoruz. Bu liste
#kullanıcının girdiği verileri tutacak
liste = []
#Şimdi kullanıcıya adını soruyoruz...
ad = input("Lütfen adınızı giriniz: ")
#Kullanıcıdan aldığımız veriyi listeye ekliyoruz.
liste.append(ad)
#Kullanıcı "p" harfine basarsa liste içeriğini ekrana dökelim.
#if ad == "p":
# print(liste)
Burada, programa henüz eklemek istemediğimiz bir özelliği, yorum içine alarak şimdilik iptal ediyoruz (İngilizce’de 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 (#!/usr/bin/env python satırı 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 İngilizce’de “uncomment” diyorlar).
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 #
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#
#######################################################
#Boş bir liste oluşturuyoruz. Bu liste
#kullanıcının girdiği verileri tutacak
liste = []
#Şimdi kullanıcıya adını soruyoruz...
ad = input("Lütfen adınızı giriniz: ")
#Kullanıcıdan aldığımız veriyi listeye ekliyoruz.
liste.append(ad)
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...
9.11. Karakter Dizilerini Biçimlendirme¶
Python’daki özel bir fonksiyon/metot yardımıyla karakter dizilerine müdahale edebilir, bunları istediğimiz şekilde biçimlendirebiliriz.
Öncelikle elimizdekilerle neler yapabildiğimize bakalım. Şimdiye kadar öğrendiklerimizi kullanarak şöyle bir kod yazabiliyoruz:
>>> lider = input("Şampiyonun ismini giriniz: ")
>>> print("Bu senenin şampiyonu", lider, "Tebrikler.")
Burada kullanıcımız “lider” değişkeni için ne yazarsa, print() fonksiyonu içinde ilgili yere o kelime yerleştirilecektir.
Gördüğünüz gibi, yukarıdaki yapıyı kullanarak isteğimizi yerine getirebiliyoruz. Ama Python’da bu tür işlemleri ve daha fazlasını çok daha esnek bir biçimde yerine getirmenin yolları vardır.
Öncelikle yukarıda yaptığımız örneğe bakalım. Dediğim gibi, yukarıdaki kodlar temel olarak istediğimiz şeyi yerine getiriyor. Ama tam olarak değil... Diyelim ki kullanıcı burada “Şampiyonun ismini giriniz: ” cümlesine karşılık olarak “Sarıyer” yazdı... O zaman çıktımız şöyle görünecektir:
Bu senenin şampiyonu Sarıyer Tebrikler.
Burada aslında çıktı düzgün değil. Türkçe’nin kurallarına göre bu çıktının şöyle olması gerekiyordu:
Bu senenin şampiyonu Sarıyer. Tebrikler.
Yukarıdaki kodları kullanarak “Sarıyer” kelimesine yapışık şekilde bir nokta işareti koyabilmek için deveye hendek atlatmanız gerekir...
>>> lider = input("Şampiyonun ismini giriniz: ")
>>> print("Bu senenin şampiyonu", lider, "\b.", "Tebrikler.")
Buradaki “\b” işareti henüz öğrenmediğimiz bir kaçış dizisidir (“escape sequence”). Bu konuyu birkaç bölüm sonra göreceğiz.
Peki ya kullanıcının girdiği kelimeyi tırnak içine almak isterseniz ne yapacaksınız? İşte bunu yapmanız yukarıdaki yöntemle imkansızdır.
Bu tür işlemleri yapabilmek için karakter dizilerinin format() adlı metodunu devreye sokacağız. Yukarıdaki uygulamayı temel alarak basit bir örnek verelim:
>>> lider = input("Şampiyonun ismini giriniz: ")
>>> print("Bu senenin şampiyonu {0}. Tebrikler.".format(lider))
Bu yapı gözünüze biraz karışık mı göründü? Hiç endişelenmeyin aslında çok basittir kullanımı. İsterseniz daha belirgin bir örnek verelim:
>>> "{0}".format("istihza")
'istihza'
Gördüğünüz gibi, format() metodunun, daha önce öğrendiğimiz herhangi bir metottan farkı yok... Örneğin listeleri anlatırken liste metotlarından da bahsetmiştik. Liste metotları “liste.metot()” şeklinde kullanılıyordu. format() metodu da böyledir. Bu da “karakter_dizisi.format()” şeklinde kullanılır.
Burada “{0}” şeklinde gösterdiğimiz ifade, format() metodunun parantezi içinde yer alan “istihza” adlı karakter dizisinin yerini tutuyor. Parantez içine ne yazarsanız, “{0}” ifadesinin yerinde o görünecektir:
>>> lider = input("Şampiyonun ismini giriniz: ")
>>> print("{0}".format(lider))
format() metodu içindeki ifadenin aslında bir “demet” olduğunu söylersek sanırım “{0}” sözünün anlamı biraz daha netleşecektir. Buradaki “0” sayısı, parantez içinde yazdığımız demetin öğelerinin sırasını gösteriyor. Şöyle bir örnek verelim:
>>> print("Yıllardan {0}, aylardan {1}".format(1980, "Mayıs"))
Yıllardan 1980, aylardan Mayıs
Gördüğünüz gibi, alışık olduğumuz şekilde saymaya sıfırdan başlıyoruz... “(1980, “Mayıs”)” demetinin 0. ve 1. öğelerini karakter dizisi içine tek tek yerleştiriyoruz. Burada önemli nokta şu: Karakter dizisi içinde belirlediğimiz biçimlendirme işaretlerinin sayısı kadar öğeyi parantez içindeki demete yazıyoruz.
Bu arada, biçimlendirme işaretlerinin sayı sırasına göre yazılması şart değil. Yani şöyle bir şey de yapabiliriz:
>>> print("Yıllardan {1}, aylardan {0}".format(1980, "Mayıs"))
Tabii bu şekilde elde ettiğimiz çıktıdaki öğelerin yeri de farklı olacaktır...
Yıllardan Mayıs, aylardan 1980
En baştaki örneğimize geri dönelim:
>>> lider = input("Şampiyonun ismini giriniz: ")
>>>print("Bu senenin şampiyonu", lider, "Tebrikler.")
Burada “lider” değişkenini karakter dizisi içinde mesela tırnak içine alamıyoruz... Ama artık format() adlı metodu bildiğimize göre bu işlemi yapmak bizim için çocuk oyuncağı:
>>> lider = input("Şampiyonun ismini giriniz: ")
>>> print("Bu senenin şampiyonu '{0}'. Tebrikler.".format(lider))
Gördüğünüz gibi, karakter biçimlendirme işaretleri bize epey esneklik kazandırıyor.
Bu metoda alışmak için çok basit bir örnek daha verelim:
>>> print("{0}; {1} ve {2}'i seviyor!".format("Ali", "Ayşe", "Zeynep"))
Ali; Ayşe ve Zeynep'i seviyor!
Gördüğünüz gibi, format() metodu istediğimiz sayıda öğe alabiliyor.
Biçimleyici olarak sadece sayılardan yararlanmak zorunda da değiliz. Eğer istersek sayı yerine daha anlamlı kelimeler de kullanabiliriz:
>>> lider = input("Şampiyonun ismini giriniz: ")
>>> ikinci = input("İkinci olan takımın ismini giriniz: ")
>>> print("Şampiyon {bir}. {iki} ikinci oldu...".format(bir=lider, iki=ikinci))
Burada biçimlendirme işaretleri olarak “bir” ve “iki” değişkenlerini kullandığımıza dikkat edin. Daha sonra da format() metodunun parantezleri içinde bu “bir” ve “iki” adlı değişkenleri tanımlıyoruz...
Şöyle bir örnek verelim:
>>> a = 10
>>> b = 3
>>> print("{0} ile {1} bölünürse {2} elde edilir.".format(a, b, a/b))
10 ile 3 bölünürse 3.33333333333 elde edilir.
Burada istersek “.” işaretinden sonra gelen basamak sayısını keyfimize göre ayarlayabiliriz:
Eğer noktadan sonra herhangi bir sayı olmasını istemezsek şu kodları kullanıyoruz:
>>> print("{0} ile {1} bölünürse {2:.0f} elde edilir.".format(a, b, a/b))
10 ile 3 bölünürse 3 elde edilir.
Burada dilimleme (slicing) işlemine benzer bir şey yaptığımıza dikkat edin. Küme parantezleri içinde yer alan “.0f” ifadesi noktadan sonra kaç basamak gösterileceğini belirliyor. Buna göre noktadan sonra sıfır sayıda basamak olacak... Bir de şuna bakalım:
>>> print("{0} ile {1} bölünürse {2:.1f} elde edilir.".format(a, b, a/b))
10 ile 3 bölünürse 3.3 elde edilir.
Burada noktadan sonra bir basamak istediğimizi belirttik. “.1f” ifadesi içindeki sayıyı artırarak basamak sayısını istediğiniz şekle getirebilirsiniz. Buradaki “f” harfi “fixed-point number” (sabit noktalı sayı) ifadesinin baş harfi... Bu harf, sayımızın sabit noktalı bir sayı cinsinden verileceğini gösteriyor.
Python 3.0 ile birlikte gelen bu format() adlı metot oldukça gelişmiş özellikler sunar. Hatta bu yapı Python içinde minik bir dil gibidir. Biz bu bölümde bu metodun bazı temel özelliklerini vermekle yetindik. İlerki bir bölümde bu metot daha ayrıntılı bir şekilde incelenecektir.
9.12. enumerate() Fonksiyonu¶
Bu fonksiyon Python’daki en pratik ve yararlı metotlardan bir tanesidir. “enumerate” kelimesi Türkçe’de “numaralandırmak” anlamına gelir. İsminden de anlaşılacağı gibi bu fonksiyon yardımıyla numaralandırma işlemleri yapacağız.
Örneğin, Python’daki bir veri tipinin bütün metotlarını nasıl sıralayacağımızı biliyoruz:
>>> dir(list)
Bu komut “list” (liste) adlı veri tipinin bütün metotlarını listeleyecektir. İşte bu metotları numaralandırmak istememiz halinde enumerate() adlı fonksiyon yardımımıza koşacaktır.
İşe bu metodu biraz tanıyarak başlayalım. Mesela şöyle bir şey yazalım:
>>> enumerate("istihza")
<enumerate object at 0x00C16238>
Gördüğünüz gibi, enumerate() fonksiyonunu doğrudan kullandığımızda bize bir “numaralandırma nesnesi” (enumerate object) veriyor.
Bu nesnenin içeriğini görmek için list() fonksiyonunu kullanabiliriz. Hatırlarsanız range() fonksiyonu için de list()‘ten yararlanmıştık...
>>> list(enumerate("istihza"))
[(0, 'i'), (1, 's'), (2, 't'), (3, 'i'), (4, 'h'), (5, 'z'), (6, 'a')]
Şimdi bu çıktıyı dikkatle inceleyelim. Burada bir liste içinde her biri bir sayı ve harften oluşan, iki öğeli demetler görüyoruz. Bu tabloyu daha net görebilmek için for döngülerinden yararlanabiliriz:
>>> for i in enumerate("istihza"):
... print(i)
...
(0, 'i')
(1, 's')
(2, 't')
(3, 'i')
(4, 'h')
(5, 'z')
(6, 'a')
Gördüğünüz gibi, bir sayı ve bir harften oluşan çiftler elde ediyoruz. Alıştırma olsun diye, enumerate() fonksiyonunu liste üreteçleri (list comprehensions) ile birlikte kullanalım:
>>> [i for i in enumerate("istihza")]
[(0, 'i'), (1, 's'), (2, 't'), (3, 'i'), (4, 'h'), (5, 'z'), (6, 'a')]
Bu fonksiyonun nasıl bir çıktı verdiğini öğrendiğimize göre, bu çıktıyı ihtiyaçlarımız ve isteklerimiz doğrultusunda evirip çevirebiliriz. Mesela “istihza” kelimesindeki harfleri düzgün bir şekilde numaralandıralım:
>>> for i in enumerate("istihza"):
... print(i[0], i[1])
...
0 i
1 s
2 t
3 i
4 h
5 z
6 a
Hatta istersek sayı ve harflerin arasına birer işaret de yerleştirebiliriz:
>>> for i in enumerate("istihza"):
... print(i[0], i[1], sep="==>")
...
0==>i
1==>s
2==>t
3==>i
4==>h
5==>z
6==>a
Hatta ve hatta artık format() gibi oldukça esnek bir metodu da biliyor olduğumuza göre daha karmaşık şeyler de yapabiliriz:
>>> for i in enumerate("istihza"):
... print("{0} : '{1}'".format(i[0], i[1]))
...
0 : 'i'
1 : 's'
2 : 't'
3 : 'i'
4 : 'h'
5 : 'z'
6 : 'a'
enumerate() fonksiyonunun verdiği çıktının çift öğeli demetlerden oluştuğunu görmüştük. Bu bilgiyi kullanarak yapıyı biraz sadeleştirebiliriz:
>>> for k, v in enumerate("python"):
... print("{0} : '{1}'".format(k, v))
...
0 : 'p'
1 : 'y'
2 : 't'
3 : 'h'
4 : 'o'
5 : 'n'
Burada “for k, v...” satırındaki “k” harfi enumerate() fonksiyonu tarafından üretilen iki öğeli demetin birinci öğesini, “v” harfi ise o demetin ikinci öğesini temsil ediyor. Yani “k” sayıyı, “v” ise harfi temsil ediyor... Daha sonra print() fonksiyonuyla öğeleri ekrana yazdırırken de bu harflerden yararlanıyoruz...
Daha önce veri tiplerini anlatırken sık sık kullandığımız bir kod parçasını temel alarak enumerate() ile ilgili bir örnek daha yapalım.
Hatırlarsanız len() fonksiyonunu anlatırken şöyle bir örnek vermiştik:
>>> liste = ["kitap", "defter", "kalem", "silgi", "tebeşir",
... "tahta", "sıra", "öğrenci", "okul", "önlük"]
>>> for sondarbe in range(len(liste)):
... print(sondarbe+1, liste[sondarbe], sep=". ")
...
1. kitap
2. defter
3. kalem
4. silgi
5. tebeşir
6. tahta
7. sıra
8. öğrenci
9. okul
10.önlük
Artık enumerate() fonksiyonunu öğrendiğimize göre bu işlemi çok basit ve verimli bir şekilde halledebiliriz:
>>> liste = ["kitap", "defter", "kalem", "silgi", "tebeşir",
... "tahta", "sıra", "öğrenci", "okul", "önlük"]
>>> for k, v in enumerate(liste):
... print(k, v, sep=". ")
...
0. kitap
1. defter
2. kalem
3. silgi
4. tebeşir
5. tahta
6. sıra
7. öğrenci
8. okul
9. önlük
Yalnız, gördüğünüz gibi burada bir eksiklik var. Listemizdeki sayılar 0’dan başlıyor. Halbuki biz saymaya 1’den başlanmasını istiyoruz. enumerate() fonksiyonunu kullanarak bunu yapmak çok basittir:
>>> for k, v in enumerate(liste, 1):
... print(k, v, sep=". ")
...
1. kitap
2. defter
3. kalem
4. silgi
5. tebeşir
6. tahta
7. sıra
8. öğrenci
9. okul
10. önlük
Gördüğünüz gibi, enumerate() fonksiyonuna ikinci parametre olarak verdiğimiz sayı, ilk öğenin hangi numaraya sahip olacağını gösteriyor. Biz burada ilk öğenin “1” sayısına sahip olmasını istedik...
Son bir örnek daha verip bu konuyu kapatalım:
>>> for k, v in enumerate(dir(dict), 1):
... print(k, v)
Bu kodlarla “dict” adlı veri tipinin bütün metotlarını numaralandırarak ekrana basıyoruz...
9.13. Kaçış Dizileri (Escape Sequences)¶
Hatırlarsanız ilk derslerimizin birinde şöyle bir örnek vermiştik:
>>> print("Ahmet, \"Bugün Adana'ya gidiyoruz,\" dedi.")
O derste, buradaki “\” işaretinin bir “kaçış dizisi” olduğundan söz etmiştik. Bu işaret, karakter dizisini başlatan çift tırnak ile, cümle içinde geçen çift tırnakların birbirine karışmasını engelliyordu. Aynı şekilde, yeni bir satıra geçmemizi sağlayan “\n” işaretinin de bir kaçış dizisi olduğunu söylemiştik. Python’da bol miktarda kaçış dizisi bulunur ve bunların her biri birbirinden farklı görevleri yerine getirir.
Python’da temel olarak iki adet kaçış dizisi vardır: “r” ve “\”. Bu bölümde bu kaçış dizilerini ve bunların varyasyonlarını tek tek inceleyeceğiz:
“\”
Bu işaret hemen hemen bütün programlama dillerinin demirbaşıdır. Bunun düz bölü değil ters bölü olduğuna özellikle dikkat etmeliyiz...
Bu işaretin ne işe yaradığını daha önceki derslerimizde görmüştük. Yukarıya da aldığımız örneğe baktığımızda bu işaretin görevi açıkça ortaya çıkıyor. “\” işareti kendisinden sonra gelen herhangi bir karakterin özel bir anlamı olduğunu gösterir. Mesela şu örneğe bakalım:
>>> print("Kezban, \"Nen var kuzum,\" dedi.")
Burada “\” işareti, kendisinden sonra gelen çift tırnak karakterinin özel bir anlamı olduğunu belirtiyor. Yani bu çift tırnağın, karakter dizisini başlatan ve bitiren çift tırnaklardan farklı olduğunu gösteriyor. Aynı işareti öteki özel çift tırnağın da önüne yerleştirdiğimizde yukarıdaki karakter dizisini hatasız olarak ekrana yazdırabiliyoruz.
Mesela bu kaçış dizisi “n” harfinden önce gelirse, bu harfin de özel bir anlamı olduğunu belirtecektir. “\n” adlı kaçış dizisi yeni satıra geçilmesini sağlar:
>>> print("Bu birinci satır.\nBu da ikinci satır...")
Bu birinci satır.
Bu da ikinci satır...
Python’daki kaçış dizileri genel olarak “\” işaretinin başka harflerle birleşerek özel bir anlam oluşturmasıyla meydana getirilir. Şimdi bu “\” işaretinin yanına gelip özel bir anlam kazanan harfleri ve bu şekilde ortaya çıkan kaçış dizilerini inceleyelim...
“\t”
Eğer “\” işaretini “t” harfinden önce getirirsek, ortaya çıkan işaret (“\t”), karakter dizisi içinde bir sekme (tab) oluşturacaktır:
>>> print("Aramızda \tdağlar var...")
Aramızda dağlar var...
Eğer daha büyük bir sekmeye ihtiyacınız varsa, “\t” kaçış dizisini birden fazla sayıda kullanabilirsiniz:
>>> print("Uzak... \t\tçok uzak...")
Uzak... çok uzak...
Elbette birden fazla farklı kaçış dizisini bir arada da kullanabiliriz:
>>> print("Aşağıda \n\thava nasıl?")
Aşağıda
hava nasıl?
Gördüğünüz gibi “\t” adlı kaçış dizisi bizi boşluk tuşuna üst üste birkaç kez basmaktan kurtarıyor. Karakter dizimiz içinde sekmeye ihtiyacımız olduğunda bu kaçış dizisi epey işimize yarayacak.
Şimdi başka bir kaçış dizisine bakalım.
“\\”
Şimdiye kadar öğrendiğimiz gibi, “\”, “\t” ve “\n” işaretlerini bir karakter dizisi içinde kullandığımızda her biri özel bir görevi yerine getiriyor. Peki ya biz yazdığımız bir karakter dizisi içinde bu işaretleri göstermek istersek ne yapacağız? Mesela “\n” ifadesinin kendisini bir karakter dizisi içine yazıp kullanıcılarımıza gösteremez miyiz?
Elbette gösterebiliriz. Eğer yazdığımız bir karakter dizisi içinde bu kaçış dizilerinin kendisini göstermek istersek şöyle bir yol tutuyoruz:
>>> print("Öğrendiğimiz karakter dizileri şunlardır: \\n, \\t")
Öğrendiğimiz karakter dizileri şunlardır: \n, \t
Gördüğünüz gibi, “\t”, “\n” veya “\” kaçış dizisinin kendisini ekrana basabilmek için “\” işaretini çiftleyerek “\\” şeklinde yazmamız gerekiyor...
Eğer sadece “\” işaretini göstermek istersek bazı noktalara dikkat etmemiz gerekiyor.
Mesela şu örneğe bakalım:
>>> print("demirbaş kaçış dizisi: \.")
demirbaş kaçış dizisi: \.
Gördüğünüz gibi, eğer “\” işaretini tek başına kullanacaksak özel bir şey yapmamıza gerek yok. Yalnız burada şuna dikkat etmemiz gerek: “\” işaretini çiftlemeden yazabilmemiz için, bu işaretin sağına herhangi bir özel karakterin gelmemesi lazım. Bu ne demek? Hemen bir örnek verelim:
>>> print("demirbaş kaçış dizisi: \")
SyntaxError: EOL while scanning string literal
Bu örnek Python’un bize bir hata mesajı göstermesine neden oluyor... Bunun sebebi aslında “\” işaretinin bu örnekte tek başına kullanılmıyor olması. Yani “\” işaretinden sonra karakter dizisinin bitiş tırnağı geliyor... Bildiğimiz gibi, “\” işareti çift veya tek tırnak ile birlikte kullanılırsa, Python bu tek veya çift tırnağı farklı bir şekilde algılayacaktır. Mesela bu örnekte, kapanış tırnağından hemen önce gelen “\” kaçış dizisi nedeniyle Python bu kapanış tırnağını sanki yokmuş gibi varsayacak ve bize hata mesajı gösterecektir... Bunun olmasını engellemek için, “\” işaretini çiftlememiz gerekiyor:
>>> print("demirbaş kaçış dizisi: \\")
demirbas kaçış dizisi: \
Bir de şu örneğe bakalım:
>>> print("Öğrendiğimiz karakter dizileri şunlardır: \, \\n, \\t")
Şimdiye kadar öğrendiğimiz karakter dizileri şunlardır: \, \n, \t
Burada “\” kaçış dizisini çiftlememize gerek kalmadığına dikkat edin. Çünkü bu işaretten hemen sonra gelen virgül işareti Python açısından özel anlam taşıyan bir karakter değildir. Bu yüzden yukarıdaki karakter dizisinin ekrana basılmasında herhangi bir sorunla karşılaşmıyoruz. Ama “\” işaretini yukarıdaki örnekte en sona yerleştiremeyeceğimize dikkat edin:
>>> print("Öğrendiğimiz karakter dizileri şunlardır: \\n, \\t, \")
SyntaxError: EOL while scanning string literal
Bu hatayı almamızın nedeni, “\” işaretini en sona koyduğumuzda bu işaretin, karakter dizisini kapatan tırnak işaretleriyle çakışmasıdır... Yukarıda verdiğimiz print(“demirbaş kaçış dizisi: \.”) örneğinde “\” işaretinden sonra bir “nokta” getirerek sorundan kaçtığımıza dikkat edin... Burada nokta koymak yerine boşluk karakteri de koyabilirdik:
>>> print("demirbaş kaçış dizisi: \ ")
demirbaş kaçış dizisi: \
Sözün özü, “\” işaretini tek başına kullandığımızda sağındaki karakterle çakışma riski varsa, çözüm olarak “\” işaretini çiftleme yoluna gidiyoruz.
“\v”
Eğer “\” işaretini “v” harfiyle birlikte kullanırsak “düşey sekme” denen şeyi elde ederiz. Hemen bir örnek verelim:
>>> print("düşey\vsekme")
düşey
sekme
Yalnız bu “\v” adlı kaçış dizisi her işletim sisteminde çalışmayabilir... Dolayısıyla, birden fazla platform üzerinde çalışmak üzere tasarladığınız programlarınızda bu kaçış dizisini kullanmanızı önermem.
“\b”
“\” kaçış dizisinin, biraraya geldiğinde özel bir anlam kazandığı bir başka harf de “b”dir... “\b” kaçış dizisini karakter dizisi biçimlendirme bölümünde bir örnek içinde kullanmıştık. Örneğimiz şöyleydi:
>>> lider = input("Şampiyonun ismini giriniz: ")
>>> print("Bu senenin şampiyonu", lider, "\b.", "Tebrikler.")
Burada “\b” adlı kaçış dizisi, kendisinden önceki bir karakteri silme görevini üstleniyor. Bu örnekte “lider” değişkeni ekrana yazdırılırken kendisinden sonra bir adet boşluk karakteri olacaktır çıktıda... İşte “\b” kaçış dizisi bu boşluk karakterini siliyor. “\b” kaçış dizisinin görevi klavyedeki “backspace” tuşuyla aynıdır...
“\b” kaçış dizisini bir örnekte daha görelim:
>>> print("merhaba\b")
Ne oldu? Bu karakter dizisi hiç bir şeyi değiştirmedi, değil mi? Çok normal. Çünkü bu kaçış dizisi biraz kaprislidir. “\b” adlı kaçış dizisi, çalışabilmek için kendisinden sonra da en az bir karakter olmasını ister. Dolayısıyla yukarıdaki örnekte “\b” kaçış dizisi görevini yerine getirmiyor, ama şu örnekte bu kaçış dizisi görevini eksiksiz olarak yerine getirecektir:
>>> print("merhaba\b dünya")
merhab dünya
Burada “\b” kaçış dizisinden sonra boşluk karakteri var. Bu yüzden bu kaçış dizisi böyle bir ortamda görevini yerine getirebiliyor. Eğer sadece “print(“merhaba”)” yazıp “merhab” çıktısını elde etmek isterseniz şöyle bir hileye başvurabilirsiniz:
>>> print("merhaba\b ")
merhab
Burada gördüğünüz gibi, “\b” kaçış dizisinden sonra bir boşluk bırakarak kandırmaca yoluna gittik...
Bu kaçış dizisini art arda yazarak tuhaf şeyler de yapabilirsiniz...
>>> print("merhaba\b\b ")
merha a
Burada “\b\b” kaçış dizilerinin yaptığı şey, sola doğru iki karakter atlayıp, ulaştığı noktaya bir adet boşluk karakteri yerleştirmektir. Şu örnekte durum biraz daha açık görünecektir:
>>> print("merhaba\b\bf")
merhafa
Yani bu karakter dizisini kullanarak şöyle saçma bir şey de yapabilirsiniz:
>>> print("merhaba\b\b\b\b\b\b\bgülegüle")
gülegüle
Bu kodları şöyle yazarak biraz beyin jimnastiği yapmak isteyebilirsiniz:
>>> print("merhaba{0}{1}".format("\b"*len('merhaba'), "gülegüle"))
gülegüle
Gördüğünüz gibi, bu karakter dizisi rahatlıkla suyu çıkarılabilecek bir araçtır...
“\r”
“\” işaretini birarada kullanacağımız başka bir harfimiz ise “r” harfidir...
“\r” kaçış dizisi, bir karakter dizisinin en başına gelmemizi sağlar. Mesela bu karakter dizisini kullanarak “tank” kelimesini “bank”a çevirebiliriz!
>>> print("tank\rb")
bank
“\a”
“\” kaçış dizisini son olarak “a” harfi ile birlikte kullanacağız. “\a” kaçış dizisi bilgisayarımızın “bip” sesi çıkarmasını sağlar:
>>> print("\a")
==bip!==
Tıpkı “\v” kaçış dizisi gibi, bu kaçış dizisi de her işletim sisteminde çalışmayabilir. Örneğin bu kaçış dizisinin GNU/Linux’ta çalışacağının garantisi yoktur...
“r”
Bu karakter dizisi kimi durumlarda oldukça faydalı olabilecek bir araçtır. Diyelim ki bilgisayarımızda tam yolu “C:\test\rehber.txt” olan bir dosya var. Bu dosyanın tam yolunu print() fonksiyonu yardımıyla ekrana yazdırmak istersek şöyle bir çıktı alırız:
>>> print("C:\test\rehber.txt")
ehber.txtst
Burada olan şey şu: Python, “C:\test\rehber.txt” içindeki “\t” ve “\r” ifadelerini birer kaçış dizisi olarak algıladı. Dolayısıyla “C:”den sonra sanki sekme tuşuna basılmış gibi davrandıktan sonra, “\r” kaçış dizisi zannettiği şeyin etkisiyle de karakter dizisinin başına dönüp “ehber.txt” kısmını oraya yapıştırdı... Bu örnek, Python’daki kaçış dizilerini kullanmasak bile onları en azından tanımamız gerektiğini açık seçik gösteriyor. İşte bu tür sürprizleri engellemek için “r” adlı kaçış dizisinden yararlanacağız. Bunun, daha önce gördüğümüz “\r” kaçış dizisinden farklı olduğuna dikkat edin:
>>> print(r"C:\test\rehber.txt")
C:\test\rehber.txt
Gördüğünüz gibi, “r” kaçış dizisinin kullanım yeri öteki kaçış dizilerine göre farklılık gösteriyor. Bu kaçış dizisini karakter dizisinin içinde değil, dışında kullanıyoruz. Bu kaçış dizisinin görevi, karakter dizisi içinde geçen bütün kaçış dizilerini etkisiz hale getirmektir... Dolayısıyla daha önce verdiğimiz şu örneği:
>>> print("Öğrendiğimiz karakter dizileri şunlardır: \\n, \\t, \\")
...şöyle de yazabiliriz...
>>> print(r"Öğrendiğimiz karakter dizileri şunlardır: \n, \t")
Burada kullandığımız “r” kaçış dizisi, karakter dizisi içindeki bütün kaçış dizilerini etkisiz hale getirdiği için, bizim cümle içinde geçen karakter dizilerini çiftlememize gerek kalmadı.
Ancak “r” adlı karakter dizisi “\” kaçış dizisini etkisizleştiremez. Dolayısıyla şöyle bir yazım, hata almamıza yol açacaktır:
>>> print(r"Öğrendiğimiz karakter dizileri şunlardır: \n, \t, \\, \")
Bu durumdan kurtulmanın tek yolu, en sona bir boşluk karakteri yerleştirmektir:
>>> print(r"Öğrendiğimiz karakter dizileri şunlardır: \n, \t, \\, \ ")
Böylece Python’daki kaçış dizilerini gözden geçirmiş olduk. Gelin isterseniz kaçış dizilerine şöyle topluca bir göz atalım:
- \n
- Yeni satır oluşturur.
- \’
- Tek tırnak içine aldığımız karakter dizilerinde tek tırnak kullanmamızı sağlar.
- \”
- Çift tırnak içine aldığımız karakter dizilerinde çift tırnak kullanmamızı sağlar.
- \a
- Sistemimizin “bip” sesi çıkarmasını sağlar (Her platformda çalışmaz).
- \b
- Kendisinden önce gelen karakteri siler.
- \r
- Karakter dizisinin en başına dönülmesini sağlar.
- \t
- Karakter dizisi içinde sekme oluşturur.
- \v
- Düşey sekme oluşturur (Her platformda çalışmaz).
- \\
- Herhangi bir kaçış dizisini etkisiz hale getirir.
- r
- Karakter dizisi içinde geçen bütün kaçış dizilerini etkisiz hale getirir.