Python İle Programlamanın Temelleri-9

Nesneler

1.Nesne Kavramı

Nesne, kendine has özellikleri olan ve bu özellikler doğrultusunda bulunduğu duruma bağlı olarak çeşitli tutumlar sergileyen somut ya da soyut varlıklardır. Bu tanım, “somut” kısmıyla gerçek yaşamdaki nesneler için de geçerlidir. Donanım açısından baktığımızda kişisel bir bilgisayar; ana kart, işlemci, video kart, sabit disk ve kontrol ünitesi, bunları barındıran bir kasa, klavye, fare ve ekrandan oluşur. Video kart; çip, hafıza ve diğer elektronik bileşenleri barındıran karmaşık bir yapıdır. Somut kısmıyla nesnelere, donanım birimleri örnek olarak verilebilir.

Ancak gerçek yaşamda “nesne” olarak nitelendirmediğimiz fonksiyon, değişken, dizi gibi kavramlar programlama ortamında nesne olarak tanımlanabilirler. Bu da tanımın “soyut” diye ifade ettiği bölümü oluşturur.

Günümüzde yazılım geliştirme daha çok yazılımların donanım gibi kullanıldığı bileşenlere dayanmaktadır. Bir yazılım sistemi var olan yazılım oluşturma blokları üzerine inşa edilir. Python, farklı yapıdaki blokları ve bileşenleri desteklemektedir.

Python nesne yönelimli bir programlama dilidir. Nesne yönelimli programlama dili programcının nesneleri tanımlamasına, oluşturmasına ve yönetmesine olanak sağlar. Nesneler, veri ve fonksiyonları bir araya toplar. Diğer değişkenler gibi Python nesnelerinin de tipi ve sınıfı vardır.

2.Nesneleri Kullanmak

Bir nesne bir sınıfa örnek olarak verilebilir. Aslında başından beridir nesneleri kullanıyoruz ama detaylı bir biçimde şimdi inceleyeceğiz. Tam sayılar, reel sayılar, diziler ve fonksiyonlar Python için birer nesnedir. Fonksiyonların dışında genel olarak nesneleri pasif veri olarak kullandık. Bir değişkene tam sayı atayarak daha sonra o değişkenin değerini kullanabiliriz. “+” operatörü ile iki reel sayıyı ya da iki kelimeyi toplayabiliriz. Fonksiyonlara nesne yollayabilir ve sonucu nesne olarak alabiliriz.

Tipik bir nesne iki bölümden oluşur: veri ve metotlar. Örnek değişken ait olduğu nesne tarafından temsil edilen değişken anlamına gelir ve nesne de bir sınıf örneğidir. Örnek değişkenler için diğer isimler, özellik ve alanları da kapsamaktadır. Metotlar fonksiyon gibidir ve operatör olarak da ifade edilir. Bir nesne için örnek değişkenler ve metotlar nesnenin üyeleri olarak bilinir. “Nesneyi kullanan kod, nesne istemcisidir ve nesne istemcilere servis sunmaktadır.” şeklinde açıklanır. Bir nesne tarafından sunulan servisler basit fonksiyonlara göre daha ayrıntılıdır. Bunun nedeni ise nesneler değişken içinde kolay veri korur çünkü nesnelerin örnek değişkenler içinde veri koruması daha kolaydır.




3.Dizi Nesneleri

Dizi nesnelerinin nasıl oluşturulacağını str örneği ile inceleyelim. Nesneler veri ve diziyi oluşturan veri diziyi oluşturan karakterlerin sıralaması hâline gelir.

Şimdi str metotlarını inceleyelim.

ad = input(“Adını yaz: “)

print(“Merhaba ” + ad.upper() + “, nasılsın?”)

Bu kodlama ile kullanıcı tarafından girilen dizideki bütün karakterler büyük harfe çevrilir.

Adını yaz: Filiz

Merhaba FİLİZ, nasılsın?

print ifadesinde yer alan ad.upper() komutu ile bir metot çağrılmaktadır. Genel olarak bir metot çağırmanın biçimi şu şekildedir:

Bir önceki örnekte “name” bir dizi nesnesini çağırmaktadır.

“.” (nokta) nesneye bağlı olarak çağırılacak metot ile bağ kurulduğunu ifade eder.

“metot adı” çağırılan ve çalışacak olan metot adıdır.

