forked from yazbel/python-istihza
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathfonksiyonlar.html
2094 lines (1964 loc) · 196 KB
/
fonksiyonlar.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 fonksiyonlar konusunu inceleyeceğiz." name="description" />
<meta content="python, fonksiyon" name="keywords" />
<title>Fonksiyonlar — 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="Gömülü Fonksiyonlar" href="gomulu_fonksiyonlar.html" />
<link rel="prev" title="Kümeler ve Dondurulmuş Kümeler" href="kumeler_ve_dondurulmus_kumeler.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="gomulu_fonksiyonlar.html" title="Gömülü Fonksiyonlar"
accesskey="N">sonraki</a></li>
<li class="right" >
<a href="kumeler_ve_dondurulmus_kumeler.html" title="Kümeler ve Dondurulmuş Kümeler"
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="">Fonksiyonlar</a></li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="body" role="main">
<div class="section" id="fonksiyonlar">
<h1>Fonksiyonlar<a class="headerlink" href="#fonksiyonlar" title="Bu başlık için kalıcı bağlantı">¶</a></h1>
<p>İlk derslerimizden bu yana bir şey özellikle dikkatinizi çekmiş olmalı: İlk
andan itibaren hep ‘fonksiyon’ diye bir kavramdan söz ettik; üstelik yazdığımız
kodlarda da bu fonksiyon denen şeyi bolca kullandık. Evet, belki bu kavramı
şimdiye dek enine boyuna inceleme fırsatımız hiç olmadı, ama yine de adının
fonksiyon olduğunu söylediğimiz pek çok araç tanıdık bu noktaya gelinceye kadar.</p>
<p>Herhalde, ‘Fonksiyon denince aklınıza ilk ne geliyor?’ diye bir soru sorsam,
vereceğiniz cevap <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu olacaktır. Gerçekten de bu fonksiyonu
ilk derslerimizden bu yana o kadar sık kullandık ki, fonksiyon denince aklınıza
ilk bu fonksiyonun gelmesi gayet doğal.</p>
<p>Elbette öğrendiğimiz tek fonksiyon <code class="docutils literal notranslate"><span class="pre">print()</span></code> değildi. Bunun dışında <code class="docutils literal notranslate"><span class="pre">type()</span></code>
diye bir fonksiyondan da söz etmiştik. <code class="docutils literal notranslate"><span class="pre">print()</span></code> kadar olmasa da, <code class="docutils literal notranslate"><span class="pre">type()</span></code>
fonksiyonunu da yazdığımız kodlarda epey kullandık. <code class="docutils literal notranslate"><span class="pre">print()</span></code> ve <code class="docutils literal notranslate"><span class="pre">type()</span></code>
dışında, fonksiyon olarak <code class="docutils literal notranslate"><span class="pre">str()</span></code>, <code class="docutils literal notranslate"><span class="pre">int()</span></code> ve benzeri araçlarla da tanıştık.
Bunların dışında pek çok başka fonksiyon da Python’la birlikte hayatımıza girdi.</p>
<p>İşte bu bölümde, en baştan bu yana sıklıkla sözünü ettiğimiz, ama hiçbir zaman
tam anlamıyla ele almadığımız bu kavramı daha iyi anlayabilmek için, fonksiyon
konusunu ayrıntılı olarak ele alacağız. Bu bölümde amacımız fonksiyonları enine
boyuna inceleyerek, okurun bilgi dağarcığında fonksiyonlara ilişkin sağlam bir
altyapı oluşturmaktır. Okur, bu bölümü bitirdikten sonra fonksiyonlara ilişkin
olarak bilmesi gereken her şeyi öğrenmiş olacak.</p>
<div class="section" id="fonksiyon-nedir-ve-ne-ise-yarar">
<h2>Fonksiyon Nedir ve Ne İşe Yarar?<a class="headerlink" href="#fonksiyon-nedir-ve-ne-ise-yarar" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Biz şimdiye dek karşılaştığımız <code class="docutils literal notranslate"><span class="pre">print()</span></code>, <code class="docutils literal notranslate"><span class="pre">len()</span></code>, <code class="docutils literal notranslate"><span class="pre">type()</span></code> ve <code class="docutils literal notranslate"><span class="pre">open()</span></code>
gibi örnekler sayesinde ‘fonksiyon’ denen şeyi az çok tanıdığımızı
söyleyebiliriz. Dolayısıyla fonksiyonun ne demek olduğunu şeklen de olsa
biliyoruz ve hatta fonksiyonları kodlarımız içinde etkili bir şekilde
kullanabiliyoruz.</p>
<p>İlk derslerimizden bu yana öğrendiğimiz fonksiyonlara şöyle bir bakacak olursak,
fonksiyonların görünüşüne ve yapısına dair herhalde şu tespitleri yapabiliriz:</p>
<blockquote>
<div><ol class="arabic simple">
<li><p>Her fonksiyonun bir adı bulunur ve fonksiyonlar sahip oldukları bu
adlarla anılır. (<code class="docutils literal notranslate"><span class="pre">print</span></code> fonksiyonu, <code class="docutils literal notranslate"><span class="pre">open</span></code> fonksiyonu, <code class="docutils literal notranslate"><span class="pre">type</span></code>
fonksiyonu, <code class="docutils literal notranslate"><span class="pre">input</span></code> fonksiyonu, <code class="docutils literal notranslate"><span class="pre">len</span></code> fonksiyonu vb.)</p></li>
<li><p>Şekil olarak, her fonksiyonun isminin yanında birer parantez işareti
bulunur. (<code class="docutils literal notranslate"><span class="pre">open()</span></code>, <code class="docutils literal notranslate"><span class="pre">print()</span></code>, <code class="docutils literal notranslate"><span class="pre">input()</span></code>, <code class="docutils literal notranslate"><span class="pre">len()</span></code> vb.)</p></li>
<li><p>Bu parantez işaretlerinin içine, fonksiyonlara işlevsellik kazandıran
bazı parametreler yazılır. (<code class="docutils literal notranslate"><span class="pre">open(dosya_adı)</span></code>, <code class="docutils literal notranslate"><span class="pre">print("Merhaba</span> <span class="pre">Zalim</span>
<span class="pre">Dünya!")</span></code>, <code class="docutils literal notranslate"><span class="pre">len("kahramanmaraş")</span></code> vb.)</p></li>
<li><p>Fonksiyonlar farklı sayıda parametre alabilir. Örneğin <code class="docutils literal notranslate"><span class="pre">print()</span></code>
fonksiyonu toplam <cite>256</cite> adet parametre alabilirken, <code class="docutils literal notranslate"><span class="pre">input()</span></code> fonksiyonu
yalnızca tek bir parametre alır.</p></li>
<li><p>Fonksiyonların isimli ve isimsiz parametreleri vardır. <code class="docutils literal notranslate"><span class="pre">print()</span></code>
fonksiyonundaki <cite>sep</cite>, <cite>end</cite> ve <cite>file</cite> parametreleri isimli parametrelere
örnekken, mesela <code class="docutils literal notranslate"><span class="pre">print("Merhaba</span> <span class="pre">Dünya!")</span></code> kodunda <cite>Merhaba Dünya!</cite>
parametresi isimsiz bir parametredir. Aynı şekilde <code class="docutils literal notranslate"><span class="pre">input("Adınız:</span> <span class="pre">")</span></code>
gibi bir kodda <cite>Adınız:</cite> parametresi isimsiz bir parametredir.</p></li>
<li><p>Fonksiyonların, isimli ve isimsiz parametreleri dışında, bir de
varsayılan değerli parametreleri vardır. Örneğin <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun
<cite>sep</cite>, <cite>end</cite> ve <cite>file</cite> parametreleri varsayılan değerli parametrelere birer
örnektir. Eğer bir parametrenin varsayılan bir değeri varsa, o parametreye
herhangi bir değer vermeden de fonksiyonu kullanabiliriz. Python bu
parametrelere, belirli değerleri öntanımlı olarak kendisi atayacaktır. Tabii
eğer istersek, varsayılan değerli parametrelere kendimiz de başka birtakım
değerler verebiliriz.</p></li>
</ol>
</div></blockquote>
<p>Fonksiyon kavramının tam olarak ne olduğunu henüz bilmiyor da olsak, şimdiye
kadar öğrendiğimiz fonksiyonlara bakarak fonksiyonlar hakkında yukarıdaki
çıkarımları yapabiliyoruz. Demek ki aslında fonksiyonlar hakkında alttan alta
pek çok şey öğrenmişiz. O halde, fonksiyonlar hakkında şimdiden bildiklerimize
güvenerek, fonksiyon kavramının ne olduğundan ziyade ne işe yaradığı konusuna
rahatlıkla eğilebiliriz. Zaten fonksiyonların ne işe yaradığını öğrendikten
sonra, fonksiyonların ne olduğunu da hemencecik anlayacaksınız.</p>
<p>Fonksiyonların ne işe yaradığını en genel ve en kaba haliyle tarif etmek
istersek şöyle bir tanımlama yapabiliriz:</p>
<blockquote>
<div><p><strong>Fonksiyonların görevi, karmaşık işlemleri bir araya toplayarak, bu
işlemleri tek adımda yapmamızı sağlamaktır. Fonksiyonlar çoğu zaman, yapmak
istediğimiz işlemler için bir şablon vazifesi görür. Fonksiyonları
kullanarak, bir veya birkaç adımdan oluşan işlemleri tek bir isim altında
toplayabiliriz. Python’daki ‘fonksiyon’ kavramı başka programlama dillerinde
‘rutin’ veya ‘prosedür’ olarak adlandırılır. Gerçekten de fonksiyonlar
rutin olarak tekrar edilen görevleri veya prosedürleri tek bir ad/çatı
altında toplayan araçlardır.</strong></p>
</div></blockquote>
<p>Dilerseniz yukarıdaki soyut ifadeleri basit bir örnek üzerinde somutlaştırmaya
çalışalım. Örneğin <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunu ele alalım.</p>
<p>Bu fonksiyonun görevini biliyorsunuz: <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun görevi,
kullanıcının girdiği parametreleri ekrana çıktı olarak vermektir. Her ne kadar
<code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun görevini, ekrana çıktı vermek olarak tanımlasak da,
aslında bu fonksiyon, ekrana çıktı vermenin yanı sıra, başka bir takım ilave
işlemler de yapar. Yani bu fonksiyon, aslında aldığı parametreleri sadece ekrana
çıktı olarak vermekle yetinmez. Örneğin şu komutu inceleyelim:</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"</span><span class="p">,</span> <span class="s2">"Özgül"</span><span class="p">,</span> <span class="s2">"1980"</span><span class="p">,</span> <span class="s2">"Adana"</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu toplam dört adet parametre alıyor. Fonksiyonumuz,
görevi gereği, bu parametreleri ekrana çıktı olarak verecek. Bu komutu
çalıştırdığımızda şöyle bir çıktı alıyoruz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">Fırat</span> <span class="n">Özgül</span> <span class="mi">1980</span> <span class="n">Adana</span>
</pre></div>
</div>
<p>Dikkat ederseniz, burada salt bir ‘ekrana çıktı verme’ işleminden fazlası var.
Zira <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu aldığı parametreleri şu şekilde de ekrana
verebilirdi:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">FıratÖzgül1980Adana</span>
</pre></div>
</div>
<p>Veya şu şekilde:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">F</span>
<span class="n">ı</span>
<span class="n">r</span>
<span class="n">a</span>
<span class="n">t</span>
<span class="n">Ö</span>
<span class="n">z</span>
<span class="n">g</span>
<span class="n">ü</span>
<span class="n">l</span>
<span class="mi">1</span>
<span class="mi">9</span>
<span class="mi">8</span>
<span class="mi">0</span>
<span class="n">A</span>
<span class="n">d</span>
<span class="n">a</span>
<span class="n">n</span>
<span class="n">a</span>
</pre></div>
</div>
<p>Neticede bunlar da birer çıktı verme işlemidir. Ama dediğimiz gibi, <code class="docutils literal notranslate"><span class="pre">print()</span></code>
fonksiyonu aldığı parametreleri sadece ekrana çıktı olarak vermekle yetinmiyor.
Gelin isterseniz ne demek istediğimizi biraz daha açıklayalım:</p>
<p><code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun yukarıdaki komutu nasıl algıladığını önceki
derslerimizde öğrenmiştik. Yukarıdaki komut Python tarafından şu şekilde
algılanıyor:</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"</span><span class="p">,</span> <span class="s2">"Özgül"</span><span class="p">,</span> <span class="s2">"1980"</span><span class="p">,</span> <span class="s2">"Adana"</span><span class="p">,</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="gp">... </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> <span class="n">flush</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
</pre></div>
</div>
<p>Yani <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu;</p>
<ol class="arabic simple">
<li><p>Kendisine verilen <cite>“Fırat”</cite>, <cite>“Özgül”</cite>, <cite>“1980”</cite> ve <cite>“Adana”</cite>
parametrelerini ekrana basıyor,</p></li>
<li><p><cite>sep=” “</cite> parametresinin etkisiyle, bu parametreler arasına birer boşluk
ekliyor,</p></li>
<li><p><cite>end=”\n”</cite> parametresinin etkisiyle, sonuncu parametreyi de ekrana
bastıktan sonra bir alt satıra geçiyor,</p></li>
<li><p><cite>file=sys.stdout</cite> parametresinin etkisiyle, çıktı konumu olarak komut
ekranını kullanıyor. Yani çıktıları ekrana veriyor.</p></li>
<li><p><cite>flush=False</cite> parametresinin etkisiyle, çıktılar ekrana gönderilmeden önce
tamponda bekletiliyor.</p></li>
</ol>
<p>Eğer <code class="docutils literal notranslate"><span class="pre">print()</span></code> gibi bir fonksiyon olmasaydı, yukarıda listediğimiz bütün bu
işlemleri kendimiz yapmak zorunda kalacaktık. Yani ekranda göstermek istediğimiz
ifadeleri ekrana çıktı olarak vermenin yanısıra, bunların ekranda nasıl
görüneceğini de tek tek kendimiz elle ayarlamak zorunda kalacaktık. Ekrana çıktı
verme ile ilgili pek çok işlem tek bir <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu altında
birleştirildiği için, her ihtiyaç duyduğumuzda o işlemleri tek tek bizim
yapmamıza gerek kalmıyor.</p>
<p>Aynı şey mesela <code class="docutils literal notranslate"><span class="pre">input()</span></code> fonksiyonu için de geçerlidir. Bu fonksiyonu
kullanarak, programımızı kullanan kişilerle etkileşim içine girebiliyoruz. Tıpkı
<code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunda olduğu gibi, <code class="docutils literal notranslate"><span class="pre">input()</span></code> fonksiyonu da aslında alttan
alta epey karmaşık işlemler gerçekleştirir. Ama o karmaşık işlemlerin tek bir
<code class="docutils literal notranslate"><span class="pre">input()</span></code> fonksiyonu içinde bir araya getirilmiş olması sayesinde, sadece
<code class="docutils literal notranslate"><span class="pre">input()</span></code> gibi basit bir komut vererek kullanıcılarımızla iletişime
geçebiliyoruz.</p>
<p>Bu açıdan bakıldığında fonksiyonlar değişkenlere benzer. Bildiğiniz gibi, her
defasında bir değeri tekrar tekrar yazmak yerine bir değişkene atayarak o değere
kolayca erişebiliyoruz. Örneğin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kurum</span> <span class="o">=</span> <span class="s2">"Sosyal Sigortalar Kurumu"</span>
</pre></div>
</div>
<p>Burada tanımladığımız <cite>kurum</cite> adlı değişken sayesinde, ‘Sosyal Sigortalar
Kurumu’ ifadesini kullanmamız gereken her yerde sadece değişken adını
kullanarak, değişkenin tuttuğu değere ulaşabiliyoruz. İşte fonksiyonlar da buna
benzer bir işlev görür: Örneğin ekrana bir çıktı vermemiz gereken her yerde,
yukarıda verdiğimiz karmaşık adımları tek tek gerçekleştirmeye çalışmak yerine,
bu karmaşık ve rutin adımları bir araya getiren <code class="docutils literal notranslate"><span class="pre">print()</span></code> gibi bir
fonksiyondan yararlanarak işlerimizi çok daha kolay bir şekilde halledebiliriz.</p>
<p>Bu anlattıklarımız fonksiyonların ne işe yaradığı konusunda size bir fikir
vermiş olabilir. Dilerseniz bu anlattıklarımızı bir örnek aracılığıyla biraz
daha somutlaştırmaya çalışalım:</p>
<p>Hatırlarsanız ‘Kullanıcıyla Veri Alışverişi’ başlıklı bölümde şöyle bir örnek
vermiştik:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">isim</span> <span class="o">=</span> <span class="s2">"Fırat"</span>
<span class="n">soyisim</span> <span class="o">=</span> <span class="s2">"Özgül"</span>
<span class="n">işsis</span> <span class="o">=</span> <span class="s2">"Ubuntu"</span>
<span class="n">şehir</span> <span class="o">=</span> <span class="s2">"İstanbul"</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"isim : "</span><span class="p">,</span> <span class="n">isim</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"soyisim : "</span><span class="p">,</span> <span class="n">soyisim</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"işletim sistemi: "</span><span class="p">,</span> <span class="n">işsis</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"şehir : "</span><span class="p">,</span> <span class="n">şehir</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu programı çalıştırdığımızda şöyle bir çıktı alıyoruz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">isim</span> <span class="p">:</span> <span class="n">Fırat</span>
<span class="n">soyisim</span> <span class="p">:</span> <span class="n">Özgül</span>
<span class="n">işletim</span> <span class="n">sistemi</span><span class="p">:</span> <span class="n">Ubuntu</span>
<span class="n">şehir</span> <span class="p">:</span> <span class="n">İstanbul</span>
</pre></div>
</div>
<p>Bu program, belli değerleri kullanarak bir kayıt oluşturma işlemi
gerçekleştiriyor. Mesela yukarıdaki örnekte, ‘Fırat Özgül’ adlı şahsa ait isim,
soyisim, işletim sistemi ve şehir bilgilerini alarak, bu kişi için bir kayıt
oluşturuyoruz.</p>
<p>Peki ‘Fırat Özgül’ adlı kişinin yanısıra, ‘Mehmet Öztaban’ adlı başka bir kişi
için de kayıt oluşturmak istersek ne yapacağız?</p>
<p>Aklınıza şöyle bir şey yazmak gelmiş olabilir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">isim1</span> <span class="o">=</span> <span class="s2">"Fırat"</span>
<span class="n">soyisim1</span> <span class="o">=</span> <span class="s2">"Özgül"</span>
<span class="n">işsis1</span> <span class="o">=</span> <span class="s2">"Ubuntu"</span>
<span class="n">şehir1</span> <span class="o">=</span> <span class="s2">"İstanbul"</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"isim : "</span><span class="p">,</span> <span class="n">isim1</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"soyisim : "</span><span class="p">,</span> <span class="n">soyisim1</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"işletim sistemi: "</span><span class="p">,</span> <span class="n">işsis1</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"şehir : "</span><span class="p">,</span> <span class="n">şehir1</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"-"</span><span class="o">*</span><span class="mi">30</span><span class="p">)</span>
<span class="n">isim2</span> <span class="o">=</span> <span class="s2">"Mehmet"</span>
<span class="n">soyisim2</span> <span class="o">=</span> <span class="s2">"Öztaban"</span>
<span class="n">işsis2</span> <span class="o">=</span> <span class="s2">"Debian"</span>
<span class="n">şehir2</span> <span class="o">=</span> <span class="s2">"Ankara"</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"isim : "</span><span class="p">,</span> <span class="n">isim2</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"soyisim : "</span><span class="p">,</span> <span class="n">soyisim2</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"işletim sistemi: "</span><span class="p">,</span> <span class="n">işsis2</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"şehir : "</span><span class="p">,</span> <span class="n">şehir2</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"-"</span><span class="o">*</span><span class="mi">30</span><span class="p">)</span>
</pre></div>
</div>
<p>Programa her yeni kayıt eklenişinde, her yeni kişi için benzer satırları tekrar
tekrar yazabilirsiniz. Peki ama bu yöntem sizce de çok sıkıcı değil mi? Üstelik
bir o kadar da hataya açık bir yöntem. Muhtemelen ilk kaydı ekledikten sonra,
ikinci kaydı eklerken birinci kayıttaki bilgileri kopyalayıp, bu kopya üzerinden
ikinci kaydı oluşturuyorsunuz. Hatta muhtemelen kopyalayıp yapıştırdıktan sonra
yeni kaydı düzenlerken bazı hatalar da yapıyor ve düzgün çalışan bir program
elde edebilmek için o hataları düzeltmekle de uğraşıyorsunuz.</p>
<p>Bütün bu işleri kolaylaştıracak bir çözüm olsa ve bizi aynı şeyleri tekrar
tekrar yazmaktan kurtarsa sizce de çok güzel olmaz mıydı? Mesela tıpkı
<code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu gibi, <code class="docutils literal notranslate"><span class="pre">kayıt_oluştur()</span></code> adlı bir fonksiyon olsa, biz
sadece gerekli bilgileri bu fonksiyonun parantezleri içine parametre olarak
yazsak ve bu fonksiyon bize istediğimiz bilgileri içeren bir kayıt oluştursa ne
hoş olurdu, değil mi? Yani örneğin bahsettiğimiz bu hayali <code class="docutils literal notranslate"><span class="pre">kayıt_oluştur()</span></code>
fonksiyonunu şu şekilde kullanabilseydik…</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kayıt_oluştur</span><span class="p">(</span><span class="s2">"Mehmet"</span><span class="p">,</span> <span class="s2">"Öztaban"</span><span class="p">,</span> <span class="s2">"Debian"</span><span class="p">,</span> <span class="s2">"Ankara"</span><span class="p">)</span>
</pre></div>
</div>
<p>… ve bu komut bize şu çıktıyı verebilseydi…</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="o">------------------------------</span>
<span class="n">isim</span> <span class="p">:</span> <span class="n">Mehmet</span>
<span class="n">soyisim</span> <span class="p">:</span> <span class="n">Öztaban</span>
<span class="n">işletim</span> <span class="n">sistemi</span><span class="p">:</span> <span class="n">Debian</span>
<span class="n">şehir</span> <span class="p">:</span> <span class="n">Ankara</span>
<span class="o">------------------------------</span>
</pre></div>
</div>
<p>… ne kadar güzel olurdu, değil mi?</p>
<p>İşte böyle bir şey Python’da mümkündür. Nasıl Python geliştiricileri
<code class="docutils literal notranslate"><span class="pre">print()</span></code>, <code class="docutils literal notranslate"><span class="pre">input()</span></code> ve benzeri fonksiyonları tanımlayıp, karmaşık işlemleri
tek adımda yapabilmemiz için bize sunmuş ve böylece bizi her defasında tekerleği
yeniden icat etme külfetinden kurtarmışsa, biz de kendi fonksiyonlarımızı
tanımlayarak, kendimizi aynı işlemleri tekrar tekrar yapma zahmetinden
kurtarabiliriz.</p>
<p>Gelin şimdi bu işi nasıl yapabileceğimizi tartışalım.</p>
</div>
<div class="section" id="fonksiyon-tanimlamak-ve-cagirmak">
<h2>Fonksiyon Tanımlamak ve Çağırmak<a class="headerlink" href="#fonksiyon-tanimlamak-ve-cagirmak" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Bir önceki bölümde, <code class="docutils literal notranslate"><span class="pre">kayıt_oluştur()</span></code> adlı hayali bir fonksiyondan söz
etmiştik. Tasarımıza göre bu fonksiyon şu şekilde kullanılacak:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kayıt_oluştur</span><span class="p">(</span><span class="s2">"Ahmet"</span><span class="p">,</span> <span class="s2">"Gür"</span><span class="p">,</span> <span class="s2">"Pardus"</span><span class="p">,</span> <span class="s2">"İzmir"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu komutu verdiğimizde ise şöyle bir çıktı almayı planlıyoruz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="o">------------------------------</span>
<span class="n">isim</span> <span class="p">:</span> <span class="n">Ahmet</span>
<span class="n">soyisim</span> <span class="p">:</span> <span class="n">Gür</span>
<span class="n">işletim</span> <span class="n">sistemi</span><span class="p">:</span> <span class="n">Pardus</span>
<span class="n">şehir</span> <span class="p">:</span> <span class="n">İzmir</span>
<span class="o">------------------------------</span>
</pre></div>
</div>
<p>Dediğimiz gibi, böyle bir şey yapmak Python’la mümkündür. Ancak tabii ki
<code class="docutils literal notranslate"><span class="pre">kayıt_oluştur()</span></code> adlı böyle bir fonksiyonu kullanabilmenin belli ön koşulları
var. Nasıl <cite>sayı</cite> adlı bir değişkeni kullanabilmek için öncelikle bu ada sahip
bir değişken tanımlamış olmamız gerekiyorsa, aynı şekilde <code class="docutils literal notranslate"><span class="pre">kayıt_oluştur()</span></code>
adlı bir fonksiyonu kullanabilmek için de öncelikle bu ada sahip bir fonksiyonu
tanımlamış olmamız gerekiyor. Zira mesela <code class="docutils literal notranslate"><span class="pre">input()</span></code> ve <code class="docutils literal notranslate"><span class="pre">print()</span></code> gibi
fonksiyonları kullanabiliyor olmamız, Python geliştiricilerinin bu fonksiyonları
tanımlayıp dilin içine gömmüş olmaları sayesindedir.</p>
<p>İşte biz de <code class="docutils literal notranslate"><span class="pre">kayıt_oluştur()</span></code> adlı fonksiyonu kullanabilmek için bu ada sahip
fonksiyonu aşağıdaki şekilde tanımlamalıyız:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">kayıt_oluştur</span><span class="p">(</span><span class="n">isim</span><span class="p">,</span> <span class="n">soyisim</span><span class="p">,</span> <span class="n">işsis</span><span class="p">,</span> <span class="n">şehir</span><span class="p">):</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"-"</span><span class="o">*</span><span class="mi">30</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"isim : "</span><span class="p">,</span> <span class="n">isim</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"soyisim : "</span><span class="p">,</span> <span class="n">soyisim</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"işletim sistemi: "</span><span class="p">,</span> <span class="n">işsis</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"şehir : "</span><span class="p">,</span> <span class="n">şehir</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"-"</span><span class="o">*</span><span class="mi">30</span><span class="p">)</span>
</pre></div>
</div>
<p>İlk bakışta bu kodlar size hiçbir şey ifade etmemiş olabilir. Ama hiç endişe
etmeyin. Biz birazdan bu satırların ne anlama geldiğini bütün ayrıntılarıyla
anlatacağız. Siz şimdilik anlamadığınız kısımları görmezden gelip okumaya devam
edin.</p>
<p>Yukarıdaki kodlar yardımıyla fonksiyonumuzu tanımlamış olduk. Artık elimizde,
tıpkı <code class="docutils literal notranslate"><span class="pre">print()</span></code> veya <code class="docutils literal notranslate"><span class="pre">input()</span></code> gibi, <code class="docutils literal notranslate"><span class="pre">kayıt_oluştur()</span></code> adlı ‘ev yapımı’
bir fonksiyon var. Dolayısıyla bu yeni fonksiyonumuzu, daha önce öğrendiğimiz
fonksiyonları nasıl kullanıyorsak aynı şekilde kullanabiliriz. Yani aşağıdaki
gibi komutlar yazabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kayıt_oluştur</span><span class="p">(</span><span class="s2">"Fırat"</span><span class="p">,</span> <span class="s2">"Özgül"</span><span class="p">,</span> <span class="s2">"Ubuntu"</span><span class="p">,</span> <span class="s2">"İstanbul"</span><span class="p">)</span>
<span class="n">kayıt_oluştur</span><span class="p">(</span><span class="s2">"Mehmet"</span><span class="p">,</span> <span class="s2">"Öztaban"</span><span class="p">,</span> <span class="s2">"Debian"</span><span class="p">,</span> <span class="s2">"Ankara"</span><span class="p">)</span>
</pre></div>
</div>
<p>Yalnız fonksiyonumuzu tanımlayıp bitirdikten sonra, bu fonksiyonu kullanırken,
kodlarımızın hizalamasına dikkat ediyoruz. Fonksiyonu kullanmak için yazdığımız
kodları <cite>def</cite> ifadesinin hizasına getiriyoruz. Yani:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">kayıt_oluştur</span><span class="p">(</span><span class="n">isim</span><span class="p">,</span> <span class="n">soyisim</span><span class="p">,</span> <span class="n">işsis</span><span class="p">,</span> <span class="n">şehir</span><span class="p">):</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"-"</span><span class="o">*</span><span class="mi">30</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"isim : "</span><span class="p">,</span> <span class="n">isim</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"soyisim : "</span><span class="p">,</span> <span class="n">soyisim</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"işletim sistemi: "</span><span class="p">,</span> <span class="n">işsis</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"şehir : "</span><span class="p">,</span> <span class="n">şehir</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"-"</span><span class="o">*</span><span class="mi">30</span><span class="p">)</span>
<span class="n">kayıt_oluştur</span><span class="p">(</span><span class="s2">"Fırat"</span><span class="p">,</span> <span class="s2">"Özgül"</span><span class="p">,</span> <span class="s2">"Ubuntu"</span><span class="p">,</span> <span class="s2">"İstanbul"</span><span class="p">)</span>
<span class="n">kayıt_oluştur</span><span class="p">(</span><span class="s2">"Mehmet"</span><span class="p">,</span> <span class="s2">"Öztaban"</span><span class="p">,</span> <span class="s2">"Debian"</span><span class="p">,</span> <span class="s2">"Ankara"</span><span class="p">)</span>
</pre></div>
</div>
<p>Yukarıdaki yapıyı kullanarak, istediğiniz sayıda kayıt oluşturabilirsiniz. Mesela:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kayıt_oluştur</span><span class="p">(</span><span class="s2">"İlkay"</span><span class="p">,</span> <span class="s2">"Kaya"</span><span class="p">,</span> <span class="s2">"Mint"</span><span class="p">,</span> <span class="s2">"Adana"</span><span class="p">)</span>
<span class="n">kayıt_oluştur</span><span class="p">(</span><span class="s2">"Seda"</span><span class="p">,</span> <span class="s2">"Kara"</span><span class="p">,</span> <span class="s2">"SuSe"</span><span class="p">,</span> <span class="s2">"Erzurum"</span><span class="p">)</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, yukarıdaki yöntem sayesinde kodlarımızdaki tekrar eden kısımlar
ortadan kalktı. Yukarıdaki fonksiyonun bize nasıl bir kolaylık sağladığını daha
net görebilmek için, fonksiyon kullanarak sadece şu <cite>11</cite> satırla elde ettiğimiz
çıktıyı, fonksiyon kullanmadan elde etmeyi deneyebilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">kayıt_oluştur</span><span class="p">(</span><span class="n">isim</span><span class="p">,</span> <span class="n">soyisim</span><span class="p">,</span> <span class="n">işsis</span><span class="p">,</span> <span class="n">şehir</span><span class="p">):</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"-"</span><span class="o">*</span><span class="mi">30</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"isim : "</span><span class="p">,</span> <span class="n">isim</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"soyisim : "</span><span class="p">,</span> <span class="n">soyisim</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"işletim sistemi: "</span><span class="p">,</span> <span class="n">işsis</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"şehir : "</span><span class="p">,</span> <span class="n">şehir</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"-"</span><span class="o">*</span><span class="mi">30</span><span class="p">)</span>
<span class="n">kayıt_oluştur</span><span class="p">(</span><span class="s2">"Fırat"</span><span class="p">,</span> <span class="s2">"Özgül"</span><span class="p">,</span> <span class="s2">"Ubuntu"</span><span class="p">,</span> <span class="s2">"İstanbul"</span><span class="p">)</span>
<span class="n">kayıt_oluştur</span><span class="p">(</span><span class="s2">"Mehmet"</span><span class="p">,</span> <span class="s2">"Öztaban"</span><span class="p">,</span> <span class="s2">"Debian"</span><span class="p">,</span> <span class="s2">"Ankara"</span><span class="p">)</span>
<span class="n">kayıt_oluştur</span><span class="p">(</span><span class="s2">"İlkay"</span><span class="p">,</span> <span class="s2">"Kaya"</span><span class="p">,</span> <span class="s2">"Mint"</span><span class="p">,</span> <span class="s2">"Adana"</span><span class="p">)</span>
<span class="n">kayıt_oluştur</span><span class="p">(</span><span class="s2">"Seda"</span><span class="p">,</span> <span class="s2">"Kara"</span><span class="p">,</span> <span class="s2">"SuSe"</span><span class="p">,</span> <span class="s2">"Erzurum"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu anlattıklarımız size çok karmaşık gelmiş olabilir. Ama endişe etmenize hiç
gerek yok. Biraz sonra, yukarıda yazdığımız kodların hepsini didik didik
edeceğiz. Ama öncelikle yukarıdaki kod parçasını yapısal olarak bir incelemenizi
istiyorum. Fonksiyonu tanımladığımız aşağıdaki kod parçasına şöyle bir
baktığınızda neler görüyorsunuz?</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">kayıt_oluştur</span><span class="p">(</span><span class="n">isim</span><span class="p">,</span> <span class="n">soyisim</span><span class="p">,</span> <span class="n">işsis</span><span class="p">,</span> <span class="n">şehir</span><span class="p">):</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"-"</span><span class="o">*</span><span class="mi">30</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"isim : "</span><span class="p">,</span> <span class="n">isim</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"soyisim : "</span><span class="p">,</span> <span class="n">soyisim</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"işletim sistemi: "</span><span class="p">,</span> <span class="n">işsis</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"şehir : "</span><span class="p">,</span> <span class="n">şehir</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"-"</span><span class="o">*</span><span class="mi">30</span><span class="p">)</span>
<span class="n">kayıt_oluştur</span><span class="p">(</span><span class="s2">"Fırat"</span><span class="p">,</span> <span class="s2">"Özgül"</span><span class="p">,</span> <span class="s2">"Ubuntu"</span><span class="p">,</span> <span class="s2">"İstanbul"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu kodları incelediğinizde şu noktalar dikkatinizi çekiyor olmalı:</p>
<ol class="arabic simple">
<li><p>Kodlar <cite>def</cite> adlı bir ifade ile başlamış.</p></li>
<li><p>Bunun ardından ‘kayıt_oluştur’ ifadesini görüyoruz.</p></li>
<li><p>Bu ifadeyi, içinde birtakım kelimeler barındıran bir parantez çifti izliyor.</p></li>
<li><p>Parantezin içinde, <cite>isim</cite>, <cite>soyisim</cite>, <cite>işsis</cite> ve <cite>şehir</cite> adlı değerler var.</p></li>
<li><p><cite>def</cite> ile başlayan bu satır iki nokta üst üste işareti ile son buluyor.</p></li>
<li><p>İlk satırın ardından gelen kısım ilk satıra göre girintili bir şekilde yazılmış.</p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">kayıt_oluştur("Fırat",</span> <span class="pre">"Özgül",</span> <span class="pre">"Ubuntu",</span> <span class="pre">"İstanbul")</span></code> satırı önceki
satırlara göre girintisiz yazılmış.</p></li>
</ol>
<p>Eğer bu kodlara dikkatlice bakacak olursanız, aslında bu kodların topu topu iki
parçadan oluştuğunu göreceksiniz. İsterseniz yukarıdaki yapıyı biraz
sadeleştirelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">kayıt_oluştur</span><span class="p">(</span><span class="n">parametre1</span><span class="p">,</span> <span class="n">parametre2</span><span class="p">,</span> <span class="n">parametre3</span><span class="p">,</span> <span class="n">parametre4</span><span class="p">):</span>
<span class="p">(</span><span class="o">...</span><span class="p">)</span>
<span class="n">kayıt_oluştur</span><span class="p">(</span><span class="n">parametre1</span><span class="p">,</span> <span class="n">parametre2</span><span class="p">,</span> <span class="n">parametre3</span><span class="p">,</span> <span class="n">parametre4</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu yapının ilk parçası şudur:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">kayıt_oluştur</span><span class="p">(</span><span class="n">parametre1</span><span class="p">,</span> <span class="n">parametre2</span><span class="p">,</span> <span class="n">parametre3</span><span class="p">,</span> <span class="n">parametre4</span><span class="p">):</span>
<span class="p">(</span><span class="o">...</span><span class="p">)</span>
</pre></div>
</div>
<p>İkinci parçası ise şu:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kayıt_oluştur</span><span class="p">(</span><span class="n">parametre1</span><span class="p">,</span> <span class="n">parametre2</span><span class="p">,</span> <span class="n">parametre3</span><span class="p">,</span> <span class="n">parametre4</span><span class="p">)</span>
</pre></div>
</div>
<p>Teknik olarak söylemek gerekirse, ilk parçaya ‘fonksiyon tanımı’ (<em>function
definition</em>), ikinci parçaya ise ‘fonksiyon çağrısı’ (<em>function call</em>) adı
verilir. Dolayısıyla bir fonksiyonun yaşam döngüsü iki aşamadan oluşur. Buna
göre bir fonksiyon önce tanımlanır;</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">kayıt_oluştur</span><span class="p">(</span><span class="n">parametre1</span><span class="p">,</span> <span class="n">parametre2</span><span class="p">,</span> <span class="n">parametre3</span><span class="p">,</span> <span class="n">parametre4</span><span class="p">):</span>
<span class="p">(</span><span class="o">...</span><span class="p">)</span>
</pre></div>
</div>
<p>…sonra da çağrılır;</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kayıt_oluştur</span><span class="p">(</span><span class="n">parametre1</span><span class="p">,</span> <span class="n">parametre2</span><span class="p">,</span> <span class="n">parametre3</span><span class="p">,</span> <span class="n">parametre4</span><span class="p">)</span>
</pre></div>
</div>
<p>Aslında biz şimdiye kadar gördüğümüz <code class="docutils literal notranslate"><span class="pre">print()</span></code>, <code class="docutils literal notranslate"><span class="pre">type()</span></code>, <code class="docutils literal notranslate"><span class="pre">open()</span></code> vb.
fonksiyonlarda bu ‘fonksiyon çağrısı’ kısmıyla zaten tanışmıştık. Zira şu komut
tam anlamıyla bir fonksiyon çağrısıdır (yani bir fonksiyon çağırma işlemidir):</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="s2">"Fırat"</span><span class="p">,</span> <span class="s2">"Özgül"</span><span class="p">,</span> <span class="s2">"Adana"</span><span class="p">,</span> <span class="mi">32</span><span class="p">)</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, yukarıdaki komutun yapı olarak şu komuttan hiçbir farkı yok:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kayıt_oluştur</span><span class="p">(</span><span class="s2">"Fırat"</span><span class="p">,</span> <span class="s2">"Özgül"</span><span class="p">,</span> <span class="s2">"Ubuntu"</span><span class="p">,</span> <span class="s2">"İstanbul"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu iki fonksiyon arasındaki tek fark, <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunu Python
geliştiricilerinin; <code class="docutils literal notranslate"><span class="pre">kayıt_oluştur()</span></code> fonksiyonunu ise sizin tanımlamış
olmanızdır.</p>
<p>Elbette bu iki fonksiyon yapı olarak birbirinin aynı olsa da, işlev olarak
birbirinden farklıdır. <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunun görevi kendisine parametre
olarak verilen değerleri ekrana çıktı vermek iken, <code class="docutils literal notranslate"><span class="pre">kayıt_oluştur()</span></code>
fonksiyonunun görevi kendisine parametre olarak verilen değerleri kullanarak bir
kayıt oluşturmaktır.</p>
<p>Bu derse gelinceye kadar öğrendiğimiz <code class="docutils literal notranslate"><span class="pre">print()</span></code>, <code class="docutils literal notranslate"><span class="pre">type()</span></code> ve <code class="docutils literal notranslate"><span class="pre">open()</span></code> gibi
fonksiyonlara teknik olarak ‘gömülü fonksiyonlar’ (<em>builtin functions</em>) adı
verilir. Bu fonksiyonlara bu adın verilmiş olmasının sebebi, bu fonksiyonların
gerçekten de Python programlama dili içine gömülü bir vaziyette olmalarıdır.
Dikkat ederseniz kendi yazdığımız fonksiyonları kullanabilmek için öncelikle
fonksiyonu tanımlamamız gerekiyor. Gömülü fonksiyonlar ise Python
geliştiricileri tarafından halihazırda tanımlanmış olduğu için bunları biz
herhangi bir tanımlama işlemi yapmaya gerek kalmadan doğrudan çağırabiliyoruz.</p>
<p>Böylece bir fonksiyonun yapı olarak neye benzediğini üstünkörü de olsa incelemiş
olduk. Buraya kadar anlatılan kısımda bazı noktaları anlamakta zorlanmış
olabilirsiniz. Eğer öyleyse hiç endişelenmeyin. Bu gayet doğal.</p>
<p>Gelin isterseniz şimdi yukarıda anlattıklarımızın içini doldurmaya çalışalım.</p>
</div>
<div class="section" id="fonksiyonlarin-yapisi">
<h2>Fonksiyonların Yapısı<a class="headerlink" href="#fonksiyonlarin-yapisi" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>İsterseniz biraz da fonksiyonların yapısından söz edelim. Böylelikle ne ile
karşı karşıya olduğumuzu anlamak zihninizde biraz daha kolaylaşır.</p>
<p>Dedik ki, bir fonksiyonun ilk parçasına ‘fonksiyon tanımı’ (<em>function
definition</em>) adı verilir. Bir fonksiyonu tanımlamak için <cite>def</cite> adlı bir
parçacıktan yararlanıyoruz. Örneğin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">bir_fonksiyon</span><span class="p">():</span>
<span class="p">(</span><span class="o">...</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada <cite>def</cite> parçacığı, tanımladığımız şeyin bir fonksiyon olduğunu gösteriyor.
<cite>bir_fonksiyon</cite> ifadesi ise tanımladığımız bu fonksiyonun adıdır. Fonksiyonu
tanımladıktan sonra, çağırırken bu adı kullanacağız.</p>
<p><code class="docutils literal notranslate"><span class="pre">def</span> <span class="pre">bir_fonksiyon():</span></code> ifadesinin sonundaki iki nokta işaretinden de tahmin
edebileceğiniz gibi, sonraki satıra yazacağımız kodlar girintili olacak. Yani
mesela:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">selamla</span><span class="p">():</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Elveda Zalim Dünya!"</span><span class="p">)</span>
</pre></div>
</div>
<p>Yukarıda <code class="docutils literal notranslate"><span class="pre">selamla()</span></code> adlı bir fonksiyon tanımlamış olduk. Bu fonksiyonun
görevi ekrana <cite>Elveda Zalim Dünya!</cite> çıktısı vermektir.</p>
<p>Bu noktada şöyle bir soru akla geliyor: Acaba fonksiyon gövdesindeki kısım için
ne kadarlık bir girinti oluşturacağız?</p>
<p>Girintilemeye ilişkin olarak önceki derslerde bahsettiğimiz bütün kurallar
burada da geçerlidir. Fonksiyon gövdesine, <cite>def</cite> ifadesinden itibaren <cite>4</cite> (dört)
boşlukluk bir girinti veriyoruz. <cite>def</cite> ifadesinden itibaren girintili olarak
yazdığımız kısmın tamamı o fonksiyonun gövdesini oluşturur ve bütünüyle o
fonksiyona aittir.</p>
<p>Bu kodlarla yaptığımız şey bir fonksiyon tanımlama işlemidir. Eğer bu kodları
bir dosyaya kaydedip çalıştırırsak herhangi bir çıktı almayız. Çünkü henüz
fonksiyonumuzu çağırmadık. Bu durumu <code class="docutils literal notranslate"><span class="pre">print()</span></code>, <code class="docutils literal notranslate"><span class="pre">input()</span></code> ve benzeri gömülü
fonksiyonlara benzetebilirsiniz. Tıpkı yukarıda bizim yaptığımız gibi, gömülü
fonksiyonlar da Python geliştiricileri tarafından bir yerlerde tanımlanmış
vaziyette dururlar, ama biz bu fonksiyonları yazdığımız programlarda çağırana
kadar bu fonksiyonlar çalışmaz.</p>
<p>Daha önce de dediğimiz gibi, bir fonksiyonun yaşam döngüsü iki aşamadan oluşur:
Fonksiyon tanımı ve fonksiyon çağrısı. Yukarıda bu döngünün sadece fonksiyon
tanımı aşaması mevcut. Unutmayın, bir fonksiyon çağrılmadan asla çalışmaz. Bir
fonksiyonun çalışabilmesi için o fonksiyonun tanımlandıktan sonra çağrılması
gerekir. Örneğin <code class="docutils literal notranslate"><span class="pre">input()</span></code> fonksiyonu Python’ın derinliklerinde bir yerlerde
tanımlanmış vaziyette durur. Bu fonksiyon, biz onu çağırana kadar, bulunduğu
yerde sessizce bekler. Aynı şekilde <code class="docutils literal notranslate"><span class="pre">selamla()</span></code> adlı fonksiyon da programımız
içinde tanımlanmış vaziyette, bizim onu çağıracağımız anı bekliyor. Bu
söylediklerimizi destekleyecek açıklayıcı bilgileri biraz sonra vereceğiz. Biz
şimdilik fonksiyon tanımı kısmını incelemeye devam edelim.</p>
<p>Bu arada yukarıdaki fonksiyon tanımının yapısına çok dikkat edin. İki nokta üst
üste işaretinden sonraki satırda girintili olarak yazılan bütün kodlar (yani
fonksiyonun gövde kısmı) fonksiyonun bir parçasıdır. Girintinin dışına çıkıldığı
anda fonksiyon tanımlama işlemi de sona erer.</p>
<p>Örneğin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">selamla</span><span class="p">():</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Elveda Zalim Dünya!"</span><span class="p">)</span>
<span class="n">selamla</span><span class="p">()</span>
</pre></div>
</div>
<p>İşte burada fonksiyonumuzu çağırmış olduk. Dikkat edin! Dediğim gibi, iki nokta
üst üste işaretinden sonraki satırda girintili olarak yazılan bütün kodlar
fonksiyona aittir. <code class="docutils literal notranslate"><span class="pre">selamla()</span></code> satırı ise fonksiyon tanımının dışında yer
alır. Bu satırla birlikte girintinin dışına çıkıldığı için artık fonksiyon
tanımlama safhası sona ermiş oldu.</p>
<p>Biz yukarıdaki örnekte, <code class="docutils literal notranslate"><span class="pre">selamla()</span></code> adlı fonksiyonu tanımlar tanımlamaz
çağırmayı tercih ettik. Ama elbette siz bir fonksiyonu tanımlar tanımlamaz
çağırmak zorunda değilsiniz. Yazdığınız bir program içinde fonksiyonlarınızı
tanımladıktan sonra, ihtiyacınıza bağlı olarak, programın herhangi başka bir
yerinde fonksiyonlarınızı çağırabilirsiniz.</p>
<p>Fonksiyonlarla ilgili söylediklerimizi toparlayacak olursak şöyle bir bilgi
listesi ortaya çıkarabiliriz:</p>
<ol class="arabic simple">
<li><p>Python’da kabaca iki tip fonksiyon bulunur. Bunlardan biri gömülü
fonksiyonlar (<em>builtin functions</em>), öteki ise özel fonksiyonlardır (<em>custom
functions</em>). Burada ‘özel’ ifadesi, ‘kullanıcının ihtiyaçlarına göre
kullanıcı tarafından özel olarak üretilmiş’ anlamına gelir.</p></li>
<li><p>Gömülü fonksiyonlar; Python geliştiricileri tarafından tanımlanıp dilin
içine gömülmüş olan <code class="docutils literal notranslate"><span class="pre">print()</span></code>, <code class="docutils literal notranslate"><span class="pre">open()</span></code>, <code class="docutils literal notranslate"><span class="pre">type()</span></code>, <code class="docutils literal notranslate"><span class="pre">str()</span></code>,
<code class="docutils literal notranslate"><span class="pre">int()</span></code> vb. fonksiyonlardır. Bu fonksiyonlar halihazırda tanımlanıp
hizmetimize sunulduğu için bunları biz herhangi bir tanımlama işlemi
yapmadan doğrudan kullanabiliriz.</p></li>
<li><p>Özel fonksiyonlar ise, gömülü fonksiyonların aksine, Python
geliştiricileri tarafından değil, bizim tarafımızdan tanımlanmıştır. Bu
fonksiyonlar dilin bir parçası olmadığından, bu fonksiyonları kullanabilmek
için bunları öncelikle tanımlamamız gerekir.</p></li>
<li><p>Python’da bir fonksiyonun yaşam döngüsü iki aşamadan oluşur: Tanımlanma
ve çağrılma.</p></li>
<li><p>Bir fonksiyonun çağrılabilmesi (yani kullanılabilmesi) için mutlaka
birisi tarafından tanımlanmış olması gerekir.</p></li>
<li><p>Fonksiyonu tanımlayan kişi Python geliştiricileri olabileceği gibi, siz
de olabilirsiniz. Ama neticede ortada bir fonksiyon varsa, bir yerlerde o
fonksiyonun tanımı da vardır.</p></li>
<li><p>Fonksiyon tanımlamak için <cite>def</cite> adlı bir ifadeden yararlanıyoruz. Bu
ifadeden sonra, tanımlayacağımız fonksiyonun adını belirleyip iki nokta üst
üste işareti koyuyoruz. İki nokta üst üste işaretinden sonra gelen satırlar
girintili olarak yazılıyor. Daha önce öğrendiğimiz bütün girintileme
kuralları burada da geçerlidir.</p></li>
<li><p>Fonksiyonun adını belirleyip iki nokta üst üste koyduktan sonra, alt
satırda girintili olarak yazdığımız bütün kodlar fonksiyonun gövdesini
oluşturur. Doğal olarak, bir fonksiyonun gövdesindeki bütün kodlar o
fonksiyona aittir. Girintinin dışına çıkıldığı anda fonksiyon tanımı da sona
erer.</p></li>
</ol>
<p>Fonksiyonlarla ilgili öğrendiklerimizi toparladığımıza göre, gelin isterseniz
fonksiyonlarla ilgili bir örnek yaparak, bu yapıyı daha iyi anlamaya çalışalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">sistem_bilgisi_göster</span><span class="p">():</span>
<span class="kn">import</span> <span class="nn">sys</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="se">\n</span><span class="s2">Sistemde kurulu Python'ın;"</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="se">\t</span><span class="s2">ana sürüm numarası:"</span><span class="p">,</span> <span class="n">sys</span><span class="o">.</span><span class="n">version_info</span><span class="o">.</span><span class="n">major</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="se">\t</span><span class="s2">alt sürüm numarası:"</span><span class="p">,</span> <span class="n">sys</span><span class="o">.</span><span class="n">version_info</span><span class="o">.</span><span class="n">minor</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="se">\t</span><span class="s2">minik sürüm numarası:"</span><span class="p">,</span> <span class="n">sys</span><span class="o">.</span><span class="n">version_info</span><span class="o">.</span><span class="n">micro</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="se">\n</span><span class="s2">Kullanılan işletim sisteminin;"</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="se">\t</span><span class="s2">adı:"</span><span class="p">,</span> <span class="n">sys</span><span class="o">.</span><span class="n">platform</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada <code class="docutils literal notranslate"><span class="pre">sistem_bilgisi_göster()</span></code> adlı bir fonksiyon tanımladık. Bu fonksiyonun
görevi, kullanıcının sistemindeki Python sürümü ve işletim sistemine dair
birtakım bilgiler vermektir.</p>
<p>Bu arada, bu kodlarda, daha önceki derslerimizde öğrendiğimiz <cite>sys</cite> modülünden
ve bu modül içindeki değişkenlerden yararlandığımızı görüyorsunuz. Bu kodlarda
<cite>sys</cite> modülünün içindeki şu araçları kullandık:</p>
<ol class="arabic simple">
<li><p><cite>version_info.major</cite>: Python’ın ana sürüm numarası (Örn. 3)</p></li>
<li><p><cite>version_info.minor</cite>: Python’ın alt sürüm numarası (Örn. 4)</p></li>
<li><p><cite>version_info.micro</cite>: Python’ın minik sürüm numarası (Örn. 0)</p></li>
<li><p><cite>platform</cite>: Kullanılan işletim sisteminin adı (Örn. ‘win32’ veya ‘linux2’)</p></li>
</ol>
<p>Yukarıda tanımladığımız fonksiyonu nasıl çağıracağımızı biliyorsunuz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">sistem_bilgisi_göster</span><span class="p">()</span>
</pre></div>
</div>
<p>Bu fonksiyonun tanımını ve çağrısını eksiksiz bir program içinde gösterelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">sistem_bilgisi_göster</span><span class="p">():</span>
<span class="kn">import</span> <span class="nn">sys</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="se">\n</span><span class="s2">Sistemde kurulu Python'ın;"</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="se">\t</span><span class="s2">ana sürüm numarası:"</span><span class="p">,</span> <span class="n">sys</span><span class="o">.</span><span class="n">version_info</span><span class="o">.</span><span class="n">major</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="se">\t</span><span class="s2">alt sürüm numarası:"</span><span class="p">,</span> <span class="n">sys</span><span class="o">.</span><span class="n">version_info</span><span class="o">.</span><span class="n">minor</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="se">\t</span><span class="s2">minik sürüm numarası:"</span><span class="p">,</span> <span class="n">sys</span><span class="o">.</span><span class="n">version_info</span><span class="o">.</span><span class="n">micro</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="se">\n</span><span class="s2">Kullanılan işletim sisteminin;"</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="se">\t</span><span class="s2">adı:"</span><span class="p">,</span> <span class="n">sys</span><span class="o">.</span><span class="n">platform</span><span class="p">)</span>
<span class="n">sistem_bilgisi_göster</span><span class="p">()</span>
</pre></div>
</div>
<p>Bu kodları bir dosyaya kaydedip çalıştırdığımızda şuna benzer bir çıktı
alacağız:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">Sistemde</span> <span class="n">kurulu</span> <span class="n">Python</span><span class="s1">'ın;</span>
<span class="n">ana</span> <span class="n">sürüm</span> <span class="n">numarası</span><span class="p">:</span> <span class="mi">3</span>
<span class="n">alt</span> <span class="n">sürüm</span> <span class="n">numarası</span><span class="p">:</span> <span class="mi">3</span>
<span class="n">minik</span> <span class="n">sürüm</span> <span class="n">numarası</span><span class="p">:</span> <span class="mi">0</span>
<span class="n">Kullanılan</span> <span class="n">işletim</span> <span class="n">sisteminin</span><span class="p">;</span>
<span class="n">adı</span><span class="p">:</span> <span class="n">linux</span>
</pre></div>
</div>
<p>Demek ki bu kodların çalıştırıldığı sistem Python’ın 3.3.0 sürümünün kurulu
olduğu bir GNU/Linux işletim sistemi imiş…</p>
</div>
<div class="section" id="fonksiyonlar-ne-ise-yarar">
<h2>Fonksiyonlar Ne İşe Yarar?<a class="headerlink" href="#fonksiyonlar-ne-ise-yarar" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Şimdiye kadar söylediklerimizden ve verdiğimiz örneklerden fonksiyonların ne işe
yaradığını anlamış olmalısınız. Ama biz yine de fonksiyonların faydası üzerine
birkaç söz daha söyleyelim. Böylece fonksiyonların ne işe yaradığı konusunda
aklımızda hiçbir şüphe kalmaz…</p>
<p>İsterseniz bir örnek üzerinden ilerleyelim.</p>
<p>Diyelim ki, bir sayının karesini bulan bir program yazmak istiyoruz. Şimdiye
kadarki bilgilerimizi kullanarak şöyle bir şey yazabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">sayı</span> <span class="o">=</span> <span class="mi">12</span>
<span class="n">çıktı</span> <span class="o">=</span> <span class="s2">"</span><span class="si">{}</span><span class="s2"> sayısının karesi </span><span class="si">{}</span><span class="s2"> sayısıdır"</span>
<span class="nb">print</span><span class="p">(</span><span class="n">çıktı</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">sayı</span><span class="p">,</span> <span class="n">sayı</span><span class="o">**</span><span class="mi">2</span><span class="p">))</span>
</pre></div>
</div>
<p>Yukarıdaki programı çalıştırdığımızda şöyle bir çıktı elde edeceğiz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="mi">12</span> <span class="n">sayısının</span> <span class="n">karesi</span> <span class="mi">144</span> <span class="n">sayısıdır</span>
</pre></div>
</div>
<p>Gayet güzel. Şimdi şöyle bir durum hayal edin: Diyelim ki büyük bir program
içinde, farklı farklı yerlerde yukarıdaki işlemi tekrar tekrar yapmak
istiyorsunuz. Böyle bir durumda şöyle bir şey yazmanız gerekebilir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">sayı</span> <span class="o">=</span> <span class="mi">12</span>
<span class="n">çıktı</span> <span class="o">=</span> <span class="s2">"</span><span class="si">{}</span><span class="s2"> sayısının karesi </span><span class="si">{}</span><span class="s2"> sayısıdır"</span>
<span class="nb">print</span><span class="p">(</span><span class="n">çıktı</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">sayı</span><span class="p">,</span> <span class="n">sayı</span><span class="o">**</span><span class="mi">2</span><span class="p">))</span>
<span class="c1">####programla ilgili başka kodlar###</span>
<span class="n">sayı</span> <span class="o">=</span> <span class="mi">15</span>
<span class="nb">print</span><span class="p">(</span><span class="n">çıktı</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">sayı</span><span class="p">,</span> <span class="n">sayı</span><span class="o">**</span><span class="mi">2</span><span class="p">))</span>
<span class="c1">###programla ilgili başka kodlar###</span>
<span class="n">sayı</span> <span class="o">=</span> <span class="mi">29</span>
<span class="nb">print</span><span class="p">(</span><span class="n">çıktı</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">sayı</span><span class="p">,</span> <span class="n">sayı</span><span class="o">**</span><span class="mi">2</span><span class="p">))</span>
</pre></div>
</div>
<p>Buradaki sorun, aynı şeyleri tekrar tekrar yazmak zorunda kalmamızdır. Bu küçük
örnekte pek belli olmuyor olabilir, ama özellikle büyük programlarda aynı
kodların program içinde sürekli olarak tekrarlanması pek çok probleme yol açar.
Örneğin kodlarda bir değişiklik yapmak istediğinizde, tekrarlanan kısımları
bulup hepsinin üzerinde tek tek değişiklik yapmanız gerekir. Mesela <cite>çıktı</cite> adlı
değişkenin içeriğini değiştirmek isterseniz, yaptığınız değişiklik programınızın
pek çok kısmını etkileyebilir. Örneğin, <cite>çıktı</cite> değişkenini şu şekle
getirdiğinizi düşünün:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">çıktı</span> <span class="o">=</span> <span class="s2">"</span><span class="si">{}</span><span class="s2"> sayısının karesi </span><span class="si">{}</span><span class="s2">, karekökü </span><span class="si">{}</span><span class="s2"> sayısıdır"</span>
</pre></div>
</div>
<p>Böyle bir durumda, program içinde geçen bütün <code class="docutils literal notranslate"><span class="pre">print(çıktı.format(sayı,</span>
<span class="pre">sayı**2))</span></code> satırlarını bulup, üçüncü <cite>{}</cite> işaretine ait işlemi parantez içine
eklemeniz gerekir. Tahmin edebileceğiniz gibi, son derece sıkıcı, yorucu ve
üstelik hata yapmaya açık bir işlemdir bu. İşte bu tür problemlere karşı
fonksiyonlar çok iyi bir çözümdür.</p>
<p>Yukarıda bahsettiğimiz kare bulma işlemi için şu şekilde basit bir fonksiyon
tanımlayabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">kare_bul</span><span class="p">():</span>
<span class="n">sayı</span> <span class="o">=</span> <span class="mi">12</span>
<span class="n">çıktı</span> <span class="o">=</span> <span class="s2">"</span><span class="si">{}</span><span class="s2"> sayısının karesi </span><span class="si">{}</span><span class="s2"> sayısıdır"</span>
<span class="nb">print</span><span class="p">(</span><span class="n">çıktı</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">sayı</span><span class="p">,</span> <span class="n">sayı</span><span class="o">**</span><span class="mi">2</span><span class="p">))</span>
</pre></div>
</div>
<p>Bu fonksiyonu tanımladık. Şimdi de fonksiyonumuzu çağıralım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kare_bul</span><span class="p">()</span>
</pre></div>
</div>
<p>Kodlarımız tam olarak şöyle görünüyor:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">kare_bul</span><span class="p">():</span>
<span class="n">sayı</span> <span class="o">=</span> <span class="mi">12</span>
<span class="n">çıktı</span> <span class="o">=</span> <span class="s2">"</span><span class="si">{}</span><span class="s2"> sayısının karesi </span><span class="si">{}</span><span class="s2"> sayısıdır"</span>
<span class="nb">print</span><span class="p">(</span><span class="n">çıktı</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">sayı</span><span class="p">,</span> <span class="n">sayı</span><span class="o">**</span><span class="mi">2</span><span class="p">))</span>
<span class="n">kare_bul</span><span class="p">()</span>
</pre></div>
</div>
<p>Burada fonksiyonumuz <code class="docutils literal notranslate"><span class="pre">def</span> <span class="pre">kare_bul():</span></code> satırıyla başlıyor,
<code class="docutils literal notranslate"><span class="pre">print(çıktı.format(sayı,</span> <span class="pre">sayı**2))</span></code> satırıyla bitiyor. Daha sonra gelen
<code class="docutils literal notranslate"><span class="pre">kare_bul()</span></code> kodu, girintinin dışında yer aldığı için fonksiyon tanımına ait
değildir.</p>
<p>Bu kodları bir dosyaya kaydedip çalıştırdığımızda alacağımız çıktı şu
olacaktır:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="mi">12</span> <span class="n">sayısının</span> <span class="n">karesi</span> <span class="mi">144</span> <span class="n">sayısıdır</span>
</pre></div>
</div>
<p><code class="docutils literal notranslate"><span class="pre">kare_bul()</span></code> adlı fonksiyonu bir kez tanımladıktan sonra bu fonksiyonu
programınız içinde gereken her yerde çağırabilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kare_bul</span><span class="p">()</span>
<span class="c1">####programla ilgili başka kodlar###</span>
<span class="n">kare_bul</span><span class="p">()</span>
<span class="c1">###programla ilgili başka kodlar###</span>
<span class="n">kare_bul</span><span class="p">()</span>
</pre></div>
</div>
<p>Gördüğünüz gibi <code class="docutils literal notranslate"><span class="pre">kare_bul()</span></code> adlı bu fonksiyon bizi pek çok zahmetten
kurtarıyor. Ancak bu fonksiyonun bir sorunu var. Bu fonksiyon ekrana yalnızca
<cite>12 sayısının karesi 144 sayısıdır</cite> çıktısı verebiliyor. Buradaki problem,
fonksiyonun sadece <cite>12</cite> sayısı üzerinde işlem yapabilmesi. Şöyle bir düşününce,
bu çıktının ne kadar anlamsız olduğunu, aslında yukarıdaki fonksiyonun tamamen
gereksiz bir iş yaptığını rahatlıkla görebiliyoruz. Fonksiyonumuzun adı
<code class="docutils literal notranslate"><span class="pre">kare_bul</span></code>. Ama dediğimiz gibi, fonksiyonumuz sadece <cite>12</cite> sayısının karesini
söyleyebiliyor. Halbuki mantık olarak fonksiyonumuzun, bütün sayıların karesini
söyleyebilmesini beklerdik.</p>
<div class="admonition note">
<p class="admonition-title">Not</p>
<p>Bu arada, gördüğünüz gibi, yukarıdaki fonksiyon parametresiz bir
fonksiyondur. Dolayısıyla bu fonksiyonu çağırırken parantez içinde herhangi bir
değer belirtmiyoruz.</p>
</div>
<p>Fonksiyonumuzun gerçek anlamda işlevli bir hale gelebilmesi için sadece tek bir
sayıyı değil, bütün sayıları inceleyebiliyor olması gerek. İşte fonksiyonumuza
bu yeteneği parametreler aracılığıyla kazandırabiliriz.</p>
<p>Dikkatlice bakın:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">kare_bul</span><span class="p">(</span><span class="n">sayı</span><span class="p">):</span>
<span class="n">çıktı</span> <span class="o">=</span> <span class="s2">"</span><span class="si">{}</span><span class="s2"> sayısının karesi </span><span class="si">{}</span><span class="s2"> sayısıdır"</span>
<span class="nb">print</span><span class="p">(</span><span class="n">çıktı</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">sayı</span><span class="p">,</span> <span class="n">sayı</span><span class="o">**</span><span class="mi">2</span><span class="p">))</span>
</pre></div>
</div>
<p>Fonksiyona parametre olarak nasıl bir isim verdiğinizin önemi yoktur. Parantez
içine parametre olarak istediğiniz kelimeyi yazabilirsiniz. Önemli olan,
parantez içinde fonksiyonun kaç parametre alacağını gösteren bir işaret
olmasıdır. Mesela yukarıdaki fonksiyonu şöyle de tanımlayabilirdik:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">kare_bul</span><span class="p">(</span><span class="n">i</span><span class="p">):</span>
<span class="n">çıktı</span> <span class="o">=</span> <span class="s2">"</span><span class="si">{}</span><span class="s2"> sayısının karesi </span><span class="si">{}</span><span class="s2"> sayısıdır"</span>
<span class="nb">print</span><span class="p">(</span><span class="n">çıktı</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">i</span><span class="o">**</span><span class="mi">2</span><span class="p">))</span>
</pre></div>
</div>
<p>…veya şöyle:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">kare_bul</span><span class="p">(</span><span class="n">osman</span><span class="p">):</span>
<span class="n">çıktı</span> <span class="o">=</span> <span class="s2">"</span><span class="si">{}</span><span class="s2"> sayısının karesi </span><span class="si">{}</span><span class="s2"> sayısıdır"</span>
<span class="nb">print</span><span class="p">(</span><span class="n">çıktı</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">osman</span><span class="p">,</span> <span class="n">osman</span><span class="o">**</span><span class="mi">2</span><span class="p">))</span>
</pre></div>
</div>
<p>Elbette parametre adı olarak akılda kalıcı ve daha mantıklı bir seçim yapmak
işlerinizi kolaylaştıracaktır…</p>
<p>Şimdi de yukarıdaki fonksiyonu çağıralım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kare_bul</span><span class="p">(</span><span class="mi">9</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu fonksiyonu çalıştırdığımızda şu çıktıyı alırız:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="mi">9</span> <span class="n">sayısının</span> <span class="n">karesi</span> <span class="mi">81</span> <span class="n">sayısıdır</span>
</pre></div>
</div>
<p>Bu fonksiyona parametre olarak hangi sayıyı verirseniz o sayının karesi
hesaplanacaktır. Örneğin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kare_bul</span><span class="p">(</span><span class="mi">15</span><span class="p">)</span>
<span class="n">kare_bul</span><span class="p">(</span><span class="mi">25555</span><span class="p">)</span>
</pre></div>
</div>
<p>Yine bu fonksiyonu programınız içinde gereken her yerde çağırabilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kare_bul</span><span class="p">(</span><span class="mi">17</span><span class="p">)</span>
<span class="c1">####programla ilgili başka kodlar###</span>
<span class="n">kare_bul</span><span class="p">(</span><span class="mi">21</span><span class="p">)</span>
<span class="c1">###programla ilgili başka kodlar###</span>
<span class="n">kare_bul</span><span class="p">(</span><span class="mi">54354</span><span class="p">)</span>
</pre></div>
</div>
<p>Fonksiyonu oluşturan kodlarda herhangi bir değişiklik yapmak istediğinizde
sadece fonksiyon tanımının gövdesini değiştirmeniz yeterli olacaktır. Örneğin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">kare_bul</span><span class="p">(</span><span class="n">sayı</span><span class="p">):</span>
<span class="n">çıktı</span> <span class="o">=</span> <span class="s2">"</span><span class="si">{}</span><span class="s2"> sayısının karesi </span><span class="si">{}</span><span class="s2">, karekökü ise </span><span class="si">{}</span><span class="s2"> sayısıdır"</span>
<span class="nb">print</span><span class="p">(</span><span class="n">çıktı</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">sayı</span><span class="p">,</span> <span class="n">sayı</span><span class="o">**</span><span class="mi">2</span><span class="p">,</span> <span class="n">sayı</span><span class="o">**</span><span class="mf">0.5</span><span class="p">))</span>
</pre></div>
</div>
<p>Bu sayede sadece fonksiyon gövdesinde değişiklik yaparak, programın başka
kısımlarını hiç etkilemeden yolumuza devam edebiliyoruz.</p>
<p>Buraya kadar anlattıklarımız, fonksiyonların ne işe yaradığı ve bir program
yazarken neden fonksiyonlara ihtiyaç duyacağımız konusunda size bir fikir vermiş
olmalı. Eğer hala aklınızda fonksiyonların faydası konusunda bir şüphe kaldıysa,
fonksiyonların faydasını anlamanızı sağlayabilmek için size şöyle bir soru
sormama izin verin: Acaba ‘istihza’ kelimesinin kaç karakterden oluştuğunu nasıl
buluruz?</p>
<p>‘Elbette <code class="docutils literal notranslate"><span class="pre">len()</span></code> fonksiyonunu kullanarak!’ dediğinizi duyar gibiyim. Gerçekten
de Python’da bir karakter dizisinin uzunluğunu bulmanın en iyi yolu <code class="docutils literal notranslate"><span class="pre">len()</span></code>
fonksiyonunu kullanmaktır:</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">"istihza"</span><span class="p">)</span>
<span class="go">7</span>
</pre></div>
</div>
<p>Peki ya Python’da <code class="docutils literal notranslate"><span class="pre">len()</span></code> diye bir fonksiyon olmasaydı ne yapacaktınız? Böyle
bir durumda, karakter dizilerinin uzunluğunu ölçmek için sizin bir yöntem icat
etmeniz gerekecekti. Mesela ‘istihza’ kelimesinin kaç karakterden oluştuğunu
bulmak için şöyle bir kod yazacaktınız:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">c</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">for</span> <span class="n">s</span> <span class="ow">in</span> <span class="s2">"istihza"</span><span class="p">:</span>
<span class="n">c</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="nb">print</span><span class="p">(</span><span class="n">c</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada önce <cite>c</cite> adlı bir değişken tanımlayıp, bu değişkenin değerini <cite>0</cite> yaptık.
Bu değişken, uzunluğunu sorgulamak istediğimiz kelimenin kaç karakterden
oluştuğu bilgisini saklayacak.</p>
<p>Ardından bir <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü tanımlıyoruz. Bu döngüde, ‘istihza’ kelimesindeki
her bir karakter için <cite>c</cite> değişkeninin değerini <cite>1</cite> sayı artırıyoruz. Böylece
döngü sonunda <cite>c</cite> değişkeni ‘istihza’ kelimesi içinde kaç karakter olduğu
bilgisini tutmuş oluyor.</p>
<p>Son olarak da <cite>c</cite> değişkeninin nihai değerini ekrana yazdırıyoruz.</p>
<p>Bu kodları çalıştırdığınızda <cite>7</cite> cevabı alacaksınız. Demek ki ‘istihza’
kelimesinde <cite>7</cite> karakter varmış. Peki ‘istihza’ kelimesi yerine mesela
‘Afyonkarahisar’ kelimesi içinde kaç karakter olduğunu hesaplamak isterseniz ne
yapacaksınız? Elbette yukarıdaki kodları tekrar yazıp, ‘istihza’ kelimesini
‘Afyonkarahisar’ kelimesi ile değiştireceksiniz. Böylece bu kelimenin kaç
karakterden oluştuğunu bulmuş olacaksınız. Sorgulamak istediğiniz her kelime
için aynı şeyleri yapabilirsiniz…</p>
<p>Ne kadar verimsiz bir yöntem, değil mi?</p>
<p>Halbuki hiç bu tür şeylerle uğraşmaya gerek yok. Eğer Python bize <code class="docutils literal notranslate"><span class="pre">len()</span></code>
fonksiyonu gibi bir fonksiyon vermemiş olsaydı, kendi <code class="docutils literal notranslate"><span class="pre">len()</span></code> fonksiyonumuzu
icat edebilirdik. Dikkatlice bakın:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">uzunluk</span><span class="p">(</span><span class="n">öğe</span><span class="p">):</span>
<span class="n">c</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">for</span> <span class="n">s</span> <span class="ow">in</span> <span class="n">öğe</span><span class="p">:</span>
<span class="n">c</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="nb">print</span><span class="p">(</span><span class="n">c</span><span class="p">)</span>
</pre></div>
</div>
<p>Böylece adı <cite>uzunluk</cite> olan bir fonksiyon tanımlamış olduk. Artık bir öğenin
uzunluğunu hesaplamak istediğimizde, bütün o kodları her defasında tekrar tekrar
yazmak yerine sadece <code class="docutils literal notranslate"><span class="pre">uzunluk()</span></code> fonksiyonunu kullanabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">uzunluk</span><span class="p">(</span><span class="s2">"istihza"</span><span class="p">)</span>
<span class="n">uzunluk</span><span class="p">(</span><span class="s2">"Afyonkarahisar"</span><span class="p">)</span>
<span class="n">uzunluk</span><span class="p">(</span><span class="s2">"Tarım ve Köyişleri Bakanlığı"</span><span class="p">)</span>
</pre></div>
</div>
<p>Üstelik bu fonksiyon yalnızca karakter dizilerinin değil öteki veri tiplerinin
de uzunluğunu hesaplayabilir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">liste</span> <span class="o">=</span> <span class="p">[</span><span class="s2">"ahmet"</span><span class="p">,</span> <span class="s2">"mehmet"</span><span class="p">,</span> <span class="s2">"veli"</span><span class="p">]</span>
<span class="n">uzunluk</span><span class="p">(</span><span class="n">liste</span><span class="p">)</span>
</pre></div>
</div>
<p>Verdiğimiz bu örnek bize hem gömülü fonksiyonların faydasını, hem de genel
olarak fonksiyonların ne işe yaradığını açıkça gösteriyor. Buna göre, <code class="docutils literal notranslate"><span class="pre">len()</span></code>
benzeri gömülü fonksiyonlar tekerleği yeniden icat etme derdinden kurtarıyor
bizi. Örneğin Python geliştiricilerinin <code class="docutils literal notranslate"><span class="pre">len()</span></code> gibi bir fonksiyon tanımlamış
olmaları sayesinde, bir karakter dizisinin uzunluğunu hesaplamak için kendi
kendimize yöntem icat etmek zorunda kalmıyoruz. Ama eğer kendi yöntemimizi icat
etmemiz gerekirse, istediğimiz işlevi yerine getiren bir fonksiyon tanımlamamız
da mümkün.</p>
<p>Böylece temel olarak fonksiyonların ne işe yaradığını, neye benzediğini, nasıl
tanımlandığını ve nasıl çağrıldığını incelemiş olduk. Şimdi fonksiyonların biraz
daha derinine dalmaya başlayabiliriz.</p>
</div>
<div class="section" id="parametreler-ve-argumanlar">
<h2>Parametreler ve Argümanlar<a class="headerlink" href="#parametreler-ve-argumanlar" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Şimdiye kadar yaptığımız örnekler sayesinde aslında parametrelerin neye
benzediğini ve ne işe yaradığını öğrenmiştik. Bu bölümde ise sizi ‘argüman’ adlı
bir kavramla tanıştırıp, argüman ile parametre arasındaki benzerlik ve
farklılıkları inceleyeceğiz. Bunun yanısıra, parametre kavramını da bu bölümde
daha derinlikli bir şekilde ele alacağız.</p>
<p>O halde hemen yola koyulalım.</p>
<p>Parametrenin ne olduğunu biliyorsunuz. Bunlar fonksiyon tanımlarken parantez
içinde belirttiğimiz, fonksiyon gövdesinde yapılan işin değişken öğelerini
gösteren parçalardır. Mesela:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">kopyala</span><span class="p">(</span><span class="n">kaynak_dosya</span><span class="p">,</span> <span class="n">hedef_dizin</span><span class="p">):</span>
<span class="n">çıktı</span> <span class="o">=</span> <span class="s2">"</span><span class="si">{}</span><span class="s2"> adlı dosya </span><span class="si">{}</span><span class="s2"> adlı dizin içine kopyalandı!"</span>
<span class="nb">print</span><span class="p">(</span><span class="n">çıktı</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">kaynak_dosya</span><span class="p">,</span> <span class="n">hedef_dizin</span><span class="p">))</span>
</pre></div>
</div>
<p>Burada <code class="docutils literal notranslate"><span class="pre">kopyala()</span></code> adlı bir fonksiyon tanımladık. Bu fonksiyon toplam iki adet
parametre alıyor: <cite>kaynak_dosya</cite> ve <cite>hedef_dizin</cite>. Gördüğünüz gibi, bu iki
parametre gerçekten de fonksiyon gövdesinde yapılan işin değişken öğelerini
gösteriyor. Bu fonksiyonun üreteceği çıktı, fonksiyonu çağıran kişinin bu iki
parametreye vereceği değerlere bağlı olarak şekillenecek.</p>
<p>Bildiğiniz gibi, parametrelere ne ad verdiğinizin hiçbir önemi yok. Elbette
parametrenin görevine uygun bir isim vermeniz fonksiyonunuzun okunaklılığını
artıracaktır. Ama tabii ki bu fonksiyonu pekala şu parametrelerle de
tanımlayabilirdik:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">kopyala</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">):</span>
<span class="n">çıktı</span> <span class="o">=</span> <span class="s2">"</span><span class="si">{}</span><span class="s2"> adlı dosya </span><span class="si">{}</span><span class="s2"> adlı dizin içine kopyalandı!"</span>
<span class="nb">print</span><span class="p">(</span><span class="n">çıktı</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">))</span>
</pre></div>
</div>
<p>Burada önemli olan, parametre görevi görecek iki adet kelime bulmak. Bu
kelimelerin ne olduğunun önemi yok. Ama tabii ki <cite>kaynak_dosya</cite> ve <cite>hedef_dizin</cite>
adları, <cite>a</cite> ve <cite>b</cite> adlarına kıyasla, fonksiyondaki parametrelerin yaptığı işi
çok daha iyi tarif ediyor.</p>
<p>Parametre adı belirleme kuralları değişken adı belirleme kurallarıyla aynıdır.
Dolayısıyla bir değişken adı belirlerken neye dikkat ediyorsak, parametre adı
belirlerken de aynı şeye dikkat etmeliyiz.</p>
<p>Gelin şimdi isterseniz tanımladığınız bu fonksiyonu çağıralım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kopyala</span><span class="p">(</span><span class="s2">"deneme.txt"</span><span class="p">,</span> <span class="s2">"/home/istihza/Desktop"</span><span class="p">)</span>
</pre></div>
</div>
<p>Kodlarımız dosya içinde tam olarak şöyle görünüyor:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">kopyala</span><span class="p">(</span><span class="n">kaynak_dosya</span><span class="p">,</span> <span class="n">hedef_dizin</span><span class="p">):</span>
<span class="n">çıktı</span> <span class="o">=</span> <span class="s2">"</span><span class="si">{}</span><span class="s2"> adlı dosya </span><span class="si">{}</span><span class="s2"> adlı dizin içine kopyalandı!"</span>
<span class="nb">print</span><span class="p">(</span><span class="n">çıktı</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">kaynak_dosya</span><span class="p">,</span> <span class="n">hedef_dizin</span><span class="p">))</span>
<span class="n">kopyala</span><span class="p">(</span><span class="s2">"deneme.txt"</span><span class="p">,</span> <span class="s2">"/home/istihza/Desktop"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu kodları bir dosyaya kaydedip çalıştırdığımızda şöyle bir çıktı alırız:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span>deneme.txt adlı dosya /home/istihza/Desktop adlı dizin içine kopyalandı!
</pre></div>
</div>
<p>Gördüğünüz gibi, <cite>“deneme.txt”</cite> ve <cite>“/home/istihza/Desktop”</cite> değerleri, <cite>çıktı</cite>
adlı karakter dizisinde uygun yerlere yerleştirildi ve ekrana çıktı olarak
verildi. İşte burada gördüğünüz bu <cite>“deneme.txt”</cite> ve <cite>“/home/istihza/Desktop”</cite>
değerlerine argüman adı verilir. Yani bir fonksiyonu <strong>tanımlarken</strong>
belirlediğimiz adlara parametre, aynı fonksiyonu <strong>çağırırken</strong> belirlediğimiz
adlara ise argüman deniyor. Dolayısıyla fonksiyon tanımında belirlediğimiz
<cite>kaynak_dosya</cite> ve <cite>hedef_dizin</cite> adlı değişkenler birer parametre, fonksiyon
çağrısında bu parametrelere karşılık gelen <cite>“deneme.txt”</cite> ve
<cite>“/home/istihza/Desktop”</cite> değerleri ise birer argüman oluyor.</p>
<p>Böylece parametre ve argüman arasındaki farkı öğrenmiş olduk. Ancak şunu
belirtmekte yarar var: Bu iki kavram genellikle birbirinin yerine kullanılır.
Yani bu iki kavram arasındaki, yukarıda açıkladığımız farka pek kimse dikkat
etmez. Dolayısıyla pek çok yerde hem parametre hem de argüman için aynı ifadenin
kullanıldığını görebilirsiniz. Özellikle Türkçede parametre kelimesi argüman
kelimesine kıyasla daha bilinir ve yaygın olduğu için, ayrım yapılmaksızın hem
fonksiyon çağrısındaki değerlere, hem de fonksiyon tanımındaki değerlere
parametre adı verilir.</p>
<p>Gelelim parametrelerin çeşitlerine…</p>
<p>Python’da parametreler işlevlerine göre farklı kategorilere ayrılır. Gelin şimdi
bu kategorileri tek tek inceleyelim.</p>
<div class="section" id="sirali-veya-isimsiz-parametreler">
<h3>Sıralı (veya İsimsiz) Parametreler<a class="headerlink" href="#sirali-veya-isimsiz-parametreler" title="Bu başlık için kalıcı bağlantı">¶</a></h3>
<p>Python’da şöyle bir fonksiyon tanımlayabileceğimizi biliyoruz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">kayıt_oluştur</span><span class="p">(</span><span class="n">isim</span><span class="p">,</span> <span class="n">soyisim</span><span class="p">,</span> <span class="n">işsis</span><span class="p">,</span> <span class="n">şehir</span><span class="p">):</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"-"</span><span class="o">*</span><span class="mi">30</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"isim : "</span><span class="p">,</span> <span class="n">isim</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"soyisim : "</span><span class="p">,</span> <span class="n">soyisim</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"işletim sistemi: "</span><span class="p">,</span> <span class="n">işsis</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"şehir : "</span><span class="p">,</span> <span class="n">şehir</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"-"</span><span class="o">*</span><span class="mi">30</span><span class="p">)</span>
</pre></div>
</div>
<p>Yukarıda tanımladığımız bu fonksiyonu şu şekilde çağırabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kayıt_oluştur</span><span class="p">(</span><span class="s2">"Ahmet"</span><span class="p">,</span> <span class="s2">"Öz"</span><span class="p">,</span> <span class="s2">"Debian"</span><span class="p">,</span> <span class="s2">"Ankara"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu fonksiyonda, yazdığımız parametrelerin sırası büyük önem taşır. Mesela
yukarıdaki fonksiyonu şöyle çağırdığımızı düşünün:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kayıt_oluştur</span><span class="p">(</span><span class="s2">"Debian"</span><span class="p">,</span> <span class="s2">"Ankara"</span><span class="p">,</span> <span class="s2">"Öz"</span><span class="p">,</span> <span class="s2">"Ahmet"</span><span class="p">)</span>