Python'da sayılardan başka, verileri birarada tutan veri tipleri de tanımlanmıştır. Yazı barındıran dize (İng. string), farklı verileri sırasıyla barındıran liste ve çokuz (İng. tuple), ayrıca sıralı olmayan sözlük ve küme yapıları gibi.
Gerektiği zaman yeni bir sınıf (İng. class) yaratarak kendi veri tiplerinizi de tanımlayabilirsiniz, ama burada bu konuya girmeyeceğiz.
Bir dize (string) harfler, rakamlar, işaretler gibi yazı karakterlerini barındırır. Karakterler tek tırnak veya çift tırnak arasında olmalıdır. Sözgelişi:
Python için dizelerin tek tırnak veya çift tırnak arasında olması farketmez. Bu esneklik, içinde bu tırnaklardan barındıran yazılarda işe yarar:
In [3]:
s1 = "Kitabım Ali'de kaldı."
s2 = 'Dedi ki "yarın gel al".'
print s1,s2
Ancak bazen her iki tırnak tipini kullanmaktan kaçınamayız. Mesela
In [6]:
s3 = "Ali'nin "Gel" dediğini duydum."
print s3
Bu sorunu gidermek için dize içindeki tırnağı \" biçiminde yazmalıyız. Bu yazma tarzı tırnak karakterinin dize sonu işareti gibi yorumlanmasını engeller, olduğu gibi kullanılmasını sağlar.
In [7]:
s3 = "Ali'nin \"Gel\" dediğini duydum."
print s3
Kaçma karakteri denen ters bölü () işareti önüne geldiği karakterin anlamını değiştirir. Sözgelişi, bir dize içinde satır başına geçmek için "\n", sekme (tab) için "\t" yazılır.
In [9]:
s4 = "Alınacaklar:\nSüt\t1L\nEkmek\nYoğurt\t1kg\n"
print s4
Dizeler üç tırnak (""") ile de sınırlanabilir. O zaman dizeyi yazarken bastığınız satırbaşları ve sekmeler aynen korunur.
In [13]:
s5 = """Alınacaklar:
Süt 1L
Ekmek
Yoğurt 1kg"""
print s5
print kullanmayarak, bir dizenin Python'da nasıl saklandığını görebiliriz:
In [15]:
s3
Out[15]:
Görüldüğü gibi Python dizelerin çevresinde her zaman tek tırnak kullanıyor; dize içindeki tek tırnakları kaçma karakteri (\') ile temsil ediyor.
\xc4\x9f ise ğ karakterinin Unicode sayısıdır. Python dizelerinde İngilizcede olmayan harfler Unicode kodlarına dönüştürülerek saklanır, print kullanıldığında uygun şekilde ekrana basar.
Bu Python 2.x versiyonuna özgü bir davranıştır. Python 3.x'de dizeler standart olarak Unicode kullandığından bu kodlamalar görülmez.
Dizeler + işlemiyle birleştirilebilir.
In [17]:
s6 = s1 + " " + s3
print s6
Tamsayıyla çarpmak, dizenin o sayı kadar tekrarlanmasını sağlar.
In [18]:
"abc"*5
Out[18]:
Dizeleri sayılarla birleştirmek için önce sayıyı str fonksiyonuyla dizeye dönüştürmek gerekir
In [22]:
x = 1.72
y = 80
print "Boyum " + str(x) + ", kilom " + str(y) + "."
Bunun başka bir yolu da biçimleyici (format specifier) kullanmaktır.
In [24]:
print "Boyum %.2f, kilom %d." % (x,y)
Burada %.2f bir virgüllü sayının virgülden sonra sadece iki basamağı, %d ise bir tamsayı demektir. Dizeden sonraki yüzde işaretinin ardından gelen parantez içindeki çokuzdaki sırayla değerler yerine konur.
Bir sıralı nesne olan dizenin içindeki tek tek karakterlere erişmek için sıra numaraları kullanılabilir. Sıra numaraları sıfırdan başlar.
In [38]:
isim = "Albert Einstein"
print isim[0] # ilk karakter
print isim[1] # ikinci karakter
print isim[-1] # son karakter
print isim[-2] # sondan bir önceki karakter
Sıra numarası yerine a:b gibi bir ifade yazılırsa, a sıra numarasından başlayarak b-1 numaralı karaktere kadar bir dilim elde ederiz. Dilim ifadesi :b biçimindeyse baştan b-1 numaralı karaktere kadar, a: biçimindeyse de a numaralı karakterden sona kadar dilim alınır.
In [43]:
print isim[2:6] # 3.karakterden (isim[2]) 6. karaktere (isim[5]) kadar
print isim[:6] # Baştan 6. karaktere kadar
print isim[7:] # 8. karakterden sona kadar
print isim[-4:] # son dört karakter
print isim[:] # bütün karakterler
Son örnek manasız gelmiş olabilir, ama bir dizenin veya listenin kopyasını üretmek için kullanılan yaygın bir ifadedir.
Dilimleme ifadesini a:b:c biçiminde verirsek, elemanlar a'dan b-1'e kadar c adımla seçilir.
In [49]:
print isim[2:13] # Üçüncü karakterden 12. karaktere kadar
print isim[2:13:2] # Üçüncü karakterden 12. karaktere kadar ikişerli adımlarla
print isim[::2] # Baştan sona ikişerli adımlarla
print isim[::-1] # Negatif adım tersten yazar
Bir çokuz parantez içinde virgüllerle ayrılmış elemanlardan oluşur. Elemanlarının aynı tipte olmasına lüzum yoktur; herhangi bir veri tipi olabilir (başka çokuzlar, dizeler, listeler dahil). Eleman sayısı sınırsızdır.
In [ ]:
t = (2, (0.1, "merhaba"), -2+3j)
Toplama işlemi iki çokuzu birleştirir. Tamsayıyla çarpma işlemi çokuzun elemanlarını çarpılan tamsayı kadar sırayla tekrarlar.
In [53]:
print (1,2,3,4)+(7,8,9)
print (1,2,3)*4
Çokuzların listelerden en önemli farkı, değiştirilemez (immutable) olmalarıdır. Bunun anlamı, tek tek elemanlarına yeni değer atanamayacağı, mevcut bir çokuza bir eleman eklenip çıkarılamayacağıdır. Değiştirilemezliği aşağıda daha ayrıntılı açıklayacağız.
Tek elemanlı bir çokuz tanımlarken sağ parantezden önce virgül koyarız.
In [ ]:
t = (5,)
Tek tek elemanlara ulaşmak ve dilimlemek için yukarıda dizeler için gösterdiğimiz yöntem kullanılır.
In [54]:
t = (1,2,3,4,5,6,7)
u = (3.1, (8, 9), -2)
print t[1:3] # t listesinin ikinci ve üçüncü elemanları
print u[1] # u listesinin ikinci elemanı
print u[1][0] # u listesinin ikinci elemanının birinci elemanı
Bir atamanın sol tarafında bir çokuz varsa, sağ taraftaki değerler soldaki çokuzun elemanlarına sırayla atanır.
In [56]:
(x,y,z) = (7,9,12)
print x
print y
print z
Aynısını parantez kullanmadan da yapabiliriz.
In [36]:
x,y,z = 7,9,12
Bu özellik kod kısalığı sağlamanın yanı sıra, iki değişkenin değerinin, geçici bir değişken kullanmadan kolaylıkla değiş-tokuş edilmesini de sağlar.
In [37]:
x, y = y, x
print x
print y
Çokuz ataması kullanarak bir fonksiyonun birden fazla değer döndürür gibi davranmasını sağlayabiliriz. Sözgelişi, f fonksiyonu üç elemanlı bir çokuz döndürsün. Bu değerleri tek tek almak için şöyle bir atama yapılabilir.
Elbette t = f() gibi bir atama yapıp, sonra t'nin elemanlarına tek tek erişmek de mümkün.
Bir liste köşeli parantezle tanımlanır ve elemanlar virgüllerle ayrılır. Liste elemanlarının aynı tipte olmasına lüzum yoktur; herhangi bir veri tipi liste elemanı olabilir. Listeler istendiği kadar uzun olabilir.
In [51]:
x = [1,-2, 0.1, 1+2j]
y = ["merhaba", [2, 3]]
Toplama işlemi iki listeyi birleştiren yeni bir liste verir.
In [29]:
x + y
Out[29]:
Bir listeyle bir tamsayıyı çarpmak, listenin elemanlarını o sayı kadar tekrarlar. Bir liste virgüllü bir sayıyla veya başka bir listeyle çarpılamaz.
In [27]:
y*2
Out[27]:
Dizeler kısmında bahsettiğimiz dilimleme işlemleri listelerde de aynen kullanılabilir.
range fonksiyonu düzenli artan (veya azalan) tamsayılar listesi oluşturur.
In [76]:
print range(10) # 0-9
print range(1,11) # 1-10
print range(-5,6,2) # İkili adımlar: -5, -3, -1, 1, 3, 5
Liste elemanları basit atama işlemiyle değiştirilebilir. Listeden alacağımız bir dilime de atama yapabiliriz.
In [57]:
L = [1,2,3,4]
L[0] = 7
print L # [7,2,3,4]
L[1] = (6,9)
print L # [7, (6,9), 3, 4]
L[2:4] = [0.1, "a"]
print L # [7, (6,9), 0.1, 'a']
Bir L listesinin sonuna bir eleman eklemek için L.append metodu kullanılabilir.
In [62]:
L = [1,2,3,4,5]
L.append(6)
print L
Bir listeye yeni bir listeden elemanları eklemek için extend metodu kullanılır.
In [63]:
L.extend([7,8,9])
print L
append'in sadece tek eleman eklediğine dikkat edin:
In [64]:
L = [1,2,3,4,5]
L.append([7,8,9])
print L
L1.extend(L2) yerine L1 += L2 işlemi de kullanılabilir
In [71]:
L = [1,2,3,4,5]
L += [7,8,9]
print L
insert metodu bir elemanı belli bir pozisyona yerleştirir, sonraki elemanları kaydırır.
In [77]:
L = range(8) # [0,1,2,3,4,5,6,7]
L.insert(5, "a") # "a"yı 5 numaralı indekse (altıncı sıraya) yerleştir.
print L
del komutu belli bir elemanı siler. Diğer liste elemanları otomatik olarak doğru yere kayarlar.
In [78]:
del L[5]
print L
Listeden bir dilimi silmek de mümkün:
In [79]:
del L[2:5]
print L
Python'a başlayanların merak ettiği noktalardan biri, neden çokuz ve liste gibi neredeyse tıpatıp aynı iki veri tipinin bulunduğudur. İki tip arasındaki temel fark şu: Listeler değiştirilebilir (mutable) tiplerdir, çokuzlar ise değiştirilemez (immutable). Yukarıda listeler için gösterdiğimiz eleman silme, eleman ekleme, araya eleman sokma gibi işlemler çokuzlarda yapılamaz. Bir çokuz elemanına yeni bir değer de atanamaz.
In [80]:
c = (1,2,3,4,5)
del c[2]
In [81]:
c[2] = 0
Bazı işlemler ve fonksiyonlar tasarımları açısından, kullanıcının değiştirilemeyecek veri tipleri kullanmalıdırlar. Sözgelişi, aşağıda göreceğimiz sözlük yapılarının anahtar (key) olarak değiştirilemez tipler almaları gerekir. Çokuzlar böyle durumlarda liste yerine kullanılır.
Çokuzlar değiştirilemez de olsalar, kullandığımız bir çokuz ismine yeni bir atama yapabiliriz. Python'da isimler ve onların işaret ettiği nesneler ayrı tutulur. Yeni bir atama, eski nesnenin atılmasına ve ismin yeni nesneye işaret etmesine neden olur.
Varolan bir çokuz elemanını değiştiremesek de, dilimleme ve yeniden atama ile aynı etkiyi dolaylı yoldan yaratabiliriz.
In [86]:
c = (0,1,2,3,4,5)
c = c[:3]+c[4:] # 3 elemanını sil
print c
In [84]:
c = (0,1,2,3,4,5)
c = c[:3]+('a',)+c[4:] # 3 yerine 'a' koy
print c
In [85]:
c = (0,1,2,3,4,5)
c = c[:3]+('a',)+c[3:] # 2 ile 3 arasına 'a' koy
print c
Dizeler de değiştirilemez tiplerdir, ama yukarıdaki gibi dilimleme ve yeniden atama işlemleri ile düzenlenebilirler.
len fonksiyonu aldığı bir nesnenin kaç eleman barındırdığını verir.
In [96]:
L = [1,2,3,(4,5,6)] # dört elemanlı, son eleman bir çokuz
print len(L)
print len(L[3])
print len("Merhaba")
Çeşitli yerlerde liste, çokuz ve dize arasında değişiklikler yapmanız gerekebilir. Bir dizili nesne verildiğinde list fonksiyonu onun liste halini, tuple fonksiyonu ise çokuz halini döndürür.
In [98]:
c = (1,2,"abc",(7,8,9))
L = [-1, ["a", "b"]]
print list(c)
print tuple(L)
print list("merhaba")
Bir karakter listesini (veya çokuzunu) bir dizeye dönüştürmek için, dize nesnesinin join metodunu kullanırız.
In [102]:
L = list("merhaba")
print L
s = "".join(L)
print s
Tabii burada L'nin elemanlarının dize olmasına dikkat etmelisiniz.
Genel olarak s.join(L) komutu, L'nin her elemanı arasına s dizesini yerleştirir:
In [103]:
s = "-*-".join(L)
print s
max(L) fonksiyonu L'nin en büyük elemanını, min(L) ise en küçük elemanını verir.
In [104]:
L = [-2, 3, 7, 1, 9, 0, -5]
print max(L), min(L)
sorted fonksiyonu bir dizili nesnenin elemanlarını sıralayarak liste halinde geri verir.
In [107]:
print sorted( (1,0,4,3,5,2,9,7,8,6) )
print sorted( (1,0,4,3,5,2,9,7,8,6) , reverse = True) # ters sıralama
print sorted( ("ali", "fatma", "mehmet", "duygu") ) # alfabetik sıralama
sum fonksiyonu elementlerin toplamını verir.
In [116]:
c = (1,2,4,-1,-3)
print sum(c)
1'den 100'e kadar olan sayıların toplamı:
In [115]:
print "1 + 2 + ... + 100 = ", sum(range(101))
Elinizde birbiriyle ilgili veriler barındıran, aynı uzunlukta iki liste olduğunda bazen bunların elemanlarını eşleştirmek isteyebilirsiniz. Sözgelişi
In [119]:
L1 = ("Ahmet", "Burcu", "Kemal", "Zeynep") # isimler
L2 = (19, 18, 22, 23) # yaşlar
listelerini alıp, kişilerin isimlerini ve yaşlarını bir çokuzda birleştirerek, hepsini bir listede toplamak için zip fonksiyonu kullanılabilir.
In [120]:
print zip(L1,L2)
In [ ]: