3. Python'a Giriş

Ş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 yazılımlama dillerindekine benzer çalışır (Pascal ve C de olduğu gibi mesela). İfadeleri 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 ( = ) bir 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 = 5 # x, y ve z beş değerini alır
>>> x
5
>>> y
5
>>> z
5

Tam gerçel sayı desteği vardır. Farklı türdeki değerlerin olduğu işlemlerde sonuç gerçel sayı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 soneki 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) işlevi ile kullanılır.

>>> 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 gerçel 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

Tamsayı veya gerçel sayıya dönüştürme işlevleri (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 sayı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 değişken yaratır.

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

>>> 'dizge'
'dizge'
>>> "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.'

Dizgeler birkaç şekilde birden fazla satıra yayılabilir. 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 dizge.\n\
...     Bu 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 dizge.
        Bu satırın başındaki girintinin belirgin olduğuna dikkat edin

>>>

Karakter dizisini r ile imleyerek ham dizge yapacak olursak, \n\ karakterleri yorumlanmaz, dizgenin bir parçası haline gelir. Ö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: Dizgeler 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ür. Ö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ı dizge işlemlerinin sonucunu girişine yazıldığı şekli ile çıkışa yazar. Dizgeler + işleçi ile birleştirilip, * ile tekrarlanabilir:

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

Yan yana iki dizge değişkeni otomatik olarak birleştirilir yani yukarıdaki örnekteki ilk satır kelime = 'Alo' 'ooo' şeklinde de yazılabilirdi. Bu sadece iki dizge değişkeni ile olur. Keyfî dizgeler 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 dizgeler indislenebilir. Dizgenin ilk karakterinin indisi sıfırdır. Python'da ayrı bir karakter veri türü yoktur. Bir karakter tek karakterli bir dizgedir. Icon dilinde (70'li yıllarda Ralph ve Marge Griswold'ün geliştirdiği Pascal benzeri bir SNOBOL4 türevi) olduğu gibi dizgelerin bölümleri dilim gösterimi [ : ] ile ifade edilebilir.

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

C dilinden farklı olarak, Python'da dizgeler değiştirilemez. Bir dizgenin 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 dizge 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 dizgenin 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 dizgenin boyuna eşit olur. Başlangıç değeri bitişten büyük ise boş bir dizge elde edilir.

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

İndisler negatif sayılar da olabilir. 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 soldan 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
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 işlev len() bir dizgenin boyunu verir.

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

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

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

Listeler de dizgeler 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]
['zeytin',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 dizgelerin 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 işlev 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!