Python İle Programlamanın Temelleri-2

Mehmet ÇOLAK 4 Aralık 201724 Aralık 2017 0 Comments değerler, değişkenler

Değerler ve Değişkenler

1.Tam Sayı ve Diziler

Herhangi bir sayı, sayısal değerdir. Örneğin matematikte 4 sayısı tam sayı olarak ifade edilir. Tam sayılar pozitif, negatif ya da sıfır değeri alabilir. Kesirli değerleri içermez. Örneğin 99, 105, 0, -56 ve 7896 birer tam sayıdır. Ancak 4.5 bir tam sayı değildir. Python programlama dili, sayısal ve sözel ifade kullanımını destekler. Python programları, tam sayıları kullanarak işlem yapabilir. Örneğin;

print(4)

ifadesi 4 değerini ekrana yazdırır. İfadede tırnak (“) işareti kullanılmadığına dikkat ediniz. Python tam sayılar dışındaki diğer veri türlerini de desteklemektedir. Bu ifade Python satırlarının temel yapı taşıdır. Tek başına 4 sayısı bir anlam ifade etmez. Ancak yorumlayıcılar, bir anlatım olursa Python ifadelerini değerlendirir. Python etkileşimli yorumlayıcısı hem ifadeleri hem de anlatımları değerlendirir. Örneğin;

>>> 4

Komutu yazıldığında, yorumlayıcı satırı okur, işler ve sonucu 4 olarak ekrana yazdırır. x = 10 girilirse bu ifadenin sonuca yönelik bir anlamı olmadığı için etkileşimli yorumlayıcı ekrana hiçbir şey yazdırmaz. Eğer kullanıcı bu ifadeden sonra yalnızca “x” girerse yorumlayıcı bunu değerlendirir ve ekrana x değeri olan 10 sayısını yazar. Şayet kullanıcı bundan sonra ekrana “y” yazarsa, bu değer daha önce tanımlanmadığı için yorumlayıcı hata verir.

Python, toplama işlemi için toplama (+) sembolünü kullanır. Böylece yorumlayıcı bir hesap makinesi gibi işlem yapar.

>> 5 + 4
9

>> 1+6+4+10
21

>>> print(1 + 6 + 4 + 10)
21

Son satırda toplama işleminin, doğrudan print ifadesi içerisinde yer alabildiği de görülmektedir. Şimdi de aşağıdaki işleme bakalım:

>>> 16
16
>>> “16”
“16”
>>> ’16’
’16’

İlk satırda tam sayı olan 16 değeri tek ya da çift tırnak içine alındığında sayı olarak değil metin (alfasayısal kelime yani dizi) olarak işlem görmektedir. Bu ifadeler karakter dizisi ya da dizi olarak anılır. Python, dizileri ayırt etmek ve sınırları belirlemek için hem tek (‘) hem de çift tırnak (“) kullanımına izin vermektedir. Sınırları belirlemek demek, başlangıç ve bitiş noktalarını işaret etmek demektir. Kullanılan ilk ve soldaki sembol (‘) dizinin başlangıcını, sonra kullanılan ve sağda bulunan sembol (‘) ise dizinin bitişini ifade eder. Benzer biçimde çift tırnak sembolleri de (“) başlangıç ve bitiş için iki kez kullanılmalıdır.

İki sembol tek tırnak (‘) ve çift tırnak (“), birbiri yerine kullanılamaz. Bu nedenle;

>>> “ABC”
“ABC”
>>> “ABC”
“ABC”

ifadeleri hataya neden olur.

>> “ABC”
File “<stdin>”, line 1
“ABC”

–

SyntaxError: EOL while scanning string literal
>>> “ABC”
File “<stdin>”, line 1
“ABC”

İfade olarak 4 ve ‘4’ yazımının farklı anlamlar taşıdığına dikkat ediniz. İlk değer bir tam sayı iken, ikinci değer karakter olarak algılandığı için bir dizidir. Python içindeki tüm ifadelerin bir türü vardır. İfadenin türü anlatımın da türünü ifade eder. Bazen ifadelerin türü onların sınıfı olarak belirtilir.

Şu ana kadar yalnızca tam sayı ve dizileri inceledik. Gömülü bir fonksiyon, Python ifadelerinin türünü belirtmek için kullanılabilir.

>>> type(4)
<class “int”>
>>> type(“4”)
<class “str”>

Gömülü str fonksiyonu tam sayı olarak görülen bir ifadeden dizi oluşturur.

>>> str(4)
“4”
>>> “5”
“5”
>>> int(“5”)
5

str(4) ifadesi 4 değerini karakter olarak değerlendirir, int(‘5’) ifadesi ise bu karakter değeri tam sayıya dönüştürür.

>> int(4)
4

>>> str(“Python”)
“Python”

Tahmin edilebileceği gibi, bir programcı için bu dönüşümü yapmaya çoğunlukla gerek yoktur. Bu nedenle str ve int fonksiyonlarının kullanımı, değişkenler kullanılmadıkça çok anlamlı olmayacaktır. Herhangi bir tam sayı, dizi olarak ifade edilebilir, ancak her dizi bir tam sayı olarak ifade edilemez.

>>> str(1024)
“1024”
>>> int(“sus”)
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
ValueError: invalid literal for int() with base 10: “sus”
>>> int(“3.4”)
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
ValueError: invalid literal for int() with base 10: “3.4

Görüldüğü gibi ne sus ne de 3.4, Python için geçerli bir tam sayıdır. Özetlemek gerekirse eğer dizi içerisinde sayısal ifade varsa int fonksiyonu kullanılarak bu, kolayca tam sayıya çevrilir. Bu arada toplama amacıyla kullanılan + sembolü diziler için farklı biçimde çalışır.

>>> 5 + 10
15
>>> “5” + “10”
“510”
>>> “abc” + “xyz”
“abcxyz”

Görüldüğü gibi sayı değerleri için toplama işlemi yapan + sembolü, diziler için birleştirme işlemi gerçekleştirir. Bu iki farklı tanımı aynı satırda bulundurmak hataya neden olur.

>>> “5” + 10
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
TypeError: Can”t convert “int” object to str implicitly
>>> 5 + “10”
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
TypeError: unsupported operand type(s) for +: “int” and “str”

Ancak int ve str fonksiyonları ile desteklenirse doğru sonuca ulaşılır.

>> 5 + int(“10”)

15
>>> “5” + str(10)
“510”

Python için type fonksiyonu karmaşık ifadeler için kullanılabilir.

>>> type(4)
<class “int”>
>>> type(“4”)
<class “str”>
>>> type(4 + 7)
<class “int”>
>>> type(“4” + “7”)
<class “str”>
>>> type(int(“3”) + int(4))
<class “int”>

Python kapsamında sayıları ifade ederken “,” ya da “.” gibi ayırma sembolleri kullanılmaz. Dört bin altı yüz elli sekiz, 4658 olarak yazılmalıdır.

2.Değişkenler ve Atama

Değişkenler, değerleri korumak için kullanılır. Bu değerler sayı, dizi gibi farklı biçimlerde olabilir. Örneğin;

x = 10

ifadesi bir atama satırıdır. Atama işlemi bir değeri bir değişken ile eşleştirir. Bu ifadedeki en önemli ayrıntı, atama (=) sembolüdür. Bu ifade ile 10 değeri, x değişkenine atanmaktadır. Bu noktada, x değişkeninin türü tam sayı olur çünkü atanan değer bir tam sayı değerdir. Bir değişkene birden fazla kez atama yapılabilir. Eğer bu sırada öncekinden farklı türdeki bir değer ataması yapılırsa değişkenin türü de değişir. Burada atama (=) sembolünün anlamı matematikte kullanıldığı şeklinden daha farklıdır. Matematikte bu sembol, eşitlik sağlar, bu yüzden bu sembolün sağ ve sol tarafında yer alan ifadelerin birbirine eşit olduğu anlamına gelir. Python dilinde ise atama (=) sembolünün sol tarafında yer alan ifade, sağ taraftaki ifadeyi üstlenir. Bu yüzden bu ifadeyi “5 değeri x değişkenine atandı.” ya da x’e 5 atandı.” şeklinde yorumlamak doğru olacaktır. Buradaki kullanım, matematikteki kullanımdan farklı olduğu için önemlidir. Matematikte eşitlik ve eşitliğin her iki yanında simetri söz konusudur yani matematiksel açıdan x = 5 ve 5 = x olacak biçimde her iki ifadede doğru iken Python kapsamında bu, simetri olmadığı için 5 = x ifadesi hatalı olacaktır. Çünkü tam sayı bir değişken olmadığı için atama yapma davranışı da yanlıştır.

Bir değişkene defalarca farklı değerler atayabiliriz.

x = 10
print(x)
x = 20
print(x)
x = 30
print(x)

Görüldüğü gibi print fonksiyonu her satırda aynı olmasına rağmen her seferinde farklı bir değer yazdırılmaktadır.

10
20
30

Bu program bize, değişkenlere bağlı durumlardaki davranışları her zaman öngörmediğimizi göstermektedir. Bazı fonksiyonlar bir ya da daha fazla değişkene bağımlı hareket edebilir.

x = 10
print(“x = ” + str(x))
x = 20
print(“x = ” + str(x))
x = 30
print(“x = ” + str(x))

Yukarıdaki program aşağıdaki çıktıyı oluşturur.

x = 10
x = 20
x = 30

Burada print fonksiyonu içerisinde kullanılan toplama + işlemi dizileri birleştirmek amacıyla kullanılmaktadır. Bu nedenle “x =” + x ifadesi çıktıda görülen sonucu üretmektedir. Bu örnekte print fonksiyonu, iki parametre kabul etmektedir.

print(“x =”, x)

İlk parametre “x =” dizisi ve ikinci parametre ise x değişkeni ile eşleşmiş değerdir. Print fonksiyonu her biri virgül ile ayrılmış çoklu parametre kullanımına izin verir, hepsini sıra ile yazdırır ve yazdırırken her biri arasına bir boşluk değeri bırakır. Bir programcı tek bir satırda çok ögeli yaklaşımı kullanarak birden fazla değer ataması yapabilir. Bu işleme çoklu atama denilir.

x, y, z = 100, -45, 0
print(“x =”, x, ” y =”, y, ” z =”, z)

Çoklu atamada değerler virgüller ile ayrılmış olarak listelenir. x, y, z = 100, -45, 0 ifadesinde x, y, z bir grup çoklu ögeyi; 100, -45, 0 ise diğer grup çoklu ögeyi ifade eder. Çoklu atama şu şekilde çalışır: Sol taraftaki çoklu öge grubundaki ilk değişken, sağ taraftaki çoklu öge grubunun ilk elemanı ile eşleşir (x = 100). Benzer şekilde ikinci ve sonraki ögeler de birbiri ile eşleşir. İkinci ögelerin eşleşmesi, y = -45 ve son ögelerin eşleşmesi, z = 0 ile sonuçlanır. Bu işlemden sonraki durum aşağıdaki gibidir:

x = 100 y = -45 z = 0

Çoklu atama, sol taraftaki çoklu öge grubu ile sağ taraftaki çoklu öge grubunun sayıları eşit ise gerçekleşir. Atanan değer bir değişken ismini bir nesneye bağlar.

Örnek olarak x = 2 ifadesini inceleyelim (Şekil 2.6). Bir kutu değişkeni ifade eder ve bu, değişken ismi ile adlandırılır. Diğeri kutudan nesneye doğru yönelen ok, değişkenin bağlandığı nesneyi gösterir. Bu durumda ok 2 değerini içeren başka bir kutuyu işaret eder. İkinci kutu 2 değerinin ikilik düzendeki karşılığını içeren hafıza yerini temsil eder. Bilgisayar her bir program satırını işledikçe değişkenlerin değerlerinin nasıl değiştiğini gözleyelim.

Burada özellikle x = y ifadesine dikkat ediniz. Bu atama hem x hem de y değerinin aynı değer ile eşleştiği anlamına gelmektedir. Sonra y değerinin değişmesi x değerini etkilemez.

Programın çalışması sırasında bir değişkenin yalnızca değeri değil, türü de değişebilir.

a = 10
print(“a değişkeninin ilk değeri”, a, “ve tipi”, type(a))
a = “ABC”
print(“a değişkeninin yeni değeri”, a, “ve tipi”, type(a))

Bu ifade aşağıdaki çıktıyı oluşturur.

a değişkeninin ilk değeri 10 ve tipi <class “int”>
a değişkeninin yeni değeri ABC ve tipi <class “str”>

Programcılar program akışı içinde bir değişkenin türünü nadiren değiştirmeye gerek duyarlar. Bir değişkenin program çalıştığı sürece belli bir anlamı ve rolü olmalıdır ki bu, genellikle değişmez. Herhangi bir değer atanmamış bir değişken, tanımsız değişken olarak ifade edilir. Böyle bir değişken program içerisinde kullanıldığında hata ile karşılaşılır. Nadiren daha önce tanımlanmış bir değişkeni tanımsız bir değişkene dönüştürmek isteriz. Bu işlemi del satırını kullanarak gerçekleştiririz.

Kullanılan del komutu sil anlamına gelir ve yorumlayıcı, içerisinden ya da program içerisinden değişken tanımını siler. Örneğin a, b ve c önceden tanımlanmış değişkenler ise;

del a, b, c

ifadesi bütün değişkenlerin silinmesini sağlar.

3.Reel Sayılar

Pek çok hesaplamalı işlem, kesir parçası olan sayıları kullanır. Örneğin bir dairenin çevresini ya da alanını hesaplamak için π değerine ihtiyacımız vardır ve bu değer yaklaşık 3,14159 olarak ifade edilir. Python, bu şekilde noktalı sayılarla işlem yapar ve bu sayılara reel ya da gerçek sayı denir. İsminden de anlaşılacağı gibi matematiksel hesaplamalar sırasında ondalık nokta, önemli sayıları ifade etmek için farklı basamaklara kayabilir. Python ile programlama yaparken bu tanımı yapmak için float kelimesi kullanılır.

>>> x = 5.62
>>> x
5.62
>>> type(x)
<class “float”>

Python için reel sayıların alabileceği en küçük ve en büyük değer ile duyarlılık düzeyi, kullanılan makine ve uygulamaya göre değişiklik gösterebilir. Reel sayılar da tam sayılar gibi pozitif ve negatif olabilir. Yaygın olarak geçerli olan durum aşağıda görülmektedir.

Çoğu programlama editörü, alt ya da üst simge ve özel sembollerin kullanımını desteklemediği için sayıların gösterimi farklılaşmaktadır. Python ile kod yazarken 6.022 x 1023 yerine 6.022e23 olarak yazmamız gerekir. Burada “e” karakterinin solunda kalan kısım normal sayı; sağında kalan kısım ise 10 üzerindeki sayıdır. Simge olarak “e” yerine “E” de kullanılabilir. Reel sayılardan farklı olarak tam sayılar kesirli ifadeleri içeremez.

Reel bir sayıyı bir tam sayıya dönüştürmenin iki temel yolu vardır:

Yuvarlama: Reel sayıya en yakın tam sayıya ulaşmak için kesrin belirli bir miktarı eklenerek ya da çıkarılarak yuvarlama yapılır.

Kesme: Sayının kesirli kısmı tamamen göz ardı edilir.

Yuvarlama ve kesme işlemlerinin sonuçlarının ne şekilde farklılaştığını gözlemleyebiliriz:

>>> 28.71
28.71
>>> int(28.71)
28
>>> round(28.71)
29
>>> round(19.47)
19
>>> int(19.47)
19

Görüldüğü gibi kesme, her zaman aşağı doğru yuvarlamaktadır. Yuvarlama yapmak için round fonksiyonunu noktadan sonra belirli bir sayıda basamağı koruyarak sonuç elde etmek için de kullanabiliriz.

>>> x = 93.34836
>>> x
93.34836
>>> round(x)
93
>>> round(x, 2)
93.35
>>> round(x, 3)
93.348
>>> round(x, 0)
93.0
>>> round(x, 1)
93.3
>>> type(round(x))
<class “int”>
>>> type(round(x, 1))
<class “float”>
>>> type(round(x, 0))
<class “float”>

Görüldüğü gibi tek argüman tam sayı sonucu verirken iki argüman reel sayı sonucu vermektedir. Kullanılan ikinci argüman negatif bir değerde olabilir: round(n, r) ifadesi n sayısını 10-r ile çarpma işlemini yapar. Örneğin round(n, -2) n sayısını 10-2 ile çarpmaktadır.

>> x = 28793.54836
>>> round(x)
28794

>>> round(x, 1)
28793.5
>>> round(x, 2)
28793.55
>>> round(x, 0)
28794.0
>>> round(x, 1)
28793.5
>>> round(x, -1)
28790.0
>>> round(x, -2)
28800.0
>>> round(x, -3)
29000.0

Python için round fonksiyonu tam sayılar için de kullanılabilir. Burada ilk argüman tam sayı, ikinci argüman ise yuvarlama için sola doğru kayması beklenen basamak sayısını ifade eder. İkinci değer pozitif bir değerse sayının orijinal değeri elde edilir. Her durumda sonuç her zaman tam sayıdır.

>>> round(65535)
65535
>>> round(65535, 0)
65535
>>> round(65535, 1)
65535
>>> round(65535, 2)
65535
>>> round(65535, -1)
65540
>>> round(65535, -2)
65500
>>> round(65535, -3)
66000
>>> round(65535, -4)
70000
>>> round(65535, -5)
100000
>>> round(65535, -6)
0

4.Belirteçler

Matematik işlemlerinde genellikle x ve y tek karakterden oluşan değişkenler için kullanılır. Programcıların bundan kaçınarak çok daha uzun, anlamlı ve açıklayıcı değişken isimleri seçmesi gerekir. Bu nedenle t, at, y ve s gibi isimler yerine, toplam, araToplam, yükseklik ve süre gibi içeriğindeki değeri ifade eden değişken isimleri kullanmak çok daha etkilidir. Değişken ismi program içerisindeki kullanım amacına uygun olmalıdır. Değişken isimleri ne kadar doğru seçilirse program okuyan kişiler için o kadar çabuk anlaşılır ve anlamlı olur. Python, büyük küçük harf duyarlıdır ve değişken isimleri için kesin kurallar kullanır. Bir değişken ismi belirteç için bir örnektir. Belirteç, ögeleri isimlendirmek için kullanılan kelimedir. Belirteçler fonksiyon, sınıf ve metot gibi parçaları isimlendirmek için de kullanılır.

Belirteçlerin özellikleri şöyle sıralanabilir:

Bir belirteç en az bir karakter içermelidir.

Belirtecin ilk karakteri harf (küçük ya da büyük) ya da alt çizgi olmalıdır (ABCDEFGHIJKLMNOPQRSTUV W XYZabcdefghijklmnopqrstuvwxyz_).

Devam eden karakterler, harf (küçük ya da büyük), alt çizgi ya da sayı olabilir (ABCDEFGHIJKLMNOPQRSTUV W XYZabcdefghijklmnopqrstuvwxyz_0123456789).

Belirteçlerde boşluk dâhil diğer özel karakterler kullanılamaz.

Programlama diline ait ayrılmış kelimeler belirteç olarak kullanılamaz (Reserved Words).

Son olarak print, int, str ya da type gibi özel kelimeler kullanılabilmesine rağmen iyi bir program için bunlar asla önerilmez.

Türkçe karakterler kullanılamaz.