Pyton Hakkında Ufak kodlar

print komutunun görevi, ekrana bir şeyler yazdırmamızı sağlamaktır. Mesela bu komutu tek başına kullanmayı deneyelim:

>>> print

yazıp hemen ENTER tuşuna basalım.

Not
Yukarıdaki komutta gördüğümüz >>> işaretini kendimiz yazmayacağız. O işaret, etkileşimli kabuğun görüntüsünü temsil ediyor. Bizim sadece print yazmamız yeterli.
Ne oldu? Python bir satır boşluk bırakarak alt satıra geçti, değil mi? Bunu ona yapmasını biz söyledik, o da yaptı...
Şimdi de boş bir satır bırakmak yerine ekrana bir şeyler yazmasını söyleyelim Python’a:

>>> print "Programa hoşgeldiniz. Lütfen giriş yapın!"

Bu satırı yazıp ENTER tuşuna bastıktan sonra ekranda Programa hoşgeldiniz. Lütfen giriş yapın! çıktısını görmemiz gerekiyor.
Gördüğünüz gibi print komutunun ardından gelen “Programa hoşgeldiniz. Lütfen giriş yapın!” ifadesini çift tırnak içinde belirtiyoruz. Eğer burada çift tırnak işaretini koymazsak veya koymayı unutursak Python bize bir hata çıktısı gösterecektir. Zaten yukarıdaki komutu verdikten sonra bir hata alıyorsanız, çok büyük bir ihtimalle tırnakları düzgün yerleştirmemişsinizdir.
Biz istersek yukarıdaki örnekte çift tırnak yerine tek tırnak (‘) da kullanabiliriz. Tırnak seçiminde özgürüz:

>>> print ’Programa hoşgeldiniz. Lütfen giriş yapın!’

Bu komut da bize istediğimiz çıktıyı başarıyla verecektir. Dediğimiz gibi, kullanacağınız tırnak tipi konusunda özgürsünüz. Ancak tırnak seçiminde bazı noktalara da dikkat etmemiz gerekiyor. Diyelim ki “İstanbul’un 5 günlük hava tahmini” ifadesini ekrana yazdırmak istiyoruz. Bunu çift tırnak kullanarak şu şekilde gösterebiliriz:

>>> print "İstanbul’un 5 günlük hava tahmini"

Bu komut bize hatasız bir şekilde İstanbul’un 5 günlük hava tahmini çıktısını verir. Ancak aynı işlemi tek tırnakla yapmaya çalışırsak şöyle bir hata mesajı alırız:
File "<stdin>", line 1
print ’İstanbul’un 5 günlük hava tahmini’
^
SyntaxError: invalid syntax
Bunun sebebi, “İstanbul’un” kelimesindeki kesme işaretinden ötürü Python’ın tırnakların nerede başlayıp nerede bittiğini anlamamasıdır. Eğer mutlaka tek tırnak kullanmak istiyorsak, kodu şu hale getirmemiz gerekir:

>>> print ’İstanbul\\’un 5 günlük hava tahmini’

Aynı şekilde, şöyle bir örnekte de çift tırnak bize zorluk çıkarır:

>>> print "Python’da önemli komutlardan biri de "print" komutudur."

Bu komut bize şöyle bir hata mesajı verecektir:
File "<stdin>", line 1
print "Python’daki önemli komutlardan biri de "print" komutudur."
^
SyntaxError: invalid syntax
Bu cümleyi düzgün olarak gösterebilmek için yukarıdaki komutu şöyle yazmamız gerekir:

>>> print "Python’da önemli komutlardan biri de \\"print\\" komutudur."

Yukarıdaki iki örnekte gördüğümüz “\\” işaretleri, kendilerinden sonra gelen karakterlerin Python tarafından normalden farklı algılanmasını sağlar. Yani bu işaret sayesinde, cümle içinde geçen tırnak işaretleri, cümleyi başlatan ve bitiren tırnak işaretleriyle karışmaz. Buna benzer hatalardan kaçmamızı sağlayan bu tür işaretlere Python dilinde Kaçış Dizileri (Escape Sequences) adı verilir. Şimdilik bu kaçış dizisi kavramını çok fazla kafamıza takmadan yolumuza devam edelim. Zaten birkaç bölüm sonra bu kaçış dizilerinden ayrıntılı olarak söz edeceğiz. Biz şu anda sadece, cümle içinde geçen tırnak işaretlerine dikkat etmemiz gerektiğini bilelim yeter.
Dediğimiz gibi, print komutu Python’daki en önemli ve en temel komutlardan biridir. Python’la yazdığınız programlarda kullanıcılarınıza herhangi bir mesaj göstermek istediğinizde bu print komutundan yararlanacaksınız. Dilerseniz bu önemli komutla birkaç örnek daha yapalım elimizi alıştırmak için:

>>> print "GAME OVER"

GAME OVER

>>> print "FINISH HIM!"

FINISH HIM!

>>> print "Linux’un güçlü yanları"

Linux’un güçlü yanları

>>> print ’Linux\\’un güçlü yanları’

Linux’un güçlü yanları

