forked from yazbel/python
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathnesne_tabanli_programlama1.html
More file actions
1961 lines (1819 loc) · 166 KB
/
nesne_tabanli_programlama1.html
File metadata and controls
1961 lines (1819 loc) · 166 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 nesne tabanlı programlamadan söz edeceğiz." name="description" />
<meta content="python, python3, nesne, oop, sınıf, class, miras alma, inheritance, nesne yönelimli programlama, nesne tabanlı programlama, object oriented programming, self, instantiation, instance, örnek, örneklendirme, örnekleme" name="keywords" />
<title>Nesne Tabanlı Programlama (OOP) — 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="Nesne Tabanlı Programlama (Devamı)" href="nesne_tabanli_programlama2.html" />
<link rel="prev" title="Modüller" href="moduller.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="nesne_tabanli_programlama2.html" title="Nesne Tabanlı Programlama (Devamı)"
accesskey="N">sonraki</a></li>
<li class="right" >
<a href="moduller.html" title="Modüller"
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="">Nesne Tabanlı Programlama (OOP)</a></li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="body" role="main">
<div class="section" id="nesne-tabanli-programlama-oop">
<h1>Nesne Tabanlı Programlama (OOP)<a class="headerlink" href="#nesne-tabanli-programlama-oop" title="Bu başlık için kalıcı bağlantı">¶</a></h1>
<p>Bu bölümde, programlama faaliyetlerimizin önemli bir kısmını oluşturacak olan
nesne tabanlı programlama yaklaşımına bir giriş yaparak, bu yaklaşımın temel
kavramlarından biri olan sınıflara değineceğiz. Bu bölümde amacımız, sınıflar
üzerinden hem nesne tabanlı programlamayı tanımak, hem bu yaklaşıma ilişkin
temel bilgileri edinmek, hem de etrafımızda gördüğümüz nesne tabanlı yapıların
büyük çoğunluğunu anlayabilecek seviyeye gelmek olacaktır. Bu bölümü
tamamladıktan sonra, nesne tabanlı programlamayı orta düzeyde bildiğimizi iddia
edebileceğiz.</p>
<div class="section" id="giris">
<h2>Giriş<a class="headerlink" href="#giris" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Şimdiye kadar Python programlama dili ile ilgili olarak gördüğümüz konulardan
öğrendiğimiz çok önemli bir bilgi var: Aslına bakarsak, bu programlama dilinin
bütün felsefesi, ‘bir kez yazılan kodların en verimli şekilde tekrar tekrar
kullanılabilmesi,’ fikrine dayanıyor.</p>
<p>Şimdi bir geriye dönüp baktığımızda, esasında bu fikrin izlerini ta ilk
derslerimize kadar sürebiliyoruz. Mesela değişkenleri ele alalım. Değişkenleri
kullanmamızdaki temel gerekçe, bir kez yazdığımız bir kodu başka yerlerde
rahatça kullanabilmek. Örneğin, <code class="docutils literal notranslate"><span class="pre">isim</span> <span class="pre">=</span> <span class="pre">'Uzun</span> <span class="pre">İhsan</span> <span class="pre">Efendi'</span></code> gibi bir
tanımlama yaptıktan sonra, bu <cite>isim</cite> değişkeni aracılığıyla <cite>‘Uzun İhsan
Efendi’</cite> adlı karakter dizisini her defasında tekrar tekrar yazmak zorunda
kalmadan, kodlarımızın her yanında kullanabiliyoruz.</p>
<p>Aynı fikrin fonksiyonlar ve geçen bölümde incelediğimiz modüller için de geçerli
olduğunu bariz bir şekilde görebilirsiniz. Gömülü fonksiyonlar, kendi
tanımladığımız fonksiyonlar, hazır modüller, üçüncü şahıs modülleri hep belli
bir karmaşık süreci basitleştirme, bir kez tanımlanan bir prosedürün tekrar
tekrar kullanılabilmesini sağlama amacı güdüyor.</p>
<p>İşte bu fikir nesne tabanlı programlama ve dolayısıyla ‘sınıf’ (<em>class</em>) adı
verilen özel bir veri tipi için de geçerlidir. Bu bölümde, bunun neden ve nasıl
böyle olduğunu bütün ayrıntılarıyla ele almaya çalışacağız.</p>
<p>Bu arada, İngilizcede <em>Object Oriented Programming</em> olarak ifade edilen
programlama yaklaşımı, Türkçede ‘Nesne Tabanlı Programlama’, ‘Nesne Yönelimli
Programlama’ ya da ‘Nesneye Yönelik Programlama’ olarak karşılık bulur. Biz bu
karşılıklardan, adı ‘Nesne Tabanlı Programlama’ olanı tercih edeceğiz.</p>
<p>Unutmadan, nesne tabanlı programlamaya girmeden önce değinmemiz gereken bir şey
daha var. Eğer öğrendiğiniz ilk programlama dili Python ise, nesne tabanlı
programlamayı öğrenmenin (aslında öyle olmadığı halde) zor olduğunu düşünebilir,
bu konuyu biraz karmaşık bulabilirsiniz. Bu durumda da kaçınılmaz olarak kendi
kendinize şu soruyu sorarsınız: Acaba ben nesne tabanlı programlamayı öğrenmek
zorunda mıyım?</p>
<p>Bu sorunun kısa cevabı, eğer iyi bir programcı olmak istiyorsanız nesne tabanlı
programlamayı öğrenmek zorundasınız, olacaktır.</p>
<p>Uzun cevap ise şu:</p>
<p>Nesne tabanlı programlama, pek çok yazılım geliştirme yönteminden yalnızca
biridir. Siz bu yöntemi, yazdığınız programlarda kullanmak zorunda değilsiniz.
Nesne tabanlı programlamadan hiç yararlanmadan da faydalı ve iyi programlar
yazabilirsiniz elbette. Python sizi bu yöntemi kullanmaya asla zorlamaz. Ancak
nesne tabanlı programlama yaklaşımı program geliştirme alanında oldukça yaygın
kullanılan bir yöntemdir. Dolayısıyla, etrafta nesne tabanlı programlama
yaklaşımından yararlanılarak yazılmış pek çok kodla karşılaşacaksınız. Hiç
değilse karşılaştığınız bu kodları anlayabilmek için nesne tabanlı programlamayı
biliyor ve tanıyor olmanız lazım. Aksi halde, bu yöntem kullanılarak geliştirilmiş
programları anlayamazsınız.</p>
<p>Mesela, grafik bir arayüze sahip (yani düğmeli, menülü) programların ezici
çoğunluğu nesne tabanlı programlama yöntemiyle geliştiriliyor. Grafik arayüz
geliştirmenizi sağlayacak araçları tanımanızı, öğrenmenizi sağlayan kitaplar ve
makaleler de bu konuları hep nesne tabanlı programlama yaklaşımı üzerinden
anlatıyor.</p>
<div class="admonition warning">
<p class="admonition-title">Uyarı</p>
<p>Yalnız bu söylediğimizden, nesne tabanlı programlama sadece grafik
arayüzlü programlar geliştirmeye yarar gibi bir anlam çıkarmamalısınız. Nesne
tabanlı programlama, komut arayüzlü programlar geliştirmek için de kullanışlı
bir programlama yöntemidir.</p>
</div>
<p>Sözün özü, nesne tabanlı programlamadan kaçamazsınız! İyi bir programcı olmak
istiyorsanız, kendiniz hiç kullanmasanız bile, nesne tabanlı programlamayı
öğrenmek zorundasınız. Hem şimdi nesne tabanlı programlamaya dudak bükseniz
bile, bunu kullandıkça ve size sağladığı faydaları gördükçe onu siz de
seveceksiniz…</p>
</div>
<div class="section" id="siniflar">
<h2>Sınıflar<a class="headerlink" href="#siniflar" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Nesne tabanlı programlamanın temelinde, yukarıdaki giriş bölümünde de adını
andığımız ‘sınıf’ (<em>class</em>) adlı bir kavram bulunur. Bu bölümde, bu temel
kavramı hakkıyla ele almaya çalışacağız.</p>
<p>Peki tam olarak nedir bu sınıf denen şey?</p>
<p>Çok kaba ve oldukça soyut bir şekilde tanımlayacak olursak, sınıflar, nesne
üretmemizi sağlayan veri tipleridir. İşte nesne tabanlı programlama, adından da
anlaşılacağı gibi, nesneler (ve dolayısıyla sınıflar) temel alınarak
gerçekleştirilen bir programlama faaliyetidir.</p>
<p>‘Hiçbir şey anlamadım!’ dediğinizi duyar gibiyim. Çünkü yukarıdaki tanım,
‘nesne’ ne demek, ‘sınıf’ ne anlama geliyor gibi sorulara cevap vermiyor. Yani
programcılık açısından ‘nesne’ ve ‘sınıf’ kelimelerini burada ne anlamda
kullandığımızı, yukarıdaki tanıma bakarak kestiremiyoruz. Eğer siz de bu
fikirdeyseniz okumaya devam edin…</p>
</div>
<div class="section" id="siniflar-ne-ise-yarar">
<h2>Sınıflar Ne İşe Yarar?<a class="headerlink" href="#siniflar-ne-ise-yarar" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Buraya gelene kadar Python’da pek çok veri tipi olduğunu öğrendik. Mesela önceki
derslerimizde incelediğimiz listeler, demetler, karakter dizileri, sözlükler ve
hatta fonksiyonlar hep birer veri tipidir. Bu tiplerin, verileri çeşitli
şekillerde evirip çevirmemizi sağlayan birtakım araçlar olduğunu biliyoruz. İşte
sınıflar da, tıpkı yukarıda saydığımız öteki veri tipleri gibi, verileri
manipüle etmemizi sağlayan bir veri tipidir.</p>
<p>Peki bu bölümde ele alacağımız ‘sınıf’ (<em>class</em>) veri tipi ne işe yarar?</p>
<p>Dilerseniz bunu basit bir örnek üzerinde anlatmaya çalışalım.</p>
<p>Diyelim ki, kullanıcının girdiği bir kelimedeki sesli harfleri sayan bir kod
yazmak istiyorsunuz. Bu amacı gerçekleştirebilmek için yazabileceğiniz en basit
kod herhalde şu olacaktır:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">sesli_harfler</span> <span class="o">=</span> <span class="s1">'aeıioöuü'</span>
<span class="n">sayaç</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">kelime</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s1">'Bir kelime girin: '</span><span class="p">)</span>
<span class="k">for</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">kelime</span><span class="p">:</span>
<span class="k">if</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">sesli_harfler</span><span class="p">:</span>
<span class="n">sayaç</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="n">mesaj</span> <span class="o">=</span> <span class="s1">'</span><span class="si">{}</span><span class="s1"> kelimesinde </span><span class="si">{}</span><span class="s1"> sesli harf var.'</span>
<span class="nb">print</span><span class="p">(</span><span class="n">mesaj</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">kelime</span><span class="p">,</span> <span class="n">sayaç</span><span class="p">))</span>
</pre></div>
</div>
<p>Düzgün bir şekilde çalışan, gayet basit kodlardır bunlar. Ayrıca amacımızı da
kusursuz bir şekilde yerine getirir. Üstelik kodlardaki bütün öğeler tek bir
isim/etki alanı (<em>namespace</em>, <em>scope</em>) içinde bulunduğu için, bunlara erişimde
hiçbir zorluk çekmeyiz. Yani mesela <cite>sesli_harfler</cite>, <cite>sayaç</cite>, <cite>kelime</cite>, <cite>harf</cite>,
<cite>mesaj</cite> değişkenlerine kodlar içinde her yerden erişebiliriz.</p>
<div class="admonition note">
<p class="admonition-title">Not</p>
<p>Eğer isim/etki alanı ile ilgili söylediğimiz şeyi anlamadıysanız
endişe etmeyin. Birazdan vereceğimiz örnekle durumu daha net kavrayacaksınız.</p>
</div>
<p>Ancak bu kodların önemli bir dezavantajı, kodlarda benimsediğimiz yaklaşımın
genişlemeye pek müsait olmamasıdır. Daha doğrusu, yukarıdaki kodlara yeni kodlar
ekledikçe programımız karmaşık hale gelecek, kodları anlamak zorlaşacaktır.</p>
<p>Kod yapısını biraz olsun rahatlatmak için bazı önlemler alabiliriz. Mesela
kullanıcı tarafından girilen kelimedeki bir harfin sesli olup olmadığını
denetleyen kodları bir fonksiyon içine alarak, o kısmı daha belirgin hale
getirebiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">sesli_harfler</span> <span class="o">=</span> <span class="s1">'aeıioöuü'</span>
<span class="n">sayaç</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">kelime</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s1">'Bir kelime girin: '</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">seslidir</span><span class="p">(</span><span class="n">harf</span><span class="p">):</span>
<span class="k">return</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">sesli_harfler</span>
<span class="k">for</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">kelime</span><span class="p">:</span>
<span class="k">if</span> <span class="n">seslidir</span><span class="p">(</span><span class="n">harf</span><span class="p">):</span>
<span class="n">sayaç</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="n">mesaj</span> <span class="o">=</span> <span class="s1">'</span><span class="si">{}</span><span class="s1"> kelimesinde </span><span class="si">{}</span><span class="s1"> sesli harf var.'</span>
<span class="nb">print</span><span class="p">(</span><span class="n">mesaj</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">kelime</span><span class="p">,</span> <span class="n">sayaç</span><span class="p">))</span>
</pre></div>
</div>
<p>Burada, kontrol ettiğimiz harfin <cite>sesli_harfler</cite> adlı değişken içinde bulunup
bulunmamasına göre <cite>True</cite> veya <cite>False</cite> çıktısı veren, <code class="docutils literal notranslate"><span class="pre">seslidir()</span></code> adlı bir
fonksiyon tanımladık. Eğer kontrol ettiğimiz harf <cite>sesli_harfler</cite> değişkeni
içinde geçiyorsa, yani bu bir sesli harf ise, <code class="docutils literal notranslate"><span class="pre">seslidir()</span></code> fonksiyonu <cite>True</cite>
çıktısı verecektir. Aksi durumda ise bu fonksiyondan <cite>False</cite> çıktısı alacağız.
Böylece sesli harf kontrolü yapmak istediğimiz her yerde yalnızca <code class="docutils literal notranslate"><span class="pre">seslidir()</span></code>
fonksiyonunu kullanabileceğiz. Bu da bize, bir kez yazdığımız kodları tekrar
tekrar kullanma imkanı verecek.</p>
<p>Eğer yukarıdaki kodları daha da genel amaçlı bir hale getirmek istersek, sayacı
artıran kodları da bir fonksiyon içine almayı düşünebiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">sesli_harfler</span> <span class="o">=</span> <span class="s1">'aeıioöuü'</span>
<span class="n">sayaç</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">kelime</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s1">'Bir kelime girin: '</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">seslidir</span><span class="p">(</span><span class="n">harf</span><span class="p">):</span>
<span class="k">return</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">sesli_harfler</span>
<span class="k">def</span> <span class="nf">artır</span><span class="p">():</span>
<span class="k">global</span> <span class="n">sayaç</span>
<span class="k">for</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">kelime</span><span class="p">:</span>
<span class="k">if</span> <span class="n">seslidir</span><span class="p">(</span><span class="n">harf</span><span class="p">):</span>
<span class="n">sayaç</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">return</span> <span class="n">sayaç</span>
<span class="n">mesaj</span> <span class="o">=</span> <span class="s1">'</span><span class="si">{}</span><span class="s1"> kelimesinde </span><span class="si">{}</span><span class="s1"> sesli harf var.'</span>
<span class="nb">print</span><span class="p">(</span><span class="n">mesaj</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">kelime</span><span class="p">,</span> <span class="n">artır</span><span class="p">()))</span>
</pre></div>
</div>
<p>Hatırlarsanız, ilk başta yazdığımız kodların en büyük avantajının, kodlarda
geçen bütün öğelerin tek bir isim/etki alanında bulunması olduğunu söylemiştik.
Bu sayede bütün öğelere her yerden erişebiliyorduk. Yukarıdaki kodlarda ise
birden fazla isim/etki alanı var:</p>
<blockquote>
<div><ol class="arabic simple">
<li><p><cite>sesli_harfler</cite>, <cite>sayaç</cite>, <cite>kelime</cite> ve <cite>mesaj</cite> değişkenlerinin bulunduğu
global isim/etki alanı.</p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">seslidir()</span></code> fonksiyonunun lokal isim/etki alanı.</p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">artır()</span></code> fonksiyonunun lokal isim/etki alanı.</p></li>
</ol>
</div></blockquote>
<p>Bildiğiniz gibi, global isim alanında bulunan değişkenlere her yerden
<strong>ulaşabiliyoruz</strong>. Ancak bunları her yerden <strong>değiştiremiyoruz</strong>. Yani mesela
global isim alanında bulunan <cite>sayaç</cite> değişkeninin değerini, <code class="docutils literal notranslate"><span class="pre">seslidir()</span></code>
fonksiyonu içinden görüntüleyebiliriz.</p>
<p>Bunu teyit edelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">sesli_harfler</span> <span class="o">=</span> <span class="s1">'aeıioöuü'</span>
<span class="n">sayaç</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">kelime</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s1">'Bir kelime girin: '</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">seslidir</span><span class="p">(</span><span class="n">harf</span><span class="p">):</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">'sayaç değişkeninin değeri şu anda: '</span><span class="p">,</span> <span class="n">sayaç</span><span class="p">)</span>
<span class="k">return</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">sesli_harfler</span>
<span class="k">def</span> <span class="nf">artır</span><span class="p">():</span>
<span class="k">global</span> <span class="n">sayaç</span>
<span class="k">for</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">kelime</span><span class="p">:</span>
<span class="k">if</span> <span class="n">seslidir</span><span class="p">(</span><span class="n">harf</span><span class="p">):</span>
<span class="n">sayaç</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">return</span> <span class="n">sayaç</span>
<span class="n">mesaj</span> <span class="o">=</span> <span class="s1">'</span><span class="si">{}</span><span class="s1"> kelimesinde </span><span class="si">{}</span><span class="s1"> sesli harf var.'</span>
<span class="nb">print</span><span class="p">(</span><span class="n">mesaj</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">kelime</span><span class="p">,</span> <span class="n">artır</span><span class="p">()))</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, global isim alanındaki <cite>sayaç</cite> değişkeninin değerini
<code class="docutils literal notranslate"><span class="pre">seslidir()</span></code> fonksiyonu içinde kullanabildik. Ama eğer bu değişken üzerinde
değişiklik yapacaksak ilave adımlar atmak zorundayız. Dolayısıyla, mesela
<code class="docutils literal notranslate"><span class="pre">artır()</span></code> fonksiyonunun etki alanından, global etki alanındaki <cite>sayaç</cite>
değişkeni üzerinde değişiklik yapabilmek için <code class="docutils literal notranslate"><span class="pre">global</span></code> deyimini kullanmamız
gerekiyor. Bu şekilde, global isim alanında bulunan <cite>sayaç</cite> adlı değişkenin
değerini artırabiliyoruz.</p>
<p>Dikkat ederseniz, <code class="docutils literal notranslate"><span class="pre">artır()</span></code> fonksiyonunda iki tane global değişken var:
<cite>sayaç</cite> ve <cite>kelime</cite>. Ama biz bunlardan yalnızca <cite>sayaç</cite> değişkenini global
olarak belirledik. Öbür global değişkenimiz <cite>kelime</cite> için ise bu işlemi
yapmadık. Çünkü <cite>kelime</cite> adlı değişkeni değiştirmek gibi bir niyetimiz yok. Biz
bu değişkeni sadece kullanmakla yetiniyoruz. O yüzden bu değişkeni global olarak
belirlemek zorunda değiliz.</p>
<p>Ancak bildiğiniz gibi, <code class="docutils literal notranslate"><span class="pre">global</span></code> deyimini kullanmak pek tavsiye edilen bir şey
değil. Eğer siz de bu deyimi kullanmak istemezseniz, yukarıdaki kodları şu
şekilde yazmayı yeğleyebilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">sesli_harfler</span> <span class="o">=</span> <span class="s1">'aeıioöuü'</span>
<span class="n">sayaç</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">kelime</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s1">'Bir kelime girin: '</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">seslidir</span><span class="p">(</span><span class="n">harf</span><span class="p">):</span>
<span class="k">return</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">sesli_harfler</span>
<span class="k">def</span> <span class="nf">artır</span><span class="p">(</span><span class="n">sayaç</span><span class="p">):</span>
<span class="k">for</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">kelime</span><span class="p">:</span>
<span class="k">if</span> <span class="n">seslidir</span><span class="p">(</span><span class="n">harf</span><span class="p">):</span>
<span class="n">sayaç</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">return</span> <span class="n">sayaç</span>
<span class="n">mesaj</span> <span class="o">=</span> <span class="s1">'</span><span class="si">{}</span><span class="s1"> kelimesinde </span><span class="si">{}</span><span class="s1"> sesli harf var.'</span>
<span class="nb">print</span><span class="p">(</span><span class="n">mesaj</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">kelime</span><span class="p">,</span> <span class="n">artır</span><span class="p">(</span><span class="n">sayaç</span><span class="p">)))</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, bu kodlarda <code class="docutils literal notranslate"><span class="pre">global</span></code> deyimini kullanmak yerine, <code class="docutils literal notranslate"><span class="pre">artır()</span></code>
fonksiyonuna verdiğimiz <cite>sayaç</cite> parametresi üzerinden global isim alanıyla
iletişim kurarak, <cite>sayaç</cite> değişkenini manipüle edebildik. Sadece değerini
kullandığımız global değişken <cite>kelime</cite> için ise özel bir şey yapmamıza gerek
kalmadı.</p>
<p>Bu arada, tabii ki, <code class="docutils literal notranslate"><span class="pre">artır()</span></code> fonksiyonunda parametre olarak kullandığımız
kelime <cite>sayaç</cite> olmak zorunda değil. Kodlarımızı mesela şöyle de yazabilirdik:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">sesli_harfler</span> <span class="o">=</span> <span class="s1">'aeıioöuü'</span>
<span class="n">sayaç</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">kelime</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s1">'Bir kelime girin: '</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">seslidir</span><span class="p">(</span><span class="n">harf</span><span class="p">):</span>
<span class="k">return</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">sesli_harfler</span>
<span class="k">def</span> <span class="nf">artır</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
<span class="k">for</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">kelime</span><span class="p">:</span>
<span class="k">if</span> <span class="n">seslidir</span><span class="p">(</span><span class="n">harf</span><span class="p">):</span>
<span class="n">n</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">return</span> <span class="n">n</span>
<span class="n">mesaj</span> <span class="o">=</span> <span class="s1">'</span><span class="si">{}</span><span class="s1"> kelimesinde </span><span class="si">{}</span><span class="s1"> sesli harf var.'</span>
<span class="nb">print</span><span class="p">(</span><span class="n">mesaj</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">kelime</span><span class="p">,</span> <span class="n">artır</span><span class="p">(</span><span class="n">sayaç</span><span class="p">)))</span>
</pre></div>
</div>
<p>Önemli olan, <code class="docutils literal notranslate"><span class="pre">artır()</span></code> fonksiyonunun, bizim global isim alanıyla iletişim
kurmamızı sağlayacak bir parametre alması. Bu parametrenin adının ne olduğunun
bir önemi yok.</p>
<p>Yukarıdaki kodlarda birkaç değişiklik daha yaparak, bu kodları iyice
genişletilebilir hale getirebiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">sesli_harfler</span> <span class="o">=</span> <span class="s1">'aeıioöuü'</span>
<span class="n">sayaç</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">def</span> <span class="nf">kelime_sor</span><span class="p">():</span>
<span class="k">return</span> <span class="nb">input</span><span class="p">(</span><span class="s1">'Bir kelime girin: '</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">seslidir</span><span class="p">(</span><span class="n">harf</span><span class="p">):</span>
<span class="k">return</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">sesli_harfler</span>
<span class="k">def</span> <span class="nf">artır</span><span class="p">(</span><span class="n">sayaç</span><span class="p">,</span> <span class="n">kelime</span><span class="p">):</span>
<span class="k">for</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">kelime</span><span class="p">:</span>
<span class="k">if</span> <span class="n">seslidir</span><span class="p">(</span><span class="n">harf</span><span class="p">):</span>
<span class="n">sayaç</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">return</span> <span class="n">sayaç</span>
<span class="k">def</span> <span class="nf">ekrana_bas</span><span class="p">(</span><span class="n">kelime</span><span class="p">):</span>
<span class="n">mesaj</span> <span class="o">=</span> <span class="s2">"</span><span class="si">{}</span><span class="s2"> kelimesinde </span><span class="si">{}</span><span class="s2"> sesli harf var."</span>
<span class="nb">print</span><span class="p">(</span><span class="n">mesaj</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">kelime</span><span class="p">,</span> <span class="n">artır</span><span class="p">(</span><span class="n">sayaç</span><span class="p">,</span> <span class="n">kelime</span><span class="p">)))</span>
<span class="k">def</span> <span class="nf">çalıştır</span><span class="p">():</span>
<span class="n">kelime</span> <span class="o">=</span> <span class="n">kelime_sor</span><span class="p">()</span>
<span class="n">ekrana_bas</span><span class="p">(</span><span class="n">kelime</span><span class="p">)</span>
<span class="n">çalıştır</span><span class="p">()</span>
</pre></div>
</div>
<p>Bu kodlarda, fonksiyonlara verdiğimiz parametreler yardımıyla, farklı
fonksiyonların lokal etki alanlarında yer alan öğeler arasında nasıl iletişim
kurduğumuza dikkat edin. Bir önceki kodlarda global etki alanında bulunan
<cite>kelime</cite> değişkenini bu kez <code class="docutils literal notranslate"><span class="pre">çalıştır()</span></code> fonksiyonunun lokal etki alanı içine
yerleştirdiğimiz için, <code class="docutils literal notranslate"><span class="pre">artır()</span></code> fonksiyonu içindeki <cite>kelime</cite> değişkeni boşa
düştü. O yüzden, bu değişkeni <code class="docutils literal notranslate"><span class="pre">artır()</span></code> fonksiyonuna bir parametre olarak
verdik ve <code class="docutils literal notranslate"><span class="pre">ekrana_bas()</span></code> fonksiyonu içinde bu fonksiyonu çağırırken, hem
<cite>sayaç</cite> hem de <cite>kelime</cite> argümanlarını kullandık.</p>
<p>Ayrıca, kullanıcıya kelime sorup, aldığı kelimeyi ekrana basan kod parçalarını,
yani programımızı başlatan kodları <code class="docutils literal notranslate"><span class="pre">çalıştır()</span></code> başlığı altında toplayarak bu
kısmı tam anlamıyla ‘modüler’, yani esnek ve takılıp çıkarılabilir bir hale
getirdik.</p>
<p>Gördüğünüz gibi, yazdığımız kodların olabildiğince anlaşılır ve yönetilebilir
olmasını sağlayabilmek için, bu kodları küçük birtakım birimlere böldük. Bu
şekilde hem hangi işlevin nerede olduğunu bulmak kolaylaştı, hem kodların
görünüşü daha anlaşılır oldu, hem de bu kodlara ileride yeni özellikler eklemek
basitleşti. Unutmayın, bir programcının görevi yalnızca çalışan kodlar yazmak
değildir. Programcı aynı zamanda kodlarının okunaklılığını artırmak ve bakımını
kolaylaştırmakla da yükümlüdür.</p>
<p>Bu bakımdan, programcı ile kod arasındaki ilişkiyi, yazar ile kitap arasındaki
ilişkiye benzetebilirsiniz. Tıpkı bir programcı gibi, yazarın da görevi aklına
gelenleri bir kağıda gelişigüzel boca etmek değildir. Yazar, yazdığı kitabın
daha anlaşılır olmasını sağlamak için kitabına bir başlık atmalı, yazdığı
yazıları alt başlıklara ve paragraflara bölmeli, ayrıca noktalama işaretlerini
yerli yerinde kullanarak yazılarını olabildiğince okunaklı hale getirmelidir.
Bir ana başlığı ve alt başlıkları olmayan, sadece tek bir büyük paragraftan
oluşan, içinde hiçbir noktalama işaretinin kullanılmadığı bir makaleyi okumanın
veya bu makaleye sonradan yeni bir şeyler eklemenin ne kadar zor olduğunu
düşünün. İşte aynı şey bir programcının yazdığı kodlar için de geçerlidir. Eğer
yazdığınız kodları anlaşılır birimlere bölmeden ekrana yığarsanız bu kodları ne
başkaları okuyup anlayabilir, ne de siz ileride bu kodlara yeni işlevler
ekleyebilirsiniz.</p>
<p>Python programlama dili, kodlarınızı olabildiğince anlaşılır, okunaklı ve
yönetilebilir hale getirmeniz için size pek çok araç sunar. Önceki derslerde
gördüğümüz değişkenler, fonksiyonlar ve modüller bu araçlardan yalnızca
birkaçıdır. İşte bu bölümde inceleyeceğimiz sınıflar da kodlarımızı
ehlileştirmek için kullanacağımız son derece faydalı araçlardır.</p>
<p>Birazdan, ‘sınıf’ denen bu faydalı araçları enine boyuna inceleyeceğiz. Ama
gelin isterseniz, anlatmaya devam etmeden önce, verdiğimiz son kodları biraz
daha kurcalayalım.</p>
<p>Hatırlarsanız, geçen bölümde, yazdığımız Python kodlarının aynı zamanda hem
bağımsız bir program olarak hem de bir modül olarak kullanılabileceğini
söylemiştik.</p>
<p>Mesela, yukarıdaki kodları <cite>sayac.py</cite> adlı bir dosyaya kaydettiğimizi
varsayarsak, bu programı komut satırı üzerinden <code class="docutils literal notranslate"><span class="pre">python</span> <span class="pre">sayac.py</span></code> gibi bir
kodla çalıştırabiliyoruz. Biz bu programı bu şekilde komut satırı üzerinden veya
üzerine çift tıklayarak çalıştırdığımızda, bu kodları bağımsız bir program
olarak çalıştırmış oluyoruz. Gelin bir de bu kodları bir modül olarak nasıl içe
aktaracağımızı inceleyelim.</p>
<p>Şimdi, <cite>sayac.py</cite> programının bulunduğu dizin altında Python komut satırını
başlatalım ve orada şu komutu vererek <cite>sayac</cite> modülünü içe aktaralım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">import</span> <span class="nn">sayac</span>
</pre></div>
</div>
<p>Bu komutu verdiğimiz anda, <cite>sayac.py</cite> programı çalışmaya başlayacaktır. Ancak
bizim istediğimiz şey bu değil. Biz <cite>sayac.py</cite> programının çalışmaya başlamasını
istemiyoruz. Bizim istediğimiz şey, bu <cite>sayac.py</cite> dosyasını bağımsız bir program
olarak değil, bir modül olarak kullanmak ve böylece bu modül içindeki nitelik ve
fonksiyonlara erişmek. Tam bu noktada şöyle bir soru aklımıza geliyor: Acaba bir
insan neden bir programı modül olarak içe aktarmak istiyor olabilir?</p>
<p>Bir Python dosyasına modül olarak erişmek istemenizin birkaç sebebi olabilir.
Mesela bir program yazıyorsunuzdur ve amacınız yazdığınız kodların düzgün
çalışıp çalışmadığını test etmektir. Bunun için, programınızı etkileşimli kabuk
ortamına bir modül olarak aktarıp, bu modülün test etmek istediğiniz kısımlarını
tek tek çalıştırabilirsiniz. Aynı şekilde, kendi yazdığınız veya başkası
tarafından yazılmış bir program içindeki işlevsellikten başka bir program içinde
de yararlanmak istiyor olabilirsiniz. İşte bunun için de, ilgili programı, başka
bir program içinden çağırarak, yani o programı öteki program içine bir modül
olarak aktararak, ilgili modül içindeki işlevleri kullanabilirsiniz.</p>
<p>Diyelim ki biz, yukarıda yazdığımız <cite>sayac.py</cite> adlı dosya içindeki kodların
düzgün çalışıp çalışmadığını kontrol etmek istiyoruz. Bunun için <cite>sayac.py</cite>
dosyasındaki kodlarda şu değişikliği yapalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">sesli_harfler</span> <span class="o">=</span> <span class="s1">'aeıioöuü'</span>
<span class="n">sayaç</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">def</span> <span class="nf">kelime_sor</span><span class="p">():</span>
<span class="k">return</span> <span class="nb">input</span><span class="p">(</span><span class="s1">'Bir kelime girin: '</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">seslidir</span><span class="p">(</span><span class="n">harf</span><span class="p">):</span>
<span class="k">return</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">sesli_harfler</span>
<span class="k">def</span> <span class="nf">artır</span><span class="p">(</span><span class="n">sayaç</span><span class="p">,</span> <span class="n">kelime</span><span class="p">):</span>
<span class="k">for</span> <span class="n">harf</span> <span class="ow">in</span> <span class="n">kelime</span><span class="p">:</span>
<span class="k">if</span> <span class="n">seslidir</span><span class="p">(</span><span class="n">harf</span><span class="p">):</span>
<span class="n">sayaç</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">return</span> <span class="n">sayaç</span>
<span class="k">def</span> <span class="nf">ekrana_bas</span><span class="p">(</span><span class="n">kelime</span><span class="p">):</span>
<span class="n">mesaj</span> <span class="o">=</span> <span class="s2">"</span><span class="si">{}</span><span class="s2"> kelimesinde </span><span class="si">{}</span><span class="s2"> sesli harf var."</span>
<span class="nb">print</span><span class="p">(</span><span class="n">mesaj</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">kelime</span><span class="p">,</span> <span class="n">artır</span><span class="p">(</span><span class="n">sayaç</span><span class="p">,</span> <span class="n">kelime</span><span class="p">)))</span>
<span class="k">def</span> <span class="nf">çalıştır</span><span class="p">():</span>
<span class="n">kelime</span> <span class="o">=</span> <span class="n">kelime_sor</span><span class="p">()</span>
<span class="n">ekrana_bas</span><span class="p">(</span><span class="n">kelime</span><span class="p">)</span>
<span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s1">'__main__'</span><span class="p">:</span>
<span class="n">çalıştır</span><span class="p">()</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, burada <code class="docutils literal notranslate"><span class="pre">çalıştır()</span></code> fonksiyonunu <code class="docutils literal notranslate"><span class="pre">if</span> <span class="pre">__name__</span> <span class="pre">==</span>
<span class="pre">'__main__'</span></code> bloğuna aldık. Buna göre, eğer <cite>__name__</cite> niteliğinin değeri
<cite>‘__main__’</cite> ise <code class="docutils literal notranslate"><span class="pre">çalıştır()</span></code> fonksiyonu işlemeye başlayacak. Aksi halde
herhangi bir şey olmayacak.</p>
<p>Şimdi <cite>sayac.py</cite> programını komut satırı üzerinden <code class="docutils literal notranslate"><span class="pre">python</span> <span class="pre">sayac.py</span></code> gibi bir
komutla çalıştırın. Programınız normal bir şekilde çalışacaktır. Çünkü,
bildiğiniz gibi, bir Python programı bağımsız bir program olarak
çalıştırıldığında <cite>__name__</cite> niteliğinin değeri <cite>‘__main__’</cite> olur.
Dolayısıyla da <code class="docutils literal notranslate"><span class="pre">çalıştır()</span></code> fonksiyonu işlemeye başlar.</p>
<p>Şimdi de etkileşimli kabuğu tekrar açın ve şu komutu vererek modülü içe
aktarın:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">import</span> <span class="nn">sayac</span>
</pre></div>
</div>
<p>Bu defa programımız çalışmaya başlamadı. Çünkü bu kez, programımızı bir modül
olarak içe aktardığımız için, <cite>__name__</cite> niteliğinin değeri <cite>‘__main__’</cite> değil,
ilgili modülün adı oldu (yani bizim örneğimizde <cite>sayac</cite>).</p>
<p>Böylece <cite>__name__</cite> niteliğinin farklı durumlarda farklı bir değere sahip
olmasından yararlanarak, programınızın farklı durumlarda farklı tepkiler
vermesini sağlamış olduk.</p>
<p><cite>sayac</cite> modülünü içe aktardıktan sonra, bu modülün içinde neler olduğunu nasıl
kontrol edebileceğinizi biliyorsunuz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">dir</span><span class="p">(</span><span class="n">sayac</span><span class="p">)</span>
<span class="go">['__builtins__', '__cached__', '__doc__', '__file__', '__loader__',</span>
<span class="go"> '__name__', '__package__', '__spec__', 'artır', 'ekrana_bas',</span>
<span class="go"> 'kelime_sor', 'sayaç', 'sesli_harfler', 'seslidir', 'çalıştır']</span>
</pre></div>
</div>
<p>Bu listede, <cite>sayac</cite> modülüne ait bütün nitelik ve fonksiyonları görebiliyoruz.
Bunları, başka modüllerde olduğu gibi kullanma imkanına sahibiz.</p>
<p>Mesela bu listede görünen <code class="docutils literal notranslate"><span class="pre">seslidir()</span></code> fonksiyonunu kullanalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">sayac</span><span class="o">.</span><span class="n">seslidir</span><span class="p">(</span><span class="s1">'ö'</span><span class="p">)</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="n">sayac</span><span class="o">.</span><span class="n">seslidir</span><span class="p">(</span><span class="s1">'ç'</span><span class="p">)</span>
<span class="go">False</span>
</pre></div>
</div>
<p>Gördüğünüz gibi, <cite>sayac.py</cite> içinde tanımladığımız <code class="docutils literal notranslate"><span class="pre">seslidir()</span></code> fonksiyonunu,
rastgele harflerin birer sesli harf olup olmadığını denetlemek için de
kullanabiliyoruz. Bu şekilde aynı zamanda <code class="docutils literal notranslate"><span class="pre">seslidir()</span></code> fonksiyonunun düzgün
bir şekilde çalışıp çalışmadığını, sesli olan ve olmayan harfleri başarılı bir
şekilde birbirinden ayırt edip edemediğini de test etmiş oluyoruz.</p>
<p>Devam edelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">sayac</span><span class="o">.</span><span class="n">sesli_harfler</span>
<span class="go">'aeıioöuü'</span>
</pre></div>
</div>
<p>Modüllerin ne kadar faydalı araçlar olabileceğini bu örnek gayet net bir şekilde
gösteriyor. Eğer ileride sesli harfleri kullanmamızı gerektiren başka bir
program yazacak olursak, bu harfleri yeniden tanımlamak yerine, <cite>sayac.py</cite>
dosyasından içe aktarabiliriz.</p>
<p>Bütün bu örnekler sayesinde, sınıfları daha iyi anlamamızı sağlayacak altyapıyı
oluşturmuş, bir yandan da eski bilgilerimizi pekiştirmiş olduk. Dilerseniz,
sınıfları anlatmaya geçmeden önce, yukarıda verdiğimiz kodları sınıflı bir yapı
içinde nasıl ifade edebileceğimizi de görelim.</p>
<p>Elbette aşağıdaki kodları anlamanızı şu aşamada sizden beklemiyoruz. Bu bölümün
sonuna vardığımızda, zihninizde her şey berraklaşmış olacak. Siz şimdilik sadece
aşağıdaki kodlara bakın ve hem okunaklılık hem de yönetilebilirlik bakımından bu
kodların bize ne gibi faydalar sağlıyor olabileceğine dair fikir yürütmeye
çalışın. Anlamadığınız kısımlar olursa bunları geçin gitsin. Anladığınız
kısımlar ise yanınıza kâr kalsın.</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">HarfSayacı</span><span class="p">:</span>
<span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">sesli_harfler</span> <span class="o">=</span> <span class="s1">'aeıioöuü'</span>
<span class="bp">self</span><span class="o">.</span><span class="n">sayaç</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">def</span> <span class="nf">kelime_sor</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="nb">input</span><span class="p">(</span><span class="s1">'Bir kelime girin: '</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">seslidir</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">harf</span><span class="p">):</span>
<span class="k">return</span> <span class="n">harf</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">sesli_harfler</span>
<span class="k">def</span> <span class="nf">artır</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">for</span> <span class="n">harf</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">kelime</span><span class="p">:</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">seslidir</span><span class="p">(</span><span class="n">harf</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">sayaç</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">sayaç</span>
<span class="k">def</span> <span class="nf">ekrana_bas</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="n">mesaj</span> <span class="o">=</span> <span class="s2">"</span><span class="si">{}</span><span class="s2"> kelimesinde </span><span class="si">{}</span><span class="s2"> sesli harf var."</span>
<span class="n">sesli_harf_sayısı</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">artır</span><span class="p">()</span>
<span class="nb">print</span><span class="p">(</span><span class="n">mesaj</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">kelime</span><span class="p">,</span> <span class="n">sesli_harf_sayısı</span><span class="p">))</span>
<span class="k">def</span> <span class="nf">çalıştır</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">kelime</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">kelime_sor</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">ekrana_bas</span><span class="p">()</span>
<span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s1">'__main__'</span><span class="p">:</span>
<span class="n">sayaç</span> <span class="o">=</span> <span class="n">HarfSayacı</span><span class="p">()</span>
<span class="n">sayaç</span><span class="o">.</span><span class="n">çalıştır</span><span class="p">()</span>
</pre></div>
</div>
<p>Hakkında herhangi bir fikre sahip olmadığınız bir kod parçasını anlamanın en iyi
yolu, anlamadığınız kısmı kodlardan çıkarıp, kodları bir de o şekilde
çalıştırmaktır. Mesela yukarıdaki <cite>__init__</cite>, <cite>self</cite> ve <cite>class</cite> gibi öğelerin
ismini değiştirin, bunları kodlardan çıkarın veya başka bir yere koyun. Elde
ettiğiniz sonuçları gözlemleyerek bu kodlar hakkında en azından bir fikir sahibi
olabilirsiniz.</p>
<p>Gelin isterseniz, henüz yukarıdaki kodları anlayabilecek kadar sınıf bilgisine
sahip olmasak da, bu kodları şöyle bir üstünkörü gözden geçirerek, bu kodların
programcılık deneyimimiz açısından bize ne gibi bir katkı sunuyor olabileceğini
anlamaya çalışalım.</p>
<p>Yukarıdaki kodlarda dikkatimizi çeken ilk şey, bu kodların son derece derli
toplu görünüyor olmasıdır. Öyle ki, <cite>HarfSayacı</cite> adlı sınıf içindeki
fonksiyonlar sanki ipe dizilir gibi dizilmiş.</p>
<p><cite>HarfSayacı</cite> adlı sınıf ile bu sınıf yapısı içinde yer alan fonksiyonlar
arasındaki ilişki gayet net bir şekilde görünüyor. Eğer ileride bu sayaca yeni
bir işlev eklemek istersek, neyi nereye yerleştirmemiz gerektiği çok açık.
Mesela ilerde bu kodlara sesli harflerle birlikte bir de sessiz harf denetim
işlevi eklemek istersek, gerekli değişiklikleri kolayca yapabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">HarfSayacı</span><span class="p">:</span>
<span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">sesli_harfler</span> <span class="o">=</span> <span class="s1">'aeıioöuü'</span>
<span class="bp">self</span><span class="o">.</span><span class="n">sessiz_harfler</span> <span class="o">=</span> <span class="s1">'bcçdfgğhjklmnprsştvyz'</span>
<span class="bp">self</span><span class="o">.</span><span class="n">sayaç_sesli</span> <span class="o">=</span> <span class="mi">0</span>
<span class="bp">self</span><span class="o">.</span><span class="n">sayaç_sessiz</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">def</span> <span class="nf">kelime_sor</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="nb">input</span><span class="p">(</span><span class="s1">'Bir kelime girin: '</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">seslidir</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">harf</span><span class="p">):</span>
<span class="k">return</span> <span class="n">harf</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">sesli_harfler</span>
<span class="k">def</span> <span class="nf">sessizdir</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">harf</span><span class="p">):</span>
<span class="k">return</span> <span class="n">harf</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">sessiz_harfler</span>
<span class="k">def</span> <span class="nf">artır</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">for</span> <span class="n">harf</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">kelime</span><span class="p">:</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">seslidir</span><span class="p">(</span><span class="n">harf</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">sayaç_sesli</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">sessizdir</span><span class="p">(</span><span class="n">harf</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">sayaç_sessiz</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">return</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">sayaç_sesli</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">sayaç_sessiz</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">ekrana_bas</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="n">sesli</span><span class="p">,</span> <span class="n">sessiz</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">artır</span><span class="p">()</span>
<span class="n">mesaj</span> <span class="o">=</span> <span class="s2">"</span><span class="si">{}</span><span class="s2"> kelimesinde </span><span class="si">{}</span><span class="s2"> sesli </span><span class="si">{}</span><span class="s2"> sessiz harf var."</span>
<span class="nb">print</span><span class="p">(</span><span class="n">mesaj</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">kelime</span><span class="p">,</span> <span class="n">sesli</span><span class="p">,</span> <span class="n">sessiz</span><span class="p">))</span>
<span class="k">def</span> <span class="nf">çalıştır</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">kelime</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">kelime_sor</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">ekrana_bas</span><span class="p">()</span>
<span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s1">'__main__'</span><span class="p">:</span>
<span class="n">sayaç</span> <span class="o">=</span> <span class="n">HarfSayacı</span><span class="p">()</span>
<span class="n">sayaç</span><span class="o">.</span><span class="n">çalıştır</span><span class="p">()</span>
</pre></div>
</div>
<p>Ayrıca sınıflı kodlarda, farklı etki alanları ile iletişim kurmak, sınıfsız
kodlara kıyasla daha zahmetsizdir. Sınıflı ve sınıfsız kodlarda fonksiyonlara
verdiğimiz parametreleri birbirleri ile kıyaslayarak bu durumu kendiniz de
görebilirsiniz.</p>
<p>Sınıflı yapıların daha pek çok avantajlı yönü vardır. İşte biz bu bölümde
bunları size tek tek göstermeye çalışacağız.</p>
</div>
<div class="section" id="sinif-tanimlamak">
<h2>Sınıf Tanımlamak<a class="headerlink" href="#sinif-tanimlamak" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Nesne tabanlı programlama yaklaşımı, özellikle birtakım ortak niteliklere ve
davranış şekillerine sahip gruplar tanımlamak gerektiğinde son derece
kullanışlıdır. Mesela şöyle bir örnek düşünün: Diyelim ki çalıştığınız
işyerinde, işe alınan kişilerin kayıtlarını tutan bir veritabanınız var. Bir
kişi işe alındığında, o kişiye dair belli birtakım bilgileri bu veritabanına
işliyorsunuz. Mesela işe alınan kişinin adı, soyadı, unvanı, maaşı ve buna
benzer başka bilgiler…</p>
<p>Çalışmaya başlayacak kişileri temsil eden bir ‘Çalışan’ grubunu, bu grubun
nitelikleri ile faaliyetlerini tutacak yapıyı ve bu grubun bütün öğelerinin
taşıyacağı özellikleri nesne tabanlı programlama yaklaşımı ile kolayca
kodlayabilirsiniz.</p>
<p>Aynı şekilde, mesela yazdığınız bir oyun programı için, bir ‘Asker’ grubunu
nesne tabanlı programlama mantığı içinde tanımlayarak, bu grubun her bir
üyesinin sahip olacağı nitelikleri, kabiliyetleri ve davranış şekillerini
kodlayabilir; mesela askerlerin sağa sola nasıl hareket edeceklerini, hangi
durumlarda puan/enerji/güç kazanacaklarını veya kaybedeceklerini, bir asker ilk
kez oluşturulduğunda hangi özellikleri taşıyacağını ve aklınıza gelebilecek
başka her türlü özelliği tek tek belirleyebilirsiniz.</p>
<p>Amacınız ne olursa olsun, atmanız gereken ilk adım, ilgili sınıfı tanımlamak
olmalıdır. Zira fonksiyonlarda olduğu gibi, bir sınıfı kullanabilmek için de
öncelikle o sınıfı tanımlamamız gerekiyor. Mesela, yukarıda bahsettiğimiz işe
uygun olarak, <cite>Çalışan</cite> adlı bir sınıf tanımlayalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Çalışan</span><span class="p">:</span>
<span class="k">pass</span>
</pre></div>
</div>
<p>Yukarıdaki, boş bir sınıf tanımıdır. Hatırlarsanız fonksiyonları tanımlamak için
<cite>def</cite> adlı bir ifadeden yararlanıyorduk. İşte sınıfları tanımlamak için de
<cite>class</cite> adlı bir ifadeden yararlanıyoruz. Bu ifadenin ardından gelen
<cite>Çalışan</cite> kelimesi ise bu sınıfın adıdır.</p>
<p>Eğer arzu ederseniz, yukarıdaki sınıfı şu şekilde de tanımlayabilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Çalışan</span><span class="p">():</span>
<span class="k">pass</span>
</pre></div>
</div>
<p>Yani sınıf adından sonra parantez kullanmayabileceğiniz gibi, kullanabilirsiniz
de. Her ikisi de aynı kapıya çıkar. Ayrıca sınıf adlarında, yukarıda olduğu gibi
büyük harf kullanmak ve birden fazla kelimeden oluşan sınıf adlarının ilk
harflerini büyük yazıp bunları birleştirmek adettendir. Yani:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">ÇalışanSınıfı</span><span class="p">():</span>
<span class="k">pass</span>
</pre></div>
</div>
<p>Veya parantezsiz olarak:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">ÇalışanSınıfı</span><span class="p">:</span>
<span class="k">pass</span>
</pre></div>
</div>
<p>Gördüğünüz gibi sınıf tanımlamak fonksiyon tanımlamaya çok benziyor.
Fonksiyonları tanımlarken nasıl <cite>def</cite> deyimini kullanıyorsak, sınıfları
tanımlamak için de <cite>class</cite> deyimini kullanıyoruz.</p>
<p>Örnek olması açısından, yukarıda bahsettiğimiz ‘Asker’ grubu için de bir sınıf
tanımlayalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Asker</span><span class="p">:</span>
<span class="k">pass</span>
</pre></div>
</div>
<p>… veya:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Asker</span><span class="p">():</span>
<span class="k">pass</span>
</pre></div>
</div>
<p>Python’da sınıfları nasıl tanımlayacağımızı öğrendiğimize göre, bu sınıfları
nasıl kullanacağımızı incelemeye geçebiliriz.</p>
</div>
<div class="section" id="sinif-nitelikleri">
<h2>Sınıf Nitelikleri<a class="headerlink" href="#sinif-nitelikleri" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Yukarıda, boş bir sınıfı nasıl tanımlayacağımızı öğrendik. Elbette
tanımladığımız sınıflar hep boş kalmayacak. Bu sınıflara birtakım nitelikler
ekleyerek bu sınıfları kullanışlı hale getirebiliriz. Mesela:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Çalışan</span><span class="p">():</span>
<span class="n">kabiliyetleri</span> <span class="o">=</span> <span class="p">[]</span>
<span class="n">unvanı</span> <span class="o">=</span> <span class="s1">'işçi'</span>
</pre></div>
</div>
<p>Burada <cite>unvanı</cite> ve <cite>kabiliyetleri</cite> adlı iki değişken tanımladık. Teknik
dilde bu değişkenlere ‘sınıf niteliği’ (<em>class attribute</em>) adı verilir.</p>
<p>Biraz önce, sınıf tanımlamayı öğrenirken sınıf tanımlamanın fonksiyon
tanımlamaya çok benzediğini söylemiştik. Gerçekten de öyledir. Ancak
fonksiyonlarla sınıflar arasında (başka farkların dışında) çok önemli bir fark
bulunur. Bildiğiniz gibi, bir fonksiyonu tanımladıktan sonra, o fonksiyonun
işlemeye başlaması için, o fonksiyonun mutlaka çağrılması gerekir. Çağrılmayan
fonksiyonlar çalışmaz. Mesela yukarıdaki sınıfa benzeyen şöyle bir fonksiyon
tanımladığımızı düşünün:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">çalışan</span><span class="p">():</span>
<span class="n">kabiliyetleri</span> <span class="o">=</span> <span class="p">[]</span>
<span class="n">unvanı</span> <span class="o">=</span> <span class="s1">'işçi'</span>
<span class="nb">print</span><span class="p">(</span><span class="n">kabiliyetleri</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">unvanı</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu fonksiyonun çalışması için, kodlarımızın herhangi bir yerinde bu fonksiyonu
çağırmamız lazım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">çalışan</span><span class="p">()</span>
</pre></div>
</div>
<p>Ancak sınıflar farklıdır. Bunu görmek için yukarıdaki fonksiyonu bir sınıf
haline getirelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Çalışan</span><span class="p">():</span>
<span class="n">kabiliyetleri</span> <span class="o">=</span> <span class="p">[]</span>
<span class="n">unvanı</span> <span class="o">=</span> <span class="s1">'işçi'</span>
<span class="nb">print</span><span class="p">(</span><span class="n">kabiliyetleri</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">unvanı</span><span class="p">)</span>
</pre></div>
</div>
<p>Bu kodları mesela <cite>deneme.py</cite> adlı bir dosyaya kaydedip çalıştırdığınızda,
<cite>unvanı</cite> ve <cite>kabiliyetleri</cite> değişkenlerinin değerinin ekrana
basıldığını göreceksiniz.</p>
<p>Aynı şey, yukarıdaki kodların bir modül olarak içe aktarıldığı durumlarda da
geçerlidir. Yani yukarıdaki kodların <cite>deneme.py</cite> adlı bir dosyada bulunduğunu
varsayarsak, bu modülü şu komutla içe aktardığımızda, sınıfı kodlarımızın
herhangi bir yerinde çağırmamış olmamıza rağmen sınıf içeriği çalışmaya
başlayacaktır:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">import</span> <span class="nn">deneme</span>
<span class="go">[]</span>
<span class="go">işçi</span>
</pre></div>
</div>
<p>Eğer sınıf niteliklerinin ne zaman çalışacağını kendiniz kontrol etmek
isterseniz, bu nitelikleri sınıf dışında kullanabilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Çalışan</span><span class="p">():</span>
<span class="n">kabiliyetleri</span> <span class="o">=</span> <span class="p">[]</span>
<span class="n">unvanı</span> <span class="o">=</span> <span class="s1">'işçi'</span>
<span class="nb">print</span><span class="p">(</span><span class="n">Çalışan</span><span class="o">.</span><span class="n">kabiliyetleri</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">Çalışan</span><span class="o">.</span><span class="n">unvanı</span><span class="p">)</span>
</pre></div>
</div>
<p>Burada <code class="docutils literal notranslate"><span class="pre">Çalışan()</span></code> adlı sınıfın niteliklerine nasıl eriştiğimize dikkat edin.
Gördüğünüz gibi, sınıf niteliklerine erişmek için doğrudan sınıfın adını
parantezsiz bir şekilde kullanıyoruz. Eğer sınıf adlarını parantezli bir şekilde
yazarsak başka bir şey yapmış oluruz. Bundan biraz sonra bahsedeceğiz. Biz
şimdilik, sınıf niteliklerine erişmek için sınıf adlarını parantezsiz
kullanmamız gerektiğini bilelim yeter.</p>
<p>Hatırlarsanız, bu bölüme başlarken, nesne tabanlı programlama yaklaşımının,
özellikle birtakım ortak niteliklere ve davranış şekillerine sahip gruplar
tanımlamak gerektiğinde son derece kullanışlı olduğunu söylemiştik. Gelin
isterseniz yukarıdaki <code class="docutils literal notranslate"><span class="pre">Çalışan()</span></code> sınıfına birkaç nitelik daha ekleyerek bu
iddiamızı destekleyelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Çalışan</span><span class="p">():</span>
<span class="n">kabiliyetleri</span> <span class="o">=</span> <span class="p">[]</span>
<span class="n">unvanı</span> <span class="o">=</span> <span class="s1">'işçi'</span>
<span class="n">maaşı</span> <span class="o">=</span> <span class="mi">1500</span>
<span class="n">memleketi</span> <span class="o">=</span> <span class="s1">''</span>
<span class="n">doğum_tarihi</span> <span class="o">=</span> <span class="s1">''</span>
</pre></div>
</div>
<p>Burada belli <cite>kabiliyetleri</cite>, <cite>unvanı</cite>, <cite>maaşı</cite>, <cite>memleketi</cite> ve <cite>doğum_tarihi</cite>
olan bir <code class="docutils literal notranslate"><span class="pre">Çalışan()</span></code> sınıfı tanımladık. Yani ‘Çalışan’ adlı bir grubun ortak
niteliklerini belirledik. Elbette her çalışanın memleketi ve doğum tarihi farklı
olacağı için sınıf içinde bu değişkenlere belli bir değer atamadık. Bunların
birer karakter dizisi olacağını belirten bir işaret olması için yalnızca
<cite>memleketi</cite> ve <cite>doğum_tarihi</cite> adlı birer boş karakter dizisi tanımladık.</p>
<p>Yukarıda tanımladığımız sınıf niteliklerine, doğrudan sınıf adını kullanarak
erişebileceğimizi biliyorsunuz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="n">Çalışan</span><span class="o">.</span><span class="n">maaşı</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">Çalışan</span><span class="o">.</span><span class="n">memleketi</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">Çalışan</span><span class="o">.</span><span class="n">doğum_tarihi</span><span class="p">)</span>
</pre></div>
</div>
<p>Eğer isterseniz bu sınıfa yeni sınıf nitelikleri de ekleyebilirsiniz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">Çalışan</span><span class="o">.</span><span class="n">isim</span> <span class="o">=</span> <span class="s1">'Ahmet'</span>
<span class="n">Çalışan</span><span class="o">.</span><span class="n">yaş</span> <span class="o">=</span> <span class="mi">40</span>
</pre></div>
</div>
<p>Gayet güzel…</p>
<p>Ancak burada şöyle bir sorun var: Biz yukarıdaki gibi doğrudan sınıf adını
kullanarak öğelere eriştiğimizde kodlarımız tek kullanımlık olmuş oluyor. Yani
bu şekilde ancak tek bir <code class="docutils literal notranslate"><span class="pre">Çalışan()</span></code> nesnesi (‘nesne’ kavramına ilerde
değineceğiz), dolayısıyla da tek bir çalışan oluşturma imkanı elde edebiliyoruz.
Ama biz, mantıken, sınıf içinde belirtilen özellikleri taşıyan, Ahmet, Mehmet,
Veli, Selim, Selin ve buna benzer, istediğimiz sayıda çalışan
oluşturabilmeliyiz. Peki ama nasıl?</p>
</div>
<div class="section" id="siniflarin-orneklenmesi">
<h2>Sınıfların Örneklenmesi<a class="headerlink" href="#siniflarin-orneklenmesi" title="Bu başlık için kalıcı bağlantı">¶</a></h2>
<p>Biraz önce şöyle bir sınıf tanımlamıştık:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Çalışan</span><span class="p">():</span>
<span class="n">kabiliyetleri</span> <span class="o">=</span> <span class="p">[]</span>
<span class="n">unvanı</span> <span class="o">=</span> <span class="s1">'işçi'</span>
<span class="n">maaşı</span> <span class="o">=</span> <span class="mi">1500</span>
<span class="n">memleketi</span> <span class="o">=</span> <span class="s1">''</span>
<span class="n">doğum_tarihi</span> <span class="o">=</span> <span class="s1">''</span>
</pre></div>
</div>
<p>Daha önce de söylediğimiz gibi, sınıflar belli birtakım ortak özelliklere sahip
gruplar tanımlamak için biçilmiş kaftandır. Burada da, her bir çalışan için ortak
birtakım nitelikler tanımlayan <code class="docutils literal notranslate"><span class="pre">Çalışan()</span></code> adlı bir sınıf oluşturduk. Ancak
elbette bu sınıfın bir işe yarayabilmesi için, biraz önce de değindiğimiz gibi,
bu sınıfı temel alarak, bu sınıfta belirtilen nitelikleri taşıyan birden fazla
sınıf üyesi meydana getirebilmemiz lazım.</p>
<p>Şimdi dikkatlice bakın:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Çalışan</span><span class="p">():</span>
<span class="n">kabiliyetleri</span> <span class="o">=</span> <span class="p">[]</span>
<span class="n">unvanı</span> <span class="o">=</span> <span class="s1">'işçi'</span>
<span class="n">maaşı</span> <span class="o">=</span> <span class="mi">1500</span>
<span class="n">memleketi</span> <span class="o">=</span> <span class="s1">''</span>
<span class="n">doğum_tarihi</span> <span class="o">=</span> <span class="s1">''</span>
<span class="n">ahmet</span> <span class="o">=</span> <span class="n">Çalışan</span><span class="p">()</span>
</pre></div>
</div>
<p>Burada sınıfımızı <cite>ahmet</cite> adlı bir değişkene atadık.</p>
<p>İşte bu işleme teknik dilde ‘örnekleme’ veya ‘örneklendirme’ (<em>instantiation</em>)
adı verilir. Bu işlemi fonksiyon çağırma ile kıyaslayabiliriz: Python
programlama dilinde bir fonksiyonu kullanışlı hale getirme işlemine ‘çağırma’,
bir sınıfı kullanışlı hale getirme işlemine ise ‘örnekleme’ adı veriyoruz.</p>
<p>Örnekleme kavramını daha iyi anlayabilmek için başka bir sınıf daha
oluşturalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Asker</span><span class="p">():</span>
<span class="n">rütbesi</span> <span class="o">=</span> <span class="s1">'Er'</span>
<span class="n">standart_teçhizat</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'G3'</span><span class="p">,</span> <span class="s1">'kasatura'</span><span class="p">,</span> <span class="s1">'süngü'</span><span class="p">,</span> <span class="s1">'el bombası'</span><span class="p">]</span>
<span class="n">gücü</span> <span class="o">=</span> <span class="mi">60</span>
<span class="n">birliği</span> <span class="o">=</span> <span class="s1">''</span>
</pre></div>
</div>
<p>Burada da belli birtakım niteliklere sahip <code class="docutils literal notranslate"><span class="pre">Asker()</span></code> adlı bir sınıf
tanımladık. Bu sınıfın niteliklerine doğrudan sınıf adını kullanarak
erişebileceğimizi biliyorsunuz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">Asker</span><span class="o">.</span><span class="n">rütbesi</span>
<span class="n">Asker</span><span class="o">.</span><span class="n">standart_teçhizat</span>
<span class="n">Asker</span><span class="o">.</span><span class="n">gücü</span>
<span class="n">Asker</span><span class="o">.</span><span class="n">birliği</span>
</pre></div>
</div>
<p>Ama bu sınıfın bir işe yarayabilmesi için, bu sınıfa bir ‘referans’ oluşturmamız
lazım, ki daha sonra bu sınıfa bu referans üzerinden atıfta bulunabilelim. Yani
bu sınıfı çağırırken buna bir isim vermeliyiz, ki bu isim üzerinden sınıfa ve
niteliklerine erişebilelim.</p>
<p>Mesela bu sınıfa daha sonra atıfta bulunabilmek amacıyla, bu sınıf için <cite>mehmet</cite>
adlı bir referans noktası oluşturalım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">mehmet</span> <span class="o">=</span> <span class="n">Asker</span><span class="p">()</span>
</pre></div>
</div>
<p>İşte, teknik olarak ifade etmemiz gerekirse, sınıfları bir isme atama işlemine
örnekleme (veya örneklendirme) adı veriyoruz.</p>
<p>Burada <cite>ahmet</cite> ve <cite>mehmet</cite>, ait oldukları sınıfların birer ‘sureti’ veya başka
bir deyişle ‘örneği’dir (<em>instance</em>). <cite>mehmet</cite>’in, <code class="docutils literal notranslate"><span class="pre">Asker()</span></code> adlı sınıfın bir
örneği, <cite>ahmet</cite>’inse <code class="docutils literal notranslate"><span class="pre">Çalışan()</span></code> adlı sınıfın bir örneği olması demek,
<cite>mehmet</cite>’in ve <cite>ahmet</cite>’in, ilgili sınıfların bütün özelliklerini taşıyan birer
üyesi olması demektir.</p>
<div class="admonition warning">
<p class="admonition-title">Uyarı</p>
<p>Bu bağlamda ‘örnek’ kelimesini ‘misal’ anlamında kullanmadığımıza
özellikle dikkatinizi çekmek isterim. Türkçede ‘örnek’ kelimesi ile
karşıladığımız ‘instance’ kavramı, nesne tabanlı programlamanın önemli teknik
kavramlarından biridir.</p>
</div>
<p>Biz bir sınıfı çağırdığımızda (yani <code class="docutils literal notranslate"><span class="pre">Asker()</span></code> veya <code class="docutils literal notranslate"><span class="pre">Çalışan()</span></code> komutunu
verdiğimizde), o sınıfı örneklemiş oluyoruz. Örneklediğimiz sınıfı bir değişkene
atadığımızda ise o sınıfın bir örneğini çıkarmış, yani o sınıfın bütün
özelliklerini taşıyan bir üye meydana getirmiş oluyoruz.</p>
<p>Bu arada, elbette bu teknik terimleri ezberlemek zorunda değilsiniz. Ancak nesne
tabanlı programlamaya ilişkin metinlerde bu terimlerle sık sık
karşılaşacaksınız. Eğer bu terimlerin anlamını bilirseniz, okuduğunuz şey
zihninizde daha kolay yer edecek, aksi halde, sürekli ne demek olduğunu
bilmediğiniz terimlerle karşılaşmak öğrenme motivasyonunuza zarar verecektir.</p>
<p>Esasında nesne tabanlı programlamayı öğrencilerin gözünde zor kılan şey, bu
programlama yaklaşımının özünden ziyade, içerdiği terimlerdir. Gerçekten de
nesne tabanlı programlama, pek çok çetrefilli teknik kavramı bünyesinde
barındıran bir sistemdir. Bu nedenle öğrenciler bu konuya ilişkin bir şeyler
okurken, muğlak kavramların arasında kaybolup konunun esasını gözden
kaçırabiliyor. Eğer nesne tabanlı programlamaya ilişkin kavramları hakkıyla
anlarsanız, bu yaklaşıma dair önemli bir engeli aşmışsınız demektir.</p>
<p>Öte yandan, nesne tabanlı programlamaya ilişkin kavramları anlamak sadece Türkçe
okuyup yazanlar için değil, aynı zamanda İngilizce bilip ilgili makaleleri özgün
dilinden okuyanlar için de zor olabilir. O yüzden biz bu bölümde, kavramların
Türkçeleri ile birlikte İngilizcelerini de vererek, İngilizce bilenlerin özgün
metinleri okurken konuyu daha iyi anlamalarını sağlamaya çalışacağız.
Dolayısıyla, bir kavramdan bahsederken onun aslının ne olduğunu da belirtmemiz,
İngilizce bilip de konuyu daha ileri bir düzeyde araştırmak isteyenlere kolaylık
sağlayacaktır.</p>
<p>Ne diyorduk? Eğer elimizde şöyle bir kod varsa:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Sipariş</span><span class="p">():</span>
<span class="n">firma</span> <span class="o">=</span> <span class="s1">''</span>
<span class="n">miktar</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">sipariş_tarihi</span> <span class="o">=</span> <span class="s1">''</span>
<span class="n">teslim_tarihi</span> <span class="o">=</span> <span class="s1">''</span>
<span class="n">stok_adedi</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">jilet</span> <span class="o">=</span> <span class="n">Sipariş</span><span class="p">()</span>
</pre></div>
</div>
<p>Burada <cite>class</cite>, sınıfı tanımlamamıza yarayan bir öğedir. Tıpkı fonksiyonlardaki
<cite>def</cite> gibi, sınıfları tanımlamak için de <cite>class</cite> adlı bir parçacığı
kullanıyoruz.</p>
<p><cite>Sipariş</cite> ise, sınıfımızın adı oluyor. Biz sınıfımızın adını parantezli veya
parantezsiz olarak kullanma imkanına sahibiz.</p>
<p>Sınıfın gövdesinde tanımladığımız şu değişkenler birer sınıf niteliğidir (<em>class
attribute</em>):</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">firma</span> <span class="o">=</span> <span class="s1">''</span>
<span class="n">miktar</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">sipariş_tarihi</span> <span class="o">=</span> <span class="s1">''</span>
<span class="n">teslim_tarihi</span> <span class="o">=</span> <span class="s1">''</span>
<span class="n">stok_adedi</span> <span class="o">=</span> <span class="mi">0</span>
</pre></div>
</div>
<p><code class="docutils literal notranslate"><span class="pre">jilet</span> <span class="pre">=</span> <span class="pre">Sipariş()</span></code> komutunu verdiğimizde ise, biraz önce tanımladığımız
sınıfı örnekleyip (<em>instantiation</em>), bunu <cite>jilet</cite> adlı bir örneğe (<em>instance</em>)
atamış oluyoruz. Yani <cite>jilet</cite>, <code class="docutils literal notranslate"><span class="pre">Sipariş()</span></code> adlı sınıfın bir örneği olmuş
oluyor. Bir sınıftan istediğimiz sayıda örnek çıkarabiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kalem</span> <span class="o">=</span> <span class="n">Sipariş</span><span class="p">()</span>
<span class="n">pergel</span> <span class="o">=</span> <span class="n">Sipariş</span><span class="p">()</span>
<span class="n">çikolata</span> <span class="o">=</span> <span class="n">Sipariş</span><span class="p">()</span>
</pre></div>
</div>
<p>Bu şekilde <code class="docutils literal notranslate"><span class="pre">Sipariş()</span></code> sınıfını üç kez örneklemiş, yani bu sınıfın bütün
özelliklerini taşıyan üç farklı üye meydana getirmiş oluyoruz.</p>
<p>Bu sınıf örneklerini kullanarak, ilgili sınıfın niteliklerine (<em>attribute</em>)
erişebiliriz:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">kalem</span> <span class="o">=</span> <span class="n">Sipariş</span><span class="p">()</span>
<span class="n">kalem</span><span class="o">.</span><span class="n">firma</span>
<span class="n">kalem</span><span class="o">.</span><span class="n">miktar</span>
<span class="n">kalem</span><span class="o">.</span><span class="n">sipariş_tarihi</span>
<span class="n">kalem</span><span class="o">.</span><span class="n">teslim_tarihi</span>
<span class="n">kalem</span><span class="o">.</span><span class="n">stok_adedi</span>
</pre></div>
</div>
<p>Bildiğiniz gibi, eriştiğimiz bu nitelikler birer sınıf niteliği olduğu için,
sınıfı hiç örneklemeden, bu niteliklere doğrudan sınıf adı üzerinden de
erişebilirdik:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="n">Sipariş</span><span class="o">.</span><span class="n">firma</span>
<span class="n">Sipariş</span><span class="o">.</span><span class="n">miktar</span>
<span class="n">Sipariş</span><span class="o">.</span><span class="n">sipariş_tarihi</span>
<span class="n">Sipariş</span><span class="o">.</span><span class="n">teslim_tarihi</span>
<span class="n">Sipariş</span><span class="o">.</span><span class="n">stok_adedi</span>
</pre></div>
</div>
<p>Özellikle, örneklenmesine gerek olmayan, yalnızca bir kez çalışacak sınıflarda,
sınıf niteliklerine örnekler üzerinden değil de doğrudan sınıf adı üzerinden
erişmek daha pratik olabilir. Ancak yukarıda olduğu gibi, tek bir sınıftan,
ortak niteliklere sahip birden fazla üye oluşturmamız gereken durumlarda sınıfı
bir örneğe atayıp, sınıf niteliklerine bu örnek üzerinden erişmek çok daha
akıllıca olacaktır. Ancak her koşulda sınıfların niteliklerine doğrudan sınıf
adları üzerinden erişmek yerine örnekler üzerinden erişmeyi tercih etmenizin de
hiçbir sakıncası olmadığını bilin.</p>
<p>Gelin şimdi yukarıda öğrendiklerimizi kullanarak ufak tefek uygulama çalışmaları
yapalım.</p>
<p>Sınıfımız şu olsun:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Sipariş</span><span class="p">():</span>
<span class="n">firma</span> <span class="o">=</span> <span class="s1">''</span>
<span class="n">miktar</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">sipariş_tarihi</span> <span class="o">=</span> <span class="s1">''</span>
<span class="n">teslim_tarihi</span> <span class="o">=</span> <span class="s1">''</span>
<span class="n">stok_adedi</span> <span class="o">=</span> <span class="mi">0</span>
</pre></div>
</div>
<p>Bildiğiniz gibi, ufak tefek kod çalışmaları yapmak için Python’ın etkileşimli
kabuğu son derece uygun bir ortamdır. O halde yukarıdaki sınıfı <cite>sipariş.py</cite>
adlı bir dosyaya kaydedelim, bu dosyanın bulunduğu konumda bir etkileşimli
kabuk ortamı açalım ve <cite>sipariş.py</cite> dosyasını bir modül olarak içe aktaralım:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">import</span> <span class="nn">sipariş</span>
</pre></div>
</div>
<p>Böylece <cite>sipariş</cite> modülü içindeki nitelik ve metotlara erişim sağladık. Bunu
teyit edelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">dir</span><span class="p">(</span><span class="n">sipariş</span><span class="p">)</span>
<span class="go">['Sipariş', '__builtins__', '__cached__', '__doc__', '__file__',</span>
<span class="go"> '__loader__', '__name__', '__package__', '__spec__']</span>
</pre></div>
</div>
<p><code class="docutils literal notranslate"><span class="pre">Sipariş()</span></code> adlı sınıfı listenin en başında görebilirsiniz. O halde gelin bu
sınıfı örnekleyerek kullanılabilir hale getirelim:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">gofret</span> <span class="o">=</span> <span class="n">sipariş</span><span class="o">.</span><span class="n">Sipariş</span><span class="p">()</span>
</pre></div>
</div>
<p>Elbette <code class="docutils literal notranslate"><span class="pre">Sipariş()</span></code> adlı sınıf <cite>sipariş</cite> adlı modül içinde bulunduğundan, bu
sınıfa <cite>sipariş</cite> önekiyle erişiyoruz. Tabii biz isteseydik modülü şu şekilde de
içe aktarabilirdik:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">sipariş</span> <span class="kn">import</span> <span class="n">Sipariş</span>
</pre></div>
</div>
<p>Böylece <code class="docutils literal notranslate"><span class="pre">Sipariş()</span></code> sınıfına öneksiz olarak erişebilirdik:</p>
<div class="highlight-py3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">gofret</span> <span class="o">=</span> <span class="n">Sipariş</span><span class="p">()</span>