forked from yazbel/python-istihza
-
Notifications
You must be signed in to change notification settings - Fork 0
/
donguler.html
2112 lines (1948 loc) · 184 KB
/
donguler.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 döngülerden bahsedeceğiz." name="description" />
<meta content="python, döngüler, loops, for, while , else" name="keywords" />
<title>Döngüler (Loops) — 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="Hata Yakalama" href="hata_yakalama.html" />
<link rel="prev" title="İşleçler" href="islecler.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="hata_yakalama.html" title="Hata Yakalama"
accesskey="N">sonraki</a></li>
<li class="right" >
<a href="islecler.html" title="İşleçler"
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="">Döngüler (Loops)</a></li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="body" role="main">
<div class="section" id="donguler-loops">
<h1>Döngüler (Loops)<a class="headerlink" href="#donguler-loops" title="Bu başlık için kalıcı bağlantı">¶</a></h1>
<p>Şimdiye kadar öğrendiklerimiz sayesinde Python’la ufak tefek programlar
yazabilecek düzeye geldik. Mesela öğrendiğimiz bilgiler yardımıyla bir önceki
bölümde çok basit bir hesap makinesi yazabilmiştik. Yalnız o hesap makinesinde
farkettiyseniz çok önemli bir eksiklik vardı. Hesap makinemizle hesap yaptıktan
sonra programımız kapanıyor, yeni hesap yapabilmek için programı yeniden
başlatmamız gerekiyordu.</p>
<p>Hesap makinesi programındaki sorun, örneğin, aşağıdaki program için de
geçerlidir:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">tuttuğum_sayı</span> <span class="o">=</span> <span class="mi">23</span>
<span class="n">bilbakalım</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">"Aklımdan bir sayı tuttum. Bil bakalım kaç tuttum? "</span><span class="p">))</span>
<span class="k">if</span> <span class="n">bilbakalım</span> <span class="o">==</span> <span class="n">tuttuğum_sayı</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Tebrikler! Bildiniz..."</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">"Ne yazık ki tuttuğum sayı bu değildi..."</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada <cite>tuttuğum_sayı</cite> adlı bir değişken belirledik. Bu değişkenin değeri <cite>23</cite>.
Kullanıcıdan tuttuğumuz sayıyı tahmin etmesini istiyoruz. Eğer kullanıcının
verdiği cevap <cite>tuttuğum_sayı</cite> değişkeninin değeriyle aynıysa (yani <cite>23</cite> ise),
ekrana ‘Tebrikler!…’ yazısı dökülecektir. Aksi halde ‘Ne yazık ki…’ cümlesi
ekrana dökülecektir.</p>
<p>Bu program iyi, hoş, ama çok önemli bir eksiği var. Bu programı yalnızca bir kez
kullanabiliyoruz. Yani kullanıcı yalnızca bir kez tahminde bulunabiliyor. Eğer
kullanıcı bir kez daha tahminde bulunmak isterse programı yeniden çalıştırması
gerekecek. Bunun hiç iyi bir yöntem olmadığı ortada. Halbuki yazdığımız bir
program, ilk çalışmanın ardından kapanmasa, biz bu programı tekrar tekrar
çalıştırabilsek, programımız sürekli olarak başa dönse ve program ancak biz
istediğimizde kapansa ne iyi olurdu değil mi? Yani mesela yukarıdaki örnekte
kullanıcı bir sayı tahmin ettikten sonra, eğer bu sayı bizim tuttuğumuz sayıyla
aynı değilse, kullanıcıya tekrar tahmin etme fırsatı verebilsek çok hoş
olurdu…</p>
<p>Yukarıda açıklamaya çalıştığımız süreç, yani bir sürecin tekrar tekrar devam
etmesi Python’da ‘döngü’ (<em>loop</em>) olarak adlandırılır.</p>
<p>İşte bu bölümde, programlarımızın sürekli olarak çalışmasını nasıl
sağlayabileceğimizi, yani programlarımızı bir döngü içine nasıl sokabileceğimizi
öğreneceğiz.</p>
<p>Python’da programlarımızı tekrar tekrar çalıştırabilmek için döngü adı verilen
bazı ifadelerden yararlanacağız.</p>
<p>Python’da iki tane döngü bulunur: <code class="docutils literal notranslate"><span class="pre">while</span></code> ve <code class="docutils literal notranslate"><span class="pre">for</span></code></p>
<p>Dilerseniz işe <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsü ile başlayalım.</p>
<div class="section" id="while-dongusu">
<h2>while Döngüsü<a class="headerlink" href="#while-dongusu" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>İngilizce bir kelime olan <em>while</em>, Türkçede ‘… iken, … olduğu sürece’ gibi
anlamlara gelir. Python’da <code class="docutils literal notranslate"><span class="pre">while</span></code> bir döngüdür. Bir önceki bölümde
söylediğimiz gibi, döngüler sayesinde programlarımızın sürekli olarak
çalışmasını sağlayabiliriz.</p>
<p>Bu bölümde Python’da <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsünün ne olduğunu ve ne işe yaradığını
anlamaya çalışacağız. Öncelikle <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsünün temellerini kavrayarak işe
başlayalım.</p>
<p>Basit bir <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsü kabaca şuna benzer:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">while</span> <span class="n">a</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
</pre></div>
</div>
<p>Burada <cite>a</cite> adlı bir değişken oluşturduk. Bu değişkenin değeri <cite>1</cite>. Bir sonraki
satırda ise <code class="docutils literal notranslate"><span class="pre">while</span> <span class="pre">a</span> <span class="pre">==</span> <span class="pre">1:</span></code> gibi bir ifade yazdık. En başta da söylediğimiz
gibi <em>while</em> kelimesi, ‘… iken, olduğu sürece’ gibi anlamlar taşıyor. Python
programlama dilindeki anlamı da buna oldukça yakındır. Burada <code class="docutils literal notranslate"><span class="pre">while</span> <span class="pre">a</span> <span class="pre">==</span> <span class="pre">1</span></code>
ifadesi programımıza şöyle bir anlam katıyor:</p>
<blockquote>
<div><p><cite>a</cite> değişkeninin değeri <cite>1</cite> olduğu sürece…</p>
</div></blockquote>
<p>Gördüğünüz gibi cümlemiz henüz eksik. Yani belli ki bunun bir de devamı olacak.
Ayrıca <code class="docutils literal notranslate"><span class="pre">while</span></code> ifadesinin sonundaki <cite>:</cite> işaretinden anladığımız gibi, bundan
sonra gelecek satır girintili yazılacak. Devam edelim:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">while</span> <span class="n">a</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"bilgisayar çıldırdı!"</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada Python’a şu emri vermiş olduk:</p>
<blockquote>
<div><p><cite>a</cite> değişkeninin değeri <cite>1</cite> olduğu sürece, ekrana ‘bilgisayar çıldırdı!’
yazısını dök!</p>
</div></blockquote>
<p>Bu programı çalıştırdığımızda Python verdiğimiz emre sadakatle uyacak ve <cite>a</cite>
değişkeninin değeri <cite>1</cite> olduğu müddetçe de bilgisayarımızın ekranına ‘bilgisayar
çıldırdı!’ yazısını dökecektir. Programımızın içinde <cite>a</cite> değişkeninin değeri <cite>1</cite>
olduğu ve bu değişkenin değerini değiştirecek herhangi bir şey bulunmadığı için
Python hiç sıkılmadan ekrana ‘bilgisayar çıldırdı!’ yazısını basmaya devam
edecektir. Eğer siz durdurmazsanız bu durum sonsuza kadar devam edebilir. Bu
çılgınlığa bir son vermek için klavyenizde <cite>Ctrl+C</cite> veya <cite>Ctrl+Z</cite> tuşlarına
basarak programı durmaya zorlayabilirsiniz.</p>
<p>Burada programımızı sonsuz bir döngüye sokmuş olduk (<em>infinite loop</em>). Esasında
sonsuz döngüler genellikle bir program hatasına işaret eder. Yani çoğu durumda
programcının arzu ettiği şey bu değildir. O yüzden doğru yaklaşım, döngüye
soktuğumuz programlarımızı durduracak bir ölçüt belirlemektir. Yani öyle bir kod
yazmalıyız ki, <cite>a</cite> değişkeninin <cite>1</cite> olan değeri bir noktadan sonra artık <cite>1</cite>
olmasın ve böylece o noktaya ulaşıldığında programımız dursun. Kullanıcının
<cite>Ctrl+C</cite> tuşlarına basarak programı durdurmak zorunda kalması pek hoş olmuyor.
Gelin isterseniz bu soyut ifadeleri biraz somutlaştıralım.</p>
<p>Öncelikle şu satırı yazarak işe başlıyoruz:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="o">=</span> <span class="mi">1</span>
</pre></div>
</div>
<p>Burada normal bir şekilde <cite>a</cite> değişkenine <cite>1</cite> değerini atadık. Şimdi devam
ediyoruz:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">while</span> <span class="n">a</span> <span class="o"><</span> <span class="mi">10</span><span class="p">:</span>
</pre></div>
</div>
<p><code class="docutils literal notranslate"><span class="pre">while</span></code> ile verdiğimiz ilk örnekte <code class="docutils literal notranslate"><span class="pre">while</span> <span class="pre">a</span> <span class="pre">==</span> <span class="pre">1</span></code> gibi bir ifade
kullanmıştık. Bu ifade;</p>
<blockquote>
<div><p><cite>a</cite>’nın değeri <cite>1</cite> olduğu müddetçe…</p>
</div></blockquote>
<p>gibi bir anlama geliyordu.</p>
<p><code class="docutils literal notranslate"><span class="pre">while</span> <span class="pre">a</span> <span class="pre"><</span> <span class="pre">10</span></code> ifadesi ise;</p>
<blockquote>
<div><p><cite>a</cite>’nın değeri <cite>10</cite>’dan küçük olduğu müddetçe…</p>
</div></blockquote>
<p>anlamına gelir. İşte burada programımızın sonsuz döngüye girmesini engelleyecek
bir ölçüt koymuş olduk. Buna göre, <cite>a</cite> değişkeninin şimdiki değeri <cite>1</cite>’dir. Biz,
<cite>a</cite>’nın değeri <cite>10</cite>’dan küçük olduğu müddetçe bir işlem yapacağız. Devam
edelim:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">while</span> <span class="n">a</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">"bilgisayar yine çıldırdı!"</span><span class="p">)</span>
</pre></div>
</div>
<p>Ne oldu? İstediğimizi elde edemedik, değil mi? Programımız yine sonsuz döngüye
girdi. Bu sonsuz döngüyü kırmak için <cite>Ctrl+C</cite> (veya <cite>Ctrl+Z</cite>)’ye basmamız
gerekecek yine…</p>
<p>Sizce buradaki hata nereden kaynaklandı? Yani neyi eksik yaptık da programımız
sonsuz döngüye girmekten kurtulamadı? Aslında bunun cevabı çok basit. Biz
yukarıdaki kodları yazarak Python’a şu emri vermiş olduk:</p>
<blockquote>
<div><p><cite>a</cite>’nın değeri <cite>10</cite>’dan küçük olduğu müddetçe ekrana ‘bilgisayar yine
çıldırdı!’ yazısını bas!</p>
</div></blockquote>
<p><cite>a</cite> değişkeninin değeri <cite>1</cite>. Yani <cite>10</cite>’dan küçük. Dolayısıyla Python’ın ekrana o
çıktıyı basmasını engelleyecek herhangi bir şey yok…</p>
<p>Şimdi bu problemi nasıl aşacağımızı görelim:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">while</span> <span class="n">a</span> <span class="o"><</span> <span class="mi">10</span><span class="p">:</span>
<span class="n">a</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"bilgisayar yine çıldırdı!"</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">+=</span> <span class="pre">1</span></code> satırını ekledik kodlarımızın arasına. <cite>+=</cite> işlecini
anlatırken söylediğimiz gibi, bu satır, <cite>a</cite> değişkeninin değerine her defasında
<cite>1</cite> ekliyor ve elde edilen sonucu tekrar <cite>a</cite> değişkenine atıyor. En sonunda
<cite>a</cite>’nın değeri <cite>10</cite>’a ulaşınca da, Python ekrana ‘bilgisayar yine çıldırdı!’
cümlesini yazmayı bırakıyor. Çünkü <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsü içinde belirttiğimiz ölçüte
göre, programımızın devam edebilmesi için <cite>a</cite> değişkeninin değerinin <cite>10</cite>’dan
küçük olması gerekiyor. <cite>a</cite>’nın değeri <cite>10</cite>’a ulaştığı anda bu ölçüt
bozulacaktır. Gelin isterseniz bu kodları Python’ın nasıl algıladığına bir
bakalım:</p>
<ol class="arabic simple">
<li><p>Python öncelikle <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">=</span> <span class="pre">1</span></code> satırını görüyor ve <cite>a</cite>’nın değerini <cite>1</cite>
yapıyor.</p></li>
<li><p>Daha sonra <cite>a</cite>’nın değeri <cite>10</cite>’dan küçük olduğu müddetçe…
(<code class="docutils literal notranslate"><span class="pre">while</span> <span class="pre">a</span> <span class="pre"><</span> <span class="pre">10</span></code>) satırını görüyor.</p></li>
<li><p>Ardından <cite>a</cite>’nın değerini, <cite>1</cite> artırıyor (<code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">+=</span> <span class="pre">1</span></code>) ve <cite>a</cite>’nın değeri <cite>2</cite>
oluyor.</p></li>
<li><p><cite>a</cite>’nın değeri (yani <cite>2</cite>) <cite>10</cite>’dan küçük olduğu için Python ekrana ilgili
çıktıyı veriyor.</p></li>
<li><p>İlk döngüyü bitiren Python başa dönüyor ve <cite>a</cite>’nın değerinin <cite>2</cite> olduğunu
görüyor.</p></li>
<li><p><cite>a</cite>’nın değerini yine <cite>1</cite> artırıyor ve <cite>a</cite>’yı <cite>3</cite> yapıyor.</p></li>
<li><p><cite>a</cite>’nın değeri hâlâ <cite>10</cite>’dan küçük olduğu için ekrana yine ilgili çıktıyı
veriyor.</p></li>
<li><p>İkinci döngüyü de bitiren Python yine başa dönüyor ve <cite>a</cite>’nın
değerinin <cite>3</cite> olduğunu görüyor.</p></li>
<li><p>Yukarıdaki adımları tekrar eden Python, <cite>a</cite>’nın değeri <cite>9</cite> olana kadar
ilerlemeye devam ediyor.</p></li>
<li><p><cite>a</cite>’nın değeri <cite>9</cite>’a ulaştığında Python <cite>a</cite>’nın değerini bir kez daha
artırınca bu değer <cite>10</cite>’a ulaşıyor.</p></li>
<li><p>Python <cite>a</cite>’nın değerinin artık <cite>10</cite>’dan küçük olmadığını görüyor ve
programdan çıkıyor.</p></li>
</ol>
<p>Yukarıdaki kodları şöyle yazarsak belki durum daha anlaşılır olabilir:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">while</span> <span class="n">a</span> <span class="o"><</span> <span class="mi">10</span><span class="p">:</span>
<span class="n">a</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="nb">print</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada Python’un arkada ne işler çevirdiğini daha net görebiliyoruz. Kodlarımız
içine eklediğimiz <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsü sayesinde Python her defasında <cite>a</cite>
değişkeninin değerini kontrol ediyor ve bu değer <cite>10</cite>’dan küçük olduğu müddetçe
<cite>a</cite> değişkeninin değerini <cite>1</cite> artırıp, yeni değeri ekrana basıyor. Bu değişkenin
değeri <cite>10</cite>’a ulaştığında ise, bu değerin artık <cite>10</cite>’dan küçük olmadığını
anlayıp bütün işlemleri durduruyor.</p>
<p>Gelin isterseniz bu <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsünü daha önce yazdığımız hesap makinemize
uygulayalım:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">giriş</span> <span class="o">=</span> <span class="s2">"""</span>
<span class="s2">(1) topla</span>
<span class="s2">(2) çıkar</span>
<span class="s2">(3) çarp</span>
<span class="s2">(4) böl</span>
<span class="s2">(5) karesini hesapla</span>
<span class="s2">(6) karekök hesapla</span>
<span class="s2">"""</span>
<span class="nb">print</span><span class="p">(</span><span class="n">giriş</span><span class="p">)</span>
<span class="n">anahtar</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">while</span> <span class="n">anahtar</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
<span class="n">soru</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Yapmak istediğiniz işlemin numarasını girin (Çıkmak için q): "</span><span class="p">)</span>
<span class="k">if</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"q"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"çıkılıyor..."</span><span class="p">)</span>
<span class="n">anahtar</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">elif</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"1"</span><span class="p">:</span>
<span class="n">sayı1</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">"Toplama işlemi için ilk sayıyı girin: "</span><span class="p">))</span>
<span class="n">sayı2</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">"Toplama işlemi için ikinci sayıyı girin: "</span><span class="p">))</span>
<span class="nb">print</span><span class="p">(</span><span class="n">sayı1</span><span class="p">,</span> <span class="s2">"+"</span><span class="p">,</span> <span class="n">sayı2</span><span class="p">,</span> <span class="s2">"="</span><span class="p">,</span> <span class="n">sayı1</span> <span class="o">+</span> <span class="n">sayı2</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"2"</span><span class="p">:</span>
<span class="n">sayı3</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">"Çıkarma işlemi için ilk sayıyı girin: "</span><span class="p">))</span>
<span class="n">sayı4</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">"Çıkarma işlemi için ikinci sayıyı girin: "</span><span class="p">))</span>
<span class="nb">print</span><span class="p">(</span><span class="n">sayı3</span><span class="p">,</span> <span class="s2">"-"</span><span class="p">,</span> <span class="n">sayı4</span><span class="p">,</span> <span class="s2">"="</span><span class="p">,</span> <span class="n">sayı3</span> <span class="o">-</span> <span class="n">sayı4</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"3"</span><span class="p">:</span>
<span class="n">sayı5</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">"Çarpma işlemi için ilk sayıyı girin: "</span><span class="p">))</span>
<span class="n">sayı6</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">"Çarpma işlemi için ikinci sayıyı girin: "</span><span class="p">))</span>
<span class="nb">print</span><span class="p">(</span><span class="n">sayı5</span><span class="p">,</span> <span class="s2">"x"</span><span class="p">,</span> <span class="n">sayı6</span><span class="p">,</span> <span class="s2">"="</span><span class="p">,</span> <span class="n">sayı5</span> <span class="o">*</span> <span class="n">sayı6</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"4"</span><span class="p">:</span>
<span class="n">sayı7</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">"Bölme işlemi için ilk sayıyı girin: "</span><span class="p">))</span>
<span class="n">sayı8</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">"Bölme işlemi için ikinci sayıyı girin: "</span><span class="p">))</span>
<span class="nb">print</span><span class="p">(</span><span class="n">sayı7</span><span class="p">,</span> <span class="s2">"/"</span><span class="p">,</span> <span class="n">sayı8</span><span class="p">,</span> <span class="s2">"="</span><span class="p">,</span> <span class="n">sayı7</span> <span class="o">/</span> <span class="n">sayı8</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"5"</span><span class="p">:</span>
<span class="n">sayı9</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">"Karesini hesaplamak istediğiniz sayıyı girin: "</span><span class="p">))</span>
<span class="nb">print</span><span class="p">(</span><span class="n">sayı9</span><span class="p">,</span> <span class="s2">"sayısının karesi ="</span><span class="p">,</span> <span class="n">sayı9</span> <span class="o">**</span> <span class="mi">2</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"6"</span><span class="p">:</span>
<span class="n">sayı10</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">"Karekökünü hesaplamak istediğiniz sayıyı girin: "</span><span class="p">))</span>
<span class="nb">print</span><span class="p">(</span><span class="n">sayı10</span><span class="p">,</span> <span class="s2">"sayısının karekökü = "</span><span class="p">,</span> <span class="n">sayı10</span> <span class="o">**</span> <span class="mf">0.5</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">"Yanlış giriş."</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Aşağıdaki seçeneklerden birini giriniz:"</span><span class="p">,</span> <span class="n">giriş</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada ilave olarak şu satırları görüyorsunuz:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">anahtar</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">while</span> <span class="n">anahtar</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
<span class="n">soru</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Yapmak istediğiniz işlemin numarasını girin (Çıkmak için q): "</span><span class="p">)</span>
<span class="k">if</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"q"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"çıkılıyor..."</span><span class="p">)</span>
<span class="n">anahtar</span> <span class="o">=</span> <span class="mi">0</span>
</pre></div>
</div>
<p>Bu kodlarda yaptığımız şey aslında çok basit. Öncelikle değeri <cite>1</cite> olan
<cite>anahtar</cite> adlı bir değişken tanımladık. Bir alt satırda ise, programımızın
sürekli olarak çalışmasını sağlayacak olan <code class="docutils literal notranslate"><span class="pre">while</span></code> döngümüzü yazıyoruz.
Programımız, <cite>anahtar</cite> değişkeninin değeri <cite>1</cite> olduğu müddetçe çalışmaya devam
edecek. Daha önce de dediğimiz gibi, eğer bu <cite>anahtar</cite> değişkeninin değerini
programın bir noktasında değiştirmezsek programımız sonsuza kadar çalışmaya
devam edecektir. Çünkü biz programımızı <cite>anahtar</cite> değişkeninin değeri <cite>1</cite> olduğu
sürece çalışmaya ayarladık. İşte programımızın bu tür bir sonsuz döngüye
girmesini önlemek için bir <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğu oluşturuyoruz. Buna göre, eğer kullanıcı
klavyede <cite>q</cite> tuşuna basarsa programımız önce <cite>çıkılıyor…</cite> çıktısı verecek,
ardından da <cite>anahtar</cite> değişkeninin <cite>1</cite> olan değerini <cite>0</cite> yapacaktır. Böylece
artık <cite>anahtar</cite>’ın değeri <cite>1</cite> olmayacağı için programımız çalışmaya son
verecektir.</p>
<p>Buradaki mantığın ne kadar basit olduğunu görmenizi isterim. Önce bir değişken
tanımlıyoruz, ardından bu değişkenin değeri aynı kaldığı müddetçe programımızı
çalışmaya ayarlıyoruz. Bu döngüyü kırmak için de başta tanımladığımız o
değişkene başka bir değer atıyoruz. Burada <cite>anahtar</cite> değişkenine atadığımız <cite>1</cite>
ve <cite>0</cite> değerleri tamamen tesadüfidir. Yani siz bu değerleri istediğiniz gibi
değiştirebilirsiniz. Mesela yukarıdaki kodları şöyle de yazabilirsiniz:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">anahtar</span> <span class="o">=</span> <span class="s2">"hoyda bre!"</span>
<span class="c1">#anahtar'ın değeri 'hoyda bre!' olduğu müddetçe aşağıdaki bloğu</span>
<span class="c1">#çalıştırmaya devam et.</span>
<span class="k">while</span> <span class="n">anahtar</span> <span class="o">==</span> <span class="s2">"hoyda bre!"</span><span class="p">:</span>
<span class="n">soru</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Yapmak istediğiniz işlemin numarasını girin (Çıkmak için q): "</span><span class="p">)</span>
<span class="k">if</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"q"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"çıkılıyor..."</span><span class="p">)</span>
<span class="n">anahtar</span> <span class="o">=</span> <span class="s2">"dur yolcu!"</span>
<span class="c1">#anahtar'ın değeri artık 'hoyda bre!' değil, 'dur yolcu'</span>
<span class="c1">#olduğu için döngüden çık ve böylece programı sona erdirmiş ol.</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, amaç herhangi bir değişkene herhangi bir değer atamak ve o
değer aynı kaldığı müddetçe programın çalışmaya devam etmesini sağlamak.
Kurduğumuz bu döngüyü kırmak için de o değişkene herhangi başka bir değer
atamak…</p>
<p>Yukarıda verdiğimiz son örnekte önce <cite>anahtar</cite> adlı bir değişken atayıp,
<code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsünün işleyişini bu değişkenin değerine göre yapılandırdık. Ama
aslında yukarıdaki kodları çok daha basit bir şekilde de yazabiliriz. Dikkatlice
bakın:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
<span class="n">soru</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Yapmak istediğiniz işlemin numarasını girin (Çıkmak için q): "</span><span class="p">)</span>
<span class="k">if</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"q"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"çıkılıyor..."</span><span class="p">)</span>
<span class="k">break</span>
</pre></div>
</div>
<p>Bu yapıyı hesap makinemize uygulayalım:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">giriş</span> <span class="o">=</span> <span class="s2">"""</span>
<span class="s2">(1) topla</span>
<span class="s2">(2) çıkar</span>
<span class="s2">(3) çarp</span>
<span class="s2">(4) böl</span>
<span class="s2">(5) karesini hesapla</span>
<span class="s2">(6) karekök hesapla</span>
<span class="s2">"""</span>
<span class="nb">print</span><span class="p">(</span><span class="n">giriş</span><span class="p">)</span>
<span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
<span class="n">soru</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Yapmak istediğiniz işlemin numarasını girin (Çıkmak için q): "</span><span class="p">)</span>
<span class="k">if</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"q"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"çıkılıyor..."</span><span class="p">)</span>
<span class="k">break</span>
<span class="k">elif</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"1"</span><span class="p">:</span>
<span class="n">sayı1</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">"Toplama işlemi için ilk sayıyı girin: "</span><span class="p">))</span>
<span class="n">sayı2</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">"Toplama işlemi için ikinci sayıyı girin: "</span><span class="p">))</span>
<span class="nb">print</span><span class="p">(</span><span class="n">sayı1</span><span class="p">,</span> <span class="s2">"+"</span><span class="p">,</span> <span class="n">sayı2</span><span class="p">,</span> <span class="s2">"="</span><span class="p">,</span> <span class="n">sayı1</span> <span class="o">+</span> <span class="n">sayı2</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"2"</span><span class="p">:</span>
<span class="n">sayı3</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">"Çıkarma işlemi için ilk sayıyı girin: "</span><span class="p">))</span>
<span class="n">sayı4</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">"Çıkarma işlemi için ikinci sayıyı girin: "</span><span class="p">))</span>
<span class="nb">print</span><span class="p">(</span><span class="n">sayı3</span><span class="p">,</span> <span class="s2">"-"</span><span class="p">,</span> <span class="n">sayı4</span><span class="p">,</span> <span class="s2">"="</span><span class="p">,</span> <span class="n">sayı3</span> <span class="o">-</span> <span class="n">sayı4</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"3"</span><span class="p">:</span>
<span class="n">sayı5</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">"Çarpma işlemi için ilk sayıyı girin: "</span><span class="p">))</span>
<span class="n">sayı6</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">"Çarpma işlemi için ikinci sayıyı girin: "</span><span class="p">))</span>
<span class="nb">print</span><span class="p">(</span><span class="n">sayı5</span><span class="p">,</span> <span class="s2">"x"</span><span class="p">,</span> <span class="n">sayı6</span><span class="p">,</span> <span class="s2">"="</span><span class="p">,</span> <span class="n">sayı5</span> <span class="o">*</span> <span class="n">sayı6</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"4"</span><span class="p">:</span>
<span class="n">sayı7</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">"Bölme işlemi için ilk sayıyı girin: "</span><span class="p">))</span>
<span class="n">sayı8</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">"Bölme işlemi için ikinci sayıyı girin: "</span><span class="p">))</span>
<span class="nb">print</span><span class="p">(</span><span class="n">sayı7</span><span class="p">,</span> <span class="s2">"/"</span><span class="p">,</span> <span class="n">sayı8</span><span class="p">,</span> <span class="s2">"="</span><span class="p">,</span> <span class="n">sayı7</span> <span class="o">/</span> <span class="n">sayı8</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"5"</span><span class="p">:</span>
<span class="n">sayı9</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">"Karesini hesaplamak istediğiniz sayıyı girin: "</span><span class="p">))</span>
<span class="nb">print</span><span class="p">(</span><span class="n">sayı9</span><span class="p">,</span> <span class="s2">"sayısının karesi ="</span><span class="p">,</span> <span class="n">sayı9</span> <span class="o">**</span> <span class="mi">2</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"6"</span><span class="p">:</span>
<span class="n">sayı10</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">"Karekökünü hesaplamak istediğiniz sayıyı girin: "</span><span class="p">))</span>
<span class="nb">print</span><span class="p">(</span><span class="n">sayı10</span><span class="p">,</span> <span class="s2">"sayısının karekökü = "</span><span class="p">,</span> <span class="n">sayı10</span> <span class="o">**</span> <span class="mf">0.5</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">"Yanlış giriş."</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Aşağıdaki seçeneklerden birini giriniz:"</span><span class="p">,</span> <span class="n">giriş</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu yapı sayesinde <cite>anahtar</cite> gibi bir değişken atama zorunluluğundan kurtulmuş
olduk. Yukarıdaki kodların nasıl çalıştığını açıklayalım:</p>
<p><cite>while True</cite> ifadesi şöyle bir anlama gelir:</p>
<blockquote>
<div><p><cite>True</cite> olduğu müddetçe…</p>
</div></blockquote>
<p>Peki ne <cite>True</cite> olduğu müddetçe? Burada neyin <cite>True</cite> olması gerektiğini
belirtmediğimiz için, aslında bu kod parçası şu anlama geliyor:</p>
<blockquote>
<div><p>Aksi belirtilmediği sürece çalışmaya devam et!</p>
</div></blockquote>
<p>Eğer yukarıdaki açıklamayı biraz bulanık bulduysanız şu örneği
inceleyebilirsiniz:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Bilgisayar çıldırdı!"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu kodları çalıştırdığınızda ekrana sürekli olarak <cite>Bilgisayar çıldırdı!</cite>
çıktısı verilecektir. Bu döngüden çıkabilmek için <cite>Ctrl+C</cite> tuşlarına basmanız
gerekiyor. Yukarıdaki kodların sonsuz döngüye girmesinin sorumlusu <cite>while True</cite>
satırıdır. Çünkü burada biz Python’a;</p>
<blockquote>
<div><p>Aksi belirtilmediği sürece çalışmaya devam et!</p>
</div></blockquote>
<p>emri veriyoruz. Python da bu emrimizi sadakatle yerine getiriyor. Böyle bir
durumda sonsuz döngüyü engellemek için programımızın bir yerinde Python’a bu
döngüden çıkmasını sağlayacak bir emir vermemiz gerekiyor. Biz hesap makinesi
programımızda bu döngüyü şu şekilde kırdık:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">if</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"q"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"çıkılıyor..."</span><span class="p">)</span>
<span class="k">break</span>
</pre></div>
</div>
<p>Dikkat ederseniz burada <code class="docutils literal notranslate"><span class="pre">break</span></code> adlı yeni bir araç görüyoruz. Bu aracın tam
olarak ne işe yaradığını ilerleyen sayfalarda inceleyeceğiz. Şimdilik yalnızca
şunu bilelim: <em>break</em> kelimesi İngilizce’de ‘kırmak, koparmak, bozmak’ gibi
anlamlara gelir. Bu aracın yukarıdaki görevi döngüyü ‘kırmak’tır. Dolayısıyla
kullanıcı klavyede <cite>q</cite> tuşuna bastığında, <code class="docutils literal notranslate"><span class="pre">while</span> <span class="pre">True</span></code> ifadesi ile çalışmaya
başlayan döngü kırılacak ve programımız sona erecektir.</p>
<p>Bu yapıyı daha iyi anlayabilmek için şöyle basit bir örnek daha verelim:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="c1">#Aksi belirtilmediği sürece kullanıcıya</span>
<span class="c1">#aşağıdaki soruyu sormaya devam et!</span>
<span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
<span class="n">soru</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"Nasılsınız, iyi misiniz?"</span><span class="p">)</span>
<span class="c1">#Eğer kullanıcı 'q' tuşuna basarsa...</span>
<span class="k">if</span> <span class="n">soru</span> <span class="o">==</span> <span class="s2">"q"</span><span class="p">:</span>
<span class="k">break</span> <span class="c1">#döngüyü kır ve programdan çık.</span>
</pre></div>
</div>
<p>Görüyorsunuz, aslında mantık gayet basit:</p>
<blockquote>
<div><p>Bir döngü oluştur ve bu döngüden çıkmak istediğinde, programın bir yerinde
bu döngüyü sona erdirecek bir koşul meydan getir.</p>
</div></blockquote>
<p>Bu mantığı yukarıdaki örneğe şu şekilde uyguladık:</p>
<blockquote>
<div><p><cite>while True:</cite> ifadesi yardımıyla bir döngü oluştur ve kullanıcı bu döngüden
çıkmak istediğinde (yani <cite>q</cite> tuşuna bastığında), döngüyü kır ve programı
sona erdir.</p>
</div></blockquote>
<p>Gelin isterseniz bu konuyu daha net kavramak için bir örnek daha verelim:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">tekrar</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">while</span> <span class="n">tekrar</span> <span class="o"><=</span> <span class="mi">3</span><span class="p">:</span>
<span class="n">tekrar</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="nb">input</span><span class="p">(</span><span class="s2">"Nasılsınız, iyi misiniz?"</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada programımız kullanıcıya üç kez ‘Nasılsınız, iyi misiniz?’ sorusunu
soracak ve ardından kapanacaktır. Bu kodlarda <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsünü nasıl
kullandığımıza dikkat edin. Aslında programın mantığı çok basit:</p>
<ol class="arabic simple">
<li><p>Öncelikle değeri <cite>1</cite> olan <cite>tekrar</cite> adlı bir değişken tanımlıyoruz.</p></li>
<li><p>Bu değişkenin değeri <cite>3</cite>’e eşit veya <cite>3</cite>’ten küçük olduğu müddetçe (<code class="docutils literal notranslate"><span class="pre">while</span>
<span class="pre">tekrar</span> <span class="pre"><=</span> <span class="pre">3</span></code>) değişkenin değerine <cite>1</cite> ekliyoruz (<code class="docutils literal notranslate"><span class="pre">tekrar</span> <span class="pre">+=</span> <span class="pre">1</span></code>).</p></li>
<li><p>Başka bir deyişle <code class="docutils literal notranslate"><span class="pre">bool(tekrar</span> <span class="pre"><=</span> <span class="pre">3)</span></code> ifadesi <cite>True</cite> olduğu müddetçe
değişkenin değerine <cite>1</cite> ekliyoruz.</p></li>
<li><p><cite>tekrar</cite> değişkenine her <cite>1</cite> ekleyişimizde kullanıcıya ‘Nasılsınız, iyi
misiniz?’ sorusunu soruyoruz (<code class="docutils literal notranslate"><span class="pre">input("Nasılsınız,</span> <span class="pre">iyi</span> <span class="pre">misiniz?")</span></code>).</p></li>
<li><p><cite>tekrar</cite> değişkeninin değeri <cite>3</cite>’ü aştığında <code class="docutils literal notranslate"><span class="pre">bool(tekrar</span> <span class="pre"><=</span> <span class="pre">3)</span></code> ifadesi
artık <cite>False</cite> değeri verdiği için programımız sona eriyor.</p></li>
</ol>
<p>Yukarıdaki uygulamada Python’ın alttan alta neler çevirdiğini daha iyi görmek
için bu uygulamayı şöyle yazmayı deneyin:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">tekrar</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">while</span> <span class="n">tekrar</span> <span class="o"><=</span> <span class="mi">3</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"tekrar: "</span><span class="p">,</span> <span class="n">tekrar</span><span class="p">)</span>
<span class="n">tekrar</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="nb">input</span><span class="p">(</span><span class="s2">"Nasılsınız, iyi misiniz?"</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"bool değeri: "</span><span class="p">,</span> <span class="nb">bool</span><span class="p">(</span><span class="n">tekrar</span> <span class="o"><=</span> <span class="mi">3</span><span class="p">))</span>
</pre></div>
</div>
<p>Daha önce de dediğimiz gibi, bir Python programının nasıl çalıştığını anlamanın
en iyi yolu, program içinde uygun yerlere <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonları
yerleştirerek arka planda hangi kodların hangi çıktıları verdiğini izlemektir.
İşte yukarıda da bu yöntemi kullandık. Yani <cite>tekrar</cite> değişkenininin değerini ve
<code class="docutils literal notranslate"><span class="pre">bool(tekrar</span> <span class="pre"><=</span> <span class="pre">3)</span></code> ifadesinin çıktısını ekrana yazdırarak arka tarafta neler
olup bittiğini canlı canlı görme imkanına kavuştuk.</p>
<p>Yukarıdaki programı çalıştırdığımızda şuna benzer çıktılar görüyoruz:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span>tekrar: 1
Nasılsınız, iyi misiniz? evet
bool değeri: True
tekrar: 2
Nasılsınız, iyi misiniz? evet
bool değeri: True
tekrar: 3
Nasılsınız, iyi misiniz? evet
bool değeri: False
</pre></div>
</div>
<p>Gördüğünüz gibi, <cite>tekrar</cite> değişkeninin değeri her döngüde <cite>1</cite> artıyor. <code class="docutils literal notranslate"><span class="pre">tekrar</span>
<span class="pre"><=</span> <span class="pre">3</span></code> ifadesinin bool değeri, <cite>tekrar</cite> adlı değişkenin değeri <cite>3</cite>’ü aşana kadar
hep <cite>True</cite> olacaktır. Bu değişkenin değeri <cite>3</cite>’ü aştığı anda <code class="docutils literal notranslate"><span class="pre">tekrar</span> <span class="pre"><=</span> <span class="pre">3</span></code>
ifadesinin bool değeri <cite>False</cite>’a dönüyor ve böylece <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsü sona
eriyor.</p>
<p>Peki size şöyle bir soru sorsam: Acaba <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsünü kullanarak <cite>1</cite>’den
<cite>100</cite>’e kadar olan aralıktaki çift sayıları nasıl bulursunuz?</p>
<p>Çok basit:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">while</span> <span class="n">a</span> <span class="o"><</span> <span class="mi">100</span><span class="p">:</span>
<span class="n">a</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">if</span> <span class="n">a</span> <span class="o">%</span> <span class="mi">2</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="n">a</span><span class="p">)</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsünün içine bir adet <code class="docutils literal notranslate"><span class="pre">if</span></code> bloğu yerleştirdik.</p>
<p>Yukarıdaki kodları şu şekilde Türkçeye çevirebiliriz:</p>
<blockquote>
<div><p><cite>a</cite> değişkeninin değeri <cite>100</cite>’den küçük olduğu müddetçe <cite>a</cite> değişkeninin
değerini <cite>1</cite> artır. Bu değişkenin değerini her artırışında yeni değerin
<cite>2</cite>’ye tam bölünüp bölünmediğini kontrol et. Eğer <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">modülüs</span> <span class="pre">2</span></code> değeri <cite>0</cite>
ise (<code class="docutils literal notranslate"><span class="pre">if</span> <span class="pre">a</span> <span class="pre">%</span> <span class="pre">2</span> <span class="pre">==</span> <span class="pre">0</span></code>), yani <cite>a</cite>’nın değeri bir çift sayı ise, bu değeri
ekrana yazdır.</p>
</div></blockquote>
<p>Gördüğünüz gibi, <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsü son derece kullanışlı bir araçtır. Üstelik
kullanımı da son derece kolaydır. Bu döngüyle bol bol pratik yaparak bu döngüyü
rahatça kullanabilecek duruma gelebilirsiniz.</p>
<p>En başta da söylediğimiz gibi, Python’da <code class="docutils literal notranslate"><span class="pre">while</span></code> dışında bir de <code class="docutils literal notranslate"><span class="pre">for</span></code>
döngüsü vardır. En az <code class="docutils literal notranslate"><span class="pre">while</span></code> kadar önemli bir döngü olan <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsünün
nasıl kullanıldığını anlamaya çalışalım şimdi de.</p>
</div>
<div class="section" id="for-dongusu">
<h2>for Döngüsü<a class="headerlink" href="#for-dongusu" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Etrafta yazılmış Python programlarının kaynak kodlarını incelediğinizde, içinde
<code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü geçmeyen bir program kolay kolay bulamazsınız. Belki <code class="docutils literal notranslate"><span class="pre">while</span></code>
döngüsünün kullanılmadığı programlar vardır. Ancak <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü Python’da o
kadar yaygındır ve o kadar geniş bir kullanım alanına sahiptir ki, hemen hemen
bütün Python programları bu <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsünden en az bir kez yararlanır.</p>
<p>Peki nedir bu <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü denen şey?</p>
<p><code class="docutils literal notranslate"><span class="pre">for</span></code> da tıpkı <code class="docutils literal notranslate"><span class="pre">while</span></code> gibi bir döngüdür. Yani tıpkı <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsünde
olduğu gibi, programlarımızın birden fazla sayıda çalışmasını sağlar. Ancak
<code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsüne göre biraz daha yeteneklidir. <code class="docutils literal notranslate"><span class="pre">while</span></code>
döngüsü ile yapamayacağınız veya yaparken çok zorlanacağınız şeyleri <code class="docutils literal notranslate"><span class="pre">for</span></code>
döngüsü yardımıyla çok kolay bir şekilde halledebilirsiniz.</p>
<p>Yalnız, söylediğimiz bu cümleden, <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsünün <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsüne bir
alternatif olduğu sonucunu çıkarmayın. Evet, <code class="docutils literal notranslate"><span class="pre">while</span></code> ile yapabildiğiniz bir
işlemi <code class="docutils literal notranslate"><span class="pre">for</span></code> ile de yapabilirsiniz çoğu zaman, ama bu döngülerin, belli
vakalar için tek seçenek olduğu durumlar da vardır. Zira bu iki döngünün çalışma
mantığı birbirinden farklıdır.</p>
<p>Şimdi gelelim <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsünün nasıl kullanılacağına…</p>
<p>Dikkatlice bakın:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">tr_harfler</span> <span class="o">=</span> <span class="s2">"şçöğüİı"</span>
<span class="k">for</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">tr_harfler</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="n">harf</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada öncelikle <cite>tr_harfler</cite> adlı bir değişken tanımladık. Bu değişken Türkçeye
özgü harfleri tutuyor. Daha sonra bir <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü kurarak, <cite>tr_harfler</cite> adlı
değişkenin her bir öğesini tek tek ekrana yazdırdık.</p>
<p>Peki bu <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsünü nasıl kurduk?</p>
<p><code class="docutils literal notranslate"><span class="pre">for</span></code> döngülerinin söz dizimi şöyledir:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">değişken_adı</span> <span class="ow">in</span> <span class="n">değişken</span><span class="p">:</span>
<span class="n">yapılacak_işlem</span>
</pre></div>
</div>
<p>Bu söz dizimini Türkçe olarak şöyle ifade edebiliriz:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">değişken</span> <span class="n">içindeki</span> <span class="n">her</span> <span class="n">bir</span> <span class="n">öğeyi</span> <span class="n">değişken_adı</span> <span class="n">olarak</span> <span class="n">adlandır</span><span class="p">:</span>
<span class="n">ve</span> <span class="n">bu</span> <span class="n">öğelerle</span> <span class="n">bir</span> <span class="n">işlem</span> <span class="n">yap</span><span class="o">.</span>
</pre></div>
</div>
<p>Bu soyut yapıları kendi örneğimize uygulayarak durumu daha net anlamaya
çalışalım:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">tr_harfler</span> <span class="n">adlı</span> <span class="n">değişken</span> <span class="n">içindeki</span> <span class="n">her</span> <span class="n">bir</span> <span class="n">öğeyi</span> <span class="n">harf</span> <span class="n">olarak</span> <span class="n">adlandır</span><span class="p">:</span>
<span class="n">ve</span> <span class="n">harf</span> <span class="n">olarak</span> <span class="n">adlandırılan</span> <span class="n">bu</span> <span class="n">öğeleri</span> <span class="n">ekrana</span> <span class="n">yazdır</span><span class="o">.</span>
</pre></div>
</div>
<p>Yukarıdaki örnekte bir <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü yardımıyla <cite>tr_harfler</cite> adlı değişken
içindeki her bir öğeyi ekrana yazdırdık. Esasında <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsünün
yeteneklerini düşündüğümüzde bu örnek pek heyecan verici değil. Zira aynı işi
aslında <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu ile de yapabilirdik:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">tr_harfler</span> <span class="o">=</span> <span class="s2">"şçöğüİı"</span>
<span class="nb">print</span><span class="p">(</span><span class="o">*</span><span class="n">tr_harfler</span><span class="p">,</span> <span class="n">sep</span><span class="o">=</span><span class="s2">"</span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
</pre></div>
</div>
<p>Aslında bu işlemi <code class="docutils literal notranslate"><span class="pre">while</span></code> ile de yapmak mümkün (Bu kodlardaki, henüz
öğrenmediğimiz kısmı şimdilik görmezden gelin):</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">tr_harfler</span> <span class="o">=</span> <span class="s2">"şçöğüİı"</span>
<span class="n">a</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">while</span> <span class="n">a</span> <span class="o"><</span> <span class="nb">len</span><span class="p">(</span><span class="n">tr_harfler</span><span class="p">):</span>
<span class="nb">print</span><span class="p">(</span><span class="n">tr_harfler</span><span class="p">[</span><span class="n">a</span><span class="p">],</span> <span class="n">sep</span><span class="o">=</span><span class="s2">"</span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
<span class="n">a</span> <span class="o">+=</span> <span class="mi">1</span>
</pre></div>
</div>
<p><code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsü kullanıldığında işi uzattığımızı görüyorsunuz. Dediğimiz gibi,
<code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsüne göre biraz daha yeteneklidir ve <code class="docutils literal notranslate"><span class="pre">while</span></code>
ile yapması daha zor (veya uzun) olan işlemleri <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü ile çok daha
kolay bir şekilde yapabiliriz. Ayrıca <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü ile <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsünün
çalışma mantıkları birbirinden farklıdır. <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü, üzerinde döngü
kurulabilecek veri tiplerinin her bir öğesinin üzerinden tek tek geçer ve bu
öğelerin her biri üzerinde bir işlem yapar. <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsü ise herhangi bir
ifadenin bool değerini kontrol eder ve bu değerin bool değeri <cite>False</cite> olana
kadar, belirlenen işlemi yapmayı sürdürür.</p>
<p>Bu arada, biraz önce ‘üzerinde döngü kurulabilecek veri tipleri’ diye bir
kavramdan söz ettik. Örneğin karakter dizileri, üzerinde döngü kurulabilecek bir
veri tipidir. Ama sayılar öyle değildir. Yani sayılar üzerinde döngü kuramayız.
Mesela:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">sayılar</span> <span class="o">=</span> <span class="mi">123456789</span>
<span class="gp">>>> </span><span class="k">for</span> <span class="n">sayı</span> <span class="ow">in</span> <span class="n">sayılar</span><span class="p">:</span>
<span class="gp">... </span> <span class="nb">print</span><span class="p">(</span><span class="n">sayı</span><span class="p">)</span>
<span class="gp">...</span>
<span class="gt">Traceback (most recent call last):</span>
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>, in <span class="n"><module></span>
<span class="gr">TypeError</span>: <span class="n">'int' object is not iterable</span>
</pre></div>
</div>
<p>Buradaki hata mesajından da göreceğiniz gibi <cite>int</cite> (tam sayı) türündeki nesneler
üzerinde döngü kuramıyoruz. Hata mesajında görünen <em>not iterable</em> (üzerinde
döngü kurulamaz) ifadesiyle kastedilen de budur.</p>
<p>Gelin isterseniz <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü ile bir örnek daha vererek durumu iyice
anlamaya çalışalım:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">sayılar</span> <span class="o">=</span> <span class="s2">"123456789"</span>
<span class="k">for</span> <span class="n">sayı</span> <span class="ow">in</span> <span class="n">sayılar</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="nb">int</span><span class="p">(</span><span class="n">sayı</span><span class="p">)</span> <span class="o">*</span> <span class="mi">2</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada <cite>sayılar</cite> adlı değişkenin her bir öğesini <cite>sayı</cite> olarak adlandırdıktan
sonra, <code class="docutils literal notranslate"><span class="pre">int()</span></code> fonksiyonu yardımıyla bu öğeleri tek tek sayıya çevirdik ve
her bir öğeyi <cite>2</cite> ile çarptık.</p>
<p><code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsünün mantığını az çok anlamış olmalısınız. Bu döngü bir değişken
içindeki her bir öğeyi tek tek ele alıp, iki nokta üst üste işaretinden sonra
yazdığımız kod bloğunu bu öğelere tek tek uyguluyor.</p>
<p><em>for</em> kelimesi İngilizcede ‘için’ anlamına gelir. Döngünün yapısı içinde geçen
<cite>in</cite> ifadesini de tanıyorsunuz. Biz bu ifadeyi ‘Aitlik İşleçleri’ konusunu
işlerken de görmüştük. Hatırlarsanız <cite>in</cite> işleci bir öğenin bir veri tipi içinde
bulunup bulunmadığını sorguluyordu. Mesela:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">a</span> <span class="o">=</span> <span class="s2">"istihza.com"</span>
<span class="gp">>>> </span><span class="s2">"h"</span> <span class="ow">in</span> <span class="n">a</span>
<span class="go">True</span>
</pre></div>
</div>
<p><cite>“h”</cite> öğesi <cite>“istihza.com”</cite> adlı karakter dizisi içinde geçtiği için <code class="docutils literal notranslate"><span class="pre">"h"</span> <span class="pre">in</span>
<span class="pre">a</span></code> kodu <cite>True</cite> çıktısı veriyor. Bir de şuna bakın:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"b"</span> <span class="ow">in</span> <span class="n">a</span>
<span class="go">False</span>
</pre></div>
</div>
<p><cite>“b”</cite> öğesi <cite>“istihza.com”</cite> karakter dizisi içinde bulunmuyor. Dolayısıyla <code class="docutils literal notranslate"><span class="pre">"b"</span>
<span class="pre">in</span> <span class="pre">a</span></code> sorgulaması <cite>False</cite> çıktısı veriyor.</p>
<p><em>in</em> kelimesi İngilizcede ‘içinde’ anlamına geliyor. Dolayısıyla <code class="docutils literal notranslate"><span class="pre">for</span> <span class="pre">falanca</span>
<span class="pre">in</span> <span class="pre">filanca:</span></code> yazdığımızda aslında şöyle bir şey demiş oluyoruz:</p>
<blockquote>
<div><p><cite>filanca</cite> içinde <cite>falanca</cite> adını verdiğimiz her bir öğe için…</p>
</div></blockquote>
<p>Yani şu kod:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></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="nb">print</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
</pre></div>
</div>
<p>Şu anlama geliyor:</p>
<blockquote>
<div><dl class="simple">
<dt><cite>“istihza”</cite> karakter dizisi içinde <cite>s</cite> adını verdiğimiz her bir öğe için:</dt><dd><p><cite>s</cite> öğesini ekrana basma işlemi gerçekleştir!</p>
</dd>
</dl>
</div></blockquote>
<p>Ya da şu kod:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">sayılar</span> <span class="o">=</span> <span class="s2">"123456789"</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">sayılar</span><span class="p">:</span>
<span class="k">if</span> <span class="nb">int</span><span class="p">(</span><span class="n">i</span><span class="p">)</span> <span class="o">></span> <span class="mi">3</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
</pre></div>
</div>
<p>Şu anlama geliyor:</p>
<blockquote>
<div><dl class="simple">
<dt><cite>sayılar</cite> değişkeni içinde <cite>i</cite> adını verdiğimiz her bir öğe için:</dt><dd><dl class="simple">
<dt>eğer sayıya dönüştürülmüş <cite>i</cite> değeri <cite>3</cite>’ten büyükse:</dt><dd><p><cite>i</cite> öğesini ekrana basma işlemi gerçekleştir!</p>
</dd>
</dl>
</dd>
</dl>
</div></blockquote>
<p>Yukarıdaki temsili kodların Türkçesi bozuk olsa da <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsünün çalışma
mantığını anlamaya yardımcı olacağını zannediyorum. Ama yine de, eğer bu
döngünün mantığını henüz kavrayamadıysanız hiç endişe etmeyin. Zira bu döngüyü
oldukça sık bir biçimde kullanacağımız için, siz istemeseniz de bu döngü
kafanızda yer etmiş olacak.</p>
<p>Bu <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsünü biraz daha iyi anlayabilmek için son bir örnek yapalım:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">tr_harfler</span> <span class="o">=</span> <span class="s2">"şçöğüİı"</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="k">for</span> <span class="n">karakter</span> <span class="ow">in</span> <span class="n">parola</span><span class="p">:</span>
<span class="k">if</span> <span class="n">karakter</span> <span class="ow">in</span> <span class="n">tr_harfler</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"parolada Türkçe karakter kullanılamaz"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu program, kullanıcıya bir parola soruyor. Eğer kullanıcının girdiği parola
içinde Türkçe karakterlerden herhangi biri varsa kullanıcıyı Türkçe karakter
kullanmaması konusunda uyarıyor. Buradaki <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsünü nasıl kurduğumuzu
görüyorsunuz. Aslında burada şu Türkçe cümleyi Pythonca’ya çevirmiş olduk:</p>
<blockquote>
<div><dl class="simple">
<dt><cite>parola</cite> değişkeni içinde <cite>karakter</cite> adını verdiğimiz her bir öğe için:</dt><dd><dl class="simple">
<dt>eğer <cite>karakter</cite> değişkeni <cite>tr_harfler</cite> adlı değişken içinde geçiyorsa:</dt><dd><p>‘parolada Türkçe karakter kullanılamaz’ uyarısını göster!</p>
</dd>
</dl>
</dd>
</dl>
</div></blockquote>
<p>Burada kullandığımız <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü sayesinde kullanıcının girdiği <cite>parola</cite>
adlı değişken içindeki bütün karakterlere tek tek bakıp, eğer bakılan karakter
<cite>tr_harfler</cite> adlı değişken içinde geçiyorsa kullanıcıyı uyarıyoruz.</p>
<p>Aslında <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsüyle ilgili söyleyeceklerimiz bu kadar değil. Ama henüz bu
döngüyle kullanılan önemli araçları tanımıyoruz. Gerçi zaten bu döngüyü bundan
sonra sık sık kullandığımızı göreceksiniz.</p>
<p>Gelin isterseniz yeni bir konuya geçmeden önce döngülerle ilgili ufak bir örnek
verelim:</p>
<p>Örneğin kullanıcıya bir parola belirletirken, belirlenecek parolanın <cite>8</cite>
karakterden uzun, <cite>3</cite> karakterden kısa olmamasını sağlayalım:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">while</span> <span class="kc">True</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">"Bir parola belirleyin: "</span><span class="p">)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">parola</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"parola bölümü boş geçilemez!"</span><span class="p">)</span>
<span class="k">elif</span> <span class="nb">len</span><span class="p">(</span><span class="n">parola</span><span class="p">)</span> <span class="o">></span> <span class="mi">8</span> <span class="ow">or</span> <span class="nb">len</span><span class="p">(</span><span class="n">parola</span><span class="p">)</span> <span class="o"><</span> <span class="mi">3</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"parola 8 karakterden uzun 3 karakterden kısa olmamalı"</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">"Yeni parolanız"</span><span class="p">,</span> <span class="n">parola</span><span class="p">)</span>
<span class="k">break</span>
</pre></div>
</div>
<p>Burada öncelikle, programınızın sürekli olarak çalışmasını sağlamak için bir
<code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsü oluşturduk. Buna göre, aksi belirtilmedikçe (<code class="docutils literal notranslate"><span class="pre">while</span> <span class="pre">True</span></code>)
programımız çalışmaya devam edecek.</p>
<p><code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsünü kurduktan sonra kullanıcıya bir parola soruyoruz (<code class="docutils literal notranslate"><span class="pre">parola</span> <span class="pre">=</span>
<span class="pre">input("Bir</span> <span class="pre">parola</span> <span class="pre">belirleyin:</span> <span class="pre">")</span></code>)</p>
<p>Eğer kullanıcı herhangi bir parola belirlemeden doğrudan <cite>Enter</cite> tuşuna basarsa,
yani <cite>parola</cite> değişkeninin bool değeri <cite>False</cite> olursa (<code class="docutils literal notranslate"><span class="pre">if</span> <span class="pre">not</span> <span class="pre">parola</span></code>),
kullanıcıya ‘parola bölümü boş geçilemez!’ uyarısı veriyoruz.</p>
<p>Eğer kullanıcı tarafından belirlenen parolanın uzunluğu <cite>8</cite> karakterden fazlaysa
ya da <cite>3</cite> karakterden kısaysa, ‘parola 8 karakterden uzun 3 karakterden kısa
olmamalı’ uyarısı veriyoruz.</p>
<p>Yukarıdaki koşullar harici durumlar için ise (<code class="docutils literal notranslate"><span class="pre">else</span></code>), belirlenen yeni
parolayı kullanıcıya gösterip döngüden çıkıyoruz (<code class="docutils literal notranslate"><span class="pre">break</span></code>).</p>
<p>Bu arada, hatırlarsanız <code class="docutils literal notranslate"><span class="pre">eval()</span></code> fonksiyonunu anlatırken şöyle bir örnek
vermiştik:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="s2">"""</span>
<span class="s2">Basit bir hesap makinesi uygulaması.</span>
<span class="s2">İşleçler:</span>
<span class="s2"> + toplama</span>
<span class="s2"> - çıkarma</span>
<span class="s2"> * çarpma</span>
<span class="s2"> / bölme</span>
<span class="s2">Yapmak istediğiniz işlemi yazıp ENTER</span>
<span class="s2">tuşuna basın. (Örneğin 23 ve 46 sayılarını</span>
<span class="s2">çarpmak için 23 * 46 yazdıktan sonra</span>
<span class="s2">ENTER tuşuna basın.)</span>
<span class="s2">"""</span><span class="p">)</span>
<span class="n">veri</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"İşleminiz: "</span><span class="p">)</span>
<span class="n">hesap</span> <span class="o">=</span> <span class="nb">eval</span><span class="p">(</span><span class="n">veri</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">hesap</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu programdaki eksiklikleri ve riskleri biliyorsunuz. Böyle bir program
yazdığınızda, <code class="docutils literal notranslate"><span class="pre">eval()</span></code> fonksiyonunu kontrolsüz bir şekilde kullandığınız için
önemli bir güvenlik açığına sebep olmuş oluyorsunuz. Gelin isterseniz bu derste
öğrendiğimiz bilgileri de kullanarak yukarıdaki <code class="docutils literal notranslate"><span class="pre">eval()</span></code> fonksiyonu için basit
bir kontrol mekanizması kuralım:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">izinli_karakterler</span> <span class="o">=</span> <span class="s2">"0123456789+-/*= "</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"""</span>
<span class="s2">Basit bir hesap makinesi uygulaması.</span>
<span class="s2">İşleçler:</span>
<span class="s2"> + toplama</span>
<span class="s2"> - çıkarma</span>
<span class="s2"> * çarpma</span>
<span class="s2"> / bölme</span>
<span class="s2">Yapmak istediğiniz işlemi yazıp ENTER</span>
<span class="s2">tuşuna basın. (Örneğin 23 ve 46 sayılarını</span>
<span class="s2">çarpmak için 23 * 46 yazdıktan sonra</span>
<span class="s2">ENTER tuşuna basın.)</span>
<span class="s2">"""</span><span class="p">)</span>
<span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
<span class="n">veri</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s2">"İşleminiz: "</span><span class="p">)</span>
<span class="k">if</span> <span class="n">veri</span> <span class="o">==</span> <span class="s2">"q"</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"çıkılıyor..."</span><span class="p">)</span>
<span class="k">break</span>
<span class="k">for</span> <span class="n">s</span> <span class="ow">in</span> <span class="n">veri</span><span class="p">:</span>
<span class="k">if</span> <span class="n">s</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">izinli_karakterler</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Neyin peşindesin?!"</span><span class="p">)</span>
<span class="n">quit</span><span class="p">()</span>
<span class="n">hesap</span> <span class="o">=</span> <span class="nb">eval</span><span class="p">(</span><span class="n">veri</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">hesap</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada öncelikle programımızı bir <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsü içine aldık. Böylece
programımızın ne zaman sona ereceğini kendimiz belirleyebileceğiz. Buna göre
eğer kullanıcı klavyede ‘q’ tuşuna basarsa <code class="docutils literal notranslate"><span class="pre">while</span></code> döngüsü sona erecek.</p>
<p>Bu programda bizi özellikle ilgilendiren kısım şu:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">izinli_karakterler</span> <span class="o">=</span> <span class="s2">"0123456789+-/*= "</span>
<span class="k">for</span> <span class="n">s</span> <span class="ow">in</span> <span class="n">veri</span><span class="p">:</span>
<span class="k">if</span> <span class="n">s</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">izinli_karakterler</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Neyin peşindesin?!"</span><span class="p">)</span>
<span class="n">quit</span><span class="p">()</span>
<span class="n">hesap</span> <span class="o">=</span> <span class="nb">eval</span><span class="p">(</span><span class="n">veri</span><span class="p">)</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, ilk olarak <cite>izinli_karakterler</cite> adlı bir değişken tanımladık.
Program içinde kullanılmasına izin verdiğimiz karakterleri bu değişken içine
yazıyoruz. Buna göre kullanıcı yalnızca <cite>0</cite>, <cite>1</cite>, <cite>2</cite>, <cite>3</cite>, <cite>4</cite>, <cite>5</cite>, <cite>6</cite>, <cite>7</cite>,
<cite>8</cite> ve <cite>9</cite> sayılarını, <cite>+</cite>, <cite>-</cite>, <cite>/</cite>, <cite>*</cite> ve <cite>=</cite> işleçlerini, ayrıca boşluk
karakterini (‘ ‘) kullanabilecek.</p>
<p>Kullanıcının girdiği veri üzerinde bir <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü kurarak, veri içindeki
her bir karakterin <cite>izinli_karakterler</cite> değişkeni içinde yer alıp almadığını
denetliyoruz. İzin verilen karakterler dışında herhangi bir karakterin girilmesi
<cite>Neyin peşindesin?!</cite> çıktısının verilip programdan tamamen çıkılmasına
(<code class="docutils literal notranslate"><span class="pre">quit()</span></code>) yol açacaktır.</p>
<p>Eğer kullanıcı izinli karakterleri kullanarak bir işlem gerçekleştirmişse
<code class="docutils literal notranslate"><span class="pre">hesap</span> <span class="pre">=</span> <span class="pre">eval(veri)</span></code> kodu aracılığıyla, kullanıcının yaptığı işlemi <code class="docutils literal notranslate"><span class="pre">eval()</span></code>
fonksiyonuna gönderiyoruz.</p>
<p>Böylece <code class="docutils literal notranslate"><span class="pre">eval()</span></code> fonksiyonunu daha güvenli bir hale getirebilmek için basit
bir kontrol mekanizmasının nasıl kurulabileceğini görmüş olduk. Kurduğumuz
kontrol mekanizmasının esası, kullanıcının girebileceği veri türlerini
sınırlamaya dayanıyor. Böylece kullanıcı mesela şöyle tehlikeli bir komut
giremiyor:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="nb">__import__</span><span class="p">(</span><span class="s2">"os"</span><span class="p">)</span><span class="o">.</span><span class="n">system</span><span class="p">(</span><span class="s2">"dir"</span><span class="p">)</span>
</pre></div>
</div>
<p>Çünkü bu komutu yazabilmesi için gereken karakterler <cite>izinli_karakterler</cite>
değişkeni içinde tanımlı değil. Kullanıcı yalnızca basit bir hesap makinesinde
kullanılabilecek olan sayıları ve işleçleri girebiliyor.</p>
</div>
<div class="section" id="ilgili-araclar">
<h2>İlgili Araçlar<a class="headerlink" href="#ilgili-araclar" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Elbette döngüler tek başlarına bir şey ifade etmezler. Döngülerle işe yarar
kodlar yazabilmemiz için bazı araçlara ihtiyacımız var. İşte bu bölümde
döngüleri daha verimli kullanmamızı sağlayacak bazı fonksiyon ve deyimlerden söz
edeceğiz. İlk olarak <code class="docutils literal notranslate"><span class="pre">range()</span></code> adlı bir fonksiyondan bahsedelim.</p>
<div class="section" id="range-fonksiyonu">
<h3>range Fonksiyonu<a class="headerlink" href="#range-fonksiyonu" title="Bu başlık için kalıcı bağlantı">¶</a></h3>
<p><em>range</em> kelimesi İngilizcede ‘aralık’ anlamına gelir. Biz Python’da <code class="docutils literal notranslate"><span class="pre">range()</span></code>
fonksiyonunu belli bir aralıkta bulunan sayıları göstermek için kullanıyoruz.
Örneğin:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</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="n">i</span><span class="p">)</span>
<span class="gp">...</span>
<span class="go">0</span>
<span class="go">1</span>
<span class="go">2</span>
<span class="go">3</span>
<span class="go">4</span>
<span class="go">5</span>
<span class="go">6</span>
<span class="go">7</span>
<span class="go">8</span>
<span class="go">9</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <code class="docutils literal notranslate"><span class="pre">range(0,</span> <span class="pre">10)</span></code> kodu sayesinde ve <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsünü de
kullanarak, <cite>0</cite> ile <cite>10</cite> (<cite>10</cite> hariç) aralığındaki sayıları ekrana yazdırdık.</p>
<p>Yukarıdaki kodda <code class="docutils literal notranslate"><span class="pre">range()</span></code> fonksiyonuna <cite>0</cite> ve <cite>10</cite> olmak üzere iki adet
parametre verdiğimizi görüyorsunuz. Burada <cite>0</cite> sayısı, aralıktaki ilk sayıyı,
<cite>10</cite> sayısı ise aralıktaki son sayıyı gösteriyor. Yani <code class="docutils literal notranslate"><span class="pre">range()</span></code> fonksiyonunun
formülü şöyledir:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="nb">range</span><span class="p">(</span><span class="n">ilk_sayı</span><span class="p">,</span> <span class="n">son_sayı</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu arada, <code class="docutils literal notranslate"><span class="pre">range(ilk_sayı,</span> <span class="pre">son_sayı)</span></code> kodunun verdiği çıktıya ilk_sayının
dahil olduğuna, ama son_sayının dahil olmadığına dikkat edin.</p>
<p>Eğer <code class="docutils literal notranslate"><span class="pre">range()</span></code> fonksiyonunun ilk parametresi <cite>0</cite> olacaksa, bu parametreyi
belirtmesek de olur. Yani mesela <cite>0</cite>’dan <cite>10</cite>’a kadar olan sayıları
listeleyeceksek <code class="docutils literal notranslate"><span class="pre">range()</span></code> fonksiyonunu şöyle yazmamız yeterli olacaktır:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</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="n">i</span><span class="p">)</span>
</pre></div>
</div>
<p><code class="docutils literal notranslate"><span class="pre">range()</span></code> fonksiyonunun <cite>ilk_sayı</cite> parametresi verilmediğinde Python ilk
parametreyi <cite>0</cite> olarak alır. Yani <code class="docutils literal notranslate"><span class="pre">range(10)</span></code> gibi bir kodu Python <code class="docutils literal notranslate"><span class="pre">range(0,</span>
<span class="pre">10)</span></code> olarak algılar. Elbette, eğer aralıktaki ilk sayı <cite>0</cite>’dan farklı olacaksa
bu sayıyı açık açık belirtmek gerekir:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">20</span><span class="p">):</span>
<span class="gp">... </span> <span class="nb">print</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada <cite>3</cite>’ten itibaren <cite>20</cite>’ye kadar olan sayılar ekrana dökülecektir.</p>
<p>Hatırlarsanız, biraz önce, kullanıcının <cite>3</cite> karakterden kısa, <cite>8</cite> karakterden
uzun parola belirlemesini engelleyen bir uygulama yazmıştık. O uygulamayı
<code class="docutils literal notranslate"><span class="pre">range()</span></code> fonksiyonunu kullanarak da yazabiliriz:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">while</span> <span class="kc">True</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 belirleyin: "</span><span class="p">)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">parola</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"parola bölümü boş geçilemez!"</span><span class="p">)</span>
<span class="k">elif</span> <span class="nb">len</span><span class="p">(</span><span class="n">parola</span><span class="p">)</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">8</span><span class="p">):</span> <span class="c1">#eğer parolanın uzunluğu 3 ile 8 karakter</span>
<span class="c1">#aralığında ise...</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Yeni parolanız"</span><span class="p">,</span> <span class="n">parola</span><span class="p">)</span>
<span class="k">break</span>
<span class="k">else</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"parola 8 karakterden uzun 3 karakterden kısa olmamalı"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu fonksiyonu kullanarak bir döngünün kaç kez çalışacağını da
belirleyebilirsiniz. Aşağıdaki kodları dikkatlice inceleyin:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</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 belirleyin: "</span><span class="p">)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">parola</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"parola bölümü boş geçilemez!"</span><span class="p">)</span>
<span class="k">elif</span> <span class="nb">len</span><span class="p">(</span><span class="n">parola</span><span class="p">)</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">8</span><span class="p">):</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Yeni parolanız"</span><span class="p">,</span> <span class="n">parola</span><span class="p">)</span>
<span class="k">break</span>
<span class="k">elif</span> <span class="n">i</span> <span class="o">==</span> <span class="mi">2</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"parolayı 3 kez yanlış girdiniz."</span><span class="p">,</span>
<span class="s2">"Lütfen 30 dakika sonra tekrar deneyin!"</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">"parola 8 karakterden uzun 3 karakterden kısa olmamalı"</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada <code class="docutils literal notranslate"><span class="pre">if</span> <span class="pre">i</span> <span class="pre">==</span> <span class="pre">2</span></code> kodu sayesinde <code class="docutils literal notranslate"><span class="pre">for</span></code> döngüsü içinde belirttiğimiz <cite>i</cite>
adlı değişkenin değeri <cite>2</cite> olduğu anda ‘parolayı 3 kez yanlış girdiniz…’
uyarısı gösterilecektir. Daha önce de birkaç yerde ifade ettiğimiz gibi, eğer
yukarıdaki kodların çalışma mantığını anlamakta zorlanıyorsanız, programın uygun
yerlerine <code class="docutils literal notranslate"><span class="pre">print()</span></code> fonksiyonu yerleştirerek arka planda Python’ın neler
çevirdiğini daha net görebilirsiniz. Örneğin:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</span><span class="p">):</span>
<span class="nb">print</span><span class="p">(</span><span class="n">i</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 belirleyin: "</span><span class="p">)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">parola</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"parola bölümü boş geçilemez!"</span><span class="p">)</span>
<span class="k">elif</span> <span class="nb">len</span><span class="p">(</span><span class="n">parola</span><span class="p">)</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">8</span><span class="p">):</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Yeni parolanız"</span><span class="p">,</span> <span class="n">parola</span><span class="p">)</span>
<span class="k">break</span>
<span class="k">elif</span> <span class="n">i</span> <span class="o">==</span> <span class="mi">2</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"parolayı 3 kez yanlış girdiniz."</span><span class="p">,</span>
<span class="s2">"Lütfen 30 dakika sonra tekrar deneyin!"</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">"parola 8 karakterden uzun 3 karakterden kısa olmamalı"</span><span class="p">)</span>
</pre></div>
</div>