Yukarıdaki son örnekte “\\” işaretini neden kullandığımızı biliyorsunuz. “Linux’un güçlü yanları” cümlesini tek tırnak içine aldığımız için, Linux’un kelimesindeki kesme işaretinden (‘) ötürü Python tırnakların nerede başlayıp nerede bittiğini anlayamaz. Python’ın kafasını karıştırmamak için burada kaçış dizilerinden yararlanarak düzgün çıktı almayı sağlıyoruz. Yani Linux’un kelimesindeki kesme işaretiyle karşılaşan Python’a şöyle demiş oluyoruz: “Bu tırnak senin aradığın tırnak değil. Sen yoluna devam et. Biraz ilerde aradığın tırnağı bulacaksın!“

Karakter Dizileri
Python’daki en önemli komutlardan biri olan print‘i öğrendiğimize göre, bundan sonraki konuları daha rahat anlayabilmemiz için bazı kavramlardan söz etmemiz faydalı olabilir. Bu bölümde “karakter dizisi” diye bir şeyden söz edeceğiz. Yabancılar buna string adı veriyor...
Aslında biz karakter dizisinin ne olduğunu biliyoruz. Yukarıda print komutunu işlerken bu karakter dizilerini zaten kullandık. Oradaki örneklerden de göreceğiniz gibi, karakter dizileri, tırnak içinde gösterilen herhangi bir “şey”dir. Tanımından da anlaşılacağı gibi, tırnak içinde gösterebildiğimiz her şey bir karakter dizisi olabilir. Mesela şu örnekler birer karakter dizisidir:

"Python"

"Perl"

"Ruby"

"23"

"35"

"@falanca"

"c"

Karakter dizilerinin ayırt edici özelliği, tırnak işareti taşımalarıdır. Eğer yukarıdaki örnekleri tırnak işaretsiz olarak kullanırsak, artık bu öğeler birer karakter dizisi olmayacaktır... Yukarıdaki örneklerden de gördüğümüz gibi, bir karakter dizisinin ne kadar uzun veya ne kadar kısa olduğunun hiçbir önemi yok. Bir karakter dizisi tek bir karakterden oluşabileceği gibi, birden fazla karakterden de oluşabilir. Bu nedenle “c” de bir karakter dizisidir, “@falanca” da...
Python’da karakter dizilerini ekrana yazdırabilmek için print komutundan yararlanabileceğimizi biliyorsunuz. Mesela:

>>> print "k"

k

>>> print "456"

456

>>> print "Ruby"

Ruby

>>> print "İstanbul’un 5 günlük hava tahmini"

İstanbul’un 5 günlük hava tahmini

Etkileşimli kabukta çalışırken, istersek yukarıdaki örnekleri print komutunu kullanmadan da ekrana yazdırabiliriz:

>>> "Python"

’Python’

>>> "Perl"

’Perl’

>>> "Ruby"

’Ruby’

>>> "4243"

’4243’

Ancak bu durum sadece etkileşimli kabuk için geçerlidir. Yani ilerde kodlarımızı bir dosyaya kaydettiğimiz zaman, yukarıdaki kodların çıktı vermediğini, herhangi bir şeyi ekrana yazdırabilmek için mutlaka print komutundan yararlanmamız gerektiğini göreceğiz.
Şu örneğe bir bakalım:

>>> print "Python programlama dili"

Python yukarıdaki gibi bir komutla karşılaştığında iki basamaklı bir işlem gerçekleştirir. Önce “Python programlama dili” adlı karakter dizisini okur, ardından da print komutunun etkisiyle bu karakter dizisini ekrana basıp kullanıcıya gösterir. Yani şöyle bir çıktı verir:
Python programlama dili
Etkileşimli kabukta bir karakter dizisini print komutu olmadan kullandığımızda Python yalnızca birinci basamağı gerçekleştirmiş olur. Böyle bir durumda yaptığı tek şey bu karakter dizisini okumaktır. print komutunu kullanarak bu karakter dizisini kullanıcıya göstermediğimiz için ikinci basamak gerçekleşmez. Dolayısıyla elde ettiğimiz çıktı, söz konusu karakter dizisini kullanıcının değil, Python’ın ne şekilde gördüğünü gösterir. Yani Python bize şöyle bir şey söylemiş olur:
“Sen şimdi etkileşimli kabuğa bir şeyler yazdın. Ben de bunu algıladım. Yazdığın şeyi algıladığımı göstermek için de, çıktıyı sana tek tırnak işaretleri içinde gösterdim. Ancak print gibi bir komut yardımıyla ekrana herhangi bir şey basmamış olman da dikkatimden kaçmadı değil!“
Basit bir örnek verelim:

>>> "dünya"

’d\\xc3\\xbcnya’

Gördüğünüz gibi, “dünya” kelimesi içindeki Türkçe karakter (“ü”) çıktıda düzgün görünmüyor. Demek ki Python bizim girdiğimiz “dünya” adlı karakter dizisini “d\\xc3\\xbcnya” şeklinde görüyormuş... (Buradaki “\\xc3\\xbc” kısmı kullandığınız işletim sistemine göre farklılık gösterebilir.) Biz bu karakter dizisini kullanıcıya gösterebilmek için şöyle yazacağız:

>>> print "dünya"

dünya

Yazdığımız Python programlarını dosyaya kaydedip çalıştırdığımızda yukarıda anlattıklarımızın ne demek olduğunu çok daha net bir şekilde anlayacağız. O yüzden, eğer yukarıdaki açıklamalar size kafa karıştırıcı geldiyse hiç endişe etmenize gerek yok. Okumaya devam edebilirsiniz.
Karakter dizilerini göstermek için tırnak işaretlerinden yararlanıyoruz demiştik. Python’da karakter dizilerini göstermek için farklı tırnak tiplerini kullanabilirsiniz. Örneğin çift tırnak kullanabilirsiniz:

>>> print "Python güçlü bir programlama dilidir."

veya tek tırnak:

>>> print ’Python güçlü bir programlama dilidir.’

Bu tırnak tiplerini önceki örneklerimizde görmüştük. Ama Python bize bunların dışında bir tırnak alternatifi daha sunar. Üç tırnak:

>>> print """Python güçlü bir programlama dilidir."""

Gördüğünüz gibi, karakter dizileriyle birlikte üç farklı tırnak çeşidi kullanabiliyoruz. Hangi tırnak çeşidini kullandığınızın çok fazla bir önemi yok. Önemli olan, karakter dizisini hangi tırnakla açtıysanız o tırnakla kapatmanızdır.
Bu tırnak tipleri içinde en yaygın kullanılan çift tırnaktır. Tabii siz istediğiniz tırnak biçimini kullanmakta özgürsünüz. Yalnız önceki bölümde, duruma göre kullanılan tırnak tipinin önem kazandığını gösteren şöyle bir örnek verdiğimizi biliyorsunuz:

>>> print "İstanbul’un 5 günlük hava tahmini"

Burada “İstanbul’un 5 günlük hava tahmini” bir karakter dizisidir. Bu karakter dizisini göstermek için çift tırnaklardan yararlandık. İstersek elbette bu karakter dizisini tek tırnak ile de gösterebiliriz. Ancak İstanbul’un kelimesi içinde geçen kesme işaretinden ötürü, kullanılan tırnakların birbirine karışması gibi bir tehlike söz konusu. Yani, daha önce de gördüğümüz gibi, şöyle bir kullanım Python’ın kafasının karışmasına yol açacaktır:
>>> print ’İstanbul’un 5 günlük hava tahmini’
Bu kullanımda, Python karakter dizisini kapatan tırnağın hangisi olduğunu anlayamayacak, o yüzden de şöyle bir hata mesajı verecektir:
File "<stdin>", line 1
print ’İstanbul’un 5 günlük hava tahmini’
^
SyntaxError: invalid syntax
Dikkat ederseniz hata çıktısındaki İstanbul’un kelimesinin sonunda minik bir ok işareti var. İşte bu ok, hata üreten sorunlu bölgeyi gösteriyor.
Böyle bir hata mesajı almamak için kaçış dizilerinden yararlanmamız gerektiğini söylemiştik:

>>> print ’İstanbul\\’un 5 günlük hava tahmini’

Biraz sonra kaçış dizilerinden ayrıntılı olarak söz edeceğiz. O yüzden yukarıdaki kullanımın kafanızı karıştırmasına izin vermeyin.
Eğer bunların hiçbiriyle uğraşmak istemezseniz üç tırnaktan da yararlanabilirsiniz:

>>> print """Gokhan’in öğretmeni Cem Bey, "ödevini yapmadan gelme!" dedi."""

Gördüğünüz gibi, üç tırnak işareti sayesinde karakter dizisi içinde hem tek tırnak, hem de çift tırnak kullanabildik. Zira yukarıdaki karakter dizisine tek tırnakla başlasak Gokhan’in kelimesi içindeki kesme işareti, çift tırnakla başlasak “ödevini yapmadan gelme!” ifadesi içindeki çift tırnak işaretleri bize sorun yaratacak... Bu engellere takılmadan, kodumuzu düzgün bir şekilde ekrana yazdırabilmek için üç tırnak işaretlerini kullanmayı tercih ettik.
Üç tırnak işaretinin marifetleri yukarıdakilerle sınırlı değildir. Bu tırnak tipi, kimi durumlarda işimizi bir hayli kolaylaştırır. Mesela kullanıcılarımıza şöyle bir çıktı göstermemiz gerektiğini varsayalım:
Günün mönüsü
------------
Makarna .... 6 TL
Çorba....... 3 TL
Tatlı....... 2 TL
Böyle bir çıktı vermenin en kolay yolu üç tırnak işaretlerinden yararlanmaktır:

>>> print """
... Günün mönüsü
... ------------
... Makarna .... 6 TL
... Çorba....... 3 TL
... Tatlı....... 2 TL
... """

Burada ilk üç tırnak işaretini koyduktan sonra ENTER tuşuna bastık. Alt satıra geçildiğinde >>> işaretinin ... işaretine döndüğüne dikkat edin. Bu işaret Python’ın bizden komut girmeye devam etmemizi beklediğini gösteriyor. Biz de bu beklentiye uyarak, “Günün mönüsü” satırını yazıyoruz. Tekrar ENTER tuşuna bastığımızda yine ... işaretini görüyoruz ve hemen “----------” satırını yazıyoruz. Yazacağımız kodlar bitene kadar böyle devam ediyoruz. İşimiz bittiğinde de kapanış tırnaklarını koyup ENTER tuşuna basarak çıktıyı alıyoruz:
Günün mönüsü
------------
Makarna .... 6 TL
Çorba....... 3 TL
Tatlı....... 2 TL

Normalde, tek tırnak veya çift tırnak ile başladığımız bir karakter dizisinde kapanış tırnağını koymadan ENTER tuşuna basarsak hata alırız:

>>> print "Günün Mönüsü
File "<stdin>", line 1
print "Günün Mönüsü
^
SyntaxError: EOL while scanning string literal


Burada “Günün Mönüsü” karakter dizisine çift tırnakla başladık, ama tırnağı kapatmadan ENTER tuşuna bastığımız için Python bize bir hata mesajı gösterdi. Aynı şey tek tırnak için de geçerlidir. Ama yukarıda da gördüğünüz gibi üç tırnak farklıdır:

>>> print """Günün Mönüsü
...


Üç tırnak işareti, karakter dizileri içinde geçen farklı tipte tırnakları atlatmamızı sağlamanın yanısıra, bize karakter dizilerimizi birden fazla satıra bölme imkanı da tanıyor. Aynı şeyi tek veya çift tırnakla yapamıyoruz. İlerde bu özellikten sık sık faydalandığımızı göreceksiniz.
Karakter dizilerine ilişkin önemli bir konu da bu karakter dizilerinin birbirleriyle nasıl birleştirileceğidir. Mesela bir kimsenin adı ile soyadını birleştirmek istersek ne yapmalıyız?

>>> print "AYAZ" + "Kibris1974"

AYAZ Kibris1974

Python’da Sayılar ve Matematik İşlemleri

Şimdiye kadar Python’da bazı şeyler öğrendik. Ancak öğrendiklerimiz henüz dört dörtlük bir program yazmaya yetmiyor. Ama bu durum, Python’ı şimdilik basit bir hesap makinesi niyetine kullanabilmemize engel değil.
Örneğin:

>>> 2 + 5

7


... veya:

>>> 5 - 2

3


... ya da:

>>> 2 * 5

10


... hatta:

>>> 6 / 2

3


İsterseniz bunların başına print komutu ekleyerek de kullanabilirsiniz bu kodları. Bir örnek verelim:

>>> print 234 + 546

780


Aritmetik işlemler yapabilmek için kullandığımız işaretlerin size mantıklı gelmiş olduğunu zannediyorum. Toplama işlemi için “+”, çıkarma işlemi için “-”, çarpma işlemi için “*”, bölme işlemi için ise “/” işaretlerini kullanmak gayet makul duruyor, değil mi?
Gördüğünüz gibi sayıları yazarken tırnak işaretlerini kullanmıyoruz. Eğer tırnak işareti kullanırsak Python yazdıklarımızı sayı olarak değil karakter dizisi olarak algılayacaktır. Bu durumu birkaç örnekle görelim:

>>> print 25 + 50

75


Bu komut, 25 ve 50’yi toplayıp sonucu çıktı olarak verir. Şimdi aşağıdaki örneğe bakalım:

>>> print "25 + 50"

25 + 50


Bu komut 25 ile 50’yi toplamak yerine, ekrana 25 + 50 şeklinde bir çıktı verecektir. Peki, şöyle bir komut verirsek ne olur?

>>> print "25" + "50"


Böyle bir komutla karşılaşan Python derhal “25” ve “50” karakter dizilerini (bu sayılar tırnak içinde olduğu için Python bunları sayı olarak algılamaz) yan yana getirip birleştirecektir. Yani şöyle bir şey yapacaktır:

>>> print "25" + "50"

2550


Uzun lafın kısası, “25” ifadesi ile “Çeliktepe” ifadesi arasında Python açısından hiç bir fark yoktur. Bunların ikisi de karakter dizisi sınıfına girer. Ancak tırnak işareti olmayan 25 ile “Çeliktepe” ifadeleri Python dilinde ayrı anlamlar taşır. Çünkü bunlardan biri sayı öteki ise karakter dizisidir (string).
Şimdi aritmetik işlemlere geri dönelim. Öncelikle şu komutun çıktısını inceleyelim:

>>> print 5 / 2

2


Ama biz biliyoruz ki 5’i 2’ye bölerseniz 2 değil 2,5 çıkar. Aynı komutu bir de şöyle deneyelim:

>>> print 5.0 / 2

2.5


Gördüğünüz gibi bölme işlemini oluşturan bileşenlerden birinin yanına ”.0” koyulursa sorun çözülüyor. Böylelikle Python bizim sonucu kayan noktalı sayı olarak görmek istediğimizi anlıyor. Bu ”.0” ifadesini istediğimiz sayının önüne koyabiliriz. Birkaç örnek görelim:

>>> print 5 / 2.0

2.5

>>> print 5.0 / 2.0

2.5


Python’da aritmetik işlemler yapılırken alıştığımız matematik kuralları geçerlidir. Yani mesela aynı anda bölme çıkarma, toplama, çarpma işlemleri yapılacaksa işlem öncelik sırası, önce bölme ve çarpma sonra toplama ve çıkarma şeklinde olacaktır. Örneğin:

>>> print 2 + 6 / 3 * 5 - 4


işleminin sonucu 8 olacaktır. Tabii biz istersek parantezler yardımıyla Python’ın kendiliğinden kullandığı öncelik sırasını değiştirebiliriz. Bu arada yapacağımız aritmetik işlemlerde sayıları kayan noktalı sayı cinsinden yazmamız işlem sonucunun kesinliği açısından büyük önem taşır. Eğer her defasında ”.0” koymaktan sıkılıyorsanız, şu komutla Python’a, “Bana her zaman kesin sonuçlar göster,” mesajı gönderebilirsiniz:

>>> from __future__ import division



Not
Burada “__” işaretini klavyedeki alt çizgi tuşuna iki kez art arda basarak yapabilirsiniz.
Artık bir sonraki Python oturumuna kadar bütün işlemlerinizin sonucu kayan noktalı sayı olarak gösterilecektir. Bu arada dilerseniz konuyla ilgili bazı ufak tefek teknik bilgiler verelim. Böylece karşılaştığımız örnekleri daha kolay anlayabiliriz. Mesela yukarıda sayılardan bahsettik. Python’da sayılar çeşit çeşittir:

Tamsayılar (integers)
Tamsayılar, herhangi bir ondalık kısım barındırmayan sayılardır. Mesela 3, 5, 6, 100, 1450, -56, -3 vb...
Kayan Noktalı Sayılar (floating point numbers)
Ondalık bir kısım da barındıran sayılardır. Mesela 3.4, 5.5, 6.4, vb... Bu arada ondalık kısmı virgülle değil noktayla gösterdiğimize dikkat edin.
Uzun Sayılar (long integers)
-2.147.483.648 ile 2.147.483.647 arasında kalan sayılardır.
Karmaşık Sayılar (complex numbers)
Karmaşık sayılar bir gerçel, bir de sanal kısımdan oluşan sayılardır. Mesela 34.3j, 2j+4, vb...

Bu sayılar içinde en sık karşılaşacaklarımız tamsayılar ve kayan noktalı sayılardır. Eğer özel olarak matematikle ilgili işler yapmıyorsanız uzun sayılar ve karmaşık sayılar pek karşınıza çıkmaz.
Hatırlarsanız, karakter dizilerinden bahsederken, print‘li ve print‘siz kullanımdan söz etmiştik. Orada sözünü ettiğimiz durum sayılar için de geçerlidir. Mesela şu örneğe bakalım:

>>> 12 - 3.3

8.6999999999999993


Herhalde beklediğiniz çıktı bu değildi. Bu çıktı, 12 - 3.3 işlemini Python’ın nasıl gördüğünü gösteriyor. Eğer bu işlemi insanların anlayabileceği bir biçime getirmek istersek şöyle yazmamız gerekir:

>>> print 12 - 3.3

8.7


İlerde yeri geldiğinde sayılardan daha ayrıntılı bir şekilde bahsedeceğiz. O yüzden sayılar konusunu şimdi bir kenara bırakıp çok önemli başka bir konuya değinelim.

Değişkenler

Kabaca, bir veriyi kendi içinde depolayan birimlere değişken adı veriyorlar. Ama şu anda aslında bizi değişkenin ne olduğundan ziyade neye yaradığı ilgilendiriyor. O yüzden hemen bir örnekle durumu açıklamaya çalışalım. Mesela;

>>> n = 5


ifadesinde n bir değişkendir. Bu n değişkeni 5 verisini sonradan tekrar kullanılmak üzere depolar. Python komut satırında n = 5 şeklinde değişkeni tanımladıktan sonra print n komutunu verirsek ekrana yazdırılacak veri 5 olacaktır. Yani:

>>> n = 5
>>> print n

5


Bu n değişkenini alıp bununla aritmetik işlemler de yapabiliriz:

>>> n * 2

10

>>> n / 2.0

2.5


Hatta bu n değişkeni, içinde bir aritmetik işlem de barındırabilir:

>>> n = 34 * 45
>>> print n

1530


Şu örneklere bir göz atalım:

>>> a = 5
>>> b = 3
>>> print a * b

15

>>> print "a ile b’yi çarparsak", a * b, "elde ederiz"

a ile b’yi çarparsak 15 elde ederiz


Burada değişkenleri karakter dizileri arasına nasıl yerleştirdiğimize, virgülleri nerede kullandığımıza dikkat edin.
Aynı değişkenlerle yaptığımız şu örneğe bakalım bir de:

>>> print a, "sayısı", b, "sayısından büyüktür"


Gördüğünüz gibi, aslında burada yaptığımız şey, karakter dizilerini birbiriyle birleştirmekten ibarettir. Hatırlarsanız bir önceki bölümde iki karakter dizisini şu şekilde birleştirebileceğimizi öğrenmiştik:

>>> print "PoSsYMaC", "Gokhan"


İşte yukarıda yaptığımız şeyin de bundan hiçbir farkı yoktur. Dikkatlice bakın:

>>> print a, "sayısı", b, "sayısından büyüktür"


Yukarıdaki kod şununla eşdeğerdir:

>>> print 5, "sayısı", 3, "sayısından büyüktür"


Biz burada doğrudan sayıları yazmak yerine, bu sayıları tutan değişkenleri yazdık...
Değişkenleri kullanmanın başka bir yolu da özel işaretler yardımıyla bunları karakter dizileri içine gömmektir. Şu örneğe bir bakalım:

>>> print "%s ile %s çarpılırsa %s elde edilir" %(3, 5, 3*5)


Bu da oldukça kullanışlı bir tekniktir. Burada, parantez içinde göstereceğimiz her bir öğe için karakter dizisi içine “%s” işaretini ekliyoruz. Karakter dizisini yazdıktan sonra da “%” işaretinin ardından parantez içinde bu değişkenleri teker teker tanımlıyoruz. Buna göre birinci değişkenimiz 3, ikincisi 5, üçüncüsü ise bunların çarpımı...

Cevap: Pyton Hakkında Ufak kodlar

Bir de şu örneği inceleyelim:

>>> print "%s ve %s iyi bir ikilidir." %("Python", "Django")


Görüleceği gibi, bu kez değişkenlerimiz tamsayı yerine karakter dizisi olduğu için parantez içinde değişkenleri belirtirken tırnak işaretlerini kullanmayı unutmuyoruz.
Kaçış Dizileri

Önceki bölümlerde “kaçış dizisi” diye bir şeyden söz ettik. Hatta bununla ilgili bir örnek de yaptık. İsterseniz o örneği hatırlayalım:

>>> print ’İstanbul\\’un 5 günlük hava tahmini’


İşte bu karakter dizisi içinde kullandığımız “\\” işareti bir kaçış dizisidir. Bu kaçış dizisinin buradaki görevi, İstanbul’un kelimesi içinde geçen kesme işaretinin, karakter dizisini açan ve kapatan tırnak işaretleriyle karışmasını önlemek. Python bir karakter dizisiyle karşılaştığında, bu karakter dizisini soldan sağa doğru okur. Mesela yukarıdaki örnekte önce tek tırnak işaretini görüyor ve bir karakter dizisi tanımlayacağımızı anlıyor. Ardından karakter dizisi içindeki kesme işaretine rastlıyor ve bu işaretin karakter dizisinin bitişini gösteren kesme işareti olduğunu, yani karakter dizisinin sona erdiğini zannediyor. Ancak okumaya devam ettiğinde, karakter dizisine birleşik bir halde “un 5 günlük hava tahmini” diye bir şeyle karşılaşıyor ve işte bu noktada kafası allak bullak oluyor. Bizim İstanbul’un kelimesindeki kesme işaretinin sol tarafına yerleştirdiğimiz “\\” kaçış dizisi Python’a, bu kesme işaretini görmezden gelme emri veriyor. Böylece karakter dizimiz hatasız bir şekilde ekrana basılıyor...
Dilerseniz bununla ilgili birkaç örnek daha yapalım:
>>> print "1 numaralı oyuncudan gelen cevap: "Sola dön!""

Bu karakter dizisi içinde “Sola dön!” ifadesi var. Biz yukarıdaki karakter dizisini tanımlarken çift tırnaktan yararlandığımız için, karakter dizisi içindeki bu “Sola dön!” ifadesi çakışmaya sebep oluyor. İstersek yukarıdaki karakter dizisini şu şekilde yazabiliriz:

>>> print ’1 numaralı oyuncudan gelen cevap: "Sola dön!"’


Bu komut sorunsuz bir şekilde yazdırılır. Ama eğer karakter dizisini çift tırnakla tanımlamanız gerekirse, kaçış dizilerinden yararlanabilirsiniz:

>>> print "1 numaralı oyuncudan gelen cevap: \\"Sola dön!\\""


Burada iki adet kaçış dizisi kullandığımıza dikkat edin. Bunun nedeni, karakter dizisi içinde başlangıç ve bitiş tırnaklarıyla karışabilecek iki adet tırnak işareti olmasıdır... Ayrıca kaçış dizisini, sorunlu tırnağın soluna koyduğumuza da dikkat edin.
Hatırlarsanız kaçış dizilerinden ilk bahsettiğimiz yerde şöyle bir örnek de vermiştik:

>>> print "Python’da önemli komutlardan biri de "print" komutudur."


Bu komutun hata vereceğini biliyoruz. Çünkü karakter dizisini çift tırnak içinde tanımladık. Dolayısıyla karakter dizisi içinde geçen çift tırnaklı “print” ifadesi çakışmaya yol açtı. Bu sorunu aşmak için karakter dizisini şöyle yazıyoruz:

>>> print "Python’da önemli komutlardan biri de \\"print\\" komutudur."


Burada kaçış dizilerini çift tırnaklı “print” kelimesine nasıl uyguladığımıza dikkat edin. Her bir çift tırnağın soluna bir adet “\\” işareti yerleştirdik. Böylece hatadan kıvrak hareketlerle kaçmış olduk...
“\\” işareti yalnızca tırnak işaretleriyle birlikte kullanılmaz. Bu işaret başka karakterlerle birlikte de kullanılarak farklı amaçlara hizmet edebilir.
Şu örneğe bir bakın:

>>> print "birinci satır\\nikinci satır"


Burada “\\” işaretini “n” harfiyle birlikte kullandık. “\\” işareti “n” harfiyle birlikte kullanıldığında özel bir anlam ifade eder. Yukarıdaki kod şöyle bir çıktı verir:
birinci satır
ikinci satır

Gördüğünüz gibi, karakter dizisini iki satıra böldük. Bunu yapmamızı sağlayan şey “\\n” adlı kaçış dizisidir. Bu kaçış dizisi yeni bir satıra geçmemizi sağlar. Daha belirgin bir örnek verelim:

>>> print "Yolun sonu\\n"


Bu komut, “Yolun sonu” karakter dizisini çıktı olarak verdikten sonra bir satır boşluk bırakacaktır.
Hatırlarsanız önceki bölümde, print komutunu kullanmadan herhangi bir karakter dizisi yazdığımızda elde ettiğimiz çıktının Python’ın bakış açısını yansıttığını söylemiştik. Bu durumu çok daha net anlayabilmemizi sağlayacak bir örnek verelim:

>>> """
... Günün mönüsü
... ------------
... Makarna..... 6 TL
... Çorba....... 3 TL
... Tatlı....... 2 TL
... """


Bu örneği hatırlıyorsunuz. Daha önce aynı örneği print komutu ile birlikte kullanmıştık.
Bu kodlar şöyle bir çıktı verir:
’\\nGünün mönüsü\\n------------\\nMakarna..... 6 TL\\nÇorba.......
3 TL\\nTatlı....... 2 TL\\n’

Gördüğünüz gibi, çıktıda “\\n” adlı kaçış dizileri de görünüyor. Demek ki Python üç tırnak yardımıyla girdiğimiz kodları böyle görüyormuş. Bu çıktıdan şunu da anlıyoruz: Demek ki biz üç tırnak yerine tek tırnak kullanmak istesek aynı çıktıyı elde etmek için şöyle gibi bir komut vermemiz gerekecek:

>>> print ’\\nGünün mönüsü\\n------------\\nMakarna..... 6 TL\\nÇorba....... \\
... 3 TL\\nTatlı....... 2 TL\\n’

Günün mönüsü
------------
Makarna..... 6 TL
Çorba....... 3 TL
Tatlı....... 2 TL


Buradan, üç tırnak işaretlerinin kimi durumlarda hayatımızı ne kadar da kolaylaştırabileceğini anlayabilirsiniz...
Bu arada, yukarıdaki komutlarda bir şey dikkatinizi çekmiş olmalı. >>> print ’\\nGünün mönüsü\\n--- ile başlayan komutun ilk satırının sonunda, ENTER tuşuna basıp yeni satıra geçmeden önce “\\” adlı kaçış dizisini kullandık. Elbette istersek bu iki satırı tek bir satırda da yazabiliriz. Ancak görüntü açısından kodların bu şekilde sağa doğru uzaması hoş değil. Kötü bir kod görünümü ortaya çıkmaması için, bu kaçış dizisini kullanarak kodlarımızı iki satıra bölmeyi tercih ettik.


Not
Python’da doğru kod yazmak kadar, yazdığınız kodların düzgün görünmesi ve okunaklı olması da önemlidir. Bu yüzden yazdığımız programlarda satır uzunluğunun mümkün olduğunca 79 karakterden fazla olmamasına dikkat ediyoruz. Eğer yazdığımız bir satır 79 karakterden uzun olacaksa satırı uygun bir yerinden bölüp yeni bir satıra geçmemiz gerekir. Bu durum teknik bir zorunluluk değildir, ancak okunaklılığı artırdığı için uyulması tavsiye edilir. Örneğin biz de yukarıdaki örnekte kodlarımızın sağa doğru çirkin bir şekilde uzamaması için satırı uygun bir yerinden bölüp alt satıra geçtik.
Bu kaçış dizisini kullanmamızın amacı, Python’ın herhangi bir hata vermeden alt satıra geçmesini sağlamak. Eğer orada o kaçış dizisini kullanmazsak, ENTER tuşuna bastığımız anda Python hata verecektir. “\\” işareti, alt satıra geçilmiş de olsa kodların ilk satırdan devam etmesi gerektiğini gösteriyor. Bu durumu belirgin bir şekilde gösteren bir örnek verelim:

>>> print ’mer\\
... haba’

merhaba


Gördüğünüz gibi, “merhaba” kelimesini “mer” hecesinden bölüp “\\” işareti ile alt satıra geçtiğimiz halde, çıktımız “merhaba” oldu. Eğer amacınız “merhaba” kelimesini “mer” ve “haba” olarak bölmekse şöyle bir şey yapabilirsiniz:

>>> print """mer
... haba"""

mer
haba


Eğer üç tırnak kullandığınız halde, “merhaba” kelimesinin bölünmesini istemiyorsanız yine “\\” kaçış dizisinden yararlanabilirsiniz:

>>> print """mer\\
... haba"""

merhaba


Eğer üç tırnak yerine çift veya tek tırnak kullanarak “merhaba” kelimesini ortadan bölmek isterseniz elbette “\\n” adlı kaçış dizisinden yararlanabilirsiniz:

>>> print "mer\\nhaba"

mer
haba

>>> print ’mer\\nhaba’

mer
haba



Not
Çok uzun bir karakter dizisini iki satıra bölmek için “\\” işaretini kullanırken, bu işaretin satırdaki son karakter olmasına özen gösterin. Yani “\\” işaretini koyar koymaz ENTER tuşuna basmalısınız. “\\” işaretinden sonra boşluk bile olmamalı.
Bütün bu örneklerden şunu anlıyoruz: Python’da temel olarak tek bir kaçış dizisi var. O da “\\” işareti... Bu işaret farklı karakterlerle bir araya gelerek, değişik anlamlar ortaya çıkarabiliyor. Mesela bu karakter dizisi tırnak işaretiyle birlikte kullanıldığında, karakter dizisini başlatıp bitiren tırnaklarla çakışılmasını önlüyor. Eğer bu kaçış dizisini “n” harfiyle birlikte kullanırsak, karakter dizilerini bölüp alt satıra geçebiliyoruz. Eğer bu kaçış dizisini tek başına kullanırsak, bir karakter dizisini herhangi bir yerinden bölüp alt satıra geçtiğimiz halde, o karakter dizisi çıktıda tek satır olarak görünüyor. Bütün bunların dışında bu kaçış dizisi “t” harfiyle de yan yana gelebilir. O zaman da şöyle bir anlam kazanır:

>>> print "Uzak... \\t Çok uzak"

Uzak... Çok uzak


Bu kaçış dizisinin görevi karakter dizisi içindeki karakterler arasına mesafe koymak. Bu kaçış dizisi de kimi yerlerde hayatınızı kolaylaştırabilir. “\\” kaçış dizisi başka karakterlerle de bir araya gelebilir. Ancak en önemlilerini zaten yukarıda verdik. Programlama maceramızda en çok işimize yarayacak olanlar bunlardır.
Yukarıdakilerin dışında, Python’da şablona uymayan önemli bir kaçış dizisi daha bulunur. Bu kaçış dizisinin adı “r“‘dir. Bu kaçış dizisinin hem görünüşü hem de kullanımı yukarıdaki kaçış dizilerinden biraz farklıdır. Dilerseniz bu kaçış dizisini anlatmadan önce size şöyle bir soru sorayım:
Acaba aşağıdaki karakter dizisini nasıl yazdırırız?

İsterseniz bu karakter dizisini önce şöyle yazdırmayı deneyelim:

>>> print "C:\\Documents and Settings\\nergis\\test"

C:\\Documents and Settings
ergis est


Gördüğünüz gibi Python bize tuhaf bir çıktı verdi. Sizce neden böyle oldu?
Cevap aslında çok basit. Karakter dizisinde kalın harflerle gösterdiğimiz kısımlara dikkat edin: C:\\Documents and Settings\\nergis\\test
Burada “nergis” ve “test” kelimelerinin başındaki harfler, dizin ayracı olan “\\” işareti ile yan yana geldiği için Python bunları birer kaçış dizisi olarak algılıyor. Bu durumdan kurtulmak için birkaç seçeneğimiz var. İstersek yukarıdaki karakter dizisini şöyle yazabiliriz:

>>> print "C:\\\\Documents and Settings\\\\nergis\\\\test"


Burada “\\” işaretlerini çiftleyerek sorunun üstesinden gelebiliyoruz. Ama eğer istersek yukarıdaki soruna çok daha temiz bir çözüm de bulabiliriz. İşte böyle bir duruma karşı Python’da “r” adlı bir kaçış dizisi daha bulunur. Bunu şöyle kullanıyoruz:

>>> print r"C:\\Documents and Settings\\nergis\\test"


Gördüğünüz gibi, “r” adlı kaçış dizisi, karakter dizisi içinde geçen bütün kaçış dizilerini etkisiz hale getiriyor. Bu kaçış dizisi özellikle dizin adlarını yazdırırken çok işinize yarayacaktır. İsterseniz bununla ilgili şöyle bir örnek daha verelim. Diyelim ki şu cümleyi ekrana yazdırmak istiyoruz:
Python’daki kaçış dizileri şunlardır: \\, \\n, \\t

Bu cümleyi şöyle yazdıramayız:

>>> print "Python’daki kaçış dizileri şunlardır: \\, \\n, \\t"

Python’daki kaçış dizileri şunlardır: \\,
,


Gördüğünüz gibi çıktı hiç de beklediğimiz gibi değil. Çünkü Python karakter dizisi içinde geçen kaçış dizilerini işleme sokuyor ve buradaki her bir kaçış dizisinin görevini yerine getirmesine izin veriyor. Bu kaçış dizilerinin etkisizleştirilebilmesi için şu kodu yazabilirsiniz:

print "Python’daki kaçış dizileri şunlardır: \\\\, \\\\n, \\\\t"


Ama burada “r” kaçış dizisini kullanırsak çok daha temiz bir kod görünümü elde etmiş oluruz:

print r"Python’daki kaçış dizileri şunlardır: \\, \\n, \\t"


“r” adlı kaçış dizisi, karakter dizisi içindeki kaçış dizilerinin görevlerini yerine getirmesine engel olacaktır.
Dilerseniz şimdiye kadar gördüğümüz kaçış dizilerini şöyle bir özetleyelim:


\\
ENTER tuşuna basılarak alt satıra kaydırılan karakter dizilerinin çıktıda tek satır olarak görünmesini sağlar.
\\’
Karakter dizilerini başlatıp bitiren tek tırnaklarla, karakter dizisi içinde geçen tek tırnakların karışmasını engeller.
\\”
Karakter dizilerini başlatıp bitiren çift tırnaklarla, karakter dizisi içinde geçen çift tırnakların karışmasını engeller.
\\n
Yeni bir satıra geçilmesini sağlar.
\\t
Karakter dizileri içinde sekme (TAB) tuşuna basılmış gibi boşluklar oluşturulmasını sağlar.
r
Karakter dizileri içinde geçen kaçış dizilerini etkisiz hale getirir.