Python programlamaya giriş yazı dizimizin bu bölümünde dizelerin kullanımını daha ayrıntılı inceleyeceğiz ve dize veri tipine ait olan metodların bazılarına örneklerle göz atacağız. Dizinin bütün yazılarına erişmek için Python Programlamaya Giriş kategorimize bakabilirsiniz.
Dize, bir veya daha fazla karakterden bir araya gelmiş bir sıralı veri tipidir. Dizelerle düz metin halindeki veriler alınıp işlenebilir. Veriler pek çok zaman düz metin dosyaları halinde bulunur. HTML, XML, JSON veya CSV gibi standartlardaki veriler de düz metinden oluşur. Bir metin verisini dize halinde aldığımızda, dize metodlarını kullanarak bu verileri işleyebilir, biçimlerini değiştirebilir, parçalayabilir, birleştirebilir, sıralayabilir, değişiklik yapabiliriz.
Temel işlemler
Sıralı nesnelerle kullanılan len, in, not in, +, * gibi işlemler dizelerde de aynı şekilde çalışır:
In [1]:
1
2
3
4
5
6
7
print( "Def" in "Abcç Defg" )
print( "def" in "ABcç Defg" )
print( "def" not in "ABcç Defg" )
1
2
3
4
5
6
7
True
False
True
In [2]:
1
2
3
len("Abcç Defg")
Out[2]:
1
9
In [3]:
1
2
3
"Abcç" + "Defg"
Out[3]:
1
'AbcçDefg'
In [4]:
1
2
3
"Abcç" * 5
Out[4]:
1
'AbcçAbcçAbcçAbcçAbcç'
Bir nesnenin dize biçimini elde etmek için str fonksiyonu kullanılabilir.
In [5]:
1
2
3
str(12345)
Out[5]:
1
'12345'
In [6]:
1
2
3
str([1,2,3])
Out[6]:
1
'[1, 2, 3]'
Tek tırnak, çift tırnak, üçlü tırnak
Python’da diziler istenirse tek tırnakla, istenirse çift tırnakla sınırlandırarak kullanılabilirler. İkisi de aynı nesneyi üretir; yani "abc" ile 'abc' aynı dizedir.
Bu esneklik, dizenin içinde bir çeşit tırnak varsa, dizenin çevresinde öbür çeşit tırnağı kullanma imkânı verir.
In [7]:
1
2
3
print("Ali'nin kalemini ver.")
1
2
3
Ali'nin kalemini ver.
In [8]:
1
2
3
print( 'Dedim ki: "Gel!"' )
1
2
3
Dedim ki: "Gel!"
Eğer dizenin içindeki metinde her iki tırnak çeşidine de ihtiyaç duyarsak, kaçış karakterleri \’ ve \" kullanabiliriz.
In [9]:
1
2
3
print("Ali'ye dedim ki: \"Gel!\"")
1
2
3
Ali'ye dedim ki: "Gel!"
Üç tırnak (""" veya ''') kullanarak birkaç satıra yayılan bir dize yaratabiliriz. Yaptığımız kaydırmalar, satırbaşları, boş satırlar dizenin parçası olarak kaydedilir. Bu tür dizeler özellikle fonksiyonlardaki belge dizelerinde (docstring) çok kullanılır.
In [10]:
1
2
3
4
5
6
7
8
9
s = """abcç
def
gğhıi"""
print(s)
1
2
3
4
5
6
7
abcç
def
gğhıi
Dize metodları
Dize sınıfı içinde tanımlanmış pek çok metod mevcut. Bunların tam bir listesini görmek için dir(str) komutunu verebilirsiniz.
In [11]:
1
2
3
dir(str)
Out[11]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
['__add__',
'__class__',
'__contains__',
'__delattr__',
'__dir__',
'__doc__',
'__eq__',
'__format__',
'__ge__',
'__getattribute__',
'__getitem__',
'__getnewargs__',
'__gt__',
'__hash__',
'__init__',
'__init_subclass__',
'__iter__',
'__le__',
'__len__',
'__lt__',
'__mod__',
'__mul__',
'__ne__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__rmod__',
'__rmul__',
'__setattr__',
'__sizeof__',
'__str__',
'__subclasshook__',
'capitalize',
'casefold',
'center',
'count',
'encode',
'endswith',
'expandtabs',
'find',
'format',
'format_map',
'index',
'isalnum',
'isalpha',
'isdecimal',
'isdigit',
'isidentifier',
'islower',
'isnumeric',
'isprintable',
'isspace',
'istitle',
'isupper',
'join',
'ljust',
'lower',
'lstrip',
'maketrans',
'partition',
'replace',
'rfind',
'rindex',
'rjust',
'rpartition',
'rsplit',
'rstrip',
'split',
'splitlines',
'startswith',
'strip',
'swapcase',
'title',
'translate',
'upper',
'zfill']
Her bir metodun kısa bir açıklaması için help() komutunu kullanabilirsiniz.
In [12]:
1
2
3
help(str.capitalize)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Help on method_descriptor:
capitalize(...)
S.capitalize() -> str
Return a capitalized version of S, i.e. make the first character
have upper case and the rest lower case.
Burada bu metodların belli başlılarının kullanımlarını örnekleyerek açıklayacağız. Özellikle, metin şeklindeki verilerin analizinde kullanılabilecek metodları seçtik. Tam bir liste için Python yardım belgelerine bakabilirsiniz.
startswith, endswith
Bir dizenin başlangıcında veya sonunda belli bir alt dizenin bulunması halinde True verirler.
In [13]:
1
2
3
4
5
s = "Python Programlamaya Giriş"
s.startswith("Pyth"), s.startswith("python")
Out[13]:
1
(True, False)
In [14]:
1
2
3
s.endswith("iriş"), s.endswith("xyz")
Out[14]:
1
(True, False)
Büyük-küçük harf değişiklikleri
Dizeleri tamamen küçük veya büyük harfe çevirmek, cümlenin ilk harfinin büyük olmasını sağlamak, veya bir başlıktaki gibi her kelimenin büyük harfle başlamasını sağlamak için çeşitli dize metodları vardır.
In [15]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
s = "Pijamalı hasta yağız şoföre çabucak güvendi."
print("s.upper():", s.upper()) # Hepsini büyük harfe çevir.
print("s.lower():", s.lower()) # Hepsini küçük harfe çevir.
print("s.capitalize():", s.capitalize()) # Sadece cümlelerin ilk harfini büyük yap.
print("s.swapcase():", s.swapcase()) # Büyük harfleri küçüğe, küçükleri büyüğe çevir.
print("s.title():", s.title()) # Her kelimenin ilk harfini büyük yap.
1
2
3
4
5
6
7
8
9
10
11
s.upper(): PIJAMALI HASTA YAĞIZ ŞOFÖRE ÇABUCAK GÜVENDI.
s.lower(): pijamalı hasta yağız şoföre çabucak güvendi.
s.capitalize(): Pijamalı hasta yağız şoföre çabucak güvendi.
s.swapcase(): pIJAMALI HASTA YAĞIZ ŞOFÖRE ÇABUCAK GÜVENDI.
s.title(): Pijamalı Hasta Yağız Şoföre Çabucak Güvendi.
Görüldüğü gibi bu fonksiyonlar Türkçedeki i ve I harflerini doğru şekilde işleyemiyorlar. Küçük i harfi büyük I harfine (ve tersine) dönüştürülüyor. Bu yüzden Python’un dize metodları, yazılımda Türkiye testi olarak bilinen testi geçemiyor.
In [16]:
1
2
3
"I İ".lower(), "ı i".upper()
Out[16]:
1
('i i̇', 'I I')
Bu problemin çevresinden dolaşmak için kullanılacak bir yöntemi şuradan öğrenebilirsiniz.
Alt dizeleri saymak: count
Bir dize içinde bir alt dizenin kaç kere geçtiğinin sayısını verir.
In [17]:
1
2
3
"ABCDABCAAABC".count("ABC")
Out[17]:
1
3
Sadece örtüşmeyen alt dizeler sayılır. Sözgelişi, "AAAAA" dizesinin içinde, örtüşmeleri sayarsak "AA" altdizesi 5 kere mevcuttur, ama count 2 sonucunu verir.
In [18]:
1
2
3
"AAAAA".count("AA")
Out[18]:
1
2
Bir alt dizenin yerini bulmak: find, rfind, index, rindex
find metodu, bir dizenin içinde bir alt dizenin ilk bulunduğu konumu verir. Aranan alt dize mevcut değilse -1 döndürür.
In [19]:
1
2
3
4
5
s = "ABRAKADABRA"
s.find("RA")
Out[19]:
1
2
In [20]:
1
2
3
s.find("XYZ")
Out[20]:
1
-1
Konum saymanın sıfır ile başladığını hatırlayın; o yüzden "RA" dizesi üçüncü harfte başlıyor, ama konum indeksi 2.
Dikkat: Amacınız belli bir alt dizenin yerini bulmak değil, sadece mevcut olup olmadığını anlamaksa find yerine in kullanın.
In [21]:
1
2
3
"RA" in s, "XYZ" in s
Out[21]:
1
(True, False)
Aramaya sağdan başlamak isterseniz rfind metodunu kullanın.
In [22]:
1
2
3
s.rfind("RA")
Out[22]:
1
9
index ile find aynı işi yapar. Tek farkları, aranan alt dize bulunamayınca index‘in bir hata işareti ("ValueError") vermesidir. Hata yakalamaya dayalı programlarda tercih edilir.
In [23]:
1
2
3
s.index("RA")
Out[23]:
1
2
In [24]:
1
2
3
s.index("XYZ")
1
2
3
4
5
6
7
8
9
10
11
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-24-de36660908dd> in <module>()
----> 1 s.index("XYZ")
ValueError: substring not found
Aramaya sağdan başlamak isterseniz rindex komutunu kullanabilirsiniz.
Dizeleri birleştirmek: join
Bir sıralı nesnenin (liste, çokuz, dize, vs.) dize tipi elemanlarını birleştirerek yeni bir dize üretir.
In [25]:
1
2
3
"".join(["A","67","B","0.15"]) # yanyana yapıştırır
Out[25]:
1
'A67B0.15'
In [26]:
1
2
3
" ".join(["A","67","B","0.15"]) # araya bir boşluk koyarak yapıştırır
Out[26]:
1
'A 67 B 0.15'
In [27]:
1
2
3
"-*-".join(["A","67","B","0.15"]) # araya -*- koyarak yapıştır
Out[27]:
1
'A-*-67-*-B-*-0.15'
Boşlukları atmak: lstrip, rstrip, strip
Bu metodlar bir dizenin sol ve/veya sağ tarafındaki boş karakterleri (boşluk, kaydırma \t, satırbaşı \n) kaldırır. lstrip soldaki, rstrip sağdaki, strip ise her iki yandaki boşlukları temizler. Bu metodlar özellikle bir dosya satır satır okunurken yararlı olur.
In [28]:
1
2
3
4
5
6
7
8
9
s = """
ferah ferah
"""
s
Out[28]:
1
'\n ferah ferah \n'
In [29]:
1
2
3
s.lstrip()
Out[29]:
1
'ferah ferah \n'
In [30]:
1
2
3
s.rstrip()
Out[30]:
1
'\n ferah ferah'
In [31]:
1
2
3
s.strip()
Out[31]:
1
'ferah ferah'
Değiştirme: replace
Dizede belli bir alt dizenin ortaya çıktığı her yeri başka bir alt dizeyle değiştirir.
In [32]:
1
2
3
4
5
s = "eskişehir'de eski bir evde eski bir kapı"
s.replace("eski", "yeni")
Out[32]:
1
"yenişehir'de yeni bir evde yeni bir kapı"
Tercihe bağlı olarak, soldan itibaren sadece belli sayıda değiştirme de yapılabilir:
In [33]:
1
2
3
s.replace("eski", "yeni", 2)
Out[33]:
1
"yenişehir'de yeni bir evde eski bir kapı"
Bölme: split, rsplit, splitlines
split metodu bir dizedeki kelimeleri belli yerlerden (varsayılan olarak boşluk karakterlerinden) böler ve ortaya çıkan bölümlerden oluşan bir dize listesi verir. Fazlalık boşluklar hesaba katılmaz.
In [34]:
1
2
3
" kedi köpek balık kuş ".split()
Out[34]:
1
['kedi', 'köpek', 'balık', 'kuş']
Boşluk yerine başka bir ayırıcı kullanılabilir. Ayrıcı istenilen sayıda karakterden oluşabilir.
In [35]:
1
2
3
"1,2,3,4,5,6".split(",")
Out[35]:
1
['1', '2', '3', '4', '5', '6']
In [36]:
1
2
3
"a<>b<>c<>d<>e".split("<>")
Out[36]:
1
['a', 'b', 'c', 'd', 'e']
Sadece belli sayıda bölme yapmak da mümkündür. Arta kalan kısım tek bir dizede toplanır.
In [37]:
1
2
3
" kedi köpek balık kuş ".split(maxsplit=2)
Out[37]:
1
['kedi', 'köpek', 'balık kuş ']
Soldan değil sağdan başlayarak ayırmamız gerekirse rsplit metodunu kullanırız.
In [38]:
1
2
3
" kedi köpek balık kuş ".rsplit(maxsplit=2)
Out[38]:
1
[' kedi köpek', 'balık', 'kuş']
Birden fazla satır barındıran bir dizeyi satır sınırlarından bölmek için splitlines metodu kullanılabilir.
In [39]:
1
2
3
4
5
6
7
8
9
10
11
12
13
s = """abcç
defgğ
hıi
jkl"""
s.splitlines()
Out[39]:
1
['abcç', 'defgğ', 'hıi', 'jkl']
splitlines metodu sadece satırbaşı ("\n") ile değil, "\r", "\v", "\f", ve satır sonu sayılan başka birkaç karakter ile de böler. Ayrıca, split‘ten farklı olarak dize sonundaki "\n" karakterini de göz ardı eder. Bir dosyanın içeriğini bütün olarak bir dizeye yüklediyseniz, onu satırlara bölmek için en uygunu splitlines kullanmaktır.