Altblümler

3. Python'a Giriş

Aşağıdaki örneklerde giriş ve çıkış komut satırının varlığına veya yokluğuna (">>> " and "... ") bağlıdır. Örnekleri tekrar etmek için komut satırında görünen her şeyi yazmalısınız. ( ">>> " veya "... ") ile başlamayan bütün satırlar yorumlayıcı çıktısını temsil ederler. Ikincil komut satırındaki boş bir satır (sadece "... ")) olan yerlerde bir şey yazmanıza gerek yok. O satırlar boş olup bir deyimler öbeğinin bitirilmesi için kullanılırlar. Bu kılavuzdaki alıştırmaların çoğu, etkileşimli komut satırına yazılanlar dahil, açıklamalar içerirler. Python dilinde açıklamalar "#" ile başlarlar ve bulundukları satır sonuna kadar devam ederler. Bir karakter dizisi içinde bulunan "#" işareti bir açıklama başlatmaz. Bu sadece bir "#" karakteridir. Örnekler:

# Bu bir açıklama.
SAYI = 1 # ve bu ikinci açıklama
# ... bu da üçüncü!
DIZGI = "# Bu bir açıklama değil."

3.1 Python'u Hesap Makinesi Olarak Kullanmak

3.1.1 Sayılar

Şimdi bazı basit komutlar deneyelim. Yorumlayıcıyı çalıştırın ve birincil komut satırının gelmesini bekleyin ">>> "

Yorumlayıcı basit bir hesap makinesi olarak iş görürebilir: istediğiniz herhangi bir ifadeyi yazın ve yorumlayıcı sonucu verecektir. İşleçler ( +,-,*,/ ) çoğu programlama dillerindekine benzer çalışır (Pascal ve C de olduğu gibi mesela) . Ifadeleri gruplamak için parantezler de kullanılabilir. Örnekler:

 2+2
4
>>> # Bu bir açıklama
... 2+2
4
>>> 2+2 # bu da komutlarla aynı satırda bir açıklama
4
>>> (50-5*6)/4
5
>>> # Tam sayı bölme işlemlerinde ise:
... 7/3
2
>>> 7/-3
-3

C de olduğu gibi eşit işareti("=") bi değişkene değer atamak için kullanılır. Atamanın değeri çıkışta yazılmaz:

>>> genislik = 20
>>> yukseklik = 5*9
>>> genislik * yukseklik
900

Bir değer aynı anda birden fazla değişkene atanabilir:

x = y = z = 0 # x, y ve z sıfır değerini alır
>>> x
0
>>> y
0
>>> z
0

Tam kayar nokta desteği vardır. Farklı türdeki değerlerin olduğu işlemlerde sonuç kayar noktalıya dönüştürülür:

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

Karmaşık sayılar da desteklenmektedir. Sayıların sanal kısımları "j" veya "J" eki ile yazılır. Gerçek kısmı sıfır olmayan karmaşık sayılar "(gerçek + sanalj)" şeklinde yazılırlar ya da "complex(gerçek, sanal" fonksiyonu ile yaratılırlar.

>>> 1j * 1J
(-1+0j)
>>> 1j * complex(0,1)
(-1+0j)
>>> 3+1j*3
(3+3j)
>>> (3+1j)*3
(9+3j)
>>> (1+2j)/(1+1j)
(1.5+0.5j)

Karmaşık sayılar daima iki kayar noktalı sayı ile ifade edilirler; biri gerçek diğer sanal kısım için. Z gibi bir karmaşık sayının gerçek ya da sanal kısımlarına erişmek için Z.real ve Z.imag kullanılır.

a=1.5+0.5j
>>> a.real
1.5
>>> a.imag
0.5

Tam sayı veya kayar noktalıya dönüştürme fonksiyonları ( float(), int() ve long() ) karmaşık sayılar için çalışmazlar; bir karmaşık sayıyı gerçek bir sayıya dönüştürmenin doğru bir yolu mevcut değildir. abs(z) ile karmaşık ayının büyüklüğünü ve z.real ile gerçek kısmını elde edebilirsiniz.