“parametre listesi” metoda gönderilen ve virgülle ayrılmış parametre listesidir. Bazı metotlar parametre istemez, o zaman bu liste boş olabilir.

Metoda gönderilen parametre listesi, fonksiyona gönderilen parametre listesi ile tamamen aynı biçimde davranır. Bu nedenle metotlar da geri değer döndürebilir.

Aşağıdaki örnekte rjust komutu metni sağa hizalamak için kullanılmaktadır.

kelime = “ABCD”

print(kelime.rjust(10, “*”))

print(kelime.rjust(3, “*”))

print(kelime.rjust(15, “>”))

print(kelime.rjust(10))******ABCD

Ekran Çıktısı

******ABCD

ABCD

>>>>>>>>>ABCD

ABCD

kelime.rjust(10, “*”) 10 karakterlik bir alan içinde boşluklara “*” değeri vererek “ABCD” dizisini sağa dayalı yazar.

kelime.rjust(3, “*”) komutu belirtilen değer dizi boyutundan daha küçük olduğu için bir işlem yapamaz.

kelime.rjust(15, “>”) 15 karakterlik bir alan içinde boşluklara “>” değeri vererek “ABCD” dizisini sağa dayalı yazar.

kelime.rjust(10) ise boş alanlara basılacak varsayılan karakterin boşluk olduğunu belirtmektedir.

Aşağıdaki örnek, metodu dizi kullanarak çağırabildiğimizi göstermektedir:

>> “aBcDeFgHiJ”.upper()

“ABCDEFGHIJ”

>> “PYTHON çok güzel bir dildir.”.rjust(35,”-“)

“——-PYTHON çok güzel bir dildir.”

Bu söz dizimi daha önce kullandığımız bazı örneklerle benzerlik göstermektedir.

>>> “{0} {1}”.format(23, 9)

“23 9”

>>> s = “{0} {1}”

>>> s.format(23, 9) “23 9”

3.1  str Nesnesi İçin Yöntemler

strip ve count Fonksiyon Örneği

# Ön ve arka plandaki boşlukları ve sayaç alt dizilerini ayırır

s = ” ABCDEFGHBCDIJKLMNOPQRSBCDTUVWXYZ “

print(“[“, s, “]”, sep=””)

s = s.strip()

print(“[“, s, “]”, sep=””)

# Alt dizinin sayılarını sayar “BCD”

print(s.count(“BCD”))

Ekran Çıktısı

[ ABCDEFGHBCDIJKLMNOPQRSBCDTUVWXYZ ] [ABCDEFGHBCDIJKLMNOPQRSBCDTUVWXYZ]

3

3.2  getitem Kullanımı

“str” sınıfı __getitem__ isimli bir metot ile karakterin dizideki sırasını verir. Metodun isminin “__” ile başlıyor olması, bu metodun dâhilî kullanımı olduğu ve istemcilerin kullanamayacağı anlamına ge- lir. İstemciler, bu metodu özel bir söz dizimi ile kullanabilirler.

>>> s = “ABCEFGHI”

>>> s

“ABCEFGHI”

>>> s. _ _ getitem _ _ (0) “A”

>>> s. _ _ getitem _ _ (1) “B”

>>> s. _ _ getitem _ _ (2) “C”

>>> s[0] “A”

>>> s[1] “B”

>>> s[2] “C”

Dizi nesnelerinde ilk karakterin konumu ya da indeks değeri “0” olduğundan her bir karakterin konumu, köşeli ayraç ([ ]) içerisinde gösterilir.

Dizilerle kullanılabilen başka bir metot ise “__len__” metodudur. Böylece dizideki karakter sayısı elde edilir.

>>> s

“ABCEFGHI”

>>> s = “ABCEFGHI”

>>> s

“ABCEFGHI”

>>> len(s)

8

>>> s. _ _ len _ _ ()

8

“len(s)” ve “s.__len__()” söz dizimleri fonksiyonel olarak aynıdır. İstemciler çağırırken global “len” fonksiyonunu kullanmalıdır.

Karakter Yazma Örneği

s = “Hayatta En Hakiki Mürşit İlimdir”

print(s)

for i in range(len(s)):

print(“[“, s[i], “]”, sep=””, end=””)

print() # Yeni satır başı

for ch in s:

print(“<“, ch, “>”, sep=””, end=””)

