forked from yazbel/python
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathetkilesimli_python.html
More file actions
1461 lines (1287 loc) · 112 KB
/
etkilesimli_python.html
File metadata and controls
1461 lines (1287 loc) · 112 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE html>
<html lang="tr">
<html lang="tr">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta content="Bu bölümde Python'ın etkileşimli kabuğundan söz edeceğiz." name="description" />
<meta content="etkileşimli, kabuk, Python, işleçler, aritmetik, type, str, string, fonksiyon, değişkenler, len" name="keywords" />
<title>Etkileşimli Python — 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="print() Fonksiyonu" href="print.html" />
<link rel="prev" title="Python Nasıl Çalıştırılır?" href="calistirma.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="print.html" title="print() Fonksiyonu"
accesskey="N">sonraki</a></li>
<li class="right" >
<a href="calistirma.html" title="Python Nasıl Çalıştırılır?"
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="">Etkileşimli Python</a></li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="body" role="main">
<div class="section" id="etkilesimli-python">
<h1>Etkileşimli Python<a class="headerlink" href="#etkilesimli-python" title="Bu başlık için kalıcı bağlantı">¶</a></h1>
<p>Şu ana kadar öğrendiklerimiz sayesinde Python programlama dilinin farklı sistemlere nasıl kurulacağını ve nasıl çalıştırılacağını biliyoruz.
Dolayısıyla Python’ı bir önceki bölümde anlattığımız şekilde çalıştırdığımız zaman şuna benzer bir ekranla karşılaşacağımızın farkındayız:</p>
<div class="screenshot docutils container">
<p><cite>yazbel@ubuntu:~$</cite> # python3
Python 3.7.0 (default, 08.08.2020, 12:24:55)
[GCC 4.4.7 20120313 (Red Hat 4.4.7-3)] on linux
Type “help”, “copyright”, “credits” or “license” for more information.
>>></p>
</div>
<p>Biz şimdiye kadar bu ekrana Python komut satırı demeyi tercih ettik.
Dilerseniz bundan sonra da bu adı kullanmaya devam edebilirsiniz.
Ancak teknik olarak bu ekrana etkileşimli kabuk (<em>interactive shell</em>) adı verildiğini bilmemizde fayda var.
Etkileşimli kabuk, bizim Python programlama dili ile ilişki kurabileceğimiz, yani onunla etkileşebileceğimiz bir üst katmandır.
Etkileşimli kabuk, asıl programımız içinde kullanacağımız kodları deneme imkanı sunar bize.
Burası bir nevi test alanı gibidir.
Örneğin bir Python kodunun çalışıp çalışmadığını denemek veya nasıl çalıştığını, ne sonuç verdiğini görmek istediğimizde bu ekran son derece faydalı bir araç olarak karşımıza çıkar.
Bu ortam, özellikle Python’a yeni başlayanların bu programlama diline aşinalık kazanmasını sağlaması açısından da bulunmaz bir araçtır.
Biz de bu bölümde etkileşimli kabuk üzerinde bazı çalışmalar yaparak, Python’a alışma turları atacağız.</p>
<p>Bu arada, geçen bölümde söylediğimiz gibi, bu ortamın sistem komut satırı adını verdiğimiz ortamdan farklı olduğunu aklımızdan çıkarmıyoruz.
O zaman da dediğimiz gibi, sistem komut satırında sistem komutları, Python komut satırında (yani etkileşimli kabukta) ise Python komutları verilir.
Mesela <code class="docutils literal notranslate"><span class="pre">echo</span> <span class="pre">%PATH%</span></code>, <code class="docutils literal notranslate"><span class="pre">cd</span> <span class="pre">Desktop</span></code>, <code class="docutils literal notranslate"><span class="pre">dir</span></code> ve <code class="docutils literal notranslate"><span class="pre">ls</span></code> birer sistem komutudur.
Eğer bu komutları etkileşimli kabukta vermeye kalkışırsanız, bunlar birer Python komutu olmadığı için, Python size bir hata mesajı gösterecektir.
Mesela Python’ın etkileşimli kabuğunda <code class="docutils literal notranslate"><span class="pre">cd</span> <span class="pre">Desktop</span></code> komutunu verirseniz şöyle bir hata alırsınız:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">cd</span> <span class="n">Desktop</span>
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>
<span class="n">cd</span> <span class="n">Desktop</span>
<span class="o">^</span>
<span class="gr">SyntaxError</span>: <span class="n">invalid syntax</span>
</pre></div>
</div>
<p>Çünkü <code class="docutils literal notranslate"><span class="pre">cd</span> <span class="pre">Desktop</span></code> bir Python komutu değildir.
O yüzden bu komutu Python’ın etkileşimli kabuğunda veremeyiz.
Bu komutu ancak ve ancak kullandığımız işletim sisteminin komut satırında verebiliriz.</p>
<p>Ne diyorduk?
Etkileşimli kabuk bir veya birkaç satırlık kodları denemek/test etmek için gayet uygun bir araçtır.
İsterseniz konuyu daha fazla lafa boğmayalım.
Zira etkileşimli kabuğu kullandıkça bunun ne büyük bir nimet olduğunu siz de anlayacaksınız.
Özellikle derlenerek çalıştırılan programlama dilleri ile uğraşmış olan arkadaşlarım, etkileşimli kabuğun gücünü gördüklerinde göz yaşlarına hakim olamayacaklar.</p>
<p>Farklı işletim sistemlerinde <code class="docutils literal notranslate"><span class="pre">py3</span></code>, <code class="docutils literal notranslate"><span class="pre">py</span> <span class="pre">-3</span></code>, <code class="docutils literal notranslate"><span class="pre">python3</span></code> veya <code class="docutils literal notranslate"><span class="pre">python</span></code> komutunu vererek Python’ın komut satırına nasıl erişebileceğimizi önceki derslerde ayrıntılı olarak anlatmıştık.
Etkileşimli kabuğa ulaşmakta sıkıntı yaşıyorsanız eski konuları tekrar gözden geçirmenizi tavsiye ederim.</p>
<p>Etkileşimli kabuk üzerinde çalışmaya başlamadan önce dilerseniz önemli bir konuyu açıklığa kavuşturalım:
Etkileşimli kabuğu başarıyla çalıştırdık.
Peki bu kabuktan çıkmak istersek ne yapacağız?
Elbette doğrudan pencere üzerindeki çarpı tuşuna basarak bu ortamı terk edebilirsiniz.
Ancak bu işlemi kaba kuvvete başvurmadan yapmanın bir yolu olmalı, değil mi?</p>
<p>Etkileşimli kabuktan çıkmanın birkaç farklı yolu vardır:</p>
<ol class="arabic simple">
<li><p>Pencere üzerindeki çarpı düğmesine basmak (kaba kuvvet)</p></li>
<li><p>Önce <cite>Ctrl+Z</cite> tuşlarına, ardından da <cite>Enter</cite> tuşuna basmak (Windows)</p></li>
<li><p><cite>Ctrl+Z</cite> tuşlarına basmak (GNU/Linux)</p></li>
<li><p>Önce <cite>F6</cite> tuşuna, ardından da <cite>Enter</cite> tuşuna basmak (Windows)</p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">quit()</span></code> yazıp <cite>Enter</cite> tuşuna basmak (Bütün işletim sistemleri)</p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">import</span> <span class="pre">sys;</span> <span class="pre">sys.exit()</span></code> komutunu vermek (Bütün işletim sistemleri)</p></li>
</ol>
<p>Siz bu farklı yöntemler arasından, kolayınıza hangisi geliyorsa onu seçebilirsiniz.
Bu satırların yazarı, Windows’ta 2 numaralı; GNU/Linux’ta ise 3 numaralı seçeneği tercih ediyor.</p>
<div class="section" id="etkilesimli-kabukta-ilk-adimlar">
<h2>Etkileşimli Kabukta İlk Adımlar<a class="headerlink" href="#etkilesimli-kabukta-ilk-adimlar" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Python’da etkileşimli kabuğu nasıl çalıştıracağımızı ve bu ortamı nasıl terk edeceğimizi öğrendiğimize göre artık etkileşimli kabuk aracılığıyla Python programlama dilinde ilk adımlarımızı atmaya başlayabiliriz.</p>
<p>Şimdi kendi sistemimize uygun bir şekilde etkileşimli kabuğu tekrar çalıştıralım.
Etkileşimli kabuğu çalıştırdığımızda ekranda görünen <cite>>>></cite> işareti Python’ın bizden komut almaya hazır olduğunu gösteriyor.
Python kodlarımızı bu <cite>>>></cite> işaretinden hemen sonra, <strong>hiç boşluk bırakmadan</strong> yazacağız.</p>
<p>Buradaki ‘hiç boşluk bırakmadan’ kısmı önemli.
Python’a yeni başlayanların en sık yaptığı hatalardan biri <cite>>>></cite> işareti ile komut arasında boşluk bırakmalarıdır.
Eğer bu şekilde boşluk bırakırsanız yazdığınız kod hata verecektir.</p>
<p>İsterseniz basit bir deneme yapalım.
<cite>>>></cite> işaretinden hemen sonra, hiç boşluk bırakmadan şu komutu yazalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"Merhaba Zalim Dünya!"</span>
</pre></div>
</div>
<p>Bu arada yukarıdaki kodlar içinde görünen <cite>>>></cite> işaretini siz yazmayacaksınız.
Bu işareti etkileşimli kabuğun görünümünü temsil etmek için yerleştirdik oraya.
Siz <cite>“Merhaba Zalim Dünya!”</cite> satırını yazdıktan sonra doğruca <cite>Enter</cite> düğmesine basacaksınız.</p>
<p>Bu komutu yazıp <cite>Enter</cite> tuşuna bastığımızda şöyle bir çıktı almış olmalıyız:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="s1">'Merhaba Zalim Dünya!'</span>
</pre></div>
</div>
<p>Böylece yarım yamalak da olsa ilk Python programımızı yazmış olduk…</p>
<p>Muhtemelen bu kod, içinizde en ufak bir heyecan dahi uyandırmamıştır.
Hatta böyle bir kod yazmak size anlamsız bile gelmiş olabilir.
Ama aslında şu küçücük kod parçası bile bize Python programlama dili hakkında çok önemli ipuçları veriyor.
Gelin isterseniz bu tek satırlık kodu biraz inceleyelim…</p>
<div class="section" id="karakter-dizilerine-giris">
<h3>Karakter Dizilerine Giriş<a class="headerlink" href="#karakter-dizilerine-giris" title="Bu başlık için kalıcı bağlantı">¶</a></h3>
<p>Dediğimiz gibi, yukarıda yazdığımız küçücük kod parçası sizi heyecanlandırmamış olabilir, ama aslında bu kod Python programlama dili ve bu dilin yapısı hakkında çok önemli bilgileri içinde barındırıyor.</p>
<p>Teknik olarak söylemek gerekirse, yukarıda yazdığımız <cite>“Merhaba Zalim Dünya!”</cite> ifadesi bir karakter dizisidir.
İngilizcede buna <em>string</em> adı verilir ve programlama açısından son derece önemli bir kavramdır bu.
Kavramın adından da rahatlıkla anlayabileceğiniz gibi, bir veya daha fazla karakterden oluşan öğelere karakter dizisi (<em>string</em>) diyoruz.</p>
<p>Karakter dizileri bütün programcılık maceramız boyunca karşımıza çıkacak.
O yüzden bu kavramı ne kadar erken öğrenirsek o kadar iyi.</p>
<p>Peki bir verinin karakter dizisi olup olmamasının bize ne faydası var?
Yani yukarıdaki cümle karakter dizisi olmuş olmamış bize ne?</p>
<p>Python’da, o anda elinizde bulunan bir verinin hangi tipte olduğunu bilmek son derece önemlidir.
Çünkü bir verinin ait olduğu tip, o veriyle neler yapıp neler yapamayacağınızı belirler.
Python’da her veri tipinin belli başlı özellikleri vardır.
Dolayısıyla, elimizdeki bir verinin tipini bilmezsek o veriyi programlarımızda etkin bir şekilde kullanamayız.
İşte yukarıda örneğini verdiğimiz <cite>“Merhaba Zalim Dünya!”</cite> adlı karakter dizisi de bir veri tipidir.
Python’da karakter dizileri dışında başka veri tipleri de bulunur.
Biraz sonra başka veri tiplerini de inceleyeceğiz.</p>
<p>Dikkat ederseniz <cite>“Merhaba Zalim Dünya!”</cite> adlı karakter dizisini tırnak içinde gösterdik.
Bu da çok önemli bir bilgidir.
Eğer bu cümleyi tırnak içine almazsak programımız hata verecektir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span>>>> Merhaba Zalim Dünya!
File "<stdin>", line 1
Merhaba Zalim Dünya!
^
SyntaxError: invalid syntax
</pre></div>
</div>
<p>Zaten tırnak işaretleri, karakter dizilerinin ayırt edici özelliğidir.
Öyle ki, Python’da tırnak içinde gösterdiğiniz her şey bir karakter dizisidir.
Örneğin şu bir karakter dizisidir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"a"</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, tırnak içinde gösterilen tek karakterlik bir öğe de Python’da karakter dizisi sınıfına giriyor.</p>
<p>Mesela şu, içi boş bir karakter dizisidir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">""</span>
</pre></div>
</div>
<p>Şu da içinde bir adet boşluk karakteri barındıran bir karakter dizisi…</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">" "</span>
</pre></div>
</div>
<p>Bu ikisi arasındaki farka dikkat ediyoruz:
Python’da ‘boş karakter dizisi’ ve ‘bir adet boşluktan oluşan karakter dizisi’ birbirlerinden farklı iki kavramdır.
Adından da anlaşılacağı gibi, boş karakter dizileri içlerinde hiçbir karakter (başka bir deyişle ‘öğe’) barındırmayan karakter dizileridir.
Bir (veya daha fazla) boşluktan oluşan karakter dizileri ise içlerinde boşluk karakteri barındıran karakter dizileridir.
Yani bu karakter dizilerinden biri boş, öteki ise doludur.
Ama neticede her ikisi de karakter dizisidir.
Şu anda oldukça anlamsız bir konu üzerinde vakit kaybediyormuşuz hissine kapılmış olabilirsiniz, ama emin olun, Python programlama diline yeni başlayanların önemli tökezleme noktalarından biridir bu söylediğimiz şey…</p>
<p>Dilerseniz biz karakter dizilerine elimizin alışması için birkaç örnek verelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"Elma"</span>
<span class="go">'Elma'</span>
<span class="gp">>>> </span><span class="s2">"Guido Van Rossum"</span>
<span class="go">'Guido Van Rossum'</span>
<span class="gp">>>> </span><span class="s2">"Python programlama dili"</span>
<span class="go">'Python programlama dili'</span>
<span class="gp">>>> </span><span class="s2">"ömnhbgfgh"</span>
<span class="go">'ömnhbgfgh'</span>
<span class="gp">>>> </span><span class="s2">"$5&"</span>
<span class="go">'$5&'</span>
<span class="gp">>>> </span><span class="s2">""</span>
<span class="go">''</span>
<span class="gp">>>> </span><span class="s2">" "</span>
<span class="go">' '</span>
</pre></div>
</div>
<p>Yukarıdaki örneklerin hepsi birer karakter dizisidir.
Dikkat ettiyseniz yukarıdaki karakter dizilerinin hepsinin ortak özelliği tırnak içinde gösteriliyor olmasıdır.
Dediğimiz gibi, tırnak işaretleri karakter dizilerinin ayırt edici özelliğidir.</p>
<p>Peki bir verinin karakter dizisi olup olmadığından nasıl emin olabilirsiniz?</p>
<p>Eğer herhangi bir verinin karakter dizisi olup olmadığı konusunda tereddütünüz varsa, <code class="docutils literal notranslate"><span class="pre">type()</span></code> adlı bir fonksiyondan yararlanarak o verinin tipini sorgulayabilirsiniz.
Bu fonksiyonu şöyle kullanıyoruz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">type</span><span class="p">(</span><span class="s2">"Elma"</span><span class="p">)</span>
<span class="go"><class 'str'></span>
</pre></div>
</div>
<div class="admonition note">
<p class="admonition-title">Not</p>
<p>Bu ‘fonksiyon’ kelimesinin kafanızı karıştırmasına izin vermeyin.
İleride fonksiyonları oldukça ayrıntılı bir şekilde inceleyeceğimiz için, <code class="docutils literal notranslate"><span class="pre">type()</span></code> ifadesinin bir fonksiyon olduğunu bilmeniz şimdilik yeterli olacaktır.
Üstelik fonksiyon konusunu ayrıntılı bir şekilde anlatma vakti geldiğinde siz fonksiyonlara dair pek çok şeyi zaten öğrenmiş olacaksınız.</p>
</div>
<p>Burada amacımız <cite>“Elma”</cite> adlı öğenin tipini denetlemek.
Denetlenecek öğeyi <code class="docutils literal notranslate"><span class="pre">type()</span></code> fonksiyonunun parantezleri arasında belirttiğimize dikkat edin.
(Fonksiyonların parantezleri içinde belirtilen değerlere teknik dilde parametre adı verilir.)</p>
<p>Yukarıdaki çıktıda bizi ilgilendiren kısım, sondaki ‘str’ ifadesi.
Tahmin edebileceğiniz gibi, bu ifade <em>string</em> kelimesinin kısaltmasıdır.
Bu kelimenin Türkçede karakter dizisi anlamına geldiğini söylemiştik.
O halde yukarıdaki çıktıya bakarak, <cite>“Elma”</cite> öğesinin bir karakter dizisi olduğunu söyleyebiliyoruz.</p>
<p><code class="docutils literal notranslate"><span class="pre">type()</span></code> fonksiyonu yardımıyla kendi kendinize bazı denemeler yaparak konuyu iyice sindirmenizi tavsiye ederim.
Mesela <cite>“½{656$#gfd”</cite> ifadesinin hangi sınıfa girdiğini kontrol etmekle başlayabilirsiniz.</p>
<p>Peki karakter dizileri ile neler yapabiliriz?
Şu anda Python bilgimiz kısıtlı olduğu için karakter dizileri ile çok fazla şey yapamayız, ama ileride bilgimiz arttıkça, karakter dizileriyle sıkı fıkı olacağız.</p>
<p>Esasında, henüz bilgimiz kısıtlı da olsa karakter dizileriyle yine de ufak tefek bazı şeyler yapamayacak durumda değiliz.
Mesela şu anki bilgilerimizi ve görür görmez size tanıdık gelecek bazı basit parçaları kullanarak, karakter dizilerini birbirleriyle birleştirebiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"yazbel"</span> <span class="o">+</span> <span class="s2">".com"</span>
<span class="go">'yazbel.com'</span>
</pre></div>
</div>
<p>Burada <cite>+</cite> işaretini kullanarak karakter dizilerini nasıl birleştirebildiğimize dikkat edin.
İki karakter dizisini <cite>+</cite> işareti ile birleştirdiğimizde karakter dizilerinin arasında boşluk olmadığına özellikle dikkatinizi çekmek isterim.
Bu durumu şu örnekte daha net görebiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"Fırat"</span> <span class="o">+</span> <span class="s2">"Özgül"</span>
<span class="go">'FıratÖzgül'</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, bu iki karakter dizisi, arada boşluk olmadan birbiriyle bitiştirildi.
Araya boşluk eklemek için birkaç farklı yöntemden yararlanabilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"Fırat"</span> <span class="o">+</span> <span class="s2">" "</span> <span class="o">+</span> <span class="s2">"Özgül"</span>
<span class="go">'Fırat Özgül'</span>
</pre></div>
</div>
<p>Burada iki karakter dizisi arasına bir adet boşluk karakteri yerleştirdik.
Aynı etkiyi şu şekilde de elde edebilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"Fırat"</span> <span class="o">+</span> <span class="s2">" Özgül"</span>
</pre></div>
</div>
<p>Burada da <cite>Özgül</cite> karakter dizisinin başına bir adet boşluk yerleştirerek istediğimiz çıktıyı elde ettik.</p>
<p>Bu arada, karakter dizilerini birleştirmek için mutlaka <cite>+</cite> işareti kullanmak zorunda değilsiniz.
Siz <cite>+</cite> işaretini kullanmasanız da Python sizin karakter dizilerini birleştirmek istediğinizi anlayacak kadar zekidir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"www"</span> <span class="s2">"."</span> <span class="s2">"google"</span> <span class="s2">"."</span> <span class="s2">"com"</span>
<span class="go">'www.google.com'</span>
</pre></div>
</div>
<p>Ancak gördüğünüz gibi, <cite>+</cite> işaretini kullandığınızda kodlarınız daha okunaklı oluyor.</p>
<p><cite>+</cite> işareti dışında karakter dizileri ile birlikte <cite>*</cite> (çarpı) işaretini de kullanabiliriz.
O zaman şöyle bir etki elde ederiz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"w"</span> <span class="o">*</span> <span class="mi">3</span>
<span class="go">'www'</span>
<span class="gp">>>> </span><span class="s2">"yavaş "</span> <span class="o">*</span> <span class="mi">2</span>
<span class="go">'yavaş yavaş '</span>
<span class="gp">>>> </span><span class="s2">"-"</span> <span class="o">*</span> <span class="mi">10</span>
<span class="go">'----------'</span>
<span class="gp">>>> </span><span class="s2">"uzak"</span> <span class="o">+</span> <span class="s2">" "</span> <span class="o">*</span> <span class="mi">5</span> <span class="o">+</span> <span class="s2">"çok uzak..."</span>
<span class="go">'uzak çok uzak...'</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, çok basit parçaları bir araya getirerek karmaşık çıktılar elde edebiliyoruz.
Mesela son örnekte <cite>“uzak”</cite> adlı karakter dizisine önce <cite>5</cite> adet boşluk karakteri (<code class="docutils literal notranslate"><span class="pre">"</span> <span class="pre">"</span> <span class="pre">*</span> <span class="pre">5</span></code>), ardından da <cite>“çok uzak…”</cite> adlı karakter dizisini ekleyerek istediğimiz çıktıyı aldık.</p>
<p>Burada <cite>+</cite> ve <cite>*</cite> adlı iki yeni araç görüyoruz.
Bunlar aslında sayılarla birlikte kullanılan birer aritmetik işleçtir.
Normalde <cite>+</cite> işleci toplama işlemleri için, <cite>*</cite> işleci ise çarpma işlemleri için kullanılır.
Ama yukarıdaki örneklerde, <cite>+</cite> işaretinin ‘birleştirme’; <cite>*</cite> işaretinin ise ‘tekrarlama’ anlamından ötürü bu iki işleci bazı durumlarda karakter dizileri ile birlikte de kullanabiliyoruz.
Bunların dışında bir de <cite>-</cite> (eksi) ve <cite>/</cite> (bölü) işleçleri bulunur.
Ancak bu işaretleri karakter dizileri ile birlikte kullanamıyoruz.</p>
<p>Karakter dizilerini sonraki bir bölümde bütün ayrıntılarıyla inceleyeceğiz.
O yüzden şimdilik bu konuya bir ara verelim.</p>
</div>
<div class="section" id="sayilara-giris">
<h3>Sayılara Giriş<a class="headerlink" href="#sayilara-giris" title="Bu başlık için kalıcı bağlantı">¶</a></h3>
<p>Dedik ki, Python’da birtakım veri tipleri bulunur ve karakter dizileri de bu veri tiplerinden yalnızca biridir.
Veri tipi olarak karakter dizilerinin dışında, biraz önce aritmetik işleçler vesilesiyle sözünü ettiğimiz, bir de ‘sayı’ (<em>number</em>) adlı bir veri tipi vardır.</p>
<p>Herhalde sayıların ne anlama geldiğini tarif etmeye gerek yok.
Bunlar bildiğimiz sayılardır.
Mesela:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mi">23</span>
<span class="go">23</span>
<span class="gp">>>> </span><span class="mi">4567</span>
<span class="go">4567</span>
<span class="gp">>>> </span><span class="mf">2.3</span>
<span class="go">2.3</span>
<span class="gp">>>> </span><span class="p">(</span><span class="mi">10</span><span class="o">+</span><span class="mi">2</span><span class="n">j</span><span class="p">)</span>
<span class="go">(10+2j)</span>
</pre></div>
</div>
<p>Python’da sayıların farklı alt türleri bulunur.
Mesela tamsayılar, kayan noktalı sayılar, karmaşık sayılar…</p>
<p>Yukarıdaki örnekler arasında geçen <cite>23</cite> ve <cite>4567</cite> birer tamsayıdır.
İngilizcede bu tür sayılara <em>integer</em> adı verilir.</p>
<p><cite>2.3</cite> ise bir kayan noktalı sayıdır (<em>floating point number</em> veya kısaca <em>float</em>).
Bu arada kayan noktalı sayılarda basamak ayracı olarak virgül değil, nokta işareti kullandığımıza dikkat edin.</p>
<p>En sonda gördüğümüz <cite>10+2j</cite> sayısı ise bir karmaşık sayıdır (<em>complex</em>).
Ancak eğer matematikle yoğun bir şekilde uğraşmıyorsanız karmaşık sayılar pek karşınıza çıkmaz.</p>
<p>Sayıları temel olarak öğrendiğimize göre etkileşimli kabuğu basit bir hesap makinesi niyetine kullanabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mi">5</span> <span class="o">+</span> <span class="mi">2</span>
<span class="go">7</span>
<span class="gp">>>> </span><span class="mi">25</span> <span class="o">*</span> <span class="mi">25</span>
<span class="go">625</span>
<span class="gp">>>> </span><span class="mi">5</span> <span class="o">/</span> <span class="mi">2</span>
<span class="go">2.5</span>
<span class="gp">>>> </span><span class="mi">10</span> <span class="o">-</span> <span class="mi">3</span>
<span class="go">7</span>
</pre></div>
</div>
<p>Yukarıdaki örneklerde kullandığımız aritmetik işleçlerden biraz önce bahsetmiştik.
O yüzden bunlara yabancılık çektiğinizi zannetmiyorum.
Ama biz yine de bu işleçleri ve görevlerini şöylece sıralayalım:</p>
<blockquote>
<div><table class="docutils align-default">
<colgroup>
<col style="width: 42%" />
<col style="width: 58%" />
</colgroup>
<thead>
<tr class="row-odd"><th class="head"><p>İşleç</p></th>
<th class="head"><p>Görevi</p></th>
</tr>
</thead>
<tbody>
<tr class="row-even"><td><p><cite>+</cite></p></td>
<td><p>toplama</p></td>
</tr>
<tr class="row-odd"><td><p><cite>-</cite></p></td>
<td><p>çıkarma</p></td>
</tr>
<tr class="row-even"><td><p><cite>*</cite></p></td>
<td><p>çarpma</p></td>
</tr>
<tr class="row-odd"><td><p><cite>/</cite></p></td>
<td><p>bölme</p></td>
</tr>
</tbody>
</table>
</div></blockquote>
<p>Yukarıdaki örneklerde bir şey dikkatinizi çekmiş olmalı:
Karakter dizilerini tanımlarken tırnak işaretlerini kullandık.
Ancak sayılarda tırnak işareti yok. Daha önce de dediğimiz gibi, tırnak işaretleri karakter dizilerinin ayırt edici özelliğidir.
Python’da tırnak içinde gösterdiğiniz her şey bir karakter dizisidir.
Mesela şu örneklere bakalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mi">34657</span>
<span class="go">34657</span>
</pre></div>
</div>
<p>Bu bir sayıdır.
Peki ya şu?</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"34657"</span>
<span class="go">'34657'</span>
</pre></div>
</div>
<p>Bu ise bir karakter dizisidir.
Dilerseniz biraz önce öğrendiğimiz <code class="docutils literal notranslate"><span class="pre">type()</span></code> fonksiyonu yardımıyla bu verilerin tipini sorgulayalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">type</span><span class="p">(</span><span class="mi">34657</span><span class="p">)</span>
<span class="go"><class 'int'></span>
</pre></div>
</div>
<p>Buradaki ‘int’ ifadesi İngilizce “<em>integer</em>”, yani tamsayı kelimesinin kısaltmasıdır.
Demek ki <cite>34657</cite> sayısı bir tamsayı imiş.
Bir de şuna bakalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">type</span><span class="p">(</span><span class="s2">"34657"</span><span class="p">)</span>
<span class="go"><class 'str'></span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <cite>34657</cite> sayısını tırnak içine aldığımızda bu sayı artık sayı olma özelliğini yitiriyor ve bir karakter dizisi oluyor.
Şu anda bu çok önemsiz bir ayrıntıymış gibi gelebilir size, ama aslında son derece önemli bir konudur bu.
Bu durumun etkilerini şu örneklerde görebilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mi">23</span> <span class="o">+</span> <span class="mi">65</span>
<span class="go">88</span>
</pre></div>
</div>
<p>Burada normal bir şekilde iki sayıyı birbiriyle topladık.</p>
<p>Bir de şuna bakın:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"23"</span> <span class="o">+</span> <span class="s2">"65"</span>
<span class="go">'2365'</span>
</pre></div>
</div>
<p>Burada ise Python iki karakter dizisini yan yana yazmakla yetindi; yani bunları birleştirdi.
Python açısından <cite>“23”</cite> ve <cite>23</cite> birbirinden farklıdır.
<cite>“23”</cite> bir karakter dizisi iken, <cite>23</cite> bir sayıdır.
Aynı şey <cite>“65”</cite> ve <cite>65</cite> için de geçerlidir.
Yani Python açısından <cite>“65”</cite> ile <cite>“Merhaba Zalim Dünya!”</cite> arasında hiç bir fark yoktur.
Bunların ikisi de karakter dizisi sınıfına girer.
Ancak <cite>65</cite> ile <cite>“65”</cite> birbirinden farklıdır.
<cite>65</cite> bir sayı iken, <cite>“65”</cite> bir karakter dizisidir.</p>
<p>Bu bilgi, özellikle aritmetik işlemlerde büyük önem taşır.
Bunu dilerseniz şu örnekler üzerinde gösterelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mi">45</span> <span class="o">+</span> <span class="s2">"45"</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">unsupported operand type(s) for +: 'int' and 'str'</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, yukarıdaki kodlar hata veriyor.
Bunun sebebi bir sayı (<cite>45</cite>) ile bir karakter dizisini (<cite>“45”</cite>) birbiriyle toplamaya çalışmamızdır.
Asla unutmayın, aritmetik işlemler ancak sayılar arasında yapılır.
Karakter dizileri ile herhangi bir aritmetik işlem yapılamaz.</p>
<p>Bir de şuna bakalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mi">45</span> <span class="o">+</span> <span class="mi">45</span>
<span class="go">90</span>
</pre></div>
</div>
<p>Bu kodlar ise düzgün çalışır.
Çünkü burada iki sayıyı aritmetik işleme soktuk ve başarılı olduk.</p>
<p>Son olarak şu örneği verelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"45"</span> <span class="o">+</span> <span class="s2">"45"</span>
<span class="go">'4545'</span>
</pre></div>
</div>
<p>Burada <cite>+</cite> işlecinin toplama anlamına gelmediğine dikkat edin.
Bu işleç burada iki karakter dizisini birleştirme görevi üstleniyor.
Yani yukarıdaki örneğin şu örnekten hiçbir farkı yoktur:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"yazbel."</span> <span class="o">+</span> <span class="s2">"com"</span>
<span class="go">'yazbel.com'</span>
</pre></div>
</div>
<p>Bu iki örnekte de yaptığımız şey karakter dizilerini birbiriyle birleştirmektir.</p>
<p>Gördüğünüz gibi, <cite>+</cite> işlecinin sağındaki ve solundaki değerler birer karakter dizisi ise bu işleç bu iki değeri birbiriyle birleştiriyor.
Ama eğer bu değerler birer sayı ise <cite>+</cite> işleci bu değerleri birbiriyle aritmetik olarak topluyor.</p>
<p><cite>*</cite> işleci de <cite>+</cite> işlecine benzer bir iş yapar.
Yani eğer <cite>*</cite> işleci bir sayı ve bir karakter dizisi ile karşılaşırsa, o karakter dizisini, verilen sayı kadar tekrarlar.
Örneğin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s2">"w"</span> <span class="o">*</span> <span class="mi">3</span>
<span class="go">'www'</span>
</pre></div>
</div>
<p>Burada <cite>*</cite> işleci bir karakter dizisi (<cite>“w”</cite>) ve bir sayı (<cite>3</cite>) arasında işlem yaptığı için, karakter dizisini, ilgili sayı kadar tekrarlıyor.
Yani <cite>“w”</cite> karakter dizisini <cite>3</cite> kez tekrarlıyor.</p>
<p>Bir de şuna bakalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mi">25</span> <span class="o">*</span> <span class="mi">3</span>
<span class="go">75</span>
</pre></div>
</div>
<p>Burada ise <cite>*</cite> işleci iki adet sayı arasında işlem yaptığı için bu değerleri birbiriyle aritmetik olarak çarpıyor ve <cite>75</cite> değerini elde etmemizi sağlıyor.</p>
<p>Gördüğünüz gibi, o anda elimizde bulunan verilerin tipini bilmek gerçekten de büyük önem taşıyor.
Çünkü eğer elimizdeki verilerin tipini bilmezsek nasıl sonuçlar elde edeceğimizi de kestiremeyiz.</p>
<p>Böylece karakter dizileri ile sayılar arasındaki farkı öğrenmiş olduk.
Bu bilgiler size önemsizmiş gibi gelebilir, ama aslında karakter dizileri ile sayılar arasındaki farkı anlamak, Python programlama dilinin önemli bir bölümünü öğrenmiş olmak demektir.
İleride yazacağınız en karmaşık programlarda bile, bazen programınızın çalışmamasının (veya daha kötüsü yanlış çalışmasının) nedeninin karakter dizileri ile sayıları birbirine karıştırmanız olduğunu göreceksiniz.
O yüzden burada öğrendiğiniz hiçbir bilgi kırıntısını baştan savmamanızı (ve sabırsızlık ya da acelecilik etmemenizi) tavsiye ederim.</p>
</div>
<div class="section" id="degiskenler">
<h3>Değişkenler<a class="headerlink" href="#degiskenler" title="Bu başlık için kalıcı bağlantı">¶</a></h3>
<p>Şimdi şöyle bir durum düşünün:
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>
<p>Bu programı yazarken ilk aşamada yapmanız gereken şey, kullanıcının belirlediği kullanıcı adı ve parolanın uzunluğunu tek tek denetlemek olmalı.</p>
<p>Mesela kullanıcı şöyle bir kullanıcı adı belirlemiş olsun:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">firat_ozgul_1980</span>
</pre></div>
</div>
<p>Kullanıcının belirlediği parola ise şu olsun:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>rT%65#$hGfUY56123
</pre></div>
</div>
<p>İşte bizim öncelikle kullanıcıdan gelen bu verilerin teker teker uzunluğunu biliyor olmamız lazım, ki bu verilerin toplam <cite>40</cite> karakter sınırını aşıp aşmadığını denetleyebilelim.</p>
<p>Peki bu verilerin uzunluğunu nasıl ölçeceğiz?
Elbette bunun için verilerdeki harfleri elle tek tek saymayacağız.
Bunun yerine, Python programlama dilinin bize sunduğu bir aracı kullanacağız.
Peki nedir bu araç?</p>
<p>Hatırlarsanız birkaç sayfa önce <code class="docutils literal notranslate"><span class="pre">type()</span></code> adlı bir fonksiyondan söz etmiştik.
Bu fonksiyonun görevi bir verinin hangi tipte olduğunu bize bildirmekti.
İşte tıpkı <code class="docutils literal notranslate"><span class="pre">type()</span></code> gibi, Python’da <code class="docutils literal notranslate"><span class="pre">len()</span></code> adlı başka bir fonksiyon daha bulunur.
Bu fonksiyonun görevi ise karakter dizilerinin (ve ileride göreceğimiz gibi, başka veri tiplerinin) uzunluğunu ölçmektir.
Yani bu fonksiyonu kullanarak bir karakter dizisinin toplam kaç karakterden oluştuğunu öğrenebiliriz.</p>
<p>Biz henüz kullanıcıdan nasıl veri alacağımızı bilmiyoruz.
Ama şimdilik şunu söyleyebiliriz:
Python’da kullanıcıdan herhangi bir veri aldığımızda, bu veri bize bir karakter dizisi olarak gelecektir.
Yani kullanıcıdan yukarıdaki kullanıcı adı ve parolayı aldığımızı varsayarsak, bu veriler bize şu şekilde gelir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="s2">"firat_ozgul_1980"</span>
</pre></div>
</div>
<p>ve:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="s2">"rT%65#$hGfUY56123"</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, elde ettiğimiz veriler tırnak içinde yer alıyor.
Yani bunlar birer karakter dizisi.
Şimdi gelin yukarıda bahsettiğimiz <code class="docutils literal notranslate"><span class="pre">len()</span></code> fonksiyonunu kullanarak bu karakter dizilerinin uzunluğunu ölçelim.</p>
<p>Dediğimiz gibi, <code class="docutils literal notranslate"><span class="pre">len()</span></code> de tıpkı <code class="docutils literal notranslate"><span class="pre">type()</span></code> gibi bir fonksiyondur.
Dolayısıyla <code class="docutils literal notranslate"><span class="pre">len()</span></code> fonksiyonunun kullanımı <code class="docutils literal notranslate"><span class="pre">type()</span></code> fonksiyonunun kullanımına çok benzer.
Nasıl <code class="docutils literal notranslate"><span class="pre">type()</span></code> fonksiyonu bize, kendisine verdiğimiz parametrelerin <strong>tipini</strong> söylüyorsa, <code class="docutils literal notranslate"><span class="pre">len()</span></code> fonksiyonu da kendisine verdiğimiz parametrelerin <strong>uzunluğunu</strong> söyler.</p>
<p>Dikkatlice bakın:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="s2">"firat_ozgul_1980"</span><span class="p">)</span>
<span class="go">16</span>
<span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="s2">"rT%65#$hGfUY56123"</span><span class="p">)</span>
<span class="go">17</span>
</pre></div>
</div>
<p>Demek ki <cite>“firat_ozgul_1980”</cite> adlı karakter dizisinde <cite>16</cite>; <cite>“rT%65#$hGfUY56123”</cite> adlı karakter dizisinde ise <cite>17</cite> karakter varmış.
Bizim istediğimiz şey bu iki değerin toplam uzunluğunun <cite>40</cite> karakteri aşmaması.
Bunu denetlemek için yapmamız gereken şey bu iki değerin uzunluğunu birbiriyle toplamak olmalı.
Yani:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="s2">"firat_ozgul_1980"</span><span class="p">)</span> <span class="o">+</span> <span class="nb">len</span><span class="p">(</span><span class="s2">"rT%65#$hGfUY56123"</span><span class="p">)</span>
</pre></div>
</div>
<p>Buradan alacağımız sonuç <cite>33</cite> olacaktır.
Demek ki kullanıcı <cite>40</cite> karakter limitini aşmamış.
O halde programımız bu kullanıcı adı ve parolayı kabul edebilir…</p>
<p>Bu arada, belki farkettiniz, belki de farketmediniz, ama burada da çok önemli bir durumla karşı karşıyayız.
Gördüğünüz gibi <code class="docutils literal notranslate"><span class="pre">len()</span></code> fonksiyonu bize sayı değerli bir veri gönderiyor.
Gelin isterseniz bunu teyit edelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">type</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="s2">"firat_ozgul_1980"</span><span class="p">))</span>
<span class="go"><class 'int'></span>
</pre></div>
</div>
<p><code class="docutils literal notranslate"><span class="pre">len()</span></code> fonksiyonunun bize sayı değerli bir veri göndermesi sayesinde bu fonksiyondan elde ettiğimiz değerleri birbiriyle toplayabiliyoruz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="s2">"firat_ozgul_1980"</span><span class="p">)</span> <span class="o">+</span> <span class="nb">len</span><span class="p">(</span><span class="s2">"rT%65#$hGfUY56123"</span><span class="p">)</span>
<span class="go">33</span>
</pre></div>
</div>
<p>Eğer <code class="docutils literal notranslate"><span class="pre">len()</span></code> fonksiyonu bize sayı değil de mesela karakter dizisi verseydi, bu fonksiyondan elde ettiğimiz değerleri yukarıdaki gibi doğrudan birbiriyle aritmetik olarak toplayamazdık.
Öyle bir durumda, bu iki veriyi birbiriyle toplamaya çalıştığımızda, <cite>+</cite> işleci <cite>16</cite> ve <cite>17</cite> değerlerini birbiriyle toplamak yerine bu değerleri birbiriyle birleştirerek bize <cite>‘1617’</cite> gibi bir sonuç verecekti.</p>
<p>Her zaman söylediğimiz gibi, Python’da veri tipi kavramını çok iyi anlamak ve o anda elimizde bulunan bir verinin hangi tipte olduğunu bilmek çok önemlidir.
Aksi halde programlarımızda hata yapmamız kaçınılmazdır.</p>
<p>Eğer yukarıda anlattığımız şeyleri kafa karıştırıcı bulduysanız hiç endişe etmeyin.
Birkaç bölüm sonra <code class="docutils literal notranslate"><span class="pre">input()</span></code> adlı bir fonksiyondan bahsettiğimizde şimdi söylediğimiz şeyleri çok daha net anlayacaksınız.</p>
<p>Biraz sonra <code class="docutils literal notranslate"><span class="pre">len()</span></code> fonksiyonundan bahsetmeye devam edeceğiz, ama isterseniz ondan önce çok önemli bir konuya değinelim.</p>
<p>Biraz önce şöyle bir örnek vermiştik:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="s2">"firat_ozgul_1980"</span><span class="p">)</span>
<span class="go">16</span>
<span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="s2">"rT%65#$hGfUY56123"</span><span class="p">)</span>
<span class="go">17</span>
<span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="s2">"firat_ozgul_1980"</span><span class="p">)</span> <span class="o">+</span> <span class="nb">len</span><span class="p">(</span><span class="s2">"rT%65#$hGfUY56123"</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu kodlar, istediğimiz şeyi gayet güzel yerine getiriyor.
Ama sizce de yukarıdaki kodlarda çok rahatsız edici bir durum yok mu?</p>
<p>Dikkat ederseniz, yukarıdaki örneklerde kullandığımız verileri, program içinde her ihtiyaç duyduğumuzda tekrar tekrar yazdık.
Böylece aynı program içinde iki kez <cite>“firat_ozgul_1980”</cite>; iki kez de <cite>“rT%65#$hGfUY56123”</cite> yazmak zorunda kaldık.
Halbuki bu verileri programlarımızın içinde her ihtiyaç duyduğumuzda tekrar tekrar yazmak yerine bir değişkene atasak ve gerektiğinde o değişkeni kullansak çok daha iyi olmaz mı?
Herhalde olur…</p>
<p>Peki nedir bu değişken dediğimiz şey?</p>
<p>Python’da bir program içinde değerlere verilen isimlere değişken denir.
Hemen bir örnek verelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">n</span> <span class="o">=</span> <span class="mi">5</span>
</pre></div>
</div>
<p>Burada <cite>5</cite> sayısını bir değişkene atadık.
Değişkenimiz ise <cite>n</cite>.
Ayrıca <cite>5</cite> sayısını bir değişkene atamak için <cite>=</cite> işaretinden yararlandığımıza da çok dikkat edin.
Buradan, <cite>=</cite> işaretinin Python programlama dilinde değer atama işlemleri için kullanıldığı sonucunu çıkarıyoruz.</p>
<p><code class="docutils literal notranslate"><span class="pre">n</span> <span class="pre">=</span> <span class="pre">5</span></code> gibi bir komut yardımıyla <cite>5</cite> değerini <cite>n</cite> adlı değişkene atamamız sayesinde artık ne zaman <cite>5</cite> sayısına ihtiyaç duysak bu <cite>n</cite> değişkenini çağırmamız yeterli olacaktır:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">n</span>
<span class="go">5</span>
<span class="gp">>>> </span><span class="n">n</span> <span class="o">*</span> <span class="mi">10</span>
<span class="go">50</span>
<span class="gp">>>> </span><span class="n">n</span> <span class="o">/</span> <span class="mi">2</span>
<span class="go">2.5</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <cite>5</cite> değerini bir değişkene atadıktan sonra, bu <cite>5</cite> değerini kullanmamız gereken yerlerde sadece değişkenin adını kullandığımızda değişkenin değerini Python otomatik olarak yerine koyabiliyor.
Yani <code class="docutils literal notranslate"><span class="pre">n</span> <span class="pre">=</span> <span class="pre">5</span></code> komutuyla <cite>n</cite> adlı bir değişken tanımladıktan sonra, artık ne zaman <cite>5</cite> sayısına ihtiyaç duysak <cite>n</cite> değişkenini çağırmamız yeterli olacaktır.
Python o <cite>5</cite> değerini otomatik olarak yerine koyar.</p>
<p>Şimdi de <cite>pi</cite> adlı başka bir değişken tanımlayalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">pi</span> <span class="o">=</span> <span class="mf">3.14</span>
</pre></div>
</div>
<p>Bu <cite>pi</cite> değişkeninin değeri ile <cite>n</cite> değişkeninin değerini toplayalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">pi</span> <span class="o">+</span> <span class="n">n</span>
<span class="go">8.14</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, değerleri her defasında tekrar yazmak yerine bunları bir değişkene atayıp, gereken yerde bu değişkeni kullanmak çok daha pratik bir yöntem.</p>
<p>Aynı şeyi programımız için de yapabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kullanıcı_adı</span> <span class="o">=</span> <span class="s2">"firat_ozgul_1980"</span>
<span class="gp">>>> </span><span class="n">parola</span> <span class="o">=</span> <span class="s2">"rT%65#$hGfUY56123"</span>
</pre></div>
</div>
<p><cite>=</cite> işaretini kullanarak ilgili değerlere artık birer ad verdiğimiz, yani bu değerleri birer değişkene atadığımız için, bu değerleri kullanmamız gereken yerlerde değerlerin kendisini uzun uzun yazmak yerine, belirlediğimiz değişken adlarını kullanabiliriz.
Mesela:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="n">kullanıcı_adı</span><span class="p">)</span>
<span class="go">16</span>
<span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="n">parola</span><span class="p">)</span>
<span class="go">17</span>
<span class="gp">>>> </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="go">33</span>
<span class="gp">>>> </span><span class="n">k_adı_uzunluğu</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="gp">>>> </span><span class="nb">type</span><span class="p">(</span><span class="n">k_adı_uzunluğu</span><span class="p">)</span>
<span class="go"><class 'int'></span>
</pre></div>
</div>
<p>Gördüğünüz gibi, değişken kullanımı işlerimizi bir hayli kolaylaştırıyor.</p>
<div class="section" id="degisken-adi-belirleme-kurallari">
<h4>Değişken Adı Belirleme Kuralları<a class="headerlink" href="#degisken-adi-belirleme-kurallari" title="Bu başlık için kalıcı bağlantı">¶</a></h4>
<p>Python programlama dilinde, değişken adı olarak belirleyebileceğimiz kelime sayısı neredeyse sınırsızdır.
Yani hemen hemen her kelimeyi değişken adı olarak kullanabiliriz.
Ama yine de değişken adı belirlerken dikkat etmemiz gereken bazı kurallar var.
Bu kuralların bazıları zorunluluk, bazıları ise yalnızca tavsiye niteliğindedir.</p>
<p>Şimdi bu kuralları tek tek inceleyelim:</p>
<p>1. Değişken adları bir sayı ile başlayamaz.
Yani şu kullanım yanlıştır:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mi">3</span><span class="n">_kilo_elma</span> <span class="o">=</span> <span class="s2">"5 TL"</span>
</pre></div>
</div>
<p>2. Değişken adları aritmetik işleçlerle başlayamaz.
Yani şu kullanım yanlıştır:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="o">+</span><span class="n">değer</span> <span class="o">=</span> <span class="mi">4568</span>
</pre></div>
</div>
<p>3. Değişken adları ya bir alfabe harfiyle ya da <cite>_</cite> işaretiyle başlamalıdır:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">_değer</span> <span class="o">=</span> <span class="mi">4568</span>
<span class="gp">>>> </span><span class="n">değer</span> <span class="o">=</span> <span class="mi">4568</span>
</pre></div>
</div>
<p>4. Değişken adları içinde Türkçe karakterler kullanabilirsiniz.
Ancak ileride beklenmedik uyum sorunları çıkması ihtimaline karşı değişken adlarında Türkçe karakter kullanmaktan kaçınmak isteyebilirsiniz.</p>
<p>5. Aşağıdaki kelimeleri değişken adı olarak kullanamazsınız:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'False'</span><span class="p">,</span> <span class="s1">'None'</span><span class="p">,</span> <span class="s1">'True'</span><span class="p">,</span> <span class="s1">'and'</span><span class="p">,</span> <span class="s1">'as'</span><span class="p">,</span> <span class="s1">'assert'</span><span class="p">,</span> <span class="s1">'async'</span><span class="p">,</span> <span class="s1">'await'</span><span class="p">,</span> <span class="s1">'break'</span><span class="p">,</span> <span class="s1">'class'</span><span class="p">,</span> <span class="s1">'continue'</span><span class="p">,</span> <span class="s1">'def'</span><span class="p">,</span> <span class="s1">'del'</span><span class="p">,</span>
<span class="s1">'elif'</span><span class="p">,</span> <span class="s1">'else'</span><span class="p">,</span> <span class="s1">'except'</span><span class="p">,</span> <span class="s1">'finally'</span><span class="p">,</span> <span class="s1">'for'</span><span class="p">,</span> <span class="s1">'from'</span><span class="p">,</span> <span class="s1">'global'</span><span class="p">,</span> <span class="s1">'if'</span><span class="p">,</span> <span class="s1">'import'</span><span class="p">,</span> <span class="s1">'in'</span><span class="p">,</span> <span class="s1">'is'</span><span class="p">,</span> <span class="s1">'lambda'</span><span class="p">,</span> <span class="s1">'nonlocal'</span><span class="p">,</span>
<span class="s1">'not'</span><span class="p">,</span> <span class="s1">'or'</span><span class="p">,</span> <span class="s1">'pass'</span><span class="p">,</span> <span class="s1">'raise'</span><span class="p">,</span> <span class="s1">'return'</span><span class="p">,</span> <span class="s1">'try'</span><span class="p">,</span> <span class="s1">'while'</span><span class="p">,</span> <span class="s1">'with'</span><span class="p">,</span> <span class="s1">'yield'</span><span class="p">]</span>
</pre></div>
</div>
<p>Bunlar Python’da özel anlam ifade eden kelimelerdir.
Etkileşimli kabuk zaten bu kelimeleri değişken adı olarak kullanmanıza izin vermez.
Örneğin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">elif</span> <span class="o">=</span> <span class="s2">"hoş kız"</span>
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>
<span class="k">elif</span> <span class="o">=</span> <span class="s2">"hoş kız"</span>
<span class="o">^</span>
<span class="gr">SyntaxError</span>: <span class="n">invalid syntax</span>
<span class="gp">>>> </span><span class="k">as</span> <span class="o">=</span> <span class="s2">"kare"</span>
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>
<span class="k">as</span> <span class="o">=</span> <span class="s2">"kare"</span>
<span class="o">^</span>
<span class="gr">SyntaxError</span>: <span class="n">invalid syntax</span>
<span class="gp">>>> </span><span class="kc">False</span> <span class="o">=</span> <span class="mi">45</span>
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>
<span class="gr">SyntaxError</span>: <span class="n">assignment to keyword</span>
</pre></div>
</div>
<p>Ama ileride göreceğimiz gibi, programlarınızı bir dosyaya yazarken bu kelimeleri değişken adı olarak kullanmaya çalışırsanız programınız tespit etmesi çok güç hatalar üretecektir.</p>
<p>Bu arada elbette yukarıdaki listeyi bir çırpıda ezberlemeniz beklenmiyor sizden.
Python programlama dilini öğrendikçe özel kelimeleri bir bakışta tanıyabilecek duruma geleceksiniz.
Ayrıca eğer isterseniz şu komutları vererek, istediğiniz her an yukarıdaki listeye ulaşabilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">import</span> <span class="nn">keyword</span>
<span class="gp">>>> </span><span class="n">keyword</span><span class="o">.</span><span class="n">kwlist</span>
<span class="go">['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del',</span>
<span class="go">'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal',</span>
<span class="go">'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']</span>
</pre></div>
</div>
<p>Size bir soru:
Acaba bu listede kaç tane kelime var?</p>
<p>Bu soru karşısında listedeki kelimeleri tek tek elle saymaya kalkışan arkadaşlarıma teessüflerimi iletiyorum…
Bu tür işler için hangi aracı kullanabileceğimizi artık çok iyi biliyor olmalısınız:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="n">keyword</span><span class="o">.</span><span class="n">kwlist</span><span class="p">)</span>
<span class="go">35</span>
</pre></div>
</div>
<p>Bu kodları şöyle yazabileceğimizi de biliyorsunuz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">yasaklı_kelimeler</span> <span class="o">=</span> <span class="n">keyword</span><span class="o">.</span><span class="n">kwlist</span>
<span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="n">yasaklı_kelimeler</span><span class="p">)</span>
<span class="go">35</span>
</pre></div>
</div>
<p>Bu arada, yukarıdaki kodların bir kısmını henüz anlayamamış olabilirsiniz.
Hiç endişe etmeyin.
Yukarıdaki kodları vermemizin sebebi değişken adı olarak kullanılamayacak kelimelere kısa yoldan nasıl ulaşabileceğinizi gösterebilmek içindir.
Bir-iki bölüm sonra burada yazdığımız kodları rahatlıkla anlayabilecek düzeye geleceksiniz.</p>
<p>Yukarıda verdiğimiz kodların çıktısından anladığımıza göre, toplam <cite>35</cite> tane kelime varmış değişken adı belirlerken kullanmaktan kaçınmamız gereken…</p>
<p>6. Yukarıdaki kelimeler dışında, Python programlama diline ait fonksiyon ve benzeri araçların adlarını da değişken adı olarak kullanmamalısınız.
Örneğin yazdığınız programlarda değişkenlerinize <cite>type</cite> veya <cite>len</cite> adı vermeyin.
Çünkü ‘type’ ve ‘len’ Python’a ait iki önemli fonksiyonun adıdır.
Eğer mesela bir değişkene <cite>type</cite> adını verirseniz, o programda artık <code class="docutils literal notranslate"><span class="pre">type()</span></code> fonksiyonunu kullanamazsınız:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">type</span> <span class="o">=</span> <span class="mi">3456</span>
</pre></div>
</div>
<p>Bu örnekte <cite>type</cite> adında bir değişken tanımladık.
Şimdi mesela <cite>“elma”</cite> kelimesinin tipini denetlemek için <code class="docutils literal notranslate"><span class="pre">type()</span></code> fonksiyonunu kullanmaya çalışalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">type</span><span class="p">(</span><span class="s2">"elma"</span><span class="p">)</span>
<span class="gt">Traceback (most recent call last):</span>
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>, in <span class="n"><module></span>
<span class="gr">TypeError</span>: <span class="n">'int' object is not callable</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, artık <code class="docutils literal notranslate"><span class="pre">type()</span></code> fonksiyonu çalışmıyor.
Çünkü siz ‘type’ kelimesini bir değişken adı olarak kullanarak, <code class="docutils literal notranslate"><span class="pre">type()</span></code> fonksiyonunu kullanılamaz hale getirdiniz.</p>
<p>Bu durumdan kurtulmak için etkileşimli kabuğu kapatıp tekrar açabilirsiniz.
Ya da eğer etkileşimli kabuğu kapatmak istemiyorsanız şu komut yardımıyla <cite>type</cite> değişkenini ortadan kaldırmayı da tercih edebilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">del</span> <span class="nb">type</span>
</pre></div>
</div>
<p>Böylece, (tahmin edebileceğiniz gibi <em>delete</em> (silmek) kelimesinin kısaltması olan) <code class="docutils literal notranslate"><span class="pre">del</span></code> komutuyla <cite>type</cite> değişkenini silmiş oldunuz.
Artık ‘type’ kelimesi yine <code class="docutils literal notranslate"><span class="pre">type()</span></code> fonksiyonunu çağıracak:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">type</span><span class="p">(</span><span class="s2">"elma"</span><span class="p">)</span>
<span class="go"><class 'str'></span>
</pre></div>
</div>
<p>7. Değişken adlarını belirlerken, değişkeni oluşturan kelimeler arasında boşluk bırakılamaz.
Yani şu kullanım yanlıştır:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kullanıcı</span> <span class="n">adı</span> <span class="o">=</span> <span class="s2">"yazbel"</span>
</pre></div>
</div>
<p>Yukarıdaki değişkeni şu şekilde tanımlayabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kullanıcı_adı</span> <span class="o">=</span> <span class="s2">"yazbel"</span>
</pre></div>
</div>
<p>Ya da şöyle:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">kullanıcıAdı</span> <span class="o">=</span> <span class="s2">"yazbel"</span>
</pre></div>
</div>
<p>8. Değişken adları belirlerken, değişken adının, değişkenin değerini olabildiğince betimlemesine dikkat etmemiz kodlarımızın okunaklılığını artıracaktır.
Örneğin:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">personel_sayısı</span> <span class="o">=</span> <span class="mi">45</span>
</pre></div>
</div>
<p>Yukarıdaki, tanımladığı değere uygun bir değişken adıdır.
Şu ise kurallara uygun bir değişken adı olsa da yeterince betimleyici değildir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">sayı</span> <span class="o">=</span> <span class="mi">45</span>
</pre></div>
</div>
<p>9. Değişken adları ne çok kısa, ne de çok uzun olmalıdır.
Mesela şu değişken adı, kodları okuyan kişiye, değişken değerinin anlamı konusunda pek fikir vermez:</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">345542353</span>
</pre></div>
</div>
<p>Şu değişken adı ise gereksiz yere uzundur:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">türkiye_büyük_millet_meclisi_milletvekili_sayısı</span> <span class="o">=</span> <span class="mi">600</span>
</pre></div>
</div>
<p>Değişken adlarının uzunluğunu makul seviyede tutmak esastır:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">tbmm_mv_sayısı</span> <span class="o">=</span> <span class="mi">600</span>
</pre></div>
</div>
<p>Yukarıda verdiğimiz bütün bu örnekler bize, Python’da değişkenlerin, değerlere atanmış adlardan ibaret olduğunu gösteriyor.
Değişkenler, yazdığımız programlarda bize çok büyük kolaylık sağlar.
Mesela <cite>123432456322</cite> gibi bir sayıyı ya da <cite>“Türkiye Cumhuriyeti Çalışma ve Sosyal Güvenlik Bakanlığı”</cite> gibi bir karakter dizisini gerektiği her yerde tek tek elle yazmak yerine, bunları birer değişkene atayarak, gerektiğinde sadece bu değişken adını kullanmak çok daha mantıklı bir iştir.</p>
<p>Ayrıca zaten ileride kullanıcıdan veri almaya başladığınızda, aldığınız bu verileri, yazdığınız programda kullanabilmek için mutlaka bir değişkene atamanız gerekecek.
O yüzden Python’daki değişken kavramını şimdiden iyi tanıyıp anlamakta büyük fayda var.</p>
</div>
<div class="section" id="uygulama-ornekleri">
<h4>Uygulama Örnekleri<a class="headerlink" href="#uygulama-ornekleri" title="Bu başlık için kalıcı bağlantı">¶</a></h4>
<p>Gelin isterseniz yukarıda verdiğimiz bilgileri pekiştirmek için birkaç ufak alıştırma yapalım, alıştırma yaparken de sizi yine Python programlama diline ilişkin çok önemli bazı yeni bilgilerle tanıştıralım.</p>
<p>Diyelim ki aylık yol masrafımızı hesaplayan bir program yazmak istiyoruz.
Elimizdeki verilerin şunlar olduğunu varsayalım:</p>
<ol class="arabic simple">
<li><p>Cumartesi-Pazar günleri çalışmıyoruz.</p></li>
<li><p>Dolayısıyla ayda <cite>22</cite> gün çalışıyoruz.</p></li>
<li><p>Evden işe gitmek için kullandığımız vasıtanın ücreti <cite>1.5</cite> TL</p></li>
<li><p>İşten eve dönmek için kullandığımız vasıtanın ücreti <cite>1.4</cite> TL</p></li>
</ol>
<p>Aylık yol masrafımızı hesaplayabilmek için gidiş ve dönüş ücretlerini toplayıp, bunları çalıştığımız gün sayısıyla çarpmamız yeterli olacaktır.
Elimizdeki bu bilgilere göre aylık yol masrafımızı hesaplamak için şöyle bir formül üretebiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">masraf</span> <span class="o">=</span> <span class="n">gün</span> <span class="n">sayısı</span> <span class="n">x</span> <span class="p">(</span><span class="n">gidiş</span> <span class="n">ücreti</span> <span class="o">+</span> <span class="n">dönüş</span> <span class="n">ücreti</span><span class="p">)</span>
</pre></div>
</div>
<p>Dilerseniz hemen bunu bir Python programı haline getirelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mi">22</span> <span class="o">*</span> <span class="p">(</span><span class="mf">1.5</span> <span class="o">+</span> <span class="mf">1.4</span><span class="p">)</span>
<span class="go">63.8</span>
</pre></div>
</div>
<p>Demek ki bir ayda <cite>63.8</cite> TL’lik bir yol masrafımız varmış.</p>
<p>Bu arada, yukarıdaki örnekte bir şey dikkatinizi çekmiş olmalı.
Aritmetik işlemi yaparken bazı sayıları parantez içine aldık.
Python’da aritmetik işlemler yapılırken alıştığımız matematik kuralları geçerlidir.
Yani mesela aynı anda bölme, çıkarma, toplama ve çarpma işlemleri yapılacaksa işlem öncelik sırası önce bölme ve çarpma, sonra toplama ve çıkarma şeklinde olacaktır.
Elbette siz parantezler yardımıyla bu işlem sırasını değiştirebilirsiniz.</p>
<p>Bu anlattıklarımıza göre, eğer yukarıda yol masrafını hesaplayan programda parantezleri kullanmazsak, işlem öncelik kuralları gereğince Python önce <cite>22</cite> ile <cite>1.5</cite>’i çarpıp, çıkan sonucu <cite>1.4</cite> ile toplayacağı için elde ettiğimiz sonuç yanlış çıkacaktır.
Bizim burada doğru sonuç alabilmemiz için önce <cite>1.5</cite> ile <cite>1.4</cite>’ü toplamamız, çıkan sonucu da <cite>22</cite> ile çarpmamız gerekiyor.
Bu sıralamayı da parantezler yardımıyla elde ediyoruz.</p>
<p>Yine dikkat ederseniz, yukarıdaki örnek programda aslında çok verimsiz bir yol izledik.
Gördüğünüz gibi, bu programda bütün değerleri tek tek elle kendimiz giriyoruz.
Örneğin çalışılan gün sayısına karşılık gelen <cite>22</cite> değerini başka bir yerde daha kullanmak istesek aynı sayıyı tekrar elle doğrudan kendimiz girmek zorundayız.
Mesela yılda kaç gün çalıştığımızı hesaplayalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mi">22</span> <span class="o">*</span> <span class="mi">12</span>
<span class="go">264</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, burada da <cite>22</cite> sayısına ihtiyaç duyduk.
Aslında değerleri bu şekilde her defasında tekrar tekrar elle girmek hem hata yapma riskini artırdığı, hem de bize fazladan iş çıkardığı için tercih edilmeyen bir yöntemdir.
Bunun yerine, <cite>22</cite> sayısına bir isim verip, gereken yerlerde bu ismi kullanmak daha mantıklı olacaktır.
Yani tıpkı kullanıcı ve parola örneğinde olduğu gibi, burada da verileri öncelikle bir değişkene atamak çok daha akıllıca bir iştir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">gün</span> <span class="o">=</span> <span class="mi">22</span>
<span class="gp">>>> </span><span class="n">gidiş_ücreti</span> <span class="o">=</span> <span class="mf">1.5</span>
<span class="gp">>>> </span><span class="n">dönüş_ücreti</span> <span class="o">=</span> <span class="mf">1.4</span>
<span class="gp">>>> </span><span class="n">gün</span> <span class="o">*</span> <span class="p">(</span><span class="n">gidiş_ücreti</span> <span class="o">+</span> <span class="n">dönüş_ücreti</span><span class="p">)</span>
<span class="go">63.8</span>
</pre></div>
</div>
<p>Bütün değerleri birer değişkene atadığımız için, artık bu değişkenleri istediğimiz yerde kullanabiliriz.
Mesela yılda toplam kaç gün çalıştığımızı bulmak istersek, ilgili değeri elle yazmak yerine, yukarıda tanımladığımız <cite>gün</cite> değişkenini kullanabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">gün</span> <span class="o">*</span> <span class="mi">12</span>
<span class="go">264</span>
</pre></div>
</div>
<p>İlerleyen zamanda aylık çalışılan gün sayısı değişirse sadece <cite>gün</cite> değişkeninin değerini değiştirmemiz yeterli olacaktır:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">gün</span> <span class="o">=</span> <span class="mi">23</span>
<span class="gp">>>> </span><span class="n">gün</span> <span class="o">*</span> <span class="p">(</span><span class="n">gidiş_ücreti</span> <span class="o">+</span> <span class="n">dönüş_ücreti</span><span class="p">)</span>
<span class="go">66.7</span>
<span class="gp">>>> </span><span class="n">gün</span> <span class="o">*</span> <span class="mi">12</span>
<span class="go">276</span>
</pre></div>
</div>
<p>Eğer bu şekilde değişken atamak yerine, değerleri gerektiği her yerde elle yazsaydık, bu değerlerde herhangi bir değişiklik yapmamız gerektiğinde program içinde geçen ilgili bütün değerleri bulup tek tek değiştirmemiz gerekecekti:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mi">23</span> <span class="o">*</span> <span class="p">(</span><span class="mf">1.6</span> <span class="o">+</span> <span class="mf">1.5</span><span class="p">)</span>
<span class="go">71.3</span>
<span class="gp">>>> </span><span class="mi">23</span> <span class="o">*</span> <span class="mi">12</span>
<span class="go">276</span>
</pre></div>
</div>
<p>Değişken kavramı şu anda gözünüze pek anlamlı görünmemiş olabilir.
Ama programlarımızı ileride dosyaya kaydettiğimiz zaman bu değişkenler çok daha kullanışlı araçlar olarak karşımıza çıkacaktır.</p>
<p>Dilerseniz bir örnek daha yaparak yukarıdaki bilgilerin kafamıza iyice yerleşmesini sağlayalım.
Mesela bir dairenin alanını (yaklaşık olarak) hesaplayan bir program yazalım.</p>
<p>Öncelikle <cite>çap</cite> adlı bir değişken tanımlayarak dairenin çapını belirleyelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">çap</span> <span class="o">=</span> <span class="mi">16</span>
</pre></div>
</div>
<p>Bu değeri kullanarak dairemizin yarıçapını hesaplayabiliriz.
Bunun için <cite>çap</cite> değişkeninin değerinin yarısını almamız yeterli olacaktır:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">yarıçap</span> <span class="o">=</span> <span class="n">çap</span> <span class="o">/</span> <span class="mi">2</span>
</pre></div>
</div>
<p>pi sayısını <cite>3.14159</cite> olarak alalım.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">pi</span> <span class="o">=</span> <span class="mf">3.14159</span>
</pre></div>
</div>
<p>Bir dairenin alan formülü (pi)r<sup>2</sup>’dir:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">alan</span> <span class="o">=</span> <span class="n">pi</span> <span class="o">*</span> <span class="p">(</span><span class="n">yarıçap</span> <span class="o">*</span> <span class="n">yarıçap</span><span class="p">)</span>
</pre></div>
</div>
<p>Son olarak <cite>alan</cite> değişkeninin değerini ekrana yazdırabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">alan</span>
<span class="go">201.06176</span>
</pre></div>
</div>
<p>Böylece bir dairenin alanını yaklaşık olarak hesaplamış olduk.
Dilerseniz programımızı bir de derli toplu olarak görelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">çap</span> <span class="o">=</span> <span class="mi">16</span>
<span class="gp">>>> </span><span class="n">yarıçap</span> <span class="o">=</span> <span class="n">çap</span> <span class="o">/</span> <span class="mi">2</span>
<span class="gp">>>> </span><span class="n">pi</span> <span class="o">=</span> <span class="mf">3.14159</span>
<span class="gp">>>> </span><span class="n">alan</span> <span class="o">=</span> <span class="n">pi</span> <span class="o">*</span> <span class="p">(</span><span class="n">yarıçap</span> <span class="o">*</span> <span class="n">yarıçap</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">alan</span>
<span class="go">201.06176</span>
</pre></div>
</div>
<p>Görüyorsunuz ya, değişkenler işimizi nasıl da kolaylaştırıyor.
Eğer yukarıdaki programda değişken kullanmasaydık kodlarımız şöyle görünecekti:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mf">3.14159</span> <span class="o">*</span> <span class="p">((</span><span class="mi">16</span><span class="o">/</span><span class="mi">2</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="mi">16</span><span class="o">/</span><span class="mi">2</span><span class="p">))</span>
<span class="go">201.06176</span>
</pre></div>
</div>
<p>Bu kodlar tek kullanımlıktır.
Eğer yukarıdaki örnekte mesela dairenin çapını değiştirmeniz gerekirse, iki yerde elle değişiklik yapmanız gerekir.
Ama değişkenleri kullandığımızda sadece <cite>çap</cite> değişkeninin değerini değiştirmeniz yeterli olacaktır.
Ayrıca değişken kullanmadığınızda, ilgili değeri program boyunca aklınızda tutmanız gerekir.
Örneğin <cite>çap</cite> değişkenini kullanmak yerine, gereken her yerde <cite>16</cite> değerini kullanacaksanız, bu <cite>16</cite> değerini sürekli aklınızda tutmanız lazım.
Ama bu değeri en başta bir değişkene atarsanız, <cite>16</cite> değerini kullanmanız gereken yerlerde, akılda tutması daha kolay bir ifade olan <cite>çap</cite> ismini kullanabilirsiniz.</p>
<p>Bu arada yeri gelmişken sizi yeni bir işleçle daha tanıştıralım.
Şimdiye kadar Python’da toplama (<cite>+</cite>), çıkarma (<cite>-</cite>), çarpma (<cite>*</cite>), bölme (<cite>/</cite>) ve değer atama (<cite>=</cite>) işleçlerini gördük.
Ama yukarıda verdiğimiz son örnek, başka bir işleç daha öğrenmemizi gerektiriyor…</p>
<p>Yukarıdaki şu örneğe tekrar bakalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">alan</span> <span class="o">=</span> <span class="n">pi</span> <span class="o">*</span> <span class="p">(</span><span class="n">yarıçap</span> <span class="o">*</span> <span class="n">yarıçap</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada <cite>yarıçap</cite> değişkeninin karesini alabilmek için bu değeri kendisiyle çarptık.
Aslında gayet mantıklı ve makul bir yöntem.
Kare bulmak için değeri kendisiyle çarpıyoruz.
Eğer bir sayının küpünü bulmak isteseydik o sayıyı üç kez kendisiyle çarpacaktık:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mi">3</span> <span class="o">*</span> <span class="mi">3</span> <span class="o">*</span> <span class="mi">3</span>
<span class="go">27</span>
</pre></div>
</div>
<p>Peki ya bir sayının mesela beşinci kuvvetini hesaplamak istersek ne yapacağız?
O sayıyı beş kez kendisiyle mi çarpacağız?
Bu ne kadar vasat bir yöntem, değil mi?</p>
<p>Elbette bir sayının herhangi bir kuvvetini hesaplamak için o sayıyı kendisiyle kuvvetince çarpmayacağız.
Python’da bu tür ‘kuvvet hesaplamaları’ için ayrı bir işleç (ve fonksiyon) bulunur.</p>
<p>Öncelikle kuvvet hesaplarını yapmamızı sağlayan işleçten söz edelim.</p>
<p>Python’da <cite>**</cite> adlı bir işleç bulunur.
Bu işlecin görevi bir sayının kuvvetini hesaplamamızı sağlamaktır.
Örneğin bir sayının <cite>2.</cite> kuvvetini, ya da başka bir deyişle karesini hesaplamak istersek şöyle bir kod yazabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mi">12</span> <span class="o">**</span> <span class="mi">2</span>
<span class="go">144</span>
</pre></div>
</div>
<p>Burada <cite>12</cite> sayısının <cite>2.</cite> kuvvetini, yani karesini hesapladık.
Bu bilgiyi yukarıdaki formüle uygulayalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">alan</span> <span class="o">=</span> <span class="n">pi</span> <span class="o">*</span> <span class="p">(</span><span class="n">yarıçap</span> <span class="o">**</span> <span class="mi">2</span><span class="p">)</span>
</pre></div>
</div>