>>> a=3.0+4.0j
>>> float(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: can't convert complex to float; use e.g. abs(z)
>>> a.real
3.0
>>> a.imag
4.0
>>> abs(a)  # sqrt(a.real**2 + a.imag**2)
5.0
>>>

Etkileşimli kipte son yazdırılan değer _ değişkenine atanır. Yani Python'u hesap makinesi olarak kullanırken bazen işlemlere şu şekilde devam etmek daha kolaydır :

vergi= 17.5 / 100
>>> fiyat= 3.50
>>> fiyat * vergi
0.61249999999999993
>>> fiyat + _
4.1124999999999998
>>> round(_, 2)
4.1100000000000003
>>>

Bu değişken (_) kullanıcı tarafından salt okunur olarak kabul edilmelidir. Buna kasıtlı olarak değer atamayın. Bu aynı isimli bir yerel (local) değişken yaratır.

3.1.2 Karakter Dizileri

Sayılara ek olarak, Python karakter dizileri üzerinde de işlemler yapabilir. Karakter dizileri farklı şekillerde ifade edilebilir. Tek veya çift tırnak işareti içine alınabilirler:

 >>> 'karakter dizisi'
'karakter dizisi'
>>> "Python\'un gücü"
"Python'un gücü"
>>> "doesn't"
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'

Karakter dizileri birkaç şekilde birden fazla satıra yayılabilirler. Yeni satırlar ters eğik çizgi ile şöyle gösterilebilirler:

merhaba = "Bu C de de kullandığınıza benzer\n\
birkaç satır kaplayan bir karakter dizisi.\n\
    Yeni satırın başındaki
girintinin belirgin olduğuna dikkat\
edin.\n"
print merhaba

ve bu şu çıktıyı verir:

Bu C de de kullandığınıza benzer
birkaç satır kaplayan bir karakter dizisi.
    Yeni satırın başındaki
girintinin belirgin olduğuna dikkat
edin.

Karakter dizisini ``ham'' yapacak olursak, \n yeni satıra dönüşmez ve satır sonundaki ters eğik çizgi ve yani satır karakteri de karakter dizisine veri olarak dahil olur. Örneğin:

merhaba = r"Bu C de de kullandığınıza benzer\n\
birkaç satır kaplayan bir karakter dizisi."

print merhaba

şu çıktıyı verir:

Bu C de de kullandığınıza benzer\n\
birkaç satır kaplayan bir karakter dizisi.

Karakter dizileri bir çift üçlü tırnak içinde de gösterilebilirler: """ veya '''. Bu gösterim şeklinde satır sonlarının \n ile gösterilmesine gerek yoktur ve onlar olmadan da yeni satırlar doğru şekilde görünürler. Örnek:

print """
Kullanım şekli : seninprog [SEÇENEKLER]
     -y     Bu yardım mesajını görüntüler
     -S     bağlanılacak sunucu adı
"""

ifadesi şu çıktıyı verir :

Kullanım şekli : seninprog [SEÇENEKLER]
     -y     Bu yardım mesajını görüntüler
     -S     bağlanılacak sunucu adı

Yorumlayıcı karakter dizisi işlemlerinin sonucunu girişine yazıldığı şekli ile çıkışa yazar. Karakter dizileri + işleci ile birleştirilip, * ile tekrarlanabilirler:

kelime = 'Alo' + 'ooo'
>>> kelime
'Aloooo'
>>> '<' + word*5 + '>'
'<AlooooAlooooAlooooAlooooAloooo>'

Yan yana iki karakter dizisi değişkenleri otomatik olarak birleştirilirler yani yukarıdaki örnekteki ilk satır "word kelime = 'Alo' 'ooo'" şeklinde de yazılabilirdi. Bu sadece iki karakter dizisi değişkeni ile olur. Keyfi karakter dizileri arasında olamaz:

import string
>>> 'str' 'ing' # <- Bu doğru
'string'
>>> string.strip('str') + 'ing' # <- Bu da doğru
'string'
>>> string.strip('str') 'ing' # <- Bu geçersız !!!
File "<stdin>", line 1, in ?
string.strip('str') 'ing'
                        ^
SyntaxError: invalid syntax

C de olduğu gibi, Python'da da karakter dizileri indislenebilirler ( index ). Karakter dizisinin ilk karakterinin indisi sıfırdır. Python'da ayrı bir karakter veri tipi yoktur. Bir karakter tek karakterli bir karakter dizisidir. Icon dilinde (70'li yıllarda Ralph ve Marge Griswold'ün geliştirdiği Pascal benzeri bir SNOBOL4 türevi) olduğu gibi karakter dizilerinin bölümleri dilim gösterimi "[ : ]" ile ifade edilebilirler.

>>> kelime[4]
'o'
>>> kelime[0:2]
'Al'
>>> kelime[2:4]
'oo'

C dilinden farklı olarak, Python'da karakter dizileri değiştirilemezler. Bir karakter dizinin indislenen bir konumuna değer atamaya çalışmak hatadır:

>>> kelime[0] = 'x'
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: object doesn't support item assignment
>>> kelime[:1] = 'Splat'
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: object doesn't support slice assignment

Yukarıdaki soruna elde edilmek istenen karakter dizisi için yeni bir karakter dizisi oluşturularak çözüm bulunabilir. Bu kolay ve etkilidir:

'x' + kelime[1:]
'xloooo'
>>> 'Splat' + kelime[4]
'Splato'

Dilimlerin varsayılan başlangıç ve bitiş değerleri oldukça kullanışlıdır. Başlangıç değeri yoksa sıfır kabul edilir ve eğer bitiş değeri yoksa dilimlenen karakter dizisinin boyu kadar olduğu kabul edilir. Örnekler :

>>> kelime[:2] # İlk iki karakter
'Al'
>>> kelime[2:] # İlk iki karakter dışındaki karakterler
'oooo'

s[:i] + s[i:] = s " olup dilimleme işlemlerinin kullanışlı bir şeklidir. Örnek:

>>> kelime[:2] + kelime[2:]
'Aloooo'
>>> kelime[:3] + kelime[3:]
'Aloooo'

Çok büyük veya küçük dilim aralıkları akıllıca ele alınır. Bitiş değeri büyük ise bunun boyu karakter dizisinin boyuna eşit olur. Başlangıç değeri bitişten büyük ise boş bir karakter dizisi elde edilir.

>>> kelime[1:100]
'loooo'
>>> kelime[10:]
''
>>> kelime[2:1]
''

İndisler negatif sayılar da olabilirler. Bu durumda saymaya sağ taraftan başlanır.

>>> kelime[-1] # Son karakter
'o'
>>> kelime[-2] # Sondan ikinci
'o'
>>> kelime[-2:] # Son iki karakter
'oo'
>>> kelime[:-2] # Son iki karakter dışındaki karakterler
'Aloo'

-0 ın 0 ile aynı olduğuna dikkat edin; yani yine sağdan sayar !

>>> kelime[-0] # (-0 = 0 olduğundan)
'A'

Sınır dışındaki negatif dilim indisleri küçültülürler; fakat bunu dilim olmayan tek bir indis ile denemeyin:

>>> kelime[-100:]
'Aloooo'
>>> kelime[-10] # hata !
Traceback (most recent call last):
File "<stdin>", line 1, in ?
IndexError: string index out of range

Dilimlerin nasıl çalıştığını hatırlamanın en iyi yolu indislerin karakterler arasını işaret ettiğini düşünmektir; şu şekilde bu daha iyi görülebilir:

 +---+---+---+---+---+
 | H | e | l | p | A |
 +---+---+---+---+---+
 0   1   2   3   4   5
-5  -4  -3  -2  -1

Negatif olmayan indisler için dilim boyu indisler arası fark kadardır. Örneğin kelime[1:3] diliminin boyu 2 dir.

Yerleşik (built-in) fonksiyon len() bir karakter dizisinin boyunu verir.

>>> s = 'ArrestedDevelopmentZingalamaduni'
>>> len(s)
32

3.1.3 Listeler

Python'da diğer veri tiplerini bir gruba almayı sağlayan birkaç bileşik veri tipleri vardır. Bunların en kullanışlı olanlarından biri listelerdir. Listeler kare parantez içine virgül ile birbirinden ayrılmış değerlerden (eleman) oluşurlar. Liste elemanlarının aynı tip olması gerekmez.

>>>a = ['salam', 'zeytin', 100, 1234]
>>> a
['salam', 'zeytin', 100, 1234]

Listeler de karakter dizileri gibi indislenebilir. İndisler sıfırdan başlar. Listeler dilimlenebilir, birleştirilebilir vs...

>>> a[0]
'salam'
>>> a[3]
1234
>>> a[-2]
100
>>> a[1:-1]
['salam',100]
>>> a[:2] + ['yumurta', 2*2]
['salam','zeytin', 'yumurta', 4]
>>> 3*a[:3] + ['Oley!']
['salam', 'zeytin', 100, 'salam', 'zeytin', 100,'
salam',zeytin',100,'Oley!']

Değiştirilemez (mutable) olan karakter dizilerinin aksine, listelerin her bir elemanı değiştirilebilir:

>>> a
['salam', 'zeytin', 100, 1234]
>>> a[2] = a[2] + 23
>>> a
['salam', 'zeytin', 123, 1234]

Liste dilimlerine de atama yapılabilir ve bu listenin boyunu da değiştirilebilir.

>>>
# Bazı elemanları değiştir:
... a[0:2] = [1, 12]
>>> a
[1, 12, 123, 1234]
>>> # Bazı elemanları sil:
... a[0:2] = []
>>> a
[123, 1234]
>>> # Listenin içine elemanlar ekle:
... a[1:1] = ['bletch', 'xyzzy']
>>> a
[123, 'qwerty', 'xyzzy', 1234]
>>> a[:0] = a # Listenin kopyasını listenin başına ekle
>>> a
[123, 'qwerty', 'xyzzy', 1234, 123, 'qwerty', 'xyzzy', 1234]

Yerleşik fonksiyon len() listeler ile de çalışır:

>>> len(a)
8

İç içe listeler yaratılabilir. Örnek:

>>> q = [2, 3]
>>> p = [1, q, 4] # buradaki q üst satırda tanımlanan listedir
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
>>> p[1].append('xtra')     # append daha sonra açıklanacak
>>> p
[1, [2, 3, 'xtra'], 4]
>>> q
[2, 3, 'xtra']

Üstteki örnekte p[1] ve q nun aynı nesne olduğuna dikkat edin !

3.2 Programlamaya Doğru İlk Adımlar

Tabi ki Python kullanarak iki ile ikiyi toplamaktan daha karmaşık işler yapabiliriz. Mesela bir Fibonacci serisini şöyle yazabiliriz:

>>> # Fibonacci serisi:
... # iki elemanın toplamı bir sonraki elemanı verir
... a, b = 0, 1
>>> while b < 10:
...       print b
...       a, b = b, a+b
...
1
1
2
3
5
8

Bu örnekte birkaç yeni özellik gösterilmektedir :

İlk satırda bir çoklu değer atama var; a ve b değişkenleri bir anda 0 ve 1 değerlerini alırlar. Bu özellik son satırda da kullanılmaktadır. Son satırda dikkat çeken bir diğer olay da ifadenin sağ kısmının soldan sağa doğru atama işlemlerinden önce hesaplandığıdır.
While döngüsü verilen koşul (burada: b < 10) doğru olduğu sürece tekrarlanır. Python'da, C'de olduğu gibi, sıfır dışındaki herhangi bir değer doğru ve sıfır yanlış kabul edilir. Koşul bir karakter dizisi veya liste de olabilir. Boyu sıfır olmayan her şey doğru iken, boş listeler, karakter dizileri vs yanlış kabul edilirler. Üstteki örnekte basit bir kıyaslama işlemi var. Standart kıyaslama işlemleri C'de olduğu gibi yazılır: < (küçük), > (büyük), == ( eşit), <= (küçük eşit), >= (büyük eşit), != (eşit değil).
Döngü öbeği (block) girinitli yazılmıştır. Girintili yazma Python'un ifadeleri gruplama yoludur. Etkileşimli kipte girintili bir öbek yazıldığı zaman boş bir satır ile sonlandırılmalıdır (çünkü yorumlayıcı yazmayı ne zaman bıraktığınızı bilemez). Girintili bir öbek içindeki her satırın aynı girinti miktarına sahip olması gerektiğine dikkat ediniz. Girintiler için boşluk veya tab karakterleri kullanılabilir.
print deyimi kendisine verilen ifadenin veya ifadelerin değerini yazar. Birden fazla ifade verilmesi durumunda bunlar aralarında boşluk ile yazılırlar:
```
>>>i = 256*256
>>> print 'İşlemin sonucu:', i
İşlemin sonucu: 65536
```
Sona eklenen bir virgül ise yazılan satırından sonra yeni satıra geçilmesini engeller:
```
>>> a, b = 0, 1
>>> while b < 1000:
...     print b,
...     a, b = b, a+b
...
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
```