forked from yazbel/python-istihza
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathkosul_deyimleri.html
915 lines (826 loc) · 72.9 KB
/
kosul_deyimleri.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
<!DOCTYPE html>
<html lang="tr">
<html lang="tr">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta content="Bu bölümde Python'daki koşul deyimlerinden söz edeceğiz." name="description" />
<meta content="python, if, elif, else" name="keywords" />
<title>Koşullu Durumlar — Python 3 için Türkçe Kılavuz</title>
<link rel="stylesheet" href="_static/pyramid.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<script id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
<script src="_static/jquery.js"></script>
<script src="_static/underscore.js"></script>
<script src="_static/doctools.js"></script>
<script src="_static/language_data.js"></script>
<script src="_static/translations.js"></script>
<link rel="search" title="Ara" href="search.html" />
<link rel="next" title="İşleçler" href="islecler.html" />
<link rel="prev" title="Kullanıcıdan Bilgi Almak" href="input.html" />
<!--[if lte IE 6]>
<link rel="stylesheet" href="_static/ie6.css" type="text/css" media="screen" charset="utf-8" />
<![endif]-->
</head><body>
<div class='header'><a href='https://yazbel.com'>yazbel.com</a></div>
<ul class='navbar'>
<li><a href="#"><del>pdf desteği sonlanmıştır</del></a></li>
<li class="forum"><a href="http://forum.yazbel.com">forum</a></li>
</ul>
<div class="related" role="navigation" aria-label="related navigation">
<h3>Gezinti</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="islecler.html" title="İşleçler"
accesskey="N">sonraki</a></li>
<li class="right" >
<a href="input.html" title="Kullanıcıdan Bilgi Almak"
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="">Koşullu Durumlar</a></li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="body" role="main">
<div class="section" id="kosullu-durumlar">
<h1>Koşullu Durumlar<a class="headerlink" href="#kosullu-durumlar" title="Bu başlık için kalıcı bağlantı">¶</a></h1>
<p>Artık Python programlama dilinde belli bir noktaya geldik sayılır. Ama eğer
farkettiyseniz, yine de elimizi kolumuzu bağlayan, istediğimiz şeyleri yapmamıza
engel olan bir şeyler var. İşte bu bölümde, Python programlama dilinde hareket
alanımızı bir hayli genişletecek araçları tanıyacağız.</p>
<p>Aslında sadece bu bölümde değil, bu bölümü takip eden her bölümde, hareket
alanımızı kısıtlayan duvarları tek tek yıktığımıza şahit olacaksınız. Özellikle
bu bölümde inceleyeceğimiz ‘koşullu durumlar’ konusu, tabir yerindeyse,
Python’da boyut atlamamızı sağlayacak.</p>
<p>O halde hiç vakit kaybetmeden yola koyulalım…</p>
<p>Şimdiye kadar öğrendiğimiz Python bilgilerini kullanarak şöyle bir program
yazabileceğimizi biliyorsunuz:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">yaş</span> <span class="o">=</span> <span class="mi">15</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"""Programa hoşgeldiniz!</span>
<span class="s2">Programımızı kullanabilmek için en az</span>
<span class="s2">13 yaşında olmalısınız."""</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Yaşınız: "</span><span class="p">,</span> <span class="n">yaş</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada yaptığımız şey çok basit. Öncelikle, değeri <cite>15</cite> olan, <cite>yaş</cite> adlı bir
değişken tanımladık. Daha sonra, programımızı çalıştıran kullanıcılar için bir
hoşgeldin mesajı hazırladık. Son olarak da <cite>yaş</cite> değişkeninin değerini ekrana
yazdırdık.</p>
<p>Bu programın özelliği tek sesli bir uygulama olmasıdır. Yani bu programda
kullanıcıyla herhangi bir etkileşim yok. Burada bütün değerleri/değişkenleri
programcı olarak kendimiz belirliyoruz. Bu programın ne kadar yavan olduğunu
herhalde söylemeye gerek yok.</p>
<p>Ancak yine önceki derslerde öğrendiğimiz <code class="docutils literal notranslate"><span class="pre">input()</span></code> fonksiyonu yardımıyla
yukarıdaki programın üzerindeki yavanlığı bir nebze de olsa atabilir, bu
programı rahatlıkla çok sesli bir hale getirebilir, yani kullanıcıyla etkileşim
içine girebiliriz.</p>
<p>Yukarıdaki tek sesli uygulamayı, <code class="docutils literal notranslate"><span class="pre">input()</span></code> fonksiyonunu kullanarak çok sesli
bir hale nasıl getireceğimizi gayet iyi bildiğinize eminim:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="s2">"""Programa hoşgeldiniz!</span>
<span class="s2">Programımızı kullanabilmek için en az</span>
<span class="s2">13 yaşında olmalısınız."""</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Lütfen yaşınızı girin.</span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
<span class="n">yaş</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Yaşınız: </span><span class="se">\t</span><span class="s2">"</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Yaşınız: "</span><span class="p">,</span> <span class="n">yaş</span><span class="p">)</span>
</pre></div>
</div>
<p>Tıpkı bir önceki uygulamada olduğu gibi, burada da yaptığımız şey çok basit. İlk
örnekte <cite>yaş</cite> değişkeninin değerini kendimiz elle yazmıştık. İkinci örnekte ise
bu <cite>yaş</cite> değişkenini kullanıcıdan alıyoruz ve tıpkı ilk örnekte olduğu gibi, bu
değişkenin değerini ekrana yazdırıyoruz.</p>
<p>Bu arada, yukarıdaki uygulamada yer verdiğimiz <cite>\n</cite> ve <cite>\t</cite> adlı kaçış
dizileri de artık sizin için oldukça tanıdık. <cite>\n</cite> kaçış dizisi yardımıyla bir
alt satıra geçtiğimizi, <cite>\t</cite> adlı kaçış dizisi yardımıyla da bir sekmelik
boşluk bıraktığımızı biliyorsunuz.</p>
<p>Gördüğünüz gibi, şu ana kadar öğrendiklerimizle ancak kullanıcıdan gelen yaş
bilgisini ekrana yazdırabiliyoruz. Öğrendiğimiz <code class="docutils literal notranslate"><span class="pre">input()</span></code> fonksiyonu bize
kullanıcıdan bilgi alma imkanı sağlıyor. Ama kullanıcıdan gelen bu bilgiyi
şimdilik ancak olduğu gibi kullanabiliyoruz. Yani mesela yukarıdaki örneği
dikkate alarak konuşacak olursak, kullanıcının yaşı eğer 13’ün üzerindeyse onu
programa kabul edecek, yok eğer 13 yaşın altındaysa da programdan atacak bir
mekanizma üretemiyoruz. Yapabildiğimiz tek şey, kullanıcının girdiği veriyi
ekrana yazdırmak.</p>
<p>Yukarıda verdiğimiz örneklerle nereye varmaya çalıştığımızı az çok tahmin
etmişsinizdir. Dikkat ederseniz yukarıda sözünü ettiğimiz şey koşullu bir durum.
Yani aslında yapmak istediğimiz şey, kullanıcının yaşını denetleyip, onun
programa kabul edilmesini 13 yaşından büyük olma koşuluna bağlamak.</p>
<p>İsterseniz tam olarak neden bahsettiğimizi anlayabilmek için, birkaç vaka örneği
verelim.</p>
<p>Diyelim ki Google’ın Gmail hizmeti aracılığıyla bir e.posta hesabı aldınız. Bu
hesaba gireceğiniz zaman Gmail size bir kullanıcı adı ve parola sorar. Siz de
kendinize ait kullanıcı adını ve parolayı sayfadaki kutucuklara yazarsınız. Eğer
yazdığınız kullanıcı adı ve parola doğruysa hesabınıza erişebilirsiniz. Ama eğer
kullanıcı adınız ve parolanız doğru değilse hesabınıza erişemezsiniz. Yani
e.posta hesabınıza erişmeniz, kullanıcı adı ve parolayı doğru girme koşuluna
bağlıdır.</p>
<p>Ya da şu vaka örneğini düşünelim: Diyelim ki Pardus’ta komut satırı aracılığıyla
güncelleme işlemi yapacaksınız. <code class="docutils literal notranslate"><span class="pre">sudo</span> <span class="pre">pisi</span> <span class="pre">up</span></code> komutunu verdiğiniz zaman
güncellemelerin listesi size bildirilecek, bu güncellemeleri yapmak isteyip
istemediğiniz sorulacaktır. Eğer evet cevabı verirseniz güncelleme işlemi
başlar. Ama eğer hayır cevabı verirseniz güncelleme işlemi başlamaz. Yani
güncelleme işleminin başlaması kullanıcının evet cevabı vermesi koşuluna
bağlıdır.</p>
<p>İşte bu bölümde biz bu tür koşullu durumlardan söz edeceğiz.</p>
<div class="section" id="kosul-deyimleri">
<h2>Koşul Deyimleri<a class="headerlink" href="#kosul-deyimleri" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Hiç kuşkusuz, koşula bağlı durumlar Python’daki en önemli konulardan biridir.
Giriş bölümünde bahsettiğimiz koşullu işlemleri yapabilmek için ‘koşul
deyimleri’ adı verilen birtakım araçlardan yararlanacağız. Gelin şimdi bu
araçların neler olduğunu görelim.</p>
<div class="section" id="if">
<h3>if<a class="headerlink" href="#if" title="Bu başlık için kalıcı bağlantı">¶</a></h3>
<p>Python programlama dilinde koşullu durumları belirtmek için üç adet deyimden
yararlanıyoruz:</p>
<ul class="simple">
<li><p><code class="docutils literal notranslate"><span class="pre">if</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">elif</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">else</span></code></p></li>
</ul>
<p>İsterseniz önce <code class="docutils literal notranslate"><span class="pre">if</span></code> deyimi ile başlayalım…</p>
<p>Eğer daha önceden herhangi bir programlama dilini az da olsa kurcalama
fırsatınız olduysa, bir programlama dilinde <code class="docutils literal notranslate"><span class="pre">if</span></code> deyimlerinin ne işe
yaradığını az çok biliyorsunuzdur. Daha önceden hiç programcılık deneyiminiz
olmamışsa da ziyanı yok. Zira bu bölümde <code class="docutils literal notranslate"><span class="pre">if</span></code> deyimlerinin ne işe yaradığını
ve nerelerde kullanıldığını enine boyuna tartışacağız.</p>
<p>İngilizce bir kelime olan ‘<em>if</em>’, Türkçede ‘eğer’ anlamına gelir. Anlamından da
çıkarabileceğimiz gibi, bu kelime bir koşul bildiriyor. Yani ‘<em>eğer bir şey
falanca ise…</em>’ ya da ‘<em>eğer bir şey filanca ise…</em>’ gibi… İşte biz
Python’da bir koşula bağlamak istediğimiz durumları <code class="docutils literal notranslate"><span class="pre">if</span></code> deyimi aracılığıyla
göstereceğiz.</p>
<p>Gelin isterseniz bu deyimi nasıl kullanacağımıza dair ufacık bir örnek vererek
işe başlayalım:</p>
<p>Öncelikle elimizde şöyle bir değişken olsun:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">n</span> <span class="o">=</span> <span class="mi">255</span>
</pre></div>
</div>
<p>Yukarıda verdiğimiz değişkenin değerinin bir karakter dizisi değil, aksine bir
sayı olduğunu görüyoruz. Şimdi bu değişkenin değerini sorgulayalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">if</span> <span class="n">n</span> <span class="o">></span> <span class="mi">10</span><span class="p">:</span>
</pre></div>
</div>
<p>Burada sayının 10’dan büyük olup olmadığına bakıyoruz.</p>
<p>Burada gördüğümüz <cite>></cite> işaretinin ne demek olduğunu açıklamaya gerek yok sanırım.
Hepimizin bildiği ‘büyüktür’ işareti Python’da da aynen bildiğimiz şekilde
kullanılıyor. Mesela ‘küçüktür’ demek isteseydik, <cite><</cite> işaretini kullanacaktık.
İsterseniz hemen şurada araya girip bu işaretleri yeniden hatırlayalım:</p>
<blockquote>
<div><table class="docutils align-default">
<colgroup>
<col style="width: 30%" />
<col style="width: 70%" />
</colgroup>
<thead>
<tr class="row-odd"><th class="head"><p>İşleç</p></th>
<th class="head"><p>Anlamı</p></th>
</tr>
</thead>
<tbody>
<tr class="row-even"><td><p>></p></td>
<td><p>büyüktür</p></td>
</tr>
<tr class="row-odd"><td><p><</p></td>
<td><p>küçüktür</p></td>
</tr>
<tr class="row-even"><td><p>>=</p></td>
<td><p>büyük eşittir</p></td>
</tr>
<tr class="row-odd"><td><p><=</p></td>
<td><p>küçük eşittir</p></td>
</tr>
<tr class="row-even"><td><p>==</p></td>
<td><p>eşittir</p></td>
</tr>
<tr class="row-odd"><td><p>!=</p></td>
<td><p>eşit değildir</p></td>
</tr>
</tbody>
</table>
</div></blockquote>
<p>Gördüğünüz gibi hiçbiri bize yabancı gelecek gibi değil. Yalnızca en sondaki
‘eşittir’ (<cite>==</cite>) ve ‘eşit değildir’ (<cite>!=</cite>) işaretleri biraz değişik gelmiş
olabilir. Burada ‘eşittir’ işaretinin <cite>=</cite> olmadığına dikkat edin. Python’da <cite>=</cite>
işaretini değer atama işlemleri için kullanıyoruz. <cite>==</cite> işaretini ise iki adet
değerin birbirine eşit olup olmadığını denetlemek için… Mesela:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">a</span> <span class="o">=</span> <span class="mi">26</span>
</pre></div>
</div>
<p>Burada değeri <cite>26</cite> olan <cite>a</cite> adlı bir değişken belirledik. Yani <cite>a</cite> değişkenine
değer olarak <cite>26</cite> sayısını atadık. Ayrıca burada, değer atama işleminin ardından
<cite>Enter</cite> tuşuna bastıktan sonra Python hiçbir şey yapmadan bir alt satıra geçti.
Bir de şuna bakalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">a</span> <span class="o">==</span> <span class="mi">26</span>
<span class="go">True</span>
</pre></div>
</div>
<p>Burada ise yaptığımız şey <cite>a</cite> değişkeninin değerinin <cite>26</cite> olup olmadığını
sorgulamak <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">==</span> <span class="pre">26</span></code> komutunu verdikten sonra Python bize <cite>True</cite> diye bir
çıktı verdi. Bu çıktının anlamını biraz sonra öğreneceğiz. Ama şimdi isterseniz
konuyu daha fazla dağıtmayalım. Biz şimdilik sadece <cite>=</cite> ve <cite>==</cite> işaretlerinin
birbirinden tamamen farklı anlamlara geldiğini bilelim yeter.</p>
<p>Ne diyorduk?</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">if</span> <span class="n">n</span> <span class="o">></span> <span class="mi">10</span><span class="p">:</span>
</pre></div>
</div>
<p>Bu ifadeyle Python’a şöyle bir şey demiş oluyoruz:</p>
<blockquote>
<div><p>Eğer <cite>n</cite> sayısının değeri 10’dan büyükse…</p>
</div></blockquote>
<p>Burada kullandığımız işaretlere dikkat edin. En sonda bir adet <cite>:</cite> işaretinin
olduğunu gözden kaçırmıyoruz. Bu tür işaretler Python için çok önemlidir.
Bunları yazmayı unutursak Python gözümüzün yaşına bakmayacaktır.</p>
<p>Dedik ki, <code class="docutils literal notranslate"><span class="pre">if</span> <span class="pre">n</span> <span class="pre">></span> <span class="pre">10:</span></code> ifadesi, ‘eğer n değişkeninin değeri 10’dan büyükse…’
anlamına gelir. Bu ifadenin eksik olduğu apaçık ortada. Yani belli ki bu
cümlenin bir de devamı olması gerekiyor. O halde biz de devamını getirelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">if</span> <span class="n">n</span> <span class="o">></span> <span class="mi">10</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"sayı 10'dan büyüktür!"</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada çok önemli bir durumla karşı karşıyayız. Dikkat ederseniz, ikinci satırı
ilk satıra göre girintili yazdık. Elbette bunu şirinlik olsun diye yapmadık.
Python programlama dilinde girintiler çok büyük önem taşır. Hatta ne kadarlık
bir girinti verdiğiniz bile önemlidir. Eğer Python kodlarına duyarlı bir metin
düzenleyici kullanıyorsanız, kullandığınız metin düzenleyici çoğu durumda sizin
yerinize uygun bir şekilde girintilemeyi yapacaktır. Mesela IDLE adlı geliştirme
ortamını kullananlar, ilk satırdaki <cite>:</cite> işaretini koyup <cite>Enter</cite> tuşuna
bastıklarında otomatik olarak girinti verildiğini farkedeceklerdir. Eğer
kullandığınız metin düzenleyici, satırları otomatik olarak girintilemiyorsa
sizin bu girintileme işlemini elle yapmanız gerekecektir. Yalnız elle
girintilerken, ne kadar girinti vereceğimize dikkat etmeliyiz. Genel kural
olarak <cite>4</cite> boşlukluk bir girintileme uygun olacaktır. Girintileme işlemini
klavyedeki sekme (<cite>Tab</cite>) tuşuna basarak da yapabilirsiniz. Ama aynı program
içinde sekmelerle boşlukları karıştırmayın. Yani eğer girintileme işlemini
klavyedeki boşluk (<cite>Space</cite>) tuşuna basarak yapıyorsanız, program boyunca aynı
şekilde yapın. (Ben size girinti verirken <cite>Tab</cite> tuşu yerine <cite>Space</cite> tuşunu
kullanmanızı tavsiye ederim). Kısaca söylemek gerekirse; Python’da girintileme
ve girintilemede tutarlılık çok önemlidir. Özellikle büyük programlarda,
girintilemeler açısından tutarsızlık gösterilmesi programın çalışmamasına sebep
olabilir.</p>
<div class="admonition note">
<p class="admonition-title">Not</p>
<p>Python’da girintileme konusuyla ilgili daha ayrıntılı bilgi için:
<a class="reference external" href="http://web.archive.org/web/20161122123704/http://www.istihza.com/blog/python-ve-metin-duzenleyiciler.html">http://www.istihza.com/blog/python-ve-metin-duzenleyiciler.html</a> (arşiv linki)</p>
</div>
<p>Eğer yukarıdaki <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğunu bir metin düzenleyici içine değil de doğrudan
etkileşimli kabuğa yazmışsanız bazı şeyler dikkatinizi çekmiş olmalı.
Etkileşimli kabukta <code class="docutils literal notranslate"><span class="pre">if</span> <span class="pre">sayı</span> <span class="pre">></span> <span class="pre">10:</span></code> satırını yazıp <cite>Enter</cite> tuşuna bastığınızda
şöyle bir görüntüyle karşılaşmış olmalısınız:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">if</span> <span class="n">n</span> <span class="o">></span> <span class="mi">10</span><span class="p">:</span>
<span class="gp">...</span>
</pre></div>
</div>
<p>Dikkat ederseniz, <cite>>>></cite> işareti, <cite>…</cite> işaretine dönüştü. Eğer bu noktada
herhangi bir şey yazmadan <cite>Enter</cite> tuşuna basacak olursanız Python size şöyle bir
hata mesajı verecektir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">File</span> <span class="s2">"<stdin>"</span><span class="p">,</span> <span class="n">line</span> <span class="mi">2</span>
<span class="o">^</span>
<span class="ne">IndentationError</span><span class="p">:</span> <span class="n">expected</span> <span class="n">an</span> <span class="n">indented</span> <span class="n">block</span>
</pre></div>
</div>
<p>Hata mesajında da söylendiği gibi, Python bizden girintilenmiş bir blok
beklerken, biz onun bu beklentisini karşılamamışız. Dolayısıyla bize yukarıdaki
hata mesajını göstermiş. <cite>…</cite> işaretini gördükten sonra yapmamız gereken şey,
dört kez boşluk (<cite>Space</cite>) tuşuna basarak girinti oluşturmak ve <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğunun
devamını yazmak olmalıydı. Yani şöyle:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">if</span> <span class="n">n</span> <span class="o">></span> <span class="mi">10</span><span class="p">:</span>
<span class="gp">... </span> <span class="nb">print</span><span class="p">(</span><span class="s2">"sayı 10'dan büyüktür!"</span><span class="p">)</span>
<span class="gp">...</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonunu yazıp <cite>Enter</cite> tuşuna bastıktan sonra
yine <cite>…</cite> işaretini gördük. Python burada bizden yeni bir satır daha bekliyor.
Ama bizim yazacak başka bir kodumuz olmadığı için tekrar <cite>Enter</cite> tuşuna
basıyoruz ve nihai olarak şöyle bir görüntü elde ediyoruz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">if</span> <span class="n">n</span> <span class="o">></span> <span class="mi">10</span><span class="p">:</span>
<span class="gp">... </span> <span class="nb">print</span><span class="p">(</span><span class="s2">"sayı 10'dan büyüktür!"</span><span class="p">)</span>
<span class="gp">...</span>
<span class="go">sayı 10'dan büyüktür!</span>
<span class="go">>>></span>
</pre></div>
</div>
<p>Demek ki <cite>250</cite> sayısı <cite>10</cite>’dan büyükmüş! Ne büyük bir buluş! Merak etmeyin, daha
çok şey öğrendikçe daha mantıklı programlar yazacağız. Burada amacımız işin
temelini kavramak. Bunu da en iyi, (çok mantıklı olmasa bile) basit programlar
yazarak yapabiliriz.</p>
<p>Şimdi metin düzenleyicimizi açarak daha mantıklı şeyler yazmaya çalışalım. Zira
yukarıdaki örnekte değişkeni kendimiz belirlediğimiz için, bu değişkenin
değerini <code class="docutils literal notranslate"><span class="pre">if</span></code> deyimleri yardımıyla denetlemek pek akla yatkın görünmüyor. Ne
de olsa değişkenin değerinin ne olduğunu biliyoruz. Dolayısıyla bu değişkenin
<cite>10</cite> sayısından büyük olduğunu da biliyoruz! Bunu <code class="docutils literal notranslate"><span class="pre">if</span></code> deyimiyle kontrol etmek
çok gerekli değil. Ama şimdi daha makul bir iş yapacağız. Değişkeni biz
belirlemek yerine kullanıcıya belirleteceğiz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">sayı</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="nb">input</span><span class="p">(</span><span class="s2">"Bir sayı giriniz: "</span><span class="p">))</span>
<span class="k">if</span> <span class="n">sayı</span> <span class="o">></span> <span class="mi">10</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Girdiğiniz sayı 10'dan büyüktür!"</span><span class="p">)</span>
<span class="k">if</span> <span class="n">sayı</span> <span class="o"><</span> <span class="mi">10</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Girdiğiniz sayı 10'dan küçüktür!"</span><span class="p">)</span>
<span class="k">if</span> <span class="n">sayı</span> <span class="o">==</span> <span class="mi">10</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Girdiğiniz sayı 10'dur!"</span><span class="p">)</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, art arda üç adet <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğu kullandık. Bu kodlara göre, eğer
kullanıcının girdiği sayı <cite>10</cite>’dan büyükse, ilk <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğu işletilecek; eğer
sayı <cite>10</cite>’dan küçükse ikinci <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğu işletilecek; eğer sayı 10’a eşit ise
üçüncü <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğu işletilecektir. Peki ya kullanıcı muziplik yapıp sayı yerine
harf yazarsa ne olacak? Böyle bir ihtimal için programımıza herhangi bir
denetleyici yerleştirmedik. Dolayısıyla eğer kullanıcı sayı yerine harf girerse
programımız hata verecek, yani çökecektir. Bu tür durumlara karşı nasıl önlem
alacağımızı ilerleyen derslerimizde göreceğiz. Biz şimdilik bildiğimiz yolda
yürüyelim.</p>
<p>Yukarıdaki örnekte <code class="docutils literal notranslate"><span class="pre">input()</span></code> ile gelen karakter dizisini, <code class="docutils literal notranslate"><span class="pre">int()</span></code> fonksiyonu
yardımıyla bir sayıya dönüştürdüğümüze dikkat edin. Kullanıcıdan gelen veriyi
büyüklük-küçüklük ölçütüne göre inceleyeceğimiz için, gelen veriyi bir sayıya
dönüştürmemiz gerekiyor. Bunu da <code class="docutils literal notranslate"><span class="pre">int()</span></code> fonksiyonu ile yapabileceğimizi
biliyorsunuz.</p>
<p>Elbette yukarıdaki dönüştürme işlemini şöyle de yapabilirdik:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">sayı</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Bir sayı giriniz: "</span><span class="p">)</span>
<span class="n">sayı</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sayı</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada önce <code class="docutils literal notranslate"><span class="pre">input()</span></code> fonksiyonuyla veriyi aldık, daha sonra bu veriyi ayrı
bir yerde sayıya dönüştürüp tekrar <cite>sayı</cite> adlı değişkene atadık.</p>
<p><code class="docutils literal notranslate"><span class="pre">if</span></code> deyimlerini kullanıcı adı veya parola denetlerken de kullanabiliriz.
Mesela şöyle bir program taslağı yazabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="s2">"""</span>
<span class="s2">Dünyanın en gelişmiş e.posta hizmetine</span>
<span class="s2">hoşgeldiniz. Yalnız hizmetimizden</span>
<span class="s2">yararlanmak için önce sisteme giriş</span>
<span class="s2">yapmalısınız.</span>
<span class="s2">"""</span><span class="p">)</span>
<span class="n">parola</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Parola: "</span><span class="p">)</span>
<span class="k">if</span> <span class="n">parola</span> <span class="o">==</span> <span class="s2">"12345678"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Sisteme Hoşgeldiniz!"</span><span class="p">)</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, programın başında üç tırnak işaretlerinden yararlanarak uzun
bir metni kullanıcıya gösterdik. Bu bölümü, kendiniz göze hoş gelecek bir
şekilde süsleyebilirsiniz de. Eğer kullanıcı, kendisine parola sorulduğunda
cevap olarak <cite>“12345678”</cite> yazarsa kullanıcıyı sisteme alıyoruz.</p>
<p>Yukarıdaki örnekte, kullanıcının girdiği parola <cite>“12345678”</cite> ise kendisine
<cite>“Sisteme Hoşgeldiniz!”</cite> mesajını gösteriyoruz. Mantık olarak bunun tersini
yapmak da mümkündür. Yani:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">if</span> <span class="n">parola</span> <span class="o">!=</span> <span class="s2">"12345678"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Ne yazık ki yanlış parola girdiniz!"</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada ise bir önceki örneğin mantığını ters çevirdik. Önceki örnekte <cite>parola</cite>
değişkeni <cite>“12345678”</cite> adlı karakter dizisine eşitse (<code class="docutils literal notranslate"><span class="pre">if</span> <span class="pre">parola</span> <span class="pre">==</span>
<span class="pre">"12345678"</span></code>) bir işlem yapıyorduk. Yukarıdaki örnekte ise <cite>parola</cite> değişkeni
<cite>“12345678”</cite> adlı karakter dizisine eşit değilse (<code class="docutils literal notranslate"><span class="pre">if</span> <span class="pre">parola</span> <span class="pre">!=</span> <span class="pre">"12345678"</span></code>)
bir işlem yapıyoruz.</p>
<p>Bu iki örneğin de aslında aynı kapıya çıktığını görüyorsunuz. Tek değişiklik,
kullanıcıya gösterilen mesajlardadır.</p>
<p>Böylece Python’daki koşullu durumlar üzerindeki incelememizin ilk ve en önemli
aşamasını geride bırakmış olduk. Dikkat ettiyseniz <code class="docutils literal notranslate"><span class="pre">if</span></code> deyimi sayesinde
programlarımıza karar vermeyi öğrettik. Bu deyim yardımıyla, kullanıcıdan
aldığımız herhangi bir verinin niteliği üzerinde kapsamlı bir karar verme işlemi
yürütebiliyoruz. Yani artık programlarımız kullanıcıdan alınan veriyi olduğu
gibi kabul etmekle yetinmiyor. Kullanıcının girdiği verinin ne olduğuna bağlı
olarak programlarımızın farklı işlemler yapmasını da sağlayabiliyoruz.</p>
<p>Daha önce de söylediğimiz gibi, <code class="docutils literal notranslate"><span class="pre">if</span></code> deyimi dışında Python’da koşullu
durumları ifade etmek için kullandığımız, <code class="docutils literal notranslate"><span class="pre">elif</span></code> ve <code class="docutils literal notranslate"><span class="pre">else</span></code> adlı iki deyim
daha vardır. Bunlar <code class="docutils literal notranslate"><span class="pre">if</span></code> ile birlikte kullanılırlar. Gelin isterseniz bu iki
deyimden, adı <code class="docutils literal notranslate"><span class="pre">elif</span></code> olana bakalım.</p>
</div>
<div class="section" id="elif">
<h3>elif<a class="headerlink" href="#elif" title="Bu başlık için kalıcı bağlantı">¶</a></h3>
<p>Python’da, <code class="docutils literal notranslate"><span class="pre">if</span></code> deyimleriyle birlikte kullanılan ve yine koşul belirten bir
başka deyim de <code class="docutils literal notranslate"><span class="pre">elif</span></code> deyimidir. Buna şöyle bir örnek verebiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">yaş</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="nb">input</span><span class="p">(</span><span class="s2">"Yaşınız: "</span><span class="p">))</span>
<span class="k">if</span> <span class="n">yaş</span> <span class="o">==</span> <span class="mi">18</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"18 iyidir!"</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">yaş</span> <span class="o"><</span> <span class="mi">0</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Yok canım, daha neler!..."</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">yaş</span> <span class="o"><</span> <span class="mi">18</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Genç bir kardeşimizsin!"</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">yaş</span> <span class="o">></span> <span class="mi">18</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Eh, artık yaş yavaş yavaş kemale eriyor!"</span><span class="p">)</span>
</pre></div>
</div>
<p>Yukarıdaki örneği şöyle yazmayı da deneyebilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">yaş</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="nb">input</span><span class="p">(</span><span class="s2">"Yaşınız: "</span><span class="p">))</span>
<span class="k">if</span> <span class="n">yaş</span> <span class="o">==</span> <span class="mi">18</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"18 iyidir!"</span><span class="p">)</span>
<span class="k">if</span> <span class="n">yaş</span> <span class="o"><</span> <span class="mi">0</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Yok canım, daha neler!..."</span><span class="p">)</span>
<span class="k">if</span> <span class="n">yaş</span> <span class="o"><</span> <span class="mi">18</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Genç bir kardeşimizsin!"</span><span class="p">)</span>
<span class="k">if</span> <span class="n">yaş</span> <span class="o">></span> <span class="mi">18</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Eh, artık yaş yavaş yavaş kemale eriyor!"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu iki programın da aynı işlevi gördüğünü düşünebilirsiniz. Ancak ilk bakışta
pek belli olmasa da, aslında yukarıdaki iki program birbirinden farklı
davranacaktır. Örneğin ikinci programda eğer kullanıcı eksi değerli bir sayı
girerse hem <code class="docutils literal notranslate"><span class="pre">if</span> <span class="pre">yaş</span> <span class="pre"><</span> <span class="pre">0</span></code> bloğu, hem de <code class="docutils literal notranslate"><span class="pre">if</span> <span class="pre">yaş</span> <span class="pre"><</span> <span class="pre">18</span></code> bloğu çalışacaktır.
İsterseniz yukarıdaki programı çalıştırıp, cevap olarak eksi değerli bir sayı
verin. Ne demek istediğimiz gayet net anlaşılacaktır.</p>
<p>Bu durum <code class="docutils literal notranslate"><span class="pre">if</span></code> ile <code class="docutils literal notranslate"><span class="pre">elif</span></code> arasındaki çok önemli bir farktan kaynaklanır. Buna
göre <code class="docutils literal notranslate"><span class="pre">if</span></code> bize olası bütün sonuçları listeler, <code class="docutils literal notranslate"><span class="pre">elif</span></code> ise sadece doğru olan
ilk sonucu verir. Bu soyut tanımlamayı biraz daha somutlaştıralım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="nb">input</span><span class="p">(</span><span class="s2">"Bir sayı giriniz: "</span><span class="p">))</span>
<span class="k">if</span> <span class="n">a</span> <span class="o"><</span> <span class="mi">100</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"verdiğiniz sayı 100'den küçüktür."</span><span class="p">)</span>
<span class="k">if</span> <span class="n">a</span> <span class="o"><</span> <span class="mi">50</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"verdiğiniz sayı 50'den küçüktür."</span><span class="p">)</span>
<span class="k">if</span> <span class="n">a</span> <span class="o">==</span> <span class="mi">100</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"verdiğiniz sayı 100'dür."</span><span class="p">)</span>
<span class="k">if</span> <span class="n">a</span> <span class="o">></span> <span class="mi">100</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"verdiğiniz sayı 100'den büyüktür."</span><span class="p">)</span>
<span class="k">if</span> <span class="n">a</span> <span class="o">></span> <span class="mi">150</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"verdiğiniz sayı 150'den büyüktür."</span><span class="p">)</span>
</pre></div>
</div>
<p>Yukarıdaki kodları çalıştırdığımızda, doğru olan bütün sonuçlar listelenecektir.
Yani mesela kullanıcı <cite>40</cite> sayısını girmişse, ekrana verilecek çıktı şöyle
olacaktır:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>verdiğiniz sayı 100'den küçüktür.
verdiğiniz sayı 50'den küçüktür.
</pre></div>
</div>
<p>Burada <cite>40</cite> sayısı hem <cite>100</cite>’den, hem de <cite>50</cite>’den küçük olduğu için iki sonuç da
çıktı olarak verilecektir. Ama eğer yukarıdaki kodları şöyle yazarsak:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="nb">input</span><span class="p">(</span><span class="s2">"Bir sayı giriniz: "</span><span class="p">))</span>
<span class="k">if</span> <span class="n">a</span> <span class="o"><</span> <span class="mi">100</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"verdiğiniz sayı 100'den küçüktür."</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">a</span> <span class="o"><</span> <span class="mi">50</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"verdiğiniz sayı 50'den küçüktür."</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">a</span> <span class="o">==</span> <span class="mi">100</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"verdiğiniz sayı 100'dür."</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">a</span> <span class="o">></span> <span class="mi">150</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"verdiğiniz sayı 150'den büyüktür."</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">a</span> <span class="o">></span> <span class="mi">100</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"verdiğiniz sayı 100'den büyüktür."</span><span class="p">)</span>
</pre></div>
</div>
<p>Kullanıcının <cite>40</cite> sayısını girdiğini varsaydığımızda, bu defa programımımız
yalnızca şu çıktıyı verecektir:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>verdiğiniz sayı 100'den küçüktür.
</pre></div>
</div>
<p>Gördüğünüz gibi, <code class="docutils literal notranslate"><span class="pre">elif</span></code> deyimlerini kullandığımız zaman, ekrana yalnızca doğru
olan ilk sonuç veriliyor. Yukarıda <cite>40</cite> sayısı hem <cite>100</cite>’den hem de <cite>50</cite>’den
küçük olduğu halde, Python bu sayının <cite>100</cite>’den küçük olduğunu görür görmez
sonucu ekrana basıp, öteki koşul bloklarını incelemeyi bırakıyor. <code class="docutils literal notranslate"><span class="pre">if</span></code>
deyimlerini arka arkaya sıraladığımızda ise, Python bütün olasılıkları tek tek
değerlendirip, geçerli olan bütün sonuçları ekrana döküyor.</p>
<p>Bir sonraki bölümde <code class="docutils literal notranslate"><span class="pre">else</span></code> deyimini öğrendiğimiz zaman, <code class="docutils literal notranslate"><span class="pre">elif</span></code>’in tam olarak
ne işe yaradığını çok daha iyi anlamanızı sağlayacak bir örnek vereceğiz.</p>
<div class="admonition note">
<p class="admonition-title">Not</p>
<p>Şimdiye kadar verdiğimiz örneklerden de rahatlıkla anlayabileceğiniz
gibi, ilk koşul bloğunda asla <code class="docutils literal notranslate"><span class="pre">elif</span></code> deyimi kullanılamaz. Bu deyimin
kullanılabilmesi için kendisinden önce en az bir adet <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğu olmalıdır.
Yani Python’da koşullu durumları ifade ederken ilk koşul bloğumuz her zaman
<code class="docutils literal notranslate"><span class="pre">if</span></code> deyimi ile başlamalıdır.</p>
</div>
<p><code class="docutils literal notranslate"><span class="pre">elif</span></code>’i de incelediğimize göre, koşul bildiren deyimlerin sonuncusuna göz
atabiliriz: <code class="docutils literal notranslate"><span class="pre">else</span></code></p>
</div>
<div class="section" id="else">
<h3>else<a class="headerlink" href="#else" title="Bu başlık için kalıcı bağlantı">¶</a></h3>
<p>Şimdiye kadar Python’da koşul bildiren iki deyimi öğrendik. Bunlar <code class="docutils literal notranslate"><span class="pre">if</span></code> ve
<code class="docutils literal notranslate"><span class="pre">elif</span></code> idi. Bu bölümde ise koşul deyimlerinin sonuncusu olan <code class="docutils literal notranslate"><span class="pre">else</span></code> deyimini
göreceğiz. Öğrendiğimiz şeyleri şöyle bir gözden geçirecek olursak, temel olarak
şöyle bir durumla karşı karşıya olduğumuzu görürüz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">if</span> <span class="n">falanca</span><span class="p">:</span>
<span class="n">bu</span> <span class="n">işlemi</span> <span class="n">yap</span>
<span class="k">if</span> <span class="n">filanca</span><span class="p">:</span>
<span class="n">şu</span> <span class="n">işlemi</span> <span class="n">yap</span>
</pre></div>
</div>
<p>Veya şöyle bir durum:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">if</span> <span class="n">falanca</span><span class="p">:</span>
<span class="n">bu</span> <span class="n">işlemi</span> <span class="n">yap</span>
<span class="k">elif</span> <span class="n">filanca</span><span class="p">:</span>
<span class="n">şu</span> <span class="n">işlemi</span> <span class="n">yap</span>
</pre></div>
</div>
<p><code class="docutils literal notranslate"><span class="pre">if</span></code> ile <code class="docutils literal notranslate"><span class="pre">elif</span></code> arasındaki farkı biliyoruz. Eğer <code class="docutils literal notranslate"><span class="pre">if</span></code> deyimlerini art arda
sıralayacak olursak, Python doğru olan bütün sonuçları listeleyecektir. Ama eğer
<code class="docutils literal notranslate"><span class="pre">if</span></code> deyiminden sonra <code class="docutils literal notranslate"><span class="pre">elif</span></code> deyimini kullanırsak, Python doğru olan ilk
sonucu listelemekle yetinecektir.</p>
<p>Bu bölümde göreceğimiz <code class="docutils literal notranslate"><span class="pre">else</span></code> deyimi, yukarıdaki tabloya bambaşka bir boyut
kazandırıyor. Dikkat ederseniz şimdiye kadar öğrendiğimiz deyimleri
kullanabilmek için ilgili bütün durumları tanımlamamız gerekiyordu. Yani:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">eğer</span> <span class="n">böyle</span> <span class="n">bir</span> <span class="n">durum</span> <span class="n">varsa</span><span class="p">:</span>
<span class="n">bunu</span> <span class="n">yap</span>
<span class="n">eğer</span> <span class="n">şöyle</span> <span class="n">bir</span> <span class="n">durum</span> <span class="n">varsa</span><span class="p">:</span>
<span class="n">şunu</span> <span class="n">yap</span>
<span class="n">eğer</span> <span class="n">filancaysa</span><span class="p">:</span>
<span class="n">şöyle</span> <span class="n">git</span>
<span class="n">eğer</span> <span class="n">falancaysa</span><span class="p">:</span>
<span class="n">böyle</span> <span class="n">gel</span>
</pre></div>
</div>
<p>gibi…</p>
<p>Ancak her durum için bir <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğu yazmak bir süre sonra yorucu ve sıkıcı
olacaktır. İşte bu noktada devreye <code class="docutils literal notranslate"><span class="pre">else</span></code> deyimi girecek. <code class="docutils literal notranslate"><span class="pre">else</span></code>’in anlamı
kabaca şudur:</p>
<blockquote>
<div><p>Eğer yukarıdaki koşulların hiçbiri gerçekleşmezse…</p>
</div></blockquote>
<p>Gelin isterseniz bununla ilgili şöyle bir örnek verelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">soru</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Bir meyve adı söyleyin bana:"</span><span class="p">)</span>
<span class="k">if</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"elma"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"evet, elma bir meyvedir..."</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"karpuz"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"evet, karpuz bir meyvedir..."</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"armut"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"evet, armut bir meyvedir..."</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="n">soru</span><span class="p">,</span> <span class="s2">"gerçekten bir meyve midir?"</span><span class="p">)</span>
</pre></div>
</div>
<p>Eğer kullanıcı soruya ‘elma’, ‘karpuz’ veya ‘armut’ cevabı verirse, <cite>evet, …
bir meyvedir</cite> çıktısı verilecektir. Ama eğer kullanıcı bu üçü dışında bir cevap
verirse, <cite>… gerçekten bir meyve midir?</cite> çıktısını görürüz. Burada <code class="docutils literal notranslate"><span class="pre">else</span></code>
deyimi, programımıza şu anlamı katıyor:</p>
<blockquote>
<div><p>Eğer kullanıcı yukarıda belirlenen meyve adlarından hiç birini girmez, bunların yerine bambaşka bir şey yazarsa, o zaman <code class="docutils literal notranslate"><span class="pre">else</span></code> bloğu içinde belirtilen işlemi gerçekleştir.</p>
</div></blockquote>
<p>Dikkat ederseniz yukarıdaki kodlarda <code class="docutils literal notranslate"><span class="pre">if</span></code> deyimlerini art arda sıralamak
yerine ilk <code class="docutils literal notranslate"><span class="pre">if</span></code>’ten sonra <code class="docutils literal notranslate"><span class="pre">elif</span></code> ile devam ettik. Peki şöyle bir şey
yazarsak ne olur?</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">soru</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Bir meyve adı söyleyin bana:"</span><span class="p">)</span>
<span class="k">if</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"elma"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"evet, elma bir meyvedir..."</span><span class="p">)</span>
<span class="k">if</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"karpuz"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"evet, karpuz bir meyvedir..."</span><span class="p">)</span>
<span class="k">if</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"armut"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"evet, armut bir meyvedir..."</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="n">soru</span><span class="p">,</span> <span class="s2">"gerçekten bir meyve midir?"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu kodlar beklediğiniz sonucu vermeyecektir. İsterseniz yukarıdaki kodları
çalıştırıp ne demek istediğimizi daha iyi anlayabilirsiniz. Eğer yukarıda olduğu
gibi <code class="docutils literal notranslate"><span class="pre">if</span></code> deyimlerini art arda sıralar ve son olarak da bir <code class="docutils literal notranslate"><span class="pre">else</span></code> bloğu
tanımlarsak, ekrana ilk bakışta anlamsız gibi görünen bir çıktı verilecektir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span>evet, elma bir meyvedir...
elma gerçekten bir meyve midir?
</pre></div>
</div>
<p>Burada olan şey şu:</p>
<p>Soruya ‘elma’ cevabını verdiğimizi düşünelim. Bu durumda, Python ilk olarak ilk
<code class="docutils literal notranslate"><span class="pre">if</span></code> bloğunu değerlendirecek ve soruya verdiğimiz cevap ‘elma’ olduğu için
<cite>evet, elma bir meyvedir…</cite> çıktısını verecektir.</p>
<p><code class="docutils literal notranslate"><span class="pre">if</span></code> ile <code class="docutils literal notranslate"><span class="pre">elif</span></code> arasındaki farkı anlatırken, hatırlarsanız art arda gelen <code class="docutils literal notranslate"><span class="pre">if</span></code> bloklarında Python’ın olası bütün sonuçları değerlendireceğini söylemiştik. İşte burada da böyle bir durum söz konusu. Gördüğünüz gibi, ilk <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğundan sonra yine bir <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğu geliyor. Bu nedenle Python olası bütün sonuçları değerlendirebilmek için blokları okumaya devam edecek ve sorunun cevabı ‘karpuz’ olmadığı için ikinci <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğunu atlayacaktır.</p>
<p>Sonraki blok yine bir <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğu olduğu için Python kodları okumaya devam
ediyor. Ancak sorunun cevabı ‘armut’ da olmadığı için, Python sonraki <code class="docutils literal notranslate"><span class="pre">if</span></code>
bloğunu da geçiyor ve böylece <code class="docutils literal notranslate"><span class="pre">else</span></code> bloğuna ulaşıyor.</p>
<p>Yukarıda verdiğimiz örnekteki gibi art arda <code class="docutils literal notranslate"><span class="pre">if</span></code> deyimlerinin sıralanıp en
sona <code class="docutils literal notranslate"><span class="pre">else</span></code> deyiminin yerleştirildiği durumlarda <code class="docutils literal notranslate"><span class="pre">else</span></code> deyimi sadece bir
önceki <code class="docutils literal notranslate"><span class="pre">if</span></code> deyimini dikkate alarak işlem yapar. Yani yukarıdaki örnekte
kullanıcının verdiği cevap ‘armut’ olmadığı için <code class="docutils literal notranslate"><span class="pre">else</span></code> deyiminin olduğu blok
çalışmaya başlar. Yukarıdaki örneğe ‘armut’ cevabını verirseniz ne demek
istediğimi biraz daha iyi anlayabilirsiniz. ‘armut’ cevabı verilmesi durumunda
sadece <code class="docutils literal notranslate"><span class="pre">if</span> <span class="pre">soru</span> <span class="pre">==</span> <span class="pre">"armut"</span></code> ifadesinin olduğu blok çalışır, <code class="docutils literal notranslate"><span class="pre">else</span></code> bloğu ise
çalışmaz. Çünkü dediğim gibi, eğer <code class="docutils literal notranslate"><span class="pre">else</span></code> bloğundan önce art arda gelen <code class="docutils literal notranslate"><span class="pre">if</span></code>
blokları varsa, <code class="docutils literal notranslate"><span class="pre">else</span></code> deyimi yalnızca kendisinden önceki son <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğunu
dikkate alır ve sanki yukarıdaki örnek şöyleymiş gibi davranır:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">if</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"armut"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"evet, armut bir meyvedir..."</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="n">soru</span><span class="p">,</span> <span class="s2">"gerçekten bir meyve midir?"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu tür durumlarda <code class="docutils literal notranslate"><span class="pre">else</span></code> deyimi bir önceki <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğundan önce gelen bütün
<code class="docutils literal notranslate"><span class="pre">if</span></code> bloklarını görmezden gelir ve böylece şu anlamsız görünen çıktı elde
edilir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span>evet, elma bir meyvedir...
elma gerçekten bir meyve midir?
</pre></div>
</div>
<p>Sözün özü, kullanıcının cevabı ‘elma’ olduğu için, yukarıdaki çıktıda yer alan
ilk cümle ilk <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğunun çalışması sonucu ekrana basılıyor. İkinci cümle
ise <code class="docutils literal notranslate"><span class="pre">else</span></code> bloğundan bir önceki <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğu kullanıcının cevabıyla uyuşmadığı
için ekrana basılıyor.</p>
<p>Yalnız bu dediğimizden, <code class="docutils literal notranslate"><span class="pre">else</span></code> ifadesi <code class="docutils literal notranslate"><span class="pre">if</span></code> ile birlikte kullanılmaz, anlamı
çıkarılmamalı. Mesela şöyle bir örnek yapılabilir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">soru</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Programdan çıkmak istediğinize emin misiniz? </span><span class="se">\</span>
<span class="s2">Eminseniz 'e' harfine basın : "</span><span class="p">)</span>
<span class="k">if</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"e"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Güle güle!"</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Peki, biraz daha sohbet edelim!"</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada eğer kullanıcının cevabı ‘e’ ise <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğu işletilecek, eğer cevap ‘e’
dışında herhangi bir şey ise <code class="docutils literal notranslate"><span class="pre">else</span></code> bloğu çalışacaktır. Gayet mantıklı bir
süreç. Ama eğer yukarıdaki örneğe bir <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğu daha eklerseniz işler
beklediğiniz gibi gitmez:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">soru</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Programdan çıkmak istediğinize emin misiniz? </span><span class="se">\</span>
<span class="s2">Eminseniz 'e' harfine basın : "</span><span class="p">)</span>
<span class="k">if</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"e"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Güle güle!"</span><span class="p">)</span>
<span class="k">if</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"b"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Kararsız kaldım şimdi!"</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Peki, biraz daha sohbet edelim!"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu soruya ‘e’ cevabı verdiğimizi düşünelim. Bu cevap ilk <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğuyla
uyuşuyor ve böylece ekrana <cite>Güle güle!</cite> çıktısı veriliyor. İlk <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğundan
sonra tekrar bir <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğu daha geldiği için Python bütün olasılıkları
değerlendirmek amacıyla blokları okumaya devam ediyor ve cevap ‘b’ olmadığı için
ikinci <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğunu atlıyor ve böylece <code class="docutils literal notranslate"><span class="pre">else</span></code> bloğuna ulaşıyor. Bir önceki
örnekte de söylediğimiz gibi, <code class="docutils literal notranslate"><span class="pre">else</span></code> bloğu art arda gelen <code class="docutils literal notranslate"><span class="pre">if</span></code> blokları
gördüğünde sadece bir önceki <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğunu dikkate aldığı ve kullanıcının
cevabı da ‘b’ olmadığı için ekrana <cite>Peki, biraz daha sohbet edelim!</cite> çıktısını
veriyor ve ilk bakışta tuhaf görünen şöyle bir çıktı üretiyor:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span>Güle güle!
Peki, biraz daha sohbet edelim!
</pre></div>
</div>
<p>Dolayısıyla, eğer programınızda bir <code class="docutils literal notranslate"><span class="pre">else</span></code> bloğuna yer verecekseniz, ondan
önce gelen koşullu durumların ilkini <code class="docutils literal notranslate"><span class="pre">if</span></code> ile sonrakileri ise <code class="docutils literal notranslate"><span class="pre">elif</span></code> ile
bağlayın. Yani:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">if</span> <span class="n">koşul_1</span><span class="p">:</span>
<span class="n">sonuç_1</span>
<span class="k">elif</span> <span class="n">koşul_2</span><span class="p">:</span>
<span class="n">sonuç_2</span>
<span class="k">elif</span> <span class="n">koşul_3</span><span class="p">:</span>
<span class="n">sonuç_3</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">sonuç_4</span>
</pre></div>
</div>
<p>Ama eğer <code class="docutils literal notranslate"><span class="pre">else</span></code> bloğundan önce sadece tek bir koşul bloğu yer alacaksa bunu
<code class="docutils literal notranslate"><span class="pre">if</span></code> ile bağlayın. Yani:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">if</span> <span class="n">koşul_1</span><span class="p">:</span>
<span class="n">sonuç_1</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">sonuç_2</span>
</pre></div>
</div>
<p>Programlarımızın doğru çalışması ve istediğimiz sonucu verebilmesi için bu tür
ayrıntılara olabildiğince dikkat etmemiz gerekiyor. Neticede koşullu durumlar
mantıkla ilgilidir. Dolayısıyla koşullu durumlarla muhatap olurken mantığınızı
hiçbir zaman devre dışı bırakmamalısınız.</p>
<p>Bir önceki bölümde <code class="docutils literal notranslate"><span class="pre">elif</span></code> deyiminin tam olarak ne işe yaradığını anlamamızı
sağlayacak bir örnek vereceğimizi söylemiştik. Şimdi bu örneğe bakalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">boy</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="nb">input</span><span class="p">(</span><span class="s2">"boyunuz kaç cm?"</span><span class="p">))</span>
<span class="k">if</span> <span class="n">boy</span> <span class="o"><</span> <span class="mi">170</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"boyunuz kısa"</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">boy</span> <span class="o"><</span> <span class="mi">180</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"boyunuz normal"</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"boyunuz uzun"</span><span class="p">)</span>
</pre></div>
</div>
<p>Yukarıda yedi satırla hallettiğimiz işi sadece <code class="docutils literal notranslate"><span class="pre">if</span></code> deyimleriyle yapmaya
çalışırsanız bunun ne kadar zor olduğunu göreceksiniz. Diyelim ki kullanıcı
‘165’ cevabını verdi. Python bu <cite>165</cite> sayısının <cite>170</cite>’ten küçük olduğunu görünce
<cite>boyunuz kısa</cite> cevabını verecek, öteki satırları değerlendirmeyecektir. <cite>165</cite>
sayısı, <code class="docutils literal notranslate"><span class="pre">elif</span></code> ile gösterdiğimiz koşullu duruma da uygun olduğu halde (<code class="docutils literal notranslate"><span class="pre">165</span> <span class="pre"><</span>
<span class="pre">180</span></code>), koşul ilk blokta karşılandığı için ikinci blok değerlendirmeye
alınmayacaktır.</p>
<p>Kullanıcının ‘175’ cevabını verdiğini varsayalım: Python <cite>175</cite> sayısını görünce
önce ilk koşula bakacak, verilen <cite>175</cite> sayısının ilk koşulu karşılamadığını
görecektir (<code class="docutils literal notranslate"><span class="pre">175</span> <span class="pre">></span> <span class="pre">170</span></code>). Bunun üzerine Python kodları incelemeye devam edecek
ve <code class="docutils literal notranslate"><span class="pre">elif</span></code> bloğunu değerlendirmeye alacaktır. <cite>175</cite> sayısının <cite>180</cite>’den küçük
olduğunu görünce de çıktı olarak <cite>boyunuz normal</cite> cevabını verecektir.</p>
<p>Peki ya kullanıcı ‘190’ cevabını verirse ne olacak? Python yine önce ilk <code class="docutils literal notranslate"><span class="pre">if</span></code>
bloğuna bakacak ve <cite>190</cite> cevabının bu bloğa uymadığını görecektir. Dolayısıyla
ilk bloğu bırakıp ikinci bloğa bakacaktır. <cite>190</cite> cevabının bu bloğa da
uymadığını görünce, bir sonraki bloğu değerlendirmeye alacaktır. Bir sonraki
blokta ise <code class="docutils literal notranslate"><span class="pre">else</span></code> deyimimiz var. Bu bölümde öğrendiğimiz gibi, <code class="docutils literal notranslate"><span class="pre">else</span></code>
deyimi, ‘eğer kullanıcının cevabı yukarıdaki koşulların hiçbirine uymazsa bu
bloğu çalıştır,’ anlamına geliyor. Kullanıcının girdiği <cite>190</cite> cevabı ne birinci
ne de ikinci bloktaki koşula uyduğu için, normal bir şekilde <code class="docutils literal notranslate"><span class="pre">else</span></code> bloğu
işletilecek, dolayısıyla da ekrana <cite>boyunuz uzun</cite> çıktısı verilecektir.</p>
<p>Böylece Python’da <code class="docutils literal notranslate"><span class="pre">if</span></code>, <code class="docutils literal notranslate"><span class="pre">elif</span></code> ve <code class="docutils literal notranslate"><span class="pre">else</span></code> deyimlerini incelemiş olduk.
Ancak tabii ki bu deyimlerle işimiz henüz bitmedi. Elimizdeki bilgiler şimdilik
bu deyimleri ancak bu kadar incelememize yetiyor, ama ilerleyen sayfalarda bazı
başka araçları da bilgi dağarcığımıza kattıktan sonra bu deyimlerin daha farklı
yönlerini öğrenme imkanına kavuşacağız.</p>
</div>
</div>
<div class="section" id="ornek-uygulama">
<h2>Örnek Uygulama<a class="headerlink" href="#ornek-uygulama" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Önceki derslerimizde <code class="docutils literal notranslate"><span class="pre">len()</span></code> fonksiyonunu anlatırken şöyle bir program
tasarısından bahsetmiştik hatırlarsanız:</p>
<blockquote>
<div><p>Diyelim ki sisteme kayıt için kullanıcı adı ve parola belirlenmesini isteyen
bir program yazıyorsunuz. Yazacağınız bu programda, belirlenebilecek
kullanıcı adı ve parolanın toplam uzunluğu <cite>40</cite> karakteri geçmeyecek.</p>
</div></blockquote>
<p>O zaman henüz koşullu durumları öğrenmemiş olduğumuz için, yukarıda
bahsettiğimiz programın ancak şu kadarlık kısmını yazabilmiştik:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kullanıcı_adı</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Kullanıcı adınız: "</span><span class="p">)</span>
<span class="n">parola</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Parolanız : "</span><span class="p">)</span>
<span class="n">toplam_uzunluk</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">kullanıcı_adı</span><span class="p">)</span> <span class="o">+</span> <span class="nb">len</span><span class="p">(</span><span class="n">parola</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada yapabildiğimiz tek şey, kullanıcıdan kullanıcı adı ve parola bilgilerini
alıp, bu bilgilerin karakter uzunluğunu ölçebilmekti. Ama artık koşullu
durumları öğrendiğimize göre bu programı eksiksiz olarak yazabiliriz. Şu kodları
dikkatlice inceleyin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kullanıcı_adı</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Kullanıcı adınız: "</span><span class="p">)</span>
<span class="n">parola</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Parolanız : "</span><span class="p">)</span>
<span class="n">toplam_uzunluk</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">kullanıcı_adı</span><span class="p">)</span> <span class="o">+</span> <span class="nb">len</span><span class="p">(</span><span class="n">parola</span><span class="p">)</span>
<span class="n">mesaj</span> <span class="o">=</span> <span class="s2">"Kullanıcı adı ve parolanız toplam </span><span class="si">{}</span><span class="s2"> karakterden oluşuyor!"</span>
<span class="nb">print</span><span class="p">(</span><span class="n">mesaj</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">toplam_uzunluk</span><span class="p">))</span>
<span class="k">if</span> <span class="n">toplam_uzunluk</span> <span class="o">></span> <span class="mi">40</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Kullanıcı adınız ile parolanızın "</span><span class="p">,</span>
<span class="s2">"toplam uzunluğu 40 karakteri geçmemeli!"</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Sisteme hoşgeldiniz!"</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada öncelikle kullanıcıdan kullanıcı adı ve parola bilgilerini alıyoruz. Daha
sonra da kullanıcıdan gelen bu bilgilerin toplam karakter uzunluğunu
hesaplıyoruz. Bunun için <code class="docutils literal notranslate"><span class="pre">len()</span></code> fonksiyonundan yararlanmamız gerektiğini
hatırlıyor olmalısınız.</p>
<p>Eğer toplam uzunluk 40 karakterden fazla ise, <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğunda verilen mesajı
gösteriyoruz. Bunun dışındaki bütün durumlarda ise <code class="docutils literal notranslate"><span class="pre">else</span></code> bloğunu devreye
sokuyoruz.</p>
</div>
</div>
<div class='glyph'><a href='https://yazbel.com'>♣</a></div>
<div class='extrarelbar'>
<div class="related" role="navigation" aria-label="related navigation">
<h3>Gezinti</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="islecler.html" title="İşleçler"
>sonraki</a></li>
<li class="right" >
<a href="input.html" title="Kullanıcıdan Bilgi Almak"
>önceki</a> |</li>
<li class="nav-item nav-item-0"><a href=".">⌂</a></li>
<li class="nav-item nav-item-this"><a href="">Koşullu Durumlar</a></li>
</ul>
</div> </div>
<div class='addcomment'>Yorumlar</div>
<div class='how-to-use'>
<h3>Önemli Not</h3>
Eğer yazdığınız yorum içinde kod kullanacaksanız, kodlarınızı
<span class='tag'><pre><code></span> etiketleri içine alın. Örneğin:
<pre>
<span class='tag'><pre><code class="python"></span>
<span class='keyword'>print</span>(<span class='string'>"Merhaba Dünya!"</span>)
<span class='tag'></code></pre></span>
</pre>
</div>
<div id="disqus_thread"></div>
<script type="text/javascript">
/* * * CONFIGURATION VARIABLES * * */
var disqus_shortname = 'istihza';
/* * * DON'T EDIT BELOW THIS LINE * * */
(function() {
var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true;
dsq.src = '//' + disqus_shortname + '.disqus.com/embed.js';
(document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
})();
</script>
<noscript>Please enable JavaScript to view the <a href="https://disqus.com/?ref_noscript" rel="nofollow">comments powered by Disqus.</a></noscript>
<script type="text/javascript" src="//s7.addthis.com/js/300/addthis_widget.js#pubid=ra-4eca48eb2d83faf9" async="async"></script>
<div class="clearer"></div>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related" role="navigation" aria-label="related navigation">
<h3>Gezinti</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="islecler.html" title="İşleçler"
>sonraki</a></li>
<li class="right" >
<a href="input.html" title="Kullanıcıdan Bilgi Almak"
>önceki</a> |</li>
<li class="nav-item nav-item-0"><a href=".">⌂</a></li>
<li class="nav-item nav-item-this"><a href="">Koşullu Durumlar</a></li>
</ul>
</div>
<div class="footer">
© Copyright 2007-2020, Fırat Özgül | <a href="https://yazbel.com">yazbel.com</a>.
Son güncelleme: 08.08.2020.
<a href="http://sphinx-doc.org/">Sphinx</a> 3.2.0 kullanılarak oluşturuldu.
<br>
<br>
<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/3.0/"><img
alt="Creative Commons License" style="border-width:0"
src="https://i.creativecommons.org/l/by-nc-sa/3.0/88x31.png" /></a><br />
<br>
</div>
<!-- Start of StatCounter Code for Default Guide -->
<script type="text/javascript">
var sc_project=10396326;
var sc_invisible=1;
var sc_security="fb5cd679";
var scJsHost = (("https:" == document.location.protocol) ?
"https://secure." : "http://www.");
document.write("<sc"+"ript type='text/javascript' src='" +
scJsHost+
"statcounter.com/counter/counter.js'></"+"script>");
</script>
<noscript><div class="statcounter"><a title="hit counter"
href="http://statcounter.com/" target="_blank"><img
class="statcounter"
src="http://c.statcounter.com/10396326/0/fb5cd679/1/"
alt="hit counter"></a></div></noscript>
<!-- End of StatCounter Code for Default Guide -->
</body>
</html>