forked from yazbel/python-istihza
-
Notifications
You must be signed in to change notification settings - Fork 0
/
karakter_dizileri.html
1600 lines (1459 loc) · 132 KB
/
karakter_dizileri.html
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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE html>
<html lang="tr">
<html lang="tr">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta content="Python 3.x'te karakter dizileri" name="description" />
<meta content="python, string, karakter dizisi, metotlar, capitalize, 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" name="keywords" />
<title>Karakter Dizileri — Python 3 için Türkçe Kılavuz</title>
<link rel="stylesheet" href="_static/pyramid.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<script id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
<script src="_static/jquery.js"></script>
<script src="_static/underscore.js"></script>
<script src="_static/doctools.js"></script>
<script src="_static/language_data.js"></script>
<script src="_static/translations.js"></script>
<link rel="search" title="Ara" href="search.html" />
<link rel="next" title="Karakter Dizilerinin Metotları" href="karakter_dizilerinin_metotlari1.html" />
<link rel="prev" title="Hata Yakalama" href="hata_yakalama.html" />
<!--[if lte IE 6]>
<link rel="stylesheet" href="_static/ie6.css" type="text/css" media="screen" charset="utf-8" />
<![endif]-->
</head><body>
<div class='header'><a href='https://yazbel.com'>yazbel.com</a></div>
<ul class='navbar'>
<li><a href="#"><del>pdf desteği sonlanmıştır</del></a></li>
<li class="forum"><a href="http://forum.yazbel.com">forum</a></li>
</ul>
<div class="related" role="navigation" aria-label="related navigation">
<h3>Gezinti</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="karakter_dizilerinin_metotlari1.html" title="Karakter Dizilerinin Metotları"
accesskey="N">sonraki</a></li>
<li class="right" >
<a href="hata_yakalama.html" title="Hata Yakalama"
accesskey="P">önceki</a> |</li>
<li class="nav-item nav-item-0"><a href=".">⌂</a></li>
<li class="nav-item nav-item-this"><a href="">Karakter Dizileri</a></li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="body" role="main">
<div class="section" id="karakter-dizileri">
<h1>Karakter Dizileri<a class="headerlink" href="#karakter-dizileri" title="Bu başlık için kalıcı bağlantı">¶</a></h1>
<p>Buraya gelene kadar Python programlama diline ilişkin epey bilgi edindik. Artık
yazdığımız programlarda <code class="docutils literal notranslate"><span class="pre">input()</span></code> fonksiyonu sayesinde kullanıcıyla iletişim
kurabiliyor; <code class="docutils literal notranslate"><span class="pre">if</span></code>, <code class="docutils literal notranslate"><span class="pre">elif</span></code>, <code class="docutils literal notranslate"><span class="pre">else</span></code> deyimleri yardımıyla programlarımızın
karar vermesini sağlayabiliyor; işleçler ve döngüler yoluyla programlarımızı
istediğimiz sayıda çalıştırabiliyoruz. Eğer buraya kadar olan bölümleri
dikkatlice takip ettiyseniz, şu ana kadar öğrendiklerinize dayanarak, Python’ı
giriş düzeyinde bildiğinizi rahatlıkla iddia edebilirsiniz. Zira şimdiye kadar
öğrendiklerinizi kullanarak ufak tefek de olsa işe yarar programlar yazabilecek
durumdasınız.</p>
<p>Buraya kadar öğrendiğimiz bilgiler Python programlama dilinin temellerini
oluşturuyordu. Temel Python bilgilerini edindiğimize göre, artık başlangıç-orta
düzey arası konuları incelemeye başlayabileceğiz.</p>
<p>Bu bölümde, önceki derslerde üstünkörü bakıp geçtiğimiz bir konu olan karakter
dizilerini çok daha derinlemesine ele alacağız. Python programlama dili içindeki
önemi nedeniyle bu bölüm epey uzun olacak.</p>
<p>Aslında biz karakter dizisi kavramının ne olduğunu biliyoruz. Çok kaba bir
şekilde ifade etmek gerekirse, karakter dizileri, adından da anlaşılacağı gibi,
karakterlerin bir araya gelmesiyle oluşan bir dizidir. Karakter dizileri; tek,
çift veya üç tırnak içinde gösterilen, öteki veri tiplerinden de bu tırnaklar
aracılığıyla ayırt edilen özel bir veri tipidir. Teknik olarak ifade etmek
gerekirse, bir nesneyi <code class="docutils literal notranslate"><span class="pre">type()</span></code> fonksiyonu yardımıyla sorguladığımızda, eğer
<cite><class ‘str’></cite> çıktısı alıyorsak bu nesne bir karakter dizisidir.</p>
<p>Her ne kadar ayrıntılarına girmemiş de olsak, dediğimiz gibi, biz karakter
dizilerini daha ilk bölümlerden bu yana her fırsatta kullanıyoruz. Dolayısıyla
bu veri tipinin ne olduğu konusunda bir sıkıntımız yok. Bu bölümde, şimdiye
kadar karakter dizileri ile ilgili öğrendiğimiz şeylere ek olarak, karakter
dizilerin metotlarından da söz edeceğiz.</p>
<p>Peki bu ‘metot’ denen şey de ne oluyor?</p>
<p>Kabaca ifade etmek gerekirse, metotlar Python’da nesnelerin niteliklerini
değiştirmemizi, sorgulamamızı veya bu nesnelere yeni özellikler katmamızı
sağlayan araçlardır. Metotlar sayesinde karakter dizilerini istediğimiz gibi
eğip bükebileceğiz.</p>
<p>Elbette bu bölümde bahsedeceğimiz tek şey karakter dizilerinin metotları
olmayacak. Bu bölümde aynı zamanda karakter dizilerinin yapısı ve özelliklerine
dair söyleyeceklerimiz de olacak.</p>
<p>Python’da şimdiye kadar yapabildiğimiz şeylerin sizi tatmin etmekten uzak
olduğunu, daha fazlasını yapabilmek için sabırsızlandığınızı tahmin
edebiliyorum. O halde ne duruyoruz, hiç vakit kaybetmeden yola koyulalım.</p>
<div class="section" id="karakter-dizilerinin-ogelerine-erismek">
<h2>Karakter Dizilerinin Öğelerine Erişmek<a class="headerlink" href="#karakter-dizilerinin-ogelerine-erismek" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Python ile programlama yaparken karakter dizileri ile iki şekilde
karşılaşabilirsiniz: Birincisi, bir karakter dizisini doğrudan kendiniz
tanımlamış olabilirsiniz. İkincisi, karakter dizisi size başka bir kaynak
aracılığıyla gelmiş olabilir (mesela <code class="docutils literal notranslate"><span class="pre">input()</span></code> fonksiyonu yardımıyla
kullanıcıdan aldığınız bir veri).</p>
<p>Python’da kendi tanımladığınız ya da herhangi başka bir kaynaktan gelen karakter
dizilerine erişmenin birkaç farklı yolu vardır. Örneğin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">nesne</span> <span class="o">=</span> <span class="s2">"karakter dizisi"</span>
</pre></div>
</div>
<p>Burada değeri <cite>“karakter dizisi”</cite> olan <cite>nesne</cite> adlı bir değişken tanımladık.
Yazdığımız programlarda bu değişkene erişmek için, değişkenin adını kullanmamız
yeterlidir. Örneğin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">nesne</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu komut bize karakter dizisinin tamamını verecektir.</p>
<p>Bir karakter dizisini yukarıda gördüğümüz gibi kendimiz tanımlayabiliriz. Bunun
dışında, mesela <code class="docutils literal notranslate"><span class="pre">input()</span></code> fonksiyonuyla kullanıcıdan aldığımız verilerin de
birer karakter dizisi olacağını biliyoruz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">veri</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Herhangi bir şey: "</span><span class="p">)</span>
</pre></div>
</div>
<p>Tıpkı kendi tanımladığımız karakter dizilerinde olduğu gibi, kullanıcıdan gelen
karakter dizilerini de aşağıdaki komut yardımıyla ekranda görüntüleyebiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="n">veri</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu komut da bize <cite>veri</cite> değişkeninin tuttuğu karakter dizisinin tamamını
verecektir.</p>
<p>Ayrıca istersek bu karakter dizilerini bir <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü içine alabilir,
böylece bu dizinin öğelerine tek tek de erişebiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">karakter</span> <span class="ow">in</span> <span class="n">nesne</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="n">karakter</span><span class="p">)</span>
</pre></div>
</div>
<p><code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsüyle elde ettiğimiz bu etkiyi şu kodlar yardımıyla da elde
edebileceğimizi gayet iyi biliyor olmalısınız:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="o">*</span><span class="n">nesne</span><span class="p">,</span> <span class="n">sep</span><span class="o">=</span><span class="s2">"</span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
</pre></div>
</div>
<p>Önceki derslerde verdiğimiz örneklerden de bildiğiniz gibi, karakter dizilerinin
öğelerine yukarıdaki yöntemlerle tek tek erişebilmemiz sayesinde herhangi bir
işlemi karakter dizilerinin bütün öğelerine bir çırpıda uygulayabiliyoruz.
Mesela:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">nesne</span> <span class="o">=</span> <span class="s2">"123456789"</span>
<span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="n">nesne</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">int</span><span class="p">(</span><span class="n">n</span><span class="p">)</span> <span class="o">*</span> <span class="mi">2</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada <cite>nesne</cite> değişkeni içindeki sayı değerli karakter dizilerini <cite>n</cite> olarak
adlandırdıktan sonra, <cite>n</cite> değişkenlerinin her birini tek tek <cite>2</cite> sayısı ile
çarptık. Yani çarpma işlemini karakter dizisinin bütün öğelerine tek seferde
uygulayabildik. Bu arada, yukarıdaki örnekte <cite>nesne</cite> değişkeninin her bir
öğesini <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü içinde <code class="docutils literal notranslate"><span class="pre">int()</span></code> fonksiyonu yardımıyla tam sayıya
çevirdiğimizi görüyorsunuz. Daha önce de defalarca söylediğimiz gibi, Python’da
o anda elinizde olan verinin tipini bilmeniz çok önemlidir. Eğer kendi
yazdığınız veya mesela <code class="docutils literal notranslate"><span class="pre">input()</span></code> fonksiyonundan gelen bir verinin karakter
dizisi olduğunu bilmezseniz yukarıdaki kodları şu şekilde yazma gafletine
düşebilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">nesne</span> <span class="o">=</span> <span class="s2">"123456789"</span>
<span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="n">nesne</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="n">n</span> <span class="o">*</span> <span class="mi">2</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu kodlar çalıştırıldıktan sonra hiç beklemediğiniz sonuçlar verecektir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="mi">11</span>
<span class="mi">22</span>
<span class="mi">33</span>
<span class="mi">44</span>
<span class="mi">55</span>
<span class="mi">66</span>
<span class="mi">77</span>
<span class="mi">88</span>
<span class="mi">99</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, aslında <cite>nesne</cite> içindeki öğeleri <cite>2</cite> ile çarpmak isterken, biz
her bir öğeyi iki kez ekrana yazdırmış olduk. Çünkü bildiğiniz gibi karakter
dizileri ile aritmetik işlemler yapamıyoruz. Eğer sayı değerli karakter dizileri
arasında aritmetik işlem yapacaksak öncelikle bu karakter dizilerini sayıya
çevirmemiz gerekir. Ayrıca gerçek bir program içinde yukarıdaki gibi bir durumun
ne kadar yıkıcı sonuçlar doğuracabileceğini düşünün. Yukarıdaki program çalışma
sırasında hiçbir hata vermeyeceği için, siz programınızın düzgün çalıştığını
zannederek hayatınıza devam edeceksiniz. Ama belki de yukarıdaki sinsi hata
yüzünden, programınızı kullanan bir şirket veri, zaman ve para kaybına
uğrayacak.</p>
<p>Yukarıdaki örneklerde bir şey daha dikkatinizi çekmiş olmalı: Gördüğünüz gibi,
karakter dizisinin öğelerine erişirken bu öğelerin tamamını elde ediyoruz.
Mesela <code class="docutils literal notranslate"><span class="pre">print(nesne)</span></code> komutunu verdiğimizde veya <cite>nesne</cite> değişkenini bir döngü
içine aldığımızda sonuç olarak elde ettiğimiz şey, ilgili karakter dizisinin
tamamıdır. Yani aslında karakter dizisinin hangi öğesine erişeceğimizi
seçemiyoruz. Peki ya biz bir karakter dizisinin öğelerinin tamamına değil de,
sadece tek bir öğesine erişmek istersek ne yapacağız? Mesela yukarıdaki örnekte
<cite>nesne</cite> adlı değişken içindeki sayıların tamamını değil de sadece tek bir
öğesini (veya belli bir ölçüte göre yalnızca bazı öğelerini) <cite>2</cite> ile çarpmak
istersek nasıl bir yol izleyeceğiz?</p>
<p>Python’da karakter dizilerinin içindeki öğelerin bir sırası vardır. Örneğin
<cite>“Python”</cite> dediğimizde, bu karakter dizisinin ilk öğesi olan <cite>“P”</cite> karakterinin
sırası <cite>0</cite>’dır. <cite>“y”</cite> karakteri ise <cite>1.</cite> sıradadır. Aynı şekilde devam edersek,
<cite>“t”</cite> karakteri <cite>2.</cite>, <cite>“h”</cite> karakteri <cite>3.</cite>, <cite>“o”</cite> karakteri <cite>4.</cite>, <cite>“n”</cite>
karakteri ise <cite>5.</cite> sırada yer alır.</p>
<p>Bu anlattığımız soyut durumu bir örnekle somutlaştırmaya çalışalım:</p>
<p>Dedik ki, <cite>“Python”</cite> gibi bir karakter dizisinin her bir öğesinin belli bir
sırası vardır. İşte eğer biz bu karakter dizisinin bütün öğelerini değil de,
sadece belli karakterlerini almak istersek, karakter dizisindeki öğelerin sahip
olduğu bu sıradan yararlanacağız.</p>
<p>Diyelim ki <cite>“Python”</cite> karakter dizisinin ilk karakterini almak istiyoruz. Yani
biz bu karakter dizisinin sadece <cite>“P”</cite> harfine ulaşmayı amaçlıyoruz.</p>
<p>Bu isteğimizi nasıl yerine getirebileceğimizi basit bir örnek üzerinde
göstermeye çalışalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"Python"</span>
</pre></div>
</div>
<p>Burada değeri <cite>“Python”</cite> olan <cite>kardiz</cite> adlı bir değişken tanımladık. Şimdi bu
karakter dizisinin ilk öğesine erişeceğiz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="go">'P'</span>
</pre></div>
</div>
<p>Burada yaptığımız işleme çok dikkat edin. Karakter dizisinin istediğimiz bir
öğesine ulaşmak için, ilgili öğenin sırasını köşeli parantezler içinde
belirttik. Biz bu örnekte karakter dizisinin ilk öğesine ulaşmak istediğimiz
için köşeli parantez içinde <cite>0</cite> sayısını kullandık.</p>
<p>Şimdi de, ilk verdiğimiz örnekteki <cite>nesne</cite> değişkeni içinde yer alan sayılar
arasından sadece birini <cite>2</cite> ile çarpmak istediğimizi düşünelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">nesne</span> <span class="o">=</span> <span class="s2">"123456789"</span>
<span class="gp">>>> </span><span class="nb">int</span><span class="p">(</span><span class="n">nesne</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span> <span class="o">*</span> <span class="mi">2</span>
<span class="go">4</span>
</pre></div>
</div>
<p>Burada da öncelikle <cite>nesne</cite> değişkeninin birinci sırasında yer alan öğeyi
(dikkat: sıfırıncı sırada yer alan öğeyi değil!) elde etmek için köşeli
parantezler içinde <cite>1</cite> sayısını kullandık. Daha sonra <code class="docutils literal notranslate"><span class="pre">int()</span></code> fonksiyonu
yardımıyla bu karakter dizisini tam sayıya çevirdik, ki bununla aritmetik işlem
yapabilelim… Son olarak da elimizdeki tam sayıyı <cite>2</cite> ile çarparak istediğimiz
sonuca ulaştık.</p>
<p>Elbette yukarıdaki kodları şöyle de yazabilirdik:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">nesne</span> <span class="o">=</span> <span class="s2">"123456789"</span>
<span class="gp">>>> </span><span class="n">sayı</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">nesne</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">sayı</span> <span class="o">*</span> <span class="mi">2</span>
<span class="go">4</span>
</pre></div>
</div>
<p>Belki farkındasınız, belki de değilsiniz, ama aslında şu noktada karakter
dizilerinin çok önemli bir özelliği ile karşı karşıyayız. Gördüğünüz gibi,
yukarıda bahsettiğimiz sıra kavramı sayesinde Python’da karakter dizilerinin
bütün öğelerine tek tek ve herhangi bir sıra gözetmeksizin erişmemiz mümkün.
Mesela yukarıdaki ilk örnekte <code class="docutils literal notranslate"><span class="pre">kardiz[0]</span></code> gibi bir yapı kullanarak karakter
dizisinin sıfırıncı (yani ilk) öğesini, <code class="docutils literal notranslate"><span class="pre">nesne[1]</span></code> gibi bir yapı kullanarak da
karakter dizisinin birinci (yani aslında ikinci) öğesini alabildik.</p>
<p>Bu yapının mantığını kavramak için şu örnekleri dikkatlice inceleyin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"Python"</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="go">'P'</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
<span class="go">'y'</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span>
<span class="go">'h'</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="mi">5</span><span class="p">]</span>
<span class="go">'n'</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span>
<span class="go">'t'</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="mi">4</span><span class="p">]</span>
<span class="go">'o'</span>
<span class="gp">>>> </span><span class="n">nesne</span> <span class="o">=</span> <span class="s2">"123456789"</span>
<span class="gp">>>> </span><span class="n">nesne</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="go">'1'</span>
<span class="gp">>>> </span><span class="n">nesne</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
<span class="go">'2'</span>
<span class="gp">>>> </span><span class="n">nesne</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span>
<span class="go">'3'</span>
<span class="gp">>>> </span><span class="n">nesne</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span>
<span class="go">'4'</span>
<span class="gp">>>> </span><span class="n">nesne</span><span class="p">[</span><span class="mi">4</span><span class="p">]</span>
<span class="go">'5'</span>
<span class="gp">>>> </span><span class="n">nesne</span><span class="p">[</span><span class="mi">5</span><span class="p">]</span>
<span class="go">'6'</span>
<span class="gp">>>> </span><span class="n">nesne</span><span class="p">[</span><span class="mi">6</span><span class="p">]</span>
<span class="go">'7'</span>
<span class="gp">>>> </span><span class="n">nesne</span><span class="p">[</span><span class="mi">7</span><span class="p">]</span>
<span class="go">'8'</span>
<span class="gp">>>> </span><span class="n">nesne</span><span class="p">[</span><span class="mi">8</span><span class="p">]</span>
<span class="go">'9'</span>
</pre></div>
</div>
<p>Burada şöyle bir formül yazabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">karakter_dizisi</span><span class="p">[</span><span class="n">öğe_sırası</span><span class="p">]</span>
</pre></div>
</div>
<p>Bu formülü uygulayarak karakter dizilerinin her bir öğesine tek tek erişmemiz
mümkün. Burada çok önemli bir noktaya daha dikkatinizi çekmek isterim.
Yukarıdaki örneklerden de gördüğünüz gibi, Python’da öğe sıralaması <cite>0</cite>’dan
başlıyor. Yani bir karakter dizisinin ilk öğesinin sırası <cite>0</cite> oluyor. Python
programlama dilini özellikle yeni öğrenenlerin en sık yaptığı hatalardan biri de
bir karakter dizisinin ilk öğesine ulaşmak için <cite>1</cite> sayısını kullanmalarıdır.
Asla unutmayın, Python saymaya her zaman <cite>0</cite>’dan başlar. Dolayısıyla bir
karakter dizisinin ilk öğesinin sırası <cite>0</cite>’dır. Eğer ilk öğeye ulaşayım derken
<cite>1</cite> sayısını kullanırsanız ulaştığınız öğe ilk öğe değil, ikinci öğe olacaktır.
Bu ayrıntıyı gözden kaçırmamaya dikkat etmelisiniz.</p>
<p>Karakter dizilerinin öğelerine tek tek erişirken dikkat etmemiz gereken önemli
noktalardan biri de, öğe sırası belirtirken, karakter dizisinin toplam uzunluğu
dışına çıkmamaktır. Yani mesela <cite>7</cite> karakterlik bir karakter dizimiz varsa, bu
karakter dizisinin son öğesinin sırası <cite>6</cite> olacaktır. Çünkü biliyorsunuz, Python
saymaya <cite>0</cite>’dan başlıyor. Dolayısıyla ilk karakterin sırası <cite>0</cite> olacağı için,
<cite>7</cite> karakterlik bir karakter dizisinde son öğenin sırası <cite>6</cite> olacaktır.
Örneğin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"istihza"</span>
<span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="n">kardiz</span><span class="p">)</span>
<span class="go">7</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <cite>“istihza”</cite> adlı karakter dizisinin uzunluğu <cite>7</cite>. Yani bu
karakter dizisi içinde <cite>7</cite> adet karakter var. Bu karakter dizisini incelemeye
devam edelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="go">'i'</span>
</pre></div>
</div>
<p>Dediğimiz gibi, karakter dizisinin ilk öğesinin sırası <cite>0</cite>. Dolayısıyla son
öğenin sırası <cite>6</cite> olacaktır:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="mi">6</span><span class="p">]</span>
<span class="go">'a'</span>
</pre></div>
</div>
<p>Bu durumu şöyle formüle edebiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="nb">len</span><span class="p">(</span><span class="n">kardiz</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
</pre></div>
</div>
<p>Yani;</p>
<blockquote>
<div><p>Bir karakter dizisinin uzunluğunun <cite>1</cite> eksiği, o karakter dizisinin son
öğesini verir.</p>
</div></blockquote>
<p>Yukarıdaki formülü eğer şöyle yazsaydık hata alırdık:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="nb">len</span><span class="p">(</span><span class="n">kardiz</span><span class="p">)]</span>
<span class="gt">Traceback (most recent call last):</span>
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>, in <span class="n"><module></span>
<span class="gr">IndexError</span>: <span class="n">string index out of range</span>
</pre></div>
</div>
<p>Çünkü <code class="docutils literal notranslate"><span class="pre">len(kardiz)</span></code> kodu bize karakter dizisinin uzunluğunu veriyor. Yani
yukarıdaki <cite>“istihza”</cite> karakter dizisini göz önüne alırsak, <code class="docutils literal notranslate"><span class="pre">len(kardiz)</span></code>
çıktısı <cite>7</cite> olacaktır. Dolayısıyla <cite>“istihza”</cite> karakter dizisinin son öğesine
ulaşmak istersek bu değerin 1 eksiğini almamız gerekiyor. Yani
<code class="docutils literal notranslate"><span class="pre">len(kardiz)-1</span></code>.</p>
<p>Şu ana kadar öğe sırası olarak hep artı değerli sayılar kullandık. Ancak
istersek öğe sırası olarak eksi değerli sayıları da kullanabiliriz. Eğer bir
karakter dizisine öğe sırası olarak eksi değerli bir sayı verirsek Python o
karakter dizisini sondan başa doğru okumaya başlayacaktır. Yani:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
<span class="go">'a'</span>
</pre></div>
</div>
<p>Gördüğünüz gibi <cite>-1</cite> sayısı karakter dizisini tersten okuyup, sondan başa doğru
ilk öğeyi veriyor. Dolayısıyla, yukarıda anlattığımız <code class="docutils literal notranslate"><span class="pre">len(kardiz)-1</span></code>
yönteminin yanısıra, <cite>-1</cite> sayısını kullanarak da karakter dizilerinin son
karakterini elde edebiliyoruz. Bir de şuna bakalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="o">-</span><span class="mi">2</span><span class="p">]</span>
<span class="go">'z'</span>
</pre></div>
</div>
<p>Dediğimiz gibi, eksi değerli sayılar karakter dizisindeki karakterleri sondan
başa doğru elde etmemizi sağlar. Dolayısıyla <cite>-2</cite> sayısı, karakter dizisinde
sondan bir önceki karakteri verecektir.</p>
<p>Karakter dizilerinin öğelerine tek tek erişmek amacıyla öğe sırası belirtirken,
karakter dizisinin toplam uzunluğu dışına çıkmamamız gerektiğini söylemiştik.
Peki karakter dizisinin uzunluğunu aşan bir sayı verirsek ne olur? Ne olacağını
yukarıdaki örneklerden birinde görmüştük aslında. Ama konunun öneminden dolayı
bir kez daha tekrar edelim.</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"istihza"</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="mi">7</span><span class="p">]</span>
<span class="gt">Traceback (most recent call last):</span>
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>, in <span class="n"><module></span>
<span class="gr">IndexError</span>: <span class="n">string index out of range</span>
</pre></div>
</div>
<p>…veya:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="o">-</span><span class="mi">8</span><span class="p">]</span>
<span class="gt">Traceback (most recent call last):</span>
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>, in <span class="n"><module></span>
<span class="gr">IndexError</span>: <span class="n">string index out of range</span>
</pre></div>
</div>
<p>Eğer karakter dizisinin uzunluğunu aşan bir sayı belirtirsek Python bize
<code class="docutils literal notranslate"><span class="pre">IndexError</span></code> türünde bir hata mesajı verecektir.</p>
<p>Gördüğünüz gibi, <code class="docutils literal notranslate"><span class="pre">kardiz[0]</span></code>, <code class="docutils literal notranslate"><span class="pre">kardiz[1]</span></code>, <code class="docutils literal notranslate"><span class="pre">kardiz[2]</span></code>, vb. komutlarla
karakter dizisinin öğelerine erişebiliyoruz. Burada öğe sıralarını tek tek
yazmak yerine <code class="docutils literal notranslate"><span class="pre">range()</span></code> fonksiyonunu kullanarak da öğelere tek tek
erişebilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">7</span><span class="p">):</span>
<span class="nb">print</span><span class="p">(</span><span class="n">kardiz</span><span class="p">[</span><span class="n">i</span><span class="p">])</span>
</pre></div>
</div>
<p>Bu kodlarda, <code class="docutils literal notranslate"><span class="pre">kardiz[0]</span></code>, <code class="docutils literal notranslate"><span class="pre">kardiz[1]</span></code>, <code class="docutils literal notranslate"><span class="pre">kardiz[2]</span></code> şeklinde öğe sıralarını
tek tek elle yazmak yerine, <code class="docutils literal notranslate"><span class="pre">range(7)</span></code> aralığındaki sayıları bir <cite>for</cite>
döngüsüne alıyoruz. Böylece Python <code class="docutils literal notranslate"><span class="pre">kardiz[öğe_sırası]</span></code> gibi bir yapı içinde
<cite>öğe_sırası</cite> yerine <code class="docutils literal notranslate"><span class="pre">range(7)</span></code> aralığındaki bütün sayıları (yani <cite>0</cite>, <cite>1</cite>,
<cite>2</cite>, <cite>3</cite>, <cite>4</cite>, <cite>5</cite>, <cite>6</cite> sayılarını) tek tek uyguluyor.</p>
<p>Burada aklınıza hemen şöyle bir soru gelmiş olabilir:</p>
<blockquote>
<div><p>Biz kendi tanımladığımız karakter dizisinin uzunluğunun toplam <cite>7</cite> karakter
olduğunu bildiğimiz için yukarıdaki örnekte <code class="docutils literal notranslate"><span class="pre">range()</span></code> fonksiyonunu
<code class="docutils literal notranslate"><span class="pre">range(7)</span></code> şeklinde kullanabildik. Ama başka kaynaktan gelen bir karakter
dizisinin uzunluğunu nasıl bileceğiz?</p>
</div></blockquote>
<p>Aslında bu sorunun cevabı çok basit. Uzunluğunu bilmediğiniz karakter dizileri
için <code class="docutils literal notranslate"><span class="pre">range()</span></code> fonksiyonuyla birlikte <code class="docutils literal notranslate"><span class="pre">len()</span></code> fonksiyonundan
yararlanabilirsiniz. Nasıl mı? Hemen bir örnek verelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">karakter</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">kardiz</span><span class="p">)):</span>
<span class="nb">print</span><span class="p">(</span><span class="n">kardiz</span><span class="p">[</span><span class="n">karakter</span><span class="p">])</span>
</pre></div>
</div>
<p>Burada <code class="docutils literal notranslate"><span class="pre">range()</span></code> fonksiyonuna verdiğimiz <cite>len(kardiz)</cite> parametresine
dikkatlice bakın. Biz <cite>kardiz</cite> adlı değişkenin tuttuğu karakter dizisinin <cite>7</cite>
karakterden oluştuğunu biliyoruz. Ama eğer bu karakter dizisini biz
belirlememişsek, karakter dizisinin tam olarak kaç karakterden oluşacağını
bilemeyiz. Bu kodlarda <code class="docutils literal notranslate"><span class="pre">len(kardiz)</span></code> ifadesini kullanarak, sabit bir değer
belirlemekten kaçınmış oluyoruz. Böylece, mesela kullanıcıdan aldığımız bir
karakter dizisinin kaç karakterden oluştuğunu belirleme görevini Python’a
bırakmış oluyoruz. Karakter dizisinin uzunluğu ne ise (<code class="docutils literal notranslate"><span class="pre">len(kardiz)</span></code>), Python
<code class="docutils literal notranslate"><span class="pre">range()</span></code> fonksiyonuna o sayıyı parametre olarak kendisi atayacaktır.</p>
<p>Yukarıdaki durumu daha iyi anlayabilmek için bir örnek daha verelim. Diyelim ki
kullanıcıya ismini sorup, kendisine şöyle bir çıktı vermek istiyorsunuz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">isminizin</span> <span class="mf">1.</span> <span class="n">harfi</span> <span class="o">...</span>
<span class="n">isminizin</span> <span class="mf">2.</span> <span class="n">harfi</span> <span class="o">...</span>
<span class="n">isminizin</span> <span class="mf">3.</span> <span class="n">harfi</span> <span class="o">...</span>
<span class="o">...</span>
</pre></div>
</div>
<p>Bunu yapabilmek için şöyle bir uygulama yazabilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">isim</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"isminiz: "</span><span class="p">)</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">isim</span><span class="p">)):</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"isminizin </span><span class="si">{}</span><span class="s2">. harfi: </span><span class="si">{}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">isim</span><span class="p">[</span><span class="n">i</span><span class="p">]))</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, kullanıcının girdiği kelimenin uzunluğu kaç ise o sayı otomatik
olarak <code class="docutils literal notranslate"><span class="pre">range()</span></code> fonksiyonuna atanıyor. Diyelim ki kullanıcı Ferhat ismini
girmiş olsun. Bu kelimede toplam <cite>6</cite> karakter var. Dolayısıyla Python <code class="docutils literal notranslate"><span class="pre">for</span></code>
satırını şöyle yorumlayacaktır:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">6</span><span class="p">):</span>
<span class="o">...</span>
</pre></div>
</div>
<p>Python <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsünün ilk turunda şöyle bir işlem gerçekleştirir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="s2">"isminizin </span><span class="si">{}</span><span class="s2">. harfi: </span><span class="si">{}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="n">isim</span><span class="p">[</span><span class="mi">0</span><span class="p">]))</span>
</pre></div>
</div>
<p>İkinci turda ise şöyle bir işlem:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="s2">"isminizin </span><span class="si">{}</span><span class="s2">. harfi: </span><span class="si">{}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">isim</span><span class="p">[</span><span class="mi">1</span><span class="p">]))</span>
</pre></div>
</div>
<div class="figure align-right" id="id1" style="width: 300px">
<a class="reference external image-reference" href="_images/misc/string_index.png"><img alt="_images/string_index.png" src="_images/string_index.png" style="width: 300px; height: 159px;" /></a>
<p class="caption"><span class="caption-text">Annenizin kızlık soyadının 0. harfi [<a class="reference external" href="http://pic.twitter.com/u1IE6Mma">kaynak</a>]</span><a class="headerlink" href="#id1" title="Bu resmin kalıcı bağlantısı">¶</a></p>
</div>
<p>Bu döngü <cite>6</cite> sayısına gelene kadar devam eder. Burada <cite>i</cite> adlı değişkenin
değerinin her döngüde nasıl değiştiğine dikkat edin. Python <cite>i</cite> adını verdiğimiz
değişkene, <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsünün her turunda sırasıya <cite>0</cite>, <cite>1</cite>, <cite>2</cite>, <cite>3</cite>, <cite>4</cite> ve
<cite>5</cite> sayılarını atayacağı için <cite>isim</cite> adlı değişkenin öğeleri
<code class="docutils literal notranslate"><span class="pre">isim[öğe_sırası]</span></code> formülü sayesinde tek tek ekrana dökülecektir.</p>
<p>Yalnız bu kodların çıktısında iki nokta dikkatinizi çekmiş olmalı. Birincisi,
<cite>isminizin 0. harfi f</cite> gibi bir çıktıyı kullanıcılarınız yadırgayabilir. Çünkü
‘<cite>0.</cite> harf’ çok yapay duran bir ifade. Onun yerine ilk harfi ‘1. harf’ olarak
adlandırmamız çok daha mantıklı olacaktır. Bunun için kodlarınıza şu basit
eklemeyi yapabilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">isim</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"isminiz: "</span><span class="p">)</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">isim</span><span class="p">)):</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"isminizin </span><span class="si">{}</span><span class="s2">. harfi: </span><span class="si">{}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,</span> <span class="n">isim</span><span class="p">[</span><span class="n">i</span><span class="p">]))</span>
</pre></div>
</div>
<p>Burada ilk <cite>i</cite> değişkeninin değerini <cite>1</cite> sayı artırdık. Böylece <cite>0</cite> sayısı
<cite>1</cite>’e, <cite>1</cite> sayısı <cite>2</cite>’ye, <cite>2</cite> sayısı <cite>3</cite>’e… dönüşmüş oldu. Bu şekilde
kullanıcılarınıza çok daha doğal görünen bir çıktı verebilmiş oluyorsunuz. Eğer
bu işlemi yapmazsanız, kullanıcılarınızın ‘doğal görünmeyen’ bir çıktı
almalarının yanısıra, programınızın verdiği çıktı kimi durumlarda epey yanıltıcı
da olabilir…</p>
</div>
<div class="section" id="karakter-dizilerini-dilimlemek">
<h2>Karakter Dizilerini Dilimlemek<a class="headerlink" href="#karakter-dizilerini-dilimlemek" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Bir önceki bölümde bir karakter dizisinin istediğimiz öğesini, o öğenin sırasını
belirterek nasıl elde edebileceğimizi gördük. Bu bölümde de benzer bir şey
yapacağız. Ama burada yapacağımız şey, bir önceki bölümde yaptığımız işleme göre
biraz daha kapsamlı bir işlem olacak.</p>
<p>Bu bölümde karakter dizilerini ‘dilimlemekten’ söz edeceğiz. Peki ‘dilimlemek’
derken neyi kastediyoruz? Aslında burada gerçek anlamda ‘karpuz gibi
dilimlemekten’ söz ediyoruz… Şu örnek, ne demek istediğimizi daha net ortaya
koyacaktır:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">site</span> <span class="o">=</span> <span class="s2">"www.istihza.com"</span>
<span class="gp">>>> </span><span class="n">site</span><span class="p">[</span><span class="mi">4</span><span class="p">:</span><span class="mi">11</span><span class="p">]</span>
<span class="go">'istihza'</span>
<span class="gp">>>> </span><span class="n">site</span><span class="p">[</span><span class="mi">12</span><span class="p">:</span><span class="mi">16</span><span class="p">]</span>
<span class="go">'com'</span>
<span class="gp">>>> </span><span class="n">site</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">3</span><span class="p">]</span>
<span class="go">'www'</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, karakter dizisine köşeli parantez içinde bazı değerler vererek
bu karakter dizisini dilim dilim ayırdık. Peki bunu nasıl yaptık? Yukarıdaki
örneklerde şöyle bir yapı gözümüze çarpıyor:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">karakter_dizisi</span><span class="p">[</span><span class="n">alınacak_ilk_öğenin_sırası</span><span class="p">:</span><span class="n">alınacak_son_öğenin_sırasının_bir_fazlası</span><span class="p">]</span>
</pre></div>
</div>
<p>Bu formülü çok basit bir örneğe uygulayalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">karakter_dizisi</span> <span class="o">=</span> <span class="s2">"istanbul"</span>
<span class="gp">>>> </span><span class="n">karakter_dizisi</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">3</span><span class="p">]</span>
<span class="go">'ist'</span>
</pre></div>
</div>
<p>Burada alacağımız ilk öğenin sıra numarası <cite>0</cite>. Yani <cite>“istanbul”</cite> karakter
dizisindeki ‘i’ harfi. Alacağımız son öğenin sıra numarasının 1 fazlası ise <cite>3</cite>.
Yani <cite>2.</cite> sıradaki ‘t’ harfi. İşte <code class="docutils literal notranslate"><span class="pre">karakter_dizisi[0:3]</span></code> dediğimizde, Python
<cite>0.</cite> öğe ile <cite>3.</cite> öğe arasında kalan bütün öğeleri bize verecektir. Bizim
örneğimizde bu aralıktaki öğeler ‘i’, ‘s’ ve ‘t’ harfleri. Dolayısıyla Python
bize ‘istanbul’ kelimesindeki ‘ist’ kısmını dilimleyip veriyor.</p>
<p>Bu bilgileri kullanarak şöyle bir uygulama yazalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">site1</span> <span class="o">=</span> <span class="s2">"www.google.com"</span>
<span class="n">site2</span> <span class="o">=</span> <span class="s2">"www.istihza.com"</span>
<span class="n">site3</span> <span class="o">=</span> <span class="s2">"www.yahoo.com"</span>
<span class="n">site4</span> <span class="o">=</span> <span class="s2">"www.gnu.org"</span>
<span class="k">for</span> <span class="n">isim</span> <span class="ow">in</span> <span class="n">site1</span><span class="p">,</span> <span class="n">site2</span><span class="p">,</span> <span class="n">site3</span><span class="p">,</span> <span class="n">site4</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"site: "</span><span class="p">,</span> <span class="n">isim</span><span class="p">[</span><span class="mi">4</span><span class="p">:</span><span class="o">-</span><span class="mi">4</span><span class="p">])</span>
</pre></div>
</div>
<p>Bu örnek Python’da dilimleme işlemlerinin yapısı ve özellikleri hakkında bize
epey bilgi veriyor. Gördüğünüz gibi, hem artı hem de eksi değerli sayıları
kullanabiliyoruz. Önceki bölümden hatırlayacağınız gibi, eğer verilen sayı eksi
değerliyse Python karakter dizisini sağdan sola (yani sondan başa doğru)
okuyacaktır. Yukarıdaki örnekte <code class="docutils literal notranslate"><span class="pre">isim[4:-4]</span></code> yapısını kullanarak, <cite>site1</cite>,
<cite>site2</cite>, <cite>site3</cite>, <cite>site4</cite> adlı karakter dizilerini, ilk dört ve son dört
karakterler hariç olacak şekilde dilimledik. Böylece elimizde ilk dört ve son
dört karakter arasındaki bütün karakterler kalmış oldu. Yani <cite>“google”</cite>,
<cite>“istihza”</cite>, <cite>“yahoo”</cite> ve <cite>“gnu”</cite>.</p>
<p>Bütün bu anlattıklarımızı daha iyi anlayabilmek için bir örnek daha verelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">ata1</span> <span class="o">=</span> <span class="s2">"Akıllı bizi arayıp sormaz deli bacadan akar!"</span>
<span class="n">ata2</span> <span class="o">=</span> <span class="s2">"Ağa güçlü olunca kul suçlu olur!"</span>
<span class="n">ata3</span> <span class="o">=</span> <span class="s2">"Avcı ne kadar hile bilirse ayı da o kadar yol bilir!"</span>
<span class="n">ata4</span> <span class="o">=</span> <span class="s2">"Lafla pilav pişse deniz kadar yağ benden!"</span>
<span class="n">ata5</span> <span class="o">=</span> <span class="s2">"Zenginin gönlü oluncaya kadar fukaranın canı çıkar!"</span>
</pre></div>
</div>
<p>Burada beş adet atasözü verdik. Bizim görevimiz, bu atasözlerinin sonunda
bulunan ünlem işaretlerini ortadan kaldırmak:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">ata</span> <span class="ow">in</span> <span class="n">ata1</span><span class="p">,</span> <span class="n">ata2</span><span class="p">,</span> <span class="n">ata3</span><span class="p">,</span> <span class="n">ata4</span><span class="p">,</span> <span class="n">ata5</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="n">ata</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="o">-</span><span class="mi">1</span><span class="p">])</span>
</pre></div>
</div>
<p>Burada yaptığımız şey şu: <cite>ata1</cite>, <cite>ata2</cite>, <cite>ata3</cite>, <cite>ata4</cite> ve <cite>ata5</cite> adlı
değişkenlerin her birini <cite>ata</cite> olarak adlandırdıktan sonra <cite>ata</cite> adlı değişkenin
en başından en sonuna kadar olan kısmı dilimleyip aldık. Yani <code class="docutils literal notranslate"><span class="pre">ata[0]</span></code> ile
<code class="docutils literal notranslate"><span class="pre">ata[-1]</span></code> arasında kalan bütün karakterleri elde etmiş olduk. Peki bu ünlem
işaretlerini kaldırdıktan sonra bunların yerine birer nokta koymak istersek ne
yapacağız?</p>
<p>O da çok basit bir işlem:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">ata</span> <span class="ow">in</span> <span class="n">ata1</span><span class="p">,</span> <span class="n">ata2</span><span class="p">,</span> <span class="n">ata3</span><span class="p">,</span> <span class="n">ata4</span><span class="p">,</span> <span class="n">ata5</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="n">ata</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span> <span class="o">+</span> <span class="s2">"."</span><span class="p">)</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, son karakter olan ünlem işaretini attıktan sonra onun yerine
bir nokta işareti koymak için yaptığımız tek şey, dilimlediğimiz karakter
dizisine, artı işareti (<cite>+</cite>) yardımıyla bir <cite>.</cite> karakteri eklemekten ibarettir.</p>
<p>Böylece karakter dizilerini nasıl dilimleyeceğimizi öğrenmiş olduk. Bu konuyu
kapatmadan önce dilimlemeye ilişkin bazı ayrıntılardan söz edelim. Diyelim ki
elimizde şöyle bir karakter dizisi var:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"Sana Gül Bahçesi Vadetmedim"</span>
</pre></div>
</div>
<p>Bu karakter dizisi içinden sadece ‘Sana’ kısmını dilimlemek için şöyle bir şey
yazabileceğimizi biliyorsunuz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">4</span><span class="p">]</span>
<span class="go">'Sana'</span>
</pre></div>
</div>
<p>Burada <cite>0.</cite> karakterden <cite>4.</cite> karaktere kadar olan kısmı dilimlemiş oluyoruz.
Python bize bu tür durumlarda şöyle bir kolaylık sağlar: Eğer karakter dizisi
içinden alınan ilk karakterin sırasını gösteren sayı <cite>0</cite> ise, bu sayıyı
belirtmesek de olur. Yani <code class="docutils literal notranslate"><span class="pre">kardiz[0:4]</span></code> kodunu şöyle de yazabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[:</span><span class="mi">4</span><span class="p">]</span>
<span class="go">'Sana'</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, ilk sıra sayısını yazmazsak Python ilk sayıyı <cite>0</cite> kabul ediyor.</p>
<p>Şimdi de aynı karakter dizisi içindeki ‘Vadetmedim’ kısmını dilimlemeye
çalışalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="mi">17</span><span class="p">:</span><span class="mi">27</span><span class="p">]</span>
<span class="go">'Vadetmedim'</span>
</pre></div>
</div>
<p>Burada da <cite>17.</cite> karakter ile <cite>27.</cite> karakter arasında kalan bütün karakterleri
dilimledik. Tıpkı, alacağımız ilk karakterin sırası <cite>0</cite> olduğunda bu sayıyı
belirtmemize gerek olmadığı gibi, alacağımız son karakterin sırası karakter
dizisinin sonuncu karakterine denk geliyorsa o sayıyı da yazmamıza gerek yok.
Yani yukarıdaki <code class="docutils literal notranslate"><span class="pre">kardiz[17:27]</span></code> kodunu şöyle de yazabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="mi">17</span><span class="p">:]</span>
<span class="go">'Vadetmedim'</span>
</pre></div>
</div>
<p>Python’daki bu dilimleme özelliğini kullanarak karakter dizilerini istediğiniz
gibi eğip bükebilir, evirip çevirebilirsiniz.</p>
<p>Python’daki bu dilimleme yapısı ilk bakışta gözünüze biraz karmaşıkmış gibi
görünebilir. Ama aslında hiç de öyle değildir. Bu yapının mantığını bir kez
kavradıktan sonra kodlarınızı hatasız bir şekilde yazabilirsiniz.</p>
<p>Dilimleme yapısını daha iyi anlayabilmek için kendi kendinize bazı denemeler
yapmanızı tavsiye ederim. Bu yapının nasıl çalıştığını anlamanın en iyi yolu bol
bol örnek kod yazmaktır.</p>
</div>
<div class="section" id="karakter-dizilerini-ters-cevirmek">
<h2>Karakter Dizilerini Ters Çevirmek<a class="headerlink" href="#karakter-dizilerini-ters-cevirmek" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Eğer amacınız bir karakter dizisini ters çevirmek, yani karakter dizisi içindeki
her bir öğeyi tersten yazdırmaksa biraz önce öğrendiğimiz dilimleme yöntemini
kullanabilirsiniz. Dikkatlice bakın:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[::</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
<span class="go">'midemtedaV iseçhaB lüG anaS'</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <cite>“Sana Gül Bahçesi Vadetmedim”</cite> adlı karakter dizisi içindeki
bütün karakterler sondan başa doğru ekrana dizildi.</p>
<p>Aslında bu komutla Python’a şöyle bir emir vermiş oluyoruz:</p>
<blockquote>
<div><p><cite>kardiz</cite> değişkeni içindeki bütün karakterleri, en son karakterden ilk
karaktere kadar sondan başa doğru tek tek ekrana yazdır!</p>
</div></blockquote>
<p>Bildiğiniz gibi, eğer almak istediğimiz karakter, dizi içindeki ilk karakterse
bu karakterin dizi içindeki sırasını belirtmemize gerek yok. Aynı şekilde, eğer
almak istediğimiz karakter, dizi içindeki son karakterse, bu karakterin de dizi
içindeki sırasını belirtmemize gerek yok. İşte yukarıdaki örnekte bu kuraldan
yararlandık.</p>
<p>Eğer bir karakter dizisinin tamamının değil de, sadece belli bir kısmının ters
çevrilmiş halini elde etmek istiyorsanız elbette yapmanız gereken şey, almak
istediğiniz ilk ve son karakterlerin sırasını parantez içinde belirtmek
olacaktır. Mesela yukarıdaki karakter dizisinde sadece ‘Gül’ kelimesini ters
çevirmek istersek şöyle bir şey yazabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="mi">7</span><span class="p">:</span><span class="mi">4</span><span class="p">:</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
<span class="go">'lüG'</span>
</pre></div>
</div>
<p>Yukarıdaki örnek, karakter dizisi dilimlemeye ilişkin olarak bize bazı başka
ipuçları da veriyor. Gördüğünüz gibi, köşeli parantez içinde toplam üç adet
parametre kullanabiliyoruz. Yani formülümüz şöyle:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kardiz</span><span class="p">[</span><span class="n">ilk_karakter</span><span class="p">:</span><span class="n">son_karakter</span><span class="p">:</span><span class="n">atlama_sayısı</span><span class="p">]</span>
</pre></div>
</div>
<p>Bir örnek verelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"istanbul"</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">8</span><span class="p">:</span><span class="mi">1</span><span class="p">]</span>
<span class="go">'istanbul'</span>
</pre></div>
</div>
<p>Burada <cite>“istanbul”</cite> adlı karakter dizisinin bütün öğelerini birer birer ekrana
döktük. Bir de şuna bakalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">8</span><span class="p">:</span><span class="mi">2</span><span class="p">]</span>
<span class="go">'itnu'</span>
</pre></div>
</div>
<p>Burada ise <cite>“istanbul”</cite> adlı karakter dizisinin bütün öğelerini ikişer ikişer
atlayarak ekrana döktük. Yani bir karakter yazıp bir karakter atladık (<strong>i</strong>s<strong>t</strong>a<strong>n</strong>b<strong>u</strong>l).</p>
<p>Python’ın kuralları gereğince yukarıdaki kodu şöyle yazabileceğimizi de
biliyorsunuz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[::</span><span class="mi">2</span><span class="p">]</span>
<span class="go">'itnu'</span>
</pre></div>
</div>
<p>Eğer karakter dizisini ters çevirmek istiyorsak, yukarıdaki örneği eksi değerli
bir atlama sayısı ile yazmamız gerekir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"istanbul"</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[::</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
<span class="go">'lubnatsi'</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="p">[::</span><span class="o">-</span><span class="mi">2</span><span class="p">]</span>
<span class="go">'lbas'</span>
</pre></div>
</div>
<p>Dediğimiz gibi, yukarıdaki yöntemi kullanarak karakter dizilerini ters
çevirebilirsiniz. Ama eğer isterseniz <code class="docutils literal notranslate"><span class="pre">reversed()</span></code> adlı bir fonksiyondan da
yararlanabiliriz.</p>
<p>Gelelim bu fonksiyonun nasıl kullanılacağına… Önce şöyle bir deneme yapalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">reversed</span><span class="p">(</span><span class="s2">"Sana Gül Bahçesi Vadetmedim"</span><span class="p">)</span>
<span class="go"><reversed object at 0x00E8E250></span>
</pre></div>
</div>
<p>Gördüğünüz gibi, bu fonksiyonu düz bir şekilde kullandığımızda bize bir
‘reversed’ nesnesi vermekle yetiniyor. Buna benzer bir olguyla <code class="docutils literal notranslate"><span class="pre">range()</span></code>
fonksiyonunda da karşılaşmıştık:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span>
<span class="go">range(0, 10)</span>
</pre></div>
</div>
<p>Hatırlarsanız, <code class="docutils literal notranslate"><span class="pre">range(10)</span></code> gibi bir komutun içeriğini görebilmek için bu komut
üzerinde bir <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü kurmamız gerekiyordu:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">):</span>
<span class="nb">print</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
</pre></div>
</div>
<p>…veya:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="o">*</span><span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">))</span>
</pre></div>
</div>
<p>Aynı durum <code class="docutils literal notranslate"><span class="pre">reversed()</span></code> fonksiyonu için de geçerlidir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">reversed</span><span class="p">(</span><span class="s2">"Sana Gül Bahçesi Vadetmedim"</span><span class="p">):</span>
<span class="nb">print</span><span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="s2">""</span><span class="p">)</span>
</pre></div>
</div>
<p>…veya:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="o">*</span><span class="nb">reversed</span><span class="p">(</span><span class="s2">"Sana Gül Bahçesi Vadetmedim"</span><span class="p">),</span> <span class="n">sep</span><span class="o">=</span><span class="s2">""</span><span class="p">)</span>
</pre></div>
</div>
<p>Dilimleme veya <code class="docutils literal notranslate"><span class="pre">reversed()</span></code> fonksiyonunu kullanma yöntemlerinden hangisi
kolayınıza geliyorsa onu tercih edebilirsiniz.</p>
</div>
<div class="section" id="karakter-dizilerini-alfabe-sirasina-dizmek">
<h2>Karakter Dizilerini Alfabe Sırasına Dizmek<a class="headerlink" href="#karakter-dizilerini-alfabe-sirasina-dizmek" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Python’da karakter dizilerinin öğelerine tek tek ulaşma, öğeleri dilimleme ve
ters çevirmenin yanısıra, bu öğeleri alfabe sırasına dizmek de mümkündür. Bunun
için <code class="docutils literal notranslate"><span class="pre">sorted()</span></code> adlı bir fonksiyondan yararlanacağız:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">sorted</span><span class="p">(</span><span class="s2">"kitap"</span><span class="p">)</span>
<span class="go">['a', 'i', 'k', 'p', 't']</span>
</pre></div>
</div>
<p>Nasıl <code class="docutils literal notranslate"><span class="pre">input()</span></code> fonksiyonu çıktı olarak bir karakter dizisi ve <code class="docutils literal notranslate"><span class="pre">len()</span></code>
fonksiyonu bir sayı veriyorsa, <code class="docutils literal notranslate"><span class="pre">sorted()</span></code> fonksiyonu da bize çıktı olarak,
birkaç bölüm sonra inceleyeceğimiz ‘liste’ adlı bir veri tipi verir.</p>
<p>Ama tabii eğer isterseniz bu çıktıyı alıştığınız biçimde alabilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="o">*</span><span class="nb">sorted</span><span class="p">(</span><span class="s2">"kitap"</span><span class="p">),</span> <span class="n">sep</span><span class="o">=</span><span class="s2">""</span><span class="p">)</span>
</pre></div>
</div>
<p>…veya:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="s2">"kitap"</span><span class="p">):</span>
<span class="nb">print</span><span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="s2">""</span><span class="p">)</span>
</pre></div>
</div>
<p>Bir örnek daha verelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">sorted</span><span class="p">(</span><span class="s2">"elma"</span><span class="p">)</span>
<span class="go">['a', 'e', 'l', 'm']</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <code class="docutils literal notranslate"><span class="pre">sorted()</span></code> fonksiyonunu kullanmak çok kolay, ama aslında bu
fonksiyonun önemli bir problemi var. Dikkatlice bakın:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">sorted</span><span class="p">(</span><span class="s2">"çiçek"</span><span class="p">)</span>
<span class="go">['e', 'i', 'k', 'ç', 'ç']</span>
</pre></div>
</div>
<p>Burada Türkçe bir karakter olan ‘ç’ harfinin düzgün sıralanamadığını görüyoruz.
Bu sorun bütün Türkçe karakterler için geçerlidir.</p>
<p>Bu sorunu aşmak için şöyle bir yöntem deneyebilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">import</span> <span class="nn">locale</span>
<span class="gp">>>> </span><span class="n">locale</span><span class="o">.</span><span class="n">setlocale</span><span class="p">(</span><span class="n">locale</span><span class="o">.</span><span class="n">LC_ALL</span><span class="p">,</span> <span class="s2">"Turkish_Turkey.1254"</span><span class="p">)</span> <span class="c1">#Windows için</span>
<span class="gp">>>> </span><span class="n">locale</span><span class="o">.</span><span class="n">setlocale</span><span class="p">(</span><span class="n">locale</span><span class="o">.</span><span class="n">LC_ALL</span><span class="p">,</span> <span class="s2">"tr_TR"</span><span class="p">)</span> <span class="c1">#GNU/Linux için</span>
<span class="gp">>>> </span><span class="nb">sorted</span><span class="p">(</span><span class="s2">"çiçek"</span><span class="p">,</span> <span class="n">key</span><span class="o">=</span><span class="n">locale</span><span class="o">.</span><span class="n">strxfrm</span><span class="p">)</span>
<span class="go">['ç', 'ç', 'e', 'i', 'k']</span>
</pre></div>
</div>
<p>Burada <code class="docutils literal notranslate"><span class="pre">locale</span></code> adlı bir modülden yararlandık. <code class="docutils literal notranslate"><span class="pre">locale</span></code> de tıpkı <code class="docutils literal notranslate"><span class="pre">sys</span></code>,
<code class="docutils literal notranslate"><span class="pre">os</span></code> ve <code class="docutils literal notranslate"><span class="pre">keyword</span></code> gibi bir modül olup, içinde pek çok değişken ve fonksiyon
barındırır.</p>
<p><code class="docutils literal notranslate"><span class="pre">locale</span></code> modülü bize belli bir dilin kendine has özelliklerine göre
programlama yapma imkanı verir. Örneğin bu modülünün içinde yer alan
fonksiyonlardan biri olan <code class="docutils literal notranslate"><span class="pre">setlocale()</span></code> fonksiyonunu kullanarak, programımızda
öntanımlı dil ayarlarına uygun bir şekilde programlama yapma olanağı sağlarız.</p>
<p>Bu modülü ilerleyen derslerde daha ayrıntılı bir şekilde inceleyeceğiz. O yüzden
<code class="docutils literal notranslate"><span class="pre">locale</span></code> modülünü bir kenara bırakıp yolumuza devam edelim.</p>
<p>Yukarıdaki örnekte Türkçe karakterleri doğru sıralayabilmek için <code class="docutils literal notranslate"><span class="pre">sorted()</span></code>
fonksiyonunu nasıl kullandığımıza dikkat edin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">sorted</span><span class="p">(</span><span class="s2">"çiçek"</span><span class="p">,</span> <span class="n">key</span><span class="o">=</span><span class="n">locale</span><span class="o">.</span><span class="n">strxfrm</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada <code class="docutils literal notranslate"><span class="pre">sorted()</span></code> metodunun <cite>key</cite> adlı özel bir parametresine <cite>locale.strxfrm</cite>
değerini vererek Türkçeye duyarlı bir sıralama yapılmasını sağladık. Yukarıdaki
yöntem pek çok durumda işinize yarar. Ancak bu yöntem tek bir yerde işe yaramaz.
Dikkatlice bakın:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">sorted</span><span class="p">(</span><span class="s2">"afgdhkıi"</span><span class="p">,</span> <span class="n">key</span><span class="o">=</span><span class="n">locale</span><span class="o">.</span><span class="n">strxfrm</span><span class="p">)</span>
<span class="go">['a', 'd', 'f', 'g', 'h', 'i', 'ı', 'k']</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, bu yöntem ‘i’ harfini ‘ı’ harfinden önce getiriyor. Halbuki
Türk alfabesine göre bunun tersi olmalıydı. Buna benzer problemlerle İngiliz
alfabesi dışındaki pek çok alfabede karşılaşırsınız. Dolayısıyla bu sadece
Türkçeye özgü bir sorun değil.</p>
<p>Bu soruna karşı şöyle bir kod da yazabilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">harfler</span> <span class="o">=</span> <span class="s2">"abcçdefgğhıijklmnoöprsştuüvyz"</span>
<span class="gp">>>> </span><span class="n">çevrim</span> <span class="o">=</span> <span class="p">{</span><span class="n">i</span><span class="p">:</span> <span class="n">harfler</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="n">i</span><span class="p">)</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">harfler</span><span class="p">}</span>
<span class="gp">>>> </span><span class="nb">sorted</span><span class="p">(</span><span class="s2">"afgdhkıi"</span><span class="p">,</span> <span class="n">key</span><span class="o">=</span><span class="n">çevrim</span><span class="o">.</span><span class="n">get</span><span class="p">)</span>
<span class="go">['a', 'd', 'f', 'g', 'h', 'ı', 'i', 'k']</span>
</pre></div>
</div>
<p>Gördüğünüz gibi burada ilk iş olarak Türk alfabesindeki bütün harfleri <cite>harfler</cite>
adlı bir değişkene atadık. Daha sonra ise şöyle bir kod yazdık:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">çevrim</span> <span class="o">=</span> <span class="p">{</span><span class="n">i</span><span class="p">:</span> <span class="n">harfler</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="n">i</span><span class="p">)</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">harfler</span><span class="p">}</span>
</pre></div>
</div>
<p>Burada henüz öğrenmediğimiz bir yapı var, ama ne olup bittiğini daha iyi anlamak
için bu <cite>çevrim</cite> değişkeninin içeriğini kontrol etmeyi deneyebilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">çevrim</span><span class="p">)</span>
<span class="go">{'ğ': 8, 'ı': 10, 'v': 26, 'g': 7, 'ş': 22, 'a': 0, 'c': 2, 'b': 1, 'e': 5,</span>
<span class="go">'d': 4, 'ç': 3, 'f': 6, 'i': 11, 'h': 9, 'k': 13, 'j': 12, 'm': 15, 'l': 14,</span>
<span class="go">'o': 17, 'n': 16, 'p': 19, 's': 21, 'r': 20, 'u': 24, 't': 23, 'ö': 18,</span>
<span class="go">'y': 27, 'z': 28, 'ü': 25}</span>
</pre></div>
</div>
<p>Bu çıktıya dikkatlice bakarsanız, her bir harfin bir sayıya karşılık gelecek
şekilde birbiriyle eşleştirildiğini göreceksiniz. Mesela ‘ğ’ harfi <cite>8</cite> ile, ‘f’
harfi <cite>6</cite> ile eşleşmiş. Yine dikkatlice bakarsanız, biraz önce bize sorun
çıkaran ‘ı’ harfinin <cite>10</cite>, ‘i’ harfinin ise <cite>11</cite> ile eşleştiğini göreceksiniz.
Evet, doğru tahmin ettiniz. Harfleri sayılarla eşleştirerek, Python’ın harfler
yerine sayıları sıralamasını sağlayacağız. Bunu da yine <cite>key</cite> parametresini
kullanarak yapıyoruz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">sorted</span><span class="p">(</span><span class="s2">"afgdhkıi"</span><span class="p">,</span> <span class="n">key</span><span class="o">=</span><span class="n">çevrim</span><span class="o">.</span><span class="n">get</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu yapıyı daha iyi anlayabilmek için kendi kendinize bazı denemeler yapın. Eğer
burada olan biteni anlamakta zorlanıyorsanız hiç endişe etmeyin. Bir-iki bölüm
sonra bunları da kolayca anlayabilecek duruma geleceksiniz. Bizim burada bu
bilgileri vermekteki amacımız, Python’ın Türkçe harflerle sıralama işlemini
sorunsuz bir şekilde yapabileceğini göstermektir. Bu esnada bir-iki yeni bilgi
kırıntısı da kapmanızı sağlayabildiysek kendimizi başarılı sayacağız.</p>
</div>
<div class="section" id="karakter-dizileri-uzerinde-degisiklik-yapmak">
<h2>Karakter Dizileri Üzerinde Değişiklik Yapmak<a class="headerlink" href="#karakter-dizileri-uzerinde-degisiklik-yapmak" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Bu kısımda karakter dizilerinin çok önemli bir özelliğinden söz edeceğiz.
Konumuz karakter dizileri üzerinde değişiklik yapmak. İsterseniz neyle karşı
karşıya olduğumuzu anlayabilmek için çok basit bir örnek verelim.</p>
<p>Elimizde şöyle bir karakter dizisi olduğunu düşünün:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">meyve</span> <span class="o">=</span> <span class="s2">"elma"</span>
</pre></div>
</div>
<p>Amacımız bu karakter dizisinin ilk harfini büyütmek olsun.</p>
<p>Bunun için dilimleme yönteminden yararlanabileceğimizi biliyorsunuz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"E"</span> <span class="o">+</span> <span class="n">meyve</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
<span class="go">'Elma'</span>
</pre></div>
</div>
<p>Burada “E” harfi ile, <cite>meyve</cite> değişkeninin ilk harfi dışında kalan bütün
harfleri birleştirdik.</p>
<p>Bir örnek daha verelim.</p>
<p>Elimizde şöyle dört adet internet sitesi adresi olsun:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">site1</span> <span class="o">=</span> <span class="s2">"www.google.com"</span>
<span class="n">site2</span> <span class="o">=</span> <span class="s2">"www.istihza.com"</span>
<span class="n">site3</span> <span class="o">=</span> <span class="s2">"www.yahoo.com"</span>
<span class="n">site4</span> <span class="o">=</span> <span class="s2">"www.gnu.org"</span>
</pre></div>
</div>
<p>Bizim amacımız bu adreslerin her birinin baş tarafına <cite>http://</cite> ifadesini
eklemek. Bunun için de yine karakter dizisi birleştirme işlemlerinden
yararlanabiliriz. Dikkatlice inceleyin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">site1</span> <span class="o">=</span> <span class="s2">"www.google.com"</span>
<span class="n">site2</span> <span class="o">=</span> <span class="s2">"www.istihza.com"</span>
<span class="n">site3</span> <span class="o">=</span> <span class="s2">"www.yahoo.com"</span>
<span class="n">site4</span> <span class="o">=</span> <span class="s2">"www.gnu.org"</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">site1</span><span class="p">,</span> <span class="n">site2</span><span class="p">,</span> <span class="n">site3</span><span class="p">,</span> <span class="n">site4</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"http://"</span><span class="p">,</span> <span class="n">i</span><span class="p">,</span> <span class="n">sep</span><span class="o">=</span><span class="s2">""</span><span class="p">)</span>
</pre></div>
</div>
<p>Eğer <cite>www.</cite> kısımlarını atmak isterseniz karakter dizisi birleştirme işlemleri
ile birlikte dilimleme yöntemini de kullanmanız gerekir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">site1</span><span class="p">,</span> <span class="n">site2</span><span class="p">,</span> <span class="n">site3</span><span class="p">,</span> <span class="n">site4</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"http://"</span><span class="p">,</span> <span class="n">i</span><span class="p">[</span><span class="mi">4</span><span class="p">:],</span> <span class="n">sep</span><span class="o">=</span><span class="s2">""</span><span class="p">)</span>
</pre></div>
</div>
<p>Belki farkındayız, belki de değiliz, ama aslında yukarıdaki örnekler karakter
dizileri hakkında bize çok önemli bir bilgi veriyor. Dikkat ettiyseniz
yukarıdaki örneklerde karakter dizileri üzerinde bir değişiklik yapmışız gibi
görünüyor. Esasında öyle de denebilir. Ancak burada önemli bir ayrıntı var.
Yukarıdaki örneklerde gördüğümüz değişiklikler kalıcı değildir. Yani aslında bu
değişikliklerin orijinal karakter dizisi üzerinde hiçbir etkisi yoktur. Gelin
isterseniz bunu teyit edelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"istihza"</span>
<span class="gp">>>> </span><span class="s2">"İ"</span> <span class="o">+</span> <span class="n">kardiz</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
<span class="go">'İstihza'</span>
</pre></div>
</div>
<p>Dediğimiz gibi, sanki burada <cite>“istihza”</cite> karakter dizisini <cite>“İstihza”</cite> karakter
dizisine çevirmişiz gibi duruyor. Ama aslında öyle değil:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">kardiz</span><span class="p">)</span>
<span class="go">istihza</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <cite>kardiz</cite> değişkeninin orijinalinde hiçbir değişiklik yok.
Ayrıca burada <code class="docutils literal notranslate"><span class="pre">"İ"</span> <span class="pre">+</span> <span class="pre">kardiz[1:]</span></code> satırı ile elde ettiğiniz sonuca tekrar
ulaşmanızın imkanı yok. Bu değişiklik kaybolmuş durumda. Peki bunun sebebi
nedir?</p>
<p>Bunun nedeni, karakter dizilerinin değiştirilemeyen (<em>immutable</em>) bir veri tipi
olmasıdır. Python’da iki tür veri tipi bulunur: değiştirilemeyen veri tipleri
(<em>immutable datatypes</em>) ve değiştirilebilen veri tipleri (<em>mutable datatypes</em>).
Bizim şimdiye kadar gördüğümüz veri tipleri (sayılar ve karakter dizileri),
değiştirilemeyen veri tipleridir. Henüz değiştirilebilen bir veri tipi görmedik.
Ama birkaç bölüm sonra değiştirilebilen veri tiplerini de inceleyeceğiz.</p>
<p>Neyse… Dediğimiz gibi, karakter dizileri üzerinde yaptığımız değişikliklerin
kalıcı olmamasının nedeni, karakter dizilerinin değiştirilemeyen bir veri tipi
olmasıdır. Python’da bir karakter dizisini bir kez tanımladıktan sonra bu
karakter dizisi üzerinde artık değişiklik yapamazsınız. Eğer bir karakter dizisi
üzerinde değişiklik yapmanız gerekiyorsa, yapabileceğiniz tek şey o karakter
dizisini yeniden tanımlamaktır. Mesela yukarıdaki örnekte <cite>kardiz</cite> değişkeninin
tuttuğu karakter dizisini değiştirmek isterseniz şöyle bir kod yazabilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"İ"</span> <span class="o">+</span> <span class="n">kardiz</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">kardiz</span><span class="p">)</span>
<span class="go">İstihza</span>
</pre></div>
</div>
<p>Burada yaptığımız şey <cite>kardiz</cite> değişkeninin değerini değiştirmek değildir. Biz
burada aslında bambaşka bir <cite>kardiz</cite> değişkeni daha tanımlıyoruz. Yani ilk
<cite>kardiz</cite> değişkeni ile sonraki <cite>kardiz</cite> değişkeni aynı şeyler değil. Bunu teyit
etmek için önceki derslerimizde gördüğümüz <code class="docutils literal notranslate"><span class="pre">id()</span></code> fonksiyonundan
yararlanabilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"istihza"</span>
<span class="gp">>>> </span><span class="nb">id</span><span class="p">(</span><span class="n">kardiz</span><span class="p">)</span>
<span class="go">3075853248</span>
<span class="gp">>>> </span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"İ"</span> <span class="o">+</span> <span class="n">kardiz</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
<span class="gp">>>> </span><span class="nb">id</span><span class="p">(</span><span class="n">kardiz</span><span class="p">)</span>
<span class="go">3075853280</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, ilk <cite>kardiz</cite> değişkeni ile sonraki <cite>kardiz</cite> değişkeni farklı
kimlik numaralarına sahip. Yani bu iki değişken bellek içinde farklı adreslerde
tutuluyor. Daha doğrusu, ikinci <cite>kardiz</cite>, ilk <cite>kardiz</cite>’i silip üzerine yazıyor.</p>
<p>Her ne kadar <code class="docutils literal notranslate"><span class="pre">kardiz</span> <span class="pre">=</span> <span class="pre">"İ"</span> <span class="pre">+</span> <span class="pre">kardiz[1:]</span></code> kodu <cite>kardiz</cite>’in değerini aslında
değiştirmiyor olsa da, sanki <cite>kardiz</cite> değişkeninin tuttuğu karakter dizisi
değişiyormuş gibi bir etki elde ediyoruz. Bu da bizi memnun etmeye yetiyor…</p>
<p>Yukarıdaki örnekte karakter dizisinin baş kısmı üzerinde değişiklik yaptık. Eğer
karakter dizisinin ortasında kalan bir kısmı değiştirmek isterseniz de şöyle bir
şey yazabilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"istihza"</span>
<span class="gp">>>> </span><span class="n">kardiz</span> <span class="o">=</span> <span class="n">kardiz</span><span class="p">[:</span><span class="mi">3</span><span class="p">]</span> <span class="o">+</span> <span class="s2">"İH"</span> <span class="o">+</span> <span class="n">kardiz</span><span class="p">[</span><span class="mi">5</span><span class="p">:]</span>