print() # Yeni satır başı

Ekran Çıktısı

Hayatta En Hakiki Mürşit İlimdir

[H][a][y][a][t][t][a][ ][E][n][ ][H][a][k][i][k][i][ ][M][ü][r][ş][i][t][ ][İ][l][i][m][d][i][r]

<H><a><y><a><t><t><a><       ><E><n><       ><H><a><k><i><k><i><

><M><ü><r><ş><i><t>< ><İ><l><i><m><d><i><r>

Diziler değişmez nesnelerdir. Bu nedenle bir dizi nesnesinin içeriğini değiştiremeyiz.

s = “ABCDEFGHIJKLMN”

s[3] = “S” # Kurala aykırı, dizi sabit

Dizi değişmezliği, bir şeridin belirli bir diziyi değiştirmediği bir yöntem anlamına gelir.

s = ” ABC “

s.strip() # s değişmez

print(“<” + s + “>”) # < ABC > yazılır , <ABC> değil

Ön ve arka plandaki boşlukları s değişkenine bağlı dizi kadar çıkarmak için yeniden atamanız gerekir:

s = ” ABC “

s = s.strip() # Yeniden atama yapılır

print(“<” + s + “>”) # <ABC> yazılır

“strip” metodu yeni bir dizi döndürür ancak mevcut dizi değiştirilmez. Bir diziden boşlukları etkili bir biçimde temizleyebilmek için istemci, strip metoduna gönderilen değişkene tekrar atama yapmak zorundadır. Mantıksal olarak değerlendirildiğinde boş dizi (‘’) yanlış; tüm diğer diziler ise doğru olarak işlenir.




4.Dosya Nesneleri

Şu ana kadar çalıştırdığımız tüm programlar, sonlandıklarında tüm verilerini kaybetti. Oysaki bazı durumlarda bu verilerin saklanması gerekebilir. Örneğin kaydetmenize olanak sağlamayan bir kelime işlemci programı düşünün. Bu durumda tekrar erişip düzenleme, çıktı alma vb. hiçbir işlemi yapmak mümkün olmaz.

Sistemlerin çoğu saklanması gereken veriyi dosya biçiminde kaydeder ve her bir programın da dosya türünü belirten özel uzantısı vardır.

Python kapsamında veri saklama ve geri çağırma işlemlerini “file (dosya)” nesnesi ile gerçekleştiririz. “io” modülündeki “TextIOWrapper” ile bu işlemi yaparız. Dosya işlemleri yaygın kullanıldığı için “io” modülü dâhilinde kullanılan fonksiyon ve sınıf lar, “import” komutu kullanılmadan çalıştırılabilir.

f = open(“dosyam.txt”, “r”)

ifadesi bir dosya oluşturarak “f ” isimli bir dosya nesnesi döndürür. İlk parametre dosya adını; ikinci parametre ise dosyanın durumunu ifade eder. Dosya durumu aşağıdaki gibi olabilir.

‘r’ yalnızca okunabilir.

‘w’ dosyayı yazmak için açar, yeni dosya oluşturur.

‘a’ dosyaya yeni veri eklenerek değiştirme yapılabilir.

“f ” isimli bir dosya nesnesi oluşturmak ve “dosyam.txt” isimli dosya içeriğini okuyabilmek için

f = open(“dosyam.txt”, “r”)

söz dizimi kullanılır. Eğer dosya yoksa ya da programı kullanan kişinin dosyaya erişim için gereken izinleri bulunmuyorsa bu komut hata verecektir.

“f ” isimli bir dosya nesnesi oluşturmak ve “dosyam.txt” isimli dosyaya yazabilmek için

f = open(“dosyam.txt”, “w”)

söz dizimi kullanılır. Dosya yoksa fonksiyon, disk üzerinde yeni bir dosya oluşturur. Aynı isimli bir dosya zaten varsa dosyadaki eski veriler yenileri ile değişecektir. Bu, dosyanın içerisinde önceden oluşturulmuş içeriğin silineceği anlamına gelir. “f ” isimli bir dosya nesnesi oluşturmak ve “dosyam.txt” isimli dosyaya erişmek ve veri ekleyebilmek için

f = open(“dosyam.txt”, “a”)

söz dizimi kullanılır. Dosya yoksa yeni bir dosya oluşturulur. Aynı isimli bir dosya varsa bu dosya tekrar düzenlemek için erişime açılır. Böylece dosyanın mevcut içeriği korunmuş olur. Bu fonksiyon ikinci parametre unutularak çağırılırsa varsayılan değer olarak “r” atanır.

f = open(“dosyam.txt”) ile f = open(“dosyam.txt”, “r”)

aynı işlemi gerçekleştirir. “w” ya da “a” izni ile erişilmiş ve yazabileceğiniz bir dosya nesneniz varsa write metodunu kullanarak dosya üzerinde işlem yapabilirsiniz.

f.write(“kaynak”)

komutu ‘kaynak’ verisini dosya içerisine yazar. Aşağıdaki 3 komut

f.write(“kaynak”)

f.write(“dosya”)

f.write(“veri”)

dosyaya ’kaynakdosyaveri’ verisini ekler. Veriyi ayırarak saklamak istiyorsak ona göre düzenlememiz gerekir.

f.write(“kaynak\n”)

f.write(“dosya\n”)

f.write(“veri\n”)

Bu işlem her kelimeyi ayrı bir satırda saklar. Böylece okuma işlemi yapmamız gerektiğinde işimiz kolaylaşmış olur. Dosyaya okuma izni ile erişilmişse

print(line.strip())

komutu, dosyadaki her bir satırı okur ve yazdırır. Dosya nesnesinin ok komutunu kullanarak bir dosyanın tüm içeriğini tek bir komutla bir dizi içerisine aktarabiliriz.

icerik = f.read()

in = open(“bilgiTerimleri.txt”, “r”)

“open” metodu, bir dosyayı okuma ve yazma için açar; böylece programın dosya ile etkileşimi sağlanır. Dosya ile işi bittikten sonra programın dosyayı uygun biçimde kapatması gerekir. Daha önce kapatılmamış bir dosyaya tekrar erişim sırasında sorun yaşanabilir. Bu nedenle, açılan her dosya işlemler bittikten sonra mutlaka “close” metodu kullanılarak kapatılmalıdır.

4.1. Dosya Okuma ve Yazma İşlemleri

f = open(“veriler.dat”) # f adında dosya nesnesi

for line in f: # Her satırı metin olarak oku

print(line.strip()) # Sondaki yeni satır karakterini sil

f.close() # Dosyayı kapat

with open(“veriler.dat”) as f: # f adında dosya nesnesi

for line in f: # Her satırı metin olarak oku

print(line.strip()) # Sondaki yeni satır karakterini sil

f.close() # Dosyayı kapat

4.2. Dosya Okuma ve Yazma İşlemlerinde with/as kullanımı

“with/as” ifadesi ile nesnelere ilişkin işlemler yürütülür.

“object-creation” ifadesi bir nesne oluşturur ve döndürür. Bu işlem başarısız olursa söz dizimi çalışmaya devam etmez.

“as” ifadesi yaratılan nesne ile değişkenin bağlantısını kurar.

“object” ile yaratılan nesne ilişkilendirilir.

“block” ifadesi kapsamında farklı kodlar bulunur.

“with/as” ifadesi “TextIOWrapper” gibi sınıflarla çalışabilir; böylece başlama ve bitiş için belirli bir protokol sağlanmış olur. Sadece belirli sınıf lar bu işlemi yürütmek için uygundur. Bu sınıfların ilk değer atama için “__enter__” ve sonlandırma için “__exit__” metotları vardır.

Sayıları Kaydetme Örneği

# Python “da dosyaya yazma ve dosyadan okuma programı

def Listeleme(dosyaAdi):

# Parametre olarak gelen dosyada bulunan kayıtları listeleme.

# Okumak için dosyanın açılması

with open(dosyaAdi) as f: # f adında bir dosya nesnesi oluşturuldu

for satir in f: # Satır satır okuma işlemi için döngü kuruldu

print(int(satir)) # int veri türüne dönüştürme ve ekrana yazdırma

def Kaydet(dosyaAdi):

# Parametre olarak gelen dosyada bulunan kayıtları kaydetme.

with open(dosyaAdi, “w”) as f: # f adında yazma modunda bir dosya nesnesi oluşturuldu

sayi = 0

while sayi != 999: # Kullanici 999 giresiye kadar dönen döngü kuruluyor

sayi = int(input(“Lütfen sayi giriniz..(Çıkış için 999):”))

if sayi != 999:

f.write(str(sayi) + “\n”) # String veri türüne dönüşüm ve dosyaya kayıt

else:

break # Döngüden çıkış

def main():

# Ana Program başlangıcı. Menülü seçim işlemleri ve çıkış.

kontrol = False while not kontrol:

secim = input(“K)aydet L)isteleme S)onlandır: “)

if secim == “K” or secim == “k”:

Kaydet(input(“Kayıt Edilecek Dosya Adı Girin:”))

elif secim == “L” or secim == “l”:

Listeleme(input(“Kayıtların Okunacağı Dosya Adını Girin<:”))

elif secim == “S” or secim == “s”:

kontrol = True

main()

Ekran Çıktısı

K)aydet L)isteleme S)onlandır: k

Kayıt Edilecek Dosya Adı Girin:sayilar

Lütfen sayi giriniz..(Çıkış için 999):1

Lütfen sayi giriniz..(Çıkış için 999):54

Lütfen sayi giriniz..(Çıkış için 999):66

Lütfen sayi giriniz..(Çıkış için 999):44

Lütfen sayi giriniz..(Çıkış için 999):23

Lütfen sayi giriniz..(Çıkış için 999):999

K)aydet L)isteleme S)onlandır: l

Kayıtların Okunacağı Dosya Adını Girin<:sayilar

1

54

66

44

23

K)aydet L)isteleme S)onlandır: s

“io” modülünden seçilen Python dosya sınıfını “TextIOWrapper” olarak görüyoruz. Bu sınıfta işlem gören dosyalar metin türündedir. Metin dosyaları, karakter veri saklar ve basit bir editörle kolayca oluşturulup düzenlenebilir. Python kapsamında dizi ve dosya nesnelerini bir arada kullanarak güçlü dosya işleme programları yazabiliriz. Bir dosyayı açıp, içeriğini okuyup tamamen değiştirip başka bir dosyaya yazabiliriz.

from convertupper import capitalize

capitalize(“declaration.txt”)

4.3. TextIOWrapper Yöntemleri

Örnek

Nesneler metotların yanı sıra veri de içerir. “TextIOWrapper” nesneleri tam sayı, dizi ve mantıksal ifadeler saklayabilir.

>>> f = open(“temp.dat”, “w”)

>>> f.name

“temp.dat”

>>> f. _ CHUNK _ SIZE

8192

>>> f.mode

“w”

>>> f.encoding

“cp1252”

>>> f.line _ buffering

False

name”, “_CHUNK_SIZE”, “encoding” ve “line_buffering” ifadeleri “f ” nesnesinin örnek değişkenleridir. Bu değişkenlerin önceden kullandıklarımızdan farkı “.” ile belirli bir nesne ile ilişkilendirilmiş olmalarıdır. Bu isimler metot değil veriyi ifade ettiği için sonunda ayraç kullanılmamaktadır. “f ” ve “g” isimli iki farklı nesnemiz varsa bu nesneler birbirinden farklı davranabilir.

x = 2

ifadesinde x değişkenine “2” değeri atanırken

obj.x = 2

ifadesinde “obj” isimli nesnenin örnek x değişkenine atama yapılmaktadır.




5.Turtle Grafik Nesneleri

Grafik çizme işleminde “Turtle” nesnesinin, çizim işlemi için kalemi modellediğini biliyoruz.

Kendi “Turtle” nesnelerimizi tasarlayarak kullanabiliriz. Birden fazla kalem kullanmamız gerekirse bu, çok kullanışlı olacaktır.

# Pencere içerisine diktörtgen bir kutu çizimi

import turtle

t = turtle.Turtle() # Adı t olan yeni bir Turtle() nesnesi oluşturuluyor
t.pencolor(“red”) # t nesnesinin çizim kalemi rengi kırmızı olarak ayarlanıyor
t.forward(200) # t nesnesinin kalemi 200 birim ileri oynatılıyor ve dikdörtgenin alt kenarı çiziliyor
t.left(90) # Turtle 90 derece sola döndürülüyor
t.pencolor(“blue”) # t nesnesinin rengi mavi olarak değiştiriliyor
t.forward(150) # Sağ kenarın çizilmesi için Turtle 150 birim yukarı ilerletiliyor
t.left(90) # Turtle 90 derece sola döndürülüyor
t.pencolor(“green”) # Turtle nesnesinin rengi yeşil olarak değiştiriliyor
t.forward(200) # Dikdörtgenin üst kenarının çizilmesi için Turtle 200 birim ilerletiliyor.
t.left(90) # Turtle 90 derece sola döndürülüyor
t.pencolor(“black”) # Turtle nesnesinin rengi siyah olarak değiştiriliyor
t.forward(150) # Son kenar olan sol kenarın çizilmesi için Turtle 150 birim ilerletiliyor.
t.hideturtle() # Turtle gizleniyor
mainloop() # Kullanıcıdan veri bekleniyor

5.1. Turtle Grafik & tkinter Nesneleri

“tkinter” modülü Tk araç kiti ile grafiksel kullanıcı arayüzleri oluşturma sürecinde farklı sınıf lar sunar. Tk MicrosoftWindows, Apple Mac, and Linux işletim sistemleri ile kullanılabilir. “tkinter” modülü “Turtle” modülünden daha kapsamlı ve karmaşıktır. Aslında “Turtle” modülü “tkinter” modülünün sunduğu bileşenler üzerine inşa edilmiştir.

from tkinter import Tk, Button

sayac = 0 # Tıklama sayısının hafızada tutulacağı değişken tanımlanıyor

def update():

# Grafikte bulunan butona tıklandığında sayaç artırma işlemi

global sayac, b sayac += 1

b.config(text=”Tıklama Sayısı = ” + str(sayac))

print(“Güncelleniyor”)

root = Tk()

b = Button(root)

b.configure(background=”yellow”, text         =”Tıklama  Sayısı               =             0″,

command=update) # Ekrana buton

b.pack()

root.mainloop()   # nesnesi   oluşturuluyor

5.2. Buton Test Etme

Tk: Bu sınıf bir grafik pencereyi temsil eder.

root = Tk()

ifadesi, “root” isimli bir nesne oluşturur. Bu nesne, uygulamanın ana grafik penceresini ifade eder.

root.mainloop()

ifadesi, pencerenin yanı sıra grafik programını başlatmak için “mainloop” metodunu çağırır. Bu metot, hareket sürecini başlatarak kullanıcının görsel dönüt almasına olanak sağlar.

Button: Kullanıcının basabileceği bir grafik butonu temsil eden sınıftır. Bir buton, araç kitinin sağladığı pek çok grafikten biridir.

b = Button(root)

ifadesi, “b” isimli bir buton nesnesi oluşturur ve nesneyi “root” pencere ile ilişkilendirir.

b.configure(background=”yellow   “, text=”Tıklama Sayısı = 0”,

command=update)

ifadesi, butonu sarı arka plan, metin rengi ve basıldığında gerçekleşecek işlem açısından konfigüre eder. “Button” nesnesi ile yazı tipi ve rengi, sola ya da sağa hizalı yazma, yatay ya da dikey konumlama ve çerçeve kalınlığı gibi seçenekleri de değiştirebiliriz.

b.pack()

ifadesi, butonun pencerede görünür iyi bir noktada yer almasını sağlar.

b = Button(root, background =”yellow”, text=”Tıklama Sayısı

= 0″, command=update)

ifadesinde gerekli olan pencere parametresi ile birlikte (root) 3 parametrenin daha gönderildiğini görüyoruz. Bu örnekte “sayac” değişkeni global olarak tanımlanmalıdır çünkü fonksiyonda tekrar atama yapılmaktadır. Ayrıca, “b” değişkeni de global olmalıdır.

Trafik Işıkları Örneği

# “Değiştir” butonuna basıldığında trafik ışıklarını sırasıyla yakan program

from tkinter import Tk, Canvas

from tkinter.ttk import Button, Frame

def ButonaBasildiginda(): # Her bir tıklamada ışıkların sırasıyla yanması

global renk

if renk == “red”:

renk = “green”

canvas.itemconfigure(kirmiziLamba, fill=”black”) # Kırmızı ışık kapatılıyor

canvas.itemconfigure(yesilLamba, fill=”green”) # Yeşil ışık yanıyor

elif renk == “green”:

renk = “yellow”

canvas.itemconfigure(yesilLamba, fill=”black”) # Yeşil ışık kapatılıyor

canvas.itemconfigure(sariLamba, fill=”yellow”) # Sarı ışık yanıyor

elif renk == “yellow”:

renk = “red”

canvas.itemconfigure(sariLamba, fill=”black”) # Sarı ışık kapatılıyor

canvas.itemconfigure(kirmiziLamba, fill=”red”) # Kırmızı ışık yanıyor

# Kullanılacak değişkenlerin tanımlanması

renk = “red” # Açık olarak gelecek ilk trafik ışığı

renk root = Tk() # Ana Pencere”nin oluşturulması

root.title(“Trafik Işıkları”) # Pencere başlığı

frame = Frame(root) # Nesnelerin birlikte tutulması için grafiksel bileşen ( widget ) oluşturuluyor

frame.pack() # Pencere içerisine frame yerleştiriliyor

# Grafiksel bileşenlerin yerleştirileceği çizim alanı ( canvas ) oluşturuluyor

canvas = Canvas(frame, width=150, height=300)

# frame”in içerisinde çizim arayüzü oluşturuluyor

# Trafik ışıkları oluşturuluyor, zemin rengi gri olarak ayarlanıyor

canvas.create _ rectangle(50, 20, 150, 280, fill=”gray”)

# Kırmızı Lamba

kirmiziLamba = canvas.create _ oval(70, 40, 130, 100, fill=”red”)

# Sarı Lamba

sariLamba = canvas.create _ oval(70, 120, 130, 180, fill=”black”)

# Yeşil Lamba

yesilLamba = canvas.create _ oval(70, 200, 130, 260, fill=”black”)

# Grafiksel butonun oluşturulması ve işlevsellik kazandırılması

Butona Basildiginda # Fare ile tıklama yapıldığında fonksiyon çağrılıyor

button = Button(frame, text=”Değiştir”, command=ButonaBasildiginda)

# Oluşturulan katmanın ilk satır ve ilk sütünuna buton,

# birinci satır ikinci sütunununa da çizim alanı yerleştiriliyor.

button.grid(row=0, column=0)

canvas.grid(row=0, column=1)

# Grafiksel arayüz oluşturuluyor

root.mainloop()

Mevcut kodlama içinde tkinter paketinden ve tkinter.ttk paketinden ayrı sınıf lar kullanılmaktadır. “Tk” sınıfı bir grafik penceresi sunar.

root = Tk()

komutu “root” isimli bir Tk nesnesi oluşturur ve “root” nesnesi uygulamanın ana grafik penceresi ile bağlantı kurar.

root.title(“Trafik Işıkları”)

pencerenin başlık çubuğundaki metni belirler.

root.mainloop()

“mainloop” yöntemini çağırarak grafik programı başlatır.

“Frame” sınıfı diğer grafik nesnelerini barındırmak için görünmeyen bir depo (widget) oluşturur.

frame = Frame(root)

komutu bir çerçeve nesnesi oluşturarak nesneyi grafik penceresi ile ilişkilendirir.

frame.pack()

komutu ise grafik penceresinin tamamını doldurur. “widget” görsel programlamada bir kütüphanedeki grafik bileşenlere verilen isimdir.

“Canvas” sınıfı grafik pencere içinde bir çizim alanı oluşturur.

canvas = Canvas(frame, width=300, height=300)

komutu çerçevenin deposunda yer alan “canvas” isimli bir nesne oluşturur. “canvas” nesnelerinin boyutları 300 px x 300 px olarak yükseklik ve genişlik anahtar kelimeleri ile belirlenir. Canvas üzerindeki koordinat sisteminin merkezi (0;0), pencerenin çizim alanının sol üst köşesinde yer alır ve y ekseni yukarı değil aşağı doğru şekillenir. Diğer bir ifade ile, soldan sağa doğru x değeri arttıkça, y değeri yukarıdan aşağıya doğru artmaktadır.




6.Nesne Değişkenliği ve Örtüşme

from fractions import Fraction

# Bazı kesir tanımlamaları yapılıyor

f1 = Fraction(1, 2) f2 = Fraction(1, 2) f3 = f1

# İlişkilendirmeler

print(“f1 =”, f1) print(“f2 =”, f2) print(“f3 =”, f3)

# Pay ve paydalar ayrı ayrı inceleniyor

print(“f1–> Pay, Payda:”, f1.numerator, f1.denominator)

print(“f2–> Pay, Payda:”, f2.numerator, f2.denominator)

print(“f3–> Pay, Payda:”, f3.numerator, f3.denominator)

# Kesirler karşılaştırılıyor

print(“f1 == f2 ?”, f1 == f2)

print(“f1 == f3 ?”, f1 == f3)

print(“f1 ile f2 aynı değer mi?”, f1 is f2)

print(“f1 ile f3 aynı değer mi?”, f1 is f3)

Ekran Çıktısı

f1 = 1/2 f2 = 1/2 f3 = 1/2

f1–> Pay, Payda: 1 2

f2–> Pay, Payda: 1 2

f3–> Pay, Payda: 1 2

f1 == f2 ? True

f1 == f3 ? True

f1 aynı f2 değer mi? False

f1 aynı f3 değer mi? True

f1 = Fraction(1, 2)

Komutu “Fraction (kesir)” sınıfını çağırarak yeni bir kesir nesnesi oluşturur. Bu komut ile paya 1 ve paydaya 2 değeri atanır. “f1” değişkeni de bu yeni kesir nesnesine atanır.

fraction object. The statement f2 = Fraction(1, 2)

komutu aynı şekilde davranarak “f2” nesnesi de bu kesir nesnesine atanır.

f3 = f1

komutu ile “f3” değişkeni diğerleri ile aynı kesir nesnesine atanır. Ancak, söz dizimi “Fraction” sınıf yapısını içerdiğinden yeni bir kesir nesnesi oluşturmaz. Bu aşamada iyi kesir nesnemiz ve buna bağlı 3 değişkenimiz vardır. Aşağıda nesneler ve kesir arasındaki ilişki görülmektedir.

Görüldüğü gibi f1 ve f3 aynı nesneyi işaret etmektedir. Bu durum “örtüşme” olarak ifade edilir yani f1 ile f3 örtüşmektedir (f1 aliases f3). Kesirlerin mantıksal olarak eşitliğini karşılaştırmak için kesir nesnesine ait __eq__ yöntemi “==” operatörü ile kullanılır.

print(“f1 == f2?”, f1 == f2)

print(“f1 == f3?”, f1 == f3)

komutlarının üçü de mantıksal olarak birbirine eş değer değişkenler olduğunu açığa çıkarmaktadır. “__eq__” yöntemi (==) ile kesirlerin pay ve payda değerleri eşitlik konusunda karar verebilmek için ayrı ayrı karşılaştırılmaktadır.

Bazen mantıksal eşitlik yeterli olmaz ve her iki değişkenin de aynı nesneye ait olup olmadığını bilmek isteriz.

print(“f1 ile f2 aynı değer mi?”, f1 is f2)

print(“f1 ile f3 aynı değer mi?”, f1 is f3)

komutları f1 ve f2’nin iki farklı nesneyi, f1 ve f3’ün ise aynı nesneye işaret ettiğini gösterir. Bu durumda f1 ve f3 örtüşmektedir.

Python “id” isimli bir; fonksiyonu vardır ve bu fonksiyon, her bir nesne için özel oluşturulmuş bir tam sayı değeri döndürür (Çoğu Python uygulamalarında bu değer programın nesneyi yerleştirdiği hafızanın başlangıç adresidir.). a ve b nesne ise bu nesnelerin eş değerliği aşağıdaki biçimde sorgulanır.

id(a) == id(b)

Nesnelerin örtüşüp örtüşmediğine bakılırken değişkenlerin türü önemli değildir. Tam sayı değeri olarak 3 her zaman 3’tür. Dizi olarak ‘‘Fred’’ kelimesi ‘‘Free’’ olarak değişemez. Kesir sınıfı örnekleri de bu şekilde değişkendir. Değişken nesneler için örtüşme önemli bir konu olabilir. Python’un Turtle grafik kütüphanesindeki nesneler değişkendir. Programcılar kaplumbağa nesnesini hareket ettirebilir ve yönünü ve çizim rengini değiştirebilirler. Her bir işlem kaplumbağanın durumunu değiştirir ve grafik pencere içinde kaplumbağanın çizim sürecini etkiler.


Nesneler konusu ile ilgili sunum dosyasına ve konu testine (yakında) aşağıdan ulaşabilirsiniz.

 

 

 

 

 

Bir cevap yazın

E-posta hesabınız yayımlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir