Python’da karakter dizilerini tanımlayabilmek için tek, çift veya üç tırnak işaretlerinden faydalandığımızı geçen bölümde öğrenmiştik. Python bir verinin karakter dizisi olup olmadığına bu tırnak işaretlerine bakarak karar verdiği için, tek, çift ve üç tırnak işaretleri Python açısından özel bir önem taşıyor. Zira Python’ın gözünde bir başlangıç tırnağı ile bitiş tırnağı arasında yer alan her şey bir karakter dizisidir.
Örneğin ilk olarak bir “ işareti koyup ardından “elma şeklinde devam ettiğinizde, Python ilk tırnağı gördükten sonra karakter dizisini tanımlayabilmek için ikinci bir tırnak işareti aramaya başlar. Siz “elma” şeklinde kodunuzu tamamladığınızda ise Python bellekte “elma” adlı bir karakter dizisi oluşturur.
Bu noktada size şöyle bir soru sormama izin verin: Acaba tırnak işaretleri herhangi bir metin içinde kaç farklı amaçla kullanılabilir?
İsterseniz bu sorunun cevabını örnekler üzerinde vermeye çalışalım:
Alıntı:Ahmet, “Bugün sinemaya gidiyorum,” dedi.
Burada tırnak işaretlerini, bir başkasının sözlerini aktarmak için kullandık.
Alıntı:‘book’ kelimesi Türkçede ‘kitap’ anlamına gelir.
Burada ise tırnak işaretlerini bazı kelimeleri vurgulamak için kullandık.
Bir de şuna bakalım:
Alıntı:Yarın Adana’ya gidiyorum.
Burada da tırnak işaretini, çekim eki olan ‘-(y)a’ ile özel isim olan ‘Adana’ kelimesini birbirinden ayırmak için kesme işareti görevinde kullandık.
Şimdi yukarıda verdiğimiz ilk cümleyi bir karakter dizisi olarak tanımlamaya çalışalım:
>>> 'Ahmet, "Bugün sinemaya gidiyorum," dedi.'
Burada karakter dizisini tanımlamaya tek tırnak işareti ile başladık. Böylece Python bu karakter dizisini tanımlama işlemini bitirebilmek için ikinci bir tek tırnak işareti daha aramaya koyuldu ve aradığı tek tırnak işaretini cümlenin sonunda bularak, karakter dizisini düzgün bir şekilde oluşturabildi.
Dediğimiz gibi, Python’ın gözünde tırnak işaretleri bir karakter dizisini başka veri tiplerinden ayırt etmeye yarayan bir ölçüttür. Ama biz insanlar, yukarıda verdiğimiz örnek cümlelerden de göreceğiniz gibi, programlama dillerinden farklı olarak, tırnak işaretlerini bir metin içinde daha farklı amaçlar için de kullanabiliyoruz.
Şimdi yukarıdaki karakter dizisini şöyle tanımlamaya çalıştığımızı düşünün:
>>> "Ahmet, "Bugün sinemaya gidiyorum," dedi."
İşte burada Python’ın çıkarları ile bizim çıkarlarımız birbiriyle çatıştı. Python karakter dizisini başlatan ilk çift tırnak işaretini gördükten sonra, karakter dizisini tanımlama işlemini bitirebilmek için ikinci bir tırnak işareti daha aramaya koyuldu. Bu arayış sırasında da ‘Bugün’ kelimesinin başındaki çift tırnak işaretini gördü ve karakter dizisinin şu olduğunu zannetti:
>>> "Ahmet, "
Buraya kadar bir sorun yok. Bu karakter dizisi Python’ın sözdizimi kurallarına uygun.
Karakter dizisi bu şekilde tanımlandıktan sonra Python cümlenin geri kalanını okumaya devam ediyor ve herhangi bir tırnak işareti ile başlamayan ve kendisinden önce gelen öğeden herhangi bir virgül işareti ile ayrılmamış ‘Bugün’ kelimesini görüyor. Eğer bir kelime tırnak işareti ile başlamıyorsa bu kelime ya bir değişkendir ya da sayıdır. Ama ‘Bugün’ kelimesi ne bir değişken, ne de bir sayı olduğu, üstelik önceki öğeden de virgülle ayrılmadığı için Python’ın hata vermekten başka çaresi kalmıyor. Çünkü biz burada ‘Bugün’ kelimesinin baş tarafındaki çift tırnak işaretini karakter dizisi tanımlamak için değil, başkasının sözlerini aktarmak amacıyla kullandık. Ancak elbette bir programlama dili bizim amacımızın ne olduğunu kestiremez ve hata mesajını suratımıza yapıştırır:
File "<stdin>", line 1
"Ahmet, "Bugün sinemaya gidiyorum," dedi."
^
SyntaxError: invalid syntax
Peki biz böyle bir durumda ne yapmalıyız?
Bu hatayı engellemek için karakter dizisini tanımlamaya çift tırnak yerine tek tırnakla ya da üç tırnakla başlayabiliriz:
>>> 'Ahmet, "Bugün sinemaya gidiyorum," dedi.'
Böylece karakter dizisini başlatan işaret ‘Bugün sinemaya gidiyorum,’ cümlesinin başındaki ve sonundaki işaretlerden farklı olduğu için, Python okuma esnasında bu cümleye takılmaz ve doğru bir şekilde, karakter dizisini kapatan tırnak işaretini bulabilir.
Bu yöntem tamamen geçerli ve mantıklıdır. Ama eğer istersek, aynı karakter dizisini çift tırnakla tanımlayıp, yine de hata almayı engelleyebiliriz. Peki ama nasıl?
İşte burada ‘kaçış dizileri’ adı verilen birtakım araçlardan faydalanacağız.
Peki nedir bu ‘kaçış dizisi’ denen şey?
Kaçış dizileri, Python’da özel anlam taşıyan işaret veya karakterleri, sahip oldukları bu özel anlam dışında bir amaçla kullanmamızı sağlayan birtakım araçlardır. Mesela yukarıda da örneklerini verdiğimiz gibi, tırnak işaretleri Python açısından özel anlam taşıyan işaretlerdir. Normalde Python bu işaretleri karakter dizilerini tanımlamak için kullanır. Ama eğer siz mesela bir metin içinde bu tırnak işaretlerini farklı bir amaçla kullanacaksanız Python’ı bu durumdan haberdar etmeniz gerekiyor. İşte kaçış dizileri, Python’ı böyle bir durumdan haberdar etmemize yarayan araçlardır.
Python’da pek çok kaçış dizisi bulunur. Biz burada bu kaçış dizilerini tek tek inceleyeceğiz. O halde hemen işe koyulalım.
Ters Taksim (\)
Yukarıda verdiğimiz örneklerde, çift tırnakla gösterdiğimiz karakter dizilerinin içinde de çift tırnak işareti kullanabilmek için birkaç farklı yöntemden yararlanabildiğimizi öğrenmiştik. Buna göre, eğer bir karakter dizisi içinde çift tırnak işareti geçiyorsa, o karakter dizisini tek tırnakla; eğer tek tırnak geçiyorsa da o karakter dizisini çift tırnakla tanımlayarak bu sorunun üstesinden gelebiliyorduk. Ama daha önce de söylediğimiz gibi, ‘kaçış dizileri’ adı verilen birtakım araçları kullanarak, mesela içinde çift tırnak geçen karakter dizilerini yine çift tırnakla tanımlayabiliriz.
Dilerseniz, kaçış dizisi kavramını açıklamaya geçmeden önce bununla ilgili birkaç örnek verelim. Bu sayede ne ile karşı karşıya olduğumuz, zihnimizde biraz daha belirginleşebilir:
>>> print('Yarın Adana\'ya gidiyorum.')
Yarın Adana'ya gidiyorum.
Bir örnek daha verelim:
>>> print("\"book\" kelimesi Türkçede \"kitap\" anlamına gelir.")
"book" kelimesi Türkçede "kitap" anlamına gelir.
Burada da cümle içinde çift tırnak işaretlerini kullandığımız halde, \ işaretleri sayesinde karakter dizilerini yine çift tırnakla tanımlayabildik.
Bir de şu örneğe bakalım:
>>> print("Python programlama dilinin adı \"piton\" yılanından gelmez")
Bütün bu örneklerde, karakter dizisini hem çift tırnakla tanımlayıp hem de karakter dizisi içinde çift tırnak işaretlerini kullandığımız halde, herhangi bir hata almadığımızı görüyorsunuz. Yukarıdaki kodlarda hata almamızı önleyen şeyin \ işareti olduğu belli. Ama dilerseniz bu işaretin, hata almamızı nasıl önlediğini anlatmadan önce son bir örnek daha verelim.
Hatırlarsanız önceki sayfalarda şöyle bir karakter dizisi ile karşılaşmıştık:
>>> print('İstanbul'un 5 günlük hava durumu tahmini')
File "<stdin>", line 1
print('İstanbul'un 5 günlük hava durumu tahmini')
^
SyntaxError: invalid syntax
Burada da ‘İstanbul’un’ kelimesi içinde geçen tırnak işareti nedeniyle karakter dizisini tek tırnak kullanarak tanımlayamıyorduk. Bu karakter dizisini hatasız bir şekilde tanımlayabilmek için ya çift tırnak ya da üç tırnak kullanmamız gerekiyordu:
>>> print("İstanbul'un 5 günlük hava durumu tahmini")
İstanbul'un 5 günlük hava durumu tahmini
... veya:
>>> print("""İstanbul'un 5 günlük hava durumu tahmini""")
İstanbul'un 5 günlük hava durumu tahmini
Tıpkı önceki örneklerde olduğu gibi, yukarıdaki karakter dizisini de aslında tek tırnakla tanımlayıp hata oluşmasını önleyebiliriz. Hemen görelim:
>>> print('İstanbul\'un 5 günlük hava durumu tahmini')
İstanbul'un 5 günlük hava durumu tahmini
Bütün örneklerde \ işaretini kullandığımızı görüyorsunuz. İşte bu tür işaretlere Python’da kaçış dizisi (escape sequence) adı verilir. Bu işaretler karakter dizilerini tanımlarken oluşabilecek hatalardan kaçmamızı sağlar. Peki bu \ işareti nasıl oluyor da karakter dizisini tanımlarken hata almamızı önlüyor? Gelin bu süreci adım adım tarif edelim:
Python bir karakter dizisi tanımladığımızda, karakter dizisini soldan sağa doğru okumaya başlar. Mesela yukarıdaki örnekte ilk olarak karakter dizisini tanımlamaya tek tırnakla başladığımızı görür.
Python karakter dizisini başlatan bu tek tırnak işaretini gördüğü zaman, soldan sağa doğru ilerleyerek karakter dizisini bitirecek olan tek tırnak işaretini aramaya başlar.
Soldan sağa doğru ilerlerken ‘İstanbul’un’ kelimesi içinde geçen kesme işaretini görür ve karakter dizisinin burada sona erdiğini düşünür. Ancak karakter dizisini sona erdiren işaret bu olmadığı için Python’ın hata vermekten başka çaresi kalmaz.
İşte biz ‘İstanbul’un’ kelimesi içinde geçen bu kesme işaretinin sol tarafına bir adet \ işareti yerleştirerek Python’a, ‘Aradığın işaret bu değil. Sen karakter dizisini okumaya devam et. Biraz sonra aradığın tırnağı bulacaksın!’ mesajı vermiş, yani orada tırnak işaretini farklı bir amaçla kullandığımız konusunda Python’ı bilgilendirmiş oluruz.
Şurada da aynı durum sözkonusu:
>>> print("Python programlama dilinin adı \"piton\" yılanından gelmez")
Tıpkı bir önceki örnekte olduğu gibi, burada da Python karakter dizisini soldan sağa doğru okumaya başlıyor, karakter dizisini başlatan çift tırnak işaretini görüyor ve bunun üzerine Python karakter dizisini bitirecek olan çift tırnak işaretini aramaya koyuluyor.
Karakter dizisini soldan sağa doğru okuduğu sırada, karakter dizisi içinde geçen ‘piton’ kelimesini görüyor. Eğer burada bir önlem almazsak Python bu kelimenin başındaki çift tırnak işaretini, karakter dizisini sona erdiren tırnak olarak algılar ve durum aslında böyle olmadığı için de hata verir.
Bu hatayı önlemek için ‘piton’ kelimesinin başındaki çift tırnağın soluna bir adet \ işareti yerleştirerek Python’a, ‘Aradığın tırnak bu değil!’ mesajı veriyoruz. Yani bir bakıma, \ adlı kaçış dizisi kendisini tırnak işaretine siper edip Python’ın bu tırnağı görmesine mani oluyor...
Bunun üzerine Python bu çift tırnak işaretini görmezden gelerek, soldan sağa doğru okumaya devam eder ve yol üzerinde ‘piton’ kelimesinin sonundaki çift tırnak işaretini görür. Eğer burada da bir önlem almazsak Python yine bir hata verecektir.
Tıpkı biraz önce yaptığımız gibi, bu tırnak işaretinin de soluna bir adet \ işareti yerleştirerek Python’a, ‘Aradığın tırnak bu da değil. Sen yine okumaya devam et!’ mesajı veriyoruz.
Bu mesajı alan Python karakter dizisini soldan sağa doğru okumaya devam ediyor ve sonunda karakter dizisini bitiren çift tırnak işaretini bularak bize hatasız bir çıktı veriyor.
Böylece \ işareti üzerinden hem kaçış dizilerinin ne olduğunu öğrenmiş, hem de bu kaçış dizisinin nasıl kullanılacağına dair örnekler vermiş olduk. Ancak \ kaçış dizisinin yetenekleri yukarıdakilerle sınırlı değildir. Bu kaçış dizisini, uzun karakter dizilerini bölmek için de kullanabiliriz. Şimdi şu örneği dikkatlice inceleyin:
>>> print("Python 1990 yılında Guido Van Rossum \
... tarafından geliştirilmeye başlanmış, oldukça \
... güçlü ve yetenekli bir programlama dilidir.")
Python 1990 yılında Guido Van Rossum tarafından geliştirilmeye
başlanmış, oldukça güçlü ve yetenekli bir programlama dilidir.
Normal şartlar altında, bir karakter dizisini tanımlamaya tek veya çift tırnakla başlamışsak, karakter dizisinin kapanış tırnağını koymadan Enter tuşuna bastığımızda Python bize bir hata mesajı gösterir:
>>> print("Python 1990 yılında Guido Van Rossum
File "<stdin>", line 1
print("Python 1990 yılında Guido Van Rossum
^
SyntaxError: EOL while scanning string literal
İşte \ kaçış dizisi bizim burada olası bir hatadan kaçmamızı sağlar. Eğer Enter tuşuna basmadan önce bu işareti kullanırsak Python tıpkı üç tırnak işaretlerinde şahit olduğumuz gibi, hata vermeden bir alt satıra geçecektir. Bu sırada, yani \ kaçış dizisini koyup Enter tuşuna bastığımızda >>> işaretinin ... işaretine dönüştüğünü görüyorsunuz. Bu işaretin, Python’ın bize verdiği bir ‘Yazmaya devam et!’ mesajı olduğunu biliyorsunuz.
Satır Başı (\n)
Python’daki en temel kaçış dizisi biraz önce örneklerini verdiğimiz \ işaretidir. Bu kaçış dizisi başka karakterlerle birleşerek, farklı işlevlere sahip yeni kaçış dizileri de oluşturabilir. Aslında bu olguya yabancı değiliz. Önceki sayfalarda bu duruma bir örnek vermiştik. Hatırlarsanız
Kod:
print()
fonksiyonunu anlatırken end parametresinin ön tanımlı değerinin \n, yani satır başı karakteri olduğunu söylemiştik.
Satır başı karakterine ‘yeni satır karakteri’ dendiği de olur.
Satır başı karakterini ilk öğrendiğimizde bu karakteri anlatırken bazı örnekler de vermiştik:
>>> print("birinci satır\nikinci satır\nüçüncü satır")
birinci satır
ikinci satır
üçüncü satır
Gördüğünüz gibi, \n adlı kaçış dizisi, bir alt satıra geçilmesini sağlıyor. İşte aslında \n kaçış dizisi de, \ ile ‘n’ harfinin birleşmesinden oluşmuş bir kaçış dizisidir. Burada \ işaretinin görevi, ‘n’ harfinin özel bir anlam kazanmasını sağlamaktır. \ işareti ile ‘n’ harfi birleştiğinde ‘satır başı karakteri’ denen özel bir karakter dizisi ortaya çıkarıyor.
Gelin bu kaçış dizisi ile ilgili bir örnek verelim. Şimdi şu kodları dikkatlice inceleyin:
>>> başlık = "Türkiye'de Özgür Yazılımın Geçmişi"
>>> print(başlık, "\n", "-"*len(başlık), sep="")
Türkiye'de Özgür Yazılımın Geçmişi
----------------------------------
Burada, başlık adlı değişkenin tuttuğu “Türkiye’de Özgür Yazılımın Geçmişi” adlı karakter dizisinin altını çizdik. Dikkat ederseniz, başlığın altına koyduğumuz çizgiler başlığın uzunluğunu aşmıyor. Yazdığımız program, başlığın uzunluğu kadar çizgiyi başlığın altına ekliyor. Bu programda başlık ne olursa olsun, programımız çizgi uzunluğunu kendisi ayarlayacaktır. Örneğin:
>>> başlık = "Python Programlama Dili"
>>> print(başlık, "\n", "-"*len(başlık), sep="")
satırını şöyle bir inceleyelim. Kodumuz şu:
>>> print(başlık, "\n", "-"*len(başlık), sep="")
Burada öncelikle başlık adlı değişkeni
Kod:
print()
fonksiyonunun parantezleri içine yazdık. Böylece başlık değişkeninin değeri ekrana yazdırılacak.
Kod:
print()
fonksiyonunun ikinci parametresinin \n adlı kaçış dizisi olduğunu görüyoruz. Bu kaçış dizisini eklememiz sayesinde Python ilk parametreyi çıktı olarak verdikten sonra bir alt satıra geçiyor. Bu parametrenin tam olarak ne işe yaradığını anlamak için, yukarıdaki satırı bir de o parametre olmadan çalıştırmayı deneyebilirsiniz:
>>> print(başlık, "-"*len(başlık), sep="")
Alışveriş Listesi-----------------
Kod:
print()
fonksiyonunun üçüncü parametresinin ise şu olduğunu görüyoruz:
Kod:
"-"*len(başlık)
.
İşte başlık değişkeninin altına gerekli sayıda çizgiyi çizen kodlar bunlardır. Burada
Kod:
len()
fonksiyonunu nasıl kullandığımıza çok dikkat edin. Bu kod sayesinde başlık değişkeninin uzunluğu (
Kod:
len(başlık)
) sayısınca - işaretini ekrana çıktı olarak verebiliyoruz.
Yukarıdaki kodlarda
Kod:
print()
fonksiyonunun son parametresi ise sep=’‘. Peki bu ne işe yarıyor? Her zaman olduğu gibi, bu kod parçasının ne işe yaradığını anlamak için programı bir de o kodlar olmadan çalıştırmayı deneyebilirsiniz:
>>> print(başlık, "\n", "-"*len(başlık))
Alışveriş Listesi
-----------------
Gördüğünüz gibi, başlık değişkeninin tam altına gelmesi gereken çizgi işaretleri sağa kaymış. Bunun nedeni sep parametresinin öntanımlı değerinin bir adet boşluk karakteri olmasıdır. sep parametresinin öntanımlı değeri nedeniyle çizgilerin baş tarafına bir adet boşluk karakteri ekleniyor çıktıda. O yüzden bu çizgiler sağa kaymış görünüyor. İşte biz yukarıdaki kodlarda sep parametresinin öntanımlı değerini değiştirip, boşluk karakteri yerine boş bir karakter dizisi yerleştiriyoruz. Böylece çizgiler çıktıda sağa kaymıyor.
Satır başı karakteri, programlama maceramız sırasında en çok kullanacağımız kaçış dizilerinden biri ve hatta belki de birincisidir. O yüzden bu kaçış dizisini çok iyi öğrenmenizi tavsiye ederim.
Ayrıca bu kaçış dizisini (ve tabii öteki kaçış dizilerini) tanıyıp öğrenmeniz, yazacağınız programların selameti açısından da büyük önem taşır. Eğer bir karakter dizisi içinde geçen kaçış dizilerini ayırt edemezseniz Python size hiç beklemediğiniz çıktılar verebilir. Hatta yazdığınız programlar kaçış dizilerini tanımıyor olmanızdan ötürü bir anda hata verip çökebilir. Peki ama nasıl?
Şimdi şu örneğe dikkatlice bakın:
Diyelim ki bilgisayarınızın ‘C:\’ dizinindeki ‘nisan’ adlı bir klasörün içinde yer alan masraflar.txt adlı bir dosyayı yazdığınız bir program içinde kullanmanız gerekiyor. Mesela bu dosyayı, tam adresiyle birlikte kullanıcılarınıza göstermek istiyorsunuz.
İlk denememizi yapalım:
>>> print("C:\nisan\masraflar.txt")
Buradan şöyle bir çıktı aldık:
C:
isan\masraflar.txt
Gördüğünüz gibi, bu çıktıyı normal yollardan vermeye çalıştığımızda Python bize hiç de beklemediğimiz bir çıktı veriyor. Peki ama neden?
Python’da karakter dizileri ile çalışırken asla aklımızdan çıkarmamamız gereken bir şey var: Eğer yazdığımız herhangi bir karakter dizisinin herhangi bir yerinde \ işaretini kullanmışsak, bu işaretten hemen sonra gelen karakterin ne olduğuna çok dikkat etmemiz gerekir. Çünkü eğer dikkat etmezsek, farkında olmadan Python için özel anlam taşıyan bir karakter dizisi oluşturmuş olabiliriz. Bu da kodlarımızın beklediğimiz gibi çalışmasını engeller.
Yukarıdaki sorunun kaynağını anlamak için
Kod:
"C:\nisan\masraflar.txt"
adlı karakter dizisine çok dikkatlice bakın. Python bu karakter dizisinde bizim ‘\nisan’ olarak belirttiğimiz kısmın başındaki \n karakterlerini bir kaçış dizisi olarak algıladı. Çünkü \n adlı karakter dizisi, ‘satır başı kaçış dizisi’ adını verdiğimiz, Python açısından özel anlam taşıyan bir karakter dizisine işaret ediyor. Zaten yukarıdaki tuhaf görünen çıktıya baktığınızda da, bu kaçış dizisinin olduğu noktadan itibaren karakter dizisinin bölünüp yeni bir satıra geçildiğini göreceksiniz. İşte biz yukarıdaki örnekte alelade bir dizin adı belirttiğimizi zannederken aslında hiç farkında olmadan bir kaçış dizisi üretmiş oluyoruz. Bu nedenle, daha önce de söylediğimiz gibi, karakter dizileri içinde farkında olarak veya olmayarak kullandığımız kaçış dizilerine karşı her zaman uyanık olmalıyız. Aksi takdirde, yukarıda olduğu gibi hiç beklemediğimiz çıktılarla karşılaşabiliriz.
Esasen yukarıdaki problem bir dereceye kadar (ve yerine göre) ‘masum bir kusur’ olarak görülebilir. Çünkü bu hata programımızın çökmesine yol açmıyor. Ama bir karakter dizisi içindeki gizli kaçış dizilerini gözden kaçırmak, bazı durumlarda çok daha yıkıcı sonuçlara yol açabilir. Mesela yukarıdaki sorunlu dizin adını ekrana yazdırmak yerine
Kod:
open()
fonksiyonunu kullanarak, bu karakter dizisi içinde belirttiğimiz masraflar.txt adlı dosyayı açmaya çalıştığımızı düşünün:
>>> open("C:\nisan\masraflar.txt")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
OSError: [Errno 22] Invalid argument: 'C:\nisan\\masraflar.txt'
Eğer sorunun gözden kaçan bir kaçış dizisinden kaynaklandığını farkedemezseniz, bu sorunu çözebilmek için saatlerinizi ve hatta günlerinizi harcamak zorunda kalabilirsiniz. Çünkü yukarıdaki hata mesajı sorunun nedenine dair hiçbir şey söylemiyor. Ancak ve ancak yukarıdaki karakter dizisi içinde sinsice gizlenen bir \n kaçış dizisi olduğu gözünüze çarparsa bu sorunu çözme yolunda bir adım atabilirsiniz.
Diyelim ki sorunun ‘\nisan’ ifadesinin başındaki \n karakterlerinin Python tarafından bir kaçış dizisi olarak algılanmasından kaynaklandığını farkettiniz. Peki bu sorunu nasıl çözeceksiniz?
Bu sorunun birkaç farklı çözüm yolu var. Biz şimdilik sadece ikisini göreceğiz. Bu bölümün sonuna vardığınızda öteki çözüm yolunu da öğrenmiş olacaksınız.
Yukarıdaki problemi, ilgili kaçış dizisi içindeki ters taksim işaretini çiftleyerek çözebilirsiniz:
>>> open("C:\\nisan\masraflar")
Tabii tutarlılık açısından karakter dizisi içindeki bütün ters taksim işaretlerini çiftlemek mantıklı olacaktır:
>>> open("C:\\nisan\\masraflar")
Bunun dışında, bu örnek için, dizin adlarını ters taksim yerine düz taksim işaretiyle ayırmayı tercih edebilirsiniz:
>>> open("C:/nisan/masraflar")
Dediğimiz gibi, üçüncü (ve aslında daha kullanışlı olan) yöntemi biraz sonra inceleyeceğiz. Biz şimdilik kaçış dizilerini anlatmaya devam edelim.
Sekme (\t)
Python’da \ işareti sadece ‘n’ harfiyle değil, başka harflerle de birleşebilir. Örneğin \ işaretini ‘t’ harfiyle birleştirerek yine özel bir anlam ifade eden bir kaçış dizisi elde edebiliriz:
>>> print("abc\tdef")
abc def
Burada \t adlı kaçış dizisi, “abc” ifadesinden sonra sanki Tab (sekme) tuşuna basılmış gibi bir etki oluşturarak “def” ifadesini sağa doğru itiyor. Bir de şu örneğe bakalım:
>>> print("bir", "iki", "üç", sep="\t")
bir iki üç
Bir örnek daha:
>>> print(*"123456789", sep="\t")
1 2 3 4 5 6 7 8 9
Gördüğünüz gibi, parametreler arasında belli aralıkta bir boşluk bırakmak istediğimizde \t adlı kaçış dizisinden yararlanabiliyoruz.
Tıpkı \n kaçış dizisinde olduğu gibi, karakter dizilerinde \t kaçış dizisinin varlığına karşı da uyanık olmalıyız:
>>> open("C:\nisan\masraflar\toplam_masraf.txt")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
OSError: [Errno 22] Invalid argument: 'C:\nisan\\masraflar\toplam_masraf.txt'
Burada da \n ile yaşadığımız soruna benzer bir durum var. Biz toplam_masraf.txt adlı bir dosyaya atıfta bulunmaya çalışıyoruz, ama Python bu ifadenin başındaki ‘t’ harfinin, kendisinden önce gelen \ işareti ile birleşmesinden ötürü, bunu \t kaçış dizisi olarak algılıyor ve ona göre davranıyor.
Belki yukarıdaki kodları şöyle yazarsak durumu anlamak daha kolay olabilir:
>>> print("C:\nisan\masraflar\toplam_masraf.txt")
C:
isan\masraflar oplam_masraf.txt
Gördüğünüz gibi, Python \n kaçış dizisini gördüğü noktada alt satırın başına geçiyor ve \t kaçış dizisini gördüğü noktada da önceki ve sonraki öğeler arasında bir sekme boşluğu bırakıyor. Bu durumu engellemek için ne yapmanız gerektiğini biliyorsunuz: Ya ters taksim işaretlerini çiftleyeceksiniz:
>>> print("C:\\nisan\\masraflar\\toplam_masraf.txt")
Ya da dizin adı ayracı olarak düz taksim işaretini kullanacaksınız:
>>> print("C:/nisan/masraflar/toplam_masraf.txt")
Daha önce de söylediğimiz gibi, üçüncü ve daha pratik olan yolu biraz sonra göreceğiz. Şimdilik sadece biraz sabır...
Zil Sesi (\a)
\ işaretinin birleştiğinde farklı bir anlam türettiği bir başka harf de ‘a’ harfidir. \ işareti ‘a’ harfiyle birleşerek !bip! benzeri bir zil sesi üretilmesini sağlayabilir:
>>> print("\a")
!bip!
İsterseniz yukarıdaki komutu şu şekilde yazarak, kafa şişirme katsayısını artırabilirsiniz:
>>> print("\a" * 10)
Bu şekilde !bip! sesi 10 kez tekrar edilecektir. Ancak bu kaçış dizisi çoğunlukla sadece Windows üzerinde çalışacaktır. Bu kaçış dizisinin GNU/Linux üzerinde çalışma garantisi yoktur. Hatta bu kaçış dizisi bütün Windows sistemlerinde dahi çalışmayabilir. Dolayısıyla bu kaçış dizisinin işlevine bel bağlamak pek mantıklı bir iş değildir.
Tıpkı \n ve \t kaçış dizilerinde olduğu gibi bu kaçış dizisinin varlığına karşı da uyanık olmalıyız. Burada da mesela ‘C:\aylar’ gibi bir dizin adı tanımlamaya çalışırken aslında \a kaçış dizisini oluşturuyor olabilirsiniz farkında olmadan.
Aynı Satır Başı (\r)
Bu kaçış dizisi, bir karakter dizisinde aynı satırın en başına dönülmesini sağlar. Bu kaçış dizisinin işlevini tanımına bakarak anlamak biraz zor olabilir. O yüzden dilerseniz bu kaçış dizisinin ne işe yaradığını bir örnek üzerinde göstermeye çalışalım:
>>> print("Merhaba\rZalim Dünya!")
Zalim Dünya!
Burada olan şey şu: Normal şartlar altında,
Kod:
print()
fonksiyonu içine yazdığımız bir karakter dizisindeki bütün karakterler soldan sağa doğru tek tek ekrana yazdırılır:
>>> print("Merhaba Zalim Dünya!")
Merhaba Zalim Dünya!
Ancak eğer karakter dizisinin herhangi bir yerine \r adlı kaçış dizisini yerleştirirsek, bu kaçış dizisinin bulunduğu konumdan itibaren aynı satırın başına dönülecek ve \r kaçış dizisinden sonra gelen bütün karakterler satır başındaki karakterlerin üzerine yazacaktır. Şu örnek daha açıklayıcı olabilir:
>>> print("Merhaba\rDünya")
Dünyaba
Burada, “Merhaba” karakter dizisi ekrana yazdırıldıktan sonra \r kaçış dizisinin etkisiyle satır başına dönülüyor ve bu kaçış dizisinden sonra gelen “Dünya” karakter dizisi “Merhaba” karakter dizisinin üzerine yazıyor. Tabii “Dünya” karakter dizisi içinde 5 karakter, “Merhaba” karakter dizisi içinde ise 7 karakter olduğu için, “Merhaba” karakter dizisinin son iki karakteri (“ba”) dışarda kalıyor. Böylece ortaya “Dünyaba” gibi bir şey çıkıyor.
Önceki kaçış dizilerinde olduğu gibi, bu kaçış dizisini de farkında olmadan karakter dizisi içinde kullanırsanız beklemediğiniz çıktılar alırsınız:
>>> print("C:\ülke\türkiye\iller\rize\nüfus.txt")
izeülke ürkiye\iller
üfus.txt
Burada farkında olmadan sadece bir değil, üç kaçış dizisi birden oluşturduk!
Düşey Sekme (\v)
Eğer \ işaretini ‘v’ harfiyle birlikte kullanırsak düşey sekme denen şeyi elde ederiz. Hemen bir örnek verelim:
>>> print("düşey\vsekme")
düşey
sekme
Yalnız bu \v adlı kaçış dizisi her işletim sisteminde çalışmayabilir. Dolayısıyla, birden fazla platform üzerinde çalışmak üzere tasarladığınız programlarınızda bu kaçış dizisini kullanmanızı önermem.
İmleç Kaydırma (\b)
\ kaçış dizisinin, biraraya geldiğinde özel bir anlam kazandığı bir başka harf de b’dir. \b kaçış dizisinin görevi, imleci o anki konumundan sola kaydırmaktır. Bu tanım pek anlaşılır değil. O yüzden bir örnek verelim:
>>> print("yahoo.com\b")
Bu kodu çalıştırdığınızda herhangi bir değişiklik görmeyeceksiniz. Ama aslında en sonda gördüğümüz \b kaçış dizisi, imleci bir karakter sola kaydırdı. Dikkatlice bakın:
>>> print("yahoo.com\b.uk")
Gördüğünüz gibi, \b kaçış dizisinin etkisiyle imleç bir karakter sola kaydığı için, ‘com’ kelimesinin son harfi silindi ve bunun yerine \b kaçış dizisinden sonra gelen .uk karakterleri yerleştirildi. Dolayısıyla biz de şu çıktıyı aldık:
yahoo.co.uk
Bir örnek daha verelim...
Bildiğiniz gibi,
Kod:
print()
fonksiyonu, kendisine verilen parametreler arasına birer boşluk yerleştirir:
>>> print('istihza', '.', 'com')
istihza . com
Biz bu öğeleri birbirine bitiştirmek için şöyle bir yol izleyebileceğimizi biliyoruz:
>>> print('istihza', '.', 'com', sep='')
istihza.com
İşte aynı etkiyi \b kaçış dizisini kullanarak da elde edebiliriz:
>>> print('istihza', '\b.', '\bcom')
istihza.com
Gördüğünüz gibi, \b kaçış dizisi, ‘.’ ve ‘com’ parametrelerinden önce imleci birer karakter sola kaydırdığı için, parametreler arasındaki boşluk karakterleri ortadan kalktı.
Bu kaçış dizisini kullanarak şöyle gereksiz işler peşinde de koşabilirsiniz:
>>> print('istihza\b\b\bsn')
istisna
Burada \b kaçış dizisini üst üste birkaç kez kullanarak imleci birkaç karakter sola kaydırdık ve ‘sn’ harflerini ‘hz’ harflerinin üzerine bindirdik. Böylece ‘istihza’ kelimesi ‘istisna’ kelimesine dönüşmüş oldu...
Daha fazla uzatmadan, bu kaçış dizisinin Python’da çok nadir kullanıldığı bilgisini vererek yolumuza devam edelim...
Küçük Unicode (\u)
Tıpkı bundan önceki kaçış dizileri gibi, karakter dizileri içindeki varlığı konusunda dikkatli olmamız gereken bir başka kaçış dizisi de \u adlı kaçış dizisidir. Eğer bu kaçış dizisini tanımaz ve dikkatli kullanmazsak, yazdığımız programlar tespit etmesi çok güç hatalar üretebilir.
Örneğin şöyle bir çıktı vermek istediğinizi düşünün:
Bu çıktıyı normal yollardan vermeye çalışırsak Python bize bir hata mesajı gösterecektir:
>>> print("Dosya konumu: C:\users\zeynep\gizli\dosya.txt")
File "<stdin>", line 1
SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in
position 16-18: truncated \uXXXX escape
Belki sağda solda ‘UNICODE’ diye bir şey duymuşsunuzdur. Eğer şimdiye kadar böyle bir şey duymadıysanız veya duyduysanız bile ne olduğunu bilmiyorsanız hiç ziyanı yok. Birkaç bölüm sonra bunun ne anlama geldiğini bütün ayrıntılarıyla anlatacağız. Biz şimdilik sadece şunu bilelim: UNICODE, karakterlerin, harflerin, sayıların ve bilgisayar ekranında gördüğümüz öteki bütün işaretlerin her biri için tek ve benzersiz bir numaranın tanımlandığı bir sistemdir. Bu sistemde, ‘kod konumu’ (code point) adı verilen bu numaralar özel bir şekilde gösterilir. Örneğin ‘ı’ harfi UNICODE sisteminde şu şekilde temsil edilir:
u+0131
Aynı şekilde ‘a’ harfi bu sistemde şu kod konumu ile gösterilir:
u+0061
Python programlama dilinde ise, yukarıdaki kod konumu düzeni şöyle gösterilir:
\\u0131
Gördüğünüz gibi, Python UNICODE sistemindeki her bir kod konumunu gösterebilmek için, önce \u şeklinde bir kaçış dizisi tanımlıyor, ardından UNICODE sisteminde + işaretinden sonra gelen sayıyı bu kaçış dizisinin hemen sağına ekliyor. Gelin kendi kendimize birkaç deneme çalışması yapalım:
>>> '\u0130'
'İ'
>>> '\u0070'
'p'
>>> "\ufdsf"
File "<stdin>", line 1
SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in
position 0-4: truncated \uXXXX escape
Gördüğünüz gibi, eğer \u kaçış dizisinden sonra doğru bir kod konumu belirtmezsek Python bize bir hata mesajı gösteriyor...
Bu hata mesajının, biraz önce
kodunu yazdıktan sonra aldığımız hata ile aynı olduğuna dikkat edin. Tıpkı \ufdsf örneğinde olduğu gibi, \users ifadesi de varolan bir UNICODE kod konumuna karşılık gelmediği için, Python’ın hata vermekten başka çaresi kalmıyor.
Biz bu örnekte ‘users’ kelimesini kullanmaya çalışıyoruz, ama ‘u’ harfinden hemen önce gelen \ kaçış dizisi nedeniyle, hiç farkında olmadan Python açısından önemli bir karakter dizisi (\u) meydana getirmiş oluyoruz. O yüzden, böyle can sıkıcı hatalarla karşılaşmamak için olası kaçış dizilerine karşı her zaman uyanık olmamız gerekiyor.
Pekı biz bu kaçış dizisi yüzünden, yazdığımız programlarda Dosya konumu: C:\users\zeynep\gizli\dosya.txt”) gibi bir çıktı veremeyecek miyiz?
Verebileceğimizi, ama bunun bir yolu yordamı olduğunu biliyorsunuz. Biz yine de tekrar edelim:
>>> print("Dosya konumu: C:\\users\\zeynep\\gizli\\dosya.txt")
Dosya konumu: C:\users\zeynep\gizli\dosya.txt
Gördüğünüz gibi, karakter dizisi içinde geçen bütün \ işaretlerini çiftleyerek sorunumuzu çözdük. Buradaki gibi bir sorunla karşılaşmamak için, dizin adlarını ayırırken ters taksim işareti yerine düz taksim işaretini kullanmayı da tercih edebilirsiniz:
>>> print("Dosya konumu: C:/users/zeynep/gizli/dosya.txt")
Biraz sonra bu sorunu halletmenin üçüncü ve daha kolay bir yönteminden daha söz edeceğiz. Ama biz şimdilik bu kaçış dizisini bir kenara bırakıp başka bir kaçış dizisini incelemeye geçelim.
Büyük Unicode (\U)
Bu kaçış dizisi biraz önce gördüğümüz \u adlı kaçış dizisiyle hemen hemen aynı anlama gelir. Bu kaçış dizisi de, tıpkı \u gibi, UNICODE kod konumlarını temsil etmek için kullanılır. Ancak U ile gösterilen kod konumları u ile gösterilenlere göre biraz daha uzundur. Örneğin, hatırlarsanız u kaçış dizisini kullanarak ‘ı’ harfinin UNICODE kod konumunu şöyle temsil ediyorduk:
>>> '\u0131'
'ı'
Eğer aynı kod konumunu U adlı kaçış dizisi ile göstermek istersek şöyle bir şey yazmamız gerekir:
>>> '\U00000131'
Gördüğünüz gibi, burada \U kaçış dizisinden sonra gelen kısım toplam 8 haneli bir sayıdan oluşuyor. u kaçış dizisinde ise bu kısmı toplam 4 haneli bir sayı olarak yazıyorduk. İşte \u kaçış dizisi ile U kaçış dizisi arasındaki fark budur. u kaçış dizisi hakkında söylediğimiz öteki her şey U kaçış dizisi için de geçerlidir.
Uzun Ad (\N)
UNICODE sistemi ile ilgili bir başka kaçış dizisi de \N adlı kaçış dizisidir.
Dediğimiz gibi, UNICODE sistemine ilişkin ayrıntılardan ilerleyen derslerde söz edeceğiz, ama bu sistemle ilgili ufak bir bilgi daha verelim.
UNICODE sisteminde her karakterin tek ve benzersiz bir kod konumu olduğu gibi, tek ve benzersiz bir de uzun adı vardır. Örneğin ‘a’ harfinin UNICODE sistemindeki uzun adı şudur:
LATIN SMALL LETTER A
Bir karakterin UNICODE sistemindeki uzun adını öğrenmek için unicodedata adlı bir modülden yararlanabilirsiniz:
>>> import unicodedata
>>> unicodedata.name('a')
LATIN SMALL LETTER A
>>> unicodedata.name('Ş')
LATIN CAPITAL LETTER S WITH CEDILLA
Bu arada, daha önce de söylediğimiz gibi, bu ‘modül’ kavramına şimdilik takılmayın. İlerde modülleri ayrıntılı olarak inceleyeceğiz. Şimdilik unicodedata denen şeyin, (tıpkı daha önce örneklerini gördüğümüz os, sys ve keyword gibi) bir modül olduğunu ve bu modül içindeki name adlı bir fonksiyonu kullanarak, parantez içinde belirttiğimiz herhangi bir karakterin UNICODE sistemindeki uzun adını elde edebileceğimizi bilelim yeter.
İşte \N kaçış dizisi bu uzun isimleri, Python programlarımızda kullanma imkanı verir bize. Bu kaçış dizisini, karakterlerin UNICODE sistemindeki uzun adları ile birlikte kullanarak asıl karakterleri elde edebiliriz. Dikkatlice bakın:
>>> print("\N{LATIN SMALL LETTER A}")
a
>>> print("\N{LATIN CAPITAL LETTER S WITH CEDILLA}")
ş
>>> print("\Nisan")
File "<stdin>", line 1
SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in
position 0-1: malformed \N character escape
Gördüğünüz gibi, herhangi bir karşılığı olmayan bir uzun ad belirttiğimizde Python bize bir hata mesajı gösteriyor. Çünkü Python \N kaçış dizisinin hemen ardından { işaretinin getirilmesini ve sonra da UNICODE sistemi dahilinde geçerli bir uzun ad belirtilmesini bekliyor. Yukarıdaki örnekte \N kaçış dizisinden sonra { işareti yok. Zaten \N kaçış dizisinin hemen ardından gelen ‘isan’ ifadesi de doğru bir uzun ada işaret etmiyor. Dolayısıyla da Python’ın bize hata mesajı göstermekten başka çaresi kalmıyor...
\u, \U ve \N kaçış dizileri, UNICODE sistemi ile ilgili çalışmalar yapmak isteyen programcılar için Python programlama dilinin sunduğu faydalı araçlardan yalnızca birkaçıdır. Ancak bu araçların sizin işinize yaramayacağını asla düşünmeyin. Zira \u, \U ve \N kaçış dizileri ile ilgili yukarıdaki durum hiç beklemediğiniz bir anda sizi de vurabilir. Çünkü bu kaçış dizilerinin oluşturduğu risk hiç de öyle nadir karşılaşılacak bir sorun değildir.
Bildiğiniz gibi Windows 7’de kullanıcının dosyalarını içeren dizin adı C:\Users\kullanıcı_adı şeklinde gösteriliyor. Dolayısıyla Windows kullananlar UNICODE kaçış dizilerinden kaynaklanan bu tuzağa her an düşebilir. Ya da eğer adınız ‘u’ veya ‘n’ harfi ile başlıyorsa yine bu tuzağa düşme ihtimaliniz epey yüksek olacak, C:\Users\umut veya C:\Users\Nihat gibi bir dizin adı belirtirken çok dikkatli olmanız gerekecektir. Zira özellikle dosyalar üzerinde işlem yaparken, bu tür dizin adlarını sık sık kullanmak durumunda kalacaksınız. Bu yüzden, alelade bir kelime yazdığınızı zannederken hiç farkında olmadan bir kaçış dizisi tanımlıyor olma ihtimalini her zaman göz önünde bulundurmalı ve buna uygun önlemleri almış olmalısınız.
Onaltılı Karakter (\x)
‘x’ harfi de \ işareti ile birleştiğinde özel anlam kazanarak bir kaçış dizisi meydana getirir.
\x kaçış dizisini kullanarak, onaltılı (hexadecimal) sayma sistemindeki bir sayının karakter karşılığını gösterebilirsiniz. Dikkatlice bakın:
>>> "\x41"
'A'
Onaltılı sayma sistemindeki 41 sayısı ‘A’ harfine karşılık gelir. Eğer hangi karakterlerin hangi sayılara karşılık geldiğini merak ediyorsanız http://www.ascii.cl/ adresindeki tabloyu inceleyebilirsiniz. Bu tabloda ‘hex’ sütunu altında gösterilen sayılar onaltılı sayılar olup, ‘symbol’ sütununda gösterilen karakterlere karşılık gelirler. Örneğin ‘hex’ sütunundaki 4E sayısı ‘symbol’ sütunundaki ‘N’ harfine karşılık gelir. Bu durumu Python’la da teyit edebilirsiniz:
>>>"\x4E"
N
Eğer sayılarla karakterler arasındaki bağlantının tam olarak ne olduğunu bilmiyorsanız hiç endişe etmeyin. Birkaç bölüm sonra sayılarla karakterler arasında nasıl bir bağ olduğunu gayet ayrıntılı bir şekilde anlatacağız. Biz şimdilik yalnızca \x karakter dizisinin özel bir kaçış dizisine karşılık geldiğini ve bu kaçış dizisini karakter dizileri içinde kullanırken dikkatli olmamız gerektiğini bilelim yeter:
>>> print("C:\Users\Ayşe\xp_dosyaları")
File "<stdin>", line 1
SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in
position 2-4: truncated \UXXXXXXXX escape
Gördüğünüz gibi, Python \x ifadesinden sonra onaltılı bir sayı belirtmenizi bekliyor. Halbuki biz burada \x ifadesini ‘xp_dosyaları’ adlı dizini gösterebilmek için kullanmıştık. Ama görünüşe göre yanlışlıkla Python için özel bir anlam ifade eden bir karakter dizisi oluşturmuşuz...
Etkisizleştirme ®
Dediğimiz gibi, Python’daki en temel kaçış dizisi \ işaretidir. Bu işaret bazı başka harflerle birleşerek yeni kaçış dizileri de oluşturabilir.
Python’da \ işaretinin dışında temel bir kaçış dizisi daha bulunur. Bu kaçış dizisi ‘r’ harfidir. Şimdi bu kaçış dizisinin nasıl kullanılacağını ve ne işe yaradığını inceleyelim:
Şöyle bir çıktı vermek istediğimizi düşünün:
Kurulum dizini: C:\aylar\nisan\toplam masraf
Bildiğimiz yoldan bu çıktıyı vermeye çalışırsak neler olacağını adınız gibi biliyorsunuz:
>>> print("Kurulum dizini: C:\aylar\nisan\toplam masraf")
Kurulum dizini: C:ylar
isan oplam masraf
Eğer Windows üzerinde çalışıyorsanız bu komutu verdikten sonra bir !bip! sesi de duymuş olabilirsiniz...
Python tabii ki, karakter dizisi içinde geçen ‘\aylar’, ‘\nisan’, ve ‘\toplam masraf’ ifadelerinin ilk karakterlerini yanlış anladı! \a, \n ve \t gibi ifadeler Python’ın gözünde birer kaçış dizisi. Dolayısıyla Python \a karakterlerini görünce bir !bip! sesi çıkarıyor, \n karakterlerini görünce satır başına geçiyor ve \t karakterlerini görünce de Tab tuşuna basılmış gibi bir tepki veriyor. Sonuç olarak da yukarıdaki gibi bir çıktı üretiyor.
Daha önce bu durumu şöyle bir kod yazarak engellemiştik:
>>> print("Kurulum dizini: C:\\aylar\\nisan\\toplam masraf")
Kurulum dizini: C:\aylar\nisan\toplam masraf
Burada, \ işaretlerinin her birini çiftleyerek sorunun üstesinden geldik. Yukarıdaki yöntem doğru ve kabul görmüş bir çözümdür. Ama bu sorunun üstesinden gelmenin çok daha basit ve pratik bir yolu var. Bakalım:
>>> print(r"Kurulum dizini: C:\aylar\nisan\toplam masraf")
Kurulum dizini: C:\aylar\nisan\toplam masraf
Gördüğünüz gibi, karakter dizisinin baş kısmının dış tarafına bir adet r harfi yerleştirerek sorunun üstesinden geliyoruz. Bu kaçış dizisinin, kullanım açısından öteki kaçış dizilerinden farklı olduğuna dikkat edin. Öteki kaçış dizileri karakter dizisinin içinde yer alırken, bu kaçış dizisi karakter dizisinin dışına yerleştiriliyor.
Bu kaçış dizisinin tam olarak nasıl işlediğini görmek için dilerseniz bir örnek daha verelim:
>>> print("Kaçış dizileri: \, \n, \t, \a, \\, r")
Kaçış dizileri: \,
, , , \, r
Burada da Python bizim yapmak istediğimiz şeyi anlayamadı ve karakter dizisi içinde geçen kaçış dizilerini doğrudan ekrana yazdırmak yerine bu kaçış dizilerinin işlevlerini yerine getirmesine izin verdi. Tıpkı biraz önceki örnekte olduğu gibi, istersek kaçış dizilerini çiftleyerek bu sorunu aşabiliriz:
>>> print("Kaçış dizileri: \\, \\n, \\t, \\a, \\\, r")
Kaçış dizileri: \, \n, \t, \a, \\, r
Ama tabii ki bunun çok daha kolay bir yöntemi olduğunu biliyorsunuz:
>>> print(r"Kaçış dizileri: \, \n, \t, \a, \\, r")
Kaçış dizileri: \, \n, \t, \a, \\, r
Gördüğünüz gibi, karakter dizisinin başına getirdiğimiz r kaçış dizisi, karakter dizisi içinde geçen kaçış dizilerinin işlevlerini yerine getirmesine engel olarak, istediğimiz çıktıyı elde etmemizi sağlıyor.
Bu arada bu kaçış dizisini, daha önce öğrendiğimiz \r adlı kaçış dizisi ile karıştırmamaya dikkat ediyoruz.
Python’daki bütün kaçış dizilerinden söz ettiğimize göre, konuyu kapatmadan önce önemli bir ayrıntıdan söz edelim.
Python’da karakter dizilerinin sonunda sadece çift sayıda \ işareti bulunabilir. Tek sayıda \ işareti kullanıldığında karakter dizisini bitiren tırnak işareti etkisizleşeceği için çakışma sorunu ortaya çıkar. Bu etkisizleşmeyi, karakter dizisinin başına koyduğunuz ‘r’ kaçış dizisi de engelleyemez. Yani:
>>> print("Kaçış dizisi: \")
Bu şekilde bir tanımlama yaptığımızda Python bize bir hata mesajı gösterir. Çünkü kapanış tırnağının hemen öncesine yerleştirdiğimiz \ kaçış dizisi, Python’ın karakter dizisini kapatan tırnak işaretini görmezden gelmesine yol açarak bu tırnağı etkisizleştiriyor. Böylece sanki karakter dizisini tanımlarken kapanış tırnağını hiç yazmamışız gibi bir sonuç ortaya çıkıyor:
>>> print("Kaçış dizisi: \")
File "<stdin>", line 1
print("Kaçış dizisi: \")
^
SyntaxError: EOL while scanning string literal
Üstelik bu durumu, r adlı kaçış dizisi de engelleyemiyor:
>>> print(r"Kaçış dizisi: \")
File "<stdin>", line 1
print(r"Kaçış dizisi: \")
^
SyntaxError: EOL while scanning string literal
Çözüm olarak birkaç farklı yöntemden yararlanabilirsiniz. Mesela karakter dizisini kapatmadan önce karakter dizisinin sonundaki \ işaretinin sağına bir adet boşluk karakteri yerleştirmeyi deneyebilirsiniz:
>>> print("Kaçış dizisi: \ ")
Veya kaçış dizisini çiftleyebilirsiniz:
>>> print("Kaçış dizisi: \\")
Ya da karakter dizisi birleştirme yöntemlerinden herhangi birini kullanabilirsiniz:
>>> print("Kaçış dizisi: " + "\\")
>>> print("Kaçış dizisi:", "\\")
>>> print("Kaçış dizisi: " "\\")
Böyle bir durumla ilk kez karşılaştığınızda bunun Python programlama dilinden kaynaklanan bir hata olduğunu düşünebilirsiniz, ancak bu durum Python’ın resmi internet sitesinde ‘Sıkça Sorulan Sorular’ bölümüne alınacak kadar önemli bir tasarım tercihidir: http://goo.gl/i3tkk
Sayfa Başı (\f)
\f artık günümüzde pek kullanılmayan bir kaçış dizisidir. Bu kaçış dizisinin görevi, özellikle eski yazıcılarda, bir sayfanın sona erip yeni bir sayfanın başladığını göstermektir. Dolayısıyla eski model yazıcılar, bu karakteri gördükleri noktada mevcut sayfayı sona erdirip yeni bir sayfaya geçer.
Bu kaçış dizisinin tam olarak ne işe yaradığını test etmek için şu kodları çalıştırın:
>>> f = open("deneme.txt", "w")
>>> print("deneme\fdeneme", file=f)
>>> f.close()
Şimdi bu kodlarla oluşturduğunuz deneme.txt adlı dosyayı LibreOffice veya Microsoft Word gibi bir programla açın. ‘deneme’ satırlarının iki farklı sayfaya yazdırıldığını göreceksiniz. Bu arada, eğer Microsoft Word dosyayı açarken bir hata mesajı gösterirse, o hata mesajına birkaç kez ‘tamam’ diyerek hata penceresini kapatın. Dosya normal bir şekilde açılacaktır.
Dediğimiz gibi, bu kaçış dizisi artık pek kullanılmıyor. Ama yine de bu kaçış dizisine karşı da uyanık olmalısınız. Çünkü bu kaçış dizisi de beklemediğiniz çıktılar almanıza yol açabilir. Mesela şu örneğe bir bakalım:
>>> "\fırat"
'\x0cırat'
Gördüğünüz gibi, siz aslında ‘\fırat’ yazmak isterken, Python bu kelimenin baş tarafındaki \f karakter dizisini bir kaçış dizisi olarak değerlendirip ona göre bir çıktı verdi.
Bütün bu anlattıklarımızın ardından, kaçış dizilerinin, birleştirildikleri karakterlerin farklı bir anlam yüklenmesini sağlayan birtakım işaretler olduğunu anlıyoruz. Örneğin \ işareti ‘ (tek tırnak) işareti ile bir araya gelerek, tek tırnak işaretinin karakter dizisi tanımlama dışında başka bir anlam yüklenmesini sağlıyor. Aynı şekilde yine \ işareti “ (çift tırnak) işareti ile birleşerek çift tırnak işaretinin de karakter dizisi tanımlama dışında bir anlama kavuşmasını sağlıyor. Böylece tırnak işaretlerini karakter dizileri içinde rahatlıkla kullanabiliyoruz.
Ya da yine \ işareti ‘n’ harfi ile bir araya gelip, bu harfin satır başına geçilmesini sağlayan bir kaçış dizisi oluşturmasını mümkün kılıyor. Veya aynı işaret ‘t’ harfiyle birleşip, öğeler arasında sekme oluşturulmasını sağlayabiliyor. Bu araçlar sayesinde ekrana yazdırdığımız bir metnin akışını kontrol etme imkanına kavuşuyoruz.
Kaçış Dizilerine Toplu Bakış
Biraz sonra bu önemli konuyu kapatacağız. Ama dilerseniz kapatmadan önce, bu bölümde öğrendiğimiz kaçış dizilerini şöyle bir topluca görelim:
Kaçış Dizisi
Anlamı\’
Karakter dizisi içinde tek tırnak işaretini kullanabilmemizi sağlar.
\”
Karakter dizisi içinde çift tırnak işaretini kullanabilmemizi sağlar.
\\
Karakter dizisi içinde \ işaretini kullanabilmemizi sağlar.
\n
Yeni bir satıra geçmemizi sağlar.
\t
Karakterler arasında sekme boşluğu bırakmamızı sağlar.
\u
UNICODE kod konumlarını gösterebilmemizi sağlar.
\U
UNICODE kod konumlarını gösterebilmemizi sağlar.
\N
Karakterleri UNICODE adlarına göre kullanabilmemizi sağlar.
\x
Onaltılı sistemdeki bir sayının karakter karşılığını gösterebilmemizi sağlar.
\a
Destekleyen sistemlerde, kasa hoparlöründen bir ‘bip’ sesi verilmesini sağlar.
\r
Aynı satırın başına dönülmesini sağlar.
\v
Destekleyen sistemlerde düşey sekme oluşturulmasını sağlar.
\b
Kendisinden önce gelen karakterin silinmesini sağlar.
\f
Yeni bir sayfaya geçilmesini sağlar.
r
Karakter dizisi içinde kaçış dizilerini kullanabilmemizi sağlar.
Kaçış dizileriyle ilgili son olarak şunu söyleyebiliriz: Kaçış dizileri, görmezden gelebileceğiniz, ‘öğrenmesem de olur,’ diyebileceğiniz önemsiz birtakım işaretler değildir. Bu konu boyunca verdiğimiz örneklerden de gördüğünüz gibi, kaçış dizileri, kullanıcıya göstereceğiniz metinlerin biçimini doğrudan etkiliyor. Bütün bu örnekler, bu kaçış dizilerinin yersiz veya yanlış kullanılmasının ya da bunların bir metin içinde gözden kaçmasının, yazdığınız programların hata verip çökmesine, yani programınızın durmasına sebep olabileceğini de gösteriyor bize.
Böylece bir bölümü daha bitirmiş olduk. Artık Python’la ‘gerçek’ programlar yazmamızın önünde hiçbir engel kalmadı.
Geçen bölümde bir yandan Python’ın etkileşimli kabuğunu yakından tanıyıp bu vesileyle bazı önemli fonksiyon ve araçları öğrenirken, öbür yandan bu öğrendiklerimizi kullanarak örnek programlar yazdık. Gördüğünüz gibi, azıcık bir bilgiyle dahi az çok işe yarar programlar yazmak mümkün olabiliyor. Daha yararlı programlar yazabilmek için henüz öğrenmemiz gereken pek çok şey var. İşte bu bölümde, ‘daha yararlı programlar yazmamızı’ sağlayacak çok önemli bir araçtan söz edeceğiz. Öneminden dolayı ayrıntılı bir şekilde anlatacağımız bu aracın adı
Kod:
print()
fonksiyonu.
Elbette bu bölümde sadece
Kod:
print()
fonksiyonundan bahsetmeyeceğiz. Bu bölümde
Kod:
print()
fonksiyonunun yanısıra Python’daki bazı önemli temel konuları da ele alacağız. Mesela bu bölümde Python’daki karakter dizilerine ve sayılara ilişkin çok önemli bilgiler vereceğiz. Ayrıca
Kod:
print()
fonksiyonu vesilesiyle Python’daki ‘fonksiyon’ konusuna da sağlam bir giriş yapmış, bu kavram ile ilgili ilk bilgilerimizi almış olacağız. Sözün özü, bu bölüm bizim için, deyim yerindeyse, tam anlamıyla bir dönüm noktası olacak.
O halde isterseniz lafı daha fazla uzatmadan işe
Kod:
print()
fonksiyonunun ne olduğu ve ne işe yaradığını anlatarak başlayalım.
Nedir, Ne İşe Yarar?
Şimdiye kadar etkileşimli kabukta gerek karakter dizilerini gerekse sayıları doğrudan ekrana yazdık. Yani şöyle bir şey yaptık:
>>> "Python programlama dili"
'Python programlama dili'
>>> 6567
6567
Etkileşimli kabuk da, ekrana yazdığımız bu karakter dizisi ve sayıyı doğrudan bize çıktı olarak verdi. Ancak ilerde Python kodlarımızı bir dosyaya kaydedip çalıştırdığımızda da göreceğiniz gibi, Python’ın ekrana çıktı verebilmesi için yukarıdaki kullanım yeterli değildir. Yani yukarıdaki kullanım yalnızca etkileşimli kabukta çalışır. Bu kodları bir dosyaya kaydedip çalıştırmak istediğimizde hiçbir çıktı alamayız. Python’da yazdığımız şeylerin ekrana çıktı olarak verilebilmesi için
Kod:
print()
adlı özel bir fonksiyondan yararlanmamız gerekir.
O halde gelin bu
Kod:
print()
fonksiyonunun ne işe yaradığını ve nasıl kullanıldığını anlamaya çalışalım:
Kod:
print()
de tıpkı daha önce gördüğümüz
Kod:
type()
,
Kod:
len()
ve
Kod:
pow()
gibi bir fonksiyondur. Fonksiyonları ilerde daha ayrıntılı bir şekilde inceleyeceğimizi söylemiştik hatırlarsanız. O yüzden fonksiyon kelimesine takılarak, burada anlattığımız şeylerin kafanızı karıştırmasına, moralinizi bozmasına izin vermeyin.
Kod:
print()
fonksiyonunun görevi ekrana çıktı vermemizi sağlamaktır. Hemen bununla ilgili bir örnek verelim:
>>> print("Python programlama dili")
Python programlama dili
Bildiğiniz gibi burada gördüğümüz “Python programlama dili” bir karakter dizisidir. İşte
Kod:
print()
fonksiyonunun görevi bu karakter dizisini ekrana çıktı olarak vermektir. Peki bu karakter dizisini
Kod:
print()
fonksiyonu olmadan yazdığımızda da ekrana çıktı vermiş olmuyor muyuz? Aslında olmuyoruz. Dediğimiz gibi, ilerde programlarımızı dosyalara kaydedip çalıştırdığımızda, başında
Kod:
print()
olmayan ifadelerin çıktıda görünmediğine şahit olacaksınız.
Daha önce de dediğimiz gibi, etkileşimli kabuk bir test ortamı olması açısından rahat bir ortamdır. Bu sebeple bu ortamda ekrana çıktı verebilmek için
Kod:
print()
fonksiyonunu kullanmak zorunda değilsiniz. Yani başında
Kod:
print()
olsa da olmasa da etkileşimli kabuk ekrana yazdırmak istediğiniz şeyi yazdırır. Ama iyi bir alışkanlık olması açısından, ekrana herhangi bir şey yazdıracağınızda ben size
Kod:
print()
fonksiyonunu kullanmanızı tavsiye ederim.
Kod:
print()
son derece güçlü bir fonksiyondur. Gelin isterseniz bu güçlü ve faydalı fonksiyonu derin derin incelemeye koyulalım.
Nasıl Kullanılır?
Yukarıda verdiğimiz örnekte ilk gözümüze çarpan şey, karakter dizisini
Kod:
print()
fonksiyonunun parantezleri içine yazmış olmamızdır. Biz bir fonksiyonun parantezleri içinde belirtilen öğelere ‘parametre’ dendiğini geçen bölümde öğrenmiştik. Tıpkı öğrendiğimiz öteki fonksiyonlar gibi,
Kod:
print()
fonksiyonu da birtakım parametreler alır.
Bu arada
Kod:
print()
fonksiyonunun parantezini açıp parametreyi yazdıktan sonra, parantezi kapatmayı unutmuyoruz. Python programlama diline yeni başlayanların, hatta bazen deneyimli programcıların bile en sık yaptığı hatalardan biri açtıkları parantezi kapatmayı unutmalarıdır.
Elbette, eğer istersek burada doğrudan “Python programlama dili” adlı karakter dizisini kullanmak yerine, önce bu karakter dizisini bir değişkene atayıp, sonra da
Kod:
print()
fonksiyonunun parantezleri içinde bu değişkeni kullanabiliriz. Yani:
>>> dil = "Python programlama dili"
>>> print(dil)
Python programlama dili
Bu arada, hem şimdi verdiğimiz, hem de daha önce yazdığımız örneklerde bir şey dikkatinizi çekmiş olmalı. Şimdiye kadar verdiğimiz örneklerde karakter dizilerini hep çift tırnakla gösterdik. Ama aslında tek seçeneğimiz çift tırnak değildir. Python bize üç farklı tırnak seçeneği sunar:
Tek tırnak (‘ ‘)
Çift tırnak (” ”)
Üç tırnak (“”” “””)
Dolayısıyla yukarıdaki örneği üç farklı şekilde yazabiliriz:
>>> print('Python programlama dili')
Python programlama dili
>>> print("Python programlama dili")
Python programlama dili
>>> print("""Python programlama dili""")
Python programlama dili
Gördüğünüz gibi çıktılar arasında hiçbir fark yok.
Peki çıktılarda hiçbir fark yoksa neden üç farklı tırnak çeşidi var?
İsterseniz bu soruyu bir örnek üzerinden açıklamaya çalışalım. Diyelim ki ekrana şöyle bir çıktı vermek istiyoruz:
Python programlama dilinin adı "piton" yılanından gelmez
Eğer bu cümleyi çift tırnaklar içinde gösterirsek programımız hata verecektir:
>>> print("Python programlama dilinin adı "piton" yılanından gelmez")
File "<stdin>", line 1
print("Python programlama dilinin adı "piton" yılanından gelmez")
^
SyntaxError: invalid syntax
Bunun sebebi, cümle içinde geçen ‘piton’ kelimesinin de çift tırnaklar içinde gösterilmiş olmasıdır. Cümlenin, yani karakter dizisinin kendisi de çift tırnak içinde gösterildiği için Python, karakter dizisini başlatan ve bitiren tırnakların hangisi olduğunu ayırt edemiyor. Yukarıdaki cümleyi en kolay şu şekilde ekrana yazdırabiliriz:
>>> print('Python programlama dilinin adı "piton" yılanından gelmez')
Python programlama dilinin adı "piton" yılanından gelmez
Burada karakter dizisini tek tırnak içine aldık. Karakter dizisi içinde geçen ‘piton’ kelimesi çift tırnak içinde olduğu için, karakter dizisini başlatıp bitiren tırnaklarla ‘piton’ kelimesindeki tırnakların birbirine karışması gibi bir durum söz konusu değildir.
Bir de şöyle bir örnek verelim: Diyelim ki aşağıdaki gibi bir çıktı elde etmek istiyoruz:
İstanbul'un 5 günlük hava durumu tahmini
Eğer bu karakter dizisini tek tırnak işaretleri içinde belirtirseniz Python size bir hata mesajı gösterecektir:
>>> print('İstanbul'un 5 günlük hava durumu tahmini')
File "<stdin>", line 1
print('İstanbul'un 5 günlük hava durumu tahmini')
^
SyntaxError: invalid syntax
Bu hatanın sebebi ‘İstanbul’un’ kelimesi içinde geçen kesme işaretidir. Tıpkı bir önceki örnekte olduğu gibi, Python karakter dizisini başlatan ve bitiren tırnakların hangisi olduğunu kestiremiyor. Python, karakter dizisinin en başındaki tek tırnak işaretinin ardından ‘İstanbul’un’ kelimesi içindeki kesme işaretini görünce karakter dizisinin burada sona erdiğini zannediyor. Ancak karakter dizisini soldan sağa doğru okumaya devam edince bir yerlerde bir terslik olduğunu düşünüyor ve bize bir hata mesajı göstermekten başka çaresi kalmıyor. Yukarıdaki karakter dizisini en kolay şöyle tanımlayabiliriz:
>>> print("İstanbul'un 5 günlük hava durumu tahmini")
İstanbul'un 5 günlük hava durumu tahmini
Burada da, karakter dizisi içinde geçen kesme işaretine takılmamak için karakter dizimizi çift tırnak işaretleri içine alıyoruz.
Yukarıdaki karakter dizilerini düzgün bir şekilde çıktı verebilmek için üç tırnak işaretlerinden de yararlanabiliriz:
>>> print("""Python programlama dilinin adı "piton" yılanından gelmez""")
Python programlama dilinin adı "piton" yılanından gelmez
>>> print("""İstanbul'un 5 günlük hava durumu tahmini""")
İstanbul'un 5 günlük hava durumu tahmini
Bütün bu örneklerden sonra kafanızda şöyle bir düşünce uyanmış olabilir:
Alıntı:Görünüşe göre üç tırnak işaretiyle her türlü karakter dizisini hatasız bir şekilde ekrana çıktı olarak verebiliyoruz. O zaman ben en iyisi bütün karakter dizileri için üç tırnak işaretini kullanayım!
Elbette, eğer isterseniz pek çok karakter dizisi için üç tırnak işaretini kullanabilirsiniz. Ancak Python’da karakter dizileri tanımlanırken genellikle tek tırnak veya çift tırnak işaretleri kullanılır. Üç tırnak işaretlerinin asıl kullanım yeri ise farklıdır. Peki nedir bu üç tırnak işaretlerinin asıl kullanım yeri?
Üç tırnak işaretlerini her türlü karakter dizisiyle birlikte kullanabiliyor olsak da, bu tırnak tipi çoğunlukla sadece birden fazla satıra yayılmış karakter dizilerini tanımlamada kullanılır. Örneğin şöyle bir ekran çıktısı vermek istediğinizi düşünün:
[H]=========HARMAN========[-][o][x]
| |
| Programa Hoşgeldiniz! |
| Sürüm 0.8 |
| Devam etmek için herhangi |
| bir düğmeye basın. |
| |
|=================================|
Böyle bir çıktı verebilmek için eğer tek veya çift tırnak kullanmaya kalkışırsanız epey eziyet çekersiniz. Bu tür bir çıktı vermenin en kolay yolu üç tırnakları kullanmaktır:
>>> print("""
... [H]=========HARMAN========[-][o][x]
... | |
... | Programa Hoşgeldiniz! |
... | Sürüm 0.8 |
... | Devam etmek için herhangi |
... | bir düğmeye basın. |
... | |
... |=================================|
... """)
Burada bazı şeyler dikkatinizi çekmiş olmalı. Gördüğünüz gibi, üç tırnaklı yapı öteki tırnak tiplerine göre biraz farklı davranıyor. Şimdi şu örneğe bakın:
>>> print("""Game Over!
...
Buraya çok dikkatli bakın. Karakter dizisine üç tırnakla başladıktan sonra, kapanış tırnağını koymadan Enter tuşuna bastığımızda >>> işareti ... işaretine dönüştü. Python bu şekilde bize, ‘yazmaya devam et!’ demiş oluyor. Biz de buna uyarak yazmaya devam edelim:
>>> print("""Game Over!
... Insert Coin!""")
Game Over!
Insert Coin!
Kapanış tırnağı koyulmadan Enter tuşuna basıldığında >>> işaretinin ... işaretine dönüşmesi üç tırnağa özgü bir durumdur. Eğer aynı şeyi tek veya çift tırnaklarla yapmaya çalışırsanız programınız hata verir:
>>> print("Game Over!
File "<stdin>", line 1
print("Game Over!
^
SyntaxError: EOL while scanning string literal
...veya:
>>> print('Game Over!
File "<stdin>", line 1
print("Game Over!
^
SyntaxError: EOL while scanning string literal
Üç tırnak işaretlerinin tırnak kapanmadan Enter tuşuna basıldığında hata vermeme özelliği sayesinde, bu tırnak tipi özellikle birden fazla satıra yayılmış karakter dizilerinin gösterilmesi için birebirdir.
Gelin isterseniz üç tırnak kullanımına ilişkin bir örnek daha verelim:
>>> print("""Python programlama dili Guido Van Rossum
... adlı Hollandalı bir programcı tarafından 90’lı
... yılların başında geliştirilmeye başlanmıştır. Çoğu
... insan, isminin "Python" olmasına bakarak, bu programlama
... dilinin, adını piton yılanından aldığını düşünür.
... Ancak zannedildiğinin aksine bu programlama dilinin
... adı piton yılanından gelmez.""")
Python programlama dili Guido Van Rossum
adlı Hollandalı bir programcı tarafından 90'lı
yılların başında geliştirilmeye başlanmıştır. Çoğu
insan, isminin "Python" olmasına bakarak, bu programlama
dilinin, adını piton yılanından aldığını düşünür.
Ancak zannedildiğinin aksine bu programlama dilinin
dı piton yılanından gelmez.
Elbette eğer istersek bu metni önce bir değişkene atamayı da tercih edebiliriz:
>>> python_hakkinda = """Python programlama dili Guido Van Rossum
... adlı Hollandalı bir programcı tarafından 90’lı
... yılların başında geliştirilmeye başlanmıştır. Çoğu
... insan, isminin "Python" olmasına bakarak, bu programlama
... dilinin, adını piton yılanından aldığını düşünür.
... Ancak zannedildiğinin aksine bu programlama dilinin
... adı piton yılanından gelmez."""
>>> print(python_hakkinda)
Python programlama dili Guido Van Rossum
adlı Hollandalı bir programcı tarafından 90'lı
yılların başında geliştirilmeye başlanmıştır. Çoğu
insan, isminin "Python" olmasına bakarak, bu programlama
dilinin, adını piton yılanından aldığını düşünür.
Ancak zannedildiğinin aksine bu programlama dilinin
dı piton yılanından gelmez.
Siz yukarıdaki çıktıyı tek veya çift tırnak kullanarak nasıl ekrana yazdırabileceğinizi düşünedurun, biz önemli bir konuya geçiş yapalım!
Bir Fonksiyon Olarak print()
Kod:
print()
ifadesinin bir fonksiyon olduğunu söylemiştik hatırlarsanız. Dediğimiz gibi, fonksiyonlarla ilgili ayrıntılı açıklamaları ilerleyen derslerde vereceğiz. Ancak şimdi dilerseniz bundan sonra anlatacaklarımızı daha iyi kavrayabilmemiz için, fonksiyonlar hakkında bilmemiz gereken bazı temel şeyleri öğrenmeye çalışalım.
Gördüğünüz gibi,
Kod:
print()
fonksiyonunu şöyle kullanıyoruz:
>>> print("Aramak istediğiniz kelimeyi yazın: ")
Burada
Kod:
print()
bir fonksiyon, “Aramak istediğiniz kelimeyi yazın:” adlı karakter dizisi ise bu fonksiyonun parametresidir. Daha önce
Kod:
len()
adlı başka bir fonksiyon daha öğrenmiştik hatırlarsanız. Onu da şöyle kullanıyorduk:
>>> len("elma")
Burada da
Kod:
len()
bir fonksiyon, “elma” adlı karakter dizisi ise bu fonksiyonun parametresidir. Aslında biçim olarak
Kod:
print()
ve
Kod:
len()
fonksiyonlarının birbirinden hiçbir farkı olmadığını görüyorsunuz.
Daha önce söylediğimiz ve bu örneklerden de anladığımız gibi, bir fonksiyonun parantezleri içinde belirtilen öğelere parametre adı veriliyor. Mesela aşağıdaki örnekte
Kod:
print()
fonksiyonunu tek bir parametre ile kullanıyoruz:
>>> print('En az 8 haneli bir parola belirleyin.')
Kod:
print()
fonksiyonu, tıpkı
Kod:
pow()
fonksiyonu gibi, birden fazla parametre alabilir:
>>> print('Fırat', 'Özgül')
Fırat Özgül
Bu örnekte bizim için çıkarılacak çok dersler var. Bir defa burada
Kod:
print()
fonksiyonunu iki farklı parametre ile birlikte kullandık. Bunlardan ilki Fırat adlı bir karakter dizisi, ikincisi ise Özgül adlı başka bir karakter dizisi. Python’ın bu iki karakter dizisini nasıl birleştirdiğine dikkat edin.
Kod:
print()
fonksiyonu bu iki karakter dizisini çıktı olarak verirken aralarına da birer boşluk yerleştirdi. Ayrıca, geçen derste de vurguladığımız gibi, parametrelerin birbirinden virgül ile ayrıldığını da gözden kaçırmıyoruz.
Gelin bununla ilgili bir iki örnek daha verelim elimizin alışması için:
>>> print("Python", "Programlama", "Dili")
Python Programlama Dili
>>> print('Fırat', 'Özgül', 'Adana', 1980)
Fırat Özgül Adana 1980
Bu arada dikkatinizi önemli bir noktaya çekmek istiyorum. Yukarıdaki örneklerde bazen tek tırnak, bazen de çift tırnak kullandık. Daha önce de söylediğimiz gibi, hangi tırnak tipini kullandığımız önemli değildir. Python hangi tırnak tipini kullandığımızdan ziyade, tırnak kullanımında tutarlı olup olmadığımızla ilgilenir. Yani Python için önemli olan, karakter dizisini hangi tırnakla başlatmışsak, o tırnakla bitirmemizdir. Yani şu tip kullanımlar geçerli değildir:
>>> print("karakter dizisi')
>>> print('karakter dizisi")
Karakter dizisini tanımlamaya başlarken kullandığımız tırnak tipi ile karakter dizisini tanımlamayı bitirirken kullandığımız tırnak tipi birbirinden farklı olduğu için bu iki kullanım da hata verecektir.
print() Fonksiyonunun Parametreleri
Şimdiye kadar verdiğimiz örneklerde belki çok da belli olmuyordur, ama aslında
Kod:
print()
fonksiyonu son derece güçlü bir araçtır. İşte şimdi biz bu fonksiyonun gücünü gözler önüne seren özelliklerini incelemeye başlayacağız. Bu bölümü dikkatle takip etmeniz, ilerde yapacağımız çalışmaları daha rahat anlayabilmeniz açısından büyük önem taşır.
sep
Kod:
print()
fonksiyonu ile ilgili olarak yukarıda verdiğimiz örnekleri incelediğimizde, bu fonksiyonun kendine özgü bir davranış şekli olduğunu görüyoruz. Mesela bir önceki bölümde verdiğimiz şu örneğe bakalım:
>>> print('Fırat', 'Özgül')
Fırat Özgül
Burada
Kod:
print()
fonksiyonunu iki farklı parametre ile birlikte kullandık. Bu fonksiyon, kendisine verdiğimiz bu parametreleri belli bir düzene göre birbiriyle birleştirdi. Bu düzen gereğince
Kod:
print()
, kendisine verilen parametreleri birleştirirken, parametreler arasına bir boşluk yerleştiriyor. Bunu daha net görmek için şöyle bir örnek daha verelim:
>>> print("Python", "PHP", "C++", "C", "Erlang")
Python PHP C++ C Erlang
Gördüğünüz gibi,
Kod:
print()
fonksiyonu gerçekten de, kendisine verilen parametreleri birleştirirken, parametrelerin her biri arasına bir boşluk yerleştiriyor. Halbuki bu boşluğu biz talep etmedik! Python bize bu boşluğu eşantiyon olarak verdi. Çoğu durumda istediğimiz şey bu olacaktır, ama bazı durumlarda bu boşluğu istemeyebiliriz. Örneğin:
>>> print("http://", "www.", "istihza.", "com")
http:// www. istihza. com
Ya da boşluk karakteri yerine daha farklı bir karakter kullanmak istiyor da olabiliriz. Peki böyle bir durumda ne yapmamız gerekir?
İşte bu noktada bazı özel araçlardan yararlanarak
Kod:
print()
fonksiyonunun öntanımlı davranış kalıpları üzerinde değişiklikler yapabiliriz.
Peki nedir
Kod:
print()
fonksiyonunu özelleştirmemizi sağlayacak bu araçlar?
Hatırlarsanız, Python’da fonksiyonların parantezleri içindeki değerlere parametre adı verildiğini söylemiştik. Mesela
Kod:
print()
fonksiyonunu bir ya da daha fazla parametre ile birlikte kullanabileceğimizi biliyoruz:
>>> print("Mehmet", "Öz", "İstanbul", "Çamlıca", 156, "/", 45)
Mehmet Öz İstanbul Çamlıca 156 / 45
Kod:
print()
fonksiyonu içinde istediğimiz sayıda karakter dizisi ve/veya sayı değerli parametre kullanabiliriz.
Fonksiyonların bir de daha özel görünümlü parametreleri vardır. Mesela
Kod:
print()
fonksiyonun sep adlı özel bir parametresi bulunur. Bu parametre
Kod:
print()
fonksiyonunda görünmese bile her zaman oradadır. Yani diyelim ki şöyle bir kod yazdık:
>>> print("http://", "www.", "google.", "com")
Burada herhangi bir sep parametresi görmüyoruz. Ancak Python yukarıdaki kodu aslında şöyle algılar:
>>> print("http://", "www.", "google.", "com", sep=" ")
sep ifadesi, İngilizcede separator (ayırıcı, ayraç) kelimesinin kısaltmasıdır. Dolayısıyla
Kod:
print()
fonksiyonundaki bu sep parametresi, ekrana basılacak öğeler arasına hangi karakterin yerleştirileceğini gösterir. Bu parametrenin öntanımlı değeri bir adet boşluk karakteridir (” “). Yani siz bu özel parametrenin değerini başka bir şeyle değiştirmezseniz, Python bu parametrenin değerini bir adet boşluk karakteri olarak alacak ve ekrana basılacak öğeleri birbirinden birer boşlukla ayıracaktır. Ancak eğer biz istersek bu sep parametresinin değerini değiştirebiliriz. Böylece Python, karakter dizilerini birleştirirken araya boşluk değil, bizim istediğimiz başka bir karakteri yerleştirebilir. Gelin şimdi bu parametrenin değerini nasıl değiştireceğimizi görelim:
>>> print("http://", "www.", "istihza.", "com", sep="")
http://www.istihza.com
Gördüğünüz gibi, karakter dizilerini başarıyla birleştirip, geçerli bir internet adresi elde ettik.
Burada yaptığımız şey aslında çok basit. Sadece sep parametresinin ‘bir adet boşluk karakteri’ olan öntanımlı değerini silip, yerine ‘boş bir karakter dizisi’ değerini yazdık. Bu iki kavramın birbirinden farklı olduğunu söylediğimizi hatırlıyorsunuz, değil mi?
Gelin bir örnek daha yapalım:
>>> print("T", "C", sep=".")
T.C
Burada Python’a şöyle bir emir vermiş olduk:
Alıntı:“T” ve “C” karakter dizilerini birbiriyle birleştir! Bunu yaparken de bu karakter dizilerinin arasına nokta işareti yerleştir!
sep parametresinin öteki parametrelerden farkı her zaman ismiyle birlikte kullanılmasıdır. Zaten teknik olarak da bu tür parametrelere ‘isimli parametreler’ adı verilir. Örneğin:
>>> print("Adana", "Mersin", sep="-")
Adana-Mersin
Eğer burada sep parametresinin ismini belirtmeden, doğrudan parametrenin değerini yazarsak, bu değerin öteki parametrelerden hiçbir farkı kalmayacaktır:
>>> print("Adana", "Mersin", "-")
Adana Mersin -
Gelin isterseniz bu parametreyle ilgili bir örnek daha yapalım:
‘Bir mumdur iki mumdur...’ diye başlayan türküyü biliyorsunuzdur. Şimdi bu türküyü Python’la nasıl yazabileceğimizi görelim!
>>> print("bir", "iki", "üç", "dört", "on dört", sep="mumdur")
birmumdurikimumdurüçmumdurdörtmumduron dört
Burada bir terslik olduğu açık! Karakter dizileri birbirlerine sıkışık düzende birleştirildi. Bunların arasında birer boşluk olsa tabii daha iyi olurdu. Ancak biliyorsunuz sep parametresinin öntanımlı değerini silip, yerine “mumdur” değerini yerleştirdiğimiz için, Python’ın otomatik olarak yerleştirdiği boşluk karakteri kayboldu. Ama eğer istersek o boşluk karakterlerini kendimiz de ayarlayabiliriz:
>>> print("bir", "iki", "üç", "dört", "on dört", sep=" mumdur ")
bir mumdur iki mumdur üç mumdur dört mumdur on dört
Gördüğünüz gibi, sep parametresine verdiğimiz “mumdur” değerinin sağında ve solunda birer boşluk bırakarak sorunumuzu çözebildik. Bu sorunu çözmenin başka bir yolu daha var. Hatırlarsanız etkileşimli kabukta ilk örneklerimizi verirken karakter dizilerini birleştirmek için + işaretinden de yararlanabileceğimizi söylemiştik. Dolayısıyla sep parametresini şöyle de yazabiliriz:
>>> print("bir", "iki", "üç", "dört", "on dört", sep=" " + "mumdur" + " ")
Burada da, “mumdur” adlı karakter dizisinin başında ve sonunda birer boşluk bırakmak yerine, gerekli boşlukları + işareti yardımıyla bu karakter dizisine birleştirdik. Hatta istersek + işlecini kullanmak zorunda olmadığımızı dahi biliyorsunuz:
>>> print("bir", "iki", "üç", "dört", "on dört", sep=" " "mumdur" " ")
Ama gördüğünüz gibi bir problemimiz daha var. Türkünün sözleri şu şekilde olmalıydı:
Alıntı:bir mumdur iki mumdur üç mumdur dört mumdur on dört mumdur
Ama sondaki ‘mumdur’ kelimesi yukarıdaki çıktıda yok. Normal olan da bu aslında. sep parametresi, karakter dizilerinin arasına bir değer yerleştirir. Karakter dizilerinin son tarafıyla ilgilenmez. Bu iş için
Kod:
print()
fonksiyonu başka bir parametreye sahiptir.
Bu arada, yukarıdaki örneklerde hep karakter dizilerini kullanmış olmamız sizi yanıltmasın. sep parametresi yalnızca karakter dizilerinin değil sayıların arasına da istediğiniz bir değerin yerleştirilmesini sağlayabilir. Mesela:
>>> print(1, 2, 3, 4, 5, sep="-")
1-2-3-4-5
Ancak sep parametresinin değeri bir karakter dizisi (veya ‘hiçbir şey’ anlamına gelen
Kod:
None
) olmalıdır:
>>> print(1, 2, 3, 4, 5, sep=0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: sep must be None or a string, not int
Gördüğünüz gibi, sep parametresine bir sayı olan 0 değerini veremiyoruz.
Kod:
print()
fonksiyonunun sep parametresini bütün ayrıntılarıyla incelediğimize göre, bu fonksiyonun bir başka özel parametresinden söz edebiliriz.
end
Bir önceki bölümde şöyle bir laf etmiştik:
Alıntı:
Kod:
print()
fonksiyonun sep adlı özel bir parametresi bulunur. Bu parametre
Kod:
print()
fonksiyonunda görünmese bile her zaman oradadır.
Aynı bu şekilde,
Kod:
print()
fonksiyonunun end adlı özel bir parametresi daha bulunur. Tıpkı sep parametresi gibi, end parametresi de
Kod:
print()
fonksiyonunda görünmese bile her zaman oradadır.
Bildiğiniz gibi, sep parametresi
Kod:
print()
fonksiyonuna verilen parametreler birleştirilirken araya hangi karakterin gireceğini belirliyordu. end parametresi ise bu parametrelerin sonuna neyin geleceğini belirler.
Kod:
print()
fonksiyonu öntanımlı olarak, parametrelerin sonuna ‘satır başı karakteri’ ekler. Peki bu satır başı karakteri denen şey de ne oluyor?
Dilerseniz bunu bir örnek üzerinde görelim.
Şöyle bir kodumuz olsun:
>>> print("Pardus ve Ubuntu birer GNU/Linux dağıtımıdır.")
Bu kodu yazıp Enter tuşuna bastığımız anda
Kod:
print()
fonksiyonu iki farklı işlem gerçekleştirir:
Öncelikle karakter dizisini ekrana yazdırır.
Ardından bir alt satıra geçip bize >>> işaretini gösterir.
İşte bu ikinci işlem, karakter dizisinin sonunda bir adet satır başı karakteri olmasından, daha doğrusu
Kod:
print()
fonksiyonunun, satır başı karakterini karakter dizisinin sonuna eklemesinden kaynaklanır. Bu açıklama biraz kafa karıştırıcı gelmiş olabilir. O halde biraz daha açıklayalım. Şu örneğe bakın:
>>> print("Pardus\nUbuntu")
Pardus
Ubuntu
Burada “Pardus” ve “Ubuntu” karakter dizilerinin tam ortasında çok özel bir karakter dizisi daha görüyorsunuz. Bu karakter dizisi şudur: \n. İşte bu özel karakter dizisine satır başı karakteri (newline) adı verilir. Bu karakterin görevi, karakter dizisini, bulunduğu noktadan bölüp, karakter dizisinin geri kalanını bir alt satıra geçirmektir. Zaten çıktıda da bu işlevi yerine getirdiğini görüyorsunuz. Karakter dizisi “Pardus” kısmından sonra ikiye bölünüyor ve bu karakter dizisinin geri kalan kısmı olan “Ubuntu” karakter dizisi bir alt satıra yazdırılıyor. Bunu daha iyi anlamak için bir örnek daha verelim:
>>> print("birinci satır\nikinci satır\nüçüncü satır")
birinci satır
ikinci satır
üçüncü satır
Peki size bir soru sorayım: Acaba yukarıdaki kodları daha verimli bir şekilde nasıl yazabiliriz?
Evet, doğru tahmin ettiniz... Tabii ki sep parametresini kullanarak:
>>> print("birinci satır", "ikinci satır", "üçüncü satır", sep="\n")
birinci satır
ikinci satır
üçüncü satır
Burada yaptığımız şey çok basit. sep parametresinin değerini \n, yani yeni satır karakteri olarak değiştirdik. Böylece karakter dizileri arasına birer \n karakteri yerleştirerek her bir karakter dizisinin farklı satıra yazdırılmasını sağladık.
İşte end parametresinin öntanımlı değeri de bu \n karakteridir ve bu parametre
Kod:
print()
fonksiyonunda görünmese bile her zaman oradadır.
Yani diyelim ki şöyle bir kod yazdık:
>>> print("Bugün günlerden Salı")
Burada herhangi bir end parametresi görmüyoruz. Ancak Python yukarıdaki kodu aslında şöyle algılar:
>>> print("Bugün günlerden Salı", end="\n")
Biraz önce de dediğimiz gibi, bu kodu yazıp Enter tuşuna bastığımız anda
Kod:
print()
fonksiyonu iki farklı işlem gerçekleştirir:
Öncelikle karakter dizisini ekrana yazdırır.
Ardından bir alt satıra geçip bize >>> işaretini gösterir.
Bunun ne demek olduğunu anlamak için end parametresinin değerini değiştirmemiz yeterli olacaktır:
>>> print("Bugün günlerden Salı", end=".")
Bugün günlerden Salı.>>>
Gördüğünüz gibi, end parametresinin öntanımlı değeri olan \n karakterini silip yerine . (nokta) işareti koyduğumuz için, komutu yazıp Enter tuşuna bastığımızda
Kod:
print()
fonksiyonu satır başına geçmedi. Yeni satıra geçebilmek için Enter tuşuna kendimiz basmalıyız. Elbette, eğer yukarıdaki kodları şöyle yazarsanız,
Kod:
print()
fonksiyonu hem karakter dizisinin sonuna nokta ekleyecek, hem de satır başına geçecektir:
>>> print("Bugün günlerden Salı", end=".\n")
Bugün günlerden Salı.
Şimdi bu öğrendiklerimizi türkümüze uygulayalım:
>>> print("bir", "iki", "üç", "dört", "on dört",
... sep=" mumdur ", end=" mumdur\n")
Burada kodlarımızın sağa doğru çirkin bir şekilde uzamasını engellemek için “on dört” karakter dizisini yazıp virgülü koyduktan sonra Enter tuşuna basarak bir alt satıra geçtik. Bir alt satıra geçtiğimizde >>> işaretinin ... işaretine dönüştüğüne dikkat edin. Python’da doğru kod yazmak kadar, yazdığımız kodların düzgün görünmesi de önemlidir. O yüzden yazdığımız her bir kod satırının mümkün olduğunca 79 karakteri geçmemesini sağlamalıyız. Eğer yazdığınız bir satır 79 karakteri aşıyorsa, aşan kısmı yukarıda gösterdiğimiz şekilde alt satıra alabilirsiniz.
end parametresi de, tıpkı sep parametresi gibi, her zaman ismiyle birlikte kullanılması gereken bir parametredir. Yani eğer end parametresinin ismini belirtmeden sadece değerini kullanmaya çalışırsak Python ne yapmaya çalıştığımızı anlayamaz.
file
Burada henüz öğrenmediğimiz bazı şeyler göreceksiniz. Hiç endişe etmeyin. Bunları ilerde bütün ayrıntılarıyla öğreneceğiz. Şimdilik konu hakkında biraz olsun fikir sahibi olmanızı sağlayabilirsek kendimizi başarılı sayacağız.
Kod:
print()
fonksiyonunun sep ve end dışında üçüncü bir özel parametresi daha bulunur. Bu parametrenin adı file‘dır. Görevi ise,
Kod:
print()
fonksiyonuna verilen karakter dizisi ve/veya sayıların, yani parametrelerin nereye yazılacağını belirtmektir.
Bu parametrenin öntanımlı değeri sys.stdout‘tur. Peki bu ne anlama geliyor? sys.stdout, ‘standart çıktı konumu’ anlamına gelir. Peki ‘standart çıktı konumu’ ne demek?
Standart çıktı konumu; bir programın, ürettiği çıktıları verdiği yerdir. Aslında bu kavramın ne demek olduğu adından da anlaşılıyor:
Alıntı:standart çıktı konumu = çıktıların standart olarak verildiği konum.
Mesela Python öntanımlı olarak, ürettiği çıktıları ekrana verir. Eğer o anda etkileşimli kabukta çalışıyorsanız, Python ürettiği çıktıları etkileşimli kabuk üzerinde gösterir. Eğer yazdığınız bir programı komut satırında çalıştırıyorsanız, üretilen çıktılar komut satırında görünür. Dolayısıyla Python’ın standart çıktı konumu etkileşimli kabuk veya komut satırıdır. Yani
Kod:
print()
fonksiyonu yardımıyla bastığınız çıktılar etkileşimli kabukta ya da komut satırında görünecektir.
Şimdi bu konuyu daha iyi anlayabilmek için birkaç örnek yapalım.
Normal şartlar altında
fonksiyonunun, çıktılarını ekrana değil, bir dosyaya yazdırmasını da sağlayabiliriz. Mesela biz şimdi
Kod:
print()
fonksiyonunun deneme.txt adlı bir dosyaya çıktı vermesini sağlayalım.
Bunun için sırasıyla şu kodları yazalım:
>>> dosya = open("deneme.txt", "w")
>>> print("Ben Python, Monty Python!", file=dosya)
>>> dosya.close()
Herhangi bir çıktı almadınız, değil mi? Evet. Çünkü yazdığımız bu kodlar sayesinde
Kod:
print()
fonksiyonu, çıktılarını deneme.txt adlı bir dosyaya yazdırdı.
Gelin isterseniz yukarıdaki kodları satır satır inceleyelim:
1. Öncelikle deneme.txt adlı bir dosya oluşturduk ve bu dosyayı dosya adlı bir değişkene atadık. Burada kullandığımız
Kod:
open()
fonksiyonuna çok takılmayın. Bunu birkaç bölüm sonra inceleyeceğiz. Biz şimdilik bu şekilde dosya oluşturulduğunu bilelim yeter. Bu arada
Kod:
open
fonksiyonunun da biçim olarak
Kod:
type()
,
Kod:
len()
,
Kod:
pow()
ve
Kod:
print()
fonksiyonlarına ne kadar benzediğine dikkat edin. Gördüğünüz gibi
Kod:
open()
fonksiyonu da tıpkı
Kod:
type()
,
Kod:
len()
,
Kod:
pow()
ve
Kod:
print()
fonksiyonları gibi birtakım parametreler alıyor. Bu fonksiyonun ilk parametresi “deneme.txt” adlı bir karakter dizisi. İşte bu karakter dizisi bizim oluşturmak istediğimiz dosyanın adını gösteriyor. İkinci parametre ise “w” adlı başka bir karakter dizisi. Bu da deneme.txt dosyasının yazma kipinde (modunda) açılacağını gösteriyor. Ama dediğim gibi, siz şimdilik bu ayrıntılara fazla takılmayın. İlerleyen derslerde, bu konuları adınızı bilir gibi bileceğinizden emin olabilirsiniz.
2. Oluşturduğumuz bu deneme.txt adlı dosya, o anda bulunduğunuz dizin içinde oluşacaktır. Bu dizinin hangisi olduğunu öğrenmek için şu komutları verebilirsiniz:
>>> import os
>>> os.getcwd()
Bu komutun çıktısında hangi dizinin adı görünüyorsa, deneme.txt dosyası da o dizinin içindedir. Mesela bendeki çıktı /home/istihza/Desktop. Demek ki oluşturduğum deneme.txt adlı dosya masaüstündeymiş. Ben bu komutları Ubuntu üzerinde verdim. Eğer Windows üzerinde verseydim şuna benzer bir çıktı alacaktım: C:\Users\falanca\Desktop
3. Ardından da normal bir şekilde
Kod:
print()
fonksiyonumuzu çalıştırdık. Ama gördüğünüz gibi
Kod:
print()
fonksiyonu bize herhangi bir çıktı vermedi. Çünkü, daha önce de söylediğimiz gibi,
Kod:
print()
fonksiyonunu biz ekrana değil, dosyaya çıktı verecek şekilde ayarladık. Bu işlemi, file adlı bir parametreye, biraz önce tanımladığımız dosya değişkenini yazarak yaptık.
4. Son komut yardımıyla da, yaptığımız değişikliklerin dosyada görünebilmesi için ilk başta açtığımız dosyayı kapatıyoruz.
Şimdi deneme.txt adlı dosyayı açın. Biraz önce
Kod:
print()
fonksiyonuyla yazdırdığımız “Ben Python, Monty Python!” karakter dizisinin dosyaya işlenmiş olduğunu göreceksiniz.
Böylece
Kod:
print()
fonksiyonunun standart çıktı konumunu değiştirmiş olduk. Yani
Kod:
print()
fonksiyonunun file adlı parametresine farklı bir değer vererek,
Kod:
print()
fonksiyonunun etkileşimli kabuğa değil dosyaya yazmasını sağladık.
Tıpkı sep ve end parametreleri gibi, file parametresi de, siz görmeseniz bile her zaman
Kod:
print()
fonksiyonunun içinde vardır. Yani diyelim ki şöyle bir komut verdik:
>>> print("Tahir olmak da ayıp değil", "Zühre olmak da")
Python bu komutu şöyle algılar:
>>> print("Tahir olmak da ayıp değil", "Zühre olmak da",
... sep=" ", end="\n", file=sys.stdout)
Yani kendisine parametre olarak verilen değerleri ekrana yazdırırken sırasıyla şu işlemleri gerçekleştirir:
Alıntı:
Parametrelerin arasına birer boşluk koyar (
sep=" "
),
Ekrana yazdırma işlemi bittikten sonra parametrelerin sonuna satır başı karakteri ekler (
end="\n"
)
Bu çıktıyı standart çıktı konumuna gönderir (
file=sys.stdout
).
İşte biz burada file parametresinin değeri olan standart çıktı konumuna başka bir değer vererek bu konumu değiştiriyoruz.
Gelin isterseniz bununla ilgili bir örnek daha yapalım. Mesela kişisel bilgilerimizi bir dosyaya kaydedelim. Öncelikle bilgileri kaydedeceğimiz dosyayı oluşturalım:
>>> f = open("kişisel_bilgiler.txt", "w")
Bu kodlarla, kişisel_bilgiler.txt adını taşıyan bir dosyayı yazma kipinde (w) açmış ve bu dosyayı f adlı bir değişkene atamış olduk. Şimdi bilgileri yazmaya başlayabiliriz:
>>> print("Fırat Özgül", file=f)
>>> print("Adana", file=f)
>>> print("Ubuntu", file=f)
İşimiz bittiğinde dosyayı kapatmayı unutmuyoruz. Böylece bütün bilgiler dosyaya yazılmış oluyor:
>>> f.close()
Oluşturduğumuz kişisel_bilgiler.txt adlı dosyayı açtığımızda,
Kod:
print()
fonksiyonuna verdiğimiz parametrelerin dosyaya yazdırıldığını görüyoruz.
En başta da söylediğim gibi, bu bölümde henüz öğrenmediğimiz bazı şeylerle karşılaştık. Eğer yukarıda verilen örnekleri anlamakta zorlandıysanız hiç endişe etmenize gerek yok. Birkaç bölüm sonra burada anlattığımız şeyler size çocuk oyuncağı gibi gelecek...
flush
Şimdiye kadar
Kod:
print()
fonksiyonunun sep, end ve file adlı özel birtakım parametreleri olduğunu öğrendik.
Kod:
print()
fonksiyonunun bunların dışında başka bir özel parametresi daha bulunur. Bu parametrenin adı flush. İşte şimdi biz
Kod:
print()
fonksiyonunun bu flush adlı parametresinden söz edeceğiz.
Bildiğiniz gibi,
Kod:
print()
gibi bir komut verdiğimizde Python, yazdırmak istediğimiz bilgiyi standart çıktı konumuna gönderir. Ancak Python’da bazı işlemler standart çıktı konumuna gönderilmeden önce bir süre tamponda bekletilir ve daha sonra bekleyen bu işlemler topluca standart çıktı konumuna gönderilir. Peki ilk başta çok karmaşıkmış gibi görünen bu ifade ne anlama geliyor?
Aslında siz bu olguya hiç yabancı değilsiniz. file parametresini anlatırken verdiğimiz şu örneği tekrar ele alalım:
>>> f = open("kişisel_bilgiler.txt", "w")
Bu komutla kişisel_bilgiler.txt adlı bir dosyayı yazma kipinde açtık. Şimdi bu dosyaya bazı bilgiler ekleyelim:
>>> print("Fırat Özgül", file=f)
Bu komutla kişisel_bilgiler.txt adlı dosyaya ‘Fırat Özgül’ diye bir satır eklemiş olduk.
Şimdi bilgisayarınızda oluşan bu kişisel_bilgiler.txt dosyasını açın. Gördüğünüz gibi dosyada hiçbir bilgi yok. Dosya şu anda boş görünüyor. Halbuki biz biraz önce bu dosyaya ‘Fırat Özgül’ diye bir satır eklemiştik, değil mi?
Python bizim bu dosyaya eklemek istediğimiz satırı tampona kaydetti. Dosyaya yazma işlemleri sona erdiğinde ise Python, tamponda bekleyen bütün bilgileri standart çıktı konumuna (yani bizim durumumuzda f adlı değişkenin tuttuğu kişisel_bilgiler.txt adlı dosyaya) boşaltacak.
Dosyaya başka bilgiler de yazalım:
>>> print("Adana", file=f)
>>> print("Ubuntu", file=f)
Dosyaya yazacağımız şeyler bu kadar. Artık yazma işleminin sona erdiğini Python’a bildirmek için şu komutu veriyoruz:
>>> f.close()
Böylece dosyamızı kapatmış olduk. Şimdi kişisel_bilgiler.txt adlı dosyaya çift tıklayarak dosyayı tekrar açın. Orada ‘Fırat Özgül’, ‘Adana’ ve ‘Ubuntu’ satırlarını göreceksiniz.
Gördüğünüz gibi, gerçekten de Python dosyaya yazdırmak istediğimiz bütün verileri önce tamponda bekletti, daha sonra dosya kapatılınca tamponda bekleyen bütün verileri dosyaya boşalttı. İşte flush parametresi ile, bahsettiğimiz bu boşaltma işlemini kontrol edebilirsiniz. Şimdi dikkatlice inceleyin:
>>> f = open("kişisel_bilgiler.txt", "w")
Dosyamızı oluşturduk. Şimdi bu dosyaya bazı bilgiler ekleyelim:
>>> print("Merhaba Dünya!", file=f, flush=True)
Gördüğünüz gibi, burada flush adlı yeni bir parametre kullandık. Bu parametreye verdiğimiz değer True. Şimdi dosyaya çift tıklayarak dosyayı açın. Gördüğünüz gibi, henüz dosyayı kapatmadığımız halde bilgiler dosyaya yazıldı. Bu durum, tahmin edebileceğiniz gibi, flush parametresine True değeri vermemiz sayesindedir. Bu parametre iki değer alabilir: True ve False. Bu parametrenin öntanımlı değeri False‘tur. Yani eğer biz bu parametreye herhangi bir değer belirtmezsek Python bu parametrenin değerini False olarak kabul edecek ve bilgilerin dosyaya yazılması için dosyanın kapatılmasını bekleyecektir. Ancak bu parametreye True değerini verdiğimizde ise veriler tamponda bekletilmeksizin standart çıktı konumuna gönderilecektir.
Yazdığınız bir programda, yapmak istediğiniz işin niteliğine göre, bir dosyaya yazmak istediğiniz bilgilerin bir süre tamponda bekletilmesini veya hiç bekletilmeden doğrudan dosyaya yazılmasını isteyebilirsiniz. İhtiyacınıza bağlı olarak da flush parametresinin değerini True veya False olarak belirleyebilirsiniz.
Birkaç Pratik Bilgi
Buraya gelene kadar
Kod:
print()
fonksiyonu ve bu fonksiyonun parametreleri hakkında epey söz söyledik. Dilerseniz şimdi de, programcılık maceranızda işinize yarayacak, işlerinizi kolaylaştıracak bazı ipuçları verelim.
Yıldızlı Parametreler
Şimdi size şöyle bir soru sormama izin verin: Acaba aşağıdaki gibi bir çıktıyı nasıl elde ederiz?
L.i.n.u.x
Aklınıza hemen şöyle bir cevap gelmiş olabilir:
>>> print("L", "i", "n", "u", "x", sep=".")
L.i.n.u.x
Yukarıdaki, gerçekten de doğru bir çözümdür. Ancak bu soruyu çözmenin çok daha basit bir yolu var. Şimdi dikkatle bakın:
>>> print(*"Linux", sep=".")
L.i.n.u.x
Konuyu açıklamaya geçmeden önce bir örnek daha verelim:
>>> print(*"Galatasaray")
G a l a t a s a r a y
Burada neler döndüğünü az çok tahmin ettiğinizi zannediyorum. Son örnekte de gördüğünüz gibi, “Galatasaray” karakter dizisinin başına eklediğimiz yıldız işareti; “Galatasaray” karakter dizisinin her bir öğesini parçalarına ayırarak, bunları tek tek
Kod:
print()
fonksiyonuna yolluyor. Yani sanki
Kod:
print()
fonksiyonunu şöyle yazmışız gibi oluyor:
>>> print("G", "a", "l", "a", "t", "a", "s", "a", "r", "a", "y")
G a l a t a s a r a y
Dediğimiz gibi, bir fonksiyona parametre olarak verdiğimiz bir karakter dizisinin başına eklediğimiz yıldız işareti, bu karakter dizisini tek tek öğelerine ayırıp, bu öğeleri yine tek tek ve sanki her bir öğe ayrı bir parametreymiş gibi o fonksiyona gönderdiği için doğal olarak yıldız işaretini ancak, birden fazla parametre alabilen fonksiyonlara uygulayabiliriz.
Örneğin
Kod:
len()
fonksiyonu sadece tek bir parametre alabilir:
>>> len("Galatasaray")
11
Bu fonksiyonu birden fazla parametre ile kullanamayız:
>>> len("Galatasaray", "Fenerbahçe", "Beşiktaş")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: len() takes exactly one argument (3 given)
Hata mesajında da söylendiği gibi,
Kod:
len()
fonksiyonu yalnızca tek bir parametre alabilirken, biz 3 parametre vermeye çalışmışız...
Dolayısıyla yıldızlı parametreleri
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: len() takes exactly one argument (11 given)
Bir parametrenin başına yıldız eklediğimizde, o parametreyi oluşturan bütün öğeler tek tek fonksiyona gönderildiği için, sanki
Kod:
len()
fonksiyonuna 1 değil de, 11 ayrı parametre vermişiz gibi bir sonuç ortaya çıkıyor.
Yıldızlı parametreleri bir fonksiyona uygulayabilmemiz için o fonksiyonun birden fazla parametre alabilmesinin yanısıra, yapısının da yıldızlı parametre almaya uygun olması gerekir. Mesela
Kod:
open()
,
Kod:
type()
ve biraz önce bahsettiğimiz
Kod:
len()
fonksiyonlarının yapısı yıldızlı parametre almaya uygun değildir. Dolayısıyla yıldızlı parametreleri her fonksiyonla birlikte kullanamayız, ama
Kod:
print()
fonksiyonu yıldızlı parametreler için son derece uygun bir fonksiyondur:
>>> print(*"Galatasaray")
G a l a t a s a r a y
>>> print(*"TBMM", sep=".")
T.B.M.M
>>> print(*"abcçdefgğh", sep="/")
a/b/c/ç/d/e/f/g/ğ/h
Bu örneklerden de gördüğünüz gibi,
Kod:
print()
fonksiyonuna verdiğimiz bir parametrenin başına yıldız eklediğimizde, o parametre tek tek parçalarına ayrılıp
Kod:
print()
fonksiyonuna gönderildiği için, sonuç olarak sep parametresinin karakter dizisi öğelerine tek tek uygulanmasını sağlamış oluyoruz.
Hatırlarsanız sep parametresinin öntanımlı değerinin bir adet boşluk karakteri olduğunu söylemiştik. Yani aslında Python yukarıdaki ilk komutu şöyle görüyor:
>>> print(*"Galatasaray", sep=" ")
Dolayısıyla, yıldız işareti sayesinde “Galatasaray” adlı karakter dizisinin her bir öğesinin arasına bir adet boşluk karakteri yerleştiriliyor. Bir sonraki “TBMM” karakter dizisinde ise, sep parametresinin değerini nokta işareti olarak değiştirdiğimiz için “TBMM” karakter dizisinin her bir öğesinin arasına bir adet nokta işareti yerleştiriliyor. Aynı şekilde “abcçdefgğh” karakter dizisinin her bir öğesini tek tek
Kod:
print()
fonksiyonuna yollayarak, sep parametresine verdiğimiz / işareti yardımıyla her öğenin arasına bu / işaretini yerleştirebiliyoruz.
Bu arada yıldızlı parametrelerin sayılarla birlikte kullanılamayacağına dikkat ediyoruz:
>>> print(*2345)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: print() argument after * must be a sequence, not int
Çünkü yıldızlı parametreler ancak ve ancak dizi özelliği taşıyan veri tipleriyle birlikte kullanılabilir. Mesela karakter dizileri bu türden bir veri tipidir. İlerde dizi özelliği taşıyan ve bu sayede yıldızlı parametrelerle birlikte kullanılabilecek başka veri tiplerini de öğreneceğiz.
Yıldızlı parametreler ile ilgili bir başka kısıtlama da şudur: Yıldızlı parametrelerden sonra sadece isimli parametreler gelebilir. Peki bu ne demek?
Dilerseniz bu kısıtlamayı bir örnek üzerinden anlatalım:
>>> print(*"falanca", sep=".")
Bu kod düzgün çalışır. Çünkü yıldızlı parametre olan “falanca” öğesinden sonra isimli bir parametre olan sep parametresi geliyor. Ama şu kod çalışmaz:
>>> print(*"falanca", "filanca")
Bu kod şuna benzer bir hata verecektir:
Traceback (most recent call last):
File "<stdin>", line 1
SyntaxError: only named arguments may follow *expression
Bu kodun çalışmamasının sebebi, yıldızlı parametreden sonra gelen parametrenin isimli bir parametre olmaması. Yukarıdaki kodun çalışması için parametrelerin yerini değiştirmeyi deneyebilirsiniz:
>>> print("filanca", *"falanca")
Ayrıca bir fonksiyon içinde birden fazla yıldızlı parametre de kullanılamaz. Yani şu kod yanlıştır:
>>> print(*"filanca", *"falanca")
Bütün bu örnekler bize yıldızlı parametrelerin son derece kullanışlı araçlar olduğunu gösteriyor. İleride de bu parametrelerden bol bol yararlanacağız. Biz şimdi bu konuyu burada kapatıp başka bir şeyden söz edelim.
sys.stdout’u Kalıcı Olarak Değiştirmek
Önceki başlıklar altında verdiğimiz örneklerden de gördüğünüz gibi,
Kod:
print()
fonksiyonunun file parametresi yardımıyla Python’ın standart çıktı konumunu geçici olarak değiştirebiliyoruz. Ama bazı durumlarda, yazdığınız programlarda, o programın işleyişi boyunca standart dışı bir çıktı konumu belirlemek isteyebilirsiniz. Yani standart çıktı konumunu geçici olarak değil, kalıcı olarak değiştirmeniz gerekebilir. Mesela yazdığınız programda bütün çıktıları bir dosyaya yazdırmayı tercih edebilirsiniz. Elbette bu işlemi her defasında file parametresini, çıktıları yazdırmak istediğiniz dosyanın adı olarak belirleyerek yapabilirsiniz. Tıpkı şu örnekte olduğu gibi:
>>> f = open("dosya.txt", "w")
>>> print("Fırat Özgül", file=f)
>>> print("Adana", file=f)
>>> print("Ubuntu", file=f)
>>> f.close()
Gördüğünüz gibi, her defasında file parametresine f değerini vererek işimizi hallettik. Ama bunu yapmanın daha pratik bir yöntemi var. Dilerseniz yazdığınız programın tüm işleyişi boyunca çıktıları başka bir konuma yönlendirebilirsiniz. Bunun için hem şimdiye kadar öğrendiğimiz, hem de henüz öğrenmediğimiz bazı bilgileri kullanacağız.
İlk önce şöyle bir kod yazalım:
>>> import sys
Bu kod yardımıyla sys adlı özel bir ‘modülü’ programımıza dahil etmiş, yani içe aktarmış olduk. Peki ‘modül’ nedir, ‘içe aktarmak’ ne demek?
Aslında biz bu ‘modül’ ve ‘içe aktarma’ kavramlarına hiç de yabancı değiliz. Önceki derslerde, pek üzerinde durmamış da olsak, biz Python’daki birkaç modülle zaten tanışmıştık. Mesela os adlı bir modül içindeki
Kod:
getcwd()
adlı bir fonksiyonu kullanarak, o anda hangi dizinde bulunduğumuzu öğrenebilmiştik:
>>> import os
>>> os.getcwd()
Aynı şekilde keyword adlı başka bir modül içindeki kwlist adlı değişkeni kullanarak, hangi kelimelerin Python’da değişken adı olarak kullanılamayacağını da listeleyebilmiştik:
>>> import keyword
>>> keyword.kwlist
İşte şimdi de, os ve keyword modüllerine ek olarak sys adlı bir modülden söz ediyoruz. Gelin isterseniz öteki modülleri şimdilik bir kenara bırakıp, bu sys denen modüle dikkatimizi verelim.
Dediğimiz gibi, sys modülü içinde pek çok önemli değişken ve fonksiyon bulunur. Ancak bir modül içindeki değişken ve fonksiyonları kullanabilmek için o modülü öncelikle programımıza dahil etmemiz, yani içe aktarmamız gerekiyor. Bunu
Kod:
import
komutuyla yapıyoruz:
>>> import sys
Artık sys modülü içindeki bütün fonksiyon ve değişkenlere ulaşabileceğiz.
sys modülü içinde bulunan pek çok değişken ve fonksiyondan biri de stdout adlı değişkendir. Bu değişkenin değerine şöyle ulaşabilirsiniz:
>>> sys.stdout
Bu komut şuna benzer bir çıktı verir:
<_io.TextIOWrapper name='<stdout>' mode='w' encoding='cp1254'>
Bu çıktıdaki name=’<stdout>’ kısmına dikkat edin. Bu ifadeye birazdan geri döneceğiz. Biz şimdi başka bir şeyden söz edelim.
Hatırlarsanız etkileşimli kabuğu nasıl kapatabileceğimizi anlatırken, etkileşimli kabuktan çıkmanın bir yolunun da şu komutları vermek olduğunu söylemiştik:
>>> import sys; sys.exit()
Bu komutu tek satırda yazmıştık, ama istersek şöyle de yazabiliriz elbette:
>>> import sys
>>> sys.exit()
Dedik ya, sys modülü içinde pek çok değişken ve fonksiyon bulunur. Nasıl stdout sys modülü içindeki değişkenlerden biri ise,
Kod:
exit()
de sys modülü içinde bulunan fonksiyonlardan biridir.
Biz ‘modüller’ konusunu ilerleyen derslerde ayrıntılı bir şekilde inceleyeceğiz. Şimdilik modüllere ilişkin olarak yalnızca şunları bilelim yeter:
1. Python’da modüller
Kod:
import
komutu ile içe aktarılır. Örneğin sys adlı modülü içe aktarmak için
Kod:
import sys
komutunu veriyoruz.
2. Modüller içinde pek çok faydalı değişken ve fonksiyon bulunur. İşte bir modülü içe aktardığımızda, o modül içindeki bu değişken ve fonksiyonları kullanma imkanı elde ederiz.
3. sys modülü içindeki değişkenlere bir örnek stdout; fonksiyonlara örnek ise
Kod:
exit()
fonksiyonudur. Bir modül içindeki bu değişken ve fonksiyonlara ‘modül_adı.değişken_ya_da_fonksiyon’ formülünü kullanarak erişebiliriz. Örneğin:
Alıntı:>>> sys.stdout
>>> sys.exit()
4. Hatırlarsanız bundan önce de,
Kod:
open()
fonksiyonu ile dosya oluşturmayı anlatırken, oluşturulan dosyanın hangi dizinde olduğunu bulabilmek amacıyla, o anda içinde bulunduğumuz dizini tespit edebilmek için şu kodları kullanmıştık:
Alıntı:>>> import os
>>> os.getcwd()
Burada da os adlı başka bir modül görüyoruz. İşte os da tıpkı sys gibi bir modüldür ve tıpkı sys modülünde olduğu gibi, os modülünün de içinde pek çok yararlı değişken ve fonksiyon bulunur.
Kod:
getcwd()
adlı fonksiyon da os modülü içinde yer alan ve o anda hangi dizin altında bulunduğumuzu gösteren bir fonksiyondur. Elbette, yine tıpkı sys modülünde olduğu gibi, os modülü içindeki bu yararlı değişken ve fonksiyonları kullanabilmek için de öncelikle bu os modülünü içe aktarmamız, yani programımıza dahil etmemiz gerekiyor. os modülünü
Kod:
import
komutu aracılığıyla uygun bir şekilde içe aktardıktan sonra, modül içinde yer alan
Kod:
getcwd()
adlı fonksiyona yine ‘modül_adı.fonksiyon’ formülünü kullanarak erişebiliyoruz.
Modüllere ilişkin şimdilik bu kadar bilgi yeter. Modülleri bir kenara bırakıp yolumuza devam edelim...
Eğer
Kod:
sys.exit()
komutunu verip etkileşimli kabuktan çıktıysanız, etkileşimli kabuğa tekrar girin ve sys modülünü yeniden içe aktarın:
>>> import sys
Bir modülü aynı etkileşimli kabuk oturumu içinde bir kez içe aktarmak yeterlidir. Bir modülü bir kez içe aktardıktan sonra, o oturum süresince bu modül içindeki değişken ve fonksiyonları kullanmaya devam edebilirsiniz. Ama tabii ki etkileşimli kabuğu kapatıp tekrar açtıktan sonra, bir modülü kullanabilmek için o modülü tekrar içe aktarmanız gerekir.
Şimdi şu kodu yazın:
>>> f = open("dosya.txt", "w")
Bu kodun anlamını biliyorsunuz. Burada dosya.txt adlı bir dosyayı yazma kipinde açmış olduk. Tahmin edebileceğiniz gibi, çıktılarımızı ekran yerine bu dosyaya yönlendireceğiz.
Şimdi de şöyle bir kod yazalım:
>>> sys.stdout = f
Bildiğiniz gibi, sys.stdout değeri Python’ın çıktıları hangi konuma vereceğini belirliyor. İşte biz burada sys.stdout‘un değerini biraz önce oluşturduğumuz f adlı dosya ile değiştiriyoruz. Böylece Python bütün çıktıları f değişkeni içinde belirttiğimiz dosya.txt adlı dosyaya gönderiyor.
Bu andan sonra yazacağınız her şey dosya.txt adlı dosyaya gidecektir:
>>> print("deneme metni", flush=True)
Gördüğünüz gibi, burada file parametresini kullanmadığımız halde çıktılarımız ekrana değil, dosya.txt adlı bir dosyaya yazdırıldı. Peki ama bu nasıl oldu? Aslında bunun cevabı çok basit: Biraz önce
Kod:
sys.stdout = f
komutuyla sys.stdout‘un değerini f değişkeninin tuttuğu dosya ile değiştirdik. Bu işlemi yapmadan önce
Kod:
sys.stdout
‘un değeri şuydu hatırlarsanız:
<_io.TextIOWrapper name='<stdout>' mode='w' encoding='cp1254'>
Ama
Kod:
sys.stdout = f
komutundan sonra her şey değişti. Kontrol edelim:
>>> print(sys.stdout, flush=True)
Elbette bu komuttan herhangi bir çıktı almadınız. Çıktının ne olduğunu görmek için dosya.txt adlı dosyayı açın. Orada şu satırı göreceksiniz:
<_io.TextIOWrapper name='dosya.txt' mode='w' encoding='cp1254'>
Gördüğünüz gibi, özgün stdout çıktısındaki name=’<stdout>’ değeri name=’dosya.txt’ olmuş. Dolayısıyla artık bütün çıktılar dosya.txt adlı dosyaya gidiyor...
Bu arada, yukarıdaki çıktıda görünen name, mode ve encoding değerlerine şu şekilde ulaşabilirsiniz:
>>> sys.stdout.name
>>> sys.stdout.mode
>>> sys.stdout.encoding
Burada
Kod:
sys.stdout.name
komutu standart çıktı konumunun o anki adını verecektir.
Kod:
sys.stdout.mode
komutu ise standart çıktı konumunun hangi kipe sahip olduğunu gösterir. Standart çıktı konumu genellikle yazma kipinde (w) bulunur.
Kod:
sys.stdout.encoding
kodu ise standart çıktı konumunun sahip olduğu kodlama biçimini gösterir. Kodlama biçimi, standart çıktı konumuna yazdıracağınız karakterlerin hangi kodlama biçimi ile kodlanacağını belirler. Kodlama biçimi Windows’ta genellikle ‘cp1254’, GNU/Linux’ta ise ‘utf-8’dir. Eğer bu kodlama biçimi yanlış olursa, mesela dosyaya yazdıracağınız karakterler içindeki Türkçe harfler düzgün görüntülenemez. Eğer burada söylediklerimiz size şu anda anlaşılmaz geliyorsa, söylediklerimizi dikkate almadan yolunuza devam edebilirsiniz. Birkaç bölüm sonra bu söylediklerimiz size daha fazla şey ifade etmeye başlayacak nasıl olsa.
Peki standart çıktı konumunu eski haline döndürmek isterseniz ne yapacaksınız? Bunun için etkileşimli kabuktan çıkıp tekrar girebilirsiniz. Etkileşimli kabuğu tekrar açtığınızda her şeyin eski haline döndüğünü göreceksiniz. Aynı şekilde, eğer bu kodları bir program dosyasına yazmış olsaydınız, programınız kapandığında her şey eski haline dönecekti.
Peki standart çıktı konumunu, etkileşimli kabuktan çıkmadan veya programı kapatmadan eski haline döndürmenin bir yolu var mı? Elbette var. Dikkatlice bakın:
>>> import sys
>>> f = open("dosya.txt", "w")
>>> sys.stdout, f = f, sys.stdout
>>> print("deneme", flush=True)
>>> f, sys.stdout = sys.stdout, f
>>> print("deneme")
deneme
Aslında burada anlayamayacağınız hiçbir şey yok. Burada yaptığımız şeyi geçen bölümlerde değişkenlerin değerini nasıl takas edeceğimizi anlatırken de yapmıştık. Hatırlayalım:
>>> osman = "Araştırma Geliştirme Müdürü"
>>> mehmet = "Proje Sorumlusu"
>>> osman, mehmet = mehmet, osman
Bu kodlarla Osman ve Mehmet’in unvanlarını birbiriyle takas etmiştik. İşte yukarıda yaptığımız şey de bununla aynıdır.
Kod:
sys.stdout, f = f, sys.stdout
dediğimizde f değerini sys.stdout‘a, sys.stdout‘un değerini ise f‘ye vermiş oluyoruz.
Kod:
f, sys.stdout = sys.stdout, f
dediğimizde ise, bu işlemin tam tersini yaparak her şeyi eski haline getirmiş oluyoruz.
Python’ın bize sunduğu bu kolaylıktan faydalanarak değişkenlerin değerini birbiriyle kolayca takas edebiliyoruz. Eğer böyle bir kolaylık olmasaydı yukarıdaki kodları şöyle yazabilirdik:
>>> import sys
>>> f = open("dosya.txt", "w")
>>> özgün_stdout = sys.stdout
>>> sys.stdout = f
>>> print("deneme", flush=True)
>>> sys.stdout = özgün_stdout
>>> print("deneme")
deneme
Gördüğünüz gibi, sys.stdout‘un değerini kaybetmemek için, sys.stdout değerini f adlı dosyaya göndermeden önce şu kod yardımıyla yedekliyoruz:
>>> özgün_stdout = sys.stdout
sys.stdout‘un özgün değerini özgün_stdout değişkenine atadığımız için, bu değere sonradan tekrar ulaşabileceğiz. Zaten yukarıdaki kodlardan da gördüğünüz gibi, sys.stdout‘un özgün değerine dönmek istediğimizde şu kodu yazarak isteğimizi gerçekleştirebiliyoruz:
>>> sys.stdout = özgün_stdout
Böylece stdout değeri eski haline dönmüş oluyor ve bundan sonra yazdırdığımız her şey yeniden ekrana basılmaya başlıyor.
Önceki bölümlerde Python programlama dili ve genel olarak programlamanın temelleri üzerine epey söz söyledik. Dolayısıyla artık şu soruların cevabını rahatlıkla verebilecek durumdayız:
Alıntı:
Python nasıl kurulur?
Python nasıl çalıştırılır?
YOL (PATH) nedir?
Bir dizin YOL’a nasıl eklenir?
Farklı işletim sistemlerinde komut satırına nasıl ulaşılır?
Komut satırı üzerinde dizinler arasında nasıl dolaşılır?
Komut satırında bir dizinin içeriği nasıl listelenir?
Sistem komut satırı ile Python komut satırı arasındaki fark nedir?
Eğer bu temel sorulara cevap verebiliyorsanız okumaya devam edin. Ama değilse, lütfen daha fazla ilerlemeden geri dönüp eksik bilgilerinizi tamamlayın.
Yukarıdaki soruların cevabını verebildiğinizi varsayarak yolumuza devam edelim...
Python’ın Etkileşimli Kabuğu
Dediğimiz gibi, şu ana kadar öğrendiklerimiz sayesinde Python programlama dilinin farklı sistemlere nasıl kurulacağını ve nasıl çalıştırılacağını biliyoruz. Dolayısıyla Python’ı bir önceki bölümde anlattığımız şekilde çalıştırdığımız zaman şuna benzer bir ekranla karşılaşacağımızın farkındayız:
istihza@netbook:~$ # python3 Python 3.4.3 (default, 04.09.2015, 12:24:55) [GCC 4.4.7 20120313 (Red Hat 4.4.7-3)] on linux Type “help”, “copyright”, “credits” or “license” for more information. >>>
Biz şimdiye kadar bu ekrana Python komut satırı demeyi tercih ettik. Dilerseniz bundan sonra da bu adı kullanmaya devam edebilirsiniz. Ancak teknik olarak bu ekrana etkileşimli kabuk (interactive shell) adı verildiğini bilmemizde fayda var. Etkileşimli kabuk, 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. Bu ortam, özellikle Python’a yeni başlayanların bu programlama diline aşinalık kazanmasını sağlaması açısından da bulunmaz bir araçtır. Biz de bu bölümde etkileşimli kabuk üzerinde bazı çalışmalar yaparak, Python’a alışma turları atacağız.
Bu arada, geçen bölümde söylediğimiz gibi, bu ortamın sistem komut satırı adını verdiğimiz ortamdan farklı olduğunu aklımızdan çıkarmıyoruz. O zaman da dediğimiz gibi, sistem komut satırında sistem komutları, Python komut satırında (yani etkileşimli kabukta) ise Python komutları verilir. Mesela
Kod:
echo %PATH%
,
Kod:
cd Desktop
,
Kod:
dir
ve
Kod:
ls
birer sistem komutudur. Eğer bu komutları etkileşimli kabukta vermeye kalkışırsanız, bunlar birer Python komutu olmadığı için, Python size bir hata mesajı gösterecektir. Mesela Python’ın etkileşimli kabuğunda
Kod:
cd Desktop
komutunu verirseniz şöyle bir hata alırsınız:
>>> cd Desktop
File "<stdin>", line 1
cd Desktop
^
SyntaxError: invalid syntax
Çünkü
Kod:
cd Desktop
bir Python komutu değildir. O yüzden bu komutu Python’ın etkileşimli kabuğunda veremeyiz. Bu komutu ancak ve ancak kullandığımız işletim sisteminin komut satırında verebiliriz.
Ne diyorduk? Etkileşimli kabuk bir veya birkaç satırlık kodları denemek/test etmek için gayet uygun bir araçtır. İ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.
Farklı işletim sistemlerinde
Kod:
py3
,
Kod:
py -3
,
Kod:
python3
veya
Kod:
python
komutunu vererek Python’ın komut satırına nasıl erişebileceğimizi önceki derslerde ayrıntılı olarak anlatmıştık. Etkileşimli kabuğa ulaşmakta sıkıntı yaşıyorsanız eski konuları tekrar gözden geçirmenizi tavsiye ederim.
Etkileşimli kabuk üzerinde çalışmaya başlamadan önce dilerseniz önemli bir konuyu açıklığa kavuşturalım: Etkileşimli kabuğu başarıyla çalıştırdık. Peki bu kabuktan çıkmak istersek ne yapacağız? Elbette doğrudan pencere üzerindeki çarpı tuşuna basarak bu ortamı terk edebilirsiniz. Ancak bu işlemi kaba kuvvete başvurmadan yapmanın bir yolu olmalı, değil mi?
Etkileşimli kabuktan çıkmanın birkaç farklı yolu vardır:
Pencere üzerindeki çarpı düğmesine basmak (kaba kuvvet)
Önce Ctrl+Z tuşlarına, ardından da Enter tuşuna basmak (Windows)
Ctrl+Z tuşlarına basmak (GNU/Linux)
Önce F6 tuşuna, ardından da Enter tuşuna basmak (Windows)
quit()
yazıp Enter tuşuna basmak (Bütün işletim sistemleri)
import sys; sys.exit()
komutunu vermek (Bütün işletim sistemleri)
Siz bu farklı yöntemler arasından, kolayınıza hangisi geliyorsa onu seçebilirsiniz. Bu satırların yazarı, Windows’ta 2 numaralı; GNU/Linux’ta ise 3 numaralı seçeneği tercih ediyor.
Etkileşimli Kabukta İlk Adımlar
Python’da etkileşimli kabuğu nasıl çalıştıracağımızı ve bu ortamı nasıl terk edeceğimizi öğrendiğimize göre artık etkileşimli kabuk aracılığıyla Python programlama dilinde ilk adımlarımızı atmaya başlayabiliriz.
Şimdi kendi sistemimize uygun bir şekilde etkileşimli kabuğu tekrar çalıştıralım. Etkileşimli kabuğu çalıştırdığımızda ekranda görünen >>> işareti Python’ın 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.
Buradaki ‘hiç boşluk bırakmadan’ kısmı önemli. Python’a yeni başlayanların en sık yaptığı hatalardan biri >>> işareti ile komut arasında boşluk bırakmalarıdır. Eğer bu şekilde boşluk bırakırsanız yazdığınız kod hata verecektir.
İsterseniz basit bir deneme yapalım. >>> işaretinden hemen sonra, hiç boşluk bırakmadan şu komutu yazalım:
>>> "Merhaba Zalim Dünya!"
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 “Merhaba Zalim Dünya!” satırını yazdıktan sonra doğruca Enter düğmesine basacaksınız.
Bu komutu yazıp Enter tuşuna bastığımızda şöyle bir çıktı almış olmalıyız:
'Merhaba Zalim Dünya!'
Böylece yarım yamalak da olsa ilk Python programımızı yazmış olduk...
Muhtemelen bu kod, içinizde en ufak bir heyecan dahi uyandırmamıştır. Hatta böyle bir kod yazmak size anlamsız bile gelmiş olabilir. Ama aslında şu küçücük kod parçası bile bize Python programlama dili hakkında çok önemli ipuçları veriyor. Gelin isterseniz bu tek satırlık kodu biraz inceleyelim...
Karakter Dizilerine Giriş
Dediğimiz gibi, yukarıda yazdığımız küçücük kod parçası sizi heyecanlandırmamış olabilir, ama aslında bu kod Python programlama dili ve bu dilin yapısı hakkında çok önemli bilgileri içinde barındırıyor.
Teknik olarak söylemek gerekirse, yukarıda yazdığımız “Merhaba Zalim Dünya!” ifadesi bir karakter dizisidir. İngilizcede buna string adı verilir ve programlama açısından son derece önemli bir kavramdır bu. Kavramın adından da rahatlıkla anlayabileceğiniz gibi, bir veya daha fazla karakterden oluşan öğelere karakter dizisi (string) diyoruz.
Karakter dizileri bütün programcılık maceramız boyunca karşımıza çıkacak. O yüzden bu kavramı ne kadar erken öğrenirsek o kadar iyi.
Peki bir verinin karakter dizisi olup olmamasının bize ne faydası var? Yani yukarıdaki cümle karakter dizisi olmuş olmamış bize ne?
Python’da, o anda elinizde bulunan bir verinin hangi tipte olduğunu bilmek son derece önemlidir. Çünkü bir verinin ait olduğu tip, o veriyle neler yapıp neler yapamayacağınızı belirler. Python’da her veri tipinin belli başlı özellikleri vardır. Dolayısıyla, elimizdeki bir verinin tipini bilmezsek o veriyi programlarımızda etkin bir şekilde kullanamayız. İşte yukarıda örneğini verdiğimiz “Merhaba Zalim Dünya!” adlı karakter dizisi de bir veri tipidir. Python’da karakter dizileri dışında başka veri tipleri de bulunur. Biraz sonra başka veri tiplerini de inceleyeceğiz.
Dikkat ederseniz “Merhaba Zalim Dünya!” adlı karakter dizisini tırnak içinde gösterdik. Bu da çok önemli bir bilgidir. Eğer bu cümleyi tırnak içine almazsak programımız hata verecektir:
>>> Merhaba Zalim Dünya!
Zaten tırnak işaretleri, karakter dizilerinin ayırt edici özelliğidir. Öyle ki, Python’da tırnak içinde gösterdiğiniz her şey bir karakter dizisidir. Örneğin şu bir karakter dizisidir:
>>> "a"
Gördüğünüz gibi, tırnak içinde gösterilen tek karakterlik bir öğe de Python’da karakter dizisi sınıfına giriyor.
Mesela şu, içi boş bir karakter dizisidir:
>>> ""
Şu da içinde bir adet boşluk karakteri barındıran bir karakter dizisi...
>>> " "
Bu ikisi arasındaki farka dikkat ediyoruz: Python’da ‘boş karakter dizisi’ ve ‘bir adet boşluktan oluşan karakter dizisi’ birbirlerinden farklı iki kavramdır. Adından da anlaşılacağı gibi, boş karakter dizileri içlerinde hiçbir karakter (başka bir deyişle ‘öğe’) barındırmayan karakter dizileridir. Bir (veya daha fazla) boşluktan oluşan karakter dizileri ise içlerinde boşluk karakteri barındıran karakter dizileridir. Yani bu karakter dizilerinden biri boş, öteki ise doludur. Ama neticede her ikisi de karakter dizisidir. Şu anda oldukça anlamsız bir konu üzerinde vakit kaybediyormuşuz hissine kapılmış olabilirsiniz, ama emin olun, Python programlama diline yeni başlayanların önemli tökezleme noktalarından biridir bu söylediğimiz şey...
Dilerseniz biz karakter dizilerine elimizin alışması için birkaç örnek verelim:
>>> "Elma"
'Elma'
>>> "Guido Van Rossum"
'Guido Van Rossum'
>>> "Python programlama dili"
'Python programlama dili'
>>> "ömnhbgfgh"
'ömnhbgfgh'
>>> "$5&"
'$5&'
>>> ""
''
>>> " "
' '
>>> " "
' '
Yukarıdaki örneklerin hepsi birer karakter dizisidir. Dikkat ettiyseniz yukarıdaki karakter dizilerinin hepsinin ortak özelliği tırnak içinde gösteriliyor olmasıdır. Dediğimiz gibi, tırnak işaretleri karakter dizilerinin ayırt edici özelliğidir.
Peki bir verinin karakter dizisi olup olmadığından nasıl emin olabilirsiniz?
Eğer herhangi bir verinin karakter dizisi olup olmadığı konusunda tereddütünüz varsa,
Kod:
type()
adlı bir fonksiyondan yararlanarak o verinin tipini sorgulayabilirsiniz. Bu fonksiyonu şöyle kullanıyoruz:
>>> type("Elma")
<class 'str'>
Bu ‘fonksiyon’ kelimesinin kafanızı karıştırmasına izin vermeyin. İlerde fonksiyonları oldukça ayrıntılı bir şekilde inceleyeceğimiz için,
Kod:
type()
ifadesinin bir fonksiyon olduğunu bilmeniz şimdilik yeterli olacaktır. Üstelik fonksiyon konusunu ayrıntılı bir şekilde anlatma vakti geldiğinde siz fonksiyonlara dair pek çok şeyi zaten öğrenmiş olacaksınız.
Burada amacımız “Elma” adlı öğenin tipini denetlemek. Denetlenecek öğeyi
Kod:
type()
fonksiyonunun parantezleri arasında belirttiğimize dikkat edin. (Fonksiyonların parantezleri içinde belirtilen değerlere teknik dilde parametre adı verilir.)
Yukarıdaki çıktıda bizi ilgilendiren kısım, sondaki ‘str’ ifadesi. Tahmin edebileceğiniz gibi, bu ifade string kelimesinin kısaltmasıdır. Bu kelimenin Türkçede karakter dizisi anlamına geldiğini söylemiştik. O halde yukarıdaki çıktıya bakarak, “Elma” öğesinin bir karakter dizisi olduğunu söyleyebiliyoruz.
Kod:
type()
fonksiyonu yardımıyla kendi kendinize bazı denemeler yaparak konuyu iyice sindirmenizi tavsiye ederim. Mesela “½{656$#gfd” ifadesinin hangi sınıfa girdiğini kontrol etmekle başlayabilirsiniz.
Peki karakter dizileri ile neler yapabiliriz? Şu anda Python bilgimiz kısıtlı olduğu için karakter dizileri ile çok fazla şey yapamayız, ama ilerde bilgimiz arttıkça, karakter dizileriyle sıkı fıkı olacağız.
Esasında, henüz bilgimiz kısıtlı da olsa karakter dizileriyle yine de ufak tefek bazı şeyler yapamayacak durumda değiliz. Mesela şu anki bilgilerimizi ve görür görmez size tanıdık gelecek bazı basit parçaları kullanarak, karakter dizilerini birbirleriyle birleştirebiliriz:
>>> "istihza" + ".com"
'istihza.com'
Burada + işaretini kullanarak karakter dizilerini nasıl birleştirebildiğimize dikkat edin. İki karakter dizisini + işareti ile birleştirdiğimizde karakter dizilerinin arasında boşluk olmadığına özellikle dikkatinizi çekmek isterim. Bu durumu şu örnekte daha net görebiliriz:
>>> "Fırat" + "Özgül"
'FıratÖzgül'
Gördüğünüz gibi, bu iki karakter dizisi, arada boşluk olmadan birbiriyle bitiştirildi. Araya boşluk eklemek için birkaç farklı yöntemden yararlanabilirsiniz:
>>> "Fırat" + " " + "Özgül"
'Fırat Özgül'
Burada iki karakter dizisi arasına bir adet boşluk karakteri yerleştirdik. Aynı etkiyi şu şekilde de elde edebilirsiniz:
>>> "Fırat" + " Özgül"
Burada da Özgül karakter dizisinin başına bir adet boşluk yerleştirerek istediğimiz çıktıyı elde ettik.
Bu arada, karakter dizilerini birleştirmek için mutlaka + işareti kullanmak zorunda değilsiniz. Siz + işaretini kullanmasanız da Python sizin karakter dizilerini birleştirmek istediğinizi anlayacak kadar zekidir:
>>> "www" "." "google" "." "com"
'www.google.com'
Ancak gördüğünüz gibi, + işaretini kullandığınızda kodlarınız daha okunaklı oluyor.
+ işareti dışında karakter dizileri ile birlikte * (çarpı) işaretini de kullanabiliriz. O zaman şöyle bir etki elde ederiz:
>>> "w" * 3
'www'
>>> "yavaş " * 2
'yavaş yavaş '
>>> "-" * 10
'----------'
>>> "uzak" + " " * 5 + "çok uzak..."
'uzak çok uzak...'
Gördüğünüz gibi, çok basit parçaları bir araya getirerek karmaşık çıktılar elde edebiliyoruz. Mesela son örnekte “uzak” adlı karakter dizisine önce 5 adet boşluk karakteri (
Kod:
" " * 5
), ardından da “çok uzak...” adlı karakter dizisini ekleyerek istediğimiz çıktıyı aldık.
Burada + ve * adlı iki yeni araç görüyoruz. Bunlar aslında sayılarla birlikte kullanılan birer aritmetik işleçtir. Normalde + işleci toplama işlemleri için, * işleci ise çarpma işlemleri için kullanılır. Ama yukarıdaki örneklerde, + işaretinin ‘birleştirme’; * işaretinin ise ‘tekrarlama’ anlamından ötürü bu iki işleci bazı durumlarda karakter dizileri ile birlikte de kullanabiliyoruz. Bunların dışında bir de - (eksi) ve / (bölü) işleçleri bulunur. Ancak bu işaretleri karakter dizileri ile birlikte kullanamıyoruz.
Karakter dizilerini sonraki bir bölümde bütün ayrıntılarıyla inceleyeceğiz. O yüzden şimdilik bu konuya bir ara verelim.
Sayılara Giriş
Dedik ki, Python’da birtakım veri tipleri bulunur ve karakter dizileri de bu veri tiplerinden yalnızca biridir. Python’da karakter dizileri dışında başka veri tiplerinin de bulunduğunu söylemiştik hatırlarsanız. İşte veri tipi olarak karakter dizilerinin dışında, biraz önce aritmetik işleçler vesilesiyle sözünü ettiğimiz, bir de ‘sayı’ (number) adlı bir veri tipi vardır.
Herhalde sayıların ne anlama geldiğini tarif etmeye gerek yok. Bunlar bildiğimiz sayılardır. Mesela:
>>> 23
23
>>> 4567
4567
>>> 2.3
2.3
>>> (10+2j)
(10+2j)
Python’da sayıların farklı alt türleri bulunur. Mesela tamsayılar, kayan noktalı sayılar, karmaşık sayılar...
Yukarıdaki örnekler arasında geçen 23 ve 4567 birer tamsayıdır. İngilizcede bu tür sayılara integer adı verilir.
2.3 ise bir kayan noktalı sayıdır (floating point number veya kısaca float). Bu arada kayan noktalı sayılarda basamak ayracı olarak virgül değil, nokta işareti kullandığımıza dikkat edin.
En sonda gördüğümüz 10+2j sayısı ise bir karmaşık sayıdır (complex). Ancak eğer matematikle yoğun bir şekilde uğraşmıyorsanız karmaşık sayılar pek karşınıza çıkmaz.
Sayıları temel olarak öğrendiğimize göre etkileşimli kabuğu basit bir hesap makinesi niyetine kullanabiliriz:
>>> 5 + 2
7
>>> 25 * 25
625
>>> 5 / 2
2.5
>>> 10 - 3
7
Yukarıdaki örneklerde kullandığımız aritmetik işleçlerden biraz önce bahsetmiştik. O yüzden bunlara yabancılık çektiğinizi zannetmiyorum. Ama biz yine de bu işleçleri ve görevlerini şöylece sıralayalım:
Alıntı: İşleç
Görevi+
toplama
-
çıkarma
*
çarpma
/
bölme
Yukarıdaki örneklerde bir şey dikkatinizi çekmiş olmalı: Karakter dizilerini tanımlarken tırnak işaretlerini kullandık. Ancak sayılarda tırnak işareti yok. Daha önce de dediğimiz gibi, tırnak işaretleri karakter dizilerinin ayırt edici özelliğidir. Python’da tırnak içinde gösterdiğiniz her şey bir karakter dizisidir. Mesela şu örneklere bakalım:
>>> 34657
34657
Bu bir sayıdır. Peki ya şu?
>>> "34657"
'34657'
Bu ise bir karakter dizisidir. Dilerseniz biraz önce öğrendiğimiz
Kod:
type()
fonksiyonu yardımıyla bu verilerin tipini sorgulayalım:
>>> type(34657)
<class 'int'>
Buradaki ‘int’ ifadesi İngilizce “integer”, yani tamsayı kelimesinin kısaltmasıdır. Demek ki 34657 sayısı bir tamsayı imiş. Bir de şuna bakalım:
>>> type("34657")
<class 'str'>
Gördüğünüz gibi, 34657 sayısını tırnak içine aldığımızda bu sayı artık sayı olma özelliğini yitiriyor ve bir karakter dizisi oluyor. Şu anda bu çok önemsiz bir ayrıntıymış gibi gelebilir size, ama aslında son derece önemli bir konudur bu. Bu durumun etkilerini şu örneklerde görebilirsiniz:
>>> 23 + 65
88
Burada normal bir şekilde iki sayıyı birbiriyle topladık.
Bir de şuna bakın:
>>> "23" + "65"
'2365'
Burada ise Python iki karakter dizisini yan yana yazmakla yetindi; yani bunları birleştirdi. Python açısından “23” ve 23 birbirinden farklıdır. “23” bir karakter dizisi iken, 23 bir sayıdır. Aynı şey “65” ve 65 için de geçerlidir. Yani Python açısından “65” ile “Merhaba Zalim Dünya!” arasında hiç bir fark yoktur. Bunların ikisi de karakter dizisi sınıfına girer. Ancak 65 ile “65” birbirinden farklıdır. 65 bir sayı iken, “65” bir karakter dizisidir.
Bu bilgi, özellikle aritmetik işlemlerde büyük önem taşır. Bunu dilerseniz şu örnekler üzerinde gösterelim:
>>> 45 + "45"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
Gördüğünüz gibi, yukarıdaki kodlar hata veriyor. Bunun sebebi bir sayı (45) ile bir karakter dizisini (“45”) birbiriyle toplamaya çalışmamızdır. Asla unutmayın, aritmetik işlemler ancak sayılar arasında yapılır. Karakter dizileri ile herhangi bir aritmetik işlem yapılamaz.
Bir de şuna bakalım:
>>> 45 + 45
90
Bu kodlar ise düzgün çalışır. Çünkü burada iki sayıyı aritmetik işleme soktuk ve başarılı olduk.
Son olarak şu örneği verelim:
>>> "45" + "45"
'4545'
Burada + işlecinin toplama anlamına gelmediğine dikkat edin. Bu işleç burada iki karakter dizisini birleştirme görevi üstleniyor. Yani yukarıdaki örneğin şu örnekten hiçbir farkı yoktur:
>>> "istihza." + "com"
'istihza.com'
Bu iki örnekte de yaptığımız şey karakter dizilerini birbiriyle birleştirmektir.
Gördüğünüz gibi, + işlecinin sağındaki ve solundaki değerler birer karakter dizisi ise bu işleç bu iki değeri birbiriyle birleştiriyor. Ama eğer bu değerler birer sayı ise + işleci bu değerleri birbiriyle aritmetik olarak topluyor.
* işleci de + işlecine benzer bir iş yapar. Yani eğer * işleci bir sayı ve bir karakter dizisi ile karşılaşırsa, o karakter dizisini, verilen sayı kadar tekrarlar. Örneğin:
>>> "w" * 3
'www'
Burada * işleci bir karakter dizisi (“w”) ve bir sayı (3) arasında işlem yaptığı için, karakter dizisini, ilgili sayı kadar tekrarlıyor. Yani “w” karakter dizisini 3 kez tekrarlıyor.
Bir de şuna bakalım:
>>> 25 * 3
75
Burada ise * işleci iki adet sayı arasında işlem yaptığı için bu değerleri birbiriyle aritmetik olarak çarpıyor ve 75 değerini elde etmemizi sağlıyor.
Gördüğünüz gibi, o anda elimizde bulunan verilerin tipini bilmek gerçekten de büyük önem taşıyor. Çünkü eğer elimizdeki verilerin tipini bilmezsek nasıl sonuçlar elde edeceğimizi de kestiremeyiz.
Böylece karakter dizileri ile sayılar arasındaki farkı öğrenmiş olduk. Bu bilgiler size önemsizmiş gibi gelebilir, ama aslında karakter dizileri ile sayılar arasındaki farkı anlamak, Python programlama dilinin önemli bir bölümünü öğrenmiş olmak demektir. İleride yazacağınız en karmaşık programlarda bile, bazen programınızın çalışmamasının (veya daha kötüsü yanlış çalışmasının) nedeninin karakter dizileri ile sayıları birbirine karıştırmanız olduğunu göreceksiniz. O yüzden burada öğrendiğiniz hiçbir bilgi kırıntısını baştan savmamanızı (ve sabırsızlık ya da acelecilik etmemenizi) tavsiye ederim.
Değişkenler
Şimdi şöyle bir durum düşünün: Diyelim ki sisteme kayıt için kullanıcı adı ve parola belirlenmesini isteyen bir program yazıyorsunuz. Yazacağınız bu programda, belirlenebilecek kullanıcı adı ve parolanın toplam uzunluğu 40 karakteri geçmeyecek.
Bu programı yazarken ilk aşamada yapmanız gereken şey, kullanıcının belirlediği kullanıcı adı ve parolanın uzunluğunu tek tek denetlemek olmalı.
Mesela kullanıcı şöyle bir kullanıcı adı belirlemiş olsun:
firat_ozgul_1980
Kullanıcının belirlediği parola ise şu olsun:
rT%65#$hGfUY56123
İşte bizim öncelikle kullanıcıdan gelen bu verilerin teker teker uzunluğunu biliyor olmamız lazım, ki bu verilerin toplam 40 karakter sınırını aşıp aşmadığını denetleyebilelim.
Peki bu verilerin uzunluğunu nasıl ölçeceğiz? Elbette bunun için verilerdeki harfleri elle tek tek saymayacağız. Bunun yerine, Python programlama dilinin bize sunduğu bir aracı kullanacağız. Peki nedir bu araç?
Hatırlarsanız birkaç sayfa önce
Kod:
type()
adlı bir fonksiyondan söz etmiştik. Bu fonksiyonun görevi bir verinin hangi tipte olduğunu bize bildirmekti. İşte tıpkı
Kod:
type()
gibi, Python’da
Kod:
len()
adlı başka bir fonksiyon daha bulunur. Bu fonksiyonun görevi ise karakter dizilerinin (ve ileride göreceğimiz gibi, başka veri tiplerinin) uzunluğunu ölçmektir. Yani bu fonksiyonu kullanarak bir karakter dizisinin toplam kaç karakterden oluştuğunu öğrenebiliriz.
Biz henüz kullanıcıdan nasıl veri alacağımızı bilmiyoruz. Ama şimdilik şunu söyleyebiliriz: Python’da kullanıcıdan herhangi bir veri aldığımızda, bu veri bize bir karakter dizisi olarak gelecektir. Yani kullanıcıdan yukarıdaki kullanıcı adı ve parolayı aldığımızı varsayarsak, bu veriler bize şu şekilde gelir:
"firat_ozgul_1980"
ve:
"rT%65#$hGfUY56123"
Gördüğünüz gibi, elde ettiğimiz veriler tırnak içinde yer alıyor. Yani bunlar birer karakter dizisi. Şimdi gelin yukarıda bahsettiğimiz
Kod:
len()
fonksiyonunu kullanarak bu karakter dizilerinin uzunluğunu ölçelim.
Dediğimiz gibi,
Kod:
len()
de tıpkı
Kod:
type()
gibi bir fonksiyondur. Dolayısıyla
Kod:
len()
fonksiyonunun kullanımı
Kod:
type()
fonksiyonunun kullanımına çok benzer. Nasıl
Kod:
type()
fonksiyonu bize, kendisine verdiğimiz parametrelerin tipini söylüyorsa,
Kod:
len()
fonksiyonu da kendisine verdiğimiz parametrelerin uzunluğunu söyler.
Dikkatlice bakın:
>>> len("firat_ozgul_1980")
16
>>> len("rT%65#$hGfUY56123")
17
Demek ki “firat_ozgul_1980” adlı karakter dizisinde 16; “rT%65#$hGfUY56123” adlı karakter dizisinde ise 17 karakter varmış. Bizim istediğimiz şey bu iki değerin toplam uzunluğunun 40 karakteri aşmaması. Bunu denetlemek için yapmamız gereken şey bu iki değerin uzunluğunu birbiriyle toplamak olmalı. Yani:
>>> len("firat_ozgul_1980") + len("rT%65#$hGfUY56123")
Buradan alacağımız sonuç 33 olacaktır. Demek ki kullanıcı 40 karakter limitini aşmamış. O halde programımız bu kullanıcı adı ve parolayı kabul edebilir...
Bu arada, belki farkettiniz, belki de farketmediniz, ama burada da çok önemli bir durumla karşı karşıyayız. Gördüğünüz gibi
Kod:
len()
fonksiyonu bize sayı değerli bir veri gönderiyor. Gelin isterseniz bunu teyit edelim:
>>> type(len("firat_ozgul_1980"))
<class 'int'>
Kod:
len()
fonksiyonunun bize sayı değerli bir veri göndermesi sayesinde bu fonksiyondan elde ettiğimiz değerleri birbiriyle toplayabiliyoruz:
>>> len("firat_ozgul_1980") + len("rT%65#$hGfUY56123")
33
Eğer
Kod:
len()
fonksiyonu bize sayı değil de mesela karakter dizisi verseydi, bu fonksiyondan elde ettiğimiz değerleri yukarıdaki gibi doğrudan birbiriyle aritmetik olarak toplayamazdık. Öyle bir durumda, bu iki veriyi birbiriyle toplamaya çalıştığımızda, + işleci 16 ve 17 değerlerini birbiriyle toplamak yerine bu değerleri birbiriyle birleştirerek bize ‘1617’ gibi bir sonuç verecekti.
Her zaman söylediğimiz gibi, Python’da veri tipi kavramını çok iyi anlamak ve o anda elimizde bulunan bir verinin hangi tipte olduğunu bilmek çok önemlidir. Aksi halde programlarımızda hata yapmamız kaçınılmazdır.
Eğer yukarıda anlattığımız şeyleri kafa karıştırıcı bulduysanız hiç endişe etmeyin. Birkaç bölüm sonra
Kod:
input()
adlı bir fonksiyondan bahsettiğimizde şimdi söylediğimiz şeyleri çok daha net anlayacaksınız.
Biraz sonra
Kod:
len()
fonksiyonundan bahsetmeye devam edeceğiz, ama isterseniz ondan önce çok önemli bir konuya değinelim.
Biraz önce şöyle bir örnek vermiştik:
>>> len("firat_ozgul_1980")
Bu kodlar, istediğimiz şeyi gayet güzel yerine getiriyor. Ama sizce de yukarıdaki kodlarda çok rahatsız edici bir durum yok mu?
Dikkat ederseniz, yukarıdaki örneklerde kullandığımız verileri, program içinde her ihtiyaç duyduğumuzda tekrar tekrar yazdık. Böylece aynı program içinde iki kez “firat_ozgul_1980”; iki kez de “rT%65#$hGfUY56123” yazmak zorunda kaldık. Halbuki bu verileri programlarımızın içinde her ihtiyaç duyduğumuzda tekrar tekrar yazmak yerine bir değişkene atasak ve gerektiğinde o değişkeni kullansak çok daha iyi olmaz mı? Herhalde olur...
Peki nedir bu değişken dediğimiz şey?
Python’da bir program içinde değerlere verilen isimlere değişken denir. Hemen bir örnek verelim:
>>> n = 5
Burada 5 sayısını bir değişkene atadık. Değişkenimiz ise n. Ayrıca 5 sayısını bir değişkene atamak için = işaretinden yararlandığımıza da çok dikkat edin. Buradan, = işaretinin Python programlama dilinde değer atama işlemleri için kullanıldığı sonucunu çıkarıyoruz.
Kod:
n = 5
gibi bir komut yardımıyla 5 değerini n adlı değişkene atamamız sayesinde artık ne zaman 5 sayısına ihtiyaç duysak bu n değişkenini çağırmamız yeterli olacaktır:
>>> n
5
>>> n * 10
50
>>> n / 2
2.5
Gördüğünüz gibi, 5 değerini bir değişkene atadıktan sonra, bu 5 değerini kullanmamız gereken yerlerde sadece değişkenin adını kullandığımızda değişkenin değerini Python otomatik olarak yerine koyabiliyor. Yani
Kod:
n = 5
komutuyla n adlı bir değişken tanımladıktan sonra, artık ne zaman 5 sayısına ihtiyaç duysak n değişkenini çağırmamız yeterli olacaktır. Python o 5 değerini otomatik olarak yerine koyar.
Şimdi de pi adlı başka bir değişken tanımlayalım:
>>> pi = 3.14
Bu pi değişkeninin değeri ile n değişkeninin değerini toplayalım:
>>> pi + n
8.14
Gördüğünüz gibi, değerleri her defasında tekrar yazmak yerine bunları bir değişkene atayıp, gereken yerde bu değişkeni kullanmak çok daha pratik bir yöntem.
Aynı şeyi programımız için de yapabiliriz:
>>> kullanıcı_adı = "firat_ozgul_1980"
>>> parola = "rT%65#$hGfUY56123"
= işaretini kullanarak ilgili değerlere artık birer ad verdiğimiz, yani bu değerleri birer değişkene atadığımız için, bu değerleri kullanmamız gereken yerlerde değerlerin kendisini uzun uzun yazmak yerine, belirlediğimiz değişken adlarını kullanabiliriz. Mesela:
>>> len(kullanıcı_adı)
Gördüğünüz gibi, değişken kullanımı işlerimizi bir hayli kolaylaştırıyor.
Değişken Adı Belirleme Kuralları
Python programlama dilinde, değişken adı olarak belirleyebileceğimiz kelime sayısı neredeyse sınırsızdır. Yani hemen hemen her kelimeyi değişken adı olarak kullanabiliriz. Ama yine de değişken adı belirlerken dikkat etmemiz gereken bazı kurallar var. Bu kuralların bazıları zorunluluk, bazıları ise yalnızca tavsiye niteliğindedir.
Şimdi bu kuralları tek tek inceleyelim:
1. Değişken adları bir sayı ile başlayamaz. Yani şu kullanım yanlıştır:
>>> 3_kilo_elma = "5 TL"
2. Değişken adları aritmetik işleçlerle başlayamaz. Yani şu kullanım yanlıştır:
>>> +değer = 4568
3. Değişken adları ya bir alfabe harfiyle ya da _ işaretiyle başlamalıdır:
>>> _değer = 4568
>>> değer = 4568
4. Değişken adları içinde Türkçe karakterler kullanabilirsiniz. Ancak ileride beklenmedik uyum sorunları çıkması ihtimaline karşı değişken adlarında Türkçe karakter kullanmaktan kaçınmak isteyebilirsiniz.
5. Aşağıdaki kelimeleri değişken adı olarak kullanamazsınız:
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class',
'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for',
'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not',
'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
Bunlar Python’da özel anlam ifade eden kelimelerdir. Etkileşimli kabuk zaten bu kelimeleri değişken adı olarak kullanmanıza izin vermez. Örneğin:
>>> elif = "hoş kız"
File "<stdin>", line 1
as = "kare"
^
SyntaxError: invalid syntax
>>> False = 45
File "<stdin>", line 1
SyntaxError: assignment to keyword
Ama ilerde göreceğimiz gibi, programlarınızı bir dosyaya yazarken bu kelimeleri değişken adı olarak kullanmaya çalışırsanız programınız tespit etmesi çok güç hatalar üretecektir.
Bu arada elbette yukarıdaki listeyi bir çırpıda ezberlemeniz beklenmiyor sizden. Python programlama dilini öğrendikçe özel kelimeleri bir bakışta tanıyabilecek duruma geleceksiniz. Ayrıca eğer isterseniz şu komutları vererek, istediğiniz her an yukarıdaki listeye ulaşabilirsiniz:
>>> import keyword
>>> keyword.kwlist
Size bir soru: Acaba bu listede kaç tane kelime var?
Bu soru karşısında listedeki kelimeleri tek tek elle saymaya kalkışan arkadaşlarıma teessüflerimi iletiyorum... Bu tür işler için hangi aracı kullanabileceğimizi artık çok iyi biliyor olmalısınız:
>>> len(keyword.kwlist)
33
Bu kodları şöyle yazabileceğimizi de biliyorsunuz:
>>> yasaklı_kelimeler = keyword.kwlist
>>> len(yasaklı_kelimeler)
33
Bu arada, yukarıdaki kodların bir kısmını henüz anlayamamış olabilirsiniz. Hiç endişe etmeyin. Yukarıdaki kodları vermemizin sebebi değişken adı olarak kullanılamayacak kelimelere kısa yoldan nasıl ulaşabileceğinizi gösterebilmek içindir. Bir-iki bölüm sonra burada yazdığımız kodları rahatlıkla anlayabilecek düzeye geleceksiniz.
Yukarıda verdiğimiz kodların çıktısından anladığımıza göre, toplam 33 tane kelime varmış değişken adı belirlerken kullanmaktan kaçınmamız gereken...
6. Yukarıdaki kelimeler dışında, Python programlama diline ait fonksiyon ve benzeri araçların adlarını da değişken adı olarak kullanmamalısınız. Örneğin yazdığınız programlarda değişkenlerinize type veya len adı vermeyin. Çünkü ‘type’ ve ‘len’ Python’a ait iki önemli fonksiyonun adıdır. Eğer mesela bir değişkene type adını verirseniz, o programda artık
Kod:
type()
fonksiyonunu kullanamazsınız:
>>> type = 3456
Bu örnekte type adında bir değişken tanımladık. Şimdi mesela “elma” kelimesinin tipini denetlemek için
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable
Gördüğünüz gibi, artık
Kod:
type()
fonksiyonu çalışmıyor. Çünkü siz ‘type’ kelimesini bir değişken adı olarak kullanarak,
Kod:
type()
fonksiyonunu kullanılamaz hale getirdiniz.
Bu durumdan kurtulmak için etkileşimli kabuğu kapatıp tekrar açabilirsiniz. Ya da eğer etkileşimli kabuğu kapatmak istemiyorsanız şu komut yardımıyla type değişkenini ortadan kaldırmayı da tercih edebilirsiniz:
>>> del type
Böylece, (tahmin edebileceğiniz gibi delete (silmek) kelimesinin kısaltması olan)
Kod:
del
komutuyla type değişkenini silmiş oldunuz. Artık ‘type’ kelimesi yine
Kod:
type()
fonksiyonunu çağıracak:
>>> type("elma")
<class 'str'>
7. Değişken adlarını belirlerken, değişkeni oluşturan kelimeler arasında boşluk bırakılamaz. Yani şu kullanım yanlıştır:
>>> kullanıcı adı = "istihza"
Yukarıdaki değişkeni şu şekilde tanımlayabiliriz:
>>> kullanıcı_adı = "istihza"
Ya da şöyle:
>>> kullanıcıAdı = "istihza"
8. Değişken adları belirlerken, değişken adının, değişkenin değerini olabildiğince betimlemesine dikkat etmemiz kodlarımızın okunaklılığını artıracaktır. Örneğin:
>>> personel_sayısı = 45
Yukarıdaki, tanımladığı değere uygun bir değişken adıdır. Şu ise kurallara uygun bir değişken adı olsa da yeterince betimleyici değildir:
>>> sayı = 45
9. Değişken adları ne çok kısa, ne de çok uzun olmalıdır. Mesela şu değişken adı, kodları okuyan kişiye, değişken değerinin anlamı konusunda pek fikir vermez:
>>> a = 345542353
Şu değişken adı ise gereksiz yere uzundur:
>>> türkiye_büyük_millet_meclisi_milletvekili_sayısı = 550
Yukarıda verdiğimiz bütün bu örnekler bize, Python’da değişkenlerin, değerlere atanmış adlardan ibaret olduğunu gösteriyor. Değişkenler, yazdığımız programlarda bize çok büyük kolaylık sağlar. Mesela 123432456322 gibi bir sayıyı ya da “Türkiye Cumhuriyeti Çalışma ve Sosyal Güvenlik Bakanlığı” gibi bir karakter dizisini gerektiği her yerde tek tek elle yazmak yerine, bunları birer değişkene atayarak, gerektiğinde sadece bu değişken adını kullanmak çok daha mantıklı bir iştir.
Ayrıca zaten ileride kullanıcıdan veri almaya başladığınızda, aldığınız bu verileri, yazdığınız programda kullanabilmek için mutlaka bir değişkene atamanız gerekecek. O yüzden Python’daki değişken kavramını şimdiden iyi tanıyıp anlamakta büyük fayda var.
Uygulama Örnekleri
Gelin isterseniz yukarıda verdiğimiz bilgileri pekiştirmek için birkaç ufak alıştırma yapalım, alıştırma yaparken de sizi yine Python programlama diline ilişkin çok önemli bazı yeni bilgilerle tanıştıralım.
Diyelim ki aylık yol masrafımızı hesaplayan bir program yazmak istiyoruz. Elimizdeki verilerin şunlar olduğunu varsayalım:
Cumartesi-Pazar günleri çalışmıyoruz.
Dolayısıyla ayda 22 gün çalışıyoruz.
Evden işe gitmek için kullandığımız vasıtanın ücreti 1.5 TL
İşten eve dönmek için kullandığımız vasıtanın ücreti 1.4 TL
Aylık yol masrafımızı hesaplayabilmek için gidiş ve dönüş ücretlerini toplayıp, bunları çalıştığımız gün sayısıyla çarpmamız yeterli olacaktır. Elimizdeki bu bilgilere göre aylık yol masrafımızı hesaplamak için şöyle bir formül üretebiliriz:
masraf = gün sayısı x (gidiş ücreti + dönüş ücreti)
Dilerseniz hemen bunu bir Python programı haline getirelim:
>>> 22 * (1.5 + 1.4)
63.8
Demek ki bir ayda 63.8 TL’lik bir yol masrafımız varmış.
Bu arada, yukarıdaki örnekte bir şey dikkatinizi çekmiş olmalı. Aritmetik işlemi yaparken bazı sayıları parantez içine aldık. Python’da aritmetik işlemler yapılırken alıştığımız matematik kuralları geçerlidir. Yani mesela aynı anda bölme, çıkarma, toplama ve çarpma işlemleri yapılacaksa işlem öncelik sırası önce bölme ve çarpma, sonra toplama ve çıkarma şeklinde olacaktır. Elbette siz parantezler yardımıyla bu işlem sırasını değiştirebilirsiniz.
Bu anlattıklarımıza göre, eğer yukarıda yol masrafını hesaplayan programda parantezleri kullanmazsak, işlem öncelik kuralları gereğince Python önce 22 ile 1.5‘i çarpıp, çıkan sonucu 1.4 ile toplayacağı için elde ettiğimiz sonuç yanlış çıkacaktır. Bizim burada doğru sonuç alabilmemiz için önce 1.5 ile 1.4‘ü toplamamız, çıkan sonucu da 22 ile çarpmamız gerekiyor. Bu sıralamayı da parantezler yardımıyla elde ediyoruz.
Yine dikkat ederseniz, yukarıdaki örnek programda aslında çok verimsiz bir yol izledik. Gördüğünüz gibi, bu programda bütün değerleri tek tek elle kendimiz giriyoruz. Örneğin çalışılan gün sayısına karşılık gelen 22 değerini başka bir yerde daha kullanmak istesek aynı sayıyı tekrar elle doğrudan kendimiz girmek zorundayız. Mesela yılda kaç gün çalıştığımızı hesaplayalım:
>>> 22 * 12
264
Gördüğünüz gibi, burada da 22 sayısına ihtiyaç duyduk. Aslında değerleri bu şekilde her defasında tekrar tekrar elle girmek hem hata yapma riskini artırdığı, hem de bize fazladan iş çıkardığı için tercih edilmeyen bir yöntemdir. Bunun yerine, 22 sayısına bir isim verip, gereken yerlerde bu ismi kullanmak daha mantıklı olacaktır. Yani tıpkı kullanıcı ve parola örneğinde olduğu gibi, burada da verileri öncelikle bir değişkene atamak çok daha akıllıca bir iştir:
>>> gün = 22
>>> gidiş_ücreti = 1.5
>>> dönüş_ücreti = 1.4
>>> gün * (gidiş_ücreti + dönüş_ücreti)
63.8
Bütün değerleri birer değişkene atadığımız için, artık bu değişkenleri istediğimiz yerde kullanabiliriz. Mesela yılda toplam kaç gün çalıştığımızı bulmak istersek, ilgili değeri elle yazmak yerine, yukarıda tanımladığımız gün değişkenini kullanabiliriz:
>>> gün * 12
264
İlerleyen zamanda aylık çalışılan gün sayısı değişirse sadece gün değişkeninin değerini değiştirmemiz yeterli olacaktır:
>>> gün = 23
>>> gün * (gidiş_ücreti + dönüş_ücreti)
66.7
>>> gün * 12
276
Eğer bu şekilde değişken atamak yerine, değerleri gerektiği her yerde elle yazsaydık, bu değerlerde herhangi bir değişiklik yapmamız gerektiğinde program içinde geçen ilgili bütün değerleri bulup tek tek değiştirmemiz gerekecekti:
>>> 23 * (1.6 + 1.5)
71.3
>>> 23 * 12
276
Değişken kavramı şu anda gözünüze pek anlamlı görünmemiş olabilir. Ama programlarımızı ilerde dosyaya kaydettiğimiz zaman bu değişkenler çok daha kullanışlı araçlar olarak karşımıza çıkacaktır.
Dilerseniz bir örnek daha yaparak yukarıdaki bilgilerin kafamıza iyice yerleşmesiniz sağlayalım. Mesela bir dairenin alanını (yaklaşık olarak) hesaplayan bir program yazalım.
Öncelikle çap adlı bir değişken tanımlayarak dairenin çapını belirleyelim:
>>> çap = 16
Bu değeri kullanarak dairemizin yarıçapını hesaplayabiliriz. Bunun için çap değişkeninin değerinin yarısını almamız yeterli olacaktır:
>>> yarıçap = çap / 2
pi sayısını 3.14159 olarak alalım.
>>> pi = 3.14159
Bir dairenin alan formülü (pi)r2‘dir:
>>> alan = pi * (yarıçap * yarıçap)
Son olarak alan değişkeninin değerini ekrana yazdırabiliriz:
>>> alan
201.06176
Böylece bir dairenin alanını yaklaşık olarak hesaplamış olduk. Dilerseniz programımızı bir de derli toplu olarak görelim:
>>> çap = 16
>>> yarıçap = çap / 2
>>> pi = 3.14159
>>> alan = pi * (yarıçap * yarıçap)
>>> alan
201.06176
Görüyorsunuz ya, değişkenler işimizi nasıl da kolaylaştırıyor. Eğer yukarıdaki programda değişken kullanmasaydık kodlarımız şöyle görünecekti:
>>> 3.14159 * ((16/2) * (16/2))
201.06176
Bu kodlar tek kullanımlıktır. Eğer yukarıdaki örnekte mesela dairenin çapını değiştirmeniz gerekirse, iki yerde elle değişiklik yapmanız gerekir. Ama değişkenleri kullandığımızda sadece çap değişkeninin değerini değiştirmeniz yeterli olacaktır. Ayrıca değişken kullanmadığınızda, ilgili değeri program boyunca aklınızda tutmanız gerekir. Örneğin çap değişkenini kullanmak yerine, gereken her yerde 16 değerini kullanacaksanız, bu 16 değerini sürekli aklınızda tutmanız lazım. Ama bu değeri en başta bir değişkene atarsanız, 16 değerini kullanmanız gereken yerlerde, akılda tutması daha kolay bir ifade olan çap ismini kullanabilirsiniz.
Bu arada yeri gelmişken sizi yeni bir işleçle daha tanıştıralım. Şimdiye kadar Python’da toplama (+), çıkarma (-), çarpma (*), bölme (/) ve değer atama (=) işleçlerini gördük. Ama yukarıda verdiğimiz son örnek, başka bir işleç daha öğrenmemizi gerektiriyor...
Yukarıdaki şu örneğe tekrar bakalım:
alan = pi * (yarıçap * yarıçap)
Burada yarıçap değişkeninin karesini alabilmek için bu değeri kendisiyle çarptık. Aslında gayet mantıklı ve makul bir yöntem. Kare bulmak için değeri kendisiyle çarpıyoruz. Eğer bir sayının küpünü bulmak isteseydik o sayıyı üç kez kendisiyle çarpacaktık:
>>> 3 * 3 * 3
27
Peki ya bir sayının mesela beşinci kuvvetini hesaplamak istersek ne yapacağız? O sayıyı beş kez kendisiyle mi çarpacağız? Bu ne kadar vasat bir yöntem, değil mi?
Elbette bir sayının herhangi bir kuvvetini hesaplamak için o sayıyı kendisiyle kuvvetince çarpmayacağız. Python’da bu tür ‘kuvvet hesaplamaları’ için ayrı bir işleç (ve fonksiyon) bulunur.
Öncelikle kuvvet hesaplarını yapmamızı sağlayan işleçten söz edelim.
Python’da ** adlı bir işleç bulunur. Bu işlecin görevi bir sayının kuvvetini hesaplamamızı sağlamaktır. Örneğin bir sayının 2. kuvvetini, ya da başka bir deyişle karesini hesaplamak istersek şöyle bir kod yazabiliriz:
>>> 12 ** 2
144
Burada 12 sayısının 2. kuvvetini, yani karesini hesapladık. Bu bilgiyi yukarıdaki formüle uygulayalım:
>>> alan = pi * (yarıçap ** 2)
Bu işleci herhangi bir sayının herhangi bir kuvvetini hesaplamak için kullanabiliriz elbette. Mesela 23 sayısının küpünü (yani 3. kuvvetini) hesaplayalım:
>>> 23 ** 3
12167
Aynı işleçten, bir sayının karekökünü hesaplamak için de yararlanabilirsiniz. Neticede bir sayının 0.5‘inci kuvveti, o sayının kareköküdür:
>>> 144 ** 0.5
12.0
Gördüğünüz gibi, kuvvet hesaplama işlemleri için bu işleç son derece kullanışlı bir araç vazifesi görüyor. Ama eğer istersek aynı iş için özel bir fonksiyondan da yararlanabiliriz. Bu fonksiyonun adı
Kod:
pow()
.
Peki bu fonksiyonu nasıl kullanacağız?
Daha önce öğrendiğimiz
Kod:
type()
ve
Kod:
len()
fonksiyonlarını nasıl kullanıyorsak
Kod:
pow()
fonksiyonu da aynı şekilde kullanacağız.
Kod:
type()
ve
Kod:
len()
fonksiyonlarını birtakım parametreler ile birlikte kullanıyorduk hatırlarsanız. Aynı şekilde
Kod:
pow()
fonksiyonu da birtakım parametreler alır.
Daha önce öğrendiğimiz fonksiyonları tek bir parametre ile birlikte kullanmıştık.
Kod:
pow()
fonksiyonu ise toplam üç farklı parametre alır. Ama genellikle bu fonksiyon yalnızca iki parametre ile kullanılır.
Bu fonksiyonu şöyle kullanıyoruz:
>>> pow(12, 2)
144
>>> pow(23, 3)
12167
>>> pow(144, 0.5)
12.0
Gördüğünüz gibi,
Kod:
pow()
fonksiyonunun ilk parametresi asıl sayıyı, ikinci parametresi ise bu sayının hangi kuvvetini hesaplamak istediğimizi gösteriyor.
Bu arada, fonksiyonun parantezleri içinde belirttiğimiz parametreleri birbirinden virgül ile ayırdığımızı gözden kaçırmayın.
Dediğimiz gibi,
Kod:
pow()
fonksiyonu, pek kullanılmayan üçüncü bir parametre daha alır. Bu fonksiyonun üçüncü parametresi şöyle kullanılır. Dikkatlice bakın:
>>> pow(16, 2, 2)
0
Bu komut şu anlama gelir:
Alıntı:16 sayısının 2‘nci kuvvetini hesapla ve çıkan sayıyı 2‘ye bölüp, bölme işleminden kalan sayıyı göster!
16 sayısının 2. kuvveti 256 sayısıdır. 256 sayısını 2‘ye böldüğümüzde, bölme işleminin kalanı 0‘dır. Yani 256 sayısı 2‘ye tam bölünür...
Bir örnek daha verelim:
>>> pow(11, 3, 4)
3
Demek ki, 11 sayısının 3. kuvveti olan 1331 sayısı 4‘e bölündüğünde, bölme işleminden kalan sayı 3 imiş...
Dediğimiz gibi,
Kod:
pow()
fonksiyonu genellikle sadece iki parametre ile kullanılır. Üçüncü parametrenin kullanım alanı oldukça dardır.
Değişkenlere Dair Bazı İpuçları
Değişkenin ne demek olduğunu öğrendiğimize göre, değişkenlere dair bazı ufak ipuçları verebiliriz.
Aynı Değere Sahip Değişkenler Tanımlama
Şimdi size şöyle bir soru sormama izin verin: Acaba aynı değere sahip iki değişkeni nasıl tanımlayabiliriz? Yani mesela değeri 4 sayısı olan iki farklı değişkeni nasıl belirleyeceğiz?
Aklınıza şöyle bir çözüm gelmiş olabilir:
>>> a = 4
>>> b = 4
Böylece ikisi de 4 değerine sahip a ve b adlı iki farklı değişken tanımlamış olduk. Bu tamamen geçerli bir yöntemdir. Ancak Python’da bu işlemi yapmanın daha kolay bir yolu var. Bakalım:
>>> a = b = 4
Bu kodlar bir öncekiyle tamamen aynı işlevi görür. Yani her iki kod da 4 değerine sahip a ve b değişkenleri tanımlamamızı sağlar:
>>> a
4
>>> b
4
Bu bilgiyi kullanarak mesela bir yıl içindeki her bir ayın çektiği gün sayısını ay adlarına atayabilirsiniz:
>>> ocak = mart = mayıs = temmuz = ağustos = ekim = aralık = 31
>>> nisan = haziran = eylül = kasım = 30
>>> şubat = 28
Böylece bir çırpıda değeri 31 olan yedi adet değişken, değeri 30 olan dört adet değişken, değeri 28 olan bir adet değişken tanımlamış olduk. Bu değişkenlerin değerine nasıl ulaşacağınızı biliyorsunuz:
>>> ocak
31
>>> haziran
30
>>> şubat
28
>>> mayıs
31
>>> ekim
31
>>> eylül
30
Eğer Python’ın aynı anda birden fazla değişkene tek bir değer atama özelliği olmasaydı yukarıdaki kodları şöyle yazmamız gerekirdi:
>>> ocak = 31
>>> şubat = 28
>>> mart = 31
>>> nisan = 30
>>> mayıs = 31
>>> haziran = 30
>>> temmuz = 31
>>> ağustos = 31
>>> eylül = 30
>>> ekim = 31
>>> kasım = 30
>>> aralık = 31
Bu değişkenleri nasıl bir program içinde kullanacağınız tamamen sizin hayal gücünüze kalmış. Mesela bu değişkenleri kullanarak aylara göre doğalgaz faturasını hesaplayan bir program yazabiliriz.
Hemen son gelen doğalgaz faturasını (örn. Mart ayı) elimize alıp inceliyoruz ve bu faturadan şu verileri elde ediyoruz:
Mart ayı doğalgaz faturasına göre sayaçtan ölçülen hacim 346 m3. Demek ki bir ayda toplam 346 m3 doğalgaz harcamışız.
Fatura tutarı 273.87 TL imiş. Yani 346 m3 doğalgaz tüketmenin bedeli 273.87 TL. Buna göre değişkenlerimizi tanımlayalım:
>>> aylık_sarfiyat = 346
>>> fatura_tutarı = 273.87
Bu bilgiyi kullanarak doğalgazın birim fiyatını hesaplayabiliriz. Formülümüz şöyle olmalı:
>>> birim_fiyat = fatura_tutarı / aylık_sarfiyat
>>> birim_fiyat
0.7915317919075144
Demek ki doğalgazın m3 fiyatı (vergilerle birlikte yaklaşık) 0.79 TL’ye karşılık geliyormuş.
Bu noktada günlük ortalama doğalgaz sarfiyatımızı da hesaplamamız gerekiyor:
>>> günlük_sarfiyat = aylık_sarfiyat / mart
>>> günlük_sarfiyat
11.161290322580646
Demek ki Mart ayında günlük ortalama 11 m3 doğalgaz tüketmişiz.
Bütün bu bilgileri kullanarak Nisan ayında gelecek faturayı tahmin edebiliriz:
>>> nisan_faturası = birim_fiyat * günlük_sarfiyat * nisan
>>> nisan_faturası
265.03548387096777
Şubat ayı faturası ise şöyle olabilir:
>>> şubat_faturası = birim_fiyat * günlük_sarfiyat * şubat
>>> şubat_faturası
247.36645161290326
Burada farklı değişkenlerin değerini değiştirerek daha başka işlemler de yapabilirsiniz. Örneğin pratik olması açısından günlük_sarfiyat değişkeninin değerini 15 yaparak hesaplamalarınızı buna göre güncelleyebilirsiniz.
Gördüğünüz gibi, aynı anda birden fazla değişken tanımlayabilmek işlerimizi epey kolaylaştırıyor.
Değişkenlerle ilgili bir ipucu daha verelim...
Değişkenlerin Değerini Takas Etme
Diyelim ki, işyerinizdeki personelin unvanlarını tuttuğunuz bir veritabanı var elinizde. Bu veritabanında şuna benzer ilişkiler tanımlı:
>>> osman = "Araştırma Geliştirme Müdürü"
>>> mehmet = "Proje Sorumlusu"
İlerleyen zamanda işvereniniz sizden Osman ve Mehmet’in unvanlarını değiştirmenizi talep edebilir. Yani Osman’ı Proje Sorumlusu, Mehmet’i de Araştırma Geliştirme Müdürü yapmanızı isteyebilir sizden.
Patronunuzun bu isteğini Python’da çok rahat bir biçimde yerine getirebilirsiniz. Dikkatlice bakın:
>>> osman, mehmet = mehmet, osman
Böylece tek hamlede bu iki kişinin unvanlarını takas etmiş oldunuz. Gelin isterseniz değişkenlerin son durumuna bakalım:
>>> osman
'Proje Sorumlusu
>>> mehmet
'Araştırma Geliştirme Müdürü'
Gördüğünüz gibi, osman değişkeninin değerini mehmet‘e; mehmet değişkeninin değerini ise osman‘a başarıyla verebilmişiz.
Yukarıdaki yöntem Python’ın öteki diller üzerinde önemli bir üstünlüğüdür. Başka programlama dillerinde bu işlemi yapmak için geçici bir değişken tanımlamanız gerekir. Yani mesela:
>>> osman = "Araştırma Geliştirme Müdürü"
>>> mehmet = "Proje Sorumlusu"
Elimizdeki değerler bunlar. Biz şimdi Osman’ın değerini Mehmet’e; Mehmet’in değerini ise Osman’a aktaracağız. Bunun için öncelikle bir geçici değişken tanımlamalıyız:
>>> geçici = "Proje Sorumlusu"
Bu sayede “Proje Sorumlusu” değerini yedeklemiş olduk. Bu işlem sayesinde, takas sırasında bu değeri kaybetmeyeceğiz.
Şimdi Osman’ın değerini Mehmet’e aktaralım:
>>> mehmet = osman
Şimdi elimizde iki tane Araştırma Geliştirme Müdürü olmuş oldu:
>>> mehmet
'Araştırma Geliştirme Müdürü'
>>> osman
'Araştırma Geliştirme Müdürü'
Gördüğünüz gibi,
Kod:
mehmet = osman
kodunu kullanarak mehmet değişkeninin değerini osman değişkeninin değeriyle değiştirdiğimiz için “Proje Sorumlusu” değeri ortadan kayboldu. Ama biz önceden bu değeri geçici adlı değişkene atadığımız için bu değeri kaybetmemiş olduk. Şimdi Osman’a geçici değişkeni içinde tuttuğumuz “Proje Sorumlusu” değerini verebiliriz:
>>> osman = geçici
Böylece istediğimiz takas işlemini gerçekleştirmiş olduk. Son durumu kontrol edelim:
>>> osman
'Proje Sorumlusu
>>> mehmet
'Araştırma Geliştirme Müdürü'
Basit bir işlem için ne kadar büyük bir zaman kaybı, değil mi? Ama dediğimiz gibi, Python’da bu şekilde geçici bir değişken atamakla uğraşmamıza hiç gerek yok. Sadece şu formülü kullanarak değişkenlerin değerini takas edebiliriz:
a, b = b, a
Bu şekilde a değişkeninin değerini b değişkenine; b değişkeninin değerini ise a değerine vermiş oluyoruz. Eğer bu işlemi geri alıp her şeyi eski haline döndürmek istersek, tahmin edebileceğiniz gibi yine aynı yöntemden yararlanabiliriz:
b, a = a, b
Böylece değişkenler konusunu da oldukça ayrıntılı bir şekilde incelemiş olduk. Ayrıca bu esnada
Kod:
len()
ve
Kod:
pow()
adlı iki yeni fonksiyon ile ** adlı bir işleç de öğrendik.
Hazır lafı geçmişken,
Kod:
len()
fonksiyonunun bazı kısıtlamalarından söz edelim. Dediğimiz gibi, bu fonksiyonu kullanarak karakter dizileri içinde toplam kaç adet karakter bulunduğunu hesaplayabiliyoruz. Örneğin:
>>> kelime = "muvaffakiyet"
>>> len(kelime)
12
Yalnız bu
Kod:
len()
fonksiyonunu sayıların uzunluğunu ölçmek için kullanamıyoruz:
>>> len(123456)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: object of type 'int' has no len()
Gördüğünüz gibi,
Kod:
len()
fonksiyonu, şu ana kadar öğrendiğimiz veri tipleri arasında yalnızca karakter dizileri ile birlikte kullanılabiliyor. Bu fonksiyonu sayılarla birlikte kullanamıyoruz.
Bu bölümün başında, o anda elimizde bulunan bir verinin tipini bilmemizin çok önemli olduğunu ve Python’da bir verinin tipinin, o veri ile neler yapıp neler yapamayacağınızı belirlediğini söylediğimizi hatırlıyorsunuz, değil mi? İşte
Kod:
len()
fonksiyonu bu duruma çok güzel bir örnektir.
Kod:
len()
fonksiyonu sayılarla birlikte kullanılamaz. Dolayısıyla eğer elinizdeki verinin bir sayı olduğunu bilmezseniz, bu sayıyı
Kod:
len()
fonksiyonu ile birlikte kullanmaya çalışabilir ve bu şekilde programınızın hata vererek çökmesine yol açabilirsiniz.
Ayrıca daha önce de söylediğimiz gibi,
Kod:
len()
fonksiyonunu doğru kullanabilmek için, bu fonksiyonun bize sayı değerli bir çıktı verdiğini de bilmemiz gerekir.
Kod:
len()
fonksiyonu ile ilgili bu durumu da bir kenara not ettikten sonra yolumuza kaldığımız yerden devam edelim.
Etkileşimli Kabuğun Hafızası
Bir önceki bölümde Python’ın etkileşimli kabuğunun nasıl kullanılacağına dair epey örnek verdik ve etkileşimli kabuk üzerinden Python’ın bazı temel araçlarına kısa bir giriş yaptık. Şimdi isterseniz yeri gelmişken Python’ın etkileşimli kabuğunun bir başka yeteneğinden daha söz edelim.
Etkileşimli kabukta _ adlı işaret (alt çizgi işareti), yapılan son işlemin veya girilen son öğenin değerini tutma işlevi görür. Yani:
>>> 2345 + 54355
56700
Eğer bu işlemin ardından
Kod:
_
komutunu verirsek şöyle bir çıktı alırız:
>>> _
56700
Gördüğünüz gibi,
Kod:
_
komutu son girilen öğeyi hafızasında tutuyor. Bu özellikten çeşitli şekillerde yararlanabilirsiniz:
>>> _ + 15
56715
Burada
Kod:
_
komutunun değeri bir önceki işlemin sonucu olan 56715 değeri olduğu için,
Kod:
_
komutuna 15 eklediğimizde 56715 değerini elde ediyoruz.
Kod:
_
komutunun değerini tekrar kontrol edelim:
>>> _
56715
Gördüğünüz gibi,
Kod:
_
komutunun değeri artık 56715 sayısıdır...
Kod:
_
komutu yalnızca sayıları değil, karakter dizilerini de hafızasında tutabilir:
>>> "www"
'www'
>>> _
'www'
>>> _ + ".istihza.com"
'www.istihza.com'
Bu işaret öyle çok sık kullanılan bir araç değildir, ama zaman zaman işinizi epey kolaylaştırır. Yalnız, unutmamamız gereken şey, bu özelliğin sadece etkileşimli kabuk ortamında geçerli olmasıdır.
Kod:
_
komutunun etkileşimli kabuk ortamı dışında herhangi bir geçerliliği yoktur.
Aslında burada söylenecek daha çok şey var. Ama biz şimdilik bunları sonraki konulara bırakacağız. Zira bu bölümdeki amacımız size konuların her ayrıntısını vermekten ziyade, Python’a ısınmanızı sağlamaktır.
GNU/Linux Kullanıcıları
Geçen bölümlerde gördüğünüz gibi, Python3’ü GNU/Linux sistemleri üzerine farklı şekillerde kurabiliyoruz. Bu bölümde, her bir kurulum türü için Python3’ün nasıl çalıştırılacağını ayrı ayrı inceleyeceğiz.
Kurulu Python3’ü Kullananlar
Eğer sisteminizde zaten Python3 kurulu ise komut satırında yalnızca şu komutu vererek Python3’ü başlatabilirsiniz:
python
Ancak daha önce de dediğimiz gibi, 04.09.2015 tarihi itibariyle pek çok GNU/Linux dağıtımında öntanımlı olarak Python2 kuruludur. Dolayısıyla
Kod:
python
komutunu verdiğinizde çalışan sürüm muhtemelen Python2 olacaktır. Bu yüzden sistemimizde öntanımlı olarak hangi sürümün kurulu olduğuna ve
Kod:
python
komutunun hangi sürümü başlattığına çok dikkat etmelisiniz.
Yine daha önce de söylediğimiz gibi, sisteminizde hem Python2 hem de Python3 zaten kurulu durumda olabilir. O yüzden yukarıdaki komutu bir de
Kod:
python3
şeklinde vermeyi deneyebilirsiniz.
Örneğin Ubuntu GNU/Linux dağıtımının 12.10 sürümünden itibaren
Kod:
python
komutu Python2’yi;
Kod:
python3
komutu ise Python3’ü çalıştırıyor.
Python3’ü Depodan Kuranlar
Dediğimiz gibi, 04.09.2015 tarihi itibariyle GNU/Linux dağıtımlarında öntanımlı Python sürümü ağırlıklı olarak Python2’dir. Dolayısıyla
Kod:
python
komutu Python’ın 2.x sürümlerini çalıştırır. Bu durumdan ötürü, herhangi bir çakışmayı önlemek için GNU/Linux dağıtımları Python3 paketini farklı bir şekilde adlandırma yoluna gider. Şu anda piyasada bulunan dağıtımların ezici çoğunluğu Python3 paketini ‘python3’ şeklinde adlandırıyor. O yüzden GNU/Linux kullanıcıları, eğer paket yöneticilerini kullanarak Python kurulumu gerçekleştirmiş iseler, komut satırında şu komutu vererek Python3’ü başlatabilirler:
python3
Bu komutun ardından şuna benzer bir ekranla karşılaşmış olmalısınız:
istihza@netbook:~$ # python3 Python 3.4.3 (default, 04.09.2015, 12:24:55) [GCC 4.4.7 20120313 (Red Hat 4.4.7-3)] on linux Type “help”, “copyright”, “credits” or “license” for more information. >>>
Eğer yukarıdaki ekranı gördüyseniz Python’la programlama yapmaya hazırsınız demektir. Değilse, geriye dönüp işlerin nerede ters gittiğini bulmaya çalışabilirsiniz.
Bu aşamada işlerin nerede ters gitmiş olabileceğine dair birkaç ipucu verelim:
Alıntı:
Python3 kurulurken paket yöneticinizin herhangi bir hata vermediğinden, programın sisteminize başarıyla kurulduğundan emin olun. Bunun için Python3’ün kurulu paketler listesinde görünüp görünmediğini denetleyebilirsiniz.
python3
komutunu doğru verdiğinize emin olun. Python programlama diline özellikle yeni başlayanların en sık yaptığı hatalardan biri python kelimesini yanlış yazmaktır. Python yerine yanlışlıkla pyhton, pyton veya phyton yazmış olabilirsiniz. Ayrıca
python3
komutunun tamamen küçük harflerden oluştuğuna dikkat edin. Python ve python bilgisayar açısından aynı şeyler değildir.
Kullandığınız dağıtımın Python3 paketini adlandırma politikası yukarıda anlattığımızdan farklı olabilir. Yani sizin kullandığınız dağıtım, belki de Python3 paketini farklı bir şekilde adlandırmıştır. Eğer durum böyleyse, dağıtımınızın yardım kaynaklarını (wiki, forum, irc, yardım belgeleri, kullanıcı listeleri, vb.) kullanarak ya da istihza.com/forum adresinde sorarak Python3’ün nasıl çalıştırılacağını öğrenmeyi deneyebilirsiniz.
Gelelim Python3’ü kaynaktan derlemiş olanların durumuna...
Python3’ü root Olarak Derleyenler
Eğer Python3’ü önceki bölümlerde anlattığımız şekilde kaynaktan root hakları ile derlediyseniz
Kod:
python3
komutu çalışmayacaktır. Bunun yerine şu komutu kullanmanız gerekecek:
python3.4
Kurduğunuz Python3 sürümünün 3.4 olduğunu varsayıyorum. Eğer farklı bir Python3 sürümü kurduysanız, elbette başlatıcı komut olarak o sürümün adını kullanmanız gerekecektir. Mesela:
Kod:
python3.0
veya
Kod:
python3.1
. Bu arada
Kod:
python3.4
komutunda 34 sayısının rakamları arasında bir adet nokta işareti olduğunu gözden kaçırmıyoruz...
Tıpkı paket deposundan kurulumda olduğu gibi, eğer yukarıdaki komut Python’ı çalıştırmanızı sağlamıyorsa, kurulum esnasında bazı şeyler ters gitmiş olabilir. Örneğin kaynaktan kurulumun herhangi bir aşamasında bir hata almış olabilirsiniz ve bu da Python’ın kurulumunu engellemiş olabilir.
Gördüğünüz gibi, Python’ı kaynaktan derleyenler Python programlama dilini çalıştırabilmek için Python’ın tam sürüm adını belirtiyor. Dilerseniz bu şekilde çalışmaya devam edebilirsiniz. Bunun hiçbir sakıncası yok. Ancak ben size kolaylık açısından, /usr/bin/ dizini altına py3 adında bir sembolik bağ yerleştirmenizi tavsiye ederim. Böylece sadece
Kod:
py3
komutunu vererek Python3’ü başlatabilirsiniz.
Peki bunu nasıl yapacağız?
Python kaynaktan derlendiğinde çalıştırılabilir dosya /usr/local/bin/ dizini içine Python3.4 (veya kurduğunuz Python3 sürümüne bağlı olarak Python3.0 ya da Python3.1) adıyla kopyalanır. Bu nedenle Python3’ü çalıştırabilmek için
Kod:
python3.4
komutunu kullanmamız gerekir. Python3’ü çalıştırabilmek için mesela sadece
Kod:
py3
gibi bir komut kullanmak istiyorsak yapacağımız tek şey /usr/local/bin/ dizini içindeki python3.4 adlı dosyaya /usr/bin dizini altından, py3 adlı bir sembolik bağ oluşturmak olacaktır. Bunun için
Kod:
ln
komutunu kullanmamız gerektiğini biliyorsunuz:
ln -s /usr/local/bin/python3.4 /usr/bin/py3
Tabii bu komutu yetkili kullanıcı olarak vermeniz gerektiğini söylememe herhalde gerek yoktur. Bu komutu verdikten sonra artık sadece
Kod:
py3
komutu ile Python programlama dilini başlatabilirsiniz.
Çok Önemli Bir Uyarı
Bir önceki adımda anlattığımız gibi Python3’ü resmi sitesinden indirip kendiniz derlediniz. Gayet güzel. Ancak bu noktada çok önemli bir konuya dikkatinizi çekmek isterim. En baştan beri söylediğimiz gibi, Python programlama dili GNU/Linux işletim sistemlerinde çok önemli bir yere sahiptir. Öyle ki bu programlama dili, kullandığınız dağıtımın belkemiği durumunda olabilir.
Örneğin Ubuntu GNU/Linux dağıtımında pek çok sistem aracı Python ile yazılmıştır. Bu yüzden, sistemdeki öntanımlı Python sürümünün ne olduğu ve dolayısıyla
Kod:
python
komutunun hangi Python sürümünü çalıştırdığı çok önemlidir. Çünkü sisteminizdeki hayati bazı araçlar,
Kod:
python
komutunun çalıştırdığı Python sürümüne bel bağlamış durumdadır. Dolayısıyla sizin bu
Kod:
python
komutunun çalıştırdığı Python sürümüne dokunmamanız gerekir.
Mesela eğer kullandığınız işletim sisteminde
Kod:
python
komutu Python’ın 2.x sürümlerinden birini çalıştırıyorsa sembolik bağlar veya başka araçlar vasıtasıyla
Kod:
python
komutunu Python’ın başka bir sürümüne bağlamayın. Bu şekilde bütün sistemi kullanılmaz hale getirirsiniz. Elbette eğer kurulum aşamasında tarif ettiğimiz gibi, Python3’ü
Kod:
make install
yerine
Kod:
make altinstall
komutu ile kurmaya özen gösterdiyseniz, sonradan oluşturduğunuz bağ dosyasını silip
Kod:
python
komutunu yine sistemdeki öntanımlı sürüme bağlayabilirsiniz. Bu şekilde her şey yine eski haline döner. Ama eğer Python’ı
Kod:
make install
komutuyla kurmanızdan ötürü sistemdeki öntanımlı Python sürümüne ait dosyaları kaybettiyseniz sizin için yapılacak fazla bir şey yok... Sistemi tekrar eski kararlı haline getirmek için kan, ter ve gözyaşı dökeceksiniz...
Aynı şekilde, kullandığınız dağıtımda
Kod:
python3
komutunun öntanımlı olarak belirli bir Python sürümünü başlatıp başlatmadığı da önemlidir. Yukarıda
Kod:
python
komutu ile ilgili söylediklerimiz
Kod:
python3
ve buna benzer başka komutlar için de aynen geçerli.
Örneğin, Ubuntu GNU/Linux dağıtımında
Kod:
python
komutu sistemde kurulu olan Python 2.x sürümünü;
Kod:
python3
komutu ise sistemde kurulu olan Python 3.x sürümünü çalıştırdığından, biz kendi kurduğumuz Python sürümleri için, sistemdeki sürümlerle çakışmayacak isimler seçtik. Mesela kendi kurduğumuz Python3 sürümünü çalıştırmak için
Kod:
py3
gibi bir komut tercih ettik.
İyi bir test olarak, Python programlama dilini kendiniz kaynaktan derlemeden önce şu komutun çıktısını iyice inceleyebilirsiniz:
ls -g {,/usr{,/local}}/bin | grep python
Bu komut iki farklı Python sürümünün kurulu olduğu sistemlerde şuna benzer bir çıktı verir (çıktı kırpılmıştır):
dh_python2
dh_python3
pdb2.7 -> ../lib/python2.7/pdb.py
pdb3.2 -> ../lib/python3.2/pdb.py
py3versions -> ../share/python3/py3versions.py python -> python2.7 python2 -> python2.7
python2.7 python3 -> python3.2
python3.2 -> python3.2mu
python3.2mu
python3mu -> python3.2mu
pyversions -> ../share/python/pyversions.py
Yatık harflerle gösterdiğimiz kısımlara dikkat edin. Gördüğünüz gibi
Kod:
python
ve
Kod:
python2
komutları bu sistemde Python’ın 2.7 sürümünü çalıştırıyor.
Kod:
python3
komutu ise Python’ın 3.2 sürümünü... Dolayısıyla yukarıdaki çıktıyı aldığımız bir sistemde kendi kurduğumuz Python sürümlerine ‘python’, ‘python2’ veya ‘python3’ gibi isimler vermekten kaçınmalıyız.
Sözün özü, bir GNU/Linux kullanıcısı olarak sistemdeki öntanımlı hiçbir Python sürümünü silmemeli, öntanımlı sürüme ulaşan komutları değiştirmemelisiniz. Eğer mesela sisteminizde
Kod:
python3
komutu halihazırda bir Python sürümünü çalıştırıyorsa, siz yeni kurduğunuz Python sürümüne ulaşmak için öntanımlı adla çakışmayacak başka bir komut adı kullanın. Yani örneğin sisteminizde
Kod:
python3
komutu Python’ın 3.2 sürümünü çalıştırıyorsa, siz yeni kurduğunuz sürümü çalıştırmak için
Kod:
py3
gibi bir sembolik bağ oluşturun. Bırakın öntanımlı komut (
Kod:
python
,
Kod:
python3
vb.) öntanımlı Python sürümünü çalıştırmaya devam etsin.
Asla unutmayın. Siz bir programcı adayı olarak, program yazacağınız işletim sistemini enine boyuna tanımakla yükümlüsünüz. Dolayısıyla işletim sisteminizi kararsız hale getirecek davranışları bilmeli, bu davranışlardan kaçınmalı, yanlış bir işlem yaptığınızda da nasıl geri döneceğinizi bilmelisiniz. Hele ki bir programı kaynaktan derlemeye karar vermişseniz...
Bu ciddi uyarıyı da yaptığımıza göre gönül rahatlığıyla yolumuza devam edebiliriz.
Python3’ü Ev Dizinine Kuranlar
Eğer Python3’ü kısıtlı kullanıcı hakları ile derleyip ev dizininize kurduysanız yukarıdaki komutlar Python’ı çalıştırmanızı sağlamayacaktır. Python3’ü ev dizinine kurmuş olan kullanıcılar Python3’ü çalıştırabilmek için, öncelikle komut satırı aracılığıyla Python3’ü kurdukları dizine, oradan da o dizin altındaki bin/ klasörüne ulaşacak ve orada şu komutu verecek:
./python3.4
Diyelim ki Python3’ü $HOME/python adlı dizine kurdunuz. Önce şu komutla $HOME/python/bin adlı dizine ulaşıyoruz:
cd $HOME/python/bin
Ardından da şu komutu veriyoruz:
./python3.4
Komutun başındaki ./ işaretinin ne işe yaradığını artık adınız gibi biliyorsunuz...
Elbette ben burada kurduğunuz Python sürümünün 3.4 olduğunu varsaydım. Eğer farklı bir sürüm kurduysanız yukarıdaki komutu ona göre yazmanız gerekiyor.
Eğer isterseniz bu şekilde çalışmaya devam edebilirsiniz. Ancak her defasında Python’ın kurulu olduğu dizin altına gelip orada ./python3.4 komutunu çalıştırmak bir süre sonra eziyete dönüşecektir. İşlerinizi kolaylaştırmak için şu işlemleri takip etmelisiniz:
1. ev dizininizin altında bulunan .profile (veya kullandığınız dağıtıma göre .bash_profile ya da .bashrc) adlı dosyayı açın.
2. Bu dosyanın en sonuna şuna benzer bir satır yerleştirerek Python’ı çalıştırmamızı sağlayan dosyanın bulunduğu dizini YOL’a ekleyin:
Alıntı:export PATH=$PATH:$HOME/python/bin/
3. $HOME/python/bin/ satırı Python3’ün çalıştırılabilir dosyasının hangi dizin altında olduğunu gösteriyor. Ben burada Python3’ün çalıştırılabilir dosyasının $HOME/python/bin dizini içinde olduğunu varsaydım. O yüzden de $HOME/python/bin/ gibi bir satır yazdım. Ama eğer Python3’ün çalıştırılabilir dosyası sizde farklı bir dizindeyse bu satırı ona göre yazmalısınız.
4. Kendi sisteminize uygun satırı dosyaya ekledikten sonra dosyayı kaydedip çıkın. Dosyada yaptığımız değişikliğin etkin hale gelebilmesi için şu komutu verin:
Alıntı:source .profile
Elbette eğer sizin sisteminizdeki dosyanın adı .bash_profile veya .bashrc ise yukarıdaki komutu ona göre değiştirmelisiniz.
5. Daha sonra $HOME/python/bin/python3.4 adlı dosyaya $HOME/python/bin/ dizini altından mesela py3 gibi bir sembolik bağ verin:
6. Artık hangi konumda bulunursanız bulunun, şu komutu vererek Python3’ü başlatabilirsiniz:
Alıntı:py3
Burada da eğer yukarıdaki komut Python3’ü çalıştırmanızı sağlamıyorsa, bazı şeyleri eksik veya yanlış yapmış olabilirsiniz. Yardım almak için istihza.com/forum adresine uğrayabilirsiniz.
Python3’ü başarıyla kurup çalıştırabildiğinizi varsayarak yolumuza devam edelim.
Farklı Sürümleri Birlikte Kullanmak
Daha önce de dediğimiz gibi, şu anda piyasada iki farklı Python serisi bulunuyor: Python2 ve Python3. Çok uzun zamandan beri kullanımda olduğu için, Python2 Python3’e kıyasla daha yaygın. Eğer hem Python2 ile yazılmış programları çalıştırmak, hem de Python3 ile geliştirme yapmak istiyorsanız, sisteminizde hem Python2’yi hem de Python3’ü aynı anda bulundurmayı tercih edebilirsiniz. Peki bunu nasıl yapacaksınız?
En başta da söylediğimiz gibi, hemen hemen bütün GNU/Linux dağıtımlarında Python2 kurulu olarak gelir. Dolayısıyla eğer sisteminize ek olarak Python3’ü de kurduysanız (kaynaktan veya paket deposundan), başka herhangi bir şey yapmanıza gerek yok. Yukarıda anlattığımız yönergeleri takip ettiyseniz, konsolda
Kod:
python
komutu verdiğinizde Python2 çalışacak,
Kod:
python3
(veya
Kod:
py3
) komutunu verdiğinizde ise Python3 çalışacaktır.
Ama eğer sisteminizde Python2 bile kurulu değilse, ki bu çok çok düşük bir ihtimaldir, Python2’yi paket yöneticiniz yardımıyla sisteminize kurabilirsiniz. Şu anda piyasada olup da paket deposunda Python bulundurmayan GNU/Linux dağıtımı pek azdır.
GNU/Linux’ta Python’ı nasıl çalıştıracağımızı ve farklı Python sürümlerini bir arada nasıl kullanacağımızı öğrendiğimize göre, Windows kullanıcılarının durumuna bakabiliriz.
Windows Kullanıcıları
Windows kullanıcıları Python3’ü iki şekilde başlatabilir:
Alıntı:
Başlat > Tüm Programlar > Python3.4> Python (Command Line) yolunu takip ederek.
Komut satırında
python
komutunu vererek.
Eğer birinci yolu tercih ederseniz, Python’ın size sunduğu komut satırına doğrudan ulaşmış olursunuz. Ancak Python komut satırına bu şekilde ulaştığınızda bazı kısıtlamalarla karşı karşıya kalırsınız. Doğrudan Python’ın komut satırına ulaşmak yerine önce MS-DOS komut satırına ulaşıp, oradan Python komut satırına ulaşmak özellikle ileride yapacağınız çalışmalar açısından çok daha mantıklı olacaktır. O yüzden komut satırına bu şekilde ulaşmak yerine ikinci seçeneği tercih etmenizi tavsiye ederim. Bunun için önceki bölümlerde gösterdiğimiz şekilde komut satırına ulaşın ve orada şu komutu çalıştırın:
python
Bu komutu verdiğinizde şuna benzer bir ekranla karşılaşacaksınız:
C:\Users\falanca> python3 Python 3.4.3 (v3.4.3:c0e311e010fc, 04.09.2015, 12:24:55) [MSC v.1600 32 bit (Intel)] on win32 Type “help”, “copyright”, “credits” or “license” for more information. >>>
Eğer bu komut yukarıdakine bir benzer bir ekran yerine bir hata mesajı verdiyse kurulum sırasında bazı adımları eksik veya yanlış yapmış olabilirsiniz. Yukarıdaki komut çalışmıyorsa, muhtemelen kurulum sırasında bahsettiğimiz Add python.exe to path adımını yapmayı unutmuşsunuzdur. Eğer öyleyse, kurulum dosyasını tekrar çalıştırıp, ilgili adımı gerçekleştirmeniz veya Python’ı kendiniz YOL’a eklemeniz gerekiyor.
Kod:
python
komutunu başarıyla çalıştırabildiğinizi varsayarak yolumuza devam edelim.
Farklı Sürümleri Birlikte Kullanmak
Daha önce de dediğimiz gibi, şu anda piyasada iki farklı Python serisi bulunuyor: Python2 ve Python3. Çok uzun zamandan beri kullanımda olduğu için, Python2 Python3’e kıyasla daha yaygın. Eğer hem Python2 ile yazılmış programları çalıştırmak, hem de Python3 ile geliştirme yapmak istiyorsanız, sisteminizde hem Python2’yi hem de Python3’ü aynı anda bulundurmayı tercih edebilirsiniz. Peki bunu nasıl yapacaksınız?
Windows’ta bu işlemi yapmak çok kolaydır. python.org/download adresine giderek farklı Python sürümlerini bilgisayarınıza indirebilir ve bunları bilgisayarınıza normal bir şekilde kurabilirsiniz. Bu şekilde sisteminize istediğiniz sayıda farklı Python sürümü kurabilirsiniz. Peki bu farklı sürümlere nasıl ulaşacaksınız?
Windows işletim sistemlerinde hangi Python sürümünü kurarsanız kurun, Python’ı çalıştırmanızı sağlayan dosyanın adı python.exe olacaktır. Eğer sisteminizde birden fazla Python sürümü varsa
Kod:
python
komutu YOL’a ekli ilk Python sürümünü çalıştırır. Kurulum sırasında menüden Add python.exe to Path seçeneğini seçerek Python’ı otomatik olarak YOL’a eklediğinizde Python, ‘C:\Python34;’ satırını YOL dizinlerinin en başına yerleştirir. Yani şöyle bir şey yapar:
C:\Python34;C:\WINDOWS\system32;C:\WINDOWS;
Eğer Python 3.3’ü kurmadan önce
Kod:
python
komutu sizin sisteminizde farklı bir Python sürümünü başlatıyorsa, kurulumdan sonra o sürüm değil, yeni kurduğunuz bu Python 3.4 sürümü çalışmaya başlayacaktır.
Peki bu durumda bilgisayarımızda kurulu farklı Python sürümlerine nasıl ulaşacağız?
Python, bilgisayarınızdaki farklı Python sürümlerini çalıştırabilmemiz için bize özel bir program sunar. Bu programın adı ‘py’.
Py adlı bu programı çalıştırmak için, daha önce gösterdiğimiz şekilde sistem komut satırına ulaşıyoruz ve orada şu komutu veriyoruz:
py
Bu komutu verdiğinizde (teorik olarak) sisteminize en son kurduğunuz Python sürümü çalışmaya başlayacaktır. Ancak bu her zaman böyle olmayabilir. Ya da aldığınız çıktı beklediğiniz gibi olmayabilir. O yüzden bu komutu verdiğinizde hangi sürümün başladığına dikkat edin.
Eğer sisteminizde birden fazla Python sürümü kurulu ise, bu betik yardımıyla istediğiniz sürümü başlatabilirsiniz. Mesela sisteminizde hem Python’ın 2.x sürümlerinden biri, hem de Python’ın 3.x sürümlerinden biri kurulu ise, şu komut yardımıyla Python 2.x’i başlatabilirsiniz:
py -2
Python 3.x’i başlatmak için ise şu komutu veriyoruz:
py -3
Eğer sisteminizde birden fazla Python2 veya birden fazla Python3 sürümü kurulu ise, ana ve alt sürüm numaralarını belirterek istediğiniz sürüme ulaşabilirsiniz:
py -2.6
py -2.7
py -3.2
py -3.3
Bu arada dikkat ettiyseniz, Python programlarını başlatabilmek için hem
Kod:
python
hem de
Kod:
py
komutunu kullanma imkanına sahibiz. Eğer sisteminizde tek bir Python sürümü kurulu ise, Python’ı başlatmak için
Kod:
python
komutunu kullanmak isteyebilir, farklı sürümlerin bir arada bulunduğu durumlarda ise
Kod:
py
ile bu farklı sürümlere tek tek erişmek isteyebilirsiniz.
Böylece Python’la ilgili en temel bilgileri edinmiş olduk. Bu bölümde öğrendiklerimiz sayesinde Python programlama dilini bilgisayarımıza kurabiliyor ve bu programlama dilini başarıyla çalıştırabiliyoruz.
Hangi Komut Hangi Sürümü Çalıştırıyor?
Artık Python programlama dilinin bilgisayarımıza nasıl kurulacağını ve bu programlama dilinin nasıl çalıştırılacağını biliyoruz. Ancak konunun öneminden ötürü, tekrar vurgulayıp, cevabını bilip bilmediğinizden emin olmak istediğimiz bir soru var: Kullandığınız işletim sisteminde acaba hangi komut, hangi Python sürümünü çalıştırıyor?
Bu kitapta anlattığımız farklı yöntemleri takip ederek, Python programlama dilini bilgisayarınıza farklı şekillerde kurmuş olabilirsiniz. Örneğin Python programlama dilini, kullandığınız GNU/Linux dağıtımının paket yöneticisi aracılığıyla kurduysanız, Python’ı başlatmak için
Kod:
python3
komutunu kullanmanız gerekebilir. Aynı şekilde, eğer Python’ı Windows’a kurduysanız, bu programlama dilini çalıştırmak için
Kod:
python
komutunu kullanıyor olabilirsiniz. Bütün bunlardan farklı olarak, eğer Python’ın kaynak kodlarını sitesinden indirip derlediyseniz, Python’ı çalıştırmak için kendi belirlediğiniz bambaşka bir adı da kullanıyor olabilirsiniz. Örneğin belki de Python’ı çalıştırmak için
Kod:
py3
gibi bir komut kullanıyorsunuzdur...
Python programlama dilini çalıştırmak için hangi komutu kullanıyor olursanız olun, lütfen bir sonraki konuya geçmeden önce kendi kendinize şu soruları sorun:
Kullandığım işletim sisteminde Python programı halihazırda kurulu mu?
Kullandığım işletim sisteminde toplam kaç farklı Python sürümü var?
python
komutu bu Python sürümlerinden hangisini çalıştırıyor?
python3
komutu çalışıyor mu?
Eğer çalışıyorsa, bu komut Python sürümlerinden hangisini çalıştırıyor?
Kaynaktan derlediğim Python sürümünü çalıştırmak için hangi komutu kullanıyorum?
Biz bu kitapta şunları varsayacağız:
Kullandığınız işletim sisteminde Python’ın 2.x sürümlerini
python
komutuyla çalıştırıyorsunuz.
Kullandığınız işletim sisteminde Python’ın 3.x sürümlerini
python3
komutuyla çalıştırıyorsunuz.
Bu kitaptan yararlanırken, bu varsayımları göz önünde bulundurmalı, eğer bunlardan farklı komutlar kullanıyorsanız, kodlarınızı ona göre ayarlamalısınız.
Sistem Komut Satırı ve Python Komut Satırı
Buraya kadar Python programlama dilini nasıl çalıştıracağımız konusundaki bütün bilgileri edindik. Ancak programlamaya yeni başlayanların çok sık yaptığı bir hata var: Sistem komut satırı ile Python komut satırını birbirine karıştırmak.
Asla unutmayın, kullandığınız işletim sisteminin komut satırı ile Python’ın komut satırı birbirinden farklı iki ortamdır. Yani Windows’ta
Kod:
cmd
, Ubuntu’da ise Ctrl+Alt+T ile ulaştığınız ortam sistem komut satırı iken, bu ortamı açıp
Kod:
python3
(veya
Kod:
python
ya da
Kod:
py3
) komutu vererek ulaştığınız ortam Python’ın komut satırıdır. Sistem komut satırında sistem komutları (mesela
Kod:
cd
,
Kod:
ls
,
Kod:
dir
,
Kod:
pwd
) verilirken, Python komut satırında, biraz sonra öğrenmeye başlayacağımız Python komutları verilir. Dolayısıyla
Kod:
python3
(veya
Kod:
python
ya da
Kod:
py3
) komutunu verdikten sonra ulaştığınız ortamda
Kod:
cd Desktop
ve
Kod:
ls
gibi sistem komutlarını kullanmaya çalışmanız sizi hüsrana uğratacaktır.
Bu bölüme gelene kadar, herhangi bir programlama faaliyetine girişmeden önce halihazırda biliyor olmamız gereken her şeyi öğrendik. Artık Python ile program yazabilmemizin önünde tek bir engel kaldı. İşte biz bu bölümde Python ile program yazmamızın önündeki son engel olan ‘kurulum’dan söz edeceğiz.
Dediğimiz gibi, Python ile program yazabilmemiz için bu programlama dilinin bilgisayarımızda kurulu olması gerekiyor. Bu programlama dilini kurmanızın gerekip gerekmediği, kullandığınız işletim sistemine bağlıdır. Biz burada hem GNU/Linux hem de Windows kullanıcılarının durumunu sırasıyla ve ayrı ayrı inceleyeceğiz. Dilerseniz öncelikle GNU/Linux kullanıcılarının durumuna bakalım:
Bu kitap boyunca bazı konuların GNU/Linux ve Windows kullanıcıları için ayrı ayrı anlatıldığını göreceksiniz. Ancak konular bu şekilde ayrılmış da olsa, ben size her ikisini de okumanızı tavsiye ederim. Çünkü bu bölümlerde her iki kullanıcı grubunun da ilgisini çekebilecek bilgilere rastlayacaksınız. Ayrıca bu bölümler farklı kullanıcı gruplarına hitap ediyor olsa da, aslında bu bölümlerin birbirini tamamlayıcı nitelikte olduğunu göreceksiniz.
GNU/Linux Kullanıcıları
GNU/Linux dağıtımlarına Python programlama dilini kurarken bazı noktaları göz önünde bulundurmamız gerekiyor. İşte bu bölümde bu önemli noktaların neler olduğunu inceleyeceğiz.
Kurulu Python Sürümü
Hemen hemen bütün GNU/Linux dağıtımlarında Python programlama dili kurulu olarak gelir. Örneğin Ubuntu’da Python zaten kuruludur.
Ancak burada şöyle bir durum var:
Daha önce de belirttiğimiz gibi, şu anda piyasada iki farklı Python serisi bulunuyor. Bunlardan birinin Python’ın 2.x serisi, ötekinin ise 3.x serisi olduğunu biliyorsunuz.
Sisteminizde kurulu olan Python sürümünü denetlemek için komut satırında öncelikle şu komutu vermeyi deneyin (büyük ‘V’ ile):
python -V
Eğer bu komuttan Python 2.x.y şeklinde bir çıktı alıyorsanız, yani x ve y’den önceki kısım 2 ile başlıyorsa sisteminizde Python2 kuruludur.
Ancak
Kod:
python -V
komutundan Python 2.x.y şeklinde bir çıktı almanız sisteminizde sadece Python2’nin kurulu olduğunu göstermez. Sisteminizde Python2 ile birlikte Python3 de halihazırda kurulu olabilir. Örneğin Ubuntu GNU/Linux’un 12.10 sürümünden itibaren hem Python2, hem de Python3 sistemde kurulu vaziyettedir.
Kullandığınız GNU/Linux dağıtımında durumun ne olduğunu denetlemek için yukarıdaki komutu bir de
Kod:
python3 -V
şeklinde çalıştırmayı deneyebilirsiniz. Eğer bu komut size bir hata mesajı yerine bir sürüm numarası veriyorsa sisteminizde Python3 de kuruludur.
Sisteminizdeki Python sürümlerine ilişkin daha kesin bir rapor için ise şu komutu kullanabilirsiniz:
ls -g {,/usr{,/local}}/bin | grep python
Buradan aldığınız çıktıyı inceleyerek de sisteminizde birden fazla Python sürümünün kurulu olup olmadığını görebilirsiniz. [Bununla ilgili bir tartışma için bkz. http://goo.gl/RnRRc]
Eğer Python2 ile birlikte Python3 de kuruluysa yukarıdaki komut şuna benzer bir çıktı verir (çıktı, fazla yer kaplamaması için kırpılmıştır):
dh_python2
dh_python3
pdb2.7 -> ../lib/python2.7/pdb.py
pdb3.2 -> ../lib/python3.2/pdb.py
py3versions -> ../share/python3/py3versions.py
python -> python2.7
python2 -> python2.7
python2.7
python3 -> python3.2
python3.2 -> python3.2mu
python3.2mu
python3mu -> python3.2mu
pyversions -> ../share/python/pyversions.py
Çıktıda iki farklı Python sürümüne ait kayıtların olması sistemde iki farklı Python sürümünün kurulu olduğunu doğruluyor. Bu çıktıya göre, bu komutun verildiği sistemde Python’ın 2.7 ve 3.2 sürümleri zaten kurulu.
Eğer sisteminizde Python3 kuruluysa ve siz de kurulu olan Python3 sürümünden memnunsanız herhangi bir şey yapmanıza gerek yok. Farklı bir Python sürümü kurmaya çalışmadan yolunuza devam edebilirsiniz.
Paket Deposundan Kurulum
Sistemlerinde öntanımlı olarak herhangi bir Python3 sürümü kurulu olmayan veya sistemlerinde kurulu öntanımlı Python3 sürümünden memnun olmayan GNU/Linux kullanıcılarının, Python3’ü elde etmek için tercih edebileceği iki yol var: Birincisi ve benim size önereceğim yol, öncelikle kullandığınız dağıtımın paket yöneticisini kontrol etmenizdir. Python3 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’ kelimesini kullanarak bir arama yapmanızı öneririm. Örneğin Ubuntu GNU/Linux dağıtımının paket depolarında Python3 var. Dolayısıyla Ubuntu kullanıcıları, eğer sistemlerinde zaten kurulu değilse (ki muhtemelen kuruludur), bu paketi Ubuntu Yazılım Merkezi aracılığıyla veya doğrudan şu komutla kurabilir:
sudo apt-get install python3
Bu komut, Python3’ü bütün bağımlılıkları ile beraber bilgisayarınıza kuracaktır.
Kaynaktan Kurulum
Peki ya kullandığınız dağıtımın depolarında Python3 yoksa veya depodaki Python3 sürümü eskiyse ve siz daha yeni bir Python3 sürümü kullanmak istiyorsanız ne yapacaksınız?
Eğer dağıtımınızın depolarında Python3 paketini bulamazsanız veya depodaki sürüm sizi tatmin etmiyorsa, Python3’ü kaynaktan derlemeniz gerekecektir. Python3’ü kaynaktan derlerken iki seçeneğiniz var: Python3’ü root hakları ile kurmak veya Python3’ü yetkisiz kullanıcı olarak kurmak. Normal şartlar altında eğer kullandığınız sistemde root haklarına sahipseniz Python3’ü yetkili kullanıcı olarak kurmanızı tavsiye ederim.
root Hakları İle Kurulum
Python’ı kurmadan önce sistemimizde bulunması gereken bazı programlar var. Aslında bu programlar olmadan da Python kurulabilir, ancak eğer bu programları kurmazsanız Python’ın bazı özelliklerinden yararlanamazsınız. Bu programlar şunlardır:
Alıntı:
tcl8.5-dev
tk8.5-dev
zlib1g-dev
ncurses-dev
libreadline-dev
libdb-dev
libgdbm-dev
libzip-dev
libssl-dev
libsqlite3-dev
libbz2-dev
Bu programları, kullandığınız GNU/Linux dağıtımının paket yöneticisi aracılığıyla kurabilirsiniz. Yalnız paket adlarının ve gerekli paket sayısının dağıtımlar arasında farklılık gösterebileceğini unutmayın. Yukarıdaki liste Ubuntu için geçerlidir. Mesela yukarıda tcl8.5-dev olarak verdiğimiz paket adı başka bir dağıtımda sadece tcl veya tcl8.5 olarak geçiyor olabilir ya da yukarıdaki paketlerin bazıları kullandığınız dağıtımda halihazırda kurulu olduğu için sizin daha az bağımlılık kurmanız gerekiyor olabilir.
Ubuntu’da yukarıdaki paketlerin hepsini şu komutla kurabilirsiniz:
sudo apt-get install tcl8.5-dev tk8.5-dev
zlib1g-dev ncurses-dev libreadline-dev
libdb-dev libgdbm-dev libzip-dev libssl-dev
libsqlite3-dev libbz2-dev
Farklı GNU/Linux dağıtımlarında, Python3’ü kaynaktan derleme işleminden önce halihazırda kurulu olması gereken paketlerin listesi için http://goo.gl/zfLpX adresindeki tabloyu inceleyebilirsiniz.
Yukarıdaki programları kurduktan sonra https://www.python.org/ftp/python/3.4.3 adresine gidiyoruz. Bu adreste, üzerinde ‘Python-3.4.3.tar.xz’ yazan bağlantıya tıklayarak sıkıştırılmış kurulum dosyasını bilgisayarımıza indiriyoruz.
Daha sonra bu sıkıştırılmış dosyayı açıyoruz. Açılan klasörün içine girip, orada ilk olarak şu komutu veriyoruz:
./configure
Bu komut, Python programlama dilinin sisteminize kurulabilmesi için gereken hazırlık aşamalarını gerçekleştirir. Bu betiğin temel olarak yaptığı iş, sisteminizin Python programlama dilinin kurulmasına uygun olup olmadığını, derleme işlemi için gereken yazılımların sisteminizde kurulu olup olmadığını denetlemektir. Bu betik ayrıca, bir sonraki adımda gerçekleştireceğimiz inşa işleminin nasıl yürüyeceğini tarif eden Makefile adlı bir dosya da oluşturur.
Bu arada bu komutunun başındaki ./ işaretlerinin anlamını artık gayet iyi biliyorsunuz. Bu şekilde, o anda içinde bulunduğunuz dizinde yer alan configure adlı bir betiği çalıştırıyorsunuz. Eğer yalnızca
Kod:
configure
komutu verirseniz, işletim sistemi bu betiği YOL dizinleri içinde arayacak ve bulamayacağı için de hata verecektir.
Kod:
./configure
komutu hatasız olarak tamamlandıktan sonra ikinci olarak şu komutu veriyoruz:
make
Burada aslında
Kod:
./configure
komutu ile oluşan Makefile adlı dosyayı make adlı bir program aracılığıyla çalıştırmış oluyoruz.
Kod:
make
bir sistem komutudur. Bu komutu yukarıdaki gibi parametresiz olarak çalıştırdığımızda
Kod:
make
komutu, o anda içinde bulunduğumuz dizinde bir Makefile dosyası arar ve eğer böyle bir dosya varsa onu çalıştırır. Eğer bir önceki adımda çalıştırdığımız
Kod:
./configure
komutu başarısız olduysa, dizinde bir Makefile dosyası oluşmayacağı için yukarıdaki
Kod:
make
komutu da çalışmayacaktır. O yüzden derleme işlemi sırasında verdiğimiz komutların çıktılarını takip edip, bir sonraki aşamaya geçmeden önce komutun düzgün sonlanıp sonlanmadığından emin olmamız gerekiyor.
Kod:
make
komutunun yaptığı iş, Python programlama dilinin sisteminize kurulması esnasında sistemin çeşitli yerlerine kopyalanacak olan dosyaları inşa edip oluşturmaktır. Bu komutun tamamlanması, kullandığınız bilgisayarın kapasitesine bağlı olarak biraz uzun sürebilir.
Bazı sistemlerde
Kod:
make
komutunun sonunda şöyle bir hata mesajıyla karşılaşabilirsiniz:
Undefined reference to '_PyFaulthandler_Init'
Eğer böyle bir hatayla karşılaşırsanız http://goo.gl/jzMIZ adresindeki önerimizi uygulayabilirsiniz.
Kod:
make
komutu tamamlandıktan sonra, komut çıktısının son satırlarına doğru şöyle bir uyarı mesajı da görebilirsiniz:
Python build finished, but the necessary bits
to build these modules were not found: [burada
eksik olan modül veya modüllerin adları sıralanır]
Burada Python, sistemimizde bazı paketlerin eksik olduğu konusunda bizi uyarıyor. Uyarı mesajında bir veya daha fazla paketin eksik olduğunu görebilirsiniz. Eğer öyleyse, eksik olduğu bildirilen bütün paketleri kurmamız gerekiyor.
Gerekli paketi ya da paketleri kurduktan sonra
Kod:
make
komutunu tekrar çalıştırıyoruz. Endişe etmeyin,
Kod:
make
komutunu ikinci kez verdiğimizde komutun tamamlanması birincisi kadar uzun sürmez. Eğer bu komutu ikinci kez çalıştırdığınızda yukarıdaki uyarı mesajı kaybolduysa şu komutla yolunuza devam edebilirsiniz:
sudo make altinstall
Daha önce kaynaktan program derlemiş olan GNU/Linux kullanıcılarının eli,
Kod:
make
komutundan sonra
Kod:
make install
komutunu vermeye gitmiş olabilir. Ama burada bizim
Kod:
make install
yerine
Kod:
make altinstall
komutunu kullandığımıza dikkat edin.
Kod:
make altinstall
komutu, Python kurulurken klasör ve dosyalara sürüm numarasının da eklenmesini sağlar. Böylece yeni kurduğunuz Python, sistemdeki eski Python3 sürümünü silip üzerine yazmamış olur ve iki farklı sürüm yan yana varolabilir. Eğer
Kod:
make altinstall
yerine
Kod:
make install
komutunu verirseniz sisteminizde zaten varolan eski bir Python3 sürümüne ait dosya ve dizinlerin üzerine yazıp silerek o sürümü kullanılamaz hale getirebilirsiniz. Bu da sistemde beklenmedik problemlerin ortaya çıkmasına yol açabilir. Bu önemli ayrıntıyı kesinlikle gözden kaçırmamalısınız.
Python3’ün kaynaktan kurulumu ile ilgili bir tartışma için bkz. http://www.istihza.com/forum/viewtopic.php?f=50&t=544
Derleme aşamalarının hiçbirinde herhangi bir hata mesajı almadıysanız kurulum başarıyla gerçekleşmiş ve sisteminize Python programlama dilinin 3.x sürümü kurulmuş demektir.
Yetkisiz Kullanıcı Olarak Kurulum
Elbette
Kod:
sudo make altinstall
komutunu verip Python’ı kurabilmek için root haklarına sahip olmanız gerekiyor. Ama eğer kullandığınız sistemde bu haklara sahip değilseniz Python’ı bu şekilde kuramazsınız. Kısıtlı haklara sahip olduğunuz bir sistemde Python’ı ancak kendi ev dizininize (
Kod:
$HOME
) kurabilirsiniz.
Eğer Python’ı yetkisiz kullanıcı olarak kuracaksanız, öncelikle yukarıda bahsettiğimiz Python bağımlılıklarının sisteminizde kurulu olup olmadığını kontrol etmeniz lazım. Kullandığınız sistemde herhangi bir Python sürümü halihazırda kuruluysa, bu bağımlılıklar da muhtemelen zaten kuruludur. Ama değilse, bunları kurması için ya sistem yöneticisine ricada bulunacaksınız, ya da bu bağımlılıkları da tek tek kendi ev dizininize kuracaksınız. Eğer sistem yöneticisini bu bağımlılıkları kurmaya ikna edemezseniz, internet üzerinden bulabileceğiniz bilgiler yardımıyla bu bağımlılıkları tek tek elle kendiniz kurabilirsiniz. Ancak bu işlemin epey zaman alacağını ve süreç sırasında pek çok başka bağımlılıkla da karşılacağınızı söyleyebilirim. O yüzden ne yapıp edip sistem yöneticisini bağımlılıkları kurmaya ikna etmenizi tavsiye ederim... Tabii sistem yöneticisini bu bağımlılıkları kurmaya ikna edebilirseniz, istediğiniz Python sürümünü de kurmaya ikna edebileceğinizi düşünebiliriz! Ama biz burada sizin Python’ı kendinizin kuracağını varsayarak yolumuza devam edelim.
Python’ı yetkisiz olarak kurmak, root haklarıyla kurmaya çok benzer. Aralarında yalnızca bir-iki ufak fark vardır. Mesela Python’ı yetkisiz kullanıcı olarak kurarken,
Kod:
./configure
komutunu şu şekilde vermeniz gerekiyor:
./configure --prefix=$HOME/python
Python’ı root haklarıyla kurduğunuzda Python /usr dizini altına kurulacaktır. Ancak siz yetkisiz kullanıcı olduğunuz için /usr dizinine herhangi bir şey kuramazsınız. İşte bu yüzden, configure betiğine verdiğimiz –prefix parametresi yardımıyla Python’ı, yazma yetkimiz olan bir dizine kuruyoruz. Mesela yukarıdaki komut Python’ın /usr dizinine değil, ev dizininiz içinde python adlı bir klasöre kurulmasını sağlayacaktır. Elbette siz python yerine farklı bir dizin adı da belirleyebilirsiniz... Burada önemli olan nokta, –prefix parametresine vereceğiniz dizin adının, sizin yazmaya yetkili olduğunuz bir dizin olmasıdır.
Bu komutu çalıştırdıktan sonra
Kod:
make
komutunu normal bir şekilde veriyoruz. Bunun ardından da
Kod:
make install
(veya duruma göre
Kod:
make altinstall
) komutuyla Python’ı ev dizinimize kuruyoruz. Burada
Kod:
make install
komutunu
Kod:
sudo
‘suz kullandığımıza dikkat edin. Çünkü, dediğimiz gibi, siz yetkili kullanıcı olmadığınız için
Kod:
sudo
komutunu kullanamazsınız.
Python’ı bu şekilde ev dizininiz altında bir klasöre kurduğunuzda Python ile ilgili bütün dosyaların bu klasör içinde yer aldığını göreceksiniz. Bu klasörü dikkatlice inceleyip neyin nerede olduğuna aşinalık kazanmaya çalışın. Eğer mümkünse root hakları ile kurulmuş bir Python sürümünü inceleyerek, dosyaların iki farklı kurulum türünde nerelere kopyalandığını karşılaştırın.
Böylece Python programlama dilini bilgisayarımıza nasıl kuracağımızı öğrenmiş olduk. Ama 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’ı kaynaktan derlemek bazı riskler taşıyabilir. Eğer yukarıda anlatıldığı şekilde, kaynaktan Python derleyecekseniz, karşı karşıya olduğunuz risklerin farkında olmalısınız. Ayrıca GNU/Linux üzerinde kaynaktan program derlemek konusunda tecrübeli değilseniz ve eğer yukarıdaki açıklamalar size kafa karıştırıcı geliyorsa, mesela ‘Ben bu komutları nereye yazacağım?’ diye bir soru geçiyorsa aklınızdan, kesinlikle dağıtımınızla birlikte gelen Python sürümünü kullanmalısınız. Python sürümlerini başa baş takip ettiği için, ben size Ubuntu GNU/Linux’u denemenizi önerebilirim. Ubuntu’nun depolarında Python’ın en yeni sürümlerini rahatlıkla bulabilirsiniz. Ubuntu’nun resmi sitesine ubuntu.com adresinden, yerel Türkiye sitesine ise forum.ubuntu-tr.net adresinden ulaşabilirsiniz. Eğer şu anda kullandığınız GNU/Linux dağıtımından vazgeçmek istemiyorsanız, sabit diskinizden küçük bir bölüm ayırıp bu bölüme sadece Python çalışmalarınız için Ubuntu dağıtımını da kurmayı tercih edebilirsiniz.
Yalnız küçük bir uyarı daha yapalım. Kaynaktan kurulum ile ilgili bu söylediklerimizden, Python’ın GNU/Linux’a kesinlikle kaynaktan derlenerek kurulmaması gerektiği anlamı çıkmamalı. Yukarıdaki uyarıların amacı, kullanıcının Python’ı kaynaktan derlerken sadece biraz daha dikkatli olması gerektiğini hatırlatmaktır. Örneğin bu satırların yazarı, kullandığı Ubuntu sisteminde Python3’ü kaynaktan derleyerek kullanmayı tercih ediyor ve herhangi bir problem yaşamıyor.
Bu önemli uyarıları da yaptığımıza göre gönül rahatlığıyla yolumuza devam edebiliriz.
Kurduğumuz yeni Python’ı nasıl çalıştıracağımızı biraz sonra göreceğiz. Ama önce Windows kullanıcılarının Python3’ü nasıl kuracaklarına bakalım.
Windows Kullanıcıları
Windows sürümlerinin hiçbirinde Python kurulu olarak gelmez. O yüzden Windows 7 kullanıcıları, Python’ı sitesinden indirip kuracak. Bunun için şu adımları takip ediyoruz:
Orada, üzerinde ‘python-3.4.3.msi’ yazan bağlantıya tıklıyoruz.
İnen dosyaya çift tıklayıp normal bir şekilde kuruluma başlıyoruz.
Kurulum adımlarından birinde şöyle bir ekranla karşılaşacaksınız:
Burada Add python.exe to Path (python.exe’yi yola ekle) diye bir seçenek görüyorsunuz. Tahmin edebileceğiniz gibi, bu seçenek Python programlama dilininin kurulu olduğu dizini YOL (PATH) dizinleri arasına ekleyerek, Python’ı kurulumdan sonra sadece adını kullanarak çalıştırabilmemizi sağlayacak.
Bu seçeneğin yanındaki küçük siyah oka tıklayarak, açılan menüden Entire feature will be installed on local hard drive girdisini seçiyoruz. Bundan sonra kuruluma normal bir şekilde devam edebiliriz.
Ben bu kitapta sizin Python’ı yukarıda gösterdiğim şekilde kurduğunuzu varsayacağım. Eğer siz farklı bir kurulum gerçekleştirdiyseniz kitaptaki bazı yönergeleri, kitapta gösterildiği şekilde çalıştıramayabilirsiniz. O yüzden, eğer ne yaptığınızdan emin değilseniz, Python’ı tıpkı burada anlatıldığı gibi kurmanızı ve kurulum sırasında öntanımlı 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.
Geçen bölümde, komut satırı hakkında bilmemiz gereken temel şeyleri öğrendik. Ama işimiz henüz bitmedi. Programcılık faaliyetlerimizi sağlıklı ve sağlam bir zemin üzerinde yürütebilmemiz için öğrenmemiz gereken bir kavram daha var. O kavramın adı PATH, yani YOL. İşte biz bu bölümde, programcılık maceramız açısından bir hayli önemli bir kavram olan bu YOL (PATH) kavramından söz edeceğiz. Peki nedir bu YOL denen şey?
YOL Nedir?
Bir programın veya dosyanın yolu, kabaca o programın veya dosyanın içinde yer aldığı dizindir. Örneğin GNU/Linux işletim sistemlerinde önemli bir sistem dosyası olan fstab dosyasının yolu /etc/fstab‘dır. Windows işletim sisteminde ise, öntanımlı internet tarayıcısı olan Internet Explorer adlı programın yolu C:\Program Files\Internet Explorer\iexplore.exe‘dir. Bu örneklerden de anlaşılacağı gibi, bir dosyanın ya da programın yolu, basitçe o dosyanın ya da programın bilgisayardaki tam adresidir.
Yol kelimesinin bir de daha özel bir anlamı bulunur. Bilgisayar dilinde, çalıştırılabilir dosyaların (executables) içinde yer aldığı dizinlerin adlarını tutan özel bir çevre değişkeni vardır. İşte bu çevre değişkenine PATH (YOL) adı verilir ve bu anlamda kullanıldığında yol kelimesi genellikle büyük harfle yazılır. Gelin isterseniz bu tanımı biraz daha açalım.
İşletim sistemleri, bir programı komut satırından ismiyle çağırdığımızda söz konusu programı çalıştırabilmek için bazı özel dizinlerin içine bakar. İlgili programın çalıştırılabilir dosyası eğer bu özel dizinler içindeyse, işletim sistemi bu dosyayı bulur ve çalıştırılmasını sağlar. Şimdi bu konuyu daha iyi anlayabilmek için birkaç deneme yapalım.
GNU/Linux sistemimizde hemen bir konsol ekranı açıp şu komutu veriyoruz:
echo $PATH
Bu komutun çıktısı şuna benzer bir şey olacaktır:
/usr/local/sbin:/usr/local/bin:/usr/sbin:
/usr/bin:/sbin:/bin:/usr/games
Windows işletim sisteminde ise aynı işlev için komut satırında şu komutu veriyoruz:
echo %PATH%
Bu da şuna benzer bir çıktı verecektir:
C:\Windows\system32;C:\Windows;C:\Windows\System32\
Wbem; C:\Windows\System32\WindowsPowerShell\v1.0\;
İşte bu çıktı bize YOL değişkeni (İngilizcede PATH variable) dediğimiz şeyi gösteriyor. İşletim sistemimiz, bir programı çağırmak istediğimizde, yani komut satırında programın adını yazıp Enter tuşuna bastığımızda öncelikle yukarıda adı verilen dizinlerin içini kontrol edecektir. Eğer çağırdığımız programın çalıştırılabilir dosyası bu dizinlerden herhangi birinin içinde ise o programı ismiyle çağırabiliyoruz.
GNU/Linux işletim sisteminde bir programın YOL’unun ne olduğunu bulmak için
Kod:
which
adlı bir sistem komutundan yararlanabiliriz. Örneğin Gedit programının YOL’unu bulmak için şu komutu verelim:
which gedit
Bu komut /usr/bin/gedit çıktısını verecektir. Hemen yukarıda
Kod:
echo $PATH
komutunun çıktısını kontrol ediyoruz ve görüyoruz ki /usr/bin/ dizini YOL değişkenleri arasında var. Dolayısıyla, Gedit programı YOL üstündedir, diyoruz. Zaten Gedit programının YOL üstünde olması sayesinde, konsolda sadece
Kod:
gedit
komutunu vererek Gedit programını çalıştırabiliyoruz.
Bu arada elbette
Kod:
which gedit
komutunun düzgün çıktı verebilmesi için Gedit adlı programın sisteminizde kurulu olması gerekiyor. Bu program genellikle GNOME ve UNITY masaüstü ortamlarının kurulu olduğu GNU/Linux dağıtımlarında bulunur. Eğer KDE adlı masaüstü ortamını kullanıyorsanız Gedit adlı program sizde kurulu olmayabilir. Eğer öyleyse siz Gedit yerine, sisteminizde kurulu olduğundan emin olduğunuz başka bir programın adını verebilirsiniz. Mesela
Kod:
kwrite
veya
Kod:
kate
.
Gelelim Windows’a...
Windows’ta ise GNU/Linux’taki gibi çalıştırılabilir dosyaların yolunu bulmamızı sağlayan which benzeri bir program kurulu olarak gelmez. Ama eğer isterseniz pankaj-k.net/archives/upload/which.cmd adresinden indireceğiniz which.cmd adlı betiği C:\WINDOWS dizini altına kopyalayarak benzer etkiyi elde edebilirsiniz.
Bu betiği indirip C:\WINDOWS dizini altına which.cmd adıyla kaydettiğinizi varsayarak komut satırında şöyle bir deneme yapabiliriz:
which notepad.exe
Bu komut şöyle bir çıktı verir:
Found in PATH: C:\WINDOWS\system32\notepad.exe
Demek ki notepad.exe‘nin YOL’u buymuş. Hemen yukarıdaki
Kod:
echo %PATH%
çıktısını kontrol ediyoruz ve görüyoruz ki notepad.exe‘yi barındıran C:\WINDOWS\system32\ dizini YOL değişkeni içinde yer alıyor. O halde bu programı doğrudan ismiyle çağırabiliriz. Yani komut satırında doğrudan
Kod:
notepad.exe
komutunu verirsek Notepad programı çalışmaya başlayacaktır. Bir de şunu deneyelim:
which iexplore.exe
Argument "iexplore.exe" not found in PATH
Demek ki iexplore.exe YOL üstünde değilmiş. O yüzden bu programı komut satırından doğrudan ismiyle çalıştıramıyoruz:
iexplore.exe 'iexplore.exe' iç ya da dış komut,
çalıştırılabilir program ya da toplu iş dosyası
olarak tanınmıyor.
YOL üzerinde bulunmayan bir programı çalıştırmak için o programın tam yol adresini kendimiz yazmalıyız. Program YOL üstünde bulunmadığı için işletim sistemimiz bu programın çalıştırılabilir dosyasının nerede olduğunu bulamıyor. Bu yüzden programın nerede olduğunu işletim sistemimize bizim söylememiz gerekiyor. Mesela iexplore.exe YOL üstünde olmadığı için işletim sistemimizin bu programı sırf ismiyle çalıştırması mümkün değil. İşletim sistemimizin bu programı bulabilmesi için, bu programın tam yolunu elle bizim girmemiz gerekiyor:
"C:\Program Files\Internet Explorer\iexplore.exe"
Yukarıdaki komutu verirken tırnak işaretlerini koymayı unutmuyoruz. Ayrıca kullandığımız tırnak işaretlerinin çift tırnak olduğuna da dikkat edin. Windows işletim sistemi açısından tek ve çift tırnak işaretleri birbirinden farklıdır. Yukarıdaki komutu tırnaksız veya tek tırnak işaretleriyle çalıştırmayı denerseniz, ‘Program Files’ ve ‘Internet Explorer’ ifadeleri içinde geçen boşluk karakterleri nedeniyle Windows size bir hata mesajı gösterecektir.
Aynı şekilde GNU/Linux işletim sistemlerinde /etc dizini de YOL üzerinde olmadığı için mesela bu dizinde yer alan fstab dosyasını doğrudan adıyla çağıramayız. Bu yüzden, bu dosyayı açmamız gereken durumlarda, dosyanın bulunduğu konumun tam adresini yazmamız lazım. Örneğin /etc/fstab adlı dosyayı Gedit programıyla açmayı deneyelim:
gedit fstab
Bu komut, o anda bulunduğunuz dizin içinde fstab adlı boş bir dosya oluşturacaktır. Bizim açmaya çalıştığımız asıl fstab dosyası YOL üzerinde bulunmadığı için bu dosyayı sadece adını kullanarak açamayız. Bu dosyayı açabilmek için dosyanın konumunu eksiksiz bir biçimde yazmamız lazım:
gedit /etc/fstab
Bütün bu anlattıklarımız, özellikle GNU/Linux işletim sistemlerine kurmaya çalıştığınız bazı programların neden çalışmadığını açıklıyor olmalı. Eğer bir programı çalıştırmak için ismini komut satırında yazıyorsanız, ama bu komut o programı çalıştırmıyorsa ve siz de bu komutun doğru olduğuna eminseniz, muhtemelen o programın çalıştırılabilir dosyasını barındıran dizin YOL üzerinde değildir. Böyle bir durumda yapmanız gereken bazı işlemler var. Gelin bu işlemlerin neler olduğunu görelim.
YOL’a Dizin Eklemek
Dediğimiz gibi, eğer bir program dizini YOL değişkenini oluşturan dizinler arasında yer almıyorsa, o programı komut satırından ismiyle çalıştıramayız. Böyle bir durumda o programı bizim elle YOL’a eklememiz gerekir. Peki bu işlemi nasıl yapacağız?
Öncelikle Windows’tan başlayalım...
Windows
Windows’ta herhangi bir programı YOL’a eklemek için ilk olarak Başlat simgesine tıklıyoruz:
Alıntı:
Burada menünün sağ tarafındaki listede yer alan ‘Bilgisayar’ düğmesine sağ tıklıyoruz ve şöyle bir ekranla karşılaşıyoruz:
Alıntı:
Karşımıza çıkan menünün en altındaki ‘Özellikler’ satırına tıklıyoruz. Bu satıra tıkladığımızda şöyle bir pencereyle karşılaşmamız gerekiyor:
Alıntı:
Burada, pencerenin sol tarafındaki seçenekler arasında ‘Gelişmiş Sistem Ayarları’ adlı bir satır göreceksiniz. O satıra tıklayın ve şu ekranı karşınıza alın:
Alıntı:
Bu ekranda ‘Gelişmiş’ sekmesinin içinde ‘Ortam Değişkenleri’ adlı bir düğme göreceksiniz. Bu düğmeye tıkladığınızda ise karşınıza şöyle bir pencere açılacak:
Alıntı:
Bu pencerede ‘Sistem Değişkenleri’ başlığı altında birtakım öğeleri barındıran bir liste göreceksiniz. O listede Path adlı girdiyi bulun. Path girdisine çift tıkladığınızda şöyle bir pencere ile karşılaşacaksınız:
Alıntı:
Burada, ‘Değişken Değeri’ ifadesinin karşısında bir kutucuk ve bu kutucuğun içinde de birtakım dizin adları görüyorsunuz. İşte YOL’a eklemek istediğimiz programı barındıran dizini bu kutucuğa yazacağız.
Dikkat ederseniz bu kutucuğun içindeki değerler birbirinden ; (noktalı virgül) işareti ile ayrılmış. Dolayısıyla biz de listenin en sonuna ekleyeceğimiz dizin adını ; işaretini kullanarak önceki girdilerden ayıracağız.
Gelin isterseniz ufak bir deneme çalışması yapalım.
Şimdi yukarıda bahsettiğimiz kutucuğun içindeki listenin en sonuna şu ifadeyi ekleyin:
;C:\Program Files\Internet Explorer
Daha sonra Tamam düğmelerine basarak bütün pencereleri kapatın. Daha önce gösterdiğimiz şekilde komut satırına ulaşın ve orada şu komutu verin:
iexplore
Gördüğünüz gibi, artık bu komut bize bir hata mesajı vermek yerine, doğru bir şekilde Internet Explorer adlı programı çalıştırıyor. İşte bunun sebebi, bizim Internet Explorer programını barındıran dizini YOL’a eklemiş olmamızdır. Bu sayede biz
Kod:
iexplore
komutunu verdiğimizde işletim sistemimiz ilgili programı nerede araması gerektiğini biliyor.
İsterseniz
Kod:
echo %PATH%
komutunu verip C:\Program Files\Internet Explorer adlı dizinin gerçekten yola eklenip eklenmediğini kontrol edebilirsiniz.
Bu arada, YOL değişkeni üzerinde yaptığınız herhangi bir değişikliğin etkinleşebilmesi için açık olan bütün MS-DOS komut pencerelerini kapatmanız gerekir. Komut penceresini tekrar açtığınızda, yaptığınız değişiklikler etkinleşecektir.
Gelelim GNU/Linux kullanıcılarının durumuna...
GNU/Linux
Bildiğiniz gibi, GNU/Linux işletim sistemlerinde YOL dizinlerini listelemek için şöyle bir komut kullanıyoruz:
echo $PATH
Bu komutun çıktısının şuna benzer bir şey olacağını biliyoruz:
/usr/local/sbin:/usr/local/bin:/usr/sbin:
/usr/bin:/sbin:/bin:/usr/games
Gördüğünüz gibi, nasıl Windows işletim sistemlerinde YOL dizinleri birbirinden ; işareti ile ayrılıyorsa, GNU/Linux dağıtımlarında da YOL dizinleri birbirinden : işareti ile ayrılıyor. Dolayısıyla GNU/Linux işletim sistemlerinde herhangi bir dizini YOL’a eklemek için şöyle bir komut kullanıyoruz:
PATH=$PATH:/yola/eklemek/istediğimiz/dizin
Bu komuttaki
Kod:
$PATH
kısmı, YOL’a yeni dizini eklerken halihazırdaki dizinlerin de silinmemesini sağlıyor. Eğer yukarıdaki komutu şöyle verecek olursanız:
PATH=/yola/eklemek/istediğimiz/dizin
YOL üzerinde önceden varolan bütün dizinler silinip, tek girdi olarak yeni eklediğiniz dizin görünecektir. Böyle bir durumda da sisteminizde pek çok programın artık çalışmadığını görürsünüz. O yüzden bu komutu verirken dikkatli olun.
Bütün bu bilgiler ışığında, mesela Desktop (Masaüstü) dizinini YOL’a eklemek için şöyle bir komut yazabiliriz:
PATH=$PATH:$HOME/Desktop
Bu şekilde masaüstü dizinini YOL’a eklemiş olduk. Yeni eklediğimiz dizini, halihazırda YOL üzerinde bulunan dizinlerden : işareti ile ayırdığımıza dikkat edin.
İsterseniz
Kod:
echo $PATH
komutuyla masaüstünüzün YOL üstünde görünüp görünmediğini kontrol edebilirsiniz. Bu sayede artık masaüstünde bulunan çalıştırılabilir dosyalar da kendi adlarıyla çağrılabilecekler. Ancak masaüstünü YOL’a eklediğinizde, masaüstünüz hep YOL üstünde kalmayacak, mevcut konsol oturumu kapatılınca her şey yine eski haline dönecektir. Eğer herhangi bir dizini kalıcı olarak YOL’a eklemek isterseniz, .profile (veya kullandığınız dağıtıma göre .bash_profile ya da .bashrc) dosyanızda değişiklik yapmanız gerekir. Mesela masaüstünü YOL’a eklemek için $HOME/.profile dosyanızın en sonuna şu satırı eklemelisiniz:
export PATH=$PATH:$HOME/Desktop
Ancak GNU/Linux’ta genel yaklaşımınız YOL’a kalıcı olarak dizin eklemek değil, ya bir dizini YOL’a geçici olarak eklemek, ya programınızı mevcut YOL dizinlerinden biri içine kopyalamak, ya da programımıza YOL dizinlerinden birisi içinden sembolik bağ vermek olmalıdır. Yani mesela masaüstünde bir programınız varsa, masaüstünü YOL’a eklemek yerine, programınızı YOL dizinlerinden biri içine (mesela /usr/bin) kopyalamak ya da o konumda bir sembolik bağ oluşturmak daha akıllıca olacaktır.
Hatırlarsanız geçen bölümde ‘çalıştırma yetkisi’ konusundan söz ederken deneme adlı bir kabuk betiği yazmıştık. Masaüstüne kaydettiğimiz bu betiği çalıştırabilmek için de ./deneme gibi bir komut kullanmıştık. Bu komutu verirken baştaki ./ işaretlerini kullanmazsak programımız hata veriyordu.
İşte bu bölümde öğrendiklerimiz sayesinde programımızın neden hata verip çalışmadığını artık daha iyi anlıyor olmalısınız. Dediğimiz gibi, deneme gibi bir komut verdiğimizde işletim sistemimiz
Kod:
echo $PATH
çıktısında görünen YOL dizinlerinin içine bakıp, bu dizinlerin herhangi birinin içinde deneme adlı bir program olup olmadığını kontrol edecektir. Eğer siz kendiniz eklemediyseniz, işletim sisteminizde masaüstü öntanımlı olarak YOL’a ekli değildir. O yüzden deneme komutunu verdiğinizde işletim sisteminiz masaüstüne bakmaz. İşte işletim sisteminin deneme adlı programı başka yerde değil de masaüstünde aramasını sağlamak için komutun başına ./ işaretlerini yerleştiriyoruz...
Tıpkı daha önce öğrendiğimiz %USERPROFILE% (veya $HOME) adlı çevre değişkeni gibi, %PATH% (veya $PATH) de çok önemli çevre değişkenlerinden biri olduğu için YOL kavramıyla bundan sonra da yeterince haşır neşir olacağız. Ayrıca birkaç bölüm sonra gerçek Python programları yazmaya başladığımızda, şu anda belki de kafanızda muğlak kalmış bazı şeyler iyiden iyiye yerine oturmuş olacak. O yüzden şimdilik konuyu daha fazla uzatmadan burada noktalıyoruz ve önemli bir konuya daha geçiyoruz.
Biraz sonra Python programlama diliyle ilgili ilk çalışmalarımızı yapmaya başlayacağız. Ama herhangi bir programlama faaliyetine girişmeden önce mutlaka biliyor olmamız gereken bazı şeyler var. Örneğin, programlama öğrenmek isteyen bir kişi her şeyden önce, program yazmayı tasarladığı işletim sisteminde komut satırının nasıl kullanılacağına dair temel bilgileri edinmiş olmalıdır.
Bu temel bilgilere halihazırda sahip olup olmadığınızı anlamak için aşağıdaki önermelerin sizin açınızdan doğru olup olmadığını kendi kendinize sorgulayabilirsiniz:
Kullandığım işletim sisteminde komut satırına nasıl ulaşacağımı biliyorum.
dir
veya
ls
komutlarının ne işe yaradığını biliyorum.
cd
komutunun nasıl kullanılacağını biliyorum.
Komut satırını açtıktan sonra, o anda hangi dizin altında bulunduğumu anlayabilirim.
echo $HOME
veya
echo %USERPROFILE%
komutlarının ne işe yaradığını, bu komutlardaki
$HOME
ve
%USERPROFILE%
ifadelerinin ne anlama geldiğini gayet iyi biliyorum.
Herhangi bir dosyayı veya dizini, sembolik bağ ile başka bir konuma bağlayabilirim.
permission denied ifadesinin ne anlama geldiğini biliyorum. Bu hataya bakarak, sorunun nereden kaynaklandığını tahmin edebilir, çözümün ne olduğunu kestirebilirim.
Bir dosyaya çalıştırma yetkisi verebilirim.
Masaüstünde bulunan bir dosyayı, komut satırını kullanarak /usr/bin dizini içine kopyalayabilirim, taşıyabilirim veya bu dosyayı silebilirim.
Bir dosya silmek ile dizin silmenin birbirinden farklı şeyler olduğunu ve birbirinden farklı işlemler uygulamak gerektiğini biliyorum.
Eğer yukarıdaki önermelerin tamamına ‘doğru’ cevabını verebiliyorsanız bu bölümü hızlıca gözden geçirip yolunuza devam edebilirsiniz. Ama eğer komut satırı konusunda bilginiz yoksa veya yetersizse, üstelik yukarıdaki önermelere de olumlu cevap veremiyorsanız bu bölümü iyice sindirmeden lütfen bir sonraki bölüme geçmeyin. Bu bölümü hakkıyla tamamlamanız kitaptan sağlıklı bir şekilde yararlanabilmeniz açısından büyük önem taşıyor. Zira bütün programlama dillerinde olduğu gibi, Python’da da komut satırı en büyük yardımcımız olacak. Bu kitapta Python programlama dilinin temellerini komut satırı üzerinde çalışarak öğreneceğiz. Özellikle yazacağımız ilk programlar komut satırında çalışacak. O yüzden, hiç değilse bu kitaptan yararlanabilmek için, kullandığınız işletim sisteminin komut satırına aşina olmalı, yukarıdaki önermelerin sizin için doğru olduğundan emin olmalısınız. Ayrıca sırf bu kitaptan yararlanabilmek için değil, bütün programcılık maceranız boyunca pek çok farklı sebepten, komut satırı üzerinde çalışmaya ihtiyaç duyacaksınız. İşte bundan ötürü, en azından bu kitabı rahatlıkla takip etmenizi sağlayacak kadar komut satırı bilgisini bu bölümde edinmenizi sağlamaya çalışacağız.
Komut Satırına Nasıl Ulaşırız?
Elbette komut satırı hakkında bilmemiz gereken ilk şey, kullandığımız işletim sisteminde komut satırına nasıl ulaşabileceğimizdir.
Eğer Ubuntu GNU/Linux dağıtımı üzerinde Unity masaüstü ortamını kullanıyorsanız sadece Ctrl+Alt+T tuşlarına basarak komut satırına ulaşabilirsiniz. Bu komutu verdiğinizde şuna benzer bir ekranla karşılaşacaksınız:
Alıntı:
Windows 7 kullanıcıları ise Başlat > Tüm Programlar > Donatılar > Komut İstemi yolunu takip ederek komut satırına ulaşabilir. Bu işlemleri yapan Windows kullanıcıları şöyle bir ekranla karşılaşacak:
Alıntı:
Windows kullanıcıları komut satırına ulaşmak için alternatif olarak şu yöntemi de kullanabilir:
Alıntı:
Klavyenizdeki Windows logolu tuşa ve R tuşuna birlikte basarak ‘çalıştır [run]’ penceresini açın.
Daha sonra, açılan pencereye
cmd
yazın ve Enter tuşuna basın.
Eğer Windows 7 veya Ubuntu dışında bir işletim sistemi kullanıyorsanız, kullandığınız işletim sisteminde komut satırına nasıl ulaşabileceğinizi öğrenmek için http://goo.gl/ZyjAU adresini ziyaret edebilirsiniz.
Böylece farklı işletim sistemlerinde komut satırına nasıl ulaşacağımızı öğrenmiş olduk. Ancak iyi bir programcı olabilmek için komut satırına ulaşabilmek yeterli değildir. Ulaştığımız bu komut satırını nasıl kullanacağımızı da bilmemiz gerekiyor. Örneğin komut satırı üzerinde dosyalarımızı nasıl listeleyeceğimizi ve nasıl dizin değiştirebileceğimizi de bilmeliyiz. Dediğimiz gibi, eğer bu işlemleri nasıl yapacağınızı zaten biliyorsanız bir sonraki başlığa geçebilirsiniz. Ama eğer bilginizden emin değilseniz okumaya devam edin.
Hangi Dizin Altındayım?
Şimdi biraz önce anlattığımız gibi, kullandığımız işletim sistemine uygun bir şekilde komut satırını başlatalım. Yukarıdaki ekran görüntülerinden de görebileceğiniz gibi, komut satırını başlattığımızda, siyah zemin üzerinde Windows sistemlerinde C:\Users\falanca>, GNU/Linux sistemlerinde ise istihza@netbook:~$ gibi bir ibare ile karşılaşıyoruz. Burada elbette ‘falanca’, ‘istihza’ ve ‘netbook’ ifadeleri bilgisayar adına ve kullanıcı adınıza bağlı olarak farklı olacaktır. Örneğin kullanıcı adınız ‘ahmet’ ise, yukarıdaki ibare Windows’ta C:\Users\ahmet olacaktır. Aynı şekilde kullanıcı adınız ‘mehmet’, bilgisayar adınız da ‘evbilgisayari’ ise GNU/Linux’ta komut satırını başlattığınızda mehmet@evbilgisayari:~$ gibi bir ibare ile karşılaşabilirsiniz. Ya da eğer kullandığınız Windows sürümü Türkçe, kullanıcı adınız da ‘zeynep’ ise C:\Kullanıcılar\zeynep ibaresini görebilirsiniz.
Bu ibareler, komut satırını başlattığımızda hangi dizinde bulunduğumuzu gösteriyor. Buradan anladığımıza göre, Windows’ta C:\Users\falanca, GNU/Linux’ta ise /home/istihza dizini altındayız.
Windows’taki ekran görüntüsünden hangi dizin altında bulunduğumuz rahatlıkla anlaşılabiliyor, ama GNU/Linux’taki ekran görüntüsünde görünen istihza@netbook:~$ ifadesine bakarak, /home/istihza dizini altında bulunduğumuzu çıkarmak pek kolay olmayabilir. Eğer o anda hangi dizin altında bulunduğunuzdan emin olmak istiyorsanız, GNU/Linux’ta şu komutu verebilirsiniz:
pwd
Windows’ta ise aynı işlev için şu komutu kullanıyoruz:
cd
Windows’un komut satırında C:\Users\falanca> ibaresi, GNU/Linux’un komut satırında ise istihza@netbook:~$ ibaresi görünürken, yukarıdaki komutlardan işletim sistemimize uygun olanı yazıp Enter düğmesine basarsak Windows’ta C:\Users\falanca, GNU/Linux’ta ise /home/istihza gibi bir çıktı alırız.
Kod:
pwd
ve
Kod:
cd
komutları, o anda hangi dizin altında bulunduğumuzu açık bir şekilde gösteriyor. Bu arada, daha önce de söylediğimiz gibi, sizin bilgisayarınızdaki kullanıcı adına bağlı olarak yukarıda gösterilenlerden farklı çıktılar alabilirsiniz.
Dizin İçeriğini Listelemek
Kod:
pwd
veya
Kod:
cd
komutları yardımıyla o anda hangi dizin altında bulunduğumuzu öğrendik. Peki acaba o anda altında bulunduğumuz dizinde hangi dosya ve dizinler var? Bunu bilmeniz önemlidir, çünkü programlama maceranız boyunca, o anda içinde bulunduğunuz dizinde hangi dosyaların olduğunu tespit etmenizi gerektirecek durumlarla mutlaka karşılaşacaksınız. Örneğin bir dizin içindeki herhangi bir dosyayı komut satırı üzerinden açacaksanız, öncelikle o dosyanın dizin içinde yer alıp yer almadığından emin olmanız gerekebilir.
GNU/Linux’ta, o anda altında bulunduğumuz dizinin içeriğini listelemek için şu komuttan yararlanıyoruz (komut küçük L harfi ile başlıyor):
ls
GNU/Linux kullanıcıları, komut satırında istihza@netbook:~$ ibaresi görünürken bu komutu verdiğinde şuna benzer bir çıktı alacaktır:
deneme.py Documents makaleler.rst Pictures Templates
Desktop Downloads Music Public Videos
Bu çıktıda sekiz dizin, iki de dosya görüyoruz. GNU/Linux’ta dizin ve dosyalar komut ekranında farklı renklerle gösterilir. Bu sayede dizin ve dosyaları birbirinden rahatlıkla ayırt edebilirsiniz.
Windows komut satırında ise
Kod:
ls
komutu yerine şu komutu kullanacağız:
dir
Windows’ta da komut satırında C:\Users\falanca> ibaresi görünürken bu komutu verirseniz şuna benzer bir çıktı alırsınız:
27.06.2011 12:31 <DIR> Belgeler
17.11.2011 10:09 <DIR> Desktop
27.09.2011 15:35 183 TESTLOG.log
28.09.2010 12:13 251 tkcon.hst
31.03.2011 14:49 <DIR> Start Menu
02.11.2009 11:19 <DIR> Sık Kullanılanlar
16 Dosya 13.376.408 bayt
22 Dizin 28.174.561.280 bayt boş
Gördüğünüz gibi,
Kod:
dir
komutu da, tıpkı GNU/Linux’taki
Kod:
ls
komutu gibi, o anda içinde bulunduğunuz dizinde yer alan dosya ve klasörleri listeliyor.
Yukarıdaki çıktıda, sol tarafında ‘<DIR>’ ibaresi taşıyan öğeler birer dizindir. Eğer sol tarafta herhangi bir ibare yoksa o öğe bir dosyadır. Örneğin yukarıdaki çıktıda Belgeler, Desktop, Start Menu ve Sık Kullanılanlar birer dizinken, TESTLOG.log ve tkcon.hst birer dosyadır.
Dizin Değiştirme İşlemleri
Böylece komut satırına nasıl ulaşacağımızı ve dizinlerin içeriğini nasıl listeleyeceğimizi öğrenmiş olduk. Bunun dışında, komut satırı ile ilgili olarak bilmemiz gereken önemli bir konu da dizinler arasında hareket edebilme kabiliyetidir. Yani eğer iyi bir programcı olmak istiyorsak, komut satırına ulaşıp hangi dizin altında bulunduğumuzu tespit edebilmenin yanısıra, komut satırını kullanarak o anda bulunduğumuz dizinden başka dizinlere geçiş de yapabiliyor olmalıyız.
Dizinler arasında geçiş yapabilmek için
Kod:
cd
adlı bir komuttan yararlanacağız.
Windows kullanıcıları bu komutun, GNU/Linux’taki
Kod:
pwd
komutunun eşdeğeri olarak da kullanıldığını biliyor.
Bu komut hem GNU/Linux’ta hem de Windows’ta çalışır. Dolayısıyla bu komutu her iki işletim sisteminde de rahatlıkla kullanabilirsiniz.
Peki bu komutu nasıl kullanacağız?
GNU/Linux ve Windows’ta
Kod:
ls
veya
Kod:
dir
komutlarıyla elde ettiğiniz çıktılara tekrar bakın. Bu çıktılarda o dizinin içeriğinde yer alan dosya ve dizinleri görüyorsunuz. İşte bu çıktılarda görünen dizinlerin içine girebilmek için
Kod:
cd
komutundan yararlanabilirsiniz. Diyelim ki biz o anda bulunduğumuz konumdan masaüstüne geçmek istiyoruz. Bildiğiniz gibi, bütün işletim sistemlerinde masaüstü dizini ‘Desktop’ adıyla gösteriliyor. Yukarıda verdiğimiz
Kod:
dir
ve
Kod:
ls
komutlarının çıktılarını kontrol edecek olursanız hem Windows’ta hem de GNU/Linux’ta ‘Desktop’ adlı dizinleri görebilirsiniz. Buna göre bütün işletim sistemlerinde şu komut yardımıyla masaüstüne ulaşabiliriz:
cd Desktop
Daha önce de söylediğimiz gibi
Kod:
cd
komutu dizin değiştirmemizi sağlar.
Kod:
cd Desktop
dediğimizde masaüstünün bulunduğu dizine gelmiş oluyoruz. Eğer biraz önce öğrendiğimiz
Kod:
dir
veya
Kod:
ls
komutlarını bu konumda verecek olursanız, masaüstünde bulunan dosyalarınızın listesini görürsünüz.
Bazı Türkçe GNU/Linux dağıtımlarında masaüstüne ulaşmak için
Kod:
cd Desktop
komutu yerine
Kod:
cd Masaüstü
komutunu vermeniz gerekebilir.
Yalnız burada dikkat etmemiz gereken önemli bir konu var. Yukarıda verdiğimiz
Kod:
cd Desktop
komutunun bizi masaüstüne götürebilmesi için, bu komutu verdiğimiz sırada altında bulunduğumuz dizinin Windows’ta C:\Users\falanca, GNU/Linux’ta ise /home/istihza olması gerekiyor. Neden? Çünkü
Kod:
cd
komutu ile ulaşmaya çalıştığımız Desktop (Masaüstü) dizini Windows’ta C:\Users\falanca dizinin, GNU/Linux’ta ise /home/istihza dizininin içinde bulunuyor. Dolayısıyla sadece
Kod:
cd Desktop
yazarak masaüstüne ulaşabiliyoruz. Bunun ne demek olduğunu daha iyi kavramak için isterseniz birkaç deneme çalışması yapalım.
Biraz önce
Kod:
cd Desktop
komutunu vererek masaüstüne gelmiştik. Yani şu anda Windows’ta C:\Users\falanca\Desktop, GNU/Linux’ta ise /home/istihza/Desktop dizini içinde bulunuyoruz. Şimdi masaüstünün bulunduğu konumdayken şu komutu verelim:
cd ..
Bu komut bizi Windows’ta C:\Users\falanca, GNU/Linux’ta ise /home/istihza dizinine geri götürecektir. Dikkat ederseniz yukarıdaki komut bizi bir üst dizine götürüyor. Bu komutu tekrar verirseniz yine bir üst dizine, yani Windows’ta C:\Users, GNU/Linux’ta ise /home dizinine gidersiniz.
Şimdi ekranda C:\Users veya /home ibaresi görünürken şu komutu vererek masaüstüne ulaşmaya çalışın:
cd Desktop
Gördüğünüz gibi, bu defa bu komut bizi masaüstüne götürmek yerine bir hata mesajı verdi. Çünkü o anda bulunduğumuz konumda artık Desktop bir alt dizin değil. Bu durumu teyit etmek için yine
Kod:
dir
ve
Kod:
ls
komutları yardımıyla dizin içeriğini kontrol edebilirsiniz. Gördüğünüz gibi, bu dizin içeriğini gösteren çıktıda Desktop adı görünmüyor. Eğer aldığınız çıktıda Desktop yoksa, elbette
Kod:
cd Desktop
komutu sizi masaüstüne götürmeyecektir. Böyle bir durumda masaüstüne ulaşmak için Windows’ta şöyle bir komut vermemiz gerekir:
cd falanca\Desktop
GNU/Linux’ta ise:
cd istihza/Desktop
Buradaki mantığı kavradığınızı zannediyorum. Yukarıdaki komutları verirken bulunduğumuz konum Windows’ta C:\Users, GNU/Linux’ta ise /home. Bu konum ile masaüstü arasında Windows’ta falanca, GNU/Linux’ta ise istihza klasörleri yer alıyor. Dolayısıyla bu konumdan masaüstüne ulaşabilmek için önce falanca klasörüne (GNU/Linux’ta istihza klasörüne), oradan da Desktop klasörüne ulaşmamız gerekiyor.
Alternatif olarak, bir dizine ulaşmak için o dizinin tam adresini de yazabiliriz. Örneğin GNU/Linux’ta o anda hangi konumda bulunursak bulunalım, şu komutla masaüstüne ulaşabiliriz:
cd /home/istihza/Desktop
Dikkat ederseniz, burada kök dizinden (/) itibaren Desktop dizinine kadar olan yolu eksiksiz bir biçimde yazdık.
Aynı işlev için Windows’ta şöyle bir komut kullanıyoruz:
cd C:\Users\falanca\Desktop
Burada da C:\ dizininden Desktop dizinine kadar olan yolu eksiksiz olarak yazdık. Böylece komut satırında o anda hangi konumda bulunduğumuzdan bağımsız olarak, masaüstünün bulunduğu konuma geçebilmiş olduk.
Çevre Değişkenleri
Bu noktaya gelinceye kadar komut satırına ilişkin epey şey öğrendiniz. O halde artık size şöyle bir soru sorabilirim:
Diyelim ki bir program yazdınız. Kullanıcılarınızın programınızı kolaylıkla çalıştırabilmesini sağlamak için de programınızın kısayolunu kullanıcılarınızın masaüstlerine yerleştirmek istiyorsunuz. Peki ama bu işlemi nasıl yapacaksınız?
Böyle bir şey yapabilmek için, kullanıcılarınızın masaüstüne giden yolu tespit edebilmeniz lazım. Ama burada şöyle bir problem var. Bildiğiniz gibi herkesin masaüstüne giden yol aynı değil. Bir bilgisayardaki masaüstünü bulabilmek için, o bilgisayarı kullanan kişinin kullanıcı adını da biliyor olmanız lazım. Çünkü masaüstünün bulunduğu dizin kullanıcı adına bağlı olarak farklı olacaktır.
Mesela /home/istihza/Desktop veya C:\Users\selin\Desktop
Hatta işletim sisteminin dilinin Türkçe veya İngilizce olmasına göre de masaüstünün yolu farklı olabilir. Mesela C:\Kullanıcılar\sami\Desktop...
Peki biz bunca farklılıkla karşı karşıyayken, masaüstüne giden yolu sağlıklı bir şekilde nasıl tespit edeceğiz?
İşte böyle bir durumda imdadımıza çevre değişkenleri (veya ‘ortam değişkenleri’) denen birtakım araçlar yetişecek. Peki nedir bu çevre değişkenleri denen şey?
Çevre değişkenleri, kullandığımız işletim sisteminde belli değerlerin atandığı birtakım isimlerdir. Bu tanım yeterince açık olmayabilir. O yüzden isterseniz çevre değişkenlerini bir örnekle anlatmaya çalışalım.
Mesela Windows komut satırında şu komutu verelim:
echo %USERPROFILE%
Bu komut şuna benzer bir çıktı verir:
C:\Users\falanca
GNU/Linux’ta aynı işlev için şu komutu kullanıyoruz:
echo $HOME
Bu da şuna benzer bir çıktı verir:
/home/istihza
İşte Windows’ta %USERPROFILE%, GNU/Linux’ta ise $HOME adlı bu değişkenlere teknik dilde ‘çevre değişkeni’ (environment variable) adı verilir.
Burada gördüğümüz
Kod:
echo
komutu herhangi bir değeri ekrana yazdırmamızı sağlayan bir sistem komutudur. Örneğin yukarıda $HOME ve %USERPROFILE% değişkenlerinin değerini ekrana basabilmek için
Kod:
echo
komutundan yararlandık. Bu komut hem Windows’ta hem de GNU/Linux’ta aynı şekilde çalışır.
Gördüğünüz gibi Windows’ta %USERPROFILE%, GNU/Linux’ta ise $HOME adlı çevre değişkeni, kullanıcı dizininin adını içinde saklıyor. Dolayısıyla bu komut Ahmet adlı kişinin bilgisayarında çalıştırılırsa farklı, Ayşe adlı kişinin bilgisayarında çalıştırılırsa farklı bir çıktı verecektir. Bu değişkenleri kullanarak, masaüstüne giden yolu çok rahat bir şekilde tespit edebilirsiniz:
[Windows]
echo %USERPROFILE%\Desktop
[GNU/Linux]
echo $HOME/Desktop
Gördüğünüz gibi, yukarıdaki değişkenleri kullandığımızda, işletim sistemimiz bu değişkenlerin değerini otomatik olarak yerine koyabiliyor.
Bu sayede, bir program yazdığınızda, programınızı kullanan kişinin masaüstünün tam adresini tespit edip, programınızın kısayolunu, programınızı kuran kişinin masaüstüne otomatik olarak atabilirsiniz.
Tahmin edebileceğiniz gibi, bu çevre değişkenlerini kullanarak, dizinler arasında dolaşma işlemlerinizi de kolaylaştırabilirsiniz:
Bildiğiniz gibi, dizinler arasında dolaşmak için
Kod:
cd
adlı bir komuttan yararlanıyoruz. Mesela masaüstüne ulaşmak için
Kod:
cd Desktop
gibi bir komut kullanıyoruz. Ancak bu komutla masaüstüne ulaşabilmemiz için, masaüstünün o anda bulunduğumuz dizin konumuna göre bir alt dizin olması gerekiyor. Şimdiye kadar yaptığımız örnekler, masaüstünün bir alt dizin olmadığı durumlarda masaüstüne
Kod:
cd
komutu ile ulaşmanın sıkıntılı bir iş olduğunu bize gösterdi. Ama neyse ki işletim sistemleri bize çevre değişkenleri gibi bir kolaylık sunuyor. Bu değişkenleri kullanarak, hangi konumda olursak olalım rahatlıkla masaüstüne ulaşabiliriz:
[Windows]
cd %USERPROFILE%\Desktop
[GNU/Linux]
cd $HOME/Desktop
Bunun dışında, GNU/Linux işletim sistemlerinde ~ işareti de kullanıcı dizininin adını tutar. Örneğin, kullandığınız GNU/Linux işletim sisteminin komut satırında şu komutu verin:
echo ~
Bu komut şuna benzer bir çıktı verecektir:
/home/istihza
Dolayısıyla GNU/Linux’ta şu komutu hangi konum altından verirseniz verin masaüstüne ulaşabilirsiniz:
cd ~/Desktop
Böylece ‘çevre değişkeni’ kavramını da anlatmış ve bu esnada birkaç önemli çevre değişkenini incelemiş olduk. Elbette GNU/Linux ve Windows’taki çevre değişkenleri yukarıda gösterdiklerimizden ibaret değildir. Sisteme ve o sistemi kullanan kişiye ilişkin pek çok önemli değeri içinde barındıran başka çevre değişkenleri de bulunur. Kullandığınız işletim sisteminde hangi çevre değişkenlerinin bulunduğunu öğrenmek için şu komutu verebilirsiniz:
set
Bu komut hem Windows’ta hem de GNU/Linux’ta aynı amaca hizmet eder. Yani çevre değişkenlerinin ve bu değişkenlere ait değerlerin ekrana basılmasını sağlar. Çıktı biçimi şöyledir:
ÇEVRE_DEĞİŞKENİ=değer
Bu listede gördüğünüz çevre değişkenlerini Windows’ta;
echo %ÇEVRE_DEĞİŞKENİ%
GNU/Linux’ta ise;
echo $ÇEVRE_DEĞİŞKENİ
formülüne göre kullanabiliriz.
Bu değişkenlerin bazılarını ilerleyen derslerde biz göstereceğiz, geri kalanlarını ise programlama maceranız sırasında yeri geldikçe kendiniz öğreneceksiniz. Biz şimdilik bu konuyu bir kenara bırakıp, komut satırının kullanımına ilişkin önemli başka bir konudan söz edelim.
Dizin Adı Tamamlama
Bir önceki bölümde gördüğünüz gibi, çevre değişkenlerini kullanarak dizin bulma ve dizinler arasında dolaşma işlemlerimizi kolaylaştırabiliyoruz. İşletim sistemlerinin dizinlere ilişkin bize sunduğu bir başka kolaylık da Tab (Sekme) tuşu ile ilgilidir.
Sözünü ettiğimiz bu kolaylığın ne olduğu anlamak için, komut satırında /home/istihza veya C:\Users\falanca ifadesi görünürken,
Kod:
cd
yazıp bir boşluk bıraktıktan sonra iki kez klavyedeki Tab tuşuna basın. Bu işlem, bir alt dizinde yer alan bütün dizinleri listeleyecektir:
.adobe/ Dropbox/ .local/ .shotwell/
.aptitude/ .fontconfig/ .macromedia/ Templates/
.cache/ .gconf/ .mission-control/ .themes/
.compiz-1/ .gegl-0.0/ .mozilla/ .thumbnails/
.config/ .gimp-2.6/ .mplayer/ .thunderbird/
.dbus/ .gnome2/ Music/ Ubuntu One/
Desktop/ .gstreamer-0.10/ Pictures/ Videos/
Documents/ .gvfs/ .pki/
Downloads/ .icons/ Public/
.dropbox/ lang/ .pulse/
Yukarıdaki çıktı Ubuntu işletim sisteminden. Sizin kullandığınız işletim sisteminin çıktısı elbette daha farklı olacaktır.
Burada başında . işareti olanlar gizli, olmayanlar ise görünür dizinlerdir.
Şimdi aynı konumda
Kod:
cd D
yazıp yine iki kez Tab tuşuna basın. Şöyle bir çıktı alacaksınız:
Desktop/ Documents/ Downloads/ Dropbox/
Gördüğünüz gibi, adı ‘D’ harfi ile başlayan dizinleri listeledik. Tab tuşunun, bu kod tamamlama özelliği sayesinde, ulaşmak istediğiniz dizin adının tamamını yazmak zorunda kalmadan, sadece ilk birkaç harfini yazıp Tab tuşuna basarak o dizine rahatlıkla ulaşabilirsiniz. Örneğin
Kod:
cd De
yazıp iki kez Tab tuşuna basarak (eğer bir alt dizinde ilk harfleri ‘De’ olan başka bir dizin yoksa) doğrudan Desktop dizinine ulaşabilirsiniz.
Yukarıda anlattığımız dizin tamamlama özelliği GNU/Linux’ta geçerlidir. Bu anlattıklarımız Windows sistemlerinde bazı farklılıklar gösterir. Örneğin Windows’ta
Kod:
cd
yazıp bir boşluk bıraktıktan sonra Tab tuşuna bir kez bastığımızda alfabe sırasına göre adı önce gelen dizin adı tamamlanır.
Kullandığınız işletim sisteminde dizin adı tamamlama özelliğinin nasıl çalıştığını deneme yanılma yöntemiyle rahatlıkla keşfedebilirsiniz.
Bu arada, elbette Tab tuşuna basıldığında yalnızca dizin adları tamamlanmaz. Aynı zamanda bu şekilde dosya adlarını da tamamlayabilirsiniz.
Kod:
cd
komutu yalnızca dizin adlarıyla birlikte kullanılabildiği için bu komuttan sonra Tab tuşuna basıldığında yalnızca dizin adları tamamlanacaktır. Ama mesela eğer
Kod:
echo
komutunu yazdıktan sonra bir boşluk bırakıp Tab tuşuna basarsanız dizinlerle birlikte dosyaların da tamamlandığını görürsünüz.
Dizin Ayraçları
Yukarıda verdiğimiz örneklerde belki dikkatinizi çekmiştir. GNU/Linux’ta dizin ayracı olarak / (düz taksim) işaretini, Windows’ta ise \ (ters taksim) işaretini kullanıyoruz. [Windows]
cd %USERPROFILE%\Desktop
[GNU/Linux]
cd $HOME/Desktop
Çoğu durumda düz taksim işareti (/) hem Windows’ta hem de GNU/Linux işletim sisteminde çalışacaktır. Ancak ters taksim işareti (\) yalnızca Windows’ta çalışır. Bu işareti GNU/Linux dizinlerini ayırmak için kullanamayız. Dolayısıyla yazdığınız programların birden fazla platform üzerinde çalışmasını istiyorsanız, her iki işletim sistemi için de ters taksim yerine düz taksim işaretini kullanmanız daha mantıklı olacaktır.
Ters ve düz taksim işaretlerinden hangisini kullandığınız, dosya-dizin adı tamamlama işlemleri için Tab düğmesine basarken önemlidir sadece.
Yani eğer Windows’ta dizinleri ayırmak için düz taksim işaretini kullanırsanız, dosya-dizin tamamlama özelliğinden yararlanamazsınız. Mesela o anda bulunduğumuz dizin altında falanca adlı bir klasörün altındaki filanca adlı başka bir klasöre ulaşmaya çalıştığımızı varsayalım:
cd falanca\fil
yazıp Tab düğmesine basarsak, Windows filanca dizinini bizim için tamamlayacaktır. Ama eğer yukarıdaki komutu ters taksim ile değil de düz taksim ile yazarsak bu tamamlama işlemi gerçekleşmez:
cd falanca/fil
filanca dizinine ulaşmak için dizinin yolunu tam olarak yazmamız gerekir:
cd falanca/filanca
Ama dediğimiz gibi, çoğu durumda her iki işletim sistemi için de düz taksim işaretini kullanmak çok daha makul bir yoldur.
Sembolik Bağlar
Buraya kadar hem Windows’ta hem de GNU/Linux’ta komut satırının nasıl kullanılacağından söz ettik. Sizden beklentimiz buraya kadar anlatılanları iyice sindirmeden yola devam etmemenizdi.
Eğer siz bir Windows kullanıcısı iseniz buraya kadar anlatılan konuları bilmeniz bu kitabı takip edebilmeniz açısından yeterli olacaktır. Ama eğer siz bir GNU/Linux kullanıcısı iseniz komut satırına ilişkin biraz daha fazla şey biliyor olmanız gerekiyor. O yüzden buradan itibaren yalnızca GNU/Linux kullanıcılarını ilgilendiren konulardan söz edeceğiz. Dolayısıyla Windows kullanıcıları eğer isterlerse okumayı burada kesip bir sonraki konuya geçebilir. Ama, ‘fazla bilginin göz çıkarmayacağı’ düsturundan hareketle, ben Windows kullanıcılarına konunun geri kalanını da GNU/Linux kullanıcıları ile beraber okumalarını tavsiye ederim...
İlk olarak sembolik bağları ele alacağız.
Sembolik bağ; bir dosyaya veya dizine bağlantı içeren özel bir dosya türüdür. GNU/Linux işletim sistemlerinde dosyalar ve dizinler birbirlerine sembolik bağ ile bağlanabilir. Peki bir insan neden sembolik bağ oluşturmak ister?
Bunun pek çok farklı sebebi olabilir. Örneğin bazen bir dosyanın adını değiştirmeden, o dosyaya başka bir isimle erişmeniz gereken durumlarla karşılaşabilirsiniz. Mesela orijinal dosyanın adı çok uzunsa, siz sistemde herhangi bir soruna yol açmamak için o dosyanın adını değiştirmeden, o dosyaya daha kısa bir isimle erişmek istiyor olabilirsiniz. Böyle durumlarda yapılabilecek en mantıklı iş o dosyaya bir sembolik bağ vermek olacaktır. Örneğin $HOME dizini altında çok_uzun_bir_dosya_adı adlı bir dosyanız olduğunu düşünün. Sizin amacınız bu dosyaya mesela sadece dosya gibi bir adla erişebilmek. Elbette isterseniz dosyanın adını değiştirebilirsiniz, ama bu durumda eğer o dosyayı kullanan başka uygulamalar varsa, isim değişikliği durumunda o uygulamalar da artık çalışmaz hale gelecektir. İşte böyle bir durumu önlemek için, dosyayı yeniden adlandırmak yerine o dosyaya bir sembolik bağ vermeyi tercih edebilirsiniz. Bunun için
Kod:
ln
adlı bir komuttan yararlanacağız:
ln -s $HOME/çok_uzun_bir_dosya_adı $HOME/dosya
Böylece $HOME dizini altındaki çok_uzun_bir_dosya_adı adlı dosyaya, $HOME dizini altında dosya adlı bir sembolik bağ vermiş olduk. Burada
Kod:
ln
komutunu -s parametresi ile kullandığımıza dikkat edin.
Sembolik bağ oluşturmanın gerekli olduğu bir başka durum da şudur: Mesela bilgisayarınıza kurduğunuz bir program, bir kütüphanenin belli bir konumda olmasını şart koşuyor olabilir. Örneğin Mozilla Firefox adlı program, flash kütüphanesini /usr/lib/mozilla/plugins/ dizini altında arar. Eğer sistemde başka bir konumda zaten libflashplayer.so adlı kütüphane mevcutsa, siz basit bir sembolik bağ aracılığıyla bu kütüphaneye /usr/lib/mozilla/plugins/ dizini altından bir bağlantı verebilirsiniz. Mesela libflashplayer.so adlı kütüphanenin /usr/lib/plugins dizini altında bulunduğunu varsayalım:
ln -s /usr/lib/plugins/libflashplayer.so
/usr/lib/mozilla/plugins/libflashplayer.so
Böylece hem flash kütüphanesini Firefox’a başarıyla tanıtmış, hem de aynı dosyayı iki farklı yere kopyalamak zorunda kalmamış olursunuz.
Elbette, eğer sembolik bağ oluşturacağınız dizin ev dizininiz dışında ise bağ oluşturma işlemi sırasında root haklarına sahip olmanız gerekir. Yani mesela Ubuntu’da yukarıdaki komutu şu şekilde vermeniz gerekir:
sudo ln -s /usr/lib/plugins/libflashplayer.so
/usr/lib/mozilla/plugins/libflashplayer.so
Bu arada sembolik bağlarla ilgili önemli bir bilgi daha verelim: Eğer orijinal dosyada bir değişiklik yapılırsa bu değişiklik bağ dosyasını da etkiler. Böylece ana dosyada bir değişiklik yaptığınızda aynı değişikliği bir de bağ dosyasında yapmak zahmetine girmezsiniz.
Eğer oluşturduğunuz bir sembolik bağı kaldırmak isterseniz, bağ dosyasını silmeniz yeterli olacaktır. Yalnız burada bağ dosyası yerine yanlışlıkla ana dosyayı silmemeye dikkat etmelisiniz.
Son olarak, sembolik bağlarla ilgili bilmemiz gereken önemli bir konu da şu: Bağlayacağımız dosyaların bulunduğu dizin adlarını yazarken, bu dizin adlarını kök dizinden itibaren eksiksiz olarak yazmamız gerekiyor. Aksi halde oluşan bağ dosyasının içi boş olacak ve hiçbir işe yaramayacaktır.
Yukarıda verdiğimiz bilgiler GNU/Linux işletim sistemleri için geçerlidir. Benzer bir özellik Windows işletim sistemleri için de geçerlidir. Ancak bu kitap açısından Windows’ta sembolik bağ oluşturma işlemi bizi ilgilendirmiyor. Biz burada sembolik bağları yalnızca GNU/Linux işletim sisteminin söz konusu olduğu durumlarda kullanacağız. Eğer Windows’ta sembolik bağların nasıl oluşturulacağıyla ilgileniyorsanız
Kod:
mklink
ve
Kod:
fsutil
komutları hakkında bir araştırma yapmanızı tavsiye ederim.
Çalıştırma Yetkisi
Bildiğiniz gibi, GNU/Linux işletim sistemlerinde kullanıcılar dosya ve dizinler üzerinde bazı haklara sahiptir veya değildir. Örneğin normal bir kullanıcı kendi $HOME dizini içindeki dosya ve dizinler üzerinde hem okuma hem de yazma yetkisine sahiptir. $HOME dizini dışındaki dosya ve dizinleri ise yalnızca okuyabilir. Mesela normal bir kullanıcı /usr/bin dizini içindeki dosyalar üzerinde herhangi bir değişiklik yapamaz.
Aynı şekilde, bir kullanıcı öntanımlı olarak bir dosyayı çalıştırma yetkisine de sahip değildir. Yani o dosya bir program da olsa, o dosyayı çalıştırabilmek için öncelikle o dosya üzerinde çalıştırma yetkisine sahip olmanız gerekir. Ya da başka bir deyişle, bir program dosyasının çalıştırılabilmesi için o dosyanın ‘çalıştırılabilir’ olarak işaretlenmiş olması gerekir. Çalıştırma yetkiniz olmayan bir program dosyasını çalıştırmaya teşebbüs etmeniz durumunda permission denied [izin verilmedi] hatası alırsınız.
Dilerseniz bununla ilgili basit bir örnek verelim. Şimdi masaüstünde deneme adlı bir dosya oluşturun ve bu dosyanın içini açarak şu satırları harfi harfine yazın:
#!/bin/sh
echo "merhaba"
Çoğu GNU/Linux kullanıcısının bileceği gibi, bu basit bir kabuk betiğidir.
Kabuk hakkında bilgi için bkz. http://belgeler.gen.tr/bashref/
Bu kabuk betiğini çalıştırmak için komut satırında masaüstüne gelerek şu komutu verin:
./deneme
Bu komut şu hatayı verecektir:
-bash: ./deneme: Permission denied
İşte bu hatanın nedeni, betiğimiz üzerinde çalıştırma yetkisine sahip olmamamızdır. Dosya izinleriyle ilgili bu hatayı almamak için iki seçeneğiniz var. Birinci seçenek olarak, dosyaya sağ tıklayıp dosya özelliklerinden bu dosyayı ‘çalıştırılabilir’ olarak işaretleyebilirsiniz. Ama bu işlemin grafik arayüz üzerinden nasıl yapılacağı, GNU/Linux dağıtımlarında farklılıklar gösterebilir. O yüzden bu işi yapmanın en kestirme ve kesin yöntemi
Kod:
chmod
adlı bir komuttan yararlanmaktır. Bu komut yardımıyla betiğimiz üzerinde çalıştırma yetkisine sahip olabiliriz:
chmod +x deneme
Yukarıdaki komutu şu şekilde de verebilirsiniz:
chmod a+x deneme
Bu komutu bu şekilde verdiğinizde, deneme adlı dosya için, sistemdeki herkese çalıştırma yetkisi vermiş oluyorsunuz. Yani işletim sisteminizde oturum açan herkes deneme adlı bu programı çalıştırabilecektir. Eğer yukarıdaki komutu şu şekilde verirseniz dosyayı yalnızca dosyanın sahibi, yani siz, çalıştırabilirsiniz:
chmod u+x deneme
Buradaki u parametresi İngilizcedeki user (kullanıcı) kelimesinin kısaltmasıdır. Tahmin edebileceğiniz gibi, bir önceki komutta gördüğümüz a parametresi ise all (herkes, hepsi) kelimesinin...
Bu komutlardan sonra artık
Kod:
./deneme
komutu başarıyla çalışacaktır. Eğer bir dosyadan çalıştırma yetkisini geri almak isterseniz şu komutu verebilirsiniz:
chmod -x deneme
Burada + işareti yerine - işaretini kullandığımıza dikkat edin.
Bu arada,
Kod:
./deneme
komutunda gördüğünüz ./ (nokta ve düz taksim) işaretleri, o anda içinde bulunduğunuz dizinde yer alan deneme adlı bir dosyayı çalıştırmak istediğinizi gösterir. Eğer bu komutu yalnızca
Kod:
deneme
olarak verirseniz, işletim sisteminiz deneme adlı dosyayı o anda içinde bulunduğunuz dizinde değil,
Kod:
echo $PATH
adlı özel bir komutun çıktısında görünen dizinler içinde arayacak ve eğer program dosyasını o dizinler içinde bulamazsa da size şöyle bir hata mesajı gösterecektir:
-bash: deneme: command not found
Eğer
Kod:
echo $PATH
komutunun çıktısında görünen dizinler içinde tesadüfen deneme adlı başka bir dosya varsa, yukarıdaki komutu ./ işaretleri olmadan verdiğinizde kendi yazdığınız program dosyası değil, o dosya çalışacaktır. O yüzden, o anda içinde bulunduğumuz dizinde yer alan program dosyalarını çalıştırırken ./ işaretlerini kullanmaya dikkat ediyoruz.
İlerleyen derslerde
Kod:
echo $PATH
komutunun anlam ve öneminden söz edeceğiz. Biz şimdilik bu konuyu bir kenara bırakıp başka bir konuya geçelim.
Dosya kopyalama, Taşıma ve Silme
Windows işletim sistemlerinde bir kullanıcı, sistemdeki her konuma istediği dosyayı kopyalayabilir, taşıyabilir veya bu dosyayı silebilir. Ancak GNU/Linux dağıtımlarında yetkisiz bir kullanıcı ancak ev dizini içindeki dosyalara müdahale edebilir. Bir dosyayı, örneğin $HOME dizininden /usr/bin dizini içine kopyalamak isterse root haklarını alması gerekir.
GNU/Linux dağıtımlarında bu tür işlemleri dosya yöneticileri aracılığıyla grafik olarak yapmanın bazı yöntemleri olsa da en kestirme yol kopyalama, taşıma ve silme gibi işlemleri komut satırı üzerinden halletmektir. Özellikle ev dizini dışındaki dosyalara müdahale ederken komut satırını kullanmak işlerinizi epey hızlandıracaktır. İşte biz de işlerinizi kolayca yapmanızı sağlamak için bu bölümde GNU/Linux işletim sistemlerinde dosya kopyalama, taşıma ve silme işlemlerinin komut satırı aracılığıyla nasıl yapılacağını inceleyeceğiz.
cp
GNU/Linux dağıtımlarında bir dosyayı başka bir konuma kopyalamak için
Kod:
cp
adlı bir komuttan yararlanıyoruz. Bu komut şöyle kullanılıyor:
cp özgün_konumdaki_dosya hedef_konumdaki_dosya
Örneğin masaüstünde bulunan deneme.txt adlı bir dosyayı /usr/bin dizinine aynı adla kopyalamak için şöyle bir komut yazıyoruz:
cp $HOME/Desktop/deneme.txt /usr/bin/
Gördüğünüz gibi, eğer dosyayı bulunduğu konumdan farklı bir konuma aynı adla kopyalayacaksak dosyanın adını tekrar yazmamıza gerek yok. Ama eğer deneme.txt adlı bu dosyayı /usr/bin dizinine farklı bir adla kopyalamak isterseniz yukarıdaki komutu şöyle yazabilirsiniz:
cp $HOME/Desktop/deneme.txt /usr/bin/dosyanın_yeni_adı
Elbette, daha önce de söylediğimiz gibi, /usr/bin dizinine bir dosya kopyalayabilmek için root haklarına sahip olmalısınız. Dolayısıyla yukarıdaki komutları, başlarına sudo getirerek (veya önce su - komutuyla root haklarını alarak) yazmalısınız:
sudo cp $HOME/Desktop/deneme.txt /usr/bin/deneme.txt
Eğer bir dizinin tamamını başka bir konuma kopyalamak istiyorsanız, yukarıdaki komutları -rf parametresi ile çalıştırmanız gerekir. Yani:
cp -rf özgün_dizin hedef_dizin_adresi
veya:
sudo cp -rf özgün_dizin hedef_dizin_adresi
rm
GNU/Linux dağıtımlarında bir dosyayı silmek için
Kod:
rm
adlı bir komuttan yararlanıyoruz. Örneğin masaüstünde bulunan deneme.txt adlı dosyayı silmek için şu komutu veriyoruz:
rm $HOME/Desktop/deneme.txt
Elbette eğer sileceğimiz dosya ev dizini dışındaysa bu komutu root yetkileri ile çalıştırmamız gerekir:
sudo rm /usr/bin/deneme.txt
Kod:
rm
komutu yukarıdaki şekilde ancak dosyaları silmek için kullanılabilir. Eğer silmek istediğiniz şey bir dosya değil de dizin ise o zaman
Kod:
rm
komutunu
Kod:
-rf
parametresi ile birlikte çalıştırmamız gerekir:
rm -rf $HOME/silinecek_dizin
Eğer silinecek dizin ev dizini dışındaysa root haklarını almayı unutmuyoruz:
sudo rm -rf /usr/share/silinecek_dizin
mv
GNU/Linux dağıtımlarında bir dosyayı bir yerden başka bir yere taşımak için
Kod:
mv
adlı bir komuttan yararlanacağız:
mv özgün_konumdaki_dosya hedef_konumdaki_dosya
Örneğin masaüstünde bulunan deneme.txt adlı bir dosyayı /usr/bin dizinine taşımak için şöyle bir komut yazıyoruz:
sudo mv $HOME/Desktop/deneme.txt /usr/bin/
Bu komut masaüstündeki deneme.txt dosyasını silip /usr/bin/ dizini altında deneme.txt adlı başka bir dosya oluşturacak, yani dosyayı masaüstünden /usr/bin dizinine taşımış olacaktır.
Eğer deneme.txt dosyasını farklı bir adla taşımak isterseniz yukarıdaki komutu şöyle yazabilirsiniz:
sudo mv $HOME/Desktop/deneme.txt /usr/bin/yeni_ad
Yukarıdaki örneklerden de gördüğünüz gibi,
Kod:
mv
komutu bir dosyanın konumunu değiştirmek için kullanılıyor. Ama isterseniz aynı komutu bir dosyanın adını değiştirmek için de kullanabilirsiniz:
mv $HOME/Desktop/deneme.txt $HOME/Desktop/yeni_ad
Bu komut masaüstünüzdeki deneme.txt dosyasının adını yeni_ad olarak değiştirecektir...
Böylece çok önemli bir konuyu geride bırakmış olduk. Buraya gelene kadar komut satırına ilişkin epey şey öğrendiniz. Böylece en azından bu kitabı takip etmenizi sağlayacak temel komut satırı bilgilerini edinmiş oldunuz. Bu kitaptan yararlanabilmek için komut satırına ilişkin olarak yukarıda anlattıklarımızı bilmeniz yeterli olacaktır. Ancak eğer yetkin bir programcı olmak istiyorsanız, programlama faaliyetlerinizi yürüttüğünüz işletim sisteminin komut satırını çok iyi tanımanızı tavsiye ederim.
Bölüm Soruları
Yıl 2015 olmuşken sizce komut satırını öğrenmeye ne gerek var?
Kullandığınız işletim sisteminde kaç farklı yoldan komut satırına ulaşabiliyorsunuz?
Kullandığınız işletim sistemine uygun bir şekilde komut satırını başlatın ve o anda hangi dizinde bulunduğunuzu teyit edin.
O anda içinde bulunduğunuz dizindeki bütün altdizin ve dosyaları listeleyin. Bunların hangisinin dizin hangisinin dosya olduğunu tespit edin.
Masaüstü harici bir konumda bir komut satırı oturumu başlatın. Daha sonra, kullandığınız işletim sistemine uygun komutları kullanarak masaüstüne gelin.
cd Desktop
komutu hangi durumlarda hata verebilir?
O anda hangi dizinde bulunuyor olursanız olun, bir üst dizine geçmek için hangi komutları kullanmanız lazım?
Çevre değişkeni denince ne anlıyorsunuz? Bu değişkenlerin bize ne faydası olabilir?
Kullandığınız işletim sisteminde tanımlı olan bütün çevre değişkenlerini listeleyin.
echo
komutu ne işe yarar?
Kullandığınız işletim sisteminde dizin adlarını birbirinden ayıran ayracın hangisi olduğunu gösterin.
GNU/Linux’ta sembolik bağ nedir, ne işe yarar?
Masaüstünde bulunan deneme.txt adlı bir dosyayı sembolik bağ ile /usr/bin/ dizini içine deneme adıyla bağlayın.
Bir önceki soruda oluşturduğunuz sembolik bağ dosyasını silin.
GNU/Linux’ta bir dosyayı herkes tarafından çalıştırılabilir olarak işaretlemek için hangi komutu kullanıyoruz?
GNU/Linux’ta bir dosyanın başına getirilen ./ işareti ne anlama gelir?
Masaüstünde deneme1.txt adlı boş bir dosya oluşturun. Daha sonra aktar.sh adlı bir kabuk betiği yazın. Bu kabuk betiğinin görevi sırasıyla şu işlemleri yapmak:
Ekrana “deneme1.txt dosyasının adı deneme2.txt olarak değiştiriliyor...” çıktısı vermek,
deneme1.txt dosyasının adını deneme2.txt olarak değiştirmek,
Ekrana “deneme1.txt dosyasının adı deneme2.txt olarak değiştirildi.” çıktısı vermek,
Alıntı:Bütün bu görevleri aktar.sh adlı betik dosyasının içinde tanımladıktan sonra bu betiği çalıştırın ve betiğin görevini düzgün bir şekilde yerine getirip getirmediğini teyit edin.
Dediğimiz gibi, şu anda piyasada iki farklı Python serisi var: Python3 ve Python2. Peki acaba hangi seriye ait bir sürümü öğrenmek daha uygun olur?
Eğer Python programlama diline yeni başlıyorsanız Python3’ü öğrenmeniz daha doğru olacaktır. Ama eğer önceden bir Python bilginiz varsa ve bir Python projesi üzerinde çalışmayı planlıyorsanız, hangi sürümü öğrenmeniz gerektiği, projede kullanacağınız yardımcı modüllerin durumuna bağlıdır. Zira şu anda piyasada bulunan bütün Python modülleri/programları henüz Python3’e aktarılmış değil.
Eğer projenizde kullanmayı planladığınız yardımcı modüller halihazırda Python3’e aktarılmışsa Python3’ü öğrenebilirsiniz. Ancak eğer bu modüllerin henüz Python3 sürümü çıkmamışsa sizin de Python2 ile devam etmeniz daha uygun olabilir. Ama her halükarda Python3’ün bu dilin geleceği olduğunu ve günün birinde Python2’nin tamamen tedavülden kalkacağını da aklınızın bir köşesinde bulundurun.
Eğer daha önce Python programlama dili ile ilgili araştırma yaptıysanız, şu anda piyasada iki farklı Python serisinin olduğu dikkatinizi çekmiş olmalı. 04.09.2015 tarihi itibariyle piyasada olan en yeni Python sürümleri Python 2.7.10 ve Python 3.4.3‘tür.
Eğer bir Python sürümü 2 sayısı ile başlıyorsa (mesela 2.7.10), o sürüm Python 2.x serisine aittir. Yok eğer bir Python sürümü 3 sayısı ile başlıyorsa (mesela 3.4.3), o sürüm Python 3.x serisine aittir.
Peki neden piyasada iki farklı Python sürümü var ve bu bizim için ne anlama geliyor?
Python programlama dili 1990 yılından bu yana geliştirilen bir dil. Bu süre içinde pek çok Python programı yazıldı ve insanların kullanımına sunuldu. Şu anda piyasadaki çoğu Python programı 2.x serisinden bir sürümle yazılmış durumda. 3.x serisi ise yeni yeni yaygınlık kazanıyor.
Python3, Python2’ye göre hem çok daha güçlüdür, hem de Python2’nin hatalarından arındırılmıştır. Python3’teki büyük değişikliklerden ötürü, Python2 ile yazılmış bir program Python3 altında çalışmayacaktır. Aynı durum bunun tersi için de geçerlidir. Yani Python3 kullanarak yazdığınız bir program Python2 altında çalışmaz.
Dediğimiz gibi, piyasada Python2 ile yazılmış çok sayıda program var. İşte bu sebeple Python geliştiricileri uzun bir süre daha Python2’yi geliştirmeye devam edecek. Elbette geliştiriciler bir yandan da Python3 üzerinde çalışmayı ve bu yeni seriyi geliştirmeyi sürdürecek.
Farklı Python serilerinin var olmasından ötürü, Python ile program yazarken hangi seriye ait sürümlerden birini kullandığınızı bilmeniz, yazacağınız programın kaderi açısından büyük önem taşır.
Python programlama dili pek çok farklı işletim sistemi ve platform üzerinde çalışabilir. GNU/Linux, Windows, Mac OS X, BSD, Solaris, AIX, AROS, AS/400, BeOS, MorphOS, S60, iPOD, iPhone, Android ve adını dahi duymadığınız pek çok ortamda Python uygulamaları geliştirebilirsiniz. Ayrıca herhangi bir ortamda yazdığınız bir Python programı, üzerinde hiçbir değişiklik yapılmadan veya ufak değişikliklerle başka ortamlarda da çalıştırılabilir.
Biz bu belgelerde Python programlama dilini GNU/Linux ve Microsoft Windows işletim sistemi üzerinden anlatacağız. Ancak sıkı sıkıya bel bağlayacağımız özel bir GNU/Linux dağıtımı veya Windows sürümü yok. Bu yüzden, hangi GNU/Linux dağıtımını veya hangi Windows sürümünü kullanıyor olursanız olun, buradaki bilgiler yardımıyla Python programlama dilini öğrenebilir, öğrendiklerinizi kendi işletim sisteminize uyarlayabilirsiniz.
