forked from yazbel/python-istihza
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathkarakter_dizilerinin_metotlari2.html
1521 lines (1385 loc) · 130 KB
/
karakter_dizilerinin_metotlari2.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" name="keywords" />
<title>Karakter Dizilerinin Metotları (Devamı) — 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ı (Devamı)" href="karakter_dizilerinin_metotlari3.html" />
<link rel="prev" title="Karakter Dizilerinin Metotları" href="karakter_dizilerinin_metotlari1.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_metotlari3.html" title="Karakter Dizilerinin Metotları (Devamı)"
accesskey="N">sonraki</a></li>
<li class="right" >
<a href="karakter_dizilerinin_metotlari1.html" title="Karakter Dizilerinin Metotları"
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 Dizilerinin Metotları (Devamı)</a></li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="body" role="main">
<div class="section" id="karakter-dizilerinin-metotlari-devami">
<h1>Karakter Dizilerinin Metotları (Devamı)<a class="headerlink" href="#karakter-dizilerinin-metotlari-devami" title="Bu başlık için kalıcı bağlantı">¶</a></h1>
<p>Karakter dizileri konusunun en başında söylediğimiz gibi, karakter dizileri
metot yönünden bir hayli zengin bir veri tipidir. Bir önceki bölümde karakter
dizileri metotlarının bir kısmını incelemiştik. Bu bölümde yine metotları
incelemeye devam edeceğiz.</p>
<div class="section" id="capitalize">
<h2>capitalize()<a class="headerlink" href="#capitalize" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Hatırlarsanız, bir önceki bölümde öğrendiğimiz <code class="docutils literal notranslate"><span class="pre">startswith()</span></code> ve
<code class="docutils literal notranslate"><span class="pre">endswith()</span></code> metotları karakter dizileri üzerinde herhangi bir değişiklik
yapmıyordu. Bu iki metodun görevi, karakter dizilerini sorgulamamızı sağlamaktı.
Şimdi göreceğimiz <code class="docutils literal notranslate"><span class="pre">capitalize()</span></code> metodu ise karakter dizileri üzerinde
değişiklik yapmamızı sağlayacak. Dolayısıyla bu <code class="docutils literal notranslate"><span class="pre">capitalize()</span></code> metodu da
‘değiştirici metotlar’dan biridir diyebiliriz.</p>
<p>Hatırlarsanız, <code class="docutils literal notranslate"><span class="pre">upper()</span></code> ve <code class="docutils literal notranslate"><span class="pre">lower()</span></code> metotları bir karakter dizisi içindeki
bütün karakterleri etkiliyordu. Yani mesela <code class="docutils literal notranslate"><span class="pre">upper()</span></code> metodunu bir karakter
dizisine uygularsak, o karakter dizisi içindeki bütün karakterler büyük harfe
dönecektir. Aynı şekilde <code class="docutils literal notranslate"><span class="pre">lower()</span></code> metodu da bir karakter dizisi içindeki
bütün karakterleri küçük harfe çevirir.</p>
<p>Şimdi göreceğimiz <code class="docutils literal notranslate"><span class="pre">capitalize()</span></code> metodu da <code class="docutils literal notranslate"><span class="pre">upper()</span></code> ve <code class="docutils literal notranslate"><span class="pre">lower()</span></code>
metotlarına benzemekle birlikte onlardan biraz daha farklı davranır:
<code class="docutils literal notranslate"><span class="pre">capitalize()</span></code> metodunun görevi karakter dizilerinin yalnızca ilk harfini
büyütmektir. Örneğin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">a</span> <span class="o">=</span> <span class="s2">"python"</span>
<span class="gp">>>> </span><span class="n">a</span><span class="o">.</span><span class="n">capitalize</span><span class="p">()</span>
<span class="go">'Python'</span>
</pre></div>
</div>
<p>Bu metodu kullanırken dikkat etmemiz gereken bir nokta var: Bu metot bir
karakter dizisinin yalnızca ilk harfini büyütür. Yani birden fazla kelimeden
oluşan karakter dizilerine bu metodu uyguladığımızda bütün kelimelerin ilk harfi
büyümez. Yalnızca ilk kelimenin ilk harfi büyür. Yani:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">a</span> <span class="o">=</span> <span class="s2">"python programlama dili"</span>
<span class="gp">>>> </span><span class="n">a</span><span class="o">.</span><span class="n">capitalize</span><span class="p">()</span>
<span class="go">'Python programlama dili'</span>
</pre></div>
</div>
<p><cite>“python programlama dili”</cite> üç kelimeden oluşan bir karakter dizisidir. Bu
karakter dizisi üzerine <code class="docutils literal notranslate"><span class="pre">capitalize()</span></code> metodunu uyguladığımızda bu üç
kelimenin tamamının ilk harfleri büyümüyor. Yalnızca ilk ‘python’ kelimesinin
ilk harfi bu metottan etkileniyor.</p>
<p>Bu arada <code class="docutils literal notranslate"><span class="pre">capitalize()</span></code> metodunu kullanırken bir şey dikkatinizi çekmiş
olmalı. Bu metodun da, tıpkı <code class="docutils literal notranslate"><span class="pre">upper()</span></code> ve <code class="docutils literal notranslate"><span class="pre">lower()</span></code> metotlarında olduğu
gibi, Türkçe karakterlerden bazıları ile ufak bir problemi var. Mesela şu örneğe
bir 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="o">=</span> <span class="s2">"istanbul"</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="o">.</span><span class="n">capitalize</span><span class="p">()</span>
<span class="go">'Istanbul'</span>
</pre></div>
</div>
<p>‘istanbul’ kelimesinin ilk harfi büyütüldüğünde ‘İ’ olması gerekirken ‘I’ oldu.
Bildiğiniz gibi bu problem ‘ş’, ‘ç’, ‘ö’, ‘ğ’ ve ‘ü’ gibi öteki Türkçe
karakterlerde karşımıza çıkmaz. Sadece ‘i’ ve ‘İ’ harfleri karakter dizisi
metotlarında bize problem çıkaracaktır. Ama endişe etmemize hiç gerek yok. Bu
sorunu da basit bir ‘if-else’ yapısıyla çözebilecek kadar Python bilgisine
sahibiz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"istanbul büyükşehir belediyesi"</span>
<span class="k">if</span> <span class="n">kardiz</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">"i"</span><span class="p">):</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="n">kardiz</span> <span class="o">=</span> <span class="n">kardiz</span><span class="o">.</span><span class="n">capitalize</span><span class="p">()</span>
<span class="nb">print</span><span class="p">(</span><span class="n">kardiz</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada yaptığımız şey şu: Eğer değişkenin tuttuğu karakter dizisi ‘i’ harfi ile
başlıyorsa, <code class="docutils literal notranslate"><span class="pre">"İ"</span> <span class="pre">+</span> <span class="pre">kardiz[1:]</span></code> kodunu kullanarak karakter dizisinin ilk harfi
dışında kalan kısmıyla ‘İ’ harfini birleştiriyoruz. Bu yapıyı daha iyi
anlayabilmek için etkileşimli kabukta şu denemeleri yapabilirsiniz:</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">1</span><span class="p">:]</span>
<span class="go">'stanbul'</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <code class="docutils literal notranslate"><span class="pre">kardiz[1:]</span></code> kodu bize karakter dizisinin ilk harfi hariç
geri kalan kısmını veriyor. Bu yapıyı dilimleme konusundan hatırlıyor
olmalısınız. İşte biz dilimleme tekniğinin bu özelliğinden yararlanarak,
karakter dizisinin ilk harfini kesip, baş tarafa bir adet ‘İ’ harfi ekliyoruz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></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">'İstanbul'</span>
</pre></div>
</div>
<p>Hatırlarsanız karakter dizilerinin değiştirilemeyen bir veri tipi olduğunu
söylemiştik. O yüzden, karakter dizisinin <cite>“stanbul”</cite> kısmını ‘İ’ harfiyle
birleştirdikten sonra, bu değişikliğin kalıcı olabilmesi için <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 yardımıyla, yaptığımız değişikliği tekrar <cite>kardiz</cite> adlı bir
değişkene atıyoruz.</p>
<p>Böylece;</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">if</span> <span class="n">kardiz</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">"i"</span><span class="p">):</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>
</pre></div>
</div>
<p>kodlarının ne yaptığını anlamış olduk. Kodların geri kalanında ise şöyle bir kod
bloğu görüyoruz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kardiz</span> <span class="o">=</span> <span class="n">kardiz</span><span class="o">.</span><span class="n">capitalize</span><span class="p">()</span>
</pre></div>
</div>
<p>Buna göre, hangi harfle başlarsa başlasın Python’ın standart <code class="docutils literal notranslate"><span class="pre">capitalize()</span></code>
metodunu bu karakter dizisi üzerine uyguluyoruz.</p>
<p>Son olarak da <code class="docutils literal notranslate"><span class="pre">print(kardiz)</span></code> kodunu kullanarak yeni karakter dizisini ekrana
yazdırıyoruz ve böylece <code class="docutils literal notranslate"><span class="pre">capitalize()</span></code> metodundaki Türkçe karakter sorununu
kıvrak bir çalımla aşmış oluyoruz.</p>
</div>
<div class="section" id="title">
<h2>title()<a class="headerlink" href="#title" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Bu metot biraz önce öğrendiğimiz <code class="docutils literal notranslate"><span class="pre">capitalize()</span></code> metoduna benzer. Bildiğiniz
gibi <code class="docutils literal notranslate"><span class="pre">capitalize()</span></code> metodu bir karakter dizisinin yalnızca ilk harfini
büyütüyordu. <code class="docutils literal notranslate"><span class="pre">title()</span></code> metodu da karakter dizilerinin ilk harfini büyütür. Ama
<code class="docutils literal notranslate"><span class="pre">capitalize()</span></code> metodundan farklı olarak bu metot, birden fazla kelimeden
oluşan karakter dizilerinin her kelimesinin ilk harflerini büyütür.</p>
<p>Bunu bir örnek üzerinde anlatsak sanırım daha iyi olacak:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">a</span> <span class="o">=</span> <span class="s2">"python programlama dili"</span>
<span class="gp">>>> </span><span class="n">a</span><span class="o">.</span><span class="n">capitalize</span><span class="p">()</span>
<span class="go">'Python programlama dili'</span>
<span class="gp">>>> </span><span class="n">a</span><span class="o">.</span><span class="n">title</span><span class="p">()</span>
<span class="go">'Python Programlama Dili'</span>
</pre></div>
</div>
<p><code class="docutils literal notranslate"><span class="pre">capitalize()</span></code> metodu ile <code class="docutils literal notranslate"><span class="pre">title()</span></code> metodu arasındaki fark bariz bir biçimde
görünüyor. Dediğimiz gibi, <code class="docutils literal notranslate"><span class="pre">capitalize()</span></code> metodu yalnızca ilk kelimenin ilk
harfini büyütmekle yetinirken, <code class="docutils literal notranslate"><span class="pre">title()</span></code> metodu karakter dizisi içindeki bütün
kelimelerin ilk harflerini büyütüyor.</p>
<p>Tahmin edebileceğiniz gibi, <code class="docutils literal notranslate"><span class="pre">capitalize()</span></code> metodundaki Türkçe karakter
problemi <code class="docutils literal notranslate"><span class="pre">title()</span></code> metodu için de geçerlidir. Yani:</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="o">.</span><span class="n">title</span><span class="p">()</span>
<span class="go">'Istanbul'</span>
<span class="gp">>>> </span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"istanbul büyükşehir belediyesi"</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="o">.</span><span class="n">title</span><span class="p">()</span>
<span class="go">'Istanbul Büyükşehir Belediyesi'</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, burada da Python ‘i’ harfini düzgün büyütemedi. Ama tabii ki bu
bizi durduramaz! Çözümümüz hazır:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"istanbul"</span>
<span class="k">if</span> <span class="n">kardiz</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">"i"</span><span class="p">):</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="n">kardiz</span> <span class="o">=</span> <span class="n">kardiz</span><span class="o">.</span><span class="n">title</span><span class="p">()</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">kardiz</span> <span class="o">=</span> <span class="n">kardiz</span><span class="o">.</span><span class="n">title</span><span class="p">()</span>
<span class="nb">print</span><span class="p">(</span><span class="n">kardiz</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu kodların <code class="docutils literal notranslate"><span class="pre">capitalize()</span></code> metodunu anlatırken verdiğimiz koda ne kadar
benzediğini görüyorsunuz. Bu iki kod hemen hemen birbirinin aynısı. Tek fark, en
sondaki <code class="docutils literal notranslate"><span class="pre">kardiz.capitalize()</span></code> kodunun burada <code class="docutils literal notranslate"><span class="pre">kardiz.title()</span></code> olması ve
<code class="docutils literal notranslate"><span class="pre">if</span></code> bloğu içine ek olarak <code class="docutils literal notranslate"><span class="pre">kardiz</span> <span class="pre">=</span> <span class="pre">kardiz.title()</span></code> satırını yazmış
olmamız. <code class="docutils literal notranslate"><span class="pre">kardiz.capitalize()</span></code> kodunun neden <code class="docutils literal notranslate"><span class="pre">kardiz.title()</span></code> koduna
dönüştüğünü açıklamaya gerek yok. Ama eğer <code class="docutils literal notranslate"><span class="pre">kardiz</span> <span class="pre">=</span> <span class="pre">kardiz.title()</span></code> kodunun
ne işe yaradığını tam olarak anlamadıysanız o satırı silin ve <cite>kardiz</cite>
değişkeninin değerini <cite>“istanbul büyükşehir belediyesi”</cite> yapın. Yani:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"istanbul büyükşehir belediyesi"</span>
<span class="k">if</span> <span class="n">kardiz</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">"i"</span><span class="p">):</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="k">else</span><span class="p">:</span>
<span class="n">kardiz</span> <span class="o">=</span> <span class="n">kardiz</span><span class="o">.</span><span class="n">title</span><span class="p">()</span>
<span class="nb">print</span><span class="p">(</span><span class="n">kardiz</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu kodları bu şekilde çalıştırırsanız şu çıktıyı alırsınız:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">İstanbul</span> <span class="n">büyükşehir</span> <span class="n">belediyesi</span>
</pre></div>
</div>
<p>Burada yalnızca ilk kelimenin ilk harfi büyüdü. Halbuki <code class="docutils literal notranslate"><span class="pre">title()</span></code> metodunun
işleyişi gereğince karakter dizisi içindeki bütün kelimelerin ilk harflerinin
büyümesi gerekiyordu. İşte o satır bütün kelimelerin ilk harflerinin büyümesini
sağlıyor. Eğer bir kelimenin ilk harfi zaten büyükse <code class="docutils literal notranslate"><span class="pre">title()</span></code> metodu bu harfe
dokunmaz, ama karakter dizisi içindeki öbür kelimelerin ilk harflerini yine de
büyütür.</p>
<p>İşte yukarıda <code class="docutils literal notranslate"><span class="pre">title()</span></code> metodunun bu özelliğinden faydalanıyoruz. <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> komutu karakter dizisinin ilk kelimesinin ilk harfini düzgün
bir şekilde büyütüyor, ama geri kalan kelimelere hiçbir şey yapmıyor. <code class="docutils literal notranslate"><span class="pre">kardiz</span> <span class="pre">=</span>
<span class="pre">kardiz.title()</span></code> komutu ise karakter dizisi içindeki geri kalan kelimelerin ilk
harflerini büyütüyor. Böylece istediğimiz çıktıyı elde edebilmiş oluyoruz.
Yalnız bu kodlarda bir şey dikkatinizi çekmiş olmalı. <code class="docutils literal notranslate"><span class="pre">kardiz</span> <span class="pre">=</span>
<span class="pre">kardiz.title()</span></code> komutunu program içinde iki yerde kullandık. Programcılıktaki
en önemli ilkelerden biri de mümkün olduğunca tekrardan kaçınmaktır. Eğer
yazdığınız bir programda aynı kodları program boyunca tekrar tekrar yazıyorsanız
muhtemelen bir yerde hata yapıyorsunuzdur. Öyle bir durumda yapmanız gereken şey
kodlarınızı tekrar gözden geçirip, tekrar eden kodları nasıl azaltabileceğinizi
düşünmektir. İşte burada da böyle bir tekrar söz konusu. Biz tekrara düşmekten
kurtulmak için yukarıdaki kodları şöyle de yazabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"istanbul büyükşehir belediyesi"</span>
<span class="k">if</span> <span class="n">kardiz</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">"i"</span><span class="p">):</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="n">kardiz</span> <span class="o">=</span> <span class="n">kardiz</span><span class="o">.</span><span class="n">title</span><span class="p">()</span>
<span class="nb">print</span><span class="p">(</span><span class="n">kardiz</span><span class="p">)</span>
</pre></div>
</div>
<p><code class="docutils literal notranslate"><span class="pre">kardiz</span> <span class="pre">=</span> <span class="pre">kardiz.title()</span></code> komutunu hem <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğunda, hem de <code class="docutils literal notranslate"><span class="pre">else</span></code>
bloğunda kullandığımız için, programımız her koşulda bu kodu zaten çalıştıracak.
O yüzden bu satırı <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğuna yazdıktan sonra bir de aynı şeyi <code class="docutils literal notranslate"><span class="pre">else</span></code>
bloğu içine yazmak gereksiz. Onun yerine <code class="docutils literal notranslate"><span class="pre">else</span></code> bloğunu tamamen kaldırıp, o
satırı <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğunun çıkışına yerleştirebiliriz.</p>
<p>Eski kodlardaki mantık işleyişi şöyle idi:</p>
<blockquote>
<div><ol class="arabic simple">
<li><p><cite>kardiz</cite> adlı bir değişken tanımla</p></li>
<li><p>Eğer <cite>kardiz</cite> ‘i’ harfi ile başlıyorsa (<code class="docutils literal notranslate"><span class="pre">if</span></code>), <cite>kardiz</cite>’in ilk harfi
hariç geri kalan kısmı ile ‘İ’ harfini birleştir.</p></li>
<li><p>Daha sonra <cite>kardiz</cite> değişkenine <code class="docutils literal notranslate"><span class="pre">title()</span></code> metodunu uygula.</p></li>
<li><p>Eğer <cite>kardiz</cite> ‘i’ harfi ile değil de başka bir harfle başlıyorsa (<code class="docutils literal notranslate"><span class="pre">else</span></code>),
<cite>kardiz</cite> değişkenine <code class="docutils literal notranslate"><span class="pre">title()</span></code> metodunu uygula.</p></li>
<li><p>Son olarak <cite>kardiz</cite> değişkenini yazdır.</p></li>
</ol>
</div></blockquote>
<p>Tekrar eden kodları çıkardıktan sonra ise kodlarımızın mantık işleyişi şöyle
oldu:</p>
<blockquote>
<div><ol class="arabic simple">
<li><p><cite>kardiz</cite> adlı bir değişken tanımla</p></li>
<li><p>Eğer <cite>kardiz</cite> ‘i’ harfi ile başlıyorsa (<code class="docutils literal notranslate"><span class="pre">if</span></code>), <cite>kardiz</cite>’in ilk harfi
hariç geri kalan kısmı ile ‘İ’ harfini birleştir.</p></li>
<li><p>Daha sonra <cite>kardiz</cite> değişkenine <code class="docutils literal notranslate"><span class="pre">title()</span></code> metodunu uygula.</p></li>
<li><p>Son olarak <cite>kardiz</cite> değişkenini yazdır.</p></li>
</ol>
</div></blockquote>
<p>Gördüğünüz gibi, aynı sonuca daha kısa bir yoldan ulaşabiliyoruz.</p>
<p>Ama bir dakika! Burada bir sorun var!</p>
<p>Bu kodlar ‘i’ harfinin karakter dizisinin yalnızca en başında yer aldığı
durumlarda düzgün çalışacaktır. Bu kodlar mesela şu karakter dizisini düzgün
büyütemez:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">on</span> <span class="n">iki</span> <span class="n">ada</span>
</pre></div>
</div>
<p>Aynı şekilde bu kodlar şu karakter dizisini de büyütemez:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span>hükümet istifa!
</pre></div>
</div>
<p>Çünkü bu karakter dizilerinde ‘i’ harfi karakter dizisini oluşturan kelimelerin
ilkinde yer almıyor. Bizim yazdığımız kod ise yalnızca ilk kelime düşünülerek
yazılmış. Peki bu sorunun üstesinden nasıl geleceğiz?</p>
<p>Evet, doğru tahmin ettiniz. Bizi kurtaracak şey <code class="docutils literal notranslate"><span class="pre">split()</span></code> metodu ve basit bir
<code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü. Dikkatlice bakın:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"on iki ada"</span>
<span class="k">for</span> <span class="n">kelime</span> <span class="ow">in</span> <span class="n">kardiz</span><span class="o">.</span><span class="n">split</span><span class="p">():</span>
<span class="k">if</span> <span class="n">kelime</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">"i"</span><span class="p">):</span>
<span class="n">kelime</span> <span class="o">=</span> <span class="s2">"İ"</span> <span class="o">+</span> <span class="n">kelime</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
<span class="n">kelime</span> <span class="o">=</span> <span class="n">kelime</span><span class="o">.</span><span class="n">title</span><span class="p">()</span>
<span class="nb">print</span><span class="p">(</span><span class="n">kelime</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>Bu defa istediğimizi gerçekleştiren bir kod yazabildik. Bu kodlar, ‘i’ harfi
karakter dizisini oluşturan kelimelerin hangisinde bulunursa bulunsun, karakter
dizisini Türkçeye uygun bir şekilde büyütebilecektir.</p>
<p>Bir önceki kodlara göre, bu son kodlardaki tek farkın <code class="docutils literal notranslate"><span class="pre">split()</span></code> metodu ve
<code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü olduğuna dikkat edin.</p>
<p>Bu kodları daha iyi anlayabilmek için etkileşimli kabukta kendi kendinize bazı
deneme çalışmaları yapabilirsiniz:</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">"on iki ada"</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="o">.</span><span class="n">split</span><span class="p">()</span>
<span class="go">['on', 'iki', 'ada']</span>
<span class="gp">>>> </span><span class="k">for</span> <span class="n">kelime</span> <span class="ow">in</span> <span class="n">kardiz</span><span class="o">.</span><span class="n">split</span><span class="p">():</span>
<span class="gp">... </span> <span class="nb">print</span><span class="p">(</span><span class="n">kelime</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
<span class="gp">...</span>
<span class="go">o</span>
<span class="go">i</span>
<span class="go">a</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <code class="docutils literal notranslate"><span class="pre">split()</span></code> metodu <code class="docutils literal notranslate"><span class="pre">"on</span> <span class="pre">iki</span> <span class="pre">ada"</span></code> adlı karakter dizisini
kelimelerine ayırıyor. İşte biz de kelimelerine ayrılmış bu yapı üzerinde bir
<code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü kurarak herbir öğenin ilk harfinin ‘i’ olup olmadığını kontrol
edebiliyoruz.</p>
</div>
<div class="section" id="swapcase">
<h2>swapcase()<a class="headerlink" href="#swapcase" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p><code class="docutils literal notranslate"><span class="pre">swapcase()</span></code> metodu da büyük-küçük harfle ilgili bir metottur. Bu metot bir
karakter dizisi içindeki büyük harfleri küçük harfe; küçük harfleri de büyük
harfe dönüştürü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">"python"</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="o">.</span><span class="n">swapcase</span><span class="p">()</span>
<span class="go">'PYTHON'</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="o">.</span><span class="n">swapcase</span><span class="p">()</span>
<span class="go">'python'</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="o">.</span><span class="n">swapcase</span><span class="p">()</span>
<span class="go">'pYTHON'</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, bu metot aynen dediğimiz gibi işliyor. Yani küçük harfleri
büyük harfe; büyük harfleri de küçük harfe dönüştürüyor.</p>
<p>Yine tahmin edebileceğiniz gibi, bu metodun da bazı Türkçe karakterlerle
problemi 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">"istihza"</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="o">.</span><span class="n">swapcase</span><span class="p">()</span>
<span class="go">'ISTIHZA'</span>
</pre></div>
</div>
<p>Bu sorunu da aşmak tabii ki bizim elimizde:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kardiz</span> <span class="o">=</span> <span class="s2">"istanbul"</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">kardiz</span><span class="p">:</span>
<span class="k">if</span> <span class="n">i</span> <span class="o">==</span> <span class="s1">'İ'</span><span class="p">:</span>
<span class="n">kardiz</span> <span class="o">=</span> <span class="n">kardiz</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s1">'İ'</span><span class="p">,</span> <span class="s1">'i'</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">i</span> <span class="o">==</span> <span class="s1">'i'</span><span class="p">:</span>
<span class="n">kardiz</span> <span class="o">=</span> <span class="n">kardiz</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s1">'i'</span><span class="p">,</span> <span class="s1">'İ'</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">kardiz</span> <span class="o">=</span> <span class="n">kardiz</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">i</span><span class="o">.</span><span class="n">swapcase</span><span class="p">())</span>
<span class="nb">print</span><span class="p">(</span><span class="n">kardiz</span><span class="p">)</span>
</pre></div>
</div>
<p>Daha önceki örneklerde de olduğu gibi, bu kodlarda da ‘i’ ve ‘I’ harflerini tek
tek kontrolden geçiriyoruz. Eğer bir karakter dizisi içinde bu iki harften biri
varsa, bunların büyük harf veya küçük harf karşılıklarını elle yerine koyuyoruz.
Bu karakterler dışında kalan karakterlere ise doğrudan <code class="docutils literal notranslate"><span class="pre">swapcase()</span></code> metodunu
uygulayarak istediğimiz sonucu elde ediyoruz. Bu kodlarda kafanıza yatmayan
yerler varsa, kodlar içinde kendinize göre bazı eklemeler çıkarmalar yaparak
neyin ne işe yaradığını daha kolay anlayabilirsiniz.</p>
</div>
<div class="section" id="casefold">
<h2>casefold()<a class="headerlink" href="#casefold" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Bu metot işlev olarak <code class="docutils literal notranslate"><span class="pre">lower()</span></code> metoduna çok benzer. Hatta Türkçe açısından,
bu metodun <code class="docutils literal notranslate"><span class="pre">lower()</span></code> metodundan hiçbir farkı yoktur. Ancak bazı başka
dillerde, bu metot bazı harfler için <code class="docutils literal notranslate"><span class="pre">lower()</span></code> metodunun verdiğinden farklı
bir çıktı verir. Örneğin Almancadaki ‘ß’ harfi bu duruma bir örnek olabilir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"ß"</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span>
<span class="go">'ß'</span>
<span class="gp">>>> </span><span class="s2">"ß"</span><span class="o">.</span><span class="n">casefold</span><span class="p">()</span>
<span class="go">'ss'</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <code class="docutils literal notranslate"><span class="pre">lower()</span></code> ve <code class="docutils literal notranslate"><span class="pre">casefold()</span></code> metotları bu harfe farklı
davranıyor.</p>
<p>Türkçedeki İ-i sorunu bu metot için de aynen geçerlidir.</p>
</div>
<div class="section" id="strip-lstrip-rstrip">
<h2>strip(), lstrip(), rstrip()<a class="headerlink" href="#strip-lstrip-rstrip" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Bu başlıkta birbiriyle bağlantılı üç adet karakter dizisi metodunu
inceleyeceğiz. Bu metotlar <code class="docutils literal notranslate"><span class="pre">strip()</span></code>, <code class="docutils literal notranslate"><span class="pre">lstrip()</span></code> ve <code class="docutils literal notranslate"><span class="pre">rstrip()</span></code>. İlk olarak
<code class="docutils literal notranslate"><span class="pre">strip()</span></code> metoduyla başlayalım.</p>
<p>Zaman zaman, içinde anlamsız ya da gereksiz karakterler barındıran metinleri bu
anlamsız ve gereksiz karakterlerden temizlemeniz gereken durumlarla
karşılaşabilirsiniz. Örneğin arkadaşınızdan gelen bir e.postada her satırın
başında ve/veya sonunda <cite>></cite> gibi bir karakter olabilir. Arkadaşınızdan gelen bu
e.postayı kullanabilmek için öncelikle metin içindeki o <cite>></cite> karakterlerini
silmeniz gerekebilir. Hepimizin bildiği gibi, bu tür karakterleri elle
temizlemeye kalkışmak son derece sıkıcı ve zaman alıcı bir yöntemdir. Ama artık
siz bir Python programcısı olduğunuza göre bu tür angaryaları Python’a
devredebilirsiniz.</p>
<p>Yukarıda bahsettiğimiz duruma yönelik bir örnek vermeden önce dilerseniz
<code class="docutils literal notranslate"><span class="pre">strip()</span></code> metoduyla ilgili çok basit örnekler vererek başlayalım işe:</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>
</pre></div>
</div>
<p>Burada değeri <cite>” istihza “</cite> olan <cite>kardiz</cite> adlı bir karakter dizisi tanımladık.
Dikkat ederseniz bu karakter dizisinin sağında ve solunda birer boşluk karakteri
var. Bazı durumlarda kullanıcıdan ya da başka kaynaktan gelen karakter
dizilerinde bu tür istenmeyen boşluklar olabilir. Ama sizin kullanıcıdan veya
başka bir kaynaktan gelen o karakter dizisini düzgün kullanabilmeniz için
öncelikle o karakter dizisinin sağında ve solunda bulunan boşluk
karakterlerinden kurtulmanız gerekebilir. İşte böyle anlarda <code class="docutils literal notranslate"><span class="pre">strip()</span></code> metodu
yardımınıza yetişecektir. 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">" istihza "</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>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span>
<span class="go">'istihza'</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <code class="docutils literal notranslate"><span class="pre">strip()</span></code> metodunu kullanarak, karakter dizisinin
orijinalinde bulunan sağlı sollu boşluk karakterlerini bir çırpıda ortadan
kaldırdık.</p>
<p><code class="docutils literal notranslate"><span class="pre">strip()</span></code> metodu yukarıdaki örnekte olduğu gibi parametresiz olarak
kullanıldığında, bir karakter dizisinin sağında veya solunda bulunan belli başlı
karakterleri kırpar. <code class="docutils literal notranslate"><span class="pre">strip()</span></code> metodunun öntanımlı olarak kırptığı karakterler
şunlardır:</p>
<blockquote>
<div><table class="docutils align-default">
<colgroup>
<col style="width: 14%" />
<col style="width: 86%" />
</colgroup>
<tbody>
<tr class="row-odd"><td><p><cite>‘ ‘</cite></p></td>
<td><p>boşluk karakteri</p></td>
</tr>
<tr class="row-even"><td><p><cite>\t</cite></p></td>
<td><p>sekme (TAB) oluşturan kaçış dizisi</p></td>
</tr>
<tr class="row-odd"><td><p><cite>\n</cite></p></td>
<td><p>satır başına geçiren kaçış dizisi</p></td>
</tr>
<tr class="row-even"><td><p><cite>\r</cite></p></td>
<td><p>imleci aynı satırın başına döndüren kaçış dizisi</p></td>
</tr>
<tr class="row-odd"><td><p><cite>\v</cite></p></td>
<td><p>düşey sekme oluşturan kaçış dizisi</p></td>
</tr>
<tr class="row-even"><td><p><cite>\f</cite></p></td>
<td><p>yeni bir sayfaya geçiren kaçış dizisi</p></td>
</tr>
</tbody>
</table>
</div></blockquote>
<p>Yani eğer <code class="docutils literal notranslate"><span class="pre">strip()</span></code> metoduna herhangi bir parametre vermezsek bu metot
otomatik olarak karakter dizilerinin sağında ve solunda bulunan yukarıdaki
karakterleri kırpacaktır. Ancak eğer biz istersek <code class="docutils literal notranslate"><span class="pre">strip()</span></code> metoduna bir
parametre vererek bu metodun istediğimiz herhangi başka bir karakteri kırpmasını
da sağlayabiliriz. Ö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">"python"</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="o">.</span><span class="n">strip</span><span class="p">(</span><span class="s2">"p"</span><span class="p">)</span>
<span class="go">'ython'</span>
</pre></div>
</div>
<p>Burada <code class="docutils literal notranslate"><span class="pre">strip()</span></code> metoduna parametre olarak <cite>“p”</cite> karakter dizisini vererek,
<code class="docutils literal notranslate"><span class="pre">strip()</span></code> metodunun, karakter dizisinin başında bulunan <cite>“p”</cite> karakterini
ortadan kaldırmasını sağladık. Yalnız <code class="docutils literal notranslate"><span class="pre">strip()</span></code> metodunu kullanırken bir
noktaya dikkat etmelisiniz. Bu metot bir karakter dizisinin hem başında, hem de
sonunda bulunan karakterlerle ilgilenir. Mesela şu örneğe 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="o">=</span> <span class="s2">"kazak"</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="o">.</span><span class="n">strip</span><span class="p">(</span><span class="s2">"k"</span><span class="p">)</span>
<span class="go">'aza'</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <code class="docutils literal notranslate"><span class="pre">strip()</span></code> metoduna <cite>“k”</cite> parametresini vererek, <cite>“kazak”</cite>
adlı karakter dizisinin hem başındaki hem de sonundaki <cite>“k”</cite> harflerini kırpmayı
başardık. Eğer bu metoda verdiğiniz parametre karakter dizisinde geçmiyorsa, bu
durumda <code class="docutils literal notranslate"><span class="pre">strip()</span></code> metodu herhangi bir işlem yapmaz. Ya da aradığınız karakter,
karakter dizisinin yalnızca tek bir tarafında (mesela sadece başında veya sadece
sonunda) geçiyorsa, <code class="docutils literal notranslate"><span class="pre">strip()</span></code> metodu, ilgili karakter hangi taraftaysa onu
siler. Aranan karakterin bulunmadığı tarafla ilgilenmez.</p>
<p><code class="docutils literal notranslate"><span class="pre">strip()</span></code> metodunu anlatmaya başlarken, içinde gereksiz yere <cite>></cite> işaretlerinin
geçtiği e.postalardan söz etmiş ve bu e.postalardaki o gereksiz karakterleri
elle silmenin ne kadar da sıkıcı bir iş olduğunu söylemiştik. Eğer
e.postalarınızda bu tip durumlarla sık sık karşılaşıyorsanız, gereksiz
karakterleri silme görevini sizin yerinize Python yerine getirebilir. Şimdi şu
kodları dikkatlice inceleyin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">metin</span> <span class="o">=</span> <span class="s2">"""</span>
<span class="s2">> Python programlama dili Guido Van Rossum adlı Hollandalı bir programcı tarafından</span>
<span class="s2">> 90'lı yılların başında geliştirilmeye başlanmıştır. Çoğu insan, isminin Python</span>
<span class="s2">> olmasına bakarak, bu programlama dilinin, adını piton yılanından aldığını düşünür.</span>
<span class="s2">> Ancak zannedildiğinin aksine bu programlama dilinin adı piton yılanından gelmez.</span>
<span class="s2">> Guido Van Rossum bu programlama dilini, The Monty Python adlı bir İngiliz komedi</span>
<span class="s2">> grubunun, Monty Python's Flying Circus adlı gösterisinden esinlenerek adlandırmıştır.</span>
<span class="s2">> Ancak her ne kadar gerçek böyle olsa da, Python programlama dilinin pek çok yerde</span>
<span class="s2">> bir yılan figürü ile temsil edilmesi neredeyse bir gelenek halini almıştır diyebiliriz.</span>
<span class="s2">"""</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">metin</span><span class="o">.</span><span class="n">split</span><span class="p">():</span>
<span class="nb">print</span><span class="p">(</span><span class="n">i</span><span class="o">.</span><span class="n">strip</span><span class="p">(</span><span class="s2">"> "</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>Bu programı çalıştırdığınızda şöyle bir çıktı elde edeceksiniz:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>Python programlama dili Guido Van Rossum adlı Hollandalı bir programcı tarafından
90'lı yılların başında geliştirilmeye başlanmıştır. Çoğu insan, isminin Python
olmasına bakarak, bu programlama dilinin, adını piton yılanından aldığını düşünür.
Ancak zannedildiğinin aksine bu programlama dilinin adı piton yılanından gelmez.
Guido Van Rossum bu programlama dilini, The Monty Python adlı bir İngiliz komedi
grubunun, Monty Python's Flying Circus adlı gösterisinden esinlenerek adlandırmıştır.
Ancak her ne kadar gerçek böyle olsa da, Python programlama dilinin pek çok yerde
bir yılan figürü ile temsil edilmesi neredeyse bir gelenek halini almıştır diyebiliriz.
</pre></div>
</div>
<p>Gördüğünüz gibi, her satırın başında bulunan <cite>‘> ‘</cite> karakterlerini ufacık birkaç
kod yardımıyla rahatlıkla temizledik. Burada <code class="docutils literal notranslate"><span class="pre">strip()</span></code> metoduyla birlikte
<code class="docutils literal notranslate"><span class="pre">split()</span></code> metodunu da kullandığımızı görüyorsunuz. <code class="docutils literal notranslate"><span class="pre">split()</span></code> metodu ile önce
<cite>metin</cite> adlı karakter dizisini parçaladık. Daha sonra da <code class="docutils literal notranslate"><span class="pre">strip()</span></code> metodu
yardımıyla baş taraftaki istenmeyen karakterleri temizledik.</p>
<p>Yukarıdaki örnekte verdiğimiz metin, istenmeyen karakterleri yalnızca tek bir
tarafta içeriyor. Ama elbette istenmeyen karakterler, karakter dizisinin ne
tarafında olursa olsun <code class="docutils literal notranslate"><span class="pre">strip()</span></code> metodu bu karakterleri başarıyla kırpacaktır.</p>
<p>Bu bölümün başlığında <code class="docutils literal notranslate"><span class="pre">strip()</span></code> metodu ile birlikte <code class="docutils literal notranslate"><span class="pre">lstrip()</span></code> ve
<code class="docutils literal notranslate"><span class="pre">rstrip()</span></code> adlı iki metodun daha adı geçiyordu. <code class="docutils literal notranslate"><span class="pre">strip()</span></code> metodunun ne işe
yaradığını öğrendik. Peki bu <code class="docutils literal notranslate"><span class="pre">lstrip()</span></code> ve <code class="docutils literal notranslate"><span class="pre">rstrip()</span></code> metotları ne işe
yarıyor?</p>
<p><code class="docutils literal notranslate"><span class="pre">lstrip()</span></code> metodundan başlayalım anlatmaya…</p>
<p><code class="docutils literal notranslate"><span class="pre">strip()</span></code> metodunu anlatırken, bu metodun bir karakter dizisinin sağında ve
solunda bulunan istenmeyen karakterleri kırptığını söylemiştik. Ancak bazen,
istediğimiz şey bu olmayabilir. Yani biz bir karakter dizisinin hem sağında, hem
de solunda bulunan gereksiz karakterleri değil, yalnızca sağında veya yalnızca
solunda bulunan gereksiz karakterleri kırpmak isteyebiliriz. Örneğin <code class="docutils literal notranslate"><span class="pre">strip()</span></code>
metodunu anlatırken verdiğimiz <cite>“kazak”</cite> örneğini ele alalım. Şöyle bir komutun
ne yapacağını biliyorsunuz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"kazak"</span><span class="o">.</span><span class="n">strip</span><span class="p">(</span><span class="s2">"k"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu komut hem sol, hem de sağ taraftaki <cite>“k”</cite> karakterlerini kırpacaktır. Ama
peki ya biz sadece sol taraftaki <cite>“k”</cite> karakterini atmak istersek ne olacak?
İşte böyle bir durumda <code class="docutils literal notranslate"><span class="pre">strip()</span></code> metodundan değil, <code class="docutils literal notranslate"><span class="pre">lstrip()</span></code> metodundan
faydalanacağız.</p>
<p><code class="docutils literal notranslate"><span class="pre">lstrip()</span></code> metodu bir karakter dizisinin sol tarafındaki gereksiz
karakterlerden kurtulmamızı sağlar. Mesela bu bilgiyi yukarıdaki örneğe
uygulayalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"kazak"</span><span class="o">.</span><span class="n">lstrip</span><span class="p">(</span><span class="s2">"k"</span><span class="p">)</span>
<span class="go">'azak'</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <code class="docutils literal notranslate"><span class="pre">lstrip()</span></code> metodu yalnızca sol baştaki <cite>“k”</cite> harfiyle
ilgilendi. Sağ taraftaki <cite>“k”</cite> harfine ise dokunmadı. Eğer sol taraftaki
karakteri değil de yalnızca sağ taraftaki karakteri uçurmak istemeniz halinde
ise <code class="docutils literal notranslate"><span class="pre">rstrip()</span></code> metodundan yararlanacaksınız:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"kazak"</span><span class="o">.</span><span class="n">rstrip</span><span class="p">(</span><span class="s2">"k"</span><span class="p">)</span>
<span class="go">'kaza'</span>
</pre></div>
</div>
<p>Bu arada, yukarıdaki metotları doğrudan karakter dizileri üzerine
uygulayabildiğimize de dikkat edin. Yani şu iki yöntem de uygun ve doğrudur:</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">"karakter dizisi"</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="o">.</span><span class="n">metot_adı</span><span class="p">()</span>
</pre></div>
</div>
<p>veya:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"karakter dizisi"</span><span class="o">.</span><span class="n">metot_adı</span><span class="p">()</span>
</pre></div>
</div>
</div>
<div class="section" id="join">
<h2>join()<a class="headerlink" href="#join" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Hatırlarsanız şimdiye kadar öğrendiğimiz metotlar arasında <code class="docutils literal notranslate"><span class="pre">split()</span></code> adlı bir
metot vardı. Bu metodun ne işe yaradığını ve nasıl kullanıldığını biliyorsunuz:</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">"Beşiktaş Jimnastik Kulübü"</span>
<span class="gp">>>> </span><span class="n">bölünmüş</span> <span class="o">=</span> <span class="n">kardiz</span><span class="o">.</span><span class="n">split</span><span class="p">()</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">bölünmüş</span><span class="p">)</span>
<span class="go">['Beşiktaş', 'Jimnastik', 'Kulübü']</span>
</pre></div>
</div>
<p>Gördüğünüz gibi <code class="docutils literal notranslate"><span class="pre">split()</span></code> metodu bir karakter dizisini belli yerlerden bölerek
parçalara ayırıyor. Bu noktada insanın aklına şöyle bir soru geliyor: Diyelim ki
elimizde böyle bölünmüş bir karakter dizisi grubu var. Biz bu grup içindeki
karakter dizilerini tekrar birleştirmek istersek ne yapacağız?</p>
<p>Şimdi şu kodlara çok dikkatlice bakın:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">" "</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">bölünmüş</span><span class="p">)</span>
<span class="go">'Beşiktaş Jimnastik Kulübü'</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <cite>“Beşiktaş Jimnastik Kulübü”</cite> adlı karakter dizisinin ilk
halini tekrar elde ettik. Yani bu karakter dizisine ait, bölünmüş parçaları
tekrar bir araya getirdik. Ancak bu işi yapan kod gözünüzüne biraz tuhaf ve
anlaşılmaz görünmüş olabilir.</p>
<p>İlk başta dikkatimizi çeken şey, bu metodun öbür metotlara göre biraz daha
farklı bir yapıya sahipmiş gibi görünmesi. Ama belki yukarıdaki örneği şöyle
yazarsak bu örnek biraz daha anlaşılır gelebilir gözünüze:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">birleştirme_karakteri</span> <span class="o">=</span> <span class="s2">" "</span>
<span class="gp">>>> </span><span class="n">birleştirme_karakteri</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">bölünmüş</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada da tıpkı öteki metotlarda olduğu gibi, <code class="docutils literal notranslate"><span class="pre">join()</span></code> metodunu bir karakter
dizisi üzerine uyguladık. Bu karakter dizisi bir adet boşluk karakteri. Ayrıca
gördüğünüz gibi <code class="docutils literal notranslate"><span class="pre">join()</span></code> metodu bir adet de parametre alıyor. Bu örnekte
<code class="docutils literal notranslate"><span class="pre">join()</span></code> metoduna verdiğimiz parametre <cite>bölünmüş</cite> adlı değişken. Aslında şöyle
bir düşününce yukarıdaki kodların sanki şöyle yazılması gerekiyormuş gibi
gelebilir size:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">bölünmüş</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">birleştirme_karakteri</span><span class="p">)</span>
</pre></div>
</div>
<p>Ama bu kullanım yanlıştır. Üstelik kodunuzu böyle yazarsanız Python size bir
hata mesajı gösterecektir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">bölünmüş</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">birleştirme_karakteri</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">AttributeError</span>: <span class="n">'list' object has no attribute 'join'</span>
</pre></div>
</div>
<p>Buradaki hata mesajı bize şöyle diyor: ‘liste nesnesinin <cite>join</cite> adlı bir
niteliği yoktur!’. Bu cümledeki ‘liste nesnesi’ ifadesine özellikle dikkatinizi
çekmek istiyorum. Biz şimdiye kadar iki tür nesne (ya da başka bir ifadeyle veri
tipi) görmüştük. Bunlar karakter dizileri ve sayılardı. Burada karşımıza üçüncü
bir nesne çıkıyor. Gördüğümüz kadarıyla bu yeni nesnenin adı ‘liste’. (Liste
adlı veri tipini birkaç bölüm sonra en ince ayrıntısına kadar inceleyeceğiz.
Python’da böyle bir veri tipi olduğunu bilmemiz bizim için şimdilik yeterli.)</p>
<p>İşte yukarıdaki hatayı almamızın nedeni, aslında karakter dizilerine ait bir
metot olan <code class="docutils literal notranslate"><span class="pre">join()</span></code> metodunu bir liste üzerinde uygulamaya çalışmamız. Böyle
bir durumda da Python doğal olarak bizi ‘liste nesnelerinin <cite>join</cite> adlı bir
niteliği olmadığı’ konusunda uyarıyor. Bütün bu anlattıklarımız bizi şu sonuca
ulaştırıyor: Bir veri tipine ait metotlar doğal olarak yalnızca o veri tipi
üzerinde kullanılabilir. Mesela yukarıdaki örnekte gördüğümüz gibi, bir karakter
dizisi metodu olan <code class="docutils literal notranslate"><span class="pre">join()</span></code>’i başka bir veri tipine uygulamaya çalışırsak hata
alırız.</p>
<p>Sonuç olarak, <code class="docutils literal notranslate"><span class="pre">join()</span></code> adlı metodu <cite>bölünmüş</cite> adlı değişkene
uygulayamayacağımızı anlamış bulunuyoruz. O halde bu metotla birlikte
kullanılmak üzere bir karakter dizisi bulmamız gerekiyor.</p>
<p>En başta da söylediğimiz gibi, <code class="docutils literal notranslate"><span class="pre">join()</span></code> metodunun görevi bölünmüş karakter
dizisi gruplarını birleştirmektir. Bu metot görevini yerine getirirken, yani
karakter dizisi gruplarını birleştirirken bir birleştirme karakterine ihtiyaç
duyar. Bizim örneğimizde bu birleştirme karakteri bir adet boşluktur. Durumu
daha iyi anlayabilmek için örneğimizi tekrar gözümünün önüne getirelim:</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">"Beşiktaş Jimnastik Kulübü"</span>
<span class="gp">>>> </span><span class="n">bölünmüş</span> <span class="o">=</span> <span class="n">kardiz</span><span class="o">.</span><span class="n">split</span><span class="p">()</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">bölünmüş</span><span class="p">)</span>
<span class="go">['Beşiktaş', 'Jimnastik', 'Kulübü']</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">join</span><span class="p">(</span><span class="n">bölünmüş</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">Beşiktaş Jimnastik Kulübü</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, orijinal karakter dizisinin bölünmüş parçalarını, her bir
parçanın arasında bir adet boşluk olacak şekilde yeniden birleştirdik. Elbette
sadece boşluk karakteri kullanabileceğiz diye bir kaide yok. Mesela şu örneklere
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="o">=</span> <span class="s2">"-"</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">bölünmüş</span><span class="p">)</span>
<span class="go">Beşiktaş-Jimnastik-Kulübü</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">join</span><span class="p">(</span><span class="n">bölünmüş</span><span class="p">)</span>
<span class="go">BeşiktaşJimnastikKulübü</span>
</pre></div>
</div>
<p>İlk örnekte, bölünmüş karakter dizilerini <cite>-</cite> işareti ile birleştirdik. İkinci
örnekte ise bu karakter dizilerini birleştirmek için boş bir karakter dizisi
kullandık. Yani parçaları birleştirirken arada boşluk olmamasını sağladık.</p>
<p><code class="docutils literal notranslate"><span class="pre">join()</span></code> metodu ile bol bol pratik yaparak bu metodu hakkıyla öğrenmenizi
tavsiye ederim. Zira programcılık maceranız boyunca en sık kullanacağınız
karakter dizisi metotları listesinin en başlarında bu metot yer alır.</p>
</div>
<div class="section" id="count">
<h2>count()<a class="headerlink" href="#count" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Tıpkı daha önce öğrendiğimiz sorgulayıcı metotlar gibi, <code class="docutils literal notranslate"><span class="pre">count()</span></code> metodu da
bir karakter dizisi üzerinde herhangi bir değişiklik yapmamızı sağlamaz. Bu
metodun görevi bir karakter dizisi içinde belli bir karakterin kaç kez geçtiğini
sorgulamaktır. Bununla ilgili hemen bir örnek verelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">şehir</span> <span class="o">=</span> <span class="s2">"Kahramanmaraş"</span>
<span class="gp">>>> </span><span class="n">şehir</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="s2">"a"</span><span class="p">)</span>
<span class="go">5</span>
</pre></div>
</div>
<p>Buradan anlıyoruz ki, <cite>“Kahramanmaraş”</cite> adlı karakter dizisi içinde toplam <cite>5</cite>
adet <cite>“a”</cite> karakteri geçiyor.</p>
<p><code class="docutils literal notranslate"><span class="pre">count()</span></code> metodu yaygın olarak yukarıdaki örnekte görüldüğü şekilde sadece tek
bir parametre ile kullanılır. Ama aslında bu metot toplam 3 parametre alır.
Şimdi şu örnekleri dikkatlice inceleyin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">şehir</span> <span class="o">=</span> <span class="s2">"adana"</span>
<span class="gp">>>> </span><span class="n">şehir</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="s2">"a"</span><span class="p">)</span>
<span class="go">3</span>
<span class="gp">>>> </span><span class="n">şehir</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="s2">"a"</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">şehir</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="s2">"a"</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">2</span>
<span class="gp">>>> </span><span class="n">şehir</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="s2">"a"</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="go">1</span>
<span class="gp">>>> </span><span class="n">şehir</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="s2">"a"</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="go">1</span>
</pre></div>
</div>
<p>İlk örnekte <code class="docutils literal notranslate"><span class="pre">count()</span></code> metodunu tek bir parametre ile birlikte kullandığımız
için <cite>“adana”</cite> adlı karakter dizisi içindeki bütün <cite>“a”</cite> harflerinin toplam
sayısı çıktı olarak verildi.</p>
<p>İkinci örnekte ise <code class="docutils literal notranslate"><span class="pre">count()</span></code> metoduna ikinci bir parametre daha verdik. Bu
ikinci parametre, <code class="docutils literal notranslate"><span class="pre">count()</span></code> metodunun bir karakteri saymaya başlarken karakter
dizisinin kaçıncı sırasından başlayacağını gösteriyor. Bu örnekte ikinci
parametre olarak <cite>1</cite> sayısını verdiğimiz için, Python saymaya <cite>“adana”</cite> karakter
dizisinin <cite>1.</cite> sırasından başlayacak. Dolayısıyla <cite>0.</cite> sıradaki <cite>“a”</cite> harfi
sayım işleminin dışında kalacağı için toplam <cite>“a”</cite> sayısı <cite>3</cite> değil <cite>2</cite> olarak
görünecek. Gördüğünüz gibi, sonraki örneklerde de aynı mantığı takip ettiğimiz
için aradığımız karakterin toplam sayısı örnekten örneğe farklılık gösteriyor.</p>
<p>Peki bu metodu gerçek programlarda ne amaçla kullanabilirsiniz? Bu metodu
kullanarak, örneğin, kullanıcıyı aynı karakterden yalnızca bir adet girmeye
zorlayabilirsiniz. Bunun için mesela şöyle bir yapı kullanabilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">parola</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"parolanız: "</span><span class="p">)</span>
<span class="n">kontrol</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">parola</span><span class="p">:</span>
<span class="k">if</span> <span class="n">parola</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="n">i</span><span class="p">)</span> <span class="o">></span> <span class="mi">1</span><span class="p">:</span>
<span class="n">kontrol</span> <span class="o">=</span> <span class="kc">False</span>
<span class="k">if</span> <span class="n">kontrol</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">'Parolanız onaylandı!'</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">'Parolanızda aynı harfi bir kez kullanabilirsiniz!'</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada <cite>kontrol</cite> değişkeninin değerini <cite>True</cite> olarak belirledik. Eğer <cite>parola</cite>
içindeki harflerden herhangi biri 1’den fazla geçiyorsa bu durumda <cite>kontrol</cite>
değişkeninin değerini <cite>False</cite> yapıyoruz:</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">parola</span><span class="p">:</span>
<span class="k">if</span> <span class="n">parola</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="n">i</span><span class="p">)</span> <span class="o">></span> <span class="mi">1</span><span class="p">:</span>
<span class="n">kontrol</span> <span class="o">=</span> <span class="kc">False</span>
</pre></div>
</div>
<p>Daha sonra da <cite>kontrol</cite> değişkeninin durumuna göre kullanıcıya parolanın
onaylandığı veya onaylanmadığı bilgisini veriyoruz. Buna göre eğer <cite>kontrol</cite>
değişkeninin değeri <cite>True</cite> ise şu çıktıyı veriyoruz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span>Parolanız onaylandı!
</pre></div>
</div>
<p>Aksi halde şu çıktıyı veriyoruz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span>Parolanızda aynı harfi bir kez kullanabilirsiniz!
</pre></div>
</div>
<p>Yukarıdakine benzer durumların dışında <code class="docutils literal notranslate"><span class="pre">count()</span></code> metodunu şöyle durumlarda da
kullanabilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kelime</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Herhangi bir kelime: "</span><span class="p">)</span>
<span class="k">for</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">kelime</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="si">{}</span><span class="s2"> harfi </span><span class="si">{}</span><span class="s2"> kelimesinde </span><span class="si">{}</span><span class="s2"> kez geçiyor!"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">harf</span><span class="p">,</span>
<span class="n">kelime</span><span class="p">,</span>
<span class="n">kelime</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="n">harf</span><span class="p">)))</span>
</pre></div>
</div>
<p>Burada amacımız kullanıcının girdiği bir kelime içindeki bütün harflerin o
kelime içinde kaç kez geçtiğini bulmak. <code class="docutils literal notranslate"><span class="pre">count()</span></code> metodunu kullanarak bu işi
çok kolay bir şekilde halledebiliyoruz. Kullanıcının mesela ‘adana’ kelimesini
girdiğini varsayarsak yukarıdaki program şöyle bir çıktı verecektir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span>a harfi adana kelimesinde 3 kez geçiyor!
d harfi adana kelimesinde 1 kez geçiyor!
a harfi adana kelimesinde 3 kez geçiyor!
n harfi adana kelimesinde 1 kez geçiyor!
a harfi adana kelimesinde 3 kez geçiyor!
</pre></div>
</div>
<p>Ancak burada şöyle bir problem var: ‘adana’ kelimesi içinde birden fazla geçen
harfler (mesela ‘a’ harfi) çıktıda birkaç kez tekrarlanıyor. Yani mesela ‘a’
harfinin geçtiği her yerde programımız ‘a’ harfinin kelime içinde kaç kez
geçtiğini rapor ediyor. İstediğiniz davranış bu olabilir. Ama bazı durumlarda
her harfin kelime içinde kaç kez geçtiği bilgisinin yalnızca bir kez
raporlanmasını isteyebilirsiniz. Yani siz yukarıdaki gibi bir çıktı yerine şöyle
bir çıktı elde etmek istiyor olabilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span>a harfi adana kelimesinde 3 kez geçiyor!
d harfi adana kelimesinde 1 kez geçiyor!
n harfi adana kelimesinde 1 kez geçiyor!
</pre></div>
</div>
<p>Böyle bir çıktı elde edebilmek için şöyle bir program yazabilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kelime</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Herhangi bir kelime: "</span><span class="p">)</span>
<span class="n">sayaç</span> <span class="o">=</span> <span class="s2">""</span>
<span class="k">for</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">kelime</span><span class="p">:</span>
<span class="k">if</span> <span class="n">harf</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">sayaç</span><span class="p">:</span>
<span class="n">sayaç</span> <span class="o">+=</span> <span class="n">harf</span>
<span class="k">for</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">sayaç</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="si">{}</span><span class="s2"> harfi </span><span class="si">{}</span><span class="s2"> kelimesinde </span><span class="si">{}</span><span class="s2"> kez geçiyor!"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">harf</span><span class="p">,</span>
<span class="n">kelime</span><span class="p">,</span>
<span class="n">kelime</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="n">harf</span><span class="p">)))</span>
</pre></div>
</div>
<p>Gelin isterseniz bu kodları şöyle bir inceleyelim.</p>
<p>Bu kodlarda öncelikle kullanıcıdan herhangi bir kelime girmesini istiyoruz.</p>
<p>Daha sonra <cite>sayaç</cite> adlı bir değişken tanımlıyoruz. Bu değişken, kullanıcının
girdiği kelime içindeki harfleri tutacak. Bu değişken, <cite>kelime</cite> değişkeninden
farklı olarak, kullanıcının girdiği sözcük içinde birden fazla geçen harflerden
yalnızca tek bir örnek içerecek.</p>
<p>Değişkenimizi tanımladıktan sonra bir <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü kuruyoruz. Bu döngüye
dikkatlice bakın. Kullanıcının girdiği kelime içinde geçen harflerden her birini
yalnızca bir kez alıp <cite>sayaç</cite> değişkenine gönderiyoruz. Böylece elimizde her
harften sadece bir adet olmuş oluyor. Burada Python’ın arka planda neler
çevirdiğini daha iyi anlayabilmek için isterseniz döngüden sonra şöyle bir satır
ekleyerek <cite>sayaç</cite> değişkeninin içeriğini inceleyebilir, böylece burada
kullandığımız <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsünün nasıl çalıştığını daha iyi görebilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="s2">"sayaç içeriği: "</span><span class="p">,</span> <span class="n">sayaç</span><span class="p">)</span>
</pre></div>
</div>
<p>İlk döngümüz sayesinde, kullanıcının girdiği kelime içindeki her harfi teke
indirerek, bu harfleri <cite>sayaç</cite> değişkeni içinde topladık. Şimdi yapmamız gereken
şey, <cite>sayaç</cite> değişkenine gönderilen her bir harfin, <cite>kelime</cite> adlı değişken
içinde kaç kez geçtiğini hesaplamak olmalı. Bunu da yine bir <cite>for</cite> döngüsü ile
yapabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">sayaç</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="si">{}</span><span class="s2"> harfi </span><span class="si">{}</span><span class="s2"> kelimesinde </span><span class="si">{}</span><span class="s2"> kez geçiyor!"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">harf</span><span class="p">,</span>
<span class="n">kelime</span><span class="p">,</span>
<span class="n">kelime</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="n">harf</span><span class="p">)))</span>
</pre></div>
</div>
<p>Burada yaptığımız şey şu: <code class="docutils literal notranslate"><span class="pre">count()</span></code> metodunu kullanarak, <cite>sayaç</cite> değişkeninin
içindeki her bir harfin, <cite>kelime</cite> değişkeninin içinde kaç kez geçtiğini
buluyoruz. Bu döngünün nasıl çalıştığını daha iyi anlayabilmek için, isterseniz
bu döngüyü şu şekilde sadeleştirebilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">sayaç</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="n">harf</span><span class="p">,</span> <span class="n">kelime</span><span class="p">,</span> <span class="n">kelime</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="n">harf</span><span class="p">))</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <cite>sayaç</cite> değişkeni içindeki herbir harfin <cite>kelime</cite> adlı karakter
dizisi içinde kaç kez geçtiğini tek tek sorguladık.</p>
<p>Yukarıdaki örneklerde <code class="docutils literal notranslate"><span class="pre">count()</span></code> metodunun iki farklı parametre aldığını
gördük. Bu metot bunların dışında üçüncü bir parametre daha alır. Bu üçüncü
parametre ikinci parametreyle ilişkilidir. Dilerseniz bu ilişkiyi bir örnek
üzerinde görelim:</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 programlama dili"</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="s2">"a"</span><span class="p">)</span>
<span class="go">3</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="s2">"a"</span><span class="p">,</span> <span class="mi">15</span><span class="p">)</span>
<span class="go">2</span>
</pre></div>
</div>
<p>Bu örneklerden anladığımıza göre, <cite>“python programlama dili”</cite> adlı karakter
dizisi içinde toplam <cite>3</cite> adet ‘a’ harfi var. Eğer bu karakter dizisi içindeki
‘a’ harflerini karakter dizisinin en başından itibaren değil de, <cite>15.</cite>
karakterden itibaren saymaya başlarsak bu durumda <cite>2</cite> adet ‘a’ harfi buluyoruz.
Şimdi de şu örneğe 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="o">.</span><span class="n">count</span><span class="p">(</span><span class="s2">"a"</span><span class="p">,</span> <span class="mi">15</span><span class="p">,</span> <span class="mi">17</span><span class="p">)</span>
<span class="go">1</span>
</pre></div>
</div>
<p>Burada, <cite>15.</cite> karakter ile <cite>17.</cite> karakter arasında kalan ‘a’ harflerini saymış
olduk. <cite>15.</cite> karakter ile <cite>17.</cite> karakter arasında toplam <cite>1</cite> adet ‘a’ harfi
olduğu için de Python bize <cite>1</cite> sonucunu verdi. Bütün bu örneklerden sonra
<code class="docutils literal notranslate"><span class="pre">count()</span></code> metoduna ilişkin olarak şöyle bir tespitte bulunabiliriz:</p>
<blockquote>
<div><p><code class="docutils literal notranslate"><span class="pre">count()</span></code> metodu bir karakter dizisi içinde belli bir karakterin kaç kez
geçtiğini sorgulamamızı sağlar. Örneğin bu metodu <code class="docutils literal notranslate"><span class="pre">count("a")</span></code> şeklinde
kullanırsak Python bize karakter dizisi içindeki bütün “a” harflerinin
sayısını verecektir. Eğer bu metoda 2. ve 3. parametreleri de verirsek,
sorgulama işlemi karakter dizisinin belli bir kısmında
gerçekleştirilecektir. Örneğin <code class="docutils literal notranslate"><span class="pre">count("a",</span> <span class="pre">4,</span> <span class="pre">7)</span></code> gibi bir kullanım, bize
karakter dizisinin 4. ve 7. karakterleri arasında kalan “a” harflerinin
sayısını verecektir.</p>
</div></blockquote>
<p>Böylece bir metodu daha ayrıntılı bir şekilde incelemiş olduk. Artık başka bir
metot incelemeye geçebiliriz.</p>
</div>
<div class="section" id="index-rindex">
<h2>index(), rindex()<a class="headerlink" href="#index-rindex" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Bu bölümün başında karakter dizilerinin dilimlenme özelliğinden söz ederken,
karakter dizisi içindeki her harfin bir sırası olduğunu söylemiştik. Örneğin
<cite>“python”</cite> adlı karakter dizisinde ‘p’ harfinin sırası <cite>0</cite>’dır. Aynı şekilde ‘n’
harfinin sırası ise <cite>5</cite>’tir. Karakterlerin, bir karakter dizisi içinde hangi
sırada bulunduğunu öğrenmek için <code class="docutils literal notranslate"><span class="pre">index()</span></code> adlı bir metottan yararlanabiliriz.
Ö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">"python"</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="s2">"p"</span><span class="p">)</span>
<span class="go">0</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="s2">"n"</span><span class="p">)</span>
<span class="go">5</span>
</pre></div>
</div>
<p>Eğer sırasını sorguladığımız karakter, o karakter dizisi içinde bulunmuyorsa, bu
durumda Python bize bir hata mesajı gösterir:</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="n">index</span><span class="p">(</span><span class="s2">"z"</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">ValueError</span>: <span class="n">substring not found</span>
</pre></div>
</div>
<p>Bu metodun özelliği, sorguladığımız karakterin, karakter dizisi içinde geçtiği
ilk konumu vermesidir. Yani ö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">"adana"</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="s2">"a"</span><span class="p">)</span>
<span class="go">0</span>
</pre></div>
</div>
<p><cite>“adana”</cite> adlı karakter dizisi içinde <cite>3</cite> adet ‘a’ harfi var. Ancak biz
<code class="docutils literal notranslate"><span class="pre">index()</span></code> metodu yardımıyla <cite>“adana”</cite> karakter dizisi içindeki ‘a’ harfinin
konumunu sorgularsak, Python bize ‘a’ harfinin geçtiği ilk konumu, yani <cite>0.</cite>
konumu, bildirecektir. Halbuki <cite>“adana”</cite> karakter dizisi içinde <cite>2.</cite> ve <cite>4.</cite>
sıralarda da birer ‘a’ harfi var. Ancak <code class="docutils literal notranslate"><span class="pre">index()</span></code> metodu <cite>0.</cite> konumdaki ‘a’
harfini gördükten sonra karakter dizisinin geri kalanına bakmaz.</p>
<p><code class="docutils literal notranslate"><span class="pre">index()</span></code> metodunu biz yukarıda tek bir parametre ile birlikte kullandık. Bu
parametre, karakter dizisi içinde konumunu öğrenmek istediğimiz karakteri
gösteriyor. Ama bu metot aslında toplam <cite>3</cite> parametre alır. Şu örnekleri
dikkatlice inceleyelim:</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">"adana"</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="s2">"a"</span><span class="p">)</span>
<span class="go">0</span>
</pre></div>
</div>
<p>Burada normal bir şekilde <code class="docutils literal notranslate"><span class="pre">index()</span></code> metodunu tek bir parametre ile birlikte
kullandık. Böylece Python bize ‘a’ harfinin karakter dizisi içinde ilk olarak
hangi sırada bulunduğunu gösterdi. Bir de şu örneğe 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="o">.</span><span class="n">index</span><span class="p">(</span><span class="s2">"a"</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">2</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, bu defa <code class="docutils literal notranslate"><span class="pre">index()</span></code> metoduna ikinci bir parametre daha verdik.
<code class="docutils literal notranslate"><span class="pre">index()</span></code> metodunun ikinci parametresi, Python’ın aramaya kaçıncı sıradan
itibaren başlayacağını gösteriyor. Biz yukarıdaki örnekte Python’ın aramaya 1.
sıradan itibaren başlamasını istedik. Bu yüzden Python 0. sıradaki “a”
karakterini es geçti ve 2. sırada bulunan “a” karakterini gördü. 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="o">.</span><span class="n">index</span><span class="p">(</span><span class="s2">"a"</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu defa Python’ın aramaya <cite>3.</cite> sıradan başlamasını istedik. Dolayısıyla Python
<cite>0.</cite> ve <cite>2.</cite> sıralardaki ‘a’ harflerini görmezden gelip bize <cite>4.</cite> sıradaki ‘a’
harfinin sırasını bildirdi.</p>
<p>Gelelim <code class="docutils literal notranslate"><span class="pre">index()</span></code> metodunun <cite>3.</cite> parametresine… Dilerseniz <cite>3.</cite> parametrenin
ne işe yaradığını bir örnek üzerinde gösterelim:</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">"adana"</span>
<span class="gp">>>> </span><span class="n">kardiz</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="s2">"a"</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="go">2</span>
</pre></div>
</div>
<p>Hatırlarsanız, bundan önce <code class="docutils literal notranslate"><span class="pre">count()</span></code> adlı bir metot öğrenmiştik. O metot da
toplam <cite>3</cite> parametre alıyordu. <code class="docutils literal notranslate"><span class="pre">count()</span></code> metodunda kullandığımız <cite>2.</cite> ve <cite>3.</cite>
parametrelerin görevlerini hatırlıyor olmalısınız. İşte <code class="docutils literal notranslate"><span class="pre">index()</span></code> metodunun