forked from yazbel/python-istihza
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathkacis_dizileri.html
1267 lines (1183 loc) · 92.8 KB
/
kacis_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="Bu bölümde Python'daki kaçış dizilerinden (escape sequences) söz edeceğiz." name="description" />
<meta content="python, kaçış dizileri, escape sequences, satır başı, tab, sekme" name="keywords" />
<title>Kaçış Dizileri — Python 3 için Türkçe Kılavuz</title>
<link rel="stylesheet" type="text/css" href="_static/pygments.css" />
<link rel="stylesheet" type="text/css" href="_static/pyramid.css" />
<script data-url_root="./" id="documentation_options" 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/translations.js"></script>
<link rel="search" title="Ara" href="search.html" />
<link rel="next" title="Programları Kaydetme ve Çalıştırma" href="kaydetme_ve_calistirma.html" />
<link rel="prev" title="print() Fonksiyonu" href="print.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'><img src="_static/logo.png"></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="kaydetme_ve_calistirma.html" title="Programları Kaydetme ve Çalıştırma"
accesskey="N">sonraki</a></li>
<li class="right" >
<a href="print.html" title="print() Fonksiyonu"
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="">Kaçış Dizileri</a></li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="body" role="main">
<div class="section" id="kacis-dizileri">
<h1>Kaçış Dizileri<a class="headerlink" href="#kacis-dizileri" title="Bu başlık için kalıcı bağlantı">¶</a></h1>
<p>Python’da karakter dizilerini tanımlayabilmek için tek, çift veya üç tırnak
işaretlerinden faydalandığımızı geçen bölümde öğrenmiştik. Python bir verinin
karakter dizisi olup olmadığına bu tırnak işaretlerine bakarak karar verdiği
için, tek, çift ve üç tırnak işaretleri Python açısından özel bir önem taşıyor.
Zira Python’ın gözünde bir başlangıç tırnağı ile bitiş tırnağı arasında yer alan
her şey bir karakter dizisidir.</p>
<p>Örneğin ilk olarak bir <cite>“</cite> işareti koyup ardından <cite>“elma</cite> şeklinde devam
ettiğinizde, Python ilk tırnağı gördükten sonra karakter dizisini
tanımlayabilmek için ikinci bir tırnak işareti aramaya başlar. Siz <cite>“elma”</cite>
şeklinde kodunuzu tamamladığınızda ise Python bellekte <cite>“elma”</cite> adlı bir
karakter dizisi oluşturur.</p>
<p>Bu noktada size şöyle bir soru sormama izin verin: Acaba tırnak işaretleri
herhangi bir metin içinde kaç farklı amaçla kullanılabilir?</p>
<p>İsterseniz bu sorunun cevabını örnekler üzerinde vermeye çalışalım:</p>
<blockquote>
<div><p>Ahmet, “Bugün sinemaya gidiyorum,” dedi.</p>
</div></blockquote>
<p>Burada tırnak işaretlerini, bir başkasının sözlerini aktarmak için kullandık.</p>
<blockquote>
<div><p>‘book’ kelimesi Türkçede ‘kitap’ anlamına gelir.</p>
</div></blockquote>
<p>Burada ise tırnak işaretlerini bazı kelimeleri vurgulamak için kullandık.</p>
<p>Bir de şuna bakalım:</p>
<blockquote>
<div><p>Yarın Adana’ya gidiyorum.</p>
</div></blockquote>
<p>Burada da tırnak işaretini, çekim eki olan ‘-(y)a’ ile özel isim olan ‘Adana’
kelimesini birbirinden ayırmak için kesme işareti görevinde kullandık.</p>
<p>Şimdi yukarıda verdiğimiz ilk cümleyi bir karakter dizisi olarak tanımlamaya
çalışalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s1">'Ahmet, "Bugün sinemaya gidiyorum," dedi.'</span>
</pre></div>
</div>
<p>Burada karakter dizisini tanımlamaya tek tırnak işareti ile başladık. Böylece
Python bu karakter dizisini tanımlama işlemini bitirebilmek için ikinci bir tek
tırnak işareti daha aramaya koyuldu ve aradığı tek tırnak işaretini cümlenin
sonunda bularak, karakter dizisini düzgün bir şekilde oluşturabildi.</p>
<p>Dediğimiz gibi, Python’ın gözünde tırnak işaretleri bir karakter dizisini başka
veri tiplerinden ayırt etmeye yarayan bir ölçüttür. Ama biz insanlar, yukarıda
verdiğimiz örnek cümlelerden de göreceğiniz gibi, programlama dillerinden farklı
olarak, tırnak işaretlerini bir metin içinde daha farklı amaçlar için de
kullanabiliyoruz.</p>
<p>Şimdi yukarıdaki karakter dizisini şöyle tanımlamaya çalıştığımızı düşünün:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"Ahmet, "</span><span class="n">Bugün</span> <span class="n">sinemaya</span> <span class="n">gidiyorum</span><span class="p">,</span><span class="s2">" dedi."</span>
</pre></div>
</div>
<p>İşte burada Python’ın çıkarları ile bizim çıkarlarımız birbiriyle çatıştı.
Python karakter dizisini başlatan ilk çift tırnak işaretini gördükten sonra,
karakter dizisini tanımlama işlemini bitirebilmek için ikinci bir tırnak işareti
daha aramaya koyuldu. Bu arayış sırasında da ‘Bugün’ kelimesinin başındaki çift
tırnak işaretini gördü ve karakter dizisinin şu olduğunu zannetti:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"Ahmet, "</span>
</pre></div>
</div>
<p>Buraya kadar bir sorun yok. Bu karakter dizisi Python’ın sözdizimi kurallarına
uygun.</p>
<p>Karakter dizisi bu şekilde tanımlandıktan sonra Python cümlenin geri kalanını
okumaya devam ediyor ve herhangi bir tırnak işareti ile başlamayan ve
kendisinden önce gelen öğeden herhangi bir virgül işareti ile ayrılmamış ‘Bugün’
kelimesini görüyor. Eğer bir kelime tırnak işareti ile başlamıyorsa bu kelime ya
bir değişkendir ya da sayıdır. Ama ‘Bugün’ kelimesi ne bir değişken, ne de bir
sayı olduğu, üstelik önceki öğeden de virgülle ayrılmadığı için Python’ın hata
vermekten başka çaresi kalmıyor. Çünkü biz burada ‘Bugün’ kelimesinin baş
tarafındaki çift tırnak işaretini karakter dizisi tanımlamak için değil,
başkasının sözlerini aktarmak amacıyla kullandık. Ancak elbette bir programlama
dili bizim amacımızın ne olduğunu kestiremez ve hata mesajını suratımıza
yapıştırır:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span> <span class="n">File</span> <span class="s2">"<stdin>"</span><span class="p">,</span> <span class="n">line</span> <span class="mi">1</span>
<span class="s2">"Ahmet, "</span><span class="n">Bugün</span> <span class="n">sinemaya</span> <span class="n">gidiyorum</span><span class="p">,</span><span class="s2">" dedi."</span>
<span class="o">^</span>
<span class="ne">SyntaxError</span><span class="p">:</span> <span class="n">invalid</span> <span class="n">syntax</span>
</pre></div>
</div>
<p>Peki biz böyle bir durumda ne yapmalıyız?</p>
<p>Bu hatayı engellemek için karakter dizisini tanımlamaya çift tırnak yerine tek
tırnakla ya da üç tırnakla başlayabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s1">'Ahmet, "Bugün sinemaya gidiyorum," dedi.'</span>
</pre></div>
</div>
<p>… veya:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="sd">"""Ahmet, "Bugün sinemaya gidiyorum," dedi."""</span>
</pre></div>
</div>
<p>Böylece karakter dizisini başlatan işaret ‘Bugün sinemaya gidiyorum,’ cümlesinin
başındaki ve sonundaki işaretlerden farklı olduğu için, Python okuma esnasında
bu cümleye takılmaz ve doğru bir şekilde, karakter dizisini kapatan tırnak
işaretini bulabilir.</p>
<p>Bu yöntem tamamen geçerli ve mantıklıdır. Ama eğer istersek, aynı karakter
dizisini çift tırnakla tanımlayıp, yine de hata almayı engelleyebiliriz. Peki
ama nasıl?</p>
<p>İşte burada ‘kaçış dizileri’ adı verilen birtakım araçlardan faydalanacağız.</p>
<p>Peki nedir bu ‘kaçış dizisi’ denen şey?</p>
<p>Kaçış dizileri, Python’da özel anlam taşıyan işaret veya karakterleri, sahip
oldukları bu özel anlam dışında bir amaçla kullanmamızı sağlayan birtakım
araçlardır. Mesela yukarıda da örneklerini verdiğimiz gibi, tırnak işaretleri
Python açısından özel anlam taşıyan işaretlerdir. Normalde Python bu işaretleri
karakter dizilerini tanımlamak için kullanır. Ama eğer siz mesela bir metin
içinde bu tırnak işaretlerini farklı bir amaçla kullanacaksanız Python’ı bu
durumdan haberdar etmeniz gerekiyor. İşte kaçış dizileri, Python’ı böyle bir
durumdan haberdar etmemize yarayan araçlardır.</p>
<p>Python’da pek çok kaçış dizisi bulunur. Biz burada bu kaçış dizilerini tek tek
inceleyeceğiz. O halde hemen işe koyulalım.</p>
<div class="section" id="ters-taksim">
<h2>Ters Taksim (\)<a class="headerlink" href="#ters-taksim" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Yukarıda verdiğimiz örneklerde, çift tırnakla gösterdiğimiz karakter dizilerinin
içinde de çift tırnak işareti kullanabilmek için birkaç farklı yöntemden
yararlanabildiğimizi öğrenmiştik. Buna göre, eğer bir karakter dizisi içinde
çift tırnak işareti geçiyorsa, o karakter dizisini tek tırnakla; eğer tek tırnak
geçiyorsa da o karakter dizisini çift tırnakla tanımlayarak bu sorunun
üstesinden gelebiliyorduk. Ama daha önce de söylediğimiz gibi, ‘kaçış dizileri’
adı verilen birtakım araçları kullanarak, mesela içinde çift tırnak geçen
karakter dizilerini yine çift tırnakla tanımlayabiliriz.</p>
<p>Dilerseniz, kaçış dizisi kavramını açıklamaya geçmeden önce bununla ilgili
birkaç örnek verelim. Bu sayede ne ile karşı karşıya olduğumuz, zihnimizde biraz
daha belirginleşebilir:</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="s1">'Yarın Adana</span><span class="se">\'</span><span class="s1">ya gidiyorum.'</span><span class="p">)</span>
<span class="go">Yarın Adana'ya gidiyorum.</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">print</span><span class="p">(</span><span class="s2">"</span><span class="se">\"</span><span class="s2">book</span><span class="se">\"</span><span class="s2"> kelimesi Türkçede </span><span class="se">\"</span><span class="s2">kitap</span><span class="se">\"</span><span class="s2"> anlamına gelir."</span><span class="p">)</span>
<span class="go">"book" kelimesi Türkçede "kitap" anlamına gelir.</span>
</pre></div>
</div>
<p>Burada da cümle içinde çift tırnak işaretlerini kullandığımız halde, <cite>\</cite>
işaretleri sayesinde karakter dizilerini yine çift tırnakla tanımlayabildik.</p>
<p>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="nb">print</span><span class="p">(</span><span class="s2">"Python programlama dilinin adı </span><span class="se">\"</span><span class="s2">piton</span><span class="se">\"</span><span class="s2"> yılanından gelmez"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bütün bu örneklerde, karakter dizisini hem çift tırnakla tanımlayıp hem de
karakter dizisi içinde çift tırnak işaretlerini kullandığımız halde, herhangi
bir hata almadığımızı görüyorsunuz. Yukarıdaki kodlarda hata almamızı önleyen
şeyin <cite>\</cite> işareti olduğu belli. Ama dilerseniz bu işaretin, hata almamızı nasıl
önlediğini anlatmadan önce son bir örnek daha verelim.</p>
<p>Hatırlarsanız önceki sayfalarda şöyle bir karakter dizisi ile karşılaşmıştık:</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="s1">'İstanbul'</span><span class="n">un</span> <span class="mi">5</span> <span class="n">günlük</span> <span class="n">hava</span> <span class="n">durumu</span> <span class="n">tahmini</span><span class="s1">')</span>
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">'İstanbul'</span><span class="n">un</span> <span class="mi">5</span> <span class="n">günlük</span> <span class="n">hava</span> <span class="n">durumu</span> <span class="n">tahmini</span><span class="s1">')</span>
<span class="o">^</span>
<span class="gr">SyntaxError</span>: <span class="n">invalid syntax</span>
</pre></div>
</div>
<p>Burada da ‘İstanbul’un’ kelimesi içinde geçen tırnak işareti nedeniyle karakter
dizisini tek tırnak kullanarak tanımlayamıyorduk. Bu karakter dizisini hatasız
bir şekilde tanımlayabilmek için ya çift tırnak ya da üç tırnak kullanmamız
gerekiyordu:</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="s2">"İstanbul'un 5 günlük hava durumu tahmini"</span><span class="p">)</span>
<span class="go">İstanbul'un 5 günlük hava durumu tahmini</span>
</pre></div>
</div>
<p>… veya:</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="s2">"""İstanbul'un 5 günlük hava durumu tahmini"""</span><span class="p">)</span>
<span class="go">İstanbul'un 5 günlük hava durumu tahmini</span>
</pre></div>
</div>
<p>Tıpkı önceki örneklerde olduğu gibi, yukarıdaki karakter dizisini de aslında tek
tırnakla tanımlayıp hata oluşmasını önleyebiliriz. Hemen görelim:</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="s1">'İstanbul</span><span class="se">\'</span><span class="s1">un 5 günlük hava durumu tahmini'</span><span class="p">)</span>
<span class="go">İstanbul'un 5 günlük hava durumu tahmini</span>
</pre></div>
</div>
<p>Bütün örneklerde <cite>\</cite> işaretini kullandığımızı görüyorsunuz. İşte bu tür
işaretlere Python’da kaçış dizisi (<em>escape sequence</em>) adı verilir. Bu işaretler
karakter dizilerini tanımlarken oluşabilecek hatalardan kaçmamızı sağlar. Peki
bu <cite>\</cite> işareti nasıl oluyor da karakter dizisini tanımlarken hata almamızı
önlüyor? Gelin bu süreci adım adım tarif edelim:</p>
<p>Python bir karakter dizisi tanımladığımızda, karakter dizisini soldan sağa doğru
okumaya başlar. Mesela yukarıdaki örnekte ilk olarak karakter dizisini
tanımlamaya tek tırnakla başladığımızı görür.</p>
<p>Python karakter dizisini başlatan bu tek tırnak işaretini gördüğü zaman, soldan
sağa doğru ilerleyerek karakter dizisini bitirecek olan tek tırnak işaretini
aramaya başlar.</p>
<p>Soldan sağa doğru ilerlerken ‘İstanbul’un’ kelimesi içinde geçen kesme işaretini
görür ve karakter dizisinin burada sona erdiğini düşünür. Ancak karakter
dizisini sona erdiren işaret bu olmadığı için Python’ın hata vermekten başka
çaresi kalmaz.</p>
<p>İşte biz ‘İstanbul’un’ kelimesi içinde geçen bu kesme işaretinin sol tarafına
bir adet <cite>\</cite> işareti yerleştirerek Python’a, ‘Aradığın işaret bu değil. Sen
karakter dizisini okumaya devam et. Biraz sonra aradığın tırnağı bulacaksın!’
mesajı vermiş, yani orada tırnak işaretini farklı bir amaçla kullandığımız
konusunda Python’ı bilgilendirmiş oluruz.</p>
<p>Şurada da aynı durum sözkonusu:</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="s2">"Python programlama dilinin adı </span><span class="se">\"</span><span class="s2">piton</span><span class="se">\"</span><span class="s2"> yılanından gelmez"</span><span class="p">)</span>
</pre></div>
</div>
<p>Tıpkı bir önceki örnekte olduğu gibi, burada da Python karakter dizisini soldan
sağa doğru okumaya başlıyor, karakter dizisini başlatan çift tırnak işaretini
görüyor ve bunun üzerine Python karakter dizisini bitirecek olan çift tırnak
işaretini aramaya koyuluyor.</p>
<p>Karakter dizisini soldan sağa doğru okuduğu sırada, karakter dizisi içinde geçen
‘piton’ kelimesini görüyor. Eğer burada bir önlem almazsak Python bu kelimenin
başındaki çift tırnak işaretini, karakter dizisini sona erdiren tırnak olarak
algılar ve durum aslında böyle olmadığı için de hata verir.</p>
<p>Bu hatayı önlemek için ‘piton’ kelimesinin başındaki çift tırnağın soluna bir
adet <cite>\</cite> işareti yerleştirerek Python’a, ‘Aradığın tırnak bu değil!’ mesajı
veriyoruz. Yani bir bakıma, <cite>\</cite> adlı kaçış dizisi kendisini tırnak işaretine
siper edip Python’ın bu tırnağı görmesine mani oluyor…</p>
<p>Bunun üzerine Python bu çift tırnak işaretini görmezden gelerek, soldan sağa
doğru okumaya devam eder ve yol üzerinde ‘piton’ kelimesinin sonundaki çift
tırnak işaretini görür. Eğer burada da bir önlem almazsak Python yine bir hata
verecektir.</p>
<p>Tıpkı biraz önce yaptığımız gibi, bu tırnak işaretinin de soluna bir adet <cite>\</cite>
işareti yerleştirerek Python’a, ‘Aradığın tırnak bu da değil. Sen yine okumaya
devam et!’ mesajı veriyoruz.</p>
<p>Bu mesajı alan Python karakter dizisini soldan sağa doğru okumaya devam ediyor
ve sonunda karakter dizisini bitiren çift tırnak işaretini bularak bize hatasız
bir çıktı veriyor.</p>
<p>Böylece <cite>\</cite> işareti üzerinden hem kaçış dizilerinin ne olduğunu öğrenmiş, hem
de bu kaçış dizisinin nasıl kullanılacağına dair örnekler vermiş olduk. Ancak
<cite>\</cite> kaçış dizisinin yetenekleri yukarıdakilerle sınırlı değildir. Bu kaçış
dizisini, uzun karakter dizilerini bölmek için de kullanabiliriz. Şimdi şu
örneği dikkatlice inceleyin:</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="s2">"Python 1990 yılında Guido Van Rossum </span><span class="se">\</span>
<span class="gp">... </span><span class="s2">tarafından geliştirilmeye başlanmış, oldukça </span><span class="se">\</span>
<span class="gp">... </span><span class="s2">güçlü ve yetenekli bir programlama dilidir."</span><span class="p">)</span>
<span class="go">Python 1990 yılında Guido Van Rossum tarafından geliştirilmeye</span>
<span class="go">başlanmış, oldukça güçlü ve yetenekli bir programlama dilidir.</span>
</pre></div>
</div>
<p>Normal şartlar altında, bir karakter dizisini tanımlamaya tek veya çift tırnakla
başlamışsak, karakter dizisinin kapanış tırnağını koymadan <cite>Enter</cite> tuşuna
bastığımızda 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="nb">print</span><span class="p">(</span><span class="s2">"Python 1990 yılında Guido Van Rossum</span>
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Python 1990 yılında Guido Van Rossum</span>
<span class="o">^</span>
<span class="gr">SyntaxError</span>: <span class="n">EOL while scanning string literal</span>
</pre></div>
</div>
<p>İşte <cite>\</cite> kaçış dizisi bizim burada olası bir hatadan kaçmamızı sağlar. Eğer
<cite>Enter</cite> tuşuna basmadan önce bu işareti kullanırsak Python tıpkı üç tırnak
işaretlerinde şahit olduğumuz gibi, hata vermeden bir alt satıra geçecektir. Bu
sırada, yani <cite>\</cite> kaçış dizisini koyup <cite>Enter</cite> tuşuna bastığımızda <cite>>>></cite>
işaretinin <cite>…</cite> işaretine dönüştüğünü görüyorsunuz. Bu işaretin, Python’ın bize
verdiği bir ‘Yazmaya devam et!’ mesajı olduğunu biliyorsunuz.</p>
</div>
<div class="section" id="satir-basi-n">
<h2>Satır Başı (\n)<a class="headerlink" href="#satir-basi-n" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Python’daki en temel kaçış dizisi biraz önce örneklerini verdiğimiz <cite>\</cite>
işaretidir. Bu kaçış dizisi başka karakterlerle birleşerek, farklı işlevlere
sahip yeni kaçış dizileri de oluşturabilir. Aslında bu olguya yabancı değiliz.
Önceki sayfalarda bu duruma bir örnek vermiştik. Hatırlarsanız <code class="docutils literal notranslate"><span class="pre">print()</span></code>
fonksiyonunu anlatırken <cite>end</cite> parametresinin ön tanımlı değerinin <cite>\n</cite>, yani
satır başı karakteri olduğunu söylemiştik.</p>
<div class="admonition note">
<p class="admonition-title">Not</p>
<p>Satır başı karakterine ‘yeni satır karakteri’ dendiği de olur.</p>
</div>
<p>Satır başı karakterini ilk öğrendiğimizde bu karakteri anlatırken bazı örnekler
de vermiştik:</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="s2">"birinci satır</span><span class="se">\n</span><span class="s2">ikinci satır</span><span class="se">\n</span><span class="s2">üçüncü satır"</span><span class="p">)</span>
<span class="go">birinci satır</span>
<span class="go">ikinci satır</span>
<span class="go">üçüncü satır</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <cite>\n</cite> adlı kaçış dizisi, bir alt satıra geçilmesini sağlıyor.
İşte aslında <cite>\n</cite> kaçış dizisi de, <cite>\</cite> ile ‘n’ harfinin birleşmesinden oluşmuş
bir kaçış dizisidir. Burada <cite>\</cite> işaretinin görevi, ‘n’ harfinin özel bir anlam
kazanmasını sağlamaktır. <cite>\</cite> işareti ile ‘n’ harfi birleştiğinde ‘satır başı
karakteri’ denen özel bir karakter dizisi ortaya çıkarıyor.</p>
<p>Gelin bu kaçış dizisi ile ilgili bir örnek verelim. Şimdi şu kodları dikkatlice
inceleyin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">başlık</span> <span class="o">=</span> <span class="s2">"Türkiye'de Özgür Yazılımın Geçmişi"</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">başlık</span><span class="p">,</span> <span class="s2">"</span><span class="se">\n</span><span class="s2">"</span><span class="p">,</span> <span class="s2">"-"</span><span class="o">*</span><span class="nb">len</span><span class="p">(</span><span class="n">başlık</span><span class="p">),</span> <span class="n">sep</span><span class="o">=</span><span class="s2">""</span><span class="p">)</span>
<span class="go">Türkiye'de Özgür Yazılımın Geçmişi</span>
<span class="go">----------------------------------</span>
</pre></div>
</div>
<p>Burada, <cite>başlık</cite> adlı değişkenin tuttuğu <cite>“Türkiye’de Özgür Yazılımın Geçmişi”</cite>
adlı karakter dizisinin altını çizdik. Dikkat ederseniz, başlığın altına
koyduğumuz çizgiler başlığın uzunluğunu aşmıyor. Yazdığımız program, başlığın
uzunluğu kadar çizgiyi başlığın altına ekliyor. Bu programda başlık ne olursa
olsun, programımız çizgi uzunluğunu kendisi ayarlayacaktır. Örneğin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">başlık</span> <span class="o">=</span> <span class="s2">"Python Programlama Dili"</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">başlık</span><span class="p">,</span> <span class="s2">"</span><span class="se">\n</span><span class="s2">"</span><span class="p">,</span> <span class="s2">"-"</span><span class="o">*</span><span class="nb">len</span><span class="p">(</span><span class="n">başlık</span><span class="p">),</span> <span class="n">sep</span><span class="o">=</span><span class="s2">""</span><span class="p">)</span>
<span class="go">Python Programlama Dili</span>
<span class="go">-----------------------</span>
<span class="gp">>>> </span><span class="n">başlık</span> <span class="o">=</span> <span class="s2">"Alışveriş Listesi"</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">başlık</span><span class="p">,</span> <span class="s2">"</span><span class="se">\n</span><span class="s2">"</span><span class="p">,</span> <span class="s2">"-"</span><span class="o">*</span><span class="nb">len</span><span class="p">(</span><span class="n">başlık</span><span class="p">),</span> <span class="n">sep</span><span class="o">=</span><span class="s2">""</span><span class="p">)</span>
<span class="go">Alışveriş Listesi</span>
<span class="go">-----------------</span>
</pre></div>
</div>
<p>Gelin isterseniz bu kodlardaki <code class="docutils literal notranslate"><span class="pre">print()</span></code> satırını şöyle bir inceleyelim.
Kodumuz şu:</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">başlık</span><span class="p">,</span> <span class="s2">"</span><span class="se">\n</span><span class="s2">"</span><span class="p">,</span> <span class="s2">"-"</span><span class="o">*</span><span class="nb">len</span><span class="p">(</span><span class="n">başlık</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>Burada öncelikle <cite>başlık</cite> adlı değişkeni <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun parantezleri
içine yazdık. Böylece <cite>başlık</cite> değişkeninin değeri ekrana yazdırılacak.</p>
<p><code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun ikinci parametresinin <cite>\n</cite> adlı kaçış dizisi olduğunu
görüyoruz. Bu kaçış dizisini eklememiz sayesinde Python ilk parametreyi çıktı
olarak verdikten sonra bir alt satıra geçiyor. Bu parametrenin tam olarak ne işe
yaradığını anlamak için, yukarıdaki satırı bir de o parametre olmadan
çalıştırmayı 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">başlık</span><span class="p">,</span> <span class="s2">"-"</span><span class="o">*</span><span class="nb">len</span><span class="p">(</span><span class="n">başlık</span><span class="p">),</span> <span class="n">sep</span><span class="o">=</span><span class="s2">""</span><span class="p">)</span>
<span class="go">Alışveriş Listesi-----------------</span>
</pre></div>
</div>
<p><code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun üçüncü parametresinin ise şu olduğunu görüyoruz:
<code class="docutils literal notranslate"><span class="pre">"-"*len(başlık)</span></code>.</p>
<p>İşte <cite>başlık</cite> değişkeninin altına gerekli sayıda çizgiyi çizen kodlar bunlardır.
Burada <code class="docutils literal notranslate"><span class="pre">len()</span></code> fonksiyonunu nasıl kullandığımıza çok dikkat edin. Bu kod
sayesinde <cite>başlık</cite> değişkeninin uzunluğu (<code class="docutils literal notranslate"><span class="pre">len(başlık)</span></code>) sayısınca <cite>-</cite>
işaretini ekrana çıktı olarak verebiliyoruz.</p>
<p>Yukarıdaki kodlarda <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun son parametresi ise <cite>sep=’’</cite>. Peki
bu ne işe yarıyor? Her zaman olduğu gibi, bu kod parçasının ne işe yaradığını
anlamak için programı bir de o kodlar olmadan çalıştırmayı 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">başlık</span><span class="p">,</span> <span class="s2">"</span><span class="se">\n</span><span class="s2">"</span><span class="p">,</span> <span class="s2">"-"</span><span class="o">*</span><span class="nb">len</span><span class="p">(</span><span class="n">başlık</span><span class="p">))</span>
<span class="go">Alışveriş Listesi</span>
<span class="go"> -----------------</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <cite>başlık</cite> değişkeninin tam altına gelmesi gereken çizgi
işaretleri sağa kaymış. Bunun nedeni <cite>sep</cite> parametresinin öntanımlı değerinin
bir adet boşluk karakteri olmasıdır. <cite>sep</cite> parametresinin öntanımlı değeri
nedeniyle çizgilerin baş tarafına bir adet boşluk karakteri ekleniyor çıktıda. O
yüzden bu çizgiler sağa kaymış görünüyor. İşte biz yukarıdaki kodlarda <cite>sep</cite>
parametresinin öntanımlı değerini değiştirip, boşluk karakteri yerine boş bir
karakter dizisi yerleştiriyoruz. Böylece çizgiler çıktıda sağa kaymıyor.</p>
<p>Satır başı karakteri, programlama maceramız sırasında en çok kullanacağımız
kaçış dizilerinden biri ve hatta belki de birincisidir. O yüzden bu kaçış
dizisini çok iyi öğrenmenizi tavsiye ederim.</p>
<p>Ayrıca bu kaçış dizisini (ve tabii öteki kaçış dizilerini) tanıyıp öğrenmeniz,
yazacağınız programların selameti açısından da büyük önem taşır. Eğer bir
karakter dizisi içinde geçen kaçış dizilerini ayırt edemezseniz Python size hiç
beklemediğiniz çıktılar verebilir. Hatta yazdığınız programlar kaçış dizilerini
tanımıyor olmanızdan ötürü bir anda hata verip çökebilir. Peki ama nasıl?</p>
<p>Şimdi şu örneğe dikkatlice bakın:</p>
<p>Diyelim ki bilgisayarınızın ‘C:\’ dizinindeki ‘nisan’ adlı bir klasörün içinde
yer alan <cite>masraflar.txt</cite> adlı bir dosyayı yazdığınız bir program içinde
kullanmanız gerekiyor. Mesela bu dosyayı, tam adresiyle birlikte
kullanıcılarınıza göstermek istiyorsunuz.</p>
<p>İlk denememizi yapalım:</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="s2">"C:</span><span class="se">\n</span><span class="s2">isan\masraflar.txt"</span><span class="p">)</span>
</pre></div>
</div>
<p>Buradan şöyle bir çıktı aldık:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">C</span><span class="p">:</span>
<span class="n">isan</span>\<span class="n">masraflar</span><span class="o">.</span><span class="n">txt</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, bu çıktıyı normal yollardan vermeye çalıştığımızda Python bize
hiç de beklemediğimiz bir çıktı veriyor. Peki ama neden?</p>
<p>Python’da karakter dizileri ile çalışırken asla aklımızdan çıkarmamamız gereken
bir şey var: Eğer yazdığımız herhangi bir karakter dizisinin herhangi bir
yerinde <cite>\</cite> işaretini kullanmışsak, bu işaretten hemen sonra gelen karakterin
ne olduğuna çok dikkat etmemiz gerekir. Çünkü eğer dikkat etmezsek, farkında
olmadan Python için özel anlam taşıyan bir karakter dizisi oluşturmuş
olabiliriz. Bu da kodlarımızın beklediğimiz gibi çalışmasını engeller.</p>
<p>Yukarıdaki sorunun kaynağını anlamak için <code class="docutils literal notranslate"><span class="pre">"C:\nisan\masraflar.txt"</span></code> adlı
karakter dizisine çok dikkatlice bakın. Python bu karakter dizisinde bizim
‘\nisan’ olarak belirttiğimiz kısmın başındaki <cite>\n</cite> karakterlerini bir kaçış
dizisi olarak algıladı. Çünkü <cite>\n</cite> adlı karakter dizisi, ‘satır başı kaçış
dizisi’ adını verdiğimiz, Python açısından özel anlam taşıyan bir karakter
dizisine işaret ediyor. Zaten yukarıdaki tuhaf görünen çıktıya baktığınızda da,
bu kaçış dizisinin olduğu noktadan itibaren karakter dizisinin bölünüp yeni bir
satıra geçildiğini göreceksiniz. İşte biz yukarıdaki örnekte alelade bir dizin
adı belirttiğimizi zannederken aslında hiç farkında olmadan bir kaçış dizisi
üretmiş oluyoruz. Bu nedenle, daha önce de söylediğimiz gibi, karakter dizileri
içinde farkında olarak veya olmayarak kullandığımız kaçış dizilerine karşı her
zaman uyanık olmalıyız. Aksi takdirde, yukarıda olduğu gibi hiç beklemediğimiz
çıktılarla karşılaşabiliriz.</p>
<p>Esasen yukarıdaki problem bir dereceye kadar (ve yerine göre) ‘masum bir kusur’
olarak görülebilir. Çünkü bu hata programımızın çökmesine yol açmıyor. Ama bir
karakter dizisi içindeki gizli kaçış dizilerini gözden kaçırmak, bazı durumlarda
çok daha yıkıcı sonuçlara yol açabilir. Mesela yukarıdaki sorunlu dizin adını
ekrana yazdırmak yerine <code class="docutils literal notranslate"><span class="pre">open()</span></code> fonksiyonunu kullanarak, bu karakter dizisi
içinde belirttiğimiz <cite>masraflar.txt</cite> adlı dosyayı açmaya çalıştığımızı düşünün:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">open</span><span class="p">(</span><span class="s2">"C:</span><span class="se">\n</span><span class="s2">isan\masraflar.txt"</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">OSError</span>: <span class="n">[Errno 22] Invalid argument: 'C:\nisan\\masraflar.txt'</span>
</pre></div>
</div>
<p>Eğer sorunun gözden kaçan bir kaçış dizisinden kaynaklandığını farkedemezseniz,
bu sorunu çözebilmek için saatlerinizi ve hatta günlerinizi harcamak zorunda
kalabilirsiniz. Çünkü yukarıdaki hata mesajı sorunun nedenine dair hiçbir şey
söylemiyor. Ancak ve ancak yukarıdaki karakter dizisi içinde sinsice gizlenen
bir <cite>\n</cite> kaçış dizisi olduğu gözünüze çarparsa bu sorunu çözme yolunda bir adım
atabilirsiniz.</p>
<p>Diyelim ki sorunun ‘\nisan’ ifadesinin başındaki <cite>\n</cite> karakterlerinin Python
tarafından bir kaçış dizisi olarak algılanmasından kaynaklandığını farkettiniz.
Peki bu sorunu nasıl çözeceksiniz?</p>
<p>Bu sorunun birkaç farklı çözüm yolu var. Biz şimdilik sadece ikisini göreceğiz.
Bu bölümün sonuna vardığınızda öteki çözüm yolunu da öğrenmiş olacaksınız.</p>
<p>Yukarıdaki problemi, ilgili kaçış dizisi içindeki ters taksim işaretini
çiftleyerek çözebilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">open</span><span class="p">(</span><span class="s2">"C:</span><span class="se">\\</span><span class="s2">nisan\masraflar"</span><span class="p">)</span>
</pre></div>
</div>
<p>Tabii tutarlılık açısından karakter dizisi içindeki bütün ters taksim
işaretlerini çiftlemek mantıklı olacaktır:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">open</span><span class="p">(</span><span class="s2">"C:</span><span class="se">\\</span><span class="s2">nisan</span><span class="se">\\</span><span class="s2">masraflar"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bunun dışında, bu örnek için, dizin adlarını ters taksim yerine düz taksim
işaretiyle ayırmayı tercih edebilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">open</span><span class="p">(</span><span class="s2">"C:/nisan/masraflar"</span><span class="p">)</span>
</pre></div>
</div>
<p>Dediğimiz gibi, üçüncü (ve aslında daha kullanışlı olan) yöntemi biraz sonra
inceleyeceğiz. Biz şimdilik kaçış dizilerini anlatmaya devam edelim.</p>
</div>
<div class="section" id="sekme-t">
<h2>Sekme (\t)<a class="headerlink" href="#sekme-t" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Python’da <cite>\</cite> işareti sadece ‘n’ harfiyle değil, başka harflerle de
birleşebilir. Örneğin <cite>\</cite> işaretini ‘t’ harfiyle birleştirerek yine özel bir
anlam ifade eden bir kaçış dizisi elde edebiliriz:</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="s2">"abc</span><span class="se">\t</span><span class="s2">def"</span><span class="p">)</span>
<span class="go">abc def</span>
</pre></div>
</div>
<p>Burada <cite>\t</cite> adlı kaçış dizisi, <cite>“abc”</cite> ifadesinden sonra sanki <cite>Tab</cite> (sekme)
tuşuna basılmış gibi bir etki oluşturarak <cite>“def”</cite> ifadesini sağa doğru itiyor.
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="nb">print</span><span class="p">(</span><span class="s2">"bir"</span><span class="p">,</span> <span class="s2">"iki"</span><span class="p">,</span> <span class="s2">"üç"</span><span class="p">,</span> <span class="n">sep</span><span class="o">=</span><span class="s2">"</span><span class="se">\t</span><span class="s2">"</span><span class="p">)</span>
<span class="go">bir iki üç</span>
</pre></div>
</div>
<p>Bir örnek daha:</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="o">*</span><span class="s2">"123456789"</span><span class="p">,</span> <span class="n">sep</span><span class="o">=</span><span class="s2">"</span><span class="se">\t</span><span class="s2">"</span><span class="p">)</span>
<span class="go">1 2 3 4 5 6 7 8 9</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, parametreler arasında belli aralıkta bir boşluk bırakmak
istediğimizde <cite>\t</cite> adlı kaçış dizisinden yararlanabiliyoruz.</p>
<p>Tıpkı <cite>\n</cite> kaçış dizisinde olduğu gibi, karakter dizilerinde <cite>\t</cite> kaçış
dizisinin varlığına karşı da uyanık olmalıyız:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">open</span><span class="p">(</span><span class="s2">"C:</span><span class="se">\n</span><span class="s2">isan\masraflar</span><span class="se">\t</span><span class="s2">oplam_masraf.txt"</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">OSError</span>: <span class="n">[Errno 22] Invalid argument: 'C:\nisan\\masraflar\toplam_masraf.txt'</span>
</pre></div>
</div>
<p>Burada da <cite>\n</cite> ile yaşadığımız soruna benzer bir durum var. Biz
<cite>toplam_masraf.txt</cite> adlı bir dosyaya atıfta bulunmaya çalışıyoruz, ama Python bu
ifadenin başındaki ‘t’ harfinin, kendisinden önce gelen <cite>\</cite> işareti ile
birleşmesinden ötürü, bunu <cite>\t</cite> kaçış dizisi olarak algılıyor ve ona göre
davranıyor.</p>
<p>Belki yukarıdaki kodları şöyle yazarsak durumu anlamak daha kolay olabilir:</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="s2">"C:</span><span class="se">\n</span><span class="s2">isan\masraflar</span><span class="se">\t</span><span class="s2">oplam_masraf.txt"</span><span class="p">)</span>
<span class="go">C:</span>
<span class="go">isan\masraflar oplam_masraf.txt</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, Python <cite>\n</cite> kaçış dizisini gördüğü noktada alt satırın başına
geçiyor ve <cite>\t</cite> kaçış dizisini gördüğü noktada da önceki ve sonraki öğeler
arasında bir sekme boşluğu bırakıyor. Bu durumu engellemek için ne yapmanız
gerektiğini biliyorsunuz: Ya ters taksim işaretlerini çiftleyeceksiniz:</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="s2">"C:</span><span class="se">\\</span><span class="s2">nisan</span><span class="se">\\</span><span class="s2">masraflar</span><span class="se">\\</span><span class="s2">toplam_masraf.txt"</span><span class="p">)</span>
</pre></div>
</div>
<p>Ya da dizin adı ayracı olarak düz taksim işaretini kullanacaksınız:</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="s2">"C:/nisan/masraflar/toplam_masraf.txt"</span><span class="p">)</span>
</pre></div>
</div>
<p>Daha önce de söylediğimiz gibi, üçüncü ve daha pratik olan yolu biraz sonra
göreceğiz. Şimdilik sadece biraz sabır…</p>
</div>
<div class="section" id="zil-sesi-a">
<h2>Zil Sesi (\a)<a class="headerlink" href="#zil-sesi-a" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p><cite>\</cite> işaretinin birleştiğinde farklı bir anlam türettiği bir başka harf de ‘a’
harfidir. <cite>\</cite> işareti ‘a’ harfiyle birleşerek !bip! benzeri bir zil sesi
üretilmesini sağlayabilir:</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="s2">"</span><span class="se">\a</span><span class="s2">"</span><span class="p">)</span>
<span class="go">!bip!</span>
</pre></div>
</div>
<p>İsterseniz yukarıdaki komutu şu şekilde yazarak, kafa şişirme katsayısını
artırabilirsiniz:</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="s2">"</span><span class="se">\a</span><span class="s2">"</span> <span class="o">*</span> <span class="mi">10</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu şekilde !bip! sesi <cite>10</cite> kez tekrar edilecektir. Ancak bu kaçış dizisi
çoğunlukla sadece Windows üzerinde çalışacaktır. Bu kaçış dizisinin GNU/Linux
üzerinde çalışma garantisi yoktur. Hatta bu kaçış dizisi bütün Windows
sistemlerinde dahi çalışmayabilir. Dolayısıyla bu kaçış dizisinin işlevine bel
bağlamak pek mantıklı bir iş değildir.</p>
<p>Tıpkı <cite>\n</cite> ve <cite>\t</cite> kaçış dizilerinde olduğu gibi bu kaçış dizisinin varlığına
karşı da uyanık olmalıyız. Burada da mesela ‘C:\aylar’ gibi bir dizin adı
tanımlamaya çalışırken aslında <cite>\a</cite> kaçış dizisini oluşturuyor olabilirsiniz
farkında olmadan.</p>
</div>
<div class="section" id="ayni-satir-basi-r">
<h2>Aynı Satır Başı (\r)<a class="headerlink" href="#ayni-satir-basi-r" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Bu kaçış dizisi, bir karakter dizisinde aynı satırın en başına dönülmesini
sağlar. Bu kaçış dizisinin işlevini tanımına bakarak anlamak biraz zor olabilir.
O yüzden dilerseniz bu kaçış dizisinin ne işe yaradığını 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="nb">print</span><span class="p">(</span><span class="s2">"Merhaba</span><span class="se">\r</span><span class="s2">Zalim Dünya!"</span><span class="p">)</span>
<span class="go">Zalim Dünya!</span>
</pre></div>
</div>
<p>Burada olan şey şu: Normal şartlar altında, <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu içine
yazdığımız bir karakter dizisindeki bütün karakterler soldan sağa doğru tek tek
ekrana yazdırılır:</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="s2">"Merhaba Zalim Dünya!"</span><span class="p">)</span>
<span class="go">Merhaba Zalim Dünya!</span>
</pre></div>
</div>
<p>Ancak eğer karakter dizisinin herhangi bir yerine <cite>\r</cite> adlı kaçış dizisini
yerleştirirsek, bu kaçış dizisinin bulunduğu konumdan itibaren <strong>aynı</strong> satırın
başına dönülecek ve <cite>\r</cite> kaçış dizisinden sonra gelen bütün karakterler satır
başındaki karakterlerin üzerine yazacaktır. Şu örnek daha açıklayıcı olabilir:</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="s2">"Merhaba</span><span class="se">\r</span><span class="s2">Dünya"</span><span class="p">)</span>
<span class="go">Dünyaba</span>
</pre></div>
</div>
<p>Burada, <cite>“Merhaba”</cite> karakter dizisi ekrana yazdırıldıktan sonra <cite>\r</cite> kaçış
dizisinin etkisiyle satır başına dönülüyor ve bu kaçış dizisinden sonra gelen
<cite>“Dünya”</cite> karakter dizisi <cite>“Merhaba”</cite> karakter dizisinin üzerine yazıyor. Tabii
<cite>“Dünya”</cite> karakter dizisi içinde <cite>5</cite> karakter, <cite>“Merhaba”</cite> karakter dizisi
içinde ise <cite>7</cite> karakter olduğu için, <cite>“Merhaba”</cite> karakter dizisinin son iki
karakteri (<cite>“ba”</cite>) dışarda kalıyor. Böylece ortaya <cite>“Dünyaba”</cite> gibi bir şey
çıkıyor.</p>
<p>Önceki kaçış dizilerinde olduğu gibi, bu kaçış dizisini de farkında olmadan
karakter dizisi içinde kullanırsanız beklemediğiniz çıktılar alırsınız:</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="s2">"C:\ülke</span><span class="se">\t</span><span class="s2">ürkiye\iller</span><span class="se">\r</span><span class="s2">ize</span><span class="se">\n</span><span class="s2">üfus.txt"</span><span class="p">)</span>
<span class="go">izeülke ürkiye\iller</span>
<span class="go">üfus.txt</span>
</pre></div>
</div>
<p>Burada farkında olmadan sadece bir değil, üç kaçış dizisi birden oluşturduk!</p>
</div>
<div class="section" id="dusey-sekme-v">
<h2>Düşey Sekme (\v)<a class="headerlink" href="#dusey-sekme-v" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Eğer <cite>\</cite> işaretini ‘v’ harfiyle birlikte kullanırsak düşey sekme denen şeyi
elde ederiz. Hemen bir örnek verelim:</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="s2">"düşey</span><span class="se">\v</span><span class="s2">sekme"</span><span class="p">)</span>
<span class="go">düşey</span>
<span class="go"> sekme</span>
</pre></div>
</div>
<p>Yalnız bu <cite>\v</cite> adlı kaçış dizisi her işletim sisteminde çalışmayabilir.
Dolayısıyla, birden fazla platform üzerinde çalışmak üzere tasarladığınız
programlarınızda bu kaçış dizisini kullanmanızı önermem.</p>
</div>
<div class="section" id="imlec-kaydirma-b">
<h2>İmleç Kaydırma (\b)<a class="headerlink" href="#imlec-kaydirma-b" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p><cite>\</cite> kaçış dizisinin, biraraya geldiğinde özel bir anlam kazandığı bir başka
harf de b’dir. <cite>\b</cite> kaçış dizisinin görevi, imleci o anki konumundan sola
kaydırmaktır. Bu tanım pek anlaşılır değil. O yüzden bir örnek verelim:</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="s2">"yahoo.com</span><span class="se">\b</span><span class="s2">"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu kodu çalıştırdığınızda herhangi bir değişiklik görmeyeceksiniz. Ama aslında
en sonda gördüğümüz <cite>\b</cite> kaçış dizisi, imleci bir karakter sola kaydırdı.
Dikkatlice bakın:</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="s2">"yahoo.com</span><span class="se">\b</span><span class="s2">.uk"</span><span class="p">)</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <cite>\b</cite> kaçış dizisinin etkisiyle imleç bir karakter sola kaydığı
için, ‘com’ kelimesinin son harfi silindi ve bunun yerine <cite>\b</cite> kaçış dizisinden
sonra gelen <cite>.uk</cite> karakterleri yerleştirildi. Dolayısıyla biz de şu çıktıyı
aldık:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">yahoo</span><span class="o">.</span><span class="n">co</span><span class="o">.</span><span class="n">uk</span>
</pre></div>
</div>
<p>Bir örnek daha verelim…</p>
<p>Bildiğiniz gibi, <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu, kendisine verilen parametreler arasına
birer boşluk yerleştirir:</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="s1">'istihza'</span><span class="p">,</span> <span class="s1">'.'</span><span class="p">,</span> <span class="s1">'com'</span><span class="p">)</span>
<span class="go">istihza . com</span>
</pre></div>
</div>
<p>Biz bu öğeleri birbirine bitiştirmek için şöyle bir yol izleyebileceğimizi
biliyoruz:</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="s1">'istihza'</span><span class="p">,</span> <span class="s1">'.'</span><span class="p">,</span> <span class="s1">'com'</span><span class="p">,</span> <span class="n">sep</span><span class="o">=</span><span class="s1">''</span><span class="p">)</span>
<span class="go">istihza.com</span>
</pre></div>
</div>
<p>İşte aynı etkiyi <cite>\b</cite> kaçış dizisini kullanarak da elde edebiliriz:</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="s1">'istihza'</span><span class="p">,</span> <span class="s1">'</span><span class="se">\b</span><span class="s1">.'</span><span class="p">,</span> <span class="s1">'</span><span class="se">\b</span><span class="s1">com'</span><span class="p">)</span>
<span class="go">istihza.com</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <cite>\b</cite> kaçış dizisi, ‘.’ ve ‘com’ parametrelerinden önce imleci
birer karakter sola kaydırdığı için, parametreler arasındaki boşluk karakterleri
ortadan kalktı.</p>
<p>Bu kaçış dizisini kullanarak şöyle gereksiz işler peşinde de koşabilirsiniz:</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="s1">'istihza</span><span class="se">\b\b\b</span><span class="s1">sn'</span><span class="p">)</span>
<span class="go">istisna</span>
</pre></div>
</div>
<p>Burada <cite>\b</cite> kaçış dizisini üst üste birkaç kez kullanarak imleci birkaç
karakter sola kaydırdık ve ‘sn’ harflerini ‘hz’ harflerinin üzerine bindirdik.
Böylece ‘istihza’ kelimesi ‘istisna’ kelimesine dönüşmüş oldu…</p>
<p>Daha fazla uzatmadan, bu kaçış dizisinin Python’da çok nadir kullanıldığı
bilgisini vererek yolumuza devam edelim…</p>
</div>
<div class="section" id="kucuk-unicode-u">
<h2>Küçük Unicode (\u)<a class="headerlink" href="#kucuk-unicode-u" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Tıpkı bundan önceki kaçış dizileri gibi, karakter dizileri içindeki varlığı
konusunda dikkatli olmamız gereken bir başka kaçış dizisi de <cite>\u</cite> adlı kaçış
dizisidir. Eğer bu kaçış dizisini tanımaz ve dikkatli kullanmazsak, yazdığımız
programlar tespit etmesi çok güç hatalar üretebilir.</p>
<p>Örneğin şöyle bir çıktı vermek istediğinizi düşünün:</p>
<blockquote>
<div><p>Dosya konumu: C:\users\zeynep\gizli\dosya.txt</p>
</div></blockquote>
<p>Bu çıktıyı normal yollardan vermeye çalışırsak Python bize bir hata mesajı
gösterecektir:</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="s2">"Dosya konumu: C:\users\zeynep\gizli\dosya.txt"</span><span class="p">)</span>
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>
<span class="gr">SyntaxError</span>: <span class="n">(unicode error) 'unicodeescape' codec can't decode bytes in</span>
<span class="go">position 16-18: truncated \uXXXX escape</span>
</pre></div>
</div>
<p>Belki sağda solda ‘UNICODE’ diye bir şey duymuşsunuzdur. Eğer şimdiye kadar
böyle bir şey duymadıysanız veya duyduysanız bile ne olduğunu bilmiyorsanız hiç
ziyanı yok. Birkaç bölüm sonra bunun ne anlama geldiğini bütün ayrıntılarıyla
anlatacağız. Biz şimdilik sadece şunu bilelim: UNICODE, karakterlerin,
harflerin, sayıların ve bilgisayar ekranında gördüğümüz öteki bütün işaretlerin
her biri için tek ve benzersiz bir numaranın tanımlandığı bir sistemdir. Bu
sistemde, ‘kod konumu’ (<em>code point</em>) adı verilen bu numaralar özel bir şekilde
gösterilir. Örneğin ‘ı’ harfi UNICODE sisteminde şu şekilde temsil edilir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">u</span><span class="o">+</span><span class="mi">0131</span>
</pre></div>
</div>
<p>Aynı şekilde ‘a’ harfi bu sistemde şu kod konumu ile gösterilir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">u</span><span class="o">+</span><span class="mi">0061</span>
</pre></div>
</div>
<p>Python programlama dilinde ise, yukarıdaki kod konumu düzeni şöyle gösterilir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span>\\<span class="n">u0131</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, Python UNICODE sistemindeki her bir kod konumunu gösterebilmek
için, önce <cite>\u</cite> şeklinde bir kaçış dizisi tanımlıyor, ardından UNICODE
sisteminde <cite>+</cite> işaretinden sonra gelen sayıyı bu kaçış dizisinin hemen
sağına ekliyor. Gelin kendi kendimize birkaç deneme çalışması yapalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s1">'</span><span class="se">\u0130</span><span class="s1">'</span>
<span class="go">'İ'</span>
<span class="gp">>>> </span><span class="s1">'</span><span class="se">\u0070</span><span class="s1">'</span>
<span class="go">'p'</span>
<span class="gp">>>> </span><span class="s2">"\ufdsf"</span>
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>
<span class="gr">SyntaxError</span>: <span class="n">(unicode error) 'unicodeescape' codec can't decode bytes in</span>
<span class="go">position 0-4: truncated \uXXXX escape</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, eğer <cite>\u</cite> kaçış dizisinden sonra doğru bir kod konumu
belirtmezsek Python bize bir hata mesajı gösteriyor…</p>
<p>Bu hata mesajının, biraz önce <code class="docutils literal notranslate"><span class="pre">print("Dosya</span> <span class="pre">konumu:</span>
<span class="pre">C:\users\zeynep\gizli\dosya.txt")</span></code> kodunu yazdıktan sonra aldığımız hata ile
aynı olduğuna dikkat edin. Tıpkı <cite>\ufdsf</cite> örneğinde olduğu gibi, <cite>\users</cite>
ifadesi de varolan bir UNICODE kod konumuna karşılık gelmediği için, Python’ın
hata vermekten başka çaresi kalmıyor.</p>
<p>Biz bu örnekte ‘users’ kelimesini kullanmaya çalışıyoruz, ama ‘u’ harfinden
hemen önce gelen <cite>\</cite> kaçış dizisi nedeniyle, hiç farkında olmadan Python
açısından önemli bir karakter dizisi (<cite>\u</cite>) meydana getirmiş oluyoruz. O
yüzden, böyle can sıkıcı hatalarla karşılaşmamak için olası kaçış dizilerine
karşı her zaman uyanık olmamız gerekiyor.</p>
<p>Peki biz bu kaçış dizisi yüzünden, yazdığımız programlarda <cite>Dosya konumu:
C:\users\zeynep\gizli\dosya.txt”)</cite> gibi bir çıktı veremeyecek miyiz?</p>
<p>Verebileceğimizi ve bunun bir yolu yordamı olduğunu biliyorsunuz:</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="s2">"Dosya konumu: C:</span><span class="se">\\</span><span class="s2">users</span><span class="se">\\</span><span class="s2">zeynep</span><span class="se">\\</span><span class="s2">gizli</span><span class="se">\\</span><span class="s2">dosya.txt"</span><span class="p">)</span>
<span class="go">Dosya konumu: C:\users\zeynep\gizli\dosya.txt</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, karakter dizisi içinde geçen bütün <cite>\</cite> işaretlerini
çiftleyerek sorunumuzu çözdük. Buradaki gibi bir sorunla karşılaşmamak için,
dizin adlarını ayırırken ters taksim işareti yerine düz taksim işaretini
kullanmayı da tercih edebilirsiniz:</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="s2">"Dosya konumu: C:/users/zeynep/gizli/dosya.txt"</span><span class="p">)</span>
</pre></div>
</div>
<p>Biraz sonra bu sorunu halletmenin üçüncü ve daha kolay bir yönteminden daha söz
edeceğiz. Ama biz şimdilik bu kaçış dizisini bir kenara bırakıp başka bir kaçış
dizisini incelemeye geçelim.</p>
</div>
<div class="section" id="buyuk-unicode-u">
<h2>Büyük Unicode (\U)<a class="headerlink" href="#buyuk-unicode-u" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Bu kaçış dizisi biraz önce gördüğümüz <cite>\u</cite> adlı kaçış dizisiyle hemen hemen
aynı anlama gelir. Bu kaçış dizisi de, tıpkı <cite>\u</cite> gibi, UNICODE kod konumlarını
temsil etmek için kullanılır. Ancak <cite>U</cite> ile gösterilen kod konumları <cite>u</cite> ile
gösterilenlere göre biraz daha uzundur. Örneğin, hatırlarsanız <cite>u</cite> kaçış
dizisini kullanarak ‘ı’ harfinin UNICODE kod konumunu şöyle temsil ediyorduk:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s1">'</span><span class="se">\u0131</span><span class="s1">'</span>
<span class="go">'ı'</span>
</pre></div>
</div>
<p>Eğer aynı kod konumunu <cite>U</cite> adlı kaçış dizisi ile göstermek istersek şöyle bir
şey yazmamız gerekir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s1">'</span><span class="se">\U00000131</span><span class="s1">'</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, burada <cite>\U</cite> kaçış dizisinden sonra gelen kısım toplam 8
haneli bir sayıdan oluşuyor. <cite>u</cite> kaçış dizisinde ise bu kısmı toplam 4 haneli
bir sayı olarak yazıyorduk. İşte <cite>\u</cite> kaçış dizisi ile <cite>U</cite> kaçış dizisi
arasındaki fark budur. <cite>u</cite> kaçış dizisi hakkında söylediğimiz öteki her şey
<cite>U</cite> kaçış dizisi için de geçerlidir.</p>
</div>
<div class="section" id="uzun-ad-n">
<h2>Uzun Ad (\N)<a class="headerlink" href="#uzun-ad-n" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>UNICODE sistemi ile ilgili bir başka kaçış dizisi de <cite>\N</cite> adlı kaçış dizisidir.</p>
<p>Dediğimiz gibi, UNICODE sistemine ilişkin ayrıntılardan ilerleyen derslerde söz
edeceğiz, ama bu sistemle ilgili ufak bir bilgi daha verelim.</p>
<p>UNICODE sisteminde her karakterin tek ve benzersiz bir kod konumu olduğu gibi,
tek ve benzersiz bir de uzun adı vardır. Örneğin ‘a’ harfinin UNICODE
sistemindeki uzun adı şudur:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">LATIN</span> <span class="n">SMALL</span> <span class="n">LETTER</span> <span class="n">A</span>
</pre></div>
</div>
<p>Bir karakterin UNICODE sistemindeki uzun adını öğrenmek için <cite>unicodedata</cite> adlı
bir modülden yararlanabilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">import</span> <span class="nn">unicodedata</span>
<span class="gp">>>> </span><span class="n">unicodedata</span><span class="o">.</span><span class="n">name</span><span class="p">(</span><span class="s1">'a'</span><span class="p">)</span>
<span class="go">LATIN SMALL LETTER A</span>
<span class="gp">>>> </span><span class="n">unicodedata</span><span class="o">.</span><span class="n">name</span><span class="p">(</span><span class="s1">'Ş'</span><span class="p">)</span>
<span class="go">LATIN CAPITAL LETTER S WITH CEDILLA</span>
</pre></div>
</div>
<p>Bu arada, daha önce de söylediğimiz gibi, bu ‘modül’ kavramına şimdilik
takılmayın. İlerde modülleri ayrıntılı olarak inceleyeceğiz. Şimdilik
<cite>unicodedata</cite> denen şeyin, (tıpkı daha önce örneklerini gördüğümüz <cite>os</cite>, <cite>sys</cite>
ve <cite>keyword</cite> gibi) bir modül olduğunu ve bu modül içindeki <cite>name</cite> adlı bir
fonksiyonu kullanarak, parantez içinde belirttiğimiz herhangi bir karakterin
UNICODE sistemindeki uzun adını elde edebileceğimizi bilelim yeter.</p>
<p>İşte <cite>\N</cite> kaçış dizisi bu uzun isimleri, Python programlarımızda kullanma
imkanı verir bize. Bu kaçış dizisini, karakterlerin UNICODE sistemindeki uzun
adları ile birlikte kullanarak asıl karakterleri elde edebiliriz. Dikkatlice
bakın:</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="s2">"</span><span class="se">\N{LATIN SMALL LETTER A}</span><span class="s2">"</span><span class="p">)</span>
<span class="go">a</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="se">\N{LATIN CAPITAL LETTER S WITH CEDILLA}</span><span class="s2">"</span><span class="p">)</span>
<span class="go">Ş</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="s2">"\Nisan"</span><span class="p">)</span>
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>
<span class="gr">SyntaxError</span>: <span class="n">(unicode error) 'unicodeescape' codec can't decode bytes in</span>
<span class="go">position 0-1: malformed \N character escape</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, herhangi bir karşılığı olmayan bir uzun ad belirttiğimizde
Python bize bir hata mesajı gösteriyor. Çünkü Python <cite>\N</cite> kaçış dizisinin hemen
ardından <cite>{</cite> işaretinin getirilmesini ve sonra da UNICODE sistemi dahilinde
geçerli bir uzun ad belirtilmesini bekliyor. Yukarıdaki örnekte <cite>\N</cite> kaçış
dizisinden sonra <cite>{</cite> işareti yok. Zaten <cite>\N</cite> kaçış dizisinin hemen ardından
gelen ‘isan’ ifadesi de doğru bir uzun ada işaret etmiyor. Dolayısıyla da
Python’ın bize hata mesajı göstermekten başka çaresi kalmıyor…</p>
<p><cite>\u</cite>, <cite>\U</cite> ve <cite>\N</cite> kaçış dizileri, UNICODE sistemi ile ilgili çalışmalar
yapmak isteyen programcılar için Python programlama dilinin sunduğu faydalı
araçlardan yalnızca birkaçıdır. Ancak bu araçların sizin işinize yaramayacağını
asla düşünmeyin. Zira <cite>\u</cite>, <cite>\U</cite> ve <cite>\N</cite> kaçış dizileri ile ilgili yukarıdaki
durum hiç beklemediğiniz bir anda sizi de vurabilir. Çünkü bu kaçış dizilerinin
oluşturduğu risk hiç de öyle nadir karşılaşılacak bir sorun değildir.</p>
<p>Bildiğiniz gibi Windows 7’de kullanıcının dosyalarını içeren dizin adı
<cite>C:\Users\kullanıcı_adı</cite> şeklinde gösteriliyor. Dolayısıyla Windows
kullananlar UNICODE kaçış dizilerinden kaynaklanan bu tuzağa her an düşebilir.
Ya da eğer adınız ‘u’ veya ‘n’ harfi ile başlıyorsa yine bu tuzağa düşme
ihtimaliniz epey yüksek olacak, <cite>C:\Users\umut</cite> veya <cite>C:\Users\Nihat</cite> gibi
bir dizin adı belirtirken çok dikkatli olmanız gerekecektir. Zira özellikle
dosyalar üzerinde işlem yaparken, bu tür dizin adlarını sık sık kullanmak
durumunda kalacaksınız. Bu yüzden, alelade bir kelime yazdığınızı zannederken
hiç farkında olmadan bir kaçış dizisi tanımlıyor olma ihtimalini her zaman göz
önünde bulundurmalı ve buna uygun önlemleri almış olmalısınız.</p>
</div>
<div class="section" id="onaltili-karakter-x">
<h2>Onaltılı Karakter (\x)<a class="headerlink" href="#onaltili-karakter-x" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>‘x’ harfi de <cite>\</cite> işareti ile birleştiğinde özel anlam kazanarak bir kaçış
dizisi meydana getirir.</p>
<p><cite>\x</cite> kaçış dizisini kullanarak, onaltılı
(<em>hexadecimal</em>) sayma sistemindeki bir sayının karakter karşılığını
gösterebilirsiniz. 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="se">\x41</span><span class="s2">"</span>
<span class="go">'A'</span>
</pre></div>
</div>
<p>Onaltılı sayma sistemindeki <cite>41</cite> sayısı ‘A’ harfine karşılık gelir. Eğer hangi
karakterlerin hangi sayılara karşılık geldiğini merak ediyorsanız
<a class="reference external" href="http://www.ascii.cl/">http://www.ascii.cl/</a> adresindeki tabloyu inceleyebilirsiniz. Bu tabloda ‘hex’
sütunu altında gösterilen sayılar onaltılı sayılar olup, ‘symbol’ sütununda
gösterilen karakterlere karşılık gelirler. Örneğin ‘hex’ sütunundaki <cite>4E</cite> sayısı
‘symbol’ sütunundaki ‘N’ harfine karşılık gelir. Bu durumu Python’la da teyit
edebilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="go">>>>"\x4E"</span>
<span class="go">N</span>
</pre></div>
</div>
<p>Eğer sayılarla karakterler arasındaki bağlantının tam olarak ne olduğunu
bilmiyorsanız hiç endişe etmeyin. Birkaç bölüm sonra sayılarla karakterler
arasında nasıl bir bağ olduğunu gayet ayrıntılı bir şekilde anlatacağız. Biz
şimdilik yalnızca <cite>\x</cite> karakter dizisinin özel bir kaçış dizisine karşılık
geldiğini ve bu kaçış dizisini karakter dizileri içinde kullanırken dikkatli
olmamız gerektiğini bilelim yeter:</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="s2">"C:\Users\Ayşe\xp_dosyaları"</span><span class="p">)</span>
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>
<span class="gr">SyntaxError</span>: <span class="n">(unicode error) 'unicodeescape' codec can't decode bytes in</span>
<span class="go">position 2-4: truncated \UXXXXXXXX escape</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, Python <cite>\x</cite> ifadesinden sonra onaltılı bir sayı belirtmenizi
bekliyor. Halbuki biz burada <cite>\x</cite> ifadesini ‘xp_dosyaları’ adlı dizini
gösterebilmek için kullanmıştık. Ama görünüşe göre yanlışlıkla Python için özel
bir anlam ifade eden bir karakter dizisi oluşturmuşuz…</p>
</div>
<div class="section" id="etkisizlestirme-r">
<h2>Etkisizleştirme (r)<a class="headerlink" href="#etkisizlestirme-r" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Dediğimiz gibi, Python’daki en temel kaçış dizisi <cite>\</cite> işaretidir. Bu işaret
bazı başka harflerle birleşerek yeni kaçış dizileri de oluşturabilir.</p>
<p>Python’da <cite>\</cite> işaretinin dışında temel bir kaçış dizisi daha bulunur. Bu kaçış
dizisi ‘r’ harfidir. Şimdi bu kaçış dizisinin nasıl kullanılacağını ve ne işe
yaradığını inceleyelim:</p>
<p>Şöyle bir çıktı vermek istediğimizi düşünün:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">Kurulum</span> <span class="n">dizini</span><span class="p">:</span> <span class="n">C</span><span class="p">:</span>\<span class="n">aylar</span>\<span class="n">nisan</span>\<span class="n">toplam</span> <span class="n">masraf</span>
</pre></div>
</div>
<p>Bildiğimiz yoldan bu çıktıyı vermeye çalışırsak neler olacağını adınız gibi
biliyorsunuz:</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="s2">"Kurulum dizini: C:</span><span class="se">\a</span><span class="s2">ylar</span><span class="se">\n</span><span class="s2">isan</span><span class="se">\t</span><span class="s2">oplam masraf"</span><span class="p">)</span>
<span class="go">Kurulum dizini: C:ylar</span>
<span class="go">isan oplam masraf</span>
</pre></div>
</div>
<div class="admonition note">
<p class="admonition-title">Not</p>
<p>Eğer Windows üzerinde çalışıyorsanız bu komutu verdikten sonra bir
!bip! sesi de duymuş olabilirsiniz…</p>
</div>
<p>Python tabii ki, karakter dizisi içinde geçen ‘<strong>\a</strong>ylar’, ‘<strong>\n</strong>isan’, ve
‘<strong>\t</strong>oplam masraf’ ifadelerinin ilk karakterlerini yanlış anladı!
<cite>\a</cite>, <cite>\n</cite> ve <cite>\t</cite> gibi ifadeler Python’ın gözünde birer kaçış dizisi. Dolayısıyla Python
<cite>\a</cite> karakterlerini görünce bir !bip! sesi çıkarıyor, <cite>\n</cite> karakterlerini
görünce satır başına geçiyor ve <cite>\t</cite> karakterlerini görünce de <cite>Tab</cite> tuşuna
basılmış gibi bir tepki veriyor. Sonuç olarak da yukarıdaki gibi bir çıktı
üretiyor.</p>
<p>Daha önce bu durumu şöyle bir kod yazarak engellemiştik:</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="s2">"Kurulum dizini: C:</span><span class="se">\\</span><span class="s2">aylar</span><span class="se">\\</span><span class="s2">nisan</span><span class="se">\\</span><span class="s2">toplam masraf"</span><span class="p">)</span>
<span class="go">Kurulum dizini: C:\aylar\nisan\toplam masraf</span>
</pre></div>
</div>
<p>Burada, <cite>\</cite> işaretlerinin her birini çiftleyerek sorunun üstesinden geldik.
Yukarıdaki yöntem doğru ve kabul görmüş bir çözümdür. Ama bu sorunun üstesinden
gelmenin çok daha basit ve pratik bir yolu var. Bakalım:</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="sa">r</span><span class="s2">"Kurulum dizini: C:\aylar\nisan\toplam masraf"</span><span class="p">)</span>
<span class="go">Kurulum dizini: C:\aylar\nisan\toplam masraf</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, karakter dizisinin baş kısmının dış tarafına bir adet <cite>r</cite> harfi
yerleştirerek sorunun üstesinden geliyoruz. Bu kaçış dizisinin, kullanım
açısından öteki kaçış dizilerinden farklı olduğuna dikkat edin. Öteki kaçış
dizileri karakter dizisinin içinde yer alırken, bu kaçış dizisi karakter
dizisinin dışına yerleştiriliyor.</p>
<p>Bu kaçış dizisinin tam olarak nasıl işlediğini görmek için dilerseniz bir örnek
daha verelim:</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="s2">"Kaçış dizileri: \, </span><span class="se">\n</span><span class="s2">, </span><span class="se">\t</span><span class="s2">, </span><span class="se">\a</span><span class="s2">, </span><span class="se">\\</span><span class="s2">, r"</span><span class="p">)</span>
<span class="go">Kaçış dizileri: \,</span>
<span class="go">, , , \, r</span>
</pre></div>
</div>
<p>Burada da Python bizim yapmak istediğimiz şeyi anlayamadı ve karakter dizisi
içinde geçen kaçış dizilerini doğrudan ekrana yazdırmak yerine bu kaçış
dizilerinin işlevlerini yerine getirmesine izin verdi. Tıpkı biraz önceki
örnekte olduğu gibi, istersek kaçış dizilerini çiftleyerek bu sorunu
aşabiliriz:</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="s2">"Kaçış dizileri: </span><span class="se">\\</span><span class="s2">, </span><span class="se">\\</span><span class="s2">n, </span><span class="se">\\</span><span class="s2">t, </span><span class="se">\\</span><span class="s2">a, </span><span class="se">\\</span><span class="s2">\, r"</span><span class="p">)</span>
<span class="go">Kaçış dizileri: \, \n, \t, \a, \\, r</span>
</pre></div>
</div>
<p>Ama tabii ki bunun çok daha kolay bir yöntemi olduğunu biliyorsunuz:</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="sa">r</span><span class="s2">"Kaçış dizileri: \, \n, \t, \a, </span><span class="se">\\</span><span class="s2">, r"</span><span class="p">)</span>
<span class="go">Kaçış dizileri: \, \n, \t, \a, \\, r</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, karakter dizisinin başına getirdiğimiz <cite>r</cite> kaçış dizisi,
karakter dizisi içinde geçen kaçış dizilerinin işlevlerini yerine getirmesine
engel olarak, istediğimiz çıktıyı elde etmemizi sağlıyor.</p>
<p>Bu arada bu kaçış dizisini, daha önce öğrendiğimiz <cite>\r</cite> adlı kaçış dizisi ile
karıştırmamaya dikkat ediyoruz.</p>
<p>Python’daki bütün kaçış dizilerinden söz ettiğimize göre, konuyu kapatmadan önce
önemli bir ayrıntıdan söz edelim.</p>
<p>Python’da karakter dizilerinin sonunda sadece çift sayıda <cite>\</cite> işareti
bulunabilir. Tek sayıda <cite>\</cite> işareti kullanıldığında karakter dizisini bitiren
tırnak işareti etkisizleşeceği için çakışma sorunu ortaya çıkar. Bu
etkisizleşmeyi, karakter dizisinin başına koyduğunuz ‘r’ kaçış dizisi de
engelleyemez. Yani:</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="s2">"Kaçış dizisi: </span><span class="se">\"</span><span class="s2">)</span>
</pre></div>
</div>
<p>Bu şekilde bir tanımlama yaptığımızda Python bize bir hata mesajı gösterir.
Çünkü kapanış tırnağının hemen öncesine yerleştirdiğimiz <cite>\</cite> kaçış dizisi,
Python’ın karakter dizisini kapatan tırnak işaretini görmezden gelmesine yol
açarak bu tırnağı etkisizleştiriyor. Böylece sanki karakter dizisini tanımlarken
kapanış tırnağını hiç yazmamışız gibi bir sonuç ortaya çıkıyor:</p>