Doç. Dr. Özgür Baştürk
Ankara Üniversitesi, Astronomi ve Uzay Bilimleri Bölümü
obasturk at ankara.edu.tr
http://ozgur.astrotux.org
Newton Hareket Kanunları'ndan yararlanarak matematiksel ifadesini bulan bu problemin çözümü, yer çekimine zıt yönde atılan bir cismin düşey konumunun (y) zamana (t) bağlı olarak değişimini aşağdaki formülle verir.
Burada $V_{0}$ cismin ilk hızını, $g$ yerçekimi ivmesini $y = 0$ konumu cismin $t = 0$ anındaki konumunu göstermektedir. Cismin tekrar başlangıç konumuna dönmesi için geçen süreyi hesaplamak üzere
olduğu düşünülecek olursa $t \in[0, \frac{2V_{0}}{g}]$ olur.
Dikey atış probleminde cismin herhangi bir $t$ anındaki düşey konumunu hesaplayan bir Python programı yazmak istiyor olalım. Programımızı $V_{0}$, $t$ ve $g$'nin farklı değerleri için çalıştırmak programımız üzerinde sürekli değişiklik yapmamız gerekecek. Tüm programlama dillerinde olduğu gibi Python'da da değişkenler kulllanarak bu sorunu aşabiliriz.
v0 = 5 # Ilk hiz m/s
t = 0.6 # zaman s
g = 9.81 # yercekimi ivmesi m/s**2
y = v0*t - 0.5*g*t**2
print(y)
Şimdi programımızı $V_{0}$, $t$ ya da $g$'nin farklı değerleri için çalıştırmamız çok kolay. Örnek olarak $V_{0} = 1 m/s$ ve $t = 0.1 s$ için alınan toplam yolu tekrar hesaplayalım.
v0 = 1 # Ilk hiz
t = 0.1 # zaman
y = v0*t - 0.5*g*t**2
print(y)
! g'yi tekrar yazmadığımıza ancak y'yi veren ifadeyi tekrar yazdığımıza dikkat ediniz!
Ayni anda birden fazla degiskeni tek satirda tanimlayabilirsiniz.
x = y = 3 # hem x'e hem y'ye 3 degerini ata
print(x,y)
y = 5
print(x,y) # y degistiginde x'in degismedigine dikkat ediniz
a, b, c = 3.14, 'AST415', 8 # ayni anda birden fazla degisken tek satirda
print(a)
print(b)
print(c)
#a, b, c = 3.14, 'AST415 Astronomide Sayisal Cozumleme', 8, True #degisken sayisi ile deger
#print(c)
#a, b, c = 3.14, 'AST415 Astronomide Sayisal Cozumleme' #sayisinin esit olmadigina dikkat
#print(a)
Bu derste yapılan en klasik hata, değişken isimleri içerisinde Türkçe karakterler kullanmaktır. Bu dersin ödevleri için yazdığınız kodlar çalışmasa da değerlendirmeye alınacaktır. Türkçe karakter kullanma hatasından kurtulabilmeniz amacıyla ödevlerde kullandığınız (ve bizim de yakaladığımız!) her Türkçe karakter için 2 puanınızı istikrarlı bir şekilde kıracağız! Yine de bilgisayarınızın sistemine ve jupyter defterinizin başına #UTF-8 kodunu ekleyip eklemedğinize bağlı olarak Türkçe karakterler kullanılan değişken isimlendirmelerinin de çalışma ihtimali bulunmaktadır.
başlangıç_hızı = 5
print(başlangıç_hızı)
Aşağıdaki değişken isimlendirmelerinin doğruluğunu kontrol ediniz.
Programlarınıza kendiniz ve kodunuzu okuyan başkaları (örn. BİZLER!) için yorum satırları koymanız çok yararlıdır. Bunun için Python tarafından çalıştırılmasını istemediğiniz ifadelerin başına “#” işaretini koymanız yeterlidir.
# havaya dogru bir ilk hizla atilan cismin t anindaki
# yuksekligini hesaplayan program
v0 = 5 # ilk hiz
g = 9.81 # yercekimi ivmesi
t = 0.6 # zaman
y = v0*t - 0.5*g*t**2 # dusey konum
print y
Zaten açıklayıcı değişken isimleri kullandıysanız aynı kelimeleri kullanarak bir de yorum eklemeye gerek yoktur. Aynı şeyi iki kere yapmamak iyi bir programcı alışkanlığıdır!
Düşey atış problemi çözen basit programımızın çıktısını sadece alınan toplam yolu rakamsal olarak vermek yerine daha açıklayıcı bir şekilde; örneğin, “t = 0.6 saniyede cismin yuksekligi 1.23 metredir.” gibi bir cümleyle vermek isteyebiliriz. Python programlama dilinde metin formatlamak için sık başvurulan bir yöntem (C programlama dilindeki printf fonksiyonundan miras alındığı şekliyle) yer tutuculara başvurmaktır. Ekrana yazdırılacak metin ifadesi içerisinde bir değişkenin değerinin yer almasının istendiği yere % işareti ile bir yer tutucu konur. Değişkenin değerinin hangi formatta (tam sayılar için d, metinler için s gibi...) yazdırılmasının hedeflendiği bu % işaretinden sonra belirtilir. % işareti ile başlayan bu ifade yer tutucu (ing. placeholder) olarak bilinir. Yer tutucu bir değişkenin metin ifadesi içerisinde yerini tutar. Değişkenin değeri bu ifadenin yerine gelir. Değişkenin ne olduğu ise metin ifadesi tamamlandıktan sonra % işaretini takiben parantez içinde verilir. Tek bir değişkenin yeri tutulduğunda parantez kullanılması bir zorunluluk değildir. Birden fazla değişkenin metnin farklı noktalarında yerleri tutulabilir. Bu değişkenler metnin sonunda parantez içinde aralarına virgül konarak birbirinden ayrılır. Yer tutucular sadece değişkenlerin değil pek çok türden nesne ve değerin de (metin sonrasında ne olduklarının verilmesi kaydıyla) yerini tutabilirler.
Sonuç olarak dikine atış programımızı istenen çıktıyı verecek şekilde aşağıdaki gibi düzenleyebiliriz.
# havaya bir ilk hizla atilan cismin t anindaki
# yuksekligini hesaplayan program
v0 = 5 # ilk hiz
g = 9.81 # yercekimi ivmesi
t = 0.6 # zaman
y = v0*t - 0.5*g*t**2 # cismin dusey konumu
# dusey konum
print("t = %g saniyede cismin yuksekligi %.2f metredir" % (t,y))
# buradan sonrasi 10 Ekim 2018 tarihli dersten
# degisken yerine tum ifadeyi de %'den sonra koyabiliriz
print("t = %g saniyede cismin yuksekligi %.4f metredir" % \
(t,v0*t - 0.5*g*t**2))
# t'yi 0.595 yapip sayinin nasil yuvarlandigini gorelim
t = 0.595
print("t = %g saniyede cismin yuksekligi %.2f metredir" % \
(t,v0*t - 0.5*g*t**2))
# Tek bir yer tutucu kullanildigi zaman paranteze alma zorunlulugu yoktur
# t'yi degistirdigimize ama y'yi degistirmedigimize dikkat ediniz
print("Cismin yuksekligi %.4f metredir" % y)
# Metnin sonuna basit bir syntax'la nesne degeri yazdirabilirsiniz
print('y = ', y)
Aşağıda en sık kullanılan bazı "YER TUTUCULARI" görüyorsunuz:
%s : Metin değişkenler için yer tutucu
%d : Tamsayı değişkenler için yer tutucu
%0xd : Önüne getirilen “0” rakamları ile birlikte x basamak yer kaplayacak tam sayı yer tutucusu
%f : Noktadan sonra 6 basamak kaplayacak şekilde yazılmak istenen noktalı sayı yer tutucusu
%e : Kompakt bilimsel gösterim yer tutucusu
%E : Kompakt bilimsel gösterim yer tutucusu (üssü belirtmek üzere e yerine E kullanılır)
%g : Reel bir sayı için olası en kompakt yazımı veren yer tutucu
%G : %g ile aynı sadece üs gerektiğinde belirtmek üzere e yerine E kullanılır
%x : Bir tam sayı nesnesini (int) metne (string) dönüştürüp onaltılık (hexadecimal) sistemde göstermek için kullanılır
%% : yüzde (%) işaretini yazdırmak gerektiğinde kullanılır
Bazı formatları denemek üzere ilk programımızı kullanalım. Birden çok satır süren metinler için """ işaretinin kullanıldığına dikkat ediniz.
v0 = 5
g = 9.81
t = 0.6
y = v0*t - 0.5*g*t**2
print("""
v0=%.3E m/s ilk hizla firlatilan cismin
t=%f saniyedeki yuksekligi
%.2f metredir.
""" % (v0, t, y))
Yine dikey atış problemi çözen basit programımızın çıktısını sadece alınan toplam yolu rakamsal olarak vermek yerine daha açıklayıcı bir şekilde; örneğin, "t = 0.6 saniyede cismin yuksekligi 1.23 metredir." gibi bir cümleyle verelim. Ancak bu kez printf fonksiyonalitesi yerine daha modern bir yöntem olan str.format yöntemini kullanalım. Tıpkı printf yönteminde olduğu gibi daha modern olan bu yöntemde de yer tutuculara (ing. placeholder) başvurulmaktadır. Ancak bu kez % işareti yerine { } işaretleri kullanılır. Metinde yeri tutulan nesneler metnin sonunda, bir metin nesnesi fonksiyonu (attribute) olan format fonksiyonu içinde sıralanır.
Bu yöntemle değişkenlerin konumlarını metin içinden bildirmek mümkün olduğu için, en sonda format fonksiyonunun içinde yeri tutulan değişkenlerin doğru sırada verilmesi de bir zorunluluk olmaktan çıkar.
print("t = {1:g} saniyede cismin yuksekligi {0:.2f} metredir.".format(y,t))
# siralamayi printf yonteminde oldugu gibi de kullanabiliriz
print("t = {:g} saniyede cismin yuksekligi {:.2f} metredir.".format(t,y))
Bu yöntemde herhangi bir metni hizalamak için "-" ve "+" işaretleri yerine "<" ve ">" işaretleri kullanılır.
print('%-10s' % ('test')) # printf stili
print('{:<10s}'.format('test')) # str.format yontemi
print('%10s' % ('test'))
print('{:>10s}'.format('test'))
Bu yöntemle eski printf yöntemine göre metin hizalama ve yazdırma üzerinde daha çok kontrol sahibi olmak mümkün hale getirilmiştir.
print('{:_<10s}'.format('test'))
print('{:^10s}'.format('test'))
print('{:06.2f}'.format(3.141592653589793))
print('{: d}'.format((- 23)))
print('{:+d}'.format(42))
print('{:=+8d}'.format((18)))
Yer tutucular bu formatla isimlendirilebilir ve adlarıyla atıfta bulunularak kullanılabilir.
print('{birinci} {ikinci}'.format(birinci='Ad', ikinci='Soyad'))
print('{birinci} {ikinci}'.format(ikinci='Soyad', birinci='Ad'))
Bu yöntemle ayrıca format parametreleri parametrik şekilde de kullanılabilir.
print('{:{hiza}{genislik}}'.format('test', hiza='^', genislik='10'))
print('{} = {:.{hassasiyet}f}'.format('Sayi ', 2.7182, hassasiyet=2))
print('{:{genislik}.{hassasiyet}f}'.format(3.14159, genislik=8, hassasiyet=2))
print('{:{}{}{}.{}}'.format(2.7182818284, '>', '+', 10, 3))
print('{:{}{isaret}{}.{}}'.format(2.7182818284, '>', 10, 3, isaret='+'))
Python 3.6'dan itibaren metin formatlama için daha esnek bir yapıya sahip metin interpolasyonu (string interpolation) ya da f-strings adı verilen bir yöntem de tanıtılmıştır. Ayrıca string modülü fonksiyonları da metin formatlamak için çeşitli olanaklar sunar ancak bu yöntemler bu dersin kapsamı dışında tutulmuştur. Merak edenler Real Python'dan https://realpython.com/python-string-formatting/ daha fazla bilgi edinebilirler.
Python'a 3.6 versiyonu sonrası eklenen f-string yapısı string formatlamayı daha da kolaylaştırmıştır. Kullanılacağı metnin başına $f$ harfini yazıp str.format yapısında kullanılan syntax'a benzer biçimde ${ }$ işaretleri kullanılarak formatlama yapılır.
print(f"t = {t} saniyede cismin yuksekligi {y} metredir.")
f-string'leri kodla aynı anda çalıştırıldığı için içlerindeki herhangi bir hesap da eş zamanlı yapılacağından esneklik sağlar.
f"{2 * 37}"
f-stringler hakkında daha geniş bilgi, esnekliği Python hakkında daha derin bilgi gerektirdiğinden, metin değişikenlerin işlendiği 8. bölümde verilecektir.
Python'da matematiksel işlemler, bu işlemlerde karşılaşılan bazı problemler ve işlem sırası gibi konuları santigrat derece – fahrenheit dönüşümü örneği üzerinden tartışalım.
Bu problemi C = 21° için basit bir Python koduyla çözmeye çalışalım.
C = 56
F = (9 / 5)*C + 32
print(F)
Tam sayı bölmesinin davranış şekli Python 2.x versiyonunda (ve Java gibi pek çok başka programlama dilinde) farklıdır. Yukarıdaki örnek Python 2.x'de 53 (9 / 5 = 1 --> 1 * 21 = 21 --> 21 + 32 = 53) tam sayı sonucunu verir. Python 2.x C = 21 ifadesiyle; 21 bir tam sayı olduğu için, bir tam sayı (int) nesnesi oluşturur ve bu nesnenin adı da C olarak belirlenmiş olur. Benzer şekilde C = 21.0 şeklinde bir atama yapılmış olsaydı bir kayan sayı (float) nesnesi oluşturulmuş ve bu nesnenin adı C olarak belirlenmiş olacaktı (21 ≠ 21.0). Python 3.x ise kullanıcıya, sonucun her zaman bir kayan sayı olduğu gerçek bölme yapma olanağı sağlar.
Python 3.x ile birlikte, bölünen sayıların türünden (tam sayı ya da değil) bağımsız olarak, sonucun noktadan sonraki basamaklarının kesilip atıldığı (yuvarlama (rounding) değil kesme (truncation)) yeni bir bölme operatorü ( // ) sağlanmıştır. Bu operatörün sonucu eğer bölünen sayılar birer tam sayı ise bir tam sayıdır (integer). Böylece Python 2.x2'deki tam sayı bölme fonksiyonalitesi // (floor division) operatörü ile devam ettirilmiştir. Eğer bölünen sayılardan en az biri kayan sayı ise sonuç kayan sayı (float) cinsinden ve yine noktadan sonraki basamakları kesilerek verilir.
x = 9//5
print(x), print(type(x))
y = 9.//5
print(y)
print(type(y))
“Bir Python programı yazmak, nesneler oluşturmak ve bu nesnelerin değerlerini değiştirmektir”
Aslında matematikte olduğundan çok farklı değil. Üs işareti (**) 'nin çarpma (*) ve bölmeye (\/) önceliği var. Sonra toplama (+) ve çıkarma (-) geliyor ve parantez içi ifadeler her zaman daha büyük öncelik taşıyor.
Örnek 1
Örnek 2
Şimdi bu işlemleri Python ile yapalım.
# Ornek 1
print(4 / 8 + 2*3**4/9)
# Ornek 2
print(4/(6+2) + 2*4**(4/8))
Python'da aritmetik operatörlerin sırasını anlamak temel düzeyde matematik bilen herkes için oldukça kolaydır. Matematik derslerinde öğrendiğiniz temel bilgiyi referans almanız yeterli olacaktır.
Python'da standart matematiksel fonksiyonların nasıl çalıştığını anlamak için dikey atış probleminde cismin t anındaki yüksekliği (y) yerine, herhangi bir yüksekliğe ne kadar zamanda çıkacağını bulma probleminden hareket edelim.
Bu amaçla
ikinci derece denklemini çözmemiz gerekir. Bu denklemin çözümü
sonucunu verir (iki sonuç vardır zira cisim bu yüksekliğe biri yükselirken, diğeri inerken olmak üzere iki kez ulaşır!). Bu işlemi Python ile gerçekleştirmek için karekök (sqrt) fonksiyonuna ihtiyaç duyacağımız açıktır.
Python'da standart fonksiyonları (built-in functions) kullanmak için bir şey yapmanıza gerek yoktur. Daha önce örneklerini gördüğünüz $ print$ fonksiyonu böyle fonksiyonlardandır. Değişken türü değiştirmeye olanak sağlayan $ str$, $ int$ ve $ float$ gibi fonksiyonlar da böyledir.
# Standart (built-in) Python Fonksiyonu Ornekleri
print("Merhaba Dunya!")
x = 5
print(x, type(x))
x = str(x)
print(x, type(x))
x = float(x)
print(x, type(x))
Karekök gibi trigonometrik, logaritmik, üstel, hiperbolik fonksiyonların da aralarında bulunduğu pek çok matematiksel ifadenin nasıl hesaplanacağı uzun yıllar sonucunda oluşturulmuş algoritmalarla saptanmış ve pek çok programcı bu algoritmalara dayanan fonksiyonlar hazırlamışlardır.
Python'da modül benzer nitelikte işler yapan fonksiyonların bir araya toplandığı programlara denir. Örneğin math modülünde pek çok matemtaik fonksiyonu bulunmaktadır. astropy modülünde ise astronomi hesapları için gerekli (Julyen günü dönüşümü, ufuk yüksekliği hesabı gibi...) pek çok fonksiyon bulunur.
Bir modüldeki fonksiyonları kullanabilmek için öncelikle onu çağırmak (import etmek) gereklidir. Bu işlem en basit şekliyle
ifadesiyle yapılır.
Daha sonra bu modüldeki fonksiyon (örneğin karekök fonksiyonu sqrt) modul_adi.fonksiyon(arguman) şeklinde kullanılır. (örneğin math.sqrt(5) math modülünden karekök fonskiyonunu çağırır ve karekök 5 değerini hesaplar!)
Örnek olarak düşey atış probleminde bir ilk hızla yukarı doğru atılan bir cismin herhangi bir yükseklikten hangi zamanlarda geçtğini bulmak için aşağıdaki şekilde bir Python kodu yazmamız gerekir.
# Dikey atis problemi, cismin verilen bir yukseklikten (y)
# gectigi zamanlarin (t1 ve t2) bulunmasi
v0 = 5 # m/s
g = 9.81 # m/s^2
yc = 0.2 # m
import math
t1 = (v0 - math.sqrt(v0**2 - 2*g*yc))/g
t2 = (v0 + math.sqrt(v0**2 - 2*g*yc))/g
print('t={:g} saniye ve {:g} saniyede cismin yuksekligi {:g} metredir'.\
format(t1, t2, yc))
from math import sqrt,sin,exp,log,e,sin,pi
print(sqrt(2))
print("sin (90) = {:g}".format(sin(0.5*pi)))
print("ln(e^2) = {:g}".format(log(e**2,e)))
print("e^5 = {:g}".format(exp(5)))
print(log(sin(pi/2.),10))
Bu şekilde bir modüldeki tüm fonksiyonları from modul_adi import * ifadesiyle de çağrımak mümkündür.
from modül_adi import … ifadesini kullanmanın sakıncası fonksiyonun adını doğrudan kullanmaktan gelir. Python'un büyük bir gücü olan, pek çok programcı / bilim insanı tarafından modüllerin yazılıyor olması, burada bir dezavantaja dönüşür. Zira farklı modüllerde aynı isimle ve farklı işler yapan ya da bir şekilde farklı davranan fonksiyonlar olabilir. Kodun içerisinden her iki modülün birden çağrılması bu durumda problem haline gelebilir. Hatta bazen çağrılan bir modülde yer alan (ve çoğu zaman farkında olunmayan) bir fonksiyonla kullanıcının kendi yazdığı bir fonksiyonun da adı aynı olabilir.
Bu probleme biraz yakından bakalım:
import math ifadesi math modülü fonksiyonlarını math isim uzayına (namespace) indirir. Bu nedenle o isim uzayıındaki bir fonksiyonu çağırmak istediğinizde modül adını kullanmanız gerekir: math.sqrt(x) gibi..
from math import \* ifadesi math modülündeki tüm fonksiyonları (ya da * yerine fonksiyonun adını yazarsanız o fonksiyonu) sizin kullandığınız isim uzayına (namespace) indirir. Bu uzayı siz kullanıyor olduğunuz için fonksiyon çağırırken sadece adını kullanırsınız: sqrt(x) gibi...
Aslında burada “pythonik” bir yol tam olarak tanımlı değildir. Bazen birini bazen diğerini kullanırsınız. from modul import fonksiyon yapısı uzun kodlarda değil de kabukta küçük işlevsel betikler (script) yazarken daha çok tercih edilir.
İyi bir çözüm: import numpy as np ya da from math import log as ln gibi ifadelerle lakap (alias) kullanmaktır. Bu durum, fonksiyonların bulunduğu isim uzayına kısa ve kendinizin (ve iç dokümantasyon tutuyorsanız kodunuzu okuyan kişinin) bildiği bir isim verdiğiniz için kullanım kolaylığı getirir.
import math as m
yaricap = 10
cevre = 2*m.pi*yaricap
alan = m.pi*yaricap**2
print("Yaricapi {:d} olan cemberin cevresi {:g}".format(yaricap,cevre))
print("Alani ise {:g} 'dir".format(alan))
Matematiksel olarak sinüs hiperbolik fonksiyonu (sin h)
şeklinde tanımlanır. Şimdi x = 2$\pi$ için sinh(x) 'i farklı şekillerde hesaplayalım.
from math import sinh, exp, e, pi
x = 2*pi
r1 = sinh(x)
r2 = 0.5*(exp(x) - exp(-x))
r3 = 0.5*(e**x - e**(-x))
print("{:.8f} {:.8f} {:.8f}".format(r1,r2,r3))
print("{:.16f} {:.16f} {:.16f}".format(r1,r2,r3))
İşte bu ilginç! Matematiksel olarak eşit olduğunu bildiğimiz üç ifadeden sonuncusu 12. basamaktan sonra diğerlerinden farklılaşan bir sonuç verdi!
Bir başka örneğe bakalım. Aşağıdaki iki ifadenin aynı sonucu vermesi gerek:
print(1./49.*49.)
print(1./51.*51.)
Problem reel sayıların bilgisayarlarca saklanma ve gösterilme şeklinden kaynaklanmaktadır. AST416 Astronomide Sayısal Çözümleme - II dersinde ayrıntılı bir şekilde görebileceiğniz gibi bilgisayarlar sınırlı (genellikle 32) sayıda basamakla reel sayıları saklarlar. Oysa 1/49'u tam olarak ifade etmek için SONSUZ sayıda basamağa ihtiyacınız vardır.
Problemimizde 1/49. tam olarak saklanamıyor ve sonuç 1'den farklı çıkıyor. Aslında durum 1/51. için de aynı ama çıkan sayıyı 51. ile tekrar çarptığımızda yine 1'e ulaşıyoruz. Yani hata final değere kadar yayılmıyor!
$round(n, ndigits)$ fonksiyonu Python'un kendi fonksiyonlarından (ing. built-in) bir olup, $n$ ve $ndigits$ adında iki argümanı bulunmaktadır. Bu argümanlardan $n$ yuvarlanması istenen sayıyı, $ndigits$ ise bu sayının kaç basamağı yuvarlanmasının istendiğini round() fonksiyonuna geçirmek için kullanılır. $ndigits$ argümanının varsayılan değeri sıfır olduğundan, sağlanmaması durumunda verilen $n$ sayısı bir tamsayıya yuvarlanır.
print(round(3.1415926535, 2)) # iki basamaga yuvarlama
print(round(3.1415926535)) # tam sayiya yuvarlama
round() fonksiyonunun nasıl çalıştığını anlamak başlangıçta görece kolaydır. Yuvarlanılması istenen ve $ndigits$ opsiyonuyla verilen basamaktan sonraki basamağın değeri 5'ten küçükse basamak değeri olduğu gibi bırakılır, sonraki basamaklar 5'ten büyükse bu kez basamak değeri 1 arttırılır ve gerekiyorsa (9'dan büyük bir basamak değeri olması durumunda) bu daha önceki basamak değerlerine +1 artışla yansıtılır. Ancak sonraki basamak değerlerinin 5 olması durumunda round() fonksiyonu beklenmeyen sonuçlar verebilir.
print(round(1.5)) # 1.5 sayisini tamsayiya yuvarlama
print(round(2.5)) # 2.5 sayisini tamsayiya yuvarlama
1.5 ve 2.5'in her ikisinin de 2'ye yuvarlanmış olması aslında $round()$ fonksiyonundan değil yine söz konusu sayıların bilgisayarların tüm işlemlerinin dayandığı ikilik sayı sisteminde (ing. binary) temsil edilememesinden kaynaklanmaktadır. Tüm sayı sistemlerinde benzer bir kusur mevcuttur. Örneğin 10 parmaklı canlılar olmamızdan dolayı sıkça kullandığımız onluk sayı sisteminde 1 / 3'ü sonlu sayıda basamak kullanarak temsil edemeyiz (1.333...); oysa ki, 1 / 3 irrasyonel değildir. 1.4 sayısı ikilik sayı sisteminde 1.01100110011 olarak temsil edilirken, sayıyı tamsayıya yuvarlamak istediğmizde noktadan sonraki ilk basamağa bakar (0) ve 1.0'a yuvarlarız. 1.6 sayısı ise ikilik sayı sisteminde 1.10011001100 şeklinde temsil edilir. Bu sayıyı bir tamsayıya yuvarlamak istediğimizde, noktadan sonraki ilk basamağın 1 olduğunu görür ve sayıyı ikilik sayı sisteminde 10'a yuvarlarız (2). Söz konusu sayı 1.5 ise (1.10000....) görüldüğü gibi mükemmel temsil edilemez. Sayının noktadan sonraki ilk basamağı 1 olmakla birlikte ilerleyen basamaklarında yeniden 1 değerleriyle karşılaşılır. Bu nedenle sayı yukarıya yuvarlanır ve ikilik sayı sisteminde 10, onluk sayı sisteminde 2 olur. Oysa ki 2.5 ikilik sayı sisteminde 10.1 şeklinde ifade edilir ve ilerleyen basamaklarında 1 yoktur; bu nedenle aşağı yuvarlanır (10) ve onluk sayı sisteminde 2 değerini alır. Benzer bir temsil sorunu aşağıdaki basit aritmetik ifadenin de beklenilenden farklı çıkmasına yol açmaktadır.
0.1 + 0.1 + 0.1
Sorunu teşhis etmek önemli bir şey olmakla birlikte çözümü ayrı bir şeydir. Bunun için öncelikle problemin kodunuzun çözmeye çalıştığı problemi ne düzeyde etkilediğini, yani işlemlerde ihtiyaç duyduğunuz duyarlılığı belirlemeniz gereklidir. Eğer ihtiyaç duyduğunuz duyarlılık matematik kütüphanesinden ($math$) kullanabileceğiniz yukarıya yuvarlayan $ceil()$ ve aşağıya yuvarlayan $floor$ ile çözülebilecek düzeyde ise endişe etmenize gerek yoktur. $math.ceil()$ bir tamsayıya yuvarlanmasını istediğiniz sayıyı ona en yakın ve ondan büyük (ya da eşit) tamsayıya yuvarlar. $math.floor()$ ise tam tersini yapıp, bir tamsayıya yuvarlanmasını istediğiniz sayıyı ona en yakın ve ondan küçüük (ya da eşit) tamsayıya yuvarlar.
import math
print(math.ceil(2.5)) # yukariya yuvarlama
print(math.floor(2.5)) # asagiya yuvarlama
print(math.ceil(-2.5)) # negatif sayi yukariya yuvarlama
print(math.floor(-2.5)) # negatif sayi asagiya yuvarlama
Konuyu bu noktada daha derinleştirmeden, Python'da soruna en iyi çözümünün $Decimal$ modülü fonksiyonları ile getirilmiş olduğunu belirtip; bu modül ve fonksiyonlarına daha sonra detaylı olarak değineceğimizi vurgulayalım.
Bir değişken tanımladığımızda Python tarafından adı değişkenin adı, türü değişkene verdiğimiz değerle belirlenen bir nesne oluşturulur.
C = 21
print(C, type(C))
t = 0.2
print(t,type(t))
s = "Python ogreniyorum!"
print(s, type(s))
Cs = '21'
print(Cs, type(Cs))
print(Cs*3)
print(C*3)
print('"21"')
print("AST415 Astronomide Sayisal Cozumleme")
Bu değişken türleri arasında dönüşümler yapılabilir. Bu amaçla int(x), (tam sayıya dönüştürme), float(x) (noktalı sayıya dönüştürme), str(x) (metne dönüştürme) gibi fonksiyonlar kullanılır.
D = float(C)
print(D, type(D))
T = int(t)
print(T, type(T)) # sonucta noktadan sonraki basamaklar atildigina dikkat ediniz
t2 = 0.6
print(int(t2)) # int fonksiyonunun yuvarlama islemi degil kesip atma islemi yaptigina dikkat ediniz
t3 = -1.7
print(int(t3)) # durum negatif sayilar icin de aynidir
print(t3) # t3'un kendisi degistirilmedi!
Bilindiği gibi karmaşık sayılar i = $\sqrt{-1}$ olmak üzere,
şeklinde ifade edilirler.
u = 2.5 + 3j # python'da karmasik sayilar i yerine j ile yazilir
v = 2 # bu bir tam sayi
w = u + v # karmasik sayi + tam sayi
print(w)
a = -2
b = 0.5
s = a + b*1j # karmasik sayi olustur. Dikkat j degil 1j
print(s)
s = complex(a,b) # bu sekilde de karmasik sayi olusturulabilir
print(s)
s*w # iki karmasik sayinin carpimi
s/w # iki karmasik sayinin bolumu
print(s.real) # karmasik sayinin reel kismini verir
print(s.imag) # karmasik sayinin imajiner kismini verir
print(s.conjugate())# karmasik sayinin kompleks eslenigini verir
Python'da karmaşık sayılarla işlemler için cmath modülü fonksiyonları da sıklıkla kullanılır.
from math import sin
r = sin(w) # math modulundeki sinus karmasik sayilarla calismaz
from cmath import sin,sinh
r1 = sin(8j)
print(r1)
r2 = 1j * sinh(8)
print(r2)
from cmath import exp,cos,sin,pi
q = 8 # rastgele secilmis bir sayi
print(exp(1j*q)) # e^iq
print(cos(q) + 1j*sin(q))
exp(pi*1j) # Euler esitliginin sonucu sizce neden -1 degil?
Python'da karmaşık sayılarla reel sayıların birlikte kullanıldığı işlemler için numpy.lib.scimath fonksiyonları da kullanmaktadır.
from math import sqrt
print(sqrt(4)) # 4'un karekoku reel sayidir
print(sqrt(-1)) # hata vermesini bekleriz
from cmath import sqrt
print(sqrt(4)) # 4'un karekoku reel sayi ama karmasik sekilde yazilabilir
print(sqrt(-1)) # sonucun bu kez dogru cikmasini bekliyoruz
from numpy.lib.scimath import sqrt
print(sqrt(4)) # Bu modul sonucu reelse reel,
print(sqrt(-1)) # karmasiksa karmasik sayi olarak verir.
Aşağıdaki ikinci dereceden denklemi a, b, c'nin farklı değerli için çözmek isitiyor olalım.
from numpy.lib.scimath import sqrt
a = 1; b = 2; c = 10 # polinom katsayilari
r1 = (-b + sqrt(b**2 - 4*a*c))/(2*a)
r2 = (-b - sqrt(b**2 - 4*a*c))/(2*a)
print("Denklemin cozumu: r1 = {:g}, r2 = {:g}".format(r1,r2))
a = 1; b = 4; c = 1 # polinom katsayilarini degistirelim
r1 = (-b + sqrt(b**2 - 4*a*c))/(2*a)
r2 = (-b - sqrt(b**2 - 4*a*c))/(2*a)
print("Denklemin cozumu: r1 = {:g}, r2 = {:g}".format(r1,r2))
Metre cinsinden verilen bir uzunluğu inch (1 inch = 2.54 cm), foot (1 foot = 12 inch), yard (1 yard = 3 feet) ve mile (1 mil = 1760 yard) birimlerine dönüştüren bir program yazınız. Programınızı 640 metre için test ediniz (25196.85 inch, 2099.74 feet, 699.91 yard ve 0.3977 mil).
Bir cismin yoğunluğu kütlesiyle hacminin çarpımı olarak tanımlanır ($d = m V$). Demir ($d_{Fe} = 7.87 g cm^{-3}$, aliminyum ($d_{Fe} = 2.70 g cm^{-3}$, bakır ($d_{Cu} = 8.96 g cm^{-3}$), hava ($d_{hava} = 1.283 g cm^{-3}$ ve ortalama insan vücudunun ($d_{insan} = 1.01 g cm^{-3}$) bir litresinin kaç kilogram olduğunu bulan bir program yazınız.
Aşağıda verilen programdaki hataları bulup, düzeltiniz ve programı çalıştırınız.
x=1
print('sin(%g)=%g' % (x, sin(x))Aşağıdaki küçük programcıkları yazıp çalıştırarak verilen ifadelerin doğruluğunu test ediniz. Programların çalışmadığı durumlarda hatalarını bulup, düzelttikten sonra tekrar çalıştırınız.
a) $sin^{2} + cos^{2} = 1?$
from math import sin, cos
x = pi/4
1_val = math.sin^2(x) + math.cos^2(x)
print 1_VALb) $s = v_{0} t + 1/2 a t^{2}$ ifadesinde $v_{0} = 3 m/s$ , $t = 1 s$, $a = 2 m/s^{2}$ için s'yi hesaplayınız.
```
v0 = 3 m/s
t = 1 s
a = 2 m/s**2
s = v0.t + 0,5.a.t**2
print s
```
c) Aşağıdaki ifadeleri doğrulayınız
$$(a + b)^{2} = a^{2} + 2ab + b^{2}$$
$$(a − b)^{2} = a^{2} − 2ab + b^{2}$$
```
a = 3,3 b = 5,3
a2 = a**2
b2 = b**2
eq1_sum = a2 + 2ab + b2
eq2_sum = a2 - 2ab + b2
eq1_pow = (a + b)**2
eq2_pow = (a - b)**2
print('Birinci ifade: %g = %g', % (eq1_sum, eq1_pow))
print('Ikinci ifade: %h = %h', % (eq2_pow, eq2_pow))
```
C = 21; F = 9/5*C + 32; print F
C = 21.0; F = (9/5)*C + 32; print F
C = 21.0; F = 9*C/5 + 32; print(F)
C = 21.0; F = 9.*(C/5.0) + 32;print('.2f' % F)
C = 21.0; F = 9.0*C/5.0 + 32; print("{:.2f}.format(F))
C = 21; F = 9*C/5 + 32; print(F)
C = 21.0; F = (1/5)*9*C + 32; print('%3.2f' % F)
C = 21; F = (1./5)*9*C + 32; print("{:d}.format(F)")3b = 2
b2 = b
x = 2
y = X + 4 # 6 eder mi?
from Math import sin
print sin(pi)
pi = "3.1416’
print sin(pi)
c = 2**3**4**3
_ = ((c-180)/c + 32))
indirim_orani = 5%
fiyat = 20.-
etiket_fiyati = 50€
address = www.ozgur.astrotux.org
and = AST415
sinif = 'AST415 Astronomi'de Sayisal Cozumleme-I'
dogrulukdegeri_ = x > 0
cat = kedi = True
Turkce = ['bir dil']
true = cat is kedia = 2; b = 1; c = 2
from math import sqrt
q = b*b - 4*a*c
q_sr = sqrt(q)
x1 = (-b + q_sr)/2*a
x2 = (-b - q_sr)/2*a
print x1, x2