forked from yazbel/python-istihza
-
Notifications
You must be signed in to change notification settings - Fork 0
/
print.html
1468 lines (1376 loc) · 125 KB
/
print.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 en önemli fonksiyonlardan biri olan print() fonksiyonundan söz edeceğiz." name="description" />
<meta content="print, fonksiyon, sep, end, file, flush, yıldızlı parametreler, parametre" name="keywords" />
<title>print() Fonksiyonu — 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="Kaçış Dizileri" href="kacis_dizileri.html" />
<link rel="prev" title="Etkileşimli Python" href="etkilesimli_python.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="kacis_dizileri.html" title="Kaçış Dizileri"
accesskey="N">sonraki</a></li>
<li class="right" >
<a href="etkilesimli_python.html" title="Etkileşimli Python"
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="">print() Fonksiyonu</a></li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="body" role="main">
<div class="section" id="print-fonksiyonu">
<h1>print() Fonksiyonu<a class="headerlink" href="#print-fonksiyonu" title="Bu başlık için kalıcı bağlantı">¶</a></h1>
<p>Geçen bölümde bir yandan Python’ın etkileşimli kabuğunu yakından tanıyıp bu
vesileyle bazı önemli fonksiyon ve araçları öğrenirken, öbür yandan bu
öğrendiklerimizi kullanarak örnek programlar yazdık. Gördüğünüz gibi, azıcık bir
bilgiyle dahi az çok işe yarar programlar yazmak mümkün olabiliyor. Daha yararlı
programlar yazabilmek için henüz öğrenmemiz gereken pek çok şey var. İşte bu
bölümde, ‘daha yararlı programlar yazmamızı’ sağlayacak çok önemli bir araçtan
söz edeceğiz. Öneminden dolayı ayrıntılı bir şekilde anlatacağımız bu aracın adı
<code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu.</p>
<p>Elbette bu bölümde sadece <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonundan bahsetmeyeceğiz. Bu bölümde
<code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun yanısıra Python’daki bazı önemli temel konuları da ele
alacağız. Mesela bu bölümde Python’daki karakter dizilerine ve sayılara ilişkin
çok önemli bilgiler vereceğiz. Ayrıca <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu vesilesiyle
Python’daki ‘fonksiyon’ konusuna da sağlam bir giriş yapmış, bu kavram ile
ilgili ilk bilgilerimizi almış olacağız. Sözün özü, bu bölüm bizim için, deyim
yerindeyse, tam anlamıyla bir dönüm noktası olacak.</p>
<p>O halde isterseniz lafı daha fazla uzatmadan işe <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun ne
olduğu ve ne işe yaradığını anlatarak başlayalım.</p>
<div class="section" id="nedir-ne-ise-yarar">
<h2>Nedir, Ne İşe Yarar?<a class="headerlink" href="#nedir-ne-ise-yarar" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Şimdiye kadar etkileşimli kabukta gerek karakter dizilerini gerekse sayıları
doğrudan ekrana yazdık. Yani şöyle bir şey yaptık:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"Python programlama dili"</span>
<span class="go">'Python programlama dili'</span>
<span class="gp">>>> </span><span class="mi">6567</span>
<span class="go">6567</span>
</pre></div>
</div>
<p>Etkileşimli kabuk da, ekrana yazdığımız bu karakter dizisi ve sayıyı doğrudan
bize çıktı olarak verdi. Ancak ilerde Python kodlarımızı bir dosyaya kaydedip
çalıştırdığımızda da göreceğiniz gibi, Python’ın ekrana çıktı verebilmesi için
yukarıdaki kullanım yeterli değildir. Yani yukarıdaki kullanım yalnızca
etkileşimli kabukta çalışır. Bu kodları bir dosyaya kaydedip çalıştırmak
istediğimizde hiçbir çıktı alamayız. Python’da yazdığımız şeylerin ekrana çıktı
olarak verilebilmesi için <code class="docutils literal notranslate"><span class="pre">print()</span></code> adlı özel bir fonksiyondan yararlanmamız
gerekir.</p>
<p>O halde gelin bu <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun ne işe yaradığını ve nasıl
kullanıldığını anlamaya çalışalım:</p>
<p><code class="docutils literal notranslate"><span class="pre">print()</span></code> de tıpkı daha önce gördüğümüz <code class="docutils literal notranslate"><span class="pre">type()</span></code>, <code class="docutils literal notranslate"><span class="pre">len()</span></code> ve <code class="docutils literal notranslate"><span class="pre">pow()</span></code>
gibi bir fonksiyondur. Fonksiyonları ilerde daha ayrıntılı bir şekilde
inceleyeceğimizi söylemiştik hatırlarsanız. O yüzden fonksiyon kelimesine
takılarak, burada anlattığımız şeylerin kafanızı karıştırmasına, moralinizi
bozmasına izin vermeyin.</p>
<p><code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun görevi ekrana çıktı vermemizi sağlamaktır. Hemen
bununla ilgili 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">"Python programlama dili"</span><span class="p">)</span>
<span class="go">Python programlama dili</span>
</pre></div>
</div>
<p>Bildiğiniz gibi burada gördüğümüz <cite>“Python programlama dili”</cite> bir karakter
dizisidir. İşte <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun görevi bu karakter dizisini ekrana
çıktı olarak vermektir. Peki bu karakter dizisini <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu olmadan
yazdığımızda da ekrana çıktı vermiş olmuyor muyuz? Aslında olmuyoruz. Dediğimiz
gibi, ilerde programlarımızı dosyalara kaydedip çalıştırdığımızda, başında
<code class="docutils literal notranslate"><span class="pre">print()</span></code> olmayan ifadelerin çıktıda görünmediğine şahit olacaksınız.</p>
<p>Daha önce de dediğimiz gibi, etkileşimli kabuk bir test ortamı olması açısından
rahat bir ortamdır. Bu sebeple bu ortamda ekrana çıktı verebilmek için
<code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunu kullanmak zorunda değilsiniz. Yani başında <code class="docutils literal notranslate"><span class="pre">print()</span></code>
olsa da olmasa da etkileşimli kabuk ekrana yazdırmak istediğiniz şeyi yazdırır.
Ama iyi bir alışkanlık olması açısından, ekrana herhangi bir şey
yazdıracağınızda ben size <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunu kullanmanızı tavsiye ederim.</p>
<p><code class="docutils literal notranslate"><span class="pre">print()</span></code> son derece güçlü bir fonksiyondur. Gelin isterseniz bu güçlü ve
faydalı fonksiyonu derin derin incelemeye koyulalım.</p>
</div>
<div class="section" id="nasil-kullanilir">
<h2>Nasıl Kullanılır?<a class="headerlink" href="#nasil-kullanilir" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Yukarıda verdiğimiz örnekte ilk gözümüze çarpan şey, karakter dizisini
<code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun parantezleri içine yazmış olmamızdır. Biz bir
fonksiyonun parantezleri içinde belirtilen öğelere ‘parametre’ dendiğini geçen
bölümde öğrenmiştik. Tıpkı öğrendiğimiz öteki fonksiyonlar gibi, <code class="docutils literal notranslate"><span class="pre">print()</span></code>
fonksiyonu da birtakım parametreler alır.</p>
<p>Bu arada <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun parantezini açıp parametreyi yazdıktan sonra,
parantezi kapatmayı unutmuyoruz. Python programlama diline yeni başlayanların,
hatta bazen deneyimli programcıların bile en sık yaptığı hatalardan biri
açtıkları parantezi kapatmayı unutmalarıdır.</p>
<p>Elbette, eğer istersek burada doğrudan <cite>“Python programlama dili”</cite> adlı karakter
dizisini kullanmak yerine, önce bu karakter dizisini bir değişkene atayıp, sonra
da <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun parantezleri içinde bu değişkeni kullanabiliriz.
Yani:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">dil</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">dil</span><span class="p">)</span>
<span class="go">Python programlama dili</span>
</pre></div>
</div>
<p>Bu arada, hem şimdi verdiğimiz, hem de daha önce yazdığımız örneklerde bir şey
dikkatinizi çekmiş olmalı. Şimdiye kadar verdiğimiz örneklerde karakter
dizilerini hep çift tırnakla gösterdik. Ama aslında tek seçeneğimiz çift tırnak
değildir. Python bize üç farklı tırnak seçeneği sunar:</p>
<ol class="arabic simple">
<li><p>Tek tırnak (‘ ‘)</p></li>
<li><p>Çift tırnak (” “)</p></li>
<li><p>Üç tırnak (“”” “””)</p></li>
</ol>
<p>Dolayısıyla yukarıdaki örneği üç farklı şekilde yazabiliriz:</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">'Python programlama dili'</span><span class="p">)</span>
<span class="go">Python programlama dili</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="s2">"Python programlama dili"</span><span class="p">)</span>
<span class="go">Python programlama dili</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="s2">"""Python programlama dili"""</span><span class="p">)</span>
<span class="go">Python programlama dili</span>
</pre></div>
</div>
<p>Gördüğünüz gibi çıktılar arasında hiçbir fark yok.</p>
<p>Peki çıktılarda hiçbir fark yoksa neden üç farklı tırnak çeşidi var?</p>
<p>İsterseniz bu soruyu bir örnek üzerinden açıklamaya çalışalım. Diyelim ki ekrana
şöyle bir çıktı vermek istiyoruz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">Python</span> <span class="n">programlama</span> <span class="n">dilinin</span> <span class="n">adı</span> <span class="s2">"piton"</span> <span class="n">yılanından</span> <span class="n">gelmez</span>
</pre></div>
</div>
<p>Eğer bu cümleyi çift tırnaklar içinde gösterirsek programımız hata verecektir:</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="n">piton</span><span class="s2">" yılanından gelmez"</span><span class="p">)</span>
<span class="go">File "<stdin>", line 1</span>
<span class="go"> print("Python programlama dilinin adı "piton" yılanından gelmez")</span>
<span class="go"> ^</span>
<span class="go">SyntaxError: invalid syntax</span>
</pre></div>
</div>
<p>Bunun sebebi, cümle içinde geçen ‘piton’ kelimesinin de çift tırnaklar içinde
gösterilmiş olmasıdır. Cümlenin, yani karakter dizisinin kendisi de çift tırnak
içinde gösterildiği için Python, karakter dizisini başlatan ve bitiren
tırnakların hangisi olduğunu ayırt edemiyor. Yukarıdaki cümleyi en kolay şu
şekilde ekrana yazdırabiliriz:</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">'Python programlama dilinin adı "piton" yılanından gelmez'</span><span class="p">)</span>
<span class="go">Python programlama dilinin adı "piton" yılanından gelmez</span>
</pre></div>
</div>
<p>Burada karakter dizisini tek tırnak içine aldık. Karakter dizisi içinde geçen
‘piton’ kelimesi çift tırnak içinde olduğu için, karakter dizisini başlatıp
bitiren tırnaklarla ‘piton’ kelimesindeki tırnakların birbirine karışması gibi
bir durum söz konusu değildir.</p>
<p>Bir de şöyle bir örnek verelim: Diyelim ki aşağıdaki gibi bir çıktı elde etmek
istiyoruz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">İstanbul</span><span class="s1">'un 5 günlük hava durumu tahmini</span>
</pre></div>
</div>
<p>Eğer bu karakter dizisini tek tırnak işaretleri içinde belirtirseniz 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="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="go">File "<stdin>", line 1</span>
<span class="go"> print('İstanbul'un 5 günlük hava durumu tahmini')</span>
<span class="go"> ^</span>
<span class="go">SyntaxError: invalid syntax</span>
</pre></div>
</div>
<p>Bu hatanın sebebi ‘İstanbul’un’ kelimesi içinde geçen kesme işaretidir. Tıpkı
bir önceki örnekte olduğu gibi, Python karakter dizisini başlatan ve bitiren
tırnakların hangisi olduğunu kestiremiyor. Python, karakter dizisinin en
başındaki tek tırnak işaretinin ardından ‘İstanbul’un’ kelimesi içindeki kesme
işaretini görünce karakter dizisinin burada sona erdiğini zannediyor. Ancak
karakter dizisini soldan sağa doğru okumaya devam edince bir yerlerde bir
terslik olduğunu düşünüyor ve bize bir hata mesajı göstermekten başka çaresi
kalmıyor. Yukarıdaki karakter dizisini en kolay şöyle tanımlayabiliriz:</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>Burada da, karakter dizisi içinde geçen kesme işaretine takılmamak için karakter
dizimizi çift tırnak işaretleri içine alıyoruz.</p>
<p>Yukarıdaki karakter dizilerini düzgün bir şekilde çıktı verebilmek için üç
tırnak işaretlerinden de yararlanabiliriz:</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ı "piton" yılanından gelmez"""</span><span class="p">)</span>
<span class="go">Python programlama dilinin adı "piton" yılanından gelmez</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>Bütün bu örneklerden sonra kafanızda şöyle bir düşünce uyanmış olabilir:</p>
<blockquote>
<div><p>Görünüşe göre üç tırnak işaretiyle her türlü karakter dizisini hatasız bir
şekilde ekrana çıktı olarak verebiliyoruz. O zaman ben en iyisi bütün
karakter dizileri için üç tırnak işaretini kullanayım!</p>
</div></blockquote>
<p>Elbette, eğer isterseniz <strong>pek çok karakter dizisi için</strong> üç tırnak işaretini
kullanabilirsiniz. Ancak Python’da karakter dizileri tanımlanırken genellikle
tek tırnak veya çift tırnak işaretleri kullanılır. Üç tırnak işaretlerinin asıl
kullanım yeri ise farklıdır. Peki nedir bu üç tırnak işaretlerinin asıl kullanım
yeri?</p>
<p>Üç tırnak işaretlerini her türlü karakter dizisiyle birlikte kullanabiliyor
olsak da, bu tırnak tipi çoğunlukla sadece birden fazla satıra yayılmış karakter
dizilerini tanımlamada kullanılır. Örneğin şöyle bir ekran çıktısı vermek
istediğinizi düşünün:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span>[H]=========HARMAN========[-][o][x]
| |
| Programa Hoşgeldiniz! |
| Sürüm 0.8 |
| Devam etmek için herhangi |
| bir düğmeye basın. |
| |
|=================================|
</pre></div>
</div>
<p>Böyle bir çıktı verebilmek için eğer tek veya çift tırnak kullanmaya
kalkışırsanız epey eziyet çekersiniz. Bu tür bir çıktı vermenin en kolay yolu üç
tırnakları kullanmaktı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">"""</span>
<span class="gp">... </span><span class="s2">[H]=========HARMAN========[-][o][x]</span>
<span class="gp">... </span><span class="s2">| |</span>
<span class="gp">... </span><span class="s2">| Programa Hoşgeldiniz! |</span>
<span class="gp">... </span><span class="s2">| Sürüm 0.8 |</span>
<span class="gp">... </span><span class="s2">| Devam etmek için herhangi |</span>
<span class="gp">... </span><span class="s2">| bir düğmeye basın. |</span>
<span class="gp">... </span><span class="s2">| |</span>
<span class="gp">... </span><span class="s2">|=================================|</span>
<span class="gp">... </span><span class="s2">"""</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada bazı şeyler dikkatinizi çekmiş olmalı. Gördüğünüz gibi, üç tırnaklı yapı
öteki tırnak tiplerine göre biraz farklı davranıyor. Şimdi şu örneğe 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">"""Game Over!</span>
<span class="gp">...</span><span class="s2"></span>
</pre></div>
</div>
<p>Buraya çok dikkatli bakın. Karakter dizisine üç tırnakla başladıktan sonra,
kapanış tırnağını koymadan <cite>Enter</cite> tuşuna bastığımızda <cite>>>></cite> işareti <cite>…</cite>
işaretine dönüştü. Python bu şekilde bize, ‘yazmaya devam et!’ demiş oluyor. Biz
de buna uyarak yazmaya devam edelim:</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">"""Game Over!</span>
<span class="gp">... </span><span class="s2">Insert Coin!"""</span><span class="p">)</span>
<span class="go">Game Over!</span>
<span class="go">Insert Coin!</span>
</pre></div>
</div>
<p>Kapanış tırnağı koyulmadan <cite>Enter</cite> tuşuna basıldığında <cite>>>></cite> işaretinin <cite>…</cite>
işaretine dönüşmesi üç tırnağa özgü bir durumdur. Eğer aynı şeyi tek veya çift
tırnaklarla yapmaya çalışırsanız programınız hata verir:</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">"Game Over!</span>
<span class="go">File "<stdin>", line 1</span>
<span class="go"> print("Game Over!</span>
<span class="go"> ^</span>
<span class="go">SyntaxError: EOL while scanning string literal</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="s1">'Game Over!</span>
<span class="go">File "<stdin>", line 1</span>
<span class="go"> print("Game Over!</span>
<span class="go"> ^</span>
<span class="go">SyntaxError: EOL while scanning string literal</span>
</pre></div>
</div>
<p>Üç tırnak işaretlerinin tırnak kapanmadan <cite>Enter</cite> tuşuna basıldığında hata
vermeme özelliği sayesinde, bu tırnak tipi özellikle birden fazla satıra
yayılmış karakter dizilerinin gösterilmesi için birebirdir.</p>
<p>Gelin isterseniz üç tırnak kullanımına ilişkin 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">"""Python programlama dili Guido Van Rossum</span>
<span class="gp">... </span><span class="s2">adlı Hollandalı bir programcı tarafından 90’lı</span>
<span class="gp">... </span><span class="s2">yılların başında geliştirilmeye başlanmıştır. Çoğu</span>
<span class="gp">... </span><span class="s2">insan, isminin "Python" olmasına bakarak, bu programlama</span>
<span class="gp">... </span><span class="s2">dilinin, adını piton yılanından aldığını düşünür.</span>
<span class="gp">... </span><span class="s2">Ancak zannedildiğinin aksine bu programlama dilinin</span>
<span class="gp">... </span><span class="s2">adı piton yılanından gelmez."""</span><span class="p">)</span>
<span class="go">Python programlama dili Guido Van Rossum</span>
<span class="go">adlı Hollandalı bir programcı tarafından 90'lı</span>
<span class="go">yılların başında geliştirilmeye başlanmıştır. Çoğu</span>
<span class="go">insan, isminin "Python" olmasına bakarak, bu programlama</span>
<span class="go">dilinin, adını piton yılanından aldığını düşünür.</span>
<span class="go">Ancak zannedildiğinin aksine bu programlama dilinin</span>
<span class="go">dı piton yılanından gelmez.</span>
</pre></div>
</div>
<p>Elbette eğer istersek bu metni önce bir değişkene atamayı da tercih edebiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">python_hakkinda</span> <span class="o">=</span> <span class="s2">"""Python programlama dili Guido Van Rossum</span>
<span class="gp">... </span><span class="s2">adlı Hollandalı bir programcı tarafından 90’lı</span>
<span class="gp">... </span><span class="s2">yılların başında geliştirilmeye başlanmıştır. Çoğu</span>
<span class="gp">... </span><span class="s2">insan, isminin "Python" olmasına bakarak, bu programlama</span>
<span class="gp">... </span><span class="s2">dilinin, adını piton yılanından aldığını düşünür.</span>
<span class="gp">... </span><span class="s2">Ancak zannedildiğinin aksine bu programlama dilinin</span>
<span class="gp">... </span><span class="s2">adı piton yılanından gelmez."""</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">python_hakkinda</span><span class="p">)</span>
<span class="go">Python programlama dili Guido Van Rossum</span>
<span class="go">adlı Hollandalı bir programcı tarafından 90'lı</span>
<span class="go">yılların başında geliştirilmeye başlanmıştır. Çoğu</span>
<span class="go">insan, isminin "Python" olmasına bakarak, bu programlama</span>
<span class="go">dilinin, adını piton yılanından aldığını düşünür.</span>
<span class="go">Ancak zannedildiğinin aksine bu programlama dilinin</span>
<span class="go">adı piton yılanından gelmez.</span>
</pre></div>
</div>
<p>Siz yukarıdaki çıktıyı tek veya çift tırnak kullanarak nasıl ekrana
yazdırabileceğinizi düşünedurun, biz önemli bir konuya geçiş yapalım!</p>
</div>
<div class="section" id="bir-fonksiyon-olarak-print">
<h2>Bir Fonksiyon Olarak print()<a class="headerlink" href="#bir-fonksiyon-olarak-print" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p><code class="docutils literal notranslate"><span class="pre">print()</span></code> ifadesinin bir fonksiyon olduğunu söylemiştik hatırlarsanız.
Dediğimiz gibi, fonksiyonlarla ilgili ayrıntılı açıklamaları ilerleyen derslerde
vereceğiz. Ancak şimdi dilerseniz bundan sonra anlatacaklarımızı daha iyi
kavrayabilmemiz için, fonksiyonlar hakkında bilmemiz gereken bazı temel şeyleri
öğrenmeye çalışalım.</p>
<p>Gördüğünüz gibi, <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunu şöyle kullanıyoruz:</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">"Aramak istediğiniz kelimeyi yazın: "</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada <code class="docutils literal notranslate"><span class="pre">print()</span></code> bir fonksiyon, <cite>“Aramak istediğiniz kelimeyi yazın:”</cite> adlı
karakter dizisi ise bu fonksiyonun parametresidir. Daha önce <code class="docutils literal notranslate"><span class="pre">len()</span></code> adlı
başka bir fonksiyon daha öğrenmiştik hatırlarsanız. Onu da şöyle kullanıyorduk:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="s2">"elma"</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada da <code class="docutils literal notranslate"><span class="pre">len()</span></code> bir fonksiyon, <cite>“elma”</cite> adlı karakter dizisi ise bu
fonksiyonun parametresidir. Aslında biçim olarak <code class="docutils literal notranslate"><span class="pre">print()</span></code> ve <code class="docutils literal notranslate"><span class="pre">len()</span></code>
fonksiyonlarının birbirinden hiçbir farkı olmadığını görüyorsunuz.</p>
<p>Daha önce söylediğimiz ve bu örneklerden de anladığımız gibi, bir fonksiyonun
parantezleri içinde belirtilen öğelere parametre adı veriliyor. Mesela aşağıdaki
örnekte <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunu tek bir parametre ile kullanıyoruz:</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">'En az 8 haneli bir parola belirleyin.'</span><span class="p">)</span>
</pre></div>
</div>
<p><code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu, tıpkı <code class="docutils literal notranslate"><span class="pre">pow()</span></code> fonksiyonu gibi, birden fazla parametre alabilir:</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">'Fırat'</span><span class="p">,</span> <span class="s1">'Özgül'</span><span class="p">)</span>
<span class="go">Fırat Özgül</span>
</pre></div>
</div>
<p>Bu örnekte bizim için çıkarılacak çok dersler var. Bir defa burada <code class="docutils literal notranslate"><span class="pre">print()</span></code>
fonksiyonunu iki farklı parametre ile birlikte kullandık. Bunlardan ilki <cite>Fırat</cite>
adlı bir karakter dizisi, ikincisi ise <cite>Özgül</cite> adlı başka bir karakter dizisi.
Python’ın bu iki karakter dizisini nasıl birleştirdiğine dikkat edin.
<code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu bu iki karakter dizisini çıktı olarak verirken aralarına
da birer boşluk yerleştirdi. Ayrıca, geçen derste de vurguladığımız gibi,
parametrelerin birbirinden virgül ile ayrıldığını da gözden kaçırmıyoruz.</p>
<p>Gelin bununla ilgili bir iki örnek daha verelim elimizin alışması için:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="s2">"Python"</span><span class="p">,</span> <span class="s2">"Programlama"</span><span class="p">,</span> <span class="s2">"Dili"</span><span class="p">)</span>
<span class="go">Python Programlama Dili</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="s1">'Fırat'</span><span class="p">,</span> <span class="s1">'Özgül'</span><span class="p">,</span> <span class="s1">'Adana'</span><span class="p">,</span> <span class="mi">1980</span><span class="p">)</span>
<span class="go">Fırat Özgül Adana 1980</span>
</pre></div>
</div>
<p>Bu arada dikkatinizi önemli bir noktaya çekmek istiyorum. Yukarıdaki örneklerde
bazen tek tırnak, bazen de çift tırnak kullandık. Daha önce de söylediğimiz
gibi, hangi tırnak tipini kullandığımız önemli değildir. Python hangi tırnak
tipini kullandığımızdan ziyade, tırnak kullanımında tutarlı olup olmadığımızla
ilgilenir. Yani Python için önemli olan, karakter dizisini hangi tırnakla
başlatmışsak, o tırnakla bitirmemizdir. Yani şu tip kullanımlar geçerli
değildir:</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">"karakter dizisi')</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="s1">'karakter dizisi")</span>
</pre></div>
</div>
<p>Karakter dizisini tanımlamaya başlarken kullandığımız tırnak tipi ile karakter
dizisini tanımlamayı bitirirken kullandığımız tırnak tipi birbirinden farklı
olduğu için bu iki kullanım da hata verecektir.</p>
</div>
<div class="section" id="print-fonksiyonunun-parametreleri">
<h2>print() Fonksiyonunun Parametreleri<a class="headerlink" href="#print-fonksiyonunun-parametreleri" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Şimdiye kadar verdiğimiz örneklerde belki çok da belli olmuyordur, ama aslında
<code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu son derece güçlü bir araçtır. İşte şimdi biz bu
fonksiyonun gücünü gözler önüne seren özelliklerini incelemeye başlayacağız. Bu
bölümü dikkatle takip etmeniz, ilerde yapacağımız çalışmaları daha rahat
anlayabilmeniz açısından büyük önem taşır.</p>
<div class="section" id="sep">
<h3>sep<a class="headerlink" href="#sep" title="Bu başlık için kalıcı bağlantı">¶</a></h3>
<p><code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu ile ilgili olarak yukarıda verdiğimiz örnekleri
incelediğimizde, bu fonksiyonun kendine özgü bir davranış şekli olduğunu
görüyoruz. Mesela bir önceki bölümde verdiğimiz ş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="s1">'Fırat'</span><span class="p">,</span> <span class="s1">'Özgül'</span><span class="p">)</span>
<span class="go">Fırat Özgül</span>
</pre></div>
</div>
<p>Burada <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunu iki farklı parametre ile birlikte kullandık. Bu
fonksiyon, kendisine verdiğimiz bu parametreleri belli bir düzene göre
birbiriyle birleştirdi. Bu düzen gereğince <code class="docutils literal notranslate"><span class="pre">print()</span></code>, kendisine verilen
parametreleri birleştirirken, parametreler arasına bir boşluk yerleştiriyor.
Bunu daha net görmek için şöyle 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">"Python"</span><span class="p">,</span> <span class="s2">"PHP"</span><span class="p">,</span> <span class="s2">"C++"</span><span class="p">,</span> <span class="s2">"C"</span><span class="p">,</span> <span class="s2">"Erlang"</span><span class="p">)</span>
<span class="go">Python PHP C++ C Erlang</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu gerçekten de, kendisine verilen
parametreleri birleştirirken, parametrelerin her biri arasına bir boşluk
yerleştiriyor. Halbuki bu boşluğu biz talep etmedik! Python bize bu boşluğu
eşantiyon olarak verdi. Çoğu durumda istediğimiz şey bu olacaktır, ama bazı
durumlarda bu boşluğu istemeyebiliriz. Örneğin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="s2">"http://"</span><span class="p">,</span> <span class="s2">"www."</span><span class="p">,</span> <span class="s2">"istihza."</span><span class="p">,</span> <span class="s2">"com"</span><span class="p">)</span>
<span class="go">http:// www. istihza. com</span>
</pre></div>
</div>
<p>Ya da boşluk karakteri yerine daha farklı bir karakter kullanmak istiyor da
olabiliriz. Peki böyle bir durumda ne yapmamız gerekir?</p>
<p>İşte bu noktada bazı özel araçlardan yararlanarak <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun
öntanımlı davranış kalıpları üzerinde değişiklikler yapabiliriz.</p>
<p>Peki nedir <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunu özelleştirmemizi sağlayacak bu araçlar?</p>
<p>Hatırlarsanız, Python’da fonksiyonların parantezleri içindeki değerlere
parametre adı verildiğini söylemiştik. Mesela <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunu bir ya da
daha fazla parametre ile birlikte kullanabileceğ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="s2">"Mehmet"</span><span class="p">,</span> <span class="s2">"Öz"</span><span class="p">,</span> <span class="s2">"İstanbul"</span><span class="p">,</span> <span class="s2">"Çamlıca"</span><span class="p">,</span> <span class="mi">156</span><span class="p">,</span> <span class="s2">"/"</span><span class="p">,</span> <span class="mi">45</span><span class="p">)</span>
<span class="go">Mehmet Öz İstanbul Çamlıca 156 / 45</span>
</pre></div>
</div>
<p><code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu içinde istediğimiz sayıda karakter dizisi ve/veya sayı
değerli parametre kullanabiliriz.</p>
<p>Fonksiyonların bir de daha özel görünümlü parametreleri vardır. Mesela
<code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun <cite>sep</cite> adlı özel bir parametresi bulunur. Bu parametre
<code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunda görünmese bile her zaman oradadır. Yani diyelim ki
şöyle bir kod yazdı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="s2">"http://"</span><span class="p">,</span> <span class="s2">"www."</span><span class="p">,</span> <span class="s2">"google."</span><span class="p">,</span> <span class="s2">"com"</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada herhangi bir <cite>sep</cite> parametresi görmüyoruz. Ancak Python yukarıdaki kodu
aslında şöyle algılar:</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">"http://"</span><span class="p">,</span> <span class="s2">"www."</span><span class="p">,</span> <span class="s2">"google."</span><span class="p">,</span> <span class="s2">"com"</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><em>sep</em> ifadesi, İngilizcede <em>separator</em> (ayırıcı, ayraç) kelimesinin
kısaltmasıdır. Dolayısıyla <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonundaki bu <cite>sep</cite> parametresi,
ekrana basılacak öğeler arasına hangi karakterin yerleştirileceğini gösterir. Bu
parametrenin öntanımlı değeri bir adet boşluk karakteridir (<cite>” “</cite>). Yani siz bu
özel parametrenin değerini başka bir şeyle değiştirmezseniz, Python bu
parametrenin değerini bir adet boşluk karakteri olarak alacak ve ekrana
basılacak öğeleri birbirinden birer boşlukla ayıracaktır. Ancak eğer biz
istersek bu <cite>sep</cite> parametresinin değerini değiştirebiliriz. Böylece Python,
karakter dizilerini birleştirirken araya boşluk değil, bizim istediğimiz başka
bir karakteri yerleştirebilir. Gelin şimdi bu parametrenin değerini nasıl
değiştireceğimizi 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="s2">"http://"</span><span class="p">,</span> <span class="s2">"www."</span><span class="p">,</span> <span class="s2">"istihza."</span><span class="p">,</span> <span class="s2">"com"</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">http://www.istihza.com</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, karakter dizilerini başarıyla birleştirip, geçerli bir internet
adresi elde ettik.</p>
<p>Burada yaptığımız şey aslında çok basit. Sadece <cite>sep</cite> parametresinin ‘bir adet
boşluk karakteri’ olan öntanımlı değerini silip, yerine ‘boş bir karakter
dizisi’ değerini yazdık. Bu iki kavramın birbirinden farklı olduğunu
söylediğimizi hatırlıyorsunuz, değil mi?</p>
<p>Gelin bir örnek daha 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">"T"</span><span class="p">,</span> <span class="s2">"C"</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.C</span>
</pre></div>
</div>
<p>Burada Python’a şöyle bir emir vermiş olduk:</p>
<blockquote>
<div><p><cite>“T”</cite> ve <cite>“C”</cite> karakter dizilerini birbiriyle birleştir! Bunu yaparken de bu
karakter dizilerinin arasına nokta işareti yerleştir!</p>
</div></blockquote>
<p><cite>sep</cite> parametresinin öteki parametrelerden farkı her zaman ismiyle birlikte
kullanılmasıdır. Zaten teknik olarak da bu tür parametrelere ‘isimli
parametreler’ adı verilir. Örneğin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="s2">"Adana"</span><span class="p">,</span> <span class="s2">"Mersin"</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">Adana-Mersin</span>
</pre></div>
</div>
<p>Eğer burada <cite>sep</cite> parametresinin ismini belirtmeden, doğrudan parametrenin
değerini yazarsak, bu değerin öteki parametrelerden hiçbir farkı kalmayacaktı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">"Adana"</span><span class="p">,</span> <span class="s2">"Mersin"</span><span class="p">,</span> <span class="s2">"-"</span><span class="p">)</span>
<span class="go">Adana Mersin -</span>
</pre></div>
</div>
<p>Gelin isterseniz bu parametreyle ilgili bir örnek daha yapalım:</p>
<p>‘Bir mumdur iki mumdur…’ diye başlayan türküyü biliyorsunuzdur. Şimdi bu
türküyü Python’la nasıl yazabileceğimizi 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="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="s2">"dört"</span><span class="p">,</span> <span class="s2">"on dört"</span><span class="p">,</span> <span class="n">sep</span><span class="o">=</span><span class="s2">"mumdur"</span><span class="p">)</span>
<span class="go">birmumdurikimumdurüçmumdurdörtmumduron dört</span>
</pre></div>
</div>
<p>Burada bir terslik olduğu açık! Karakter dizileri birbirlerine sıkışık düzende
birleştirildi. Bunların arasında birer boşluk olsa tabii daha iyi olurdu. Ancak
biliyorsunuz <cite>sep</cite> parametresinin öntanımlı değerini silip, yerine <cite>“mumdur”</cite>
değerini yerleştirdiğimiz için, Python’ın otomatik olarak yerleştirdiği boşluk
karakteri kayboldu. Ama eğer istersek o boşluk karakterlerini kendimiz de
ayarlayabiliriz:</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="s2">"dört"</span><span class="p">,</span> <span class="s2">"on dört"</span><span class="p">,</span> <span class="n">sep</span><span class="o">=</span><span class="s2">" mumdur "</span><span class="p">)</span>
<span class="go">bir mumdur iki mumdur üç mumdur dört mumdur on dört</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <cite>sep</cite> parametresine verdiğimiz <cite>“mumdur”</cite> değerinin sağında ve
solunda birer boşluk bırakarak sorunumuzu çözebildik. Bu sorunu çözmenin başka
bir yolu daha var. Hatırlarsanız etkileşimli kabukta ilk örneklerimizi verirken
karakter dizilerini birleştirmek için <cite>+</cite> işaretinden de yararlanabileceğimizi
söylemiştik. Dolayısıyla <cite>sep</cite> parametresini şöyle de yazabiliriz:</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="s2">"dört"</span><span class="p">,</span> <span class="s2">"on dört"</span><span class="p">,</span> <span class="n">sep</span><span class="o">=</span><span class="s2">" "</span> <span class="o">+</span> <span class="s2">"mumdur"</span> <span class="o">+</span> <span class="s2">" "</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada da, <cite>“mumdur”</cite> adlı karakter dizisinin başında ve sonunda birer boşluk
bırakmak yerine, gerekli boşlukları <cite>+</cite> işareti yardımıyla bu karakter dizisine
birleştirdik. Hatta istersek <cite>+</cite> işlecini kullanmak zorunda olmadığımızı dahi
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">"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="s2">"dört"</span><span class="p">,</span> <span class="s2">"on dört"</span><span class="p">,</span> <span class="n">sep</span><span class="o">=</span><span class="s2">" "</span> <span class="s2">"mumdur"</span> <span class="s2">" "</span><span class="p">)</span>
</pre></div>
</div>
<p>Ama gördüğünüz gibi bir problemimiz daha var. Türkünün sözleri şu şekilde
olmalıydı:</p>
<blockquote>
<div><p>bir mumdur iki mumdur üç mumdur dört mumdur on dört mumdur</p>
</div></blockquote>
<p>Ama sondaki ‘mumdur’ kelimesi yukarıdaki çıktıda yok. Normal olan da bu aslında.
<cite>sep</cite> parametresi, karakter dizilerinin <strong>arasına</strong> bir değer yerleştirir.
Karakter dizilerinin son tarafıyla ilgilenmez. Bu iş için <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu
başka bir parametreye sahiptir.</p>
<p>Bu arada, yukarıdaki örneklerde hep karakter dizilerini kullanmış olmamız sizi
yanıltmasın. <cite>sep</cite> parametresi yalnızca karakter dizilerinin değil sayıların
arasına da istediğiniz bir değerin yerleştirilmesini sağlayabilir. Mesela:</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="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</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">1-2-3-4-5</span>
</pre></div>
</div>
<p>Ancak <cite>sep</cite> parametresine değer olarak yalnızca karakter dizilerini ve <cite>None</cite>
adlı özel bir sözcüğü verebiliriz. (<cite>None</cite> sözcüğünden ileride söz edeceğiz):</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="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="n">sep</span><span class="o">=</span><span class="mi">0</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">TypeError</span>: <span class="n">sep must be None or a string, not int</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <cite>sep</cite> parametresine bir sayı olan <cite>0</cite> değerini veremiyoruz.</p>
<p>Peki bu parametreye <cite>None</cite> değeri verirsek ne olur? Bu parametreye <cite>None</cite> değeri
verildiğinde, <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu bu parametre için öntanımlı değeri (yani
bir adet boşluk) kullanı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="s1">'a'</span><span class="p">,</span> <span class="s1">'b'</span><span class="p">,</span> <span class="n">sep</span><span class="o">=</span><span class="kc">None</span><span class="p">)</span>
<span class="go">a b</span>
</pre></div>
</div>
<p>Eğer amacınız parametreleri birbirine bitiştirmekse, yani <cite>sep</cite> parametresinin
öntanımlı değeri olan boşluk karakterini ortadan kaldırmaksa, <cite>sep</cite>
parametresine boş bir karakter dizisi vermeniz gerektiğini 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="s1">'a'</span><span class="p">,</span> <span class="s1">'b'</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">ab</span>
</pre></div>
</div>
<p><code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun <cite>sep</cite> parametresini bütün ayrıntılarıyla
incelediğimize göre, bu fonksiyonun bir başka özel parametresinden söz
edebiliriz.</p>
</div>
<div class="section" id="end">
<h3>end<a class="headerlink" href="#end" title="Bu başlık için kalıcı bağlantı">¶</a></h3>
<p>Bir önceki bölümde şöyle bir laf etmiştik:</p>
<blockquote>
<div><p><code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonun <cite>sep</cite> adlı özel bir parametresi bulunur. Bu
parametre <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunda görünmese bile her zaman oradadır.</p>
</div></blockquote>
<p>Aynı bu şekilde, <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun <cite>end</cite> adlı özel bir parametresi daha
bulunur. Tıpkı <cite>sep</cite> parametresi gibi, <cite>end</cite> parametresi de <code class="docutils literal notranslate"><span class="pre">print()</span></code>
fonksiyonunda görünmese bile her zaman oradadır.</p>
<p>Bildiğiniz gibi, <cite>sep</cite> parametresi <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonuna verilen parametreler
birleştirilirken araya hangi karakterin gireceğini belirliyordu. <cite>end</cite>
parametresi ise bu parametrelerin sonuna neyin geleceğini belirler.</p>
<p><code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu öntanımlı olarak, parametrelerin sonuna ‘satır başı
karakteri’ ekler. Peki bu satır başı karakteri (veya ‘yeni satır karakteri’)
denen şey de ne oluyor?</p>
<p>Dilerseniz bunu bir örnek üzerinde görelim.</p>
<p>Şöyle bir kodumuz olsun:</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">"Pardus ve Ubuntu birer GNU/Linux dağıtımıdır."</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu kodu yazıp <cite>Enter</cite> tuşuna bastığımız anda <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu iki farklı
işlem gerçekleştirir:</p>
<ol class="arabic simple">
<li><p>Öncelikle karakter dizisini ekrana yazdırır.</p></li>
<li><p>Ardından bir alt satıra geçip bize <cite>>>></cite> işaretini gösterir.</p></li>
</ol>
<p>İşte bu ikinci işlem, karakter dizisinin sonunda bir adet satır başı karakteri
olmasından, daha doğrusu <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun, satır başı karakterini
karakter dizisinin sonuna eklemesinden kaynaklanır. Bu açıklama biraz kafa
karıştırıcı gelmiş olabilir. O halde biraz daha açıklayalım. Şu örneğe 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">"Pardus</span><span class="se">\n</span><span class="s2">Ubuntu"</span><span class="p">)</span>
<span class="go">Pardus</span>
<span class="go">Ubuntu</span>
</pre></div>
</div>
<p>Burada <cite>“Pardus”</cite> ve <cite>“Ubuntu”</cite> karakter dizilerinin tam ortasında çok özel bir
karakter dizisi daha görüyorsunuz. Bu karakter dizisi şudur: <cite>\n</cite>. İşte bu özel
karakter dizisine satır başı karakteri (<em>newline</em>) adı verilir. Bu karakterin
görevi, karakter dizisini, bulunduğu noktadan bölüp, karakter dizisinin geri
kalanını bir alt satıra geçirmektir. Zaten çıktıda da bu işlevi yerine
getirdiğini görüyorsunuz. Karakter dizisi <cite>“Pardus”</cite> kısmından sonra ikiye
bölünüyor ve bu karakter dizisinin geri kalan kısmı olan <cite>“Ubuntu”</cite> karakter
dizisi bir alt satıra yazdırılıyor. Bunu daha iyi anlamak için 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">"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>Peki size bir soru sorayım: Acaba yukarıdaki kodları daha verimli bir şekilde
nasıl yazabiliriz?</p>
<p>Evet, doğru tahmin ettiniz… Tabii ki <cite>sep</cite> parametresini kullanarak:</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="p">,</span> <span class="s2">"ikinci satır"</span><span class="p">,</span> <span class="s2">"üçüncü satır"</span><span class="p">,</span> <span class="n">sep</span><span class="o">=</span><span class="s2">"</span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
<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>Burada yaptığımız şey çok basit. <cite>sep</cite> parametresinin değerini <cite>\n</cite>, yani yeni
satır karakteri (veya satır başı karakteri) olarak değiştirdik. Böylece karakter
dizileri arasına birer <cite>\n</cite> karakteri yerleştirerek her bir karakter dizisinin
farklı satıra yazdırılmasını sağladık.</p>
<p>İşte <cite>end</cite> parametresinin öntanımlı değeri de bu <cite>\n</cite> karakteridir ve bu
parametre <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunda görünmese bile her zaman oradadır.</p>
<p>Yani diyelim ki şöyle bir kod yazdı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="s2">"Bugün günlerden Salı"</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada herhangi bir <cite>end</cite> parametresi görmüyoruz. Ancak Python yukarıdaki kodu
aslında şöyle algılar:</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">"Bugün günlerden Salı"</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="s2">"</span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
</pre></div>
</div>
<p>Biraz önce de dediğimiz gibi, bu kodu yazıp <cite>Enter</cite> tuşuna bastığımız anda
<code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu iki farklı işlem gerçekleştirir:</p>
<ol class="arabic simple">
<li><p>Öncelikle karakter dizisini ekrana yazdırır.</p></li>
<li><p>Ardından bir alt satıra geçip bize <cite>>>></cite> işaretini gösterir.</p></li>
</ol>
<p>Bunun ne demek olduğunu anlamak için <cite>end</cite> parametresinin değerini değiştirmemiz
yeterli olacaktı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">"Bugün günlerden Salı"</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="s2">"."</span><span class="p">)</span>
<span class="go">Bugün günlerden Salı.>>></span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <cite>end</cite> parametresinin öntanımlı değeri olan <cite>\n</cite> karakterini
silip yerine <cite>.</cite> (nokta) işareti koyduğumuz için, komutu yazıp <cite>Enter</cite> tuşuna
bastığımızda <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu satır başına geçmedi. Yeni satıra geçebilmek
için <cite>Enter</cite> tuşuna kendimiz basmalıyız. Elbette, eğer yukarıdaki kodları şöyle
yazarsanız, <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu hem karakter dizisinin sonuna nokta
ekleyecek, hem de satır başına geçecektir:</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">"Bugün günlerden Salı"</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="s2">".</span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
<span class="go">Bugün günlerden Salı.</span>
</pre></div>
</div>
<p>Şimdi bu öğrendiklerimizi türkümüze uygulayalı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="s2">"dört"</span><span class="p">,</span> <span class="s2">"on dört"</span><span class="p">,</span>
<span class="gp">... </span><span class="n">sep</span><span class="o">=</span><span class="s2">" mumdur "</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="s2">" mumdur</span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
</pre></div>
</div>
<div class="admonition note">
<p class="admonition-title">Not</p>
<p>Burada kodlarımızın sağa doğru çirkin bir şekilde uzamasını engellemek
için <cite>“on dört”</cite> karakter dizisini yazıp virgülü koyduktan sonra <cite>Enter</cite> tuşuna
basarak bir alt satıra geçtik. Bir alt satıra geçtiğimizde <cite>>>></cite> işaretinin
<cite>…</cite> işaretine dönüştüğüne dikkat edin. Python’da doğru kod yazmak kadar,
yazdığımız kodların düzgün görünmesi de önemlidir. O yüzden yazdığımız her bir
kod satırının mümkün olduğunca 79 karakteri geçmemesini sağlamalıyız. Eğer
yazdığınız bir satır 79 karakteri aşıyorsa, aşan kısmı yukarıda gösterdiğimiz
şekilde alt satıra alabilirsiniz.</p>
</div>
<p><cite>end</cite> parametresi de, tıpkı <cite>sep</cite> parametresi gibi, her zaman ismiyle birlikte
kullanılması gereken bir parametredir. Yani eğer <cite>end</cite> parametresinin ismini
belirtmeden sadece değerini kullanmaya çalışırsak Python ne yapmaya
çalıştığımızı anlayamaz.</p>
<p>Yine tıpkı <cite>sep</cite> parametresi gibi, <cite>end</cite> parametresinin değeri de sadece bir
karakter dizisi veya <cite>None</cite> 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="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="mi">0</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">TypeError</span>: <span class="n">end must be None or a string, not int</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <cite>end</cite> parametresine bir sayı olan <cite>0</cite> değerini veremiyoruz.</p>
<p>Eğer bu parametreye <cite>None</cite> değeri verirsek, tıpkı <cite>sep</cite> parametresinde olduğu
gibi, <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu bu parametre için öntanımlı değeri (yani satır başı
karakteri) kullanı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="s1">'a'</span><span class="p">,</span> <span class="s1">'b'</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="kc">None</span><span class="p">)</span>
<span class="go">a b</span>
</pre></div>
</div>
<p>Eğer amacınız yeni satıra geçilmesini engellemekse, yani <cite>end</cite> parametresinin
öntanımlı değeri olan <cite>\n</cite> kaçış dizisini ortadan kaldırmaksa, <cite>end</cite>
parametresine boş bir karakter dizisi vermelisiniz:</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">'a'</span><span class="p">,</span> <span class="s1">'b'</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="s1">''</span><span class="p">)</span>
<span class="go">a b>>></span>
</pre></div>
</div>
</div>
<div class="section" id="file">
<h3>file<a class="headerlink" href="#file" title="Bu başlık için kalıcı bağlantı">¶</a></h3>
<div class="admonition note">
<p class="admonition-title">Not</p>
<p>Burada henüz öğrenmediğimiz bazı şeyler göreceksiniz. Hiç endişe
etmeyin. Bunları ilerde bütün ayrıntılarıyla öğreneceğiz. Şimdilik konu hakkında
biraz olsun fikir sahibi olmanızı sağlayabilirsek kendimizi başarılı sayacağız.</p>
</div>
<p><code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun <cite>sep</cite> ve <cite>end</cite> dışında üçüncü bir özel parametresi
daha bulunur. Bu parametrenin adı <cite>file</cite>’dır. Görevi ise, <code class="docutils literal notranslate"><span class="pre">print()</span></code>
fonksiyonuna verilen karakter dizisi ve/veya sayıların, yani parametrelerin
nereye yazılacağını belirtmektir.</p>
<p>Bu parametrenin öntanımlı değeri <cite>sys.stdout</cite>’tur. Peki bu ne anlama geliyor?
<cite>sys.stdout</cite>, ‘standart çıktı konumu’ anlamına gelir. Peki ‘standart çıktı
konumu’ ne demek?</p>
<p>Standart çıktı konumu; bir programın, ürettiği çıktıları verdiği yerdir. Aslında
bu kavramın ne demek olduğu adından da anlaşılıyor:</p>
<blockquote>
<div><p>standart çıktı konumu = çıktıların standart olarak verildiği konum.</p>
</div></blockquote>
<p>Mesela Python öntanımlı olarak, ürettiği çıktıları ekrana verir. Eğer o anda
etkileşimli kabukta çalışıyorsanız, Python ürettiği çıktıları etkileşimli kabuk
üzerinde gösterir. Eğer yazdığınız bir programı komut satırında
çalıştırıyorsanız, üretilen çıktılar komut satırında görünür. Dolayısıyla
Python’ın standart çıktı konumu etkileşimli kabuk veya komut satırıdır. Yani
<code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu yardımıyla bastığınız çıktılar etkileşimli kabukta ya da
komut satırında görünecektir.</p>
<p>Şimdi bu konuyu daha iyi anlayabilmek için birkaç örnek yapalım.</p>
<p>Normal şartlar altında <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun çıktısını etkileşimli kabukta
görürü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">"Ben Python, Monty Python!"</span><span class="p">)</span>
<span class="go">Ben Python, Monty Python!</span>
</pre></div>
</div>
<p>Ama eğer istersek <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun, çıktılarını ekrana değil, bir
dosyaya yazdırmasını da sağlayabiliriz. Mesela biz şimdi <code class="docutils literal notranslate"><span class="pre">print()</span></code>
fonksiyonunun <cite>deneme.txt</cite> adlı bir dosyaya çıktı vermesini sağlayalım.</p>
<p>Bunun için sırasıyla şu kodları yazalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">dosya</span> <span class="o">=</span> <span class="nb">open</span><span class="p">(</span><span class="s2">"deneme.txt"</span><span class="p">,</span> <span class="s2">"w"</span><span class="p">)</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="s2">"Ben Python, Monty Python!"</span><span class="p">,</span> <span class="n">file</span><span class="o">=</span><span class="n">dosya</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">dosya</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
</pre></div>
</div>
<p>Herhangi bir çıktı almadınız, değil mi? Evet. Çünkü yazdığımız bu kodlar
sayesinde <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu, çıktılarını <cite>deneme.txt</cite> adlı bir dosyaya
yazdırdı.</p>
<p>Gelin isterseniz yukarıdaki kodları satır satır inceleyelim:</p>
<p>1. Öncelikle <cite>deneme.txt</cite> adlı bir dosya oluşturduk ve bu dosyayı <cite>dosya</cite> adlı
bir değişkene atadık. Burada kullandığımız <code class="docutils literal notranslate"><span class="pre">open()</span></code> fonksiyonuna çok
takılmayın. Bunu birkaç bölüm sonra inceleyeceğiz. Biz şimdilik bu şekilde dosya
oluşturulduğunu bilelim yeter. Bu arada <code class="docutils literal notranslate"><span class="pre">open</span></code> fonksiyonunun da biçim olarak
<code class="docutils literal notranslate"><span class="pre">type()</span></code>, <code class="docutils literal notranslate"><span class="pre">len()</span></code>, <code class="docutils literal notranslate"><span class="pre">pow()</span></code> ve <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonlarına ne kadar
benzediğine dikkat edin. Gördüğünüz gibi <code class="docutils literal notranslate"><span class="pre">open()</span></code> fonksiyonu da tıpkı
<code class="docutils literal notranslate"><span class="pre">type()</span></code>, <code class="docutils literal notranslate"><span class="pre">len()</span></code>, <code class="docutils literal notranslate"><span class="pre">pow()</span></code> ve <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonları gibi birtakım
parametreler alıyor. Bu fonksiyonun ilk parametresi <cite>“deneme.txt”</cite> adlı bir
karakter dizisi. İşte bu karakter dizisi bizim oluşturmak istediğimiz dosyanın
adını gösteriyor. İkinci parametre ise <cite>“w”</cite> adlı başka bir karakter dizisi. Bu
da <cite>deneme.txt</cite> dosyasının yazma kipinde (modunda) açılacağını gösteriyor. Ama
dediğim gibi, siz şimdilik bu ayrıntılara fazla takılmayın. İlerleyen derslerde,
bu konuları adınızı bilir gibi bileceğinizden emin olabilirsiniz.</p>
<p>2. Oluşturduğumuz bu <cite>deneme.txt</cite> adlı dosya, o anda bulunduğunuz dizin içinde
oluşacaktır. Bu dizinin hangisi olduğunu öğrenmek için şu komutları
verebilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">import</span> <span class="nn">os</span>
<span class="gp">>>> </span><span class="n">os</span><span class="o">.</span><span class="n">getcwd</span><span class="p">()</span>
</pre></div>
</div>
<p>Bu komutun çıktısında hangi dizinin adı görünüyorsa, <cite>deneme.txt</cite> dosyası da o
dizinin içindedir. Mesela bendeki çıktı <cite>/home/yazbel</cite><cite>/Desktop</cite>. Demek ki
oluşturduğum <cite>deneme.txt</cite> adlı dosya masaüstündeymiş. Ben bu komutları Ubuntu
üzerinde verdim. Eğer Windows üzerinde verseydim şuna benzer bir çıktı
alacaktım: <cite>C:\Users\yazbel</cite><cite>\Desktop</cite></p>
<p>3. Ardından da normal bir şekilde <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonumuzu çalıştırdık. Ama
gördüğünüz gibi <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu bize herhangi bir çıktı vermedi. Çünkü,
daha önce de söylediğimiz gibi, <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunu biz ekrana değil,
dosyaya çıktı verecek şekilde ayarladık. Bu işlemi, <cite>file</cite> adlı bir parametreye,
biraz önce tanımladığımız <cite>dosya</cite> değişkenini yazarak yaptık.</p>
<p>4. Son komut yardımıyla da, yaptığımız değişikliklerin dosyada görünebilmesi
için ilk başta açtığımız dosyayı kapatıyoruz.</p>
<p>Şimdi <cite>deneme.txt</cite> adlı dosyayı açın. Biraz önce <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonuyla
yazdırdığımız <cite>“Ben Python, Monty Python!”</cite> karakter dizisinin dosyaya işlenmiş
olduğunu göreceksiniz.</p>
<p>Böylece <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun standart çıktı konumunu değiştirmiş olduk.
Yani <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun <cite>file</cite> adlı parametresine farklı bir değer
vererek, <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun etkileşimli kabuğa değil dosyaya yazmasını
sağladık.</p>
<p>Tıpkı <cite>sep</cite> ve <cite>end</cite> parametreleri gibi, <cite>file</cite> parametresi de, siz görmeseniz
bile her zaman <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun içinde vardır. Yani diyelim ki şöyle
bir komut verdik:</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">"Tahir olmak da ayıp değil"</span><span class="p">,</span> <span class="s2">"Zühre olmak da"</span><span class="p">)</span>
</pre></div>
</div>
<p>Python bu komutu şöyle algılar:</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">"Tahir olmak da ayıp değil"</span><span class="p">,</span> <span class="s2">"Zühre olmak da"</span><span class="p">,</span>
<span class="gp">... </span><span class="n">sep</span><span class="o">=</span><span class="s2">" "</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="s2">"</span><span class="se">\n</span><span class="s2">"</span><span class="p">,</span> <span class="n">file</span><span class="o">=</span><span class="n">sys</span><span class="o">.</span><span class="n">stdout</span><span class="p">)</span>
</pre></div>
</div>
<p>Yani kendisine parametre olarak verilen değerleri ekrana yazdırırken sırasıyla
şu işlemleri gerçekleştirir:</p>
<blockquote>
<div><ol class="arabic simple">
<li><p>Parametrelerin arasına birer boşluk koyar (<code class="docutils literal notranslate"><span class="pre">sep="</span> <span class="pre">"</span></code>),</p></li>
<li><p>Ekrana yazdırma işlemi bittikten sonra parametrelerin sonuna satır başı
karakteri ekler (<code class="docutils literal notranslate"><span class="pre">end="\n"</span></code>)</p></li>
<li><p>Bu çıktıyı standart çıktı konumuna gönderir (<code class="docutils literal notranslate"><span class="pre">file=sys.stdout</span></code>).</p></li>
</ol>
</div></blockquote>
<p>İşte biz burada <cite>file</cite> parametresinin değeri olan standart çıktı konumuna başka
bir değer vererek bu konumu değiştiriyoruz.</p>
<p>Gelin isterseniz bununla ilgili bir örnek daha yapalım. Mesela kişisel
bilgilerimizi bir dosyaya kaydedelim. Öncelikle bilgileri kaydedeceğimiz dosyayı
oluşturalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">f</span> <span class="o">=</span> <span class="nb">open</span><span class="p">(</span><span class="s2">"kişisel_bilgiler.txt"</span><span class="p">,</span> <span class="s2">"w"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu kodlarla, <cite>kişisel_bilgiler.txt</cite> adını taşıyan bir dosyayı yazma kipinde
(<cite>w</cite>) açmış ve bu dosyayı <cite>f</cite> adlı bir değişkene atamış olduk. Şimdi bilgileri
yazmaya başlayabiliriz:</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">"Fırat Özgül"</span><span class="p">,</span> <span class="n">file</span><span class="o">=</span><span class="n">f</span><span class="p">)</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="s2">"Adana"</span><span class="p">,</span> <span class="n">file</span><span class="o">=</span><span class="n">f</span><span class="p">)</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="s2">"Ubuntu"</span><span class="p">,</span> <span class="n">file</span><span class="o">=</span><span class="n">f</span><span class="p">)</span>
</pre></div>
</div>
<p>İşimiz bittiğinde dosyayı kapatmayı unutmuyoruz. Böylece bütün bilgiler dosyaya
yazılmış oluyor:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">f</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
</pre></div>
</div>
<p>Oluşturduğumuz <cite>kişisel_bilgiler.txt</cite> adlı dosyayı açtığımızda, <code class="docutils literal notranslate"><span class="pre">print()</span></code>
fonksiyonuna verdiğimiz parametrelerin dosyaya yazdırıldığını görüyoruz.</p>
<p>En başta da söylediğim gibi, bu bölümde henüz öğrenmediğimiz bazı şeylerle
karşılaştık. Eğer yukarıda verilen örnekleri anlamakta zorlandıysanız hiç endişe
etmenize gerek yok. Birkaç bölüm sonra burada anlattığımız şeyler size çocuk
oyuncağı gibi gelecek…</p>
</div>
<div class="section" id="flush">
<h3>flush<a class="headerlink" href="#flush" title="Bu başlık için kalıcı bağlantı">¶</a></h3>
<p>Şimdiye kadar <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun <cite>sep</cite>, <cite>end</cite> ve <cite>file</cite> adlı özel
birtakım parametreleri olduğunu öğrendik. <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun bunların
dışında başka bir özel parametresi daha bulunur. Bu parametrenin adı <cite>flush</cite>.
İşte şimdi biz <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun bu <cite>flush</cite> adlı parametresinden söz
edeceğiz.</p>
<p>Bildiğiniz gibi, <code class="docutils literal notranslate"><span class="pre">print()</span></code> gibi bir komut verdiğimizde Python, yazdırmak
istediğimiz bilgiyi standart çıktı konumuna gönderir. Ancak Python’da bazı
işlemler standart çıktı konumuna gönderilmeden önce bir süre tamponda bekletilir
ve daha sonra bekleyen bu işlemler topluca standart çıktı konumuna gönderilir.
Peki ilk başta çok karmaşıkmış gibi görünen bu ifade ne anlama geliyor?</p>
<p>Aslında siz bu olguya hiç yabancı değilsiniz. <cite>file</cite> parametresini anlatırken
verdiğimiz şu örneği tekrar ele alalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">f</span> <span class="o">=</span> <span class="nb">open</span><span class="p">(</span><span class="s2">"kişisel_bilgiler.txt"</span><span class="p">,</span> <span class="s2">"w"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu komutla <cite>kişisel_bilgiler.txt</cite> adlı bir dosyayı yazma kipinde açtık. Şimdi bu
dosyaya bazı bilgiler ekleyelim:</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">"Fırat Özgül"</span><span class="p">,</span> <span class="n">file</span><span class="o">=</span><span class="n">f</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu komutla <cite>kişisel_bilgiler.txt</cite> adlı dosyaya ‘Fırat Özgül’ diye bir satır
eklemiş olduk.</p>
<p>Şimdi bilgisayarınızda oluşan bu <cite>kişisel_bilgiler.txt</cite> dosyasını açın.
Gördüğünüz gibi dosyada hiçbir bilgi yok. Dosya şu anda boş görünüyor. Halbuki
biz biraz önce bu dosyaya ‘Fırat Özgül’ diye bir satır eklemiştik, değil mi?</p>
<p>Python bizim bu dosyaya eklemek istediğimiz satırı tampona kaydetti. Dosyaya
yazma işlemleri sona erdiğinde ise Python, tamponda bekleyen bütün bilgileri
standart çıktı konumuna (yani bizim durumumuzda <cite>f</cite> adlı değişkenin tuttuğu
<cite>kişisel_bilgiler.txt</cite> adlı dosyaya) boşaltacak.</p>
<p>Dosyaya başka bilgiler de yazalı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">"Adana"</span><span class="p">,</span> <span class="n">file</span><span class="o">=</span><span class="n">f</span><span class="p">)</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="s2">"Ubuntu"</span><span class="p">,</span> <span class="n">file</span><span class="o">=</span><span class="n">f</span><span class="p">)</span>
</pre></div>
</div>
<p>Dosyaya yazacağımız şeyler bu kadar. Artık yazma işleminin sona erdiğini
Python’a bildirmek için şu komutu veriyoruz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">f</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
</pre></div>
</div>
<p>Böylece dosyamızı kapatmış olduk. Şimdi <cite>kişisel_bilgiler.txt</cite> adlı dosyaya çift
tıklayarak dosyayı tekrar açın. Orada ‘Fırat Özgül’, ‘Adana’ ve ‘Ubuntu’
satırlarını göreceksiniz.</p>
<p>Gördüğünüz gibi, gerçekten de Python dosyaya yazdırmak istediğimiz bütün
verileri önce tamponda bekletti, daha sonra dosya kapatılınca tamponda bekleyen
bütün verileri dosyaya boşalttı. İşte <cite>flush</cite> parametresi ile, bahsettiğimiz bu
boşaltma işlemini kontrol edebilirsiniz. Şimdi dikkatlice inceleyin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">f</span> <span class="o">=</span> <span class="nb">open</span><span class="p">(</span><span class="s2">"kişisel_bilgiler.txt"</span><span class="p">,</span> <span class="s2">"w"</span><span class="p">)</span>
</pre></div>
</div>
<p>Dosyamızı oluşturduk. Şimdi bu dosyaya bazı bilgiler ekleyelim:</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 Dünya!"</span><span class="p">,</span> <span class="n">file</span><span class="o">=</span><span class="n">f</span><span class="p">,</span> <span class="n">flush</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, burada <cite>flush</cite> adlı yeni bir parametre kullandık. Bu
parametreye verdiğimiz değer <cite>True</cite>. Şimdi dosyaya çift tıklayarak dosyayı açın.
Gördüğünüz gibi, henüz dosyayı kapatmadığımız halde bilgiler dosyaya yazıldı. Bu
durum, tahmin edebileceğiniz gibi, <cite>flush</cite> parametresine <cite>True</cite> değeri vermemiz
sayesindedir. Bu parametre iki değer alabilir: <cite>True</cite> ve <cite>False</cite>. Bu
parametrenin öntanımlı değeri <cite>False</cite>’tur. Yani eğer biz bu parametreye herhangi
bir değer belirtmezsek Python bu parametrenin değerini <cite>False</cite> olarak kabul
edecek ve bilgilerin dosyaya yazılması için dosyanın kapatılmasını
bekleyecektir. Ancak bu parametreye <cite>True</cite> değerini verdiğimizde ise veriler
tamponda bekletilmeksizin standart çıktı konumuna gönderilecektir.</p>
<p>Yazdığınız bir programda, yapmak istediğiniz işin niteliğine göre, bir dosyaya
yazmak istediğiniz bilgilerin bir süre tamponda bekletilmesini veya hiç
bekletilmeden doğrudan dosyaya yazılmasını isteyebilirsiniz. İhtiyacınıza bağlı
olarak da <cite>flush</cite> parametresinin değerini <cite>True</cite> veya <cite>False</cite> olarak
belirleyebilirsiniz.</p>
</div>
</div>
<div class="section" id="birkac-pratik-bilgi">
<h2>Birkaç Pratik Bilgi<a class="headerlink" href="#birkac-pratik-bilgi" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Buraya gelene kadar <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu ve bu fonksiyonun parametreleri
hakkında epey söz söyledik. Dilerseniz şimdi de, programcılık maceranızda
işinize yarayacak, işlerinizi kolaylaştıracak bazı ipuçları verelim.</p>
<div class="section" id="yildizli-parametreler">
<h3>Yıldızlı Parametreler<a class="headerlink" href="#yildizli-parametreler" title="Bu başlık için kalıcı bağlantı">¶</a></h3>
<p>Şimdi size şöyle bir soru sormama izin verin: Acaba aşağıdaki gibi bir çıktıyı
nasıl elde ederiz?</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">L</span><span class="o">.</span><span class="n">i</span><span class="o">.</span><span class="n">n</span><span class="o">.</span><span class="n">u</span><span class="o">.</span><span class="n">x</span>
</pre></div>
</div>
<p>Aklınıza hemen şöyle bir cevap gelmiş 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">"L"</span><span class="p">,</span> <span class="s2">"i"</span><span class="p">,</span> <span class="s2">"n"</span><span class="p">,</span> <span class="s2">"u"</span><span class="p">,</span> <span class="s2">"x"</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">L.i.n.u.x</span>
</pre></div>
</div>
<p>Yukarıdaki, gerçekten de doğru bir çözümdür. Ancak bu soruyu çözmenin çok daha
basit bir yolu var. Şimdi dikkatle 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="o">*</span><span class="s2">"Linux"</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">L.i.n.u.x</span>
</pre></div>
</div>