1. Temel Bilgiler

Python, Guido Van Rossum adlı Hollandalı bir programcı tarafından 90’lı yılların başında geliştirilmeye başlanmış bir programlama dilidir. Zannedildiğinin aksine bu programlama dilinin adı piton yılanından gelmez... Guido Van Rossum bu programlama dilini, “The Monty Python” adlı bir İngiliz komedi grubunun, “Monty Python’s Flying Circus” adlı gösterisinden esinlenerek adlandırmıştır.

Python, pek çok dile kıyasla öğrenmesi kolay bir programlama dilidir. Bu yüzden, eğer daha önce hiç programlama deneyiminiz olmamışsa, programlama maceranıza Python’la başlamayı tercih edebilirsiniz.

Python programlarının en büyük özelliklerinden birisi, C ve C++ gibi dillerin aksine, derlenmeye gerek olmadan çalıştırılabilmeleridir. Python’da derleme işlemi ortadan kaldırıldığı için, Python’la oldukça hızlı bir şekilde program geliştirilebilir.

Ayrıca Python programlama dilinin basit ve temiz sözdizimi, onu pek çok programcı tarafından tercih edilen bir dil haline getirmiştir. Python’un sözdiziminin temiz ve basit olması sayesinde hem program yazmak, hem de başkası tarafından yazılmış bir programı okumak çok kolaydır.

Python’u kullanabilmek için öncelikle onu bilgisayarımıza kurmamız gerekiyor. İsterseniz sözü daha fazla uzatmadan Python’u nereden ve nasıl edinebileceğimizi öğrenelim.

1.1. Python Nereden İndirilir?

Python’un en yeni sürümü 3.x numaralıdır. Şu anda en çok kullanılan ve en yaygın sürümler ise 2.x numaralı olanlardır. Pek çok GNU/Linux dağıtımında Python kurulu olarak gelir. Eğer siz de bir GNU/Linux kullanıcısı iseniz muhtemelen sisteminizde Python zaten kuruludur. Ancak sisteminizde kurulu olan bu sürüm büyük ihtimalle Python’un 2.x numaralı bir sürümüdür.

Windows sistemlerinde ise herhangi bir Python sürümü kurulu olarak gelmez. Biz bu sitede Python’un 3.x sürümlerini belgelendireceğiz. Dilerseniz gelin şimdi Python’un 3.x sürümünün GNU/Linux ve Windows’ta nasıl kurulacağını ayrı ayrı inceleyelim:

GNU/Linux Kullanıcıları

Dediğim gibi, eğer GNU/Linux dağıtımlarından birini kullanıyorsanız sisteminizde muhtemelen Python’un 2.x sürümlerinden biri zaten kuruludur. Bunu şu şekilde kontrol edebilirsiniz:

Komut satırında:

python

yazıp enter tuşuna bastığınızda, eğer karşınıza şuna benzer bir ekran geliyorsa, kurulu sürüm 2.x’tir:

Python 2.6.1+ (r261:67515, Mar  2 2009, 13:10:18)
[GCC 4.3.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

Burada 2.6.1+ olarak görünen rakam Python’un sürümünü gösteriyor. Bu çıktıya göre, sisteminizdeki Python sürümü 2.6.1. Yani sizde Python’un 2.x numaralı bir sürümü kurulu...

Sisteminizdeki Python sürümünü öğrenmek için şöyle bir yol da izleyebilirsiniz:

Yine komut satırında:

python -V

yazıp enter’e bastığınızda hangi Python sürümünün sisteminizde kurulu olduğu doğrudan görünecektir...

Eğer Python’un 2.x sürümleriyle çalışmak isterseniz, bu sitede 2.x sürümlerine ait belgeler de bulunmaktadır. İstediğiniz buysa sizi http://www.istihza.com/icindekiler_python.html adresine alalım...

Eğer Python’un 3.x sürümünü kullanmak isterseniz okumaya devam ediniz...

GNU/Linux kullanıcılarının, Python’un 3.x sürümünü elde etmek için tercih edebileceği iki yol vardır. Birincisi ve benim size önereceğim yol, öncelikle kullandığınız dağıtımın paket yöneticisini kontrol etmenizdir. Python 3.x sisteminizde kurulu olmasa bile, dağıtımınızın depolarında bu sürüm paketlenmiş halde duruyor olabilir. O yüzden sisteminize uygun bir şekilde paket yöneticinizi açıp orada “python” şeklinde bir arama yapmanızı öneririm. Örneğin Debian tabanlı bir GNU/Linux dağıtımı kullanıyorsanız komut satırında şu komutu vererek depolarınızdaki Python paketlerini listeleyebilirsiniz:

aptitude search python

Eğer bu komutun çıktısı içinde “python3” gibi bir şey görüyorsanız, kurmanız gereken paket odur... Yine Debian tabanlı sistemlerde bu paketi şu şekilde kurabilirsiniz:

sudo apt-get install python3

Örneğin Kubuntu, Debian tabanlı bir GNU/Linux dağıtımıdır. Eğer Kubuntu’nun “Jaunty Jackalope” veya daha üst sürümlerinden birini kullanıyorsanız, yukarıdaki komut yardımıyla python3 paketini sisteminize kurabilirsiniz.

Kullandığınız dağıtımın depolarında python3 paketini bulamazsanız, Python 3.x’i kaynaktan kurmanız gerekecektir. Bunun için yapmanız gereken işlemler şöyle:

1. Öncelikle şu adresi ziyaret ediyoruz: http://www.python.org/download

2. Bu adreste, üzerinde “Python 3.x.x compressed source tarball (for Linux, Unix or OS X)” yazan bağlantıya tıklıyoruz.

3. İlgili .tgz dosyasını bilgisayarımıza indiriyoruz.

4. Daha sonra, bu sıkıştırılmış dosyayı açıyoruz.

5. Açılan dosyanın içine girip, orada sırasıyla aşağıdaki komutları veriyoruz:

   ./configure

   make

   sudo make altinstall

Böylelikle Python 3.x’i sistemimize kurmuş olduk. Bu arada, yukarıdaki komutları vermeden önce tabii ki sistemimizde gcc ve make adlı araçların kurulu olması gerekiyor...

Yukarıdaki kodlarda “make install” yerine “make altinstall” komutunu kullandığımıza dikkat edin. Python’un kaynak kodlarıyla beraber gelen README dosyasında şöyle bir ibare bulunur:

Installing multiple versions

On Unix and Mac systems if you intend to install multiple versions of Python using the same installation prefix (–prefix argument to the configure script) you must take care that your primary python executable is not overwritten by the installation of a different version. All files and directories installed using “make altinstall” contain the major and minor version and can thus live side-by-side. “make install” also creates ${prefix}/bin/python which refers to ${prefix}/bin/pythonX.Y. If you intend to install multiple versions using the same prefix you must decide which version (if any) is your “primary” version. Install that version using “make install”. Install all other versions using “make altinstall”.

For example, if you want to install Python 2.5, 2.6 and 3.0 with 2.6 being the primary version, you would execute “make install” in your 2.6 build directory and “make altinstall” in the others.

Birden fazla sürümü aynı anda kurmak

Unix ve Mac sistemlerinde eğer birden fazla Python sürümünü aynı önek ile (configure betiğine verilen –prefix argümanı) kuracaksanız, farklı bir Python sürümüne ait çalıştırılabilir dosyanın, birincil Python sürümüne ait çalıştırılabilir dosyayı silip üzerine yazmamasına dikkat etmelisiniz. “make altinstall” ile kurulum yapıldığında bütün dosya ve dizinlerde ana ve alt sürüm numaraları da içerilecektir. Dolayısıyla farklı sürümler yan yana varolabilecektir. “make install” komutu, ${önek}/bin/pythonX.Y dosyasına bağlantı veren ${önek}/bin/python adlı bir dosya oluşturacaktır. Eğer aynı öneki kullanarak birden fazla sürüm kurmak istiyorsanız, hangi sürümün (eğer olacaksa) “birincil” sürümünüz olacağına karar vermelisiniz. Birincil sürümünüzü “make install” ile kurun. Öteki bütün sürümleri ise “make altinstall” ile...

Örneğin Python 2.5, 2.6 ve 3.0 sürümlerini kuracaksanız ve eğer 2.6 sürümünün birincil sürüm olmasına karar vermişseniz, 2.6 sürümünün inşa dizini içinde “make install” komutunu çalıştırın. Öteki sürümleri ise “make altinstall” ile kurun.

Bu noktada bir uyarı yapmadan geçmeyelim: Python özellikle bazı GNU/Linux dağıtımlarında pek çok sistem aracıyla sıkı sıkıya bağlantılıdır. Yani Python, kullandığınız dağıtımın belkemiği durumunda olabilir... Bu yüzden Python’u kaynaktan kurmak bazı riskler taşıyabilir. Eğer yukarıda anlatıldığı şekilde, sisteminize kaynaktan Python kuracaksanız, karşı karşıya olduğunuz risklerin farkında olmalısınız...

Kurduğumuz yeni Python’u nasıl çalıştıracağımızı biraz sonra göreceğiz. Ama önce Windows kullanıcılarının Python 3.x’i nasıl kuracaklarına bakalım.

Windows Kullanıcıları

Windows sürümlerinin hiçbirinde Python kurulu olarak gelmez. O yüzden Windows kullanıcıları, Python’u sitesinden indirip kuracak. Bunun için şu adımları takip ediyoruz:

1. http://www.python.org/download adresini ziyaret ediyoruz.
2. Orada, üzerinde Python 3.x.x Windows installer (Windows binary – does not include source) yazan bağlantıya tıklıyoruz.
3. .msi uzantılı dosyayı bilgisayarımıza indiriyoruz.
4. İnen dosyaya çift tıklayıp normal bir şekilde kurulumu gerçekleştiriyoruz.
5. Eğer ne yaptığınızdan emin değilseniz, kurulum sırasında varsayılan ayarları değiştirmemenizi öneririm...

Windows’ta Python kurulumu bu kadar basittir. Artık bilgisayarımıza kurduğumuz Python programını nasıl çalıştıracağımızı görebiliriz...

1.2. Python Nasıl Çalıştırılır?

Bir önceki bölümde, Python’u nasıl kuracağımızı farklı platformlara göre anlattık. Bu bölümde ise kurduğumuz bu Python programını hem GNU/Linux’ta hem de Windows’ta nasıl çalıştıracağımızı göreceğiz. Öncelikle GNU/Linux kullanıcılarının Python’u nasıl çalıştıracağına bakalım...

GNU/Linux Kullanıcıları

GNU/Linux kullanıcıları, eğer paket yöneticilerini kullanarak Python kurulumu gerçekleştirmiş iseler, komut satırında şu komutu vererek Python’u başlatabilirler:

python3

Bu komutun ardından şuna benzer bir ekranla karşılaşmış olmalısınız:

Python 3.0.1+ (r301:69556, Feb 24 2009, 13:51:44)
[GCC 4.3.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

Gördüğünüz gibi, kullandığımız Python sürümü “3.0.1”...

Burada, paket yöneticisinden kurduğunuz paketin adının “python3” olduğunu varsayıyorum. Düşük bir ihtimal de olsa bu paketin adı sizde farklı olabilir. Örneğin Python3 sizin sisteminizde farklı bir ad altında geçiyor olabilir. Mesela, “python3.0” gibi...

Eğer paketin adı python3.0 ise komut satırında şu komutu vermelisiniz:

python3.0

Bu komut da benzer bir şekilde şöyle bir çıktı vermeli:

Python 3.0.1+ (r301:69556, Feb 24 2009, 13:51:44)
[GCC 4.3.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

Python’u ne şekilde başlatacağınızı kesin olarak tespit etmek için /usr/bin adlı klasörün içinde “python” programının hangi adla yer aldığına bakabilirsiniz. Bu klasörün içinde “python” dışında, adında “python” geçen hangi programların olduğunu kontrol edin. Mesela şunlar olabilir: “python3”, “python3.0”, “python3.0.1”

Eğer Python3’ü kaynaktan kuranlardansanız, vereceğiniz komut muhtemelen şu olacaktır:

python3.0

GNU/Linux’ta Python’u nasıl çalıştıracağımızı öğrendiğimize göre, Windows kullanıcılarının durumuna bakabiliriz...

Windows Kullanıcıları

Gelelim Windows kullanıcılarına...

Windows kullanıcıları Python3’ü iki şekilde başlatabilir:

1. Başlat > Programlar > Python3.x > Python (Command Line)* yolunu takip ederek.
2. Python3.x’i YOL’a (PATH) ekledikten sonra DOS ekranında “python” komutunu vererek...

Eğer birinci yolu tercih ederseniz, Python’un size sunduğu komut satırına ulaşırsınız. Ancak Python komut satırına bu şekilde ulaştığınızda bazı kısıtlamalarla karşı karşıya kalırsınız. O yüzden komut satırına bu şekilde ulaşmak yerine ikinci seçeneği tercih edebilirsiniz.

Eğer sisteminizde birkaç farklı Python sürümü kurulu ise ve eğer siz bu eski sürümlerden birini YOL’a eklemişseniz, Python3.0’ı YOL’a eklemeyin. Sisteminde sadece Python3.0 kurulu olan Windows kullanıcıları Python’u YOL’a nasıl ekleyeceklerini öğrenmek için http://www.istihza.com/py2/windows-path.html adresindeki makaleyi inceleyebilirler. (Orada Python26 yerine Python30 ifadesi gelecek...)

Sisteminizde sadece Python3.0 sürümünün kurulu olduğunu ve bu sürümü başarıyla YOL’a eklediğinizi varsayarak bir deneme yapalım. Başlat > Çalıştır yolunu takip ederek, açılan pencerede “cmd” komutunu verelim ve Windows komut satırına ulaşalım. Orada şu komutu verelim:

python

Eğer sisteminizde başka bir Python sürümü kurulu değilse veya siz kurulu olan sürümü daha önceden YOL’a eklememişseniz, yukarıdaki komutu verdiğinizde Python3.0 çalışmaya başlayacaktır. Şuna benzer bir çıktı almalısınız:

Python 3.0.1 (r301:69561, Feb 13 2009, 20:04:18) [MSC v.1500 32 bit (Intel)] on
win32 Type "help", "copyright", "credits" or "license" for more information.
>>>

Eğer sisteminizde eski bir Python sürümü kuruluysa ve siz bu sürümü daha önceden YOL’a eklemişseniz, “python” komutunu verdiğinizde Python3 yerine, sistemimizdeki eski Python sürümü açılacaktır. Çünkü Windows’taki bütün Python sürümlerinin çalıştırılabilir (exe) dosyaları “python.exe” şeklinde adlandırıldığı için, DOS ekranında yazacağınız “python” komutu eski sürümü çalıştıracaktır. Dediğim gibi, eğer eski sürümü önceden YOL’a eklemişseniz, yeni kurduğunuz Python3’ü YOL’a eklemeyin. Bunun yerine, basit bir .bat dosyası yazmamız yeterli olacaktır. Nasıl mı?

Notepad yardımıyla boş bir metin belgesi açın ve bu metin belgesinin içine şu satırı ekleyin:

@c:\python30\python.exe %*

Şimdi bu dosyayı “python3.bat” adıyla kaydedin ve daha önce YOL’a eklediğiniz eski sürüm Python’un bulunduğu klasörün içine atın (mesela C:python26).

Artık “cmd” ile ulaştığınız komut satırında sadece “python3” yazıp enter’e basarak Python3’ü çalıştırabilirsiniz. Sadece “python” komutu verdiğinizde ise sisteminizdeki eski sürüm Python açılacaktır. Tabii ki bu eski sürümü daha önceden YOL’a eklemiş iseniz...

Bu arada, oluşturduğunuz .bat dosyasını Python26 klasörünün içine atmak yerine, Python’a ilişkin .bat dosyalarını özel bir klasörde toplayıp bu klasörü YOL’a ekleyerek de işinizi halledebilirsiniz. Örneğin benim Windows yüklü bilgisayarımda Python’un 2.5, 2.6 ve 3.0 sürümleri birlikte kurulu... Ben “yol” adını verdiğim bir klasör oluşturup bu klasörü “C:” dizininin içine attım. Daha sonra “C:\yol” dizinini YOL’a ekledim. Ardından Python2.5 ve Python3.0 sürümleri için iki ayrı .bat dosyası oluşturdum. Bunlardan birini “python25.bat”, ötekini de “python3.bat” olarak adlandırdım. “python25.bat” dosyasının içeriği şöyle:

@c:\python25\python.exe %*

“python3.bat” dosyasının içeriği ise şöyle:

@c:\python30\python.exe %*

Bu şekilde, “cmd” ile ulaştığım komut satırında “python3” komutunu verdiğimde “Python3.0” sürümünün ekranı açılıyor:

Python 3.0.1 (r301:69561, Feb 13 2009, 20:04:18) [MSC v.1500 32 bit (Intel)] on
win32 Type "help", "copyright", "credits" or "license" for more information.
>>>

Eğer “python25” komutunu verirsem, “Python2.5” sürümüne ait komut ekranı açılıyor:

Python 2.5.4 (r254:67916, Dec 23 2008, 15:10:54) [MSC v.1310 32 bit (Intel)] on
win32 Type "help", "copyright", "credits" or "license" for more information.
>>>

“Python2.6” sürümüne ise sadece “python” yazarak ulaşabiliyorum:

Python 2.6.1 (r261:67517, Dec  4 2008, 16:51:00) [MSC v.1500 32 bit (Intel)] on
win32 Type "help", "copyright", "credits" or "license" for more information.
>>>

İsterseniz siz de böyle bir çalışma şekli benimseyebilirsiniz...

1.3. FreeBSD’de Python

Yukarıda Python 3.x’in GNU/Linux ve Windows sistemlerine nasıl kurulacağını ve nasıl çalıştırılacağını anlattık. Python’un FreeBSD sistemine nasıl kurulacağını öğrenmek isterseniz http://www.istihza.com/denemeler/freebsd.7z adlı dosyayı indirerek, bu sıkıştırılmış klasör içindeki video dosyalarını izleyebilirsiniz. Klasör içinde ayrıca FreeBSD kurulumunu gösteren bir video da bulunuyor. FreeBSD üzerinde Python’un nasıl kurulup kullanılacağına ilişkin videoları hazırlayan Mahmut Çetin‘e teşekkür ederim.

Videoları 7z adlı yazılımla sıkıştırdım. Videoların özgün boyutu toplam 223 MB’dir. İndireceğiniz sıkıştırılmış klasörün boyutu 7z yardımıyla 2 MB’ye kadar azaltılmıştır.

Ubuntu GNU/Linux kullanıcıları bu dosyayı açabilmek için şu komut yardımıyla 7z yazılımını sistemlerine kurabilir:

sudo apt-get install p7zip-full

Yazılımı kurduktan sonra sıkıştırılmış dosyaya sağ tıklayıp “buraya aç” seçeneği yardımıyla dosyayı açabilirsiniz.

Windows kullanıcıları ise gerekli yazılımı http://www.7-zip.org/ adresinden indirebilir.

1.4. Python’un Etkileşimli Kabuğu ve print() Fonksiyonu

Bir önceki bölümde Python’un farklı sistem ve durumlarda nasıl çalıştırılacağını görmüş, Python’u anlattığımız şekilde çalıştırdığınız zaman karşınıza şuna benzer bir ekranın geleceğini söylemiştik:

Python 3.0.1+ (r301:69556, Feb 24 2009, 13:51:44)
[GCC 4.3.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

Bu ekrana Python dilinde “etkileşimli kabuk” (interactive shell) adı verilir. Bu, bizim Python programlama dili ile ilişki kurabileceğimiz, yani onunla etkileşebileceğimiz bir üst katmandır. Etkileşimli kabuk, asıl programımız içinde kullanacağımız kodları deneme imkanı sunar bize... Burası bir nevi “test alanı” gibidir. Örneğin bir Python kodunun çalışıp çalışmadığını denemek veya nasıl çalıştığını, ne sonuç verdiğini görmek istediğimizde bu ekran son derece faydalı bir araç olarak karşımıza çıkar. İsterseniz konuyu daha fazla lafa boğmayalım. Zira etkileşimli kabuğu kullandıkça bunun ne büyük bir nimet olduğunu siz de anlayacaksınız. Özellikle derlenerek çalıştırılan programlama dilleri ile uğraşmış olan arkadaşlarım, etkileşimli kabuğun gücünü gördüklerinde, göz yaşlarına hakim olamayacaklar...

Şimdi kendi sistemimize uygun bir şekilde etkileşimli kabuğu çalıştırıyoruz. Bu ekrana nasıl ulaşacağımızı bir önceki konuda ayrıntılı olarak anlatmıştık. Etkileşimli kabuğa ulaşmak konusunda sıkıntı yaşıyorsanız bir önceki konuyu tekrar gözden geçirmenizi tavsiye ederim.

Etkileşimli kabuğu çalıştırdığımızda ekranda görünen “>>>” işareti Python’un bizden komut almaya hazır olduğunu gösteriyor. Python kodlarımızı bu “>>>” işaretinden hemen sonra, hiç boşluk bırakmadan yazacağız. İsterseniz basit bir deneme yapalım. “>>>” işaretinden hemen sonra, hiç boşluk bırakmadan şu komutu yazıyoruz:

print("Merhaba Zalim Dünya!")

Bu komutu yazıp “enter” tuşuna bastığımızda, eğer herhangi bir yazım hatası yapmamışsak, şöyle bir çıktı almış olmalıyız:

Merhaba Zalim Dünya!

Gördüğünüz gibi, print() adlı fonksiyon, ekrana çıktı vermemizi, yani yazı yazdırmamızı sağlıyor... Bu arada, bu “fonksiyon” kelimesine fazla takılmayın. İlerde bunun ne demek olduğunu ayrıntılı bir şekilde inceleyeceğiz. Şimdilik print() ifadesinin bir “fonksiyon” olduğunu bilmemiz yeterli olacaktır.

Burada dikkat etmemiz gereken bazı noktalar var:

Komutumuzu “>>>” işaretinden hemen sonra veriyoruz. Python’a yeni başlayanların en sık yaptığı hatalardan bir tanesi, print()‘in “p”si ile “>>>” işareti arasında bir boşluk bırakmalarıdır. Eğer “p” harfi ile “>>>” işareti arasında boşluk bırakırsak, Python bize bir hata mesajı gösterecektir. O yüzden boşluklara dikkat ediyoruz...

print() fonksiyonunu oluşturan bütün harflerin küçük olduğuna dikkat edin. Python açısından, “print” ve “Print” kelimeleri birbirinden farklıdır. Bizim fonksiyonumuzun adı print()‘tir. Başka bir şey değil...

print() fonksiyonunda, parantez içindeki ifadenin tırnak içinde gösterildiğine özellikle dikkat ediyoruz. Burada çift veya tek tırnak kullanmamız önemli değildir. Yani yukarıdaki kodu şöyle de yazabiliriz:

print('Merhaba Zalim Dünya!')

Yalnız dikkat etmemiz gereken şey, hangi tırnakla başladıysak onunla bitirmemiz gerektiğidir. Yani eğer başta çift tırnak kullandıysak, sonda da çift tırnak kullanmalıyız. Aynı şey tek tırnak için de geçerlidir. Yani Python açısından tek veya çift tırnak kullanmamızın değil, tutarlı olmamızın önemi vardır. Peki neden iki farklı tırnak çeşidi var?

Ekrana şöyle bir çıktı vermek istediğimizi varsayın:

Python programlama dilinin adı “piton” yılanından gelmez...

Yukarıdaki çıktıyı alabilmek amacıyla etkileşimli kabukta “>>>” işaretinden hemen sonra aşağıdaki komutu verip enter tuşuna basın. Bakalım ne olacak?

print("Python programlama dilinin adı "piton" yılanından gelmez...")

Ne oldu? Bu komut bize sinir bozucu bir hata mesajı verdi, değil mi?

File "<stdin>", line 1
print("Python programlama dilinin adı "piton" yılanından gelmez...")
                                            ^
SyntaxError: invalid syntax

Dikkat ederseniz, yukarıdaki hata mesajında “piton” kelimesinin hemen altında minik bir ok işareti görünüyor. Bu ok işareti, ortaya çıkan hatanın nerede olduğu konusunda bize ipucu veriyor. Buradaki hata, tırnak işaretlerinin kullanımından kaynaklanıyor. Biz cümlemize çift tırnak ile başladık. Ama cümle içinde “piton” kelimesinde de birer adet çift tırnak kullandık. Ayrıca cümlemizi de çift tırnak ile bitirdik. İşte bu noktada Python’un kafasının karışmasına neden olduk. Python böyle bir yapı ile karşılaştığında, “piton” kelimesinin başındaki çift tırnak nedeniyle cümlenin nerede başlayıp nerede bittiğini anlayamıyor. İlk çift tırnaktan sonra gördüğü ikinci çift tırnağın cümle sonu olduğunu zannediyor. Ama “piton” kelimesinin sonunda da bir çift tırnak olduğunu görünce bir şeylerin ters gittiğini düşünüyor ve bize bir hata mesajı gösteriyor. Zaten gördüğünüz gibi, ok işareti de bu üçüncü çift tırnağın olduğu yerde duruyor. Yani Python’un kafası tam olarak o noktada karışmış... Bize düşen görev, Python’un kafa karışıklığını gidermek. Bunu şöyle yapabiliriz:

>>> print('Python programlama dilinin adı "piton" yılanından gelmez...')

Python programlama dilinin adı "piton" yılanından gelmez...

Gördüğünüz gibi, bu komutta, hatayı önlemek için cümlemize tek tırnak ile başladık ve cümlemizi tek tırnak ile bitirdik. Cümle içindeki “piton” kelimesini ise çift tırnak ile göstererek karışıklığı önledik. Böylece bu komutla istediğimiz çıktıyı almış olduk...

Demek ki, Python’da ekrana çıktı verirken, tırnak işaretlerini dikkatli kullanıyoruz.

Bu arada yukarıdaki kodlar içinde görünen “>>>” işaretini siz yazmayacaksınız. Bu işareti etkileşimli kabuğun görünümünü temsil etmek için yerleştirdik oraya... Siz ilk satırı yazdıktan sonra doğruca enter tuşuna basacaksınız.

Şimdi şu cümleye bakalım:

Python’u yazan kişi Guido Van Rossum adlı bir programcıdır...

Acaba bu cümleyi, print() fonksiyonunu kullanarak ekrana nasıl yazdırmalıyız? Evet, tam tahmin ettiğiniz gibi:

>>> print("Python'u yazan kişi Guido Van Rossum adlı bir programcıdır...")

Python'u yazan kişi Guido Van Rossum adlı bir programcıdır...

“Python’u” kelimesinde geçen ayraç işareti nedeniyle cümlemize tek tırnakla başlamıyoruz. Eğer cümleye tek tırnakla başlarsak, Python o tek tırnak işareti yüzünden, cümlenin nerede başlayıp nerede bittiğini anlayamayacak ve bize bir hata çıktısı verecektir. İşte biz de bunu önlemek için yukarıdaki gibi bir önlem alıyoruz...

Gördüğünüz gibi, Python’un hem çift tırnağa hem de tek tırnağa müsaade etmesi bize bazı durumlarda büyük bir kolaylık sağlıyor. Demek ki birden fazla tırnak kullanılması boşuna değil...

Eğer ekrana herhangi bir şey yazdırmak yerine, bir satır boşluk bırakmak isterseniz, print() fonksiyonunu boş olarak kullanabilirsiniz. Yani şöyle:

>>> print()

Bu komutu verip enter’e bastığımızda etkileşimli kabuğun bir boşluk bırakıp alt satıra geçtiğini görüyoruz...

Etkileşimli kabukta çalışırken, print() fonksiyonunu kullanmasak da yazdığımız cümleler ekrana çıktı olarak verilecektir. Yani şöyle bir kullanım etkileşimli kabukta çalışırken mümkündür:

>>> "Lütfen kullanıcı adı ve parolanızı giriniz"

'Lütfen kullanıcı adı ve parolanızı giriniz'

Gördüğünüz gibi, print() fonksiyonunu kullanmasak da ekrana çıktı alabiliyoruz. Ama bu durum sizi yanıltmasın. Bu özellik sadece etkileşimli kabuğa mahsustur. İlerde kodlarımızı dosyalara yazıp kaydettiğimiz zaman, ekrana çıktı verebilmek için mutlaka print() fonksiyonunu kullanmamız gerekir. Eğer programlarımız içindeki cümleleri print() fonksiyonu ile kullanmazsak, programı çalıştırdığımızda, yazdığımız cümleyi Python görür, ama biz ve kullanıcılarımız göremeyiz!

Bu arada print() fonksiyonu ile veya onsuz yazdığımız cümlelerdeki Türkçe karakterlerin çıktıda herhangi bir soruna sebep olmadığına dikkat edin. print() fonksiyonu olmadan yazılan cümlelerdeki Türkçe karakterlerin düzgün görünmesi, Python 3.x ile gelen bir özelliktir. Eğer yukarıdaki cümleyi Python’un 2.x sürümlerinden birinde verseydik, şöyle bir tabloyla karşılaşacaktık:

>>> "Lütfen kullanıcı adı ve parolanızı giriniz"

'L\xc3\xbctfen kullan\xc4\xb1c\xc4\xb1 ad\xc4\xb1 ve parolan\xc4\xb1z\xc4\xb1 giriniz'

Bunun dışında, bu bölümde öğrendiğimiz print() fonksiyonu da Python 3.x’le birlikte mutasyon geçiren özelliklerden biridir. Bu yazıda öğrendiğimiz:

print("Merhaba Zalim Dünya!")

komutunu Python’un 3.x öncesi sürümlerinde:

print "Merhaba Zalim Dünya"

şeklinde yazıyorduk...

Böylece Python’da print() fonksiyonunun ne olduğunu ve ne işe yaradığını öğrenmiş olduk. İlerde kodlarımızı dosyalara kaydettiğimiz zaman bu fonksiyonu bol bol kullanacağız. Bu konuyu bitirdiğimize göre, artık yeni bir konuya geçebiliriz.

1.5. Python’da Basit Matematik İşlemleri

Bir önceki bölümde nasıl başlatacağımızı ve nasıl kullanacağımızı öğrendiğimiz etkileşimli kabuk üzerinde biraz daha çalışmaya devam edeceğiz. Etkileşimli kabuk aslında Python’da asıl çalışma ortamımız değildir. Kodlarımızı esas olarak dosyalara kaydedeceğiz. Ama etkileşimli kabuk bize, asıl programlarımızı yazmaya başlamadan önce Python’a aşinalık kazanma fırsatı verecek... Etkileşimli kabuk; kod alıştırması yapma ve kodları test etme gibi işlerimiz için harika bir araçtır.

Bu bölümde, Python’da basit matematik işlemlerini nasıl yapabileceğimizi öğreneceğiz. Python’la hiç bir şey yapamasak bile, onu basit bir hesap makinesi yerine kullanabiliriz. Şimdi etkileşimli kabuğu açıp çalışmaya başlayalım:

>>> 5 + 2

7

Gördüğünüz gibi, Python matematikten anlıyor.. Üstelik yukarıdaki kodda bize yabancı gelecek hiçbir öğe yok. Tıpkı bildiğimiz matematikte olduğu gibi, “+” işareti “toplama” anlamına geliyor. Bir de şuna bakalım:

>>> 3457 - 2456

1001

Burada da bir sıkıntı yok. Her şey sıradan... Peki çarpma ve bölme işlemleri için ne kullanacağız? Onlara da bakalım:

Çarpma işlemi için “*” işaretini kullanıyoruz:

>>> 6 * 5

30

Bölme işlemi için ise “/” işaretini:

>>> 5 / 2

2.5

Python için, işleme alınan sayıların büyüklüğü küçüklüğü önemli değildir. Python çok büyük (veya çok küçük) sayıları hiçbir sorun çıkarmadan çarpabilir, toplayabilir, çıkarabilir veya bölebilir...

Yalnız, birden fazla matematik işlemini aynı anda yaparken bir konuya dikkat etmemiz gerekir. Mesela size şöyle bir soru soralım: Sizce aşağıdaki işlemin sonucu kaçtır?:

>>> 5 * 2 + 4 / 2

Eğer yukarıdaki işlemin sonucu beklediğiniz gibi çıkmadıysa, “işlem önceliği” (operator precedence) denen kavramı gözardı etmişsiniz demektir. Matematik derslerinden hatırladığımız “işlem önceliği” kuralı Python’da da geçerlidir. Bu kurala göre; çarpma ve bölme işlemleri, toplama ve çıkarma işlemlerinden önce yapılır. Yani yukarıdaki ifadede önce “5 * 2” işlemi, ardından “4 / 2” işlemi yapılacak, daha sonra bu iki işlemin sonucu birbiriyle toplanacaktır. Python’un kullandığı işlem sırasını değiştirmek için parantez işaretlerinden yararlanabilirsiniz. Örneğin yukarıdaki işlemin “7” sonucunu vermesi için ifadeyi şöyle düzenlemeniz gerekir:

>>> (5 * 2 + 4) / 2

7.0

Öncelikli olarak yapılmasını istediğimiz işlemleri parantez içine aldığımıza dikkat edin. Bu şekilde, önce “5” ile “2” sayısı çarpılacak, ardından bu işlemin sonucuna “4” eklenecek ve çıkan değer “2”ye bölünecektir.

Matematik işlemleri yaparken, bu şekilde parantezler kullanarak işlemin istediğiniz gibi sonuç vermesini garanti edebilirsiniz.

Şimdiye kadar Python’da “+”, “-”, “*” ve “/” işaretlerini gördük. Bu işaretlere “işleç” (operator) adı verilir. Gelin isterseniz Python’da daha başka hangi faydalı işleçlerin olduğuna bir göz gezdirelim:

“%” işleci

Bir bölme işleminde, kalan sayıyı bulmak için “%” işaretinden yararlanıyoruz:

>>> 5 % 2

1

Demek ki “5” sayısını “2”ye böldüğümüzde, bölme işleminden artan sayı, yani “kalan”, 1 oluyormuş...

Bir de şu işlemin sonucuna bakalım:

>>> 10 % 2

0

Kalan “0” olduğuna göre, demek ki “10” sayısı “2”ye tam bölünüyormuş... Peki bu bilgi bizim ne işimize yarar? Mesela “%” adlı işlecin verdiği sonuca bakarak, sayıların çift mi yoksa tek mi olduğunu denetleyebiliriz. “herhangibirsayı % 2” işleminin sonucu “0” ise o sayı çifttir. Eğer sonuç “1” ise o sayı tektir... Eğer ilkokul öğrencilerine basit matematik kavramlarını öğreten bir program yazmayı planlıyorsanız bu işleç işinize yarayacaktır. Hatta ileride bu işlecin hiç tahmin etmediğiniz yerlerde de işinize yarayacağını görürseniz şaşırmayın...

“//” işleci

Python’da kullanabileceğimiz başka bir işleç ise şudur: “//”. Bu işleç, bir bölme işleminde sonucun sadece tamsayı kısmını almamızı sağlar. Hemen bir örnek vererek durumu somutlaştıralım:

>>> 9 // 2

4

Gördüğünüz gibi, sonuç tamsayı şeklinde. Yani sonucumuz ondalık kısmı içermiyor. Normalde “9” sayısı “2” sayısına bölündüğünde şu sonucu elde ederiz:

>>> 9 / 2

4.5

Aynı işlemi “9 // 2” şeklinde yaptığımızda ise ondalık kısım atılır, ekrana sadece tamsayı kısım verilir... İlk bakışta bu işleç çok manalı gelmeyebilir, ama ileride mutlaka, ondalık sayı yerine tamsayı elde etmek istediğiniz durumlarla karşılaşacaksınızdır.

“**” işleci

Bu işleç, bir sayının kuvvetlerini hesaplamak için kullanılır. Üslü sayıları bulmak için bu işleçten yararlanacağız. Örneğin:

>>> 2 ** 3

8

Demek ki “2” sayısının üçüncü kuvveti “8” imiş... Mesela 1453 sayısının karesini şöyle bulabiliriz:

>>> 1453 ** 2

2111209

Ya da 15 sayısının 3. kuvvetini şöyle bulabiliriz:

>>> 15 ** 3

3375

Python’da bunların dışında daha pek çok işleç bulunur. Ama içlerinde şu anda en çok işimize yarayacak, en temel işleçler bunlardır. İlerde öteki işleçleri de inceleyeceğiz.

Şu ana kadar Python’un temellerine ilişkin pek çok şey söyledik. Örneğin en temel öğelerden biri olan print() fonksiyonunu ve bu fonksiyonun ne işe yaradığını öğrendik. Bunun yanısıra Python’da sayıların kullanımına da şöyle bir göz gezdirdik. print() fonksiyonunu işlerken, bu fonksiyonun ekrana çıktı vermek için kullanıldığını, bu fonksiyonla birlikte kullandığımız cümleleri tırnak içine almamız gerektiğini söylemiştik. Yalnız bu bölümde dikkatinizi çekti mi bilmiyorum, ama farkettiyseniz yukarıdaki kodların hiçbirinde tırnak işareti kullanmadık. Şimdi gelin isterseniz bunun nedenlerini tartışalım...

1.6. Karakter Dizileri (strings)

Python’da çok önemli iki adet öğe vardır. Bunlardan biri “karakter dizileri” (strings), ikincisi ise “sayılar”dır (numbers). “Sayı”nın ne olduğu adından belli. Peki bu “karakter dizisi” denen şey de ne oluyor? Aslında print() fonksiyonunu anlatırken karakter dizilerini kullandık. Yalnız orada kafa karıştırmamak için “karakter dizisi” yerine “cümle” deyip geçmiştik. Şimdi ise sizlere hakikati söylemenin zamanı geldi dostlar! Evet, daha önce “cümle” dediğimiz şey esasında Python’cada “karakter dizisi”dir. İngilizce konuşanlar buna “string” diyor... Peki karakter dizisi denen şeyi gördüğümüzde nasıl tanıyacağız? Tabii ki tipine bakarak... Python’da karakter dizileri tırnak içinde gösterilir. Yani şu aşağıda gördüğümüz şey bir karakter dizisidir:

"Merhaba Zalim Dünya!"

Bu karakter dizisini ekrana yazdırmak için, bildiğiniz gibi şu komutu kullanıyoruz:

print("Merhaba Zalim Dünya!")

Yani “karakter dizisi”; içinde bir veya daha fazla sayıda karakter barındıran bir dizidir. Dolayısıyla bir “şey”in karakter dizisi olabilmesi için birden fazla karakter içeriyor olması şart değildir. Python’da tek bir karakter dahi, “karakter dizisi” sınıfına girer. Bu sebeple aşağıdaki “şey” de bir karakter dizisidir:

"c"

Hatta bir şeyin karakter dizisi olabilmesi için harf olması da gerekmez. Kabaca söylemek gerekirse, tırnak içinde gösterebileceğimiz her şey bir karakter dizisir. Boşluk karakteri de dahil...

Karakter dizilerini anladık sayılır. “Sayılar”ı ise zaten adından ötürü rahatlıkla anlayabiliyoruz. Mesela şu örnek bir sayıdır:

12354

Ama dikkat edin! Şu örnek bir sayı değildir:

"12354"

Tırnak içinde gösterilen “12354” bir karakter dizisidir. Dediğimiz gibi, Python’da tırnak içinde gösterilen her şey bir karakter dizisidir. Karakter dizilerini basitçe böyle ayırt edebiliriz. Bu durumu şu örneklerle teyit edelim:

>>> 12354 + 3444

15798

İsterseniz bunu bir de print() fonksiyonu ile gösterelim. Zaten normalde hep bu şekli kullanmamız yararlı olacaktır:

>>> print(12354 + 3444)

15798

Bir de şuna bakalım:

>>> print("12354 + 3444")

12354 + 3444

Gördüğünüz gibi, bu defa çıktımız farklı oldu. Neden? Çünkü dediğimiz gibi, tırnak işareti olmayan 12354 veya 3444 birer sayıdır, ama tırnak işareti olan “12354” veya “3444” birer karakter dizisidir. Aritmetik işlemleri sayılarla yapılır, karakter dizileriyle değil... Dolayısıyla Python, “Merhaba Zalim Dünya“ya nasıl davranıyorsa, “12354 + 3444“e de aynı şekilde davranıyor. Bunun için Python’u suçlayamayız...

Hatta şöyle ilginç bir örnek de verebiliriz:

>>> print("12354" + "3444")

123543444

Gördüğünüz gibi, iki tane karakter dizisiyle karşılaşan Python (“12354” ve “3444”), “artı” (+) işaretini bu iki karakter dizisini birleştirmek için kullandı. Eğer artı işaretinin beraber kullanıldığı öğeler birer sayı olsaydı, Python bunları yan yana yazmak yerine, birbirleriyle toplayacaktı.

Yukarıdaki örneklerin bize gösterdiği gibi, bazı işleçler, birlikte kullanıldıkları öğelerin tipine göre farklı anlamlar taşıyabilir. Yukarıda da şahit olduğumuz gibi, eğer söz konusu olan şey sayılar ise, “artı” işareti bir aritmetik işlem yapılmasını sağlayacaktır. Ama eğer söz konusu olan şey karakter dizileri ise, “artı” işareti bu karakter dizilerini bir araya getirme görevi görecektir. Mesela daha önce çarpma işlemlerinde kullandığımız “*” işareti de birlikte kullanıldığı öğelerin tipine göre farklı anlamlar taşıyabilir:

>>> print("yavaş"*2)

yavaşyavaş

Python burada “yavaş” karakter dizisini iki kez tekrar etti. Ama dikkat ederseniz, “yavaş” adlı karakter dizisini tekrar ederken araya boşluk koymadı. Tabii ki Python bizim ne istediğimizi bilemez. Python’un istediğimizi yapabilmesi için bizim ona yardımcı olmamız gerekir. Yukarıdaki kodları şöyle yazarsak, çıktı daha düzgün görünecektir:

>>> print("yavaş "*2)

yavaş yavaş

“yavaş” adlı karakter dizisinin kapanış tırnağını koymadan önce bir boşluk bırakarak emelimize ulaştık... Python çıktıda o boşluk karakterini de göreceği için, iki tane “yavaş” kelimesi çıktıda boşluklu olarak görünecektir.

Yalnız bazı durumlarda karakter dizisinin sonuna böyle boşluk eklemek mümkün olmayabilir. Eğer öyle bir durumla karşılaşırsak, şöyle bir şey de yapabiliriz:

>>> print(("yavaş" + " ")*2)

yavaş yavaş

Gördüğünüz gibi, burada sanki bir matematik işlemi yapar gibi, parantezleri kullanarak Python’a yol gösterdik. Matematikteki işlem önceliği kuralının burada nasıl işlediğine dikkat edin.

Karakter dizileri (strings) tabii ki yukarıda anlattıklarımızla sınırlı değildir. Ama şimdilik bizim bilgimiz sınırlı olduğu için, Python’daki karakter dizilerinin bütün imkanlarını burada önünüze seremiyoruz. Python’la ilgili birkaç şey daha öğrendikten sonra karakter dizilerini etkili bir şekilde kullanmayı da öğreneceğiz. Zira karakter dizileri, Python’un en güçlü olduğu alanlardan birisidir.

Bu konuyu da böylece tamamlamış olduk. Henüz söylenmesi gereken her şeyi söyleyemedik, ama Python’da sağlam bir temel atmamımızı sağlayacak pek çok önemli bilgiyi konular arasına serpiştirdik. Bu ilk bölümleri sindire sindire çalışmak, ilerde kemikli konuları daha kolay öğütmemizi sağlayacaktır.

Bir sonraki bölümde, Python’da hareket kabiliyetimizi bir hayli artıracak bir konuyu inceleyeceğiz: Değişkenler

1.7. Değişkenler

Bir önceki bölümün sonunda da belirttiğimiz gibi, değişkenler Python’daki esnekliğimizi, hareket kabiliyetimizi bir hayli artıracak olması bakımından epey önemli bir konudur. Bu konuyu işledikten sonra, artık asıl çalışma alanımız olan dosyalara geçebilecek kadar bilgi sahibi olmuş olacağız. Yani bu konuyu da atlattıktan sonra gerçek anlamda ilk programlarımızı yazmaya başlayabileceğiz.

Biz burada “değişken” kavramını tanımlamaya uğraşmakla vakit kaybetmeyeceğiz. Bir kısmımız bu kavrama zaten pek de yabancı değiliz. Öbür kısmımız ise verdiğimiz ilk örnekte bunun ne olduğunu, ne işe yaradığını derhal anlayacaktır... Dolayısıyla bir an önce örneklerimize geçelim:

Mesela şu örneğe bir bakalım:

>>> n = 10

Burada “n” adlı bir ifadeye, “10” değerini atadık. Yani, değeri 10 olan “n” adlı bir değişken tanımladık. Artık “n” değişkeninin değerine şu şekilde ulaşabiliriz:

>>> print(n)

10

Gördüğünüz gibi, 10 değerini elde etmek için “n” değişkenini ekrana yazdırmamız yeterli oluyor.

Bu şekilde bir değişken tanımladıktan sonra, bu değişkeni türlü şekillerde kullanabiliriz. Örneğin bu değişkenle matematik işlemleri yapabiliriz:

>>> print(n * 5)

50

Tabii ki yukarıdaki değişkenle matematik işlemleri yapabilmemiz, bu değişkenin değerinin bir sayı olmasından kaynaklanıyor. Eğer “n” değişkeninin değeri bir karakter dizisi olsaydı yukarıdaki komuttan alacağımız çıktı çok farklı olacaktı. Bakalım:

>>> n = "10"

Böylece “n” değerini yeniden tanımlamış olduk. Artık “n” değişkeninin değeri 10 değil, “10”... Yani sayı değil, karakter dizisi. Bunu şu şekilde teyit edebiliriz:

>>> print(n * 5)

10101010101010101010

Gördüğünüz gibi, bu defa Python 5 adet 10’u yan yana dizdi. Bunun sebebini biliyorsunuz. Aritmetik işlemleri sayılarla yapılır, karakter dizileriyle değil...

Gelin isterseniz birkaç tane daha değişken tanımlayarak elimizi alıştıralım:

>>> isim = "istihza"

Burada, değeri “istihza” olan, isim adlı bir değişken tanımladık. Buna şöyle ulaşabiliriz:

>>> print(isim)

istihza

Bu değişkeni istersek başka karakter dizileriyle birlikte kullanarak daha karışık işlemler de yapabiliriz. Mesela:

>>> print("Benim adım", isim)

Benim adım istihza

Burada, “Benim adım” adlı karakter dizisinden sonra bir virgül koyduğumuza ve “isim” adlı değişkeni ne şekilde kullandığımıza dikkat edin. Bununla ilgili benzer bir örnek daha yapalım:

>>> konu = "değişkenler"

>>> print("Bu dersimizin konusu", konu)

Bu dersimizin konusu değişkenler

Elbette, değişkenimizi sadece en sonda kullanmak zorunda değiliz. Bunu aralara da yerleştirebiliriz. Örneğin şöyle bir kod parçası yazdığımızı düşünün:

tarih = "12 Ekim 2007"

ziyaret_sayısı = "123456789"

print("Bu siteye", tarih, "tarihinden bu yana", ziyaret_sayısı, "defa tıklanmıştır.")

Bu kodların çıktısı şöyle olacaktır:

Bu siteye 12 Ekim 2007 tarihinden bu yana 123456789 defa tıklanmıştır.

Burada değişkenlerle ilgili olarak dikkatimizi çeken bazı noktalar var:

Değişken adı belirlerken Türkçe karakter kullanabiliyoruz. Gördüğünüz gibi, “ziyaret_sayisi” demek yerine, “ziyaret_sayısı” diyebildik... Bu özellik Python3.0 ile gelen bir güzelliktir. Python’un 2.x sürümlerinde aynı değişkeni “ziyaret_sayisi” şeklinde tanımlamamız gerekecekti.

Eğer değişken adı olarak birden fazla kelime kullanacaksak, kelimeler arasında boşluk bırakmıyoruz. Kelimeleri bitişik olarak yazabileceğimiz gibi, burada gördüğümüz şekilde kelimeler arasına alt çizgi işareti de koyabiliriz.

Ayrıca yine virgülleri nasıl kullandığımıza özellikle dikkat ediyoruz...

Bunların dışında değişken adları ile ilgili birkaç kural daha vardır...

Değişken adları asla bir sayıyla başlamaz. Kelimenin ortasında veya sonunda sayı bulunabilir, ama başında bulunamaz... Mesela “3sayı” geçerli bir değişken adı değildir. Ama “s3ayı” veya “sayı3” geçerli birer değişken adıdır.

Ayrıca, bazı özel kelimeler vardır ki, bunları değişken adı olarak kullanamayız. Bunlar şöyle listelenebilir:

and, del, from, not, while, as, elif, global, or, with, assert, else, if, pass, yield, break, except, import, print, class, exec, in, raise, continue, finally, is, return, def, for, lambda, try

Elbette bu listeyi ezberlemenize gerek yok. Programınız değişkenlerle ilgili anlamsız hatalar verdiğinde gelip bu listeyi kontrol edebilirsiniz... Ayrıca etkileşimli kabukta şu komutu vererek de yukarıdaki listeyi elde edebilirsiniz:

>>> help("keywords")

Gerçi eğer programlarınızı Türkçe olarak yazıyorsanız, yukarıdaki yasaklı kelimelerden birine toslamanız düşük bir ihtimaldir. Ama yine de Python’da bu tür “yasaklı kelimeler”in olduğunu bilmenin ilerde bize faydası dokunacaktır.

Değişkenler özellikle kullanıcıyla etkileşen, yani onlardan veri alıp onlara veri veren programlar yazdığımızda daha çok işimize yarayacaktır.

Gördüğünüz gibi, komut satırında yazdığımız kodlar artık tek satırı geçmeye başladı. Bunları bir yere kaydedip oradan çalıştırsak daha iyi olacak. Hem zaten etkileşimli kabukta yazdığımız kodlar kalıcı olmuyor. Etkileşimli kabuğu kapattığımız anda bunlar hafızadan siliniyor. Tabii ki yazdığımız programları başkalarıyla paylaşabilmek için bunları önce bir yere uygun şekilde kaydetmiş olmamız gerekiyor. Dolayısıyla artık yavaş yavaş asıl çalışma ortamımıza geçebiliriz. Çünkü bunu yapabilecek kadar temel bilgiye sahibiz şu anda.

1.8. Python Programlarını Kaydetmek

Buraya kadar olan tecrübelerimizden gördüğümüz gibi, etkileşimli kabuk gerçekten de oldukça pratik ve güçlü bir araçtır. Ama burada yazdığımız kodlar kalıcı olmuyor. Bizim istediğimiz şey ise, bir kod yazdığımızda o anı ölümsüzleştirmek... İşte bunun için, yazdığımız programları bir yere kaydetmemiz gerekiyor. Bu bölümde bunu nasıl yapacağımızı öğreneceğiz.

Aslında bizim bu aşamada ihtiyacımız olan tek şey basit bir metin düzenleyicidir. Eğer GNU/Linux üzerinde KDE masaüstü ortamını kullanıyorsanız Kwrite veya Kate işinizi görecektir. Eğer kullandığınız sistem GNU/Linux üzerinde GNOME masaüstü ortamı ise Gedit sizin için yeterli olacaktır. Windows kullanıcıları, bilgisayarlarına kurdukları Python programı ile birlikte gelen IDLE adlı yazılımı kullanabilirler.

Windows kullananlar, IDLE’ye Başlat > Programlar > Python 3.x > IDLE (Python GUI) yolunu takip ederek ulaşabilir. IDLE’yi ilk başlattığınızda karşınıza “Python Shell” başlıklı bir ekran gelecektir. Aslında bu daha önce bahsettiğimiz ve şimdiye kadar hep üzerinde çalıştığımız etkileşimli kabuğun kendisidir... Burayı da etkileşimli kabuğu kullandığımız gibi kullanabiliriz. Ama bizim şimdi bahsedeceğimiz özellik bu değildir. Bizim ihtiyacımız olan şey bir metin düzenleyici. IDLE’nin metin düzenleyicisine ulaşmak için File > New Window yolunu takip etmeliyiz. Veya kısaca “CTRL+N” tuşlarına basarak da metin düzenleyiciyi açabiliriz. File > New Window yolunu takip ederek veya kısaca “CTRL+N” tuşlarına basarak ulaştığımız ekran, Python kodlarımızı yazacağımız alandır. Bu alanı nasıl kullanacağımızı biraz sonra göreceğiz. Ama önce GNU/Linux kullanıcılarının neler yapacağına bir bakalım...

Dediğim gibi, eğer GNU/Linux üzerindeyseniz Kwrite, Kate veya Gedit programlarını kullanabilirsiniz. Bu metin düzenleyici programlara ulaşmanın en kolay yolu “komut çalıştır” penceresinde bu programların ismini yazıp enter’e basmaktır... Muhtemelen bunun nasıl yapılacağını biliyorsunuz, ama ben yine de kısaca anlatayım:

Önce ALT+F2 tuşlarına basıyoruz. Eğer KDE kullanıyorsak, Kwrite’yi çalıştırmak için, açılan pencerede şu komutu veriyoruz:

kwrite

Kate için şu komutu:

kate

Eğer bir GNOME kullanıcısıysak, Gedit’i çalıştırmak için şöyle bir komut veriyoruz:

gedit

Yukarıdaki komutlar arasından kendinize uygun olanı verdiğinizde karşınıza boş bir metin düzenleyici gelecek. İşte Python kodlarımızı buraya yazacağız.

Aslında IDLE, Kwrite, Kate veya Gedit dışında, Python programlarımızı yazıp çalıştırmak için kullanabileceğimiz pek çok uygulama bulunur. Programlarımızı yazmak ve çalıştırmak için kullanabileceğimiz bu özel uygulamalara “IDE” (Geliştirme Ortamı) adı verilir. Bazı IDE’ler bize oldukça gelişmiş özellikler sunar. Python için geliştirilmiş IDE’lerin bir listesi için şu adresi ziyaret edebilirsiniz: http://wiki.python.org/moin/IntegratedDevelopmentEnvironments.

Her bir IDE’nin kendine özgü bir çalışma mantığı ve şekli vardır. Biz burada bu IDE’leri tek tek incelemeyeceğiz. Bizim için şu aşamada, yazılan kodları bilgisayarımıza kaydetmemizi sağlayacak herhangi bir program yeterli olacaktır. Hatta Notepad uygulaması bile bu iş için yeterlidir... Ama tabii ki Notepad’dan biraz daha gelişmiş bir metin düzenleyici kullanmak hayatımızı kolaylaştıracaktır. Dolayısıyla, Kwrite, Kate, Gedit veya IDLE şu aşamada bizim için yeter de artar bile... Neyse... Lafı çok fazla uzattık. Asıl konumuza gelmeliyiz artık.

Şimdi kendi sistemimize uygun olarak Kwrite, Kate, Gedit veya IDLE programlarından birini başlatalım. (IDLE kullanıcıları File > New Window yolunu takip ederek boş bir sayfa açmayı unutmuyorlar...)

Açtığımız boş metin sayfasına şu satırı yazıyoruz:

#!/usr/bin/env python3.0

Bu satır sadece GNU/Linux kullanıcıları içindir. Windows kullanıcıları bu satırı yazmasa da olur... Bu satırı yazmamızın amacı, GNU/Linux’ta programımızı çalıştıracağımız zaman Python’un hangi sürümünü kullanmak istediğimizi açıkça belli etmektir... Bu satırın önemini biraz sonra ayrıntılı olarak anlatacağız. Ama şimdi programımızı yazmaya devam edelim. İkinci satırımız şöyle:

print("Merhaba Zalim Dünya!")

İlk programımız bu kadar. İsterseniz bu kodları bir arada görelim:

#!/usr/bin/env python3.0

print("Merhaba Zalim Dünya!")

Programımızı yazdığımıza göre sıra geldi bu programı bilgisayarımıza kaydetmeye... Kullandığımız metin düzenleyicinin kaydetme özelliğini kullanarak bu dosyayı “ilk.py” adıyla (tırnaklar olmadan) bilgisayarımıza kaydedelim. Gelin isterseniz ilk programımızı masaüstüne kaydedelim, ki ulaşması kolay olsun. Programımızı kaydettiğimize göre, artık bu programı çalıştırabiliriz. Kaydettiğimiz bu programı nasıl çalıştıracağımızı bir sonraki bölüme bırakalım...

1.9. Python Programlarını Çalıştırmak

Bir önceki bölümde, bir Python programını nasıl yazıp kaydedebileceğimizi öğrendik. Bu bölümde ise yazıp kaydettiğimiz bu programı nasıl çalıştıracağımızı inceleyeceğiz.

Önce kendi sistemimize uygun olarak bir konsol veya DOS ekranı açıyoruz. GNU/Linux KDE kullanıcıları ALT+F2 ile gelen pencerede “konsole” komutunu kullanarak komut satırına ulaşabilir. GNOME kullanıcılarının aynı iş için kullanması gereken komut “gnome-terminal”dir. Windows kullanıcıları ise Başlat > Çalıştır yolunu takip ederek açılan pencerede “cmd” komutuyla DOS ekranına erişebilir.

Komut satırını ilk açtığınızda bulunduğunuz dizin muhtemelen masaüstü olmayacaktır. Ama biz programımızı masaüstüne kaydettiğimiz için, öncelikle dizinimizi masaüstü olarak değiştirmemiz gerekiyor. Bütün platformlarda şu komutu vererek masaüstüne geçebilirsiniz:

cd Desktop

Masaüstüne geldikten sonra GNU/Linux kullanıcıları şu komutu veriyor:

python3.0 ilk.py

Windows kullanıcıları ise şu komutu:

python ilk.py

Windows kullanıcıları bu komutu verdiklerinde program muhtemelen çalışacaktır. Ama eğer sistemde başka bir Python sürümü kuruluysa, programı o sürüm çalıştırmış olabilir. Lütfen okumaya devam ediniz...

Eğer her şey yolunda gitmişse konsol veya DOS ekranına şu yazının döküldüğünü göreceğiz:

Merhaba Zalim Dünya!

Tebrikler! Böylece gerçek anlamda ilk Python programınızı yazmış oldunuz. Henüz programımız önemli bir iş yapmıyor. Ama bir Python programının sahip olması gereken bütün temel özellikleri taşıyor. Şimdilik bizim için önemli olan tek şey, bu basit programı çalıştırabiliyor olmaktır... Yalnız bu noktada bir-iki ufak not düşelim:

Temel kural şudur: Python’un etkileşimli kabuğunu çalıştırmak için hangi komutu kullanıyorsanız, yazdığınız programı çalıştırmak için de o komutu kullanacaksınız. Yukarıda gördüğünüz gibi, Windows için “python ilk.py” komutunu kullandık. Tabii bu komut, sistemlerinde sadece Python 3.x sürümü kurulu olan kullanıcılar için geçerlidir. Eğer sisteminizde Python 3.x ile birlikte Python’un eski sürümleri de kuruluysa (mesela Python2.6), bu komutu verdiğinizde aslında programınız Python2.6 ile çalışmış olabilir. Ama siz aynen bu sitede anlatıldığı şekilde .bat dosyaları hazırlayarak Python sürümlerini birbirinden ayırdıysanız, programınızın Python3.x sürümüyle çalışmasını garanti etmek için vermeniz gereken komut şu olacaktır:

python3 ilk.py

Tabii ki, eğer siz .bat dosyasının adını farklı bir şey yapmışsanız o ismi kullanmanız gerekir. Mesela benim Windows yüklü bilgisayarımda, daha önce de söylediğim gibi, Python2.5, Python2.6 ve Python3.0 sürümleri bir arada kurulu. Windows’taki Python’a ait bütün çalıştırılabilir dosyaların adı “python.exe” olduğu için, ben Python 2.6 sürümünü YOL’a ekledim. Öteki sürümler için ise, “python25.bat” ve “python3.bat” adlı iki ayrı .bat dosyası yazdım. Dolayısıyla ben herhangi bir Python programını Python2.5 sürümüyle çalıştırmak istersem şu komutu veriyorum:

python25 program_adı.py

Veya bir programı Python2.6 ile çalıştırmak istediğimde sadece şu komutu veriyorum:

python program_adı.py

Çünkü Python2.6’yı daha önceden YOL’a eklemiştim... Eğer bir programı Python 3.x ile çalıştırmam gerekirse de şu komutu kullanıyorum:

python3 program_adı.py

GNU/Linux kullanıcıları için ise şu komutu kullandık:

python3.0 ilk.py

Tabii eğer siz Python’un etkileşimli kabuğunu çalıştırmak için “python3” komutunu kullanıyorsanız ilk.py adlı programı şöyle de çalıştırabilirsiniz:

python3 ilk.py

Dediğim gibi, işin özü şu: Python’un etkileşimli kabuğunu nasıl başlatıyorsanız, programlarınızı da öyle çalıştıracaksınız. Yani eğer etkileşimli kabuğu:

python

komutuyla başlatıyorsanız, ilk.py adlı programımızı çalıştırmak için şu komutu vereceksiniz:

python ilk.py

Eğer etkileşimli kabuğu:

python3

komutuyla çalıştırıyorsanız, programımızı şu komutla çalıştıracaksınız:

python3 ilk.py

Eğer etkileşimli kabuğu çalıştırmak için verdiğiniz komut:

python3.0

ise, ilk.py’yi şöyle çalıştırıyoruz:

python3.0 ilk.py

Bu noktada IDLE kullanıcıları için ufak bir not düşelim: IDLE kullananlar, programı bilgisayara kaydettikten sonra, sadece F5 tuşuna basarak programlarını çalıştırabilir. Ayrıca şunu da söyleyelim: IDLE programı, .py uzantılı dosyaların sağ tık menüsüne yerleşecektir. Yani bilgisayarınızdaki herhangi bir Python dosyasına sağ tıkladığınızda, menüde “Edit with IDLE” adlı bir seçenek de göreceksiniz. Bu seçeneği kullanarak .py uzantılı dosyayı IDLE ile düzenlemek üzere açabilirsiniz. Bu arada ufak bir not daha düşelim: IDLE adlı program Python’u yazan kişi olan Guido Van Rossum tarafından geliştirilmiştir...

Peki bir soru soralım: Acaba Python programlarını çalıştırmak için hep başlarına böyle “python” diye yazmak zorunda mıyız? Elbette hayır. Programlarımızı isimleriyle de çağırabiliriz:

Aşağıda söyleyeceklerim GNU/Linux kullanıcıları için geçerli:

Burada, ilk.py adlı programımızın ilk satırına yerleştirdiğimiz “#!/usr/bin/env python3.0” satırının önemi ortaya çıkıyor. Programlarımızı isimleriyle çalıştırabilmek için bir defa bu satırı mutlaka yazmalıyız. İkincisi, program dosyamızı “çalıştırılabilir” olarak ayarlamalıyız. Bunu yapmak için program dosyasına sağ tıklayıp “özellikler” menüsü içindeki “izinler” sekmesine geldikten sonra, oradaki “çalıştırılabilir” adlı kutucuğu işaretlememiz gerekir. Aynı işlemi konsoldan şu komutu vererek de yapabiliriz:

chmod a+x ilk.py

Böylece dosyamıza çalıştırma yetkisi vermiş olduk. Bundan sonra programımızı şu komutla çalıştırabiliriz:

./ilk.py

Artık programımızın .py uzantısını silip, adını “ilk” olarak değiştirdikten sonra konsolda doğrudan şu komutu vererek de programımızı çalıştırabiliriz:

./ilk

Peki ya biz programımızı tıpkı öteki programlar gibi sadece adını kullanarak çalıştırmak istiyorsak ne yapacağız?

Bunun için programımızı /usr/bin/ klasörünün içine atmamız gerekir. Programımızı /usr/bin/ içine attıktan sonra sadece şu komutu vermemiz yeterli olacaktır:

ilk

Gelelim Windows kullanıcılarına:

Windows kullanıcıları, yazdıkları programı sadece ismiyle çalıştırmak için DOS ekranında “cd Desktop” komutuyla masaüstüne geldikten sonra şu komutu verebilir:

deneme.py

Bu komut, programı otomatik olarak sistemdeki en son Python sürümüyle çalıştıracaktır.

Windows kullanıcıları ayrıca program dosyasına çift tıklayarak da programlarını çalıştırabilir. Çünkü Python sisteme kurulurken kendini Windows kütüğüne (registry) kaydeder. Dolayısıyla Windows, .py uzantılı bir dosyayı hangi programla çalıştırması gerektiğini bilir. Ancak dosyaya çift tıklandığında Windows bu programı Python’un yine en son sürümüyle çalıştıracaktır.

Windows’ta, yazdığınız programa çift tıkladığınızda bir DOS ekranının hızla yanıp söndüğünü göreceksiniz. Aslında programınız çalışıyor ve ekrana “Merhaba Zalim Dünya!” yazısını yazdırıyor, ama çalışma süreci çok hızlı olduğu için bu çıktı ekrana verilir verilmez, programın sonuna gelindiğinden ötürü DOS ekranı hemen kapanıyor. İsterseniz ilk.py adlı dosyayı şu şekilde yazarak DOS ekranının hemencecik kapanmasını engelleyebilirsiniz:

print("Merhaba Zalim Dünya!")

input()

Böylelikle, program dosyasına çift tıkladığınızda DOS ekranı açılacak, “Merhaba Zalim Dünya!” çıktısı ekrana verilecek ve siz enter tuşuna basana kadar da DOS ekranı açık kalacaktır... Ancak bu yöntem her zaman tercih edilmeyebilir. Çünkü bu şekilde, eğer programda bir hata varsa programın verdiği hataları göremezsiniz. Hataları görebilmek için en doğru yol programı komut satırından çalıştırmaktır. Böylece eğer programda bir hata varsa komut ekranında bunları görebilir ve hataları düzeltebilirsiniz. Buna bir örnek verelim. Diyelim ki programımızda şöyle bir hata yaptık:

print("Merhaba Zalim Dünya!"

input()

Gördüğünüz gibi, “print(“Merhaba Zalim Dünya!” satırında kapanış parantezini koymayı unuttuk ve programımızı bu şekilde kaydettik. Şimdi program dosyamıza çift tıkladığımızda DOS ekranı input() satırına rağmen anlık olarak ekranda görünüp kaybolacaktır. Bu şekilde sorunun nereden kaynaklandığını anlayamazsınız. Ama eğer bu programı komut satırından çalıştırırsanız, en azından programdaki hata konusunda bir fikir sahibi olabilir, buna göre programa müdahale edebilirsiniz.

Böylece Python programlarımızı nasıl çalıştırabileceğimiz öğrenmiş olduk. Artık hızla yolumuza devam edebiliriz.

1.10. Python’da İlk Örnekler...

Buraya kadar Python’la ilgili birkaç şey öğrendik... Öğrendiklerimiz henüz yeterli değil elbette. Ama en azından elimizi alıştırmak için dahi olsa birkaç örnek yapabiliriz. Bu bölüm aynı zamanda bir nevi, önceki konuların tekrarı gibi de olacaktır. Daha önce öğrendiğimiz konuları burada tekrar etme fırsatı bulmanın yanısıra, bu derste yeni şeyler de öğreneceğiz. O halde hemen işe koyulalım.

İlk iş olarak, daha önceki derslerde öğrendiğimiz şekilde boş bir metin sayfası açıyoruz. Bu iş için Kwrite, Kate, Gedit, IDLE ve hatta Notepad gibi programlardan herhangi birini kullanabiliriz. Şimdi, tercih ettiğimiz metin düzenleyiciyi kullanarak boş bir sayfa açalım ve içine şunları yazalım:

#!/usr/bin/env python3.0

a = "kalem"
b = "pergel"
c = "çikolata"

print("Bir", a, "bir", b, "bir de", c, "alacağım...")

Buradaki ilk satır sadece GNU/Linux kullanıcıları içindir. Windows kullanıcıları bu satırı yazmayabilirler. Burada “a”, “b” ve “c” adlı değişkenlere sırasıyla “kalem”, “pergel” ve “çikolata” değerlerini nasıl atadığımıza dikkat edin. Değerlerimizi tırnak içine almayı unutmuyoruz. Çünkü bunlar birer karakter dizisidir.

En son satırda ise, ilk derslerde öğrendiğimiz print() fonksiyonunu görüyoruz. Daha önce tanımladığımız değişkenleri, print() fonksiyonu içine tek tek yerleştirdik. Değişken adlarını tırnak içine almadığımıza dikkat edin. Ayrıca bu kodları yazarken, virgülleri de yanlış yerlere koymamaya özen gösteriyoruz.

Şimdi artık bu kodları .py uzantısıyla kaydedebiliriz. Mesela “deneme.py” adıyla kaydedelim kodlarımızı... Böylelikle elimizde, Python’la yazılmış bir program örneği olmuş oldu. Şimdi bu programı çalıştıracağız. Bunun için, kullandığımız işletim sistemine uygun olarak hemen bir komut satırı açıyoruz. Komut satırını nasıl açacağımızı daha önceki derslerimizde anlatmıştık. Ama isterseniz yine de kısaca değinelim:

GNU/Linux’ta KDE masaüstü ortamını kullananlar “ALT+F2” tuşlarına basıp, açılan pencerede “konsole” komutunu vererek; GNOME masaüstü ortamını kullananlar ise aynı pencerede “gnome-terminal” komutunu vererek bir komut satırı açabilirler. Windows kullanıcıları ise Başlat > Çalıştır yolunu takip ederek, açılan pencerede “cmd” komutunu verdikten sonra MS-DOS ekranına ulaşabilir. Komut satırına ulaştıktan sonra, orada şu komutu verelim:

python3 deneme.py

Tabii eğer program dosyanızı masaüstüne kaydettiyseniz:

cd Desktop

komutu yardımıyla öncelikle masaüstünün bulunduğu dizine gelmeniz gerekir...

Bir de ben burada dosyayı “deneme.py” adıyla kaydettiğinizi varsaydım. Eğer farklı bir dosya adı kullandıysanız, burada o adı yazmalısınız. Ayrıca dosya adının önüne “python3” yazdığıma dikkat edin. Temel kuralımız şuydu: Python’un etkileşimli kabuğuna ulaşmak için hangi komutu kullanıyorsanız burada da o komutu kullanacaksınız. Yani eğer etkileşimli kabuğu “python3.0” diyerek açıyorsanız şu komutu vermeniz gerekir:

python3.0 deneme.py

Yok eğer Python 3.x’in etkileşimli kabuğunu sadece “python” komutuyla açıyorsanız, tabii ki vereceğiniz komut şu olacaktır:

python deneme.py

Eğer daha önceki derslerde açıkladığımız şekilde gerekli ayarları yaparsanız, programımızı sadece adıyla veya üzerine çift tıklayarak da çalıştırabileceğimizi biliyorsunuz.

Kendimize uygun olan komutu verip yukarıdaki programı çalıştırdığımızda şöyle bir çıktı elde edeceğiz:

Bir kalem bir pergel bir de çikolata alacağım...

Gelin isterseniz bu kodlara yeni bir satır daha ekleyelim. Dosyanın en son satırından sonra şunu yazalım:

print("Fişini almayacak mısın oğlum?")

Yani kodlarımız şöyle olmuş oldu:

#!/usr/bin/env python3.0

a = "kalem"
b = "pergel"
c = "çikolata"

print("Bir", a, "bir", b, "bir de", c, "alacağım...")
print("Fişini almayacak mısın oğlum?")

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

Bir kalem bir pergel bir de çikolata alacağım...
Fişini almayacak mısın oğlum!

Gördüğünüz gibi, ikinci print() fonksiyonu ile verdiğimiz çıktı otomatik olarak bir alt satırda görünüyor. Çoğu zaman istediğimiz davranış bu olacaktır. Ama bazen istediğimiz şey bu olmayabilir. Bunun yerine, yeni eklenen satırın bir öncekiyle aynı satırda görünmesini isteyebiliriz. O zaman, Python’un bize sunduğu “end” adlı ifadeden yararlanabiliriz:

#!/usr/bin/env python3.0

a = "kalem"
b = "pergel"
c = "çikolata"

print("Bir", a, "bir", b, "bir de", c, "alacağım...",
       end="Fişini almayacak mısın oğlum?")

Bu kodların çıktısı şöyle olacaktır:

Bir kalem bir pergel bir de çikolata alacağım... Fişini almayacak mısın
oğlum!istihza@istihza:~/Desktop$

Gördüğünüz gibi, çıktımız hiçbir şekilde biçimlendirilmedi. Öyle ki, çıktımız komut satırındaki “istihza@istihza:~/Desktop$” ifadesinin dahi gerisinde kaldı! Bu kullanımda ne bir boşluk karakteri otomatik olarak eklenir, ne de otomatik olarak yeni satıra geçilir. Arzu ettiğimiz işaretleri kendimiz koymamız lazım. Mesela bu kodları şu şekilde yazarak daha düzgün bir çıktı alabiliriz:

#!/usr/bin/env python3.0

a = "kalem"
b = "pergel"
c = "çikolata"

print("Bir", a, "bir", b, "bir de", c, "alacağım...",
end="Fişini almayacak mısın oğlum?\n")

Bu defa çıktımız şöyle olacak:

Bir kalem bir pergel bir de çikolata alacağım... Fişini almayacak mısın oğlum!

Bu kez hem üç noktadan sonra bir boşluk var, hem de çıktımız verildikten sonra bir alt satıra geçiliyor. Bunu nasıl becerdiğimize bakalım:

“end=” ifadesinin ardından bir boşluk bırakarak çıktının da bir adet boşluk karakteri içermesini sağladık. “end=” ile eklediğimiz karakter dizisinin en sonuna şöyle bir işaret koyduk: “\n”. Buna programlama dillerinde “yeni satır karakteri” adı verilir. Bir cümleyi herhangi bir yerinden bölüp alt satıra geçmek istediğimizde bu karakteri kullanabiliriz. İsterseniz bununla ilgili birkaç örnek yapalım:

Diyelim ki elimizde şöyle bir karakter dizisi var:

Guido Van Rossum Python’u geliştirmeye 1990 yılında başlamış... Yani aslında Python için nispeten yeni bir dil denebilir. Ancak Python’un çok uzun bir geçmişi olmasa da, bu dil öteki dillere kıyasla kolay olması, hızlı olması, ayrı bir derleyici programa ihtiyaç duymaması ve bunun gibi pek çok nedenden ötürü çoğu kimsenin gözdesi haline gelmiştir. Ayrıca Google’nin de Python’a özel bir önem ve değer verdiğini, çok iyi derecede Python bilenlere iş olanağı sunduğunu da hemen söyleyelim. Mesela bundan kısa bir süre önce Python’un yaratıcısı Guido Van Rossum Google’de işe başladı...

Bizim amacımız bu uzun cümleyi ekrana yazdırmak, ama yazdırırken de belli noktalarından bölmek olsun. Bunun için şöyle bir şey yazabiliriz:

#!/usr/bin/env python3.0

print("\nPython Hakkında:")
print()
print("Guido Van Rossum Python'u geliştirmeye 1990 yılında başlamış...\nYani \
aslında Python için nispeten yeni bir dil denebilir.\nAncak Python'un çok uzun\
bir geçmişi olmasa da,\nbu dil öteki dillere kıyasla kolay olması, hızlı olması,\nayrı\
bir derleyici programa ihtiyaç duymaması\nve bunun gibi pek çok nedenden ötürü\
çoğu kimsenin\ngözdesi haline gelmiştir. Ayrıca Google'nin de Python'a özel bir\
önem\nve değer verdiğini, çok iyi derecede Python bilenlere iş olanağı\nsunduğunu\
da hemen söyleyelim. Mesela bundan kısa bir süre önce\nPython'un yaratıcısı Guido\
Van Rossum Google'de işe başladı...")

Gördüğünüz gibi, yeni bir satırda yer almasını istediğimiz kısımlara “\n” karakterini yerleştirdik. Ayrıca bu uzun karakter dizisini belli noktalarda enter tuşuna basarak bölmek istediğimizde de “\” işaretinden yararlanıyoruz. Eğer enter tuşuna basacağımız noktalarda bu “ters bölü” işaretini kullanmazsak programımız hata verecektir... Bu ters bölü işaretleri çıktıda görünmez, hatta bu işaretlerin çıktı üzerinde hiçbir etkisi yoktur. Bu işaret yardımıyla Python’a şöyle bir şey söylemiş oluyoruz:

“enter tuşuna bastığıma bakma! Aslında satır devam ediyor...“

Bu kodları çalıştırdığımızda şuna benzer bir çıktı alırız:

istihza@istihza:~/Desktop$ python3 deneme.py

Python Hakkında:

Guido Van Rossum Python'u geliştirmeye 1990 yılında başlamış...
Yani aslında Python için nispeten yeni bir dil denebilir.
Ancak Python'un çok uzun bir geçmişi olmasa da,
bu dil öteki dillere kıyasla kolay olması, hızlı olması,
ayrı bir derleyici programa ihtiyaç duymaması
ve bunun gibi pek çok nedenden ötürü çoğu kimsenin
gözdesi haline gelmiştir. Ayrıca Google'nin de Python'a özel bir önem
ve değer verdiğini, çok iyi derecede Python bilenlere iş olanağı
sunduğunu da hemen söyleyelim. Mesela bundan kısa bir süre önce
Python'un yaratıcısı Guido Van Rossum Google'de işe başladı...

Gördüğünüz gibi, satırlar “\” işaretinin bulunduğu yerlerden değil, “\n” işaretinin olduğu noktalardan bölünüyor... Ayrıca burada “\n” karakterini kelimeler arasına yerleştirirken boşluk bırakmadığımıza da dikkat edin. Çünkü “\n” karakteri kendisinden sonra gelen kelimeyi bir alt satıra alacağı için, eğer kelimeler arasında boşluk bırakırsak, alt satıra geçen kelime, yeni satırda girintili olarak görünecektir...

Yukarıda da ifade ettiğimiz gibi, böyle uzun cümlelerle çalışırken, eğer kendiniz enter tuşuna basarak alt satıra geçmeye çalışırsanız, programınız hata verecektir. Bunu önlemek için “\” işaretinden yararlanmamız gerekir. Bu durum Python’da tek ve çift tırnak işaretlerinin özelliğidir.

Eğer karakter dizilerini yazarken alt satıra geçmek istiyorsanız bu işi “\n” adlı karakterle yapmanız gerekir. Dediğim gibi, aksi halde hata alırsınız...

Gördüğünüz gibi yukarıdaki gibi bir kod yazabilmek için epey takla atmamız gerekti... Ama Python’da çareler tükenmez! Bunun gibi uzun cümlelerle çalışırken işimize yarayacak başka bir tırnak tipi daha vardır Python’da: “üç tırnak”

“üç tırnak” işaretini kullanarak, çok uzun cümleleri sorunsuz ve dertsiz bir şekilde ekrana yazdırabiliriz. Mesela yukarıdaki örnek üzerinden gidelim:

#!/usr/bin/env python3.0

print("""
Python Hakkında:
""")

print("""Guido Van Rossum Python'u geliştirmeye 1990 yılında başlamış...
Yani aslında Python için nispeten yeni bir dil denebilir. Ancak
Python'un çok uzun bir geçmişi olmasa da, bu dil öteki dillere kıyasla
kolay olması, hızlı olması, ayrı bir derleyici programa ihtiyaç duymaması
ve bunun gibi pek çok nedenden ötürü çoğu kimsenin gözdesi haline gelmiştir.
Ayrıca Google'nin de Python'a özel bir önem ve değer verdiğini, çok iyi derecede
Python bilenlere iş olanağı sunduğunu da hemen söyleyelim. Mesela bundan kısa
bir süre önce Python'un yaratıcısı Guido Van Rossum Google'de işe başladı...""")

Burada “”” (üç tırnak) işaretini nasıl kullandığımıza dikkat edin. Bir tane bile “\n” karakteri kullanmadan, klavyedeki enter tuşunu kullanarak, istediğimiz yerden böldük cümlelerimizi. Aynı şeyi çift veya tek tırnak ile yapmaya çalıştığımızda programımızın hata verdiğini görürüz...

Buraya kadar öğrendiğimiz bilgilere göre Python’da üç adet tırnak tipi kullanılabiliyor:

1. Tek tırnak (‘)
2. Çift tırnak (”)
3. Üç tırnak (“””)

Tek ve çift tırnaklar kısa karakter dizilerinde kullanılmaya oldukça uygundur. Elbette kısa karakter dizileriyle de üç tırnağı kullanabilirsiniz.Ama kısa karakter dizileri için üç tırnak kullanımı pek yaygın değildir. Zaten mesela “elma” gibi kısa bir karakter dizisini “”“elma”“” şeklinde yazmak en basitinden “çirkin” bir görünüm sunacak, hiç de pratik olmayacaktır...

Yukarıdaki kodları çok dikkatli bir şekilde inceleyip, hangi kodun ne işe yaradığını anlamaya çalışmanızı öneririm. Hatta yukarıdaki kodlarda kendinize göre birtakım değişiklikler yaparak, kodların işlevini daha iyi kavrayabilirsiniz.

İsterseniz Python’da tırnak işaretlerinin işlevini daha iyi kavrayabilmek için birkaç örnek daha yapalım. Mesela şöyle bir cümleyi ekrana nasıl yazdırırsınız:

*Bugün Adana'ya gidiyoruz!*

Bu cümleyi en kolay şu şekilde yazdırabiliriz:

>>> print("Bugün Adana'ya gidiyoruz!")

Bugün Adana'ya gidiyoruz!

“Adana’ya” kelimesinde geçen kesme işareti nedeniyle tek tırnak kullanmıyoruz. Aksi halde Python’un kafası karışacak, tırnakların nerede başlayıp nerede bittiğini anlayamayacaktır.

Bir de şu cümleyi yazdırmayı deneyelim:

"Bugün günlerden Perşembe," dedi Bihter Hanım

Tahmin ettiğiniz gibi, cümle içinde çift tırnaklar olduğu için, bu cümleyi en kolay şu şekilde yazdırırız:

>>> print('"Bugün günlerden Perşembe," dedi Bihter Hanım')

Bugün günlerden Perşembe," dedi Bihter Hanım

Burada başta ve sonda tek tırnak işaretlerini kullanıyoruz...

Peki ya şu cümle nasıl yazdırılır?

Ahmet, "Bugün Adana'ya gidiyoruz," dedi.

Burada hem tek tırnak hem de çift tırnak var. Acaba bu sorunu nasıl aşacağız?

Bu sorunu en kolay, üç tırnak işaretlerini kullanarak çözebiliriz:

>>> print("""Ahmet, "Bugün Adana'ya gidiyoruz," dedi.""")

Gördüğünüz gibi sorun kolayca çözüldü. Peki ya biz burada üç tırnak işaretini kullanmak istemezsek ne olacak? Diyelim ki biz bu cümleyi mutlaka çift tırnak kullanarak yazdırmak istiyoruz. O zaman ne yapacağız?

Burada, Python’un özel işaretleri devreye girecek. Bu özel işaretlere programlama dilinde “kaçış dizisi” (escape sequence) adı verilir. Mesela “\” işareti bunlardan biridir ve bizim yukarıdaki gibi bir problemden “kaçmamızı” sağlar. Hemen görelim nasıl kullanıldığını bu işaretin:

>>> print("Ahmet, \"Bugün Adana'ya gidiyoruz,\" dedi.")

“\” adlı kaçış dizisini nasıl kullandığımızı görüyorsunuz. Başlangıç ve bitiş tırnakları dışında kalan bütün çift tırnak işaretlerinin önüne “\” adlı kaçış dizisini getiriyoruz.

Eğer yukarıdaki cümleyi çift tırnak yerine mutlaka tek tırnak kullanarak yazdırmak istiyor olsaydık, şöyle yapacaktık:

>>> print('Ahmet, "Bugün Adana\'ya gidiyoruz," dedi.')

Burada da, kaçmamız gereken bir adet kesme işareti var. Cümlemize tek tırnakla başladığımız için cümle içinde geçen çift tırnakların zararı olmayacak. Ama “Adana’ya” kelimesindeki kesme işareti bize sorun çıkaracak. Bu işaretin sorun yaratmaması için “\” adlı kaçış dizisini kullanarak sorundan “kaçıyoruz”...

Python’da “\” karakterinden başka pek çok kaçış dizisi vardır. Bunları ilerleyen derslerde tek tek inceleyeceğiz.

Karakter dizileri üzerinde yeterince çalıştık sayılır. İsterseniz biraz da “sayılar”la ilgili örnekler yapalım...

Önceki derslerden hatırladığımız gibi, karakter dizileriyle sayılar arasında iki temel fark bulunuyordu:

1. Karakter dizileri tırnak içinde gösterilir, sayılar tırnaksız...
2. Sayılar, adlarından anlaşılacağı gibi sayı değerli öğelerdir. Karakter dizileri ise sayı değerli olabilecekleri gibi, olmayabilirler de...

Önceki bilgilerimize dayanarak şu örnekleri verebiliriz. Mesela aşağıdaki ifade bir sayıdır:

13

Ama şu ifade bir sayı değildir:

"13"

Ancak şöyle bir yanılgıya düşmeyelim. Sayı olup olmama özelliği yalnızca tırnak işaretleriyle ilgili bir durum değildir. Örneğin aşağıdaki karakter dizisinin tırnaklarını kesip aldığımızda bir sayı elde etmeyiz:

"elma"

Yani:

elma

gibi bir kullanım hata verecektir. Çünkü bir ifadenin sayı olabilmesi için, tırnak işareti taşımamasının yanısıra, sayı değerli olması da gerekir...

İsterseniz sayıları (ve karakter dizilerini) kullanarak şöyle bir örnek yapalım:

#!/usr/bin/env python3.0

km = 10
m = 50000

print(m, "metre", m/1000, "kilometreye eşittir.")
print(km, "kilometre", km*1000, "metreye eşittir.")

Bu program şöyle bir çıktı verecektir:

50000 metre 50.0 kilometreye eşittir.
10 kilometre 10000 metreye eşittir.

Eğer “km” ve “m” değişkenlerinin değeri sayı değil de karakter dizisi olsaydı, “m/1000” veya “km*1000” işlemlerini yapamazdık.

Bu arada, buradaki çıktıda “50.0” gibi ondalık değer taşıyan bir sayı elde ettiğimize dikkat edin. Eğer ondalık sayı yerine tamsayı elde etmek isterseniz, bölme işlemini şu şekilde yapabilirsiniz:

m//1000

Önceki derslerimizde “//” işlecinden söz etmiştik. Bu işleç yukarıdaki gibi durumlarda oldukça faydalı bir araçtır.

Böylelikle bir konuyu daha bitirmiş olduk. Bu derste, şimdiye kadar öğrendiğimiz konularla ilgili pek çok örnek yaptık. Burada anlatılanları daha iyi kavrayabilmek için kendi kendinize alıştırmalar yapmanızı tavsiye ederim.

1.11. Kullanıcıyla İletişim: input() fonksiyonu

Python’da artık bazı şeyleri yapabiliyoruz. Ama şimdiye kadar yaptıklarımız, kendimiz çalıp kendimiz oynamaktan pek farklı değil... Artık bir yolunu bulup kullanıcıyla iletişime geçebilmemiz lazım. Aksi halde tek yönlü bir programlama deneyiminin çok sıkıcı olacağı bariz...

Bu bölümde kullanıcıyla etkileşeceğiz. Yani ondan bir takım veriler alıp programımız içinde bu verileri işleyeceğiz. Her zamanki gibi, lafı hiç uzatmadan konunun özüne dalalım...

Python’da kullanıcıyla veri alış-verişi yapabilmek için input() adlı bir fonksiyondan yararlanacağız.

Hemen bir örnek yapalım.

Boş bir metin belgesi açıp içine şunları yazıyoruz:

#!/usr/bin/env python3.0

print("Merhaba, ben Python. Monty Python")
input("Senin adın nedir? ")

Bu programı çalıştırdığımız zaman, ekrana şöyle bir çıktı verilecektir:

Merhaba, ben Python. Monty Python
Senin adın nedir?

Burada Python kullanıcıya adını sordu ve cevap bekliyor. Kullanıcı kendi adını yazıp “enter” tuşuna bastığında programımız kapanacaktır. Tabii ki program bu haliyle bizi tatmin etmekten çok uzak. En azından, kullanıcının adını öğrenip ona kendi adıyla hitap edebilsek çok iyi olur... Şu kodlar bu dileğimizi yerine getirecektir:

#!/usr/bin/env python3.0

print("Merhaba, ben Python. Monty Python")
isim = input("Senin adın nedir? ")
print("Merhaba", isim)

Bu programı çalıştırdığımızda, kullanıcıya kendi adıyla hitap edebildiğimizi görüyoruz. Bunu yapabilmek için, öncelikle input() fonksiyonunun kendisini bir değişken içinde depoladık. Kullanıcı ekrana ismini yazdığında input() fonksiyonu bu bilgiyi alıp “isim” adlı değişken içinde saklayacaktır. Böylece bu veriyi daha sonra tekrar kullanabileceğiz. Hemen bir sonraki satırda da bu veriyi kullandığımıza dikkat edin. Daha önceki derslerde öğrendiğimiz bilgilerden pek farklı değil. Bu kodlardaki tek yenilik, araya bir input() fonksiyonunun yerleştirilmiş olması. Gördüğünüz gibi, input() fonksiyonunun kullanımı print() fonksiyonunun kullanımına biraz benziyor.

İsterseniz kullanıcıyla biraz sohbet edelim, ne dersiniz?

#!/usr/bin/env python3.0

print("Merhaba, ben Python. Monty Python")
isim = input("Senin adın nedir? ")
print("Merhaba", isim)
yaş = input("Peki yaşın kaç diye sorsam?")
print("Hmmm... Yaşıt değiliz seninle!")

...bu böyle gider...

Benzer bir örnek daha yaparak konuyu pekiştirelim:

#!/usr/bin/env python3.0

kare = input("Bir sayı gir, ben sana o sayının karesini söyleyeyim:")
print(kare, "sayısının karesi: ", kare**2)

Ne oldu? Python hata verdi, değil mi? Gayet normal. Çünkü input() fonksiyonu çıktı olarak bir karakter dizisi verir. Hatırlarsanız önceki bölümlerde şöyle bir şey demiştik:

“tırnak işareti taşımayan “13” bir sayıdır, ama tırnak işareti taşıyan “13” bir sayı değildir...”

İşte bu input() fonksiyonu kullanılarak elde edilen değer de bir sayı değildir. Dolayısıyla kullanıcı ekrana bir sayı giriyormuş gibi görünse de aslında input() fonksiyonunun çıktı türü bir karakter dizisidir... Biz görmesek de, input() fonksiyonu ekrana yazılan ifadeleri tırnak içine alır... Bu bilgi önemlidir. Bunu aklımızda tutmaya çalışalım. Zira daha önce de dediğimiz gibi, aritmetik işlemleri ancak sayılar arasında yapılabilir. Karakter dizileri ile aritmetik işlemi yapılamaz.

Peki ne yapacağız? Böyle elimiz kolumuz bağlı oturacak mıyız? Elbette hayır! Yapacağımız işlem çok basit. input() ile elde edilen çıktıyı sayıya dönüştüreceğiz. Bu noktada biraz Python’daki sayı tiplerinden bahsetmekte fayda var:

Python’da temel olarak iki farklı sayı tipi vardır:

1. Tamsayılar (Integers)
2. Ondalık Sayılar (Floats)

Tamsayılar, ondalık bir kısım içermeyen sayılardır. Mesela “5”, “20”, “17” gibi sayılara tamsayı adı verilir.

Ondalık sayılar ise, içinde ondalık bir kısım barındıran sayılardır. Mesela, “12.7”, “5.4”, “56.8”, “0.5” gibi sayılar ondalık sayılardır.

Bunların dışında Python’da bir de karmaşık sayılar (complex numbers) vardır. Karmaşık sayılar; bir gerçek ve bir sanal kısımdan oluşan sayılardır. Python’da karmaşık sayılar şu şekilde gösterilir: (9+3j), (1+2j), gibi...

Eğer matematikle çok içli dışlı değilseniz karmaşık sayılar pek işinize yaramayacaktır...

Birkaç küçük örnek ile yolumuza devam edelim. Aşağıdaki küçük örnekleri, uzun uzun metin dosyalarına yazmak yerine Python’un etkileşimli kabuğunu kullanarak yapalım. Zira etkileşimli kabuk bu tür ufak kod denemeleri için birebirdir:

>>> a = 56

Bu sayı bir “tamsayı”dır. İngilizce olarak ifade etmek gerekirse, “integer”... Bunun bir tamsayı olduğunu şu şekilde teyit edebiliriz:

>>> type(a)

<class 'int'>

Burada aldığımız “class int” çıktısı, bize “a” değişkeninin tuttuğu sayının bir “tamsayı” olduğunu söylüyor. “int” ifadesi, “integer” (tamsayı) kelimesinin kısaltmasıdır.

Bir de şu sayıya bakalım:

>>> b = 34.5
>>> type(b)

<class 'float'>

Bu çıktı ise bize “34.5” sayısının bir ondalık sayı olduğunu söylüyor. “float” kelimesi “Floats” veya “Floating Point Number” ifadesinin kısaltmasıdır. Yani “ondalık sayı” demektir...

Bu arada, yeni öğrendiğimiz bu type() adlı fonksiyonu sadece sayılara değil, başka şeylere de uygulayabiliriz. Mesela bir örnek vermek gerekirse:

>>> meyve = "karpuz"
>>> type(meyve)

<class 'str'>

Gördüğünüz gibi, type() fonksiyonu bize meyve adlı değişkenin değerinin bir “str” yani “string” yani “karakter dizisi” olduğunu bildirdi...

Şimdi de etkileşimli kabuktan çıkıp aşağıdaki gibi bir program yazalım:

#!/usr/bin/env python3.0

kare = input("Bir sayı giriniz lütfen:")
print(kare)
print("Girdiğiniz verinin tipi şudur:")
print(type(kare))

Burada, kullanıcıdan bir sayı girmesini istedik. Kullanıcı bir veri girip enter tuşuna bastığında, önce kullanıcının girdiği verinin kendisi ekrana yazdırılacak, ardından da bu verinin tipi ekrana çıktı olarak verilecektir.

Yukarıdaki programdan aldığımız çıktının gösterdiği gibi, input() fonksiyonu ile alınan verinin tipi “str”, yani karakter dizisidir. Bizim yapmamız gereken şey, kullanıcıdan aldığımız bu karakter dizisini sayıya dönüştürmek olacaktır. Peki bu dönüştürme işlemi nasıl olacak? Hemen bakalım:

Diyelim ki elimizde şöyle bir sayı var (Bu arada, artık aşağıdaki kod parçalarını denemek için etkileşimli kabuğu kullanmanın daha pratik olduğunu söylememe gerek yok...):

>>> a = 45

“sayı” adlı değişkenin tuttuğu verinin değeri bir “tamsayı”dır. İsterseniz bunu type() fonksiyonunu kullanarak teyit edebileceğinizi biliyorsunuz... Biz bu tamsayıyı ondalık sayıya dönüştürmek istiyoruz. Yapacağımız işlem çok basit:

>>> float(a)

45.0

Gördüğünüz gibi, “45” adlı tamsayıyı, “45.0” adlı bir ondalık sayıya dönüştürdük. Şimdi type(45.0) komutu bize “<class ‘float’>” çıktısını verecektir... Eğer ondalık bir sayıyı tamsayıya çevirmek istersek şu komutu veriyoruz. Mesela ondalık sayımız, “56.5” olsun:

>>> int(56.5)

56

Yukarıdaki örneği tabii ki şöyle de yazabiliriz:

>>> a = 56.5
>>> type(a)

56

Bu arada tekrar bir hatırlatma yapalım. Yukarıdaki ufak kod parçalarını etkileşimli kabukta çalıştırdığımız için print() fonksiyonunu kullanmamıza gerek kalmadan ekrana çıktı alabiliyoruz. Daha önce de dediğimiz gibi, bu durum etkileşimli kabuğun bir özelliğidir. Yukarıdaki kodları şu şekilde bir metin dosyasına yazarsak çıktı almamız mümkün olmaz:

#!/usr/bin/env python3.0

sayı = 56.5
type(sayı)

Bu programı çalıştırdığımızda ekranda hiçbir çıktı görünmeyecektir. Bu programın çalışması için print() fonksiyonunu kullanmamız lazım:

#!/usr/bin/env python3.0

sayı = 56.5
print(type(sayı))

Dönüştürme işlemini sayılar arasında yapabileceğimiz gibi, sayılar ve karakter dizileri arasında da yapabiliriz. Örneğin şu bir karakter dizisidir:

>>> nesne = "45"

Yukarıdaki değeri tırnak içinde belirttiğimiz için bu değer bir karakter dizisidir. Şimdi bunu bir tamsayıya çevireceğiz:

>>> int(nesne)

45

Dilersek, aynı karakter dizisini ondalık sayıya da çevirebiliriz:

>>> float(nesne)

45.0

Hatta bir sayıyı karakter dizisine de çevirebiliriz. Bunun için “string” (karakter dizisi) kelimesinin kısaltması olan “str” parçacığını kullanacağız:

>>> s = 6547
>>> str(s)

'6547'

Bir örnek de ondalık sayılarla yapalım:

>>> s = 65.7
>>> str(s)

'65.7'

Yalnız şunu unutmayın: Bir karakter dizisinin sayıya dönüştürülebilmesi için o karakter dizisinin sayı değerli olması lazım. Yani “45” değerini sayıya dönüştürebiliriz. Çünkü “45” değeri, tırnaklardan ötürü bir karakter dizisi de olsa, neticede sayı değerli bir karakter dizisidir. Ama mesela “elma” karakter dizisi böyle değildir. Dolayısıyla, şöyle bir maceraya girişmek bizi hüsrana uğratacaktır:

>>> nesne = "elma"
>>> int(nesne)

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'elma'

Gördüğünüz gibi, Python bu numarayı yutmadı!...

Neyse, olmayacak duaya amin demeyi bırakıp yolumuza devam edelim...

Gelin şimdi daha büyük bir işlem yapalım. Kullanıcıdan aldığımız veriyi tamsayıya çevirelim... Aşağıdaki kodları bir metin dosyasına yazıyoruz:

#!/usr/bin/env python3.0

kare = int(input("Bir sayı giriniz lütfen:"))
print(kare)

print("Girdiğiniz verinin tipi şudur:")
print(type(kare))

Gördüğünüz gibi, “type(kare)” fonksiyonu bu defa “class ‘int’” çıktısı verdi. Yukarıdaki kodlar kafanızı karıştırmasın. İstersek bu kodları şöyle de yazabiliriz:

#!/usr/bin/env python3.0

kare = input("Bir sayı giriniz lütfen:")
sayı = int(kare)

print(sayı)

print("Girdiğiniz verinin tipi şudur:")
print(type(sayı))

Bu örnekten anlıyoruz ki, kullanıcıdan gelecek veriyi daha almadan sayıya dönüştürebileceğimiz gibi, önce kullanıcıdan veriyi alıp daha sonra bunu sayıya da dönüştürebiliyoruz...

Kullanıcıdan aldığımız veriyi nasıl sayıya dönüştüreceğimizi öğrendiğimize göre artık en başa dönebiliriz... En yukarıda yazdığımız ve hata verdiğini gördüğümüz kodları tekrar ele alalım:

#!/usr/bin/env python3.0

kare = input("Bir sayı gir, ben sana o sayının karesini söyleyeyim:")
print(kare, "sayısının karesi: ", kare**2)

Bu kodları bu şekilde çalıştırırsak hata vereceğini biliyoruz artık. O yüzden yukarıdaki kodlarda şu değişikliği yapıyoruz:

#!/usr/bin/env python3.0

kare = int(input("Bir sayı gir, ben sana o sayının karesini söyleyeyim:"))
print(kare, "sayısının karesi: ", kare**2)

Böylece, Python kullanıcıdan aldığımız veriyi başarıyla sayıya dönüştürüp, bu veri üzerinde aritmetik bir işlem yapabildi. Yalnız, tabii ki kullanıcının yanlışlıkla sayı değerli bir veri yerine sayı değerli olmayan bir veri girmesi durumunda programımız yine yere çakılacaktır... Yani mesela kullanıcı “12” yazmak isterken yanlışlıkla veya bilerek bir harf girerse programımız beklediğimiz çıktıyı vermeyecektir... Henüz bu tür durumlara karşı önlem almayı bilmiyoruz. Ama zamanı geldiğinde beklenmedik durumlara karşı önlem almayı da öğreneceğiz... Şimdilik kullanıcılarımızın istediğimiz ve beklediğimiz verileri uslu uslu girmesi için dua ediyoruz...

Böylece bu konunun da sonuna geldik... Şimdi isterseniz bu bölümde öğrendiklerimizi şöyle kısaca bir özetleyelim.

Özet

Bu bölümde pek çok yeni şey öğrendik. Bu bölümün en önemli getirisi input() fonksiyonunu öğrenmemiz oldu. Bu fonksiyon sayesinde kullanıcıyla iletişim kurmayı başardık. Artık kullanıcıdan veri alıp, bu verileri programlarımız içinde işleyebiliyoruz. Yine bu bölümde dikkatinizi çektiğimiz başka bir konu da sayılar ve karakter dizileri arasındaki ilişkiydi. input() fonksiyonuyla elde edilen çıktının bir karakter dizisi olduğunu öğrendik. Bildiğimiz gibi, aritmetik işlemleri ancak sayılar arasında yapılabilir. Dolayısıyla input() fonksiyonuyla gelen karakter dizisini bir sayıyla çarpmaya kalkarsak hata alıyoruz. Burada yapmamız gereken şey, elimizdeki verileri dönüştürmek. Yani input() fonksiyonundan gelen karakter dizisini bir sayıyla çarpmak istiyorsak, öncelikle aldığımız karakter dizisini sayıya dönüştürmemiz gerekiyor. Dönüştürme işlemleri için kullandığımız fonksiyonlar şunlardı:

int()

Sayı değerli bir karakter dizisini veya ondalık sayıyı tamsayıya (integer) çevirir.

float()

Sayı değerli bir karakter dizisini veya tamsayıyı ondalık sayıya (float) çevirir.

str()

Bir tamsayı veya ondalık sayıyı karakter dizisine (string) çevirir.

Ayrıca bu bölümde şöyle önemli bir tespitte de bulunduk:

Her tamsayı ve/veya ondalık sayı bir karakter dizisine dönüştürülebilir. Ama her karakter dizisi tamsayıya ve/veya ondalık sayıya dönüştürülemez...

Örneğin, 5654 gibi bir tamsayıyı veya 543.34 gibi bir ondalık sayıyı str() fonksiyonu yardımıyla karakter dizisine dönüştürebiliriz:

>>> str(5654)
>>> str(543.34)

“5654” veya “543.34” gibi bir karakter dizisini int() veya float() fonksiyonu yardımıyla tamsayıya ya da ondalık sayıya da dönüştürebiliriz:

>>> int("5654")
>>> int("543.34")

>>> float("5654")
>>> float("543.34")

Ama “elma” gibi bir karakter dizisini ne int() ne de float() fonksiyonuyla tamsayıya veya ondalık sayıya dönüştürebiliriz!

Bu bilgileri, önemlerinden ötürü aklımızda tutmaya çalışalım. Buraya kadar anlatılan konular hakkında zihnimizde belirsizlikler varsa veya bazı noktaları tam olarak kavrayamadıysak, şimdiye kadar öğrendiğimiz konuları tekrar gözden geçirmemiz bizim için epey faydalı olacaktır. Zira bundan sonraki bölümlerde, yeni bilgilerin yanısıra, buraya kadar öğrendiğimiz şeyleri de yoğun bir şekilde pratiğe dökeceğiz. Bundan sonraki konuları takip edebilmemiz açısından, buraya kadar verdiğimiz temel bilgileri iyice sindirmiş olmak işimizi bir hayli kolaylaştıracaktır.

Önemli bir konuyu daha geride bıraktığımıza göre artık yeni bir bölüme geçebiliriz...