{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# AST415 Astronomide Sayısal Çözümleme - I #\n", "## Ders - 02 Formüllerle Hesaplar ve Yazım Kuralları (Syntax) ##" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Doç. Dr. Özgür Baştürk
\n", "Ankara Üniversitesi, Astronomi ve Uzay Bilimleri Bölümü
\n", "obasturk at ankara.edu.tr
\n", "http://ozgur.astrotux.org" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Bu derste neler öğreneceksiniz?#\n", "## Formüllerle Hesaplar ##\n", "\n", "* [Dikey Atış Problemi](#Dikey-Atış-Problemi)\n", "* [Değişken Kullanımı](#Değişken-Kullanımı)\n", "* [Değişken İsimlendirmeleri](#Değişken-İsimlendirmeleri)\n", "* [Yorum İfadeleri](#Yorum-İfadeleri)\n", "* [Metin ve Sayı Formatlama](#Metin-ve-Sayı-Formatlama)\n", " * [printf fonksiyonalitesi](#printf-fonksiyonalitesi)\n", " * [str.format yöntemi](#str.format-yöntemi)\n", "* [Matematiksel İşlemler](#Matematiksel-İşlemler)\n", "* [Tam Sayı Bölmesi](#Tam-Sayı-Bölmesi)\n", "* [Aritmetik Operatörlerin Öncelik Sırası](#Aritmetik-Operatörlerin-Öncelik-Sırası)\n", "* [Standart Matematiksel Fonksiyonlar](#Standart-Matematiksel-Fonksiyonlar)\n", "* [Modül Fonksiyonları](#Modül-Fonksiyonları)\n", "* [Modül Çağırma](#Modül-Çağırma)\n", "* [Yuvarlama Hataları](#Yuvarlama-Hataları)\n", "* [Değişken Türleri ve Dönüşümler](#Değişken-Türleri-ve-Dönüşümler)\n", "* [Karmaşık Sayılar (Opsiyonel)](#Karmaşık-Sayılar-(Opsiyonel))\n", "* [Örnek: 2. Dereceden Denklem Çözümü](#Örnek:-2.-Dereceden-Denklem-Çözümü)\n", "* [Alıştırmalar](#Alıştırmalar)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Dikey Atış Problemi\n", "\n", "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.
\n", "\n", "
\n", "$$y(t) = V_{0} t - \\frac{1}{2} g t^{2}$$\n", "
\n", "\n", "
\n", "\n", "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
\n", "\n", "
\n", "$$V_{0} t - \\frac{1}{2} g t^{2} = 0 \\rightarrow t(V_{0} - \\frac{1}{2} g t) = 0$$
\n", " $t = 0$ ve $t = \\frac{2 V_{0}}{g}$\n", "
\n", "
\n", "\n", "olduğu düşünülecek olursa $t \\in[0, \\frac{2V_{0}}{g}]$ olur.\n", "\n", "\n", "[Başa Dön](#Formüllerle-Hesaplar)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Değişken Kullanımı #\n", "\n", "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." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.2342\n" ] } ], "source": [ "v0 = 5 # Ilk hiz m/s\n", "t = 0.6 # zaman s\n", "g = 9.81 # yercekimi ivmesi m/s**2\n", "y = v0*t - 0.5*g*t**2\n", "print(y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ş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." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.050949999999999995\n" ] } ], "source": [ "v0 = 1 # Ilk hiz\n", "t = 0.1 # zaman\n", "y = v0*t - 0.5*g*t**2\n", "print(y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "! g'yi tekrar yazmadığımıza ancak y'yi veren ifadeyi tekrar yazdığımıza dikkat ediniz!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ayni anda birden fazla degiskeni tek satirda tanimlayabilirsiniz." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3 3\n", "3 5\n", "3.14\n", "AST415\n", "8\n" ] }, { "ename": "ValueError", "evalue": "too many values to unpack (expected 3)", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 8\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mc\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m3.14\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'AST415 Astronomide Sayisal Cozumleme'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m8\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;32mTrue\u001b[0m \u001b[1;31m#degisken sayisi ile deger\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 10\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mc\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 11\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m3.14\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'AST415 Astronomide Sayisal Cozumleme'\u001b[0m \u001b[1;31m#sayisinin esit olmadigina dikkat\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[1;31mValueError\u001b[0m: too many values to unpack (expected 3)" ] } ], "source": [ "x = y = 3 # hem x'e hem y'ye 3 degerini ata\n", "print(x,y)\n", "y = 5\n", "print(x,y) # y degistiginde x'in degismedigine dikkat ediniz\n", "a, b, c = 3.14, 'AST415', 8 # ayni anda birden fazla degisken tek satirda\n", "print(a)\n", "print(b)\n", "print(c)\n", "a, b, c = 3.14, 'AST415 Astronomide Sayisal Cozumleme', 8, True #degisken sayisi ile deger\n", "print(c)\n", "a, b, c = 3.14, 'AST415 Astronomide Sayisal Cozumleme' #sayisinin esit olmadigina dikkat\n", "print(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Formüllerle-Hesaplar)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Değişken İsimlendirmeleri #\n", "\n", "* Değişkenleri isimlendirmek üzere (inglizce alfabe dışında karakter içermeyen) küçük (a-z) ve büyük (A-Z), rakamlardan (0-9) ve alt çizgi (– underscore) işaretinden faydalanabilirsiniz.\n", "* Değişken isimleri rakamla başlayamaz! Bu şekilde verilmiş bir değişken ismi yazım (syntax) hatası verir.\n", "* Python küçük harflerle büyük harfleri birbirinden ayırır (case sensitive). Yani “x” ile “X” aynı değildir!\n", "* Kesin bir kural olmamakla birlikte değişkenler için küçük harf, sabitler (PI, PLANCK_SABITI gibi) için büyük harf kullanmak, kelimeleri “_” (alt çizgi) işaret ile birbirinden ayırmak; daha sonra göreceğiniz sınıf (class) isimlerinde ikinci kelimenin baş harfini büyük yapmak gibi genel Python alışkanlıkları olmakla birlikte bunları takip etmezseniz hata vermez. (Python'da kullanılan genel kod yazma stili alışkanlıkları için bkz: PEP 0008: Style Guide for Python, https://www.python.org/dev/peps/pep-0008/)\n", "* Mümkün olduğunca açıklayıcı değişken isimleri kullanmak hem siz, hem de kodunuzu okuyanlar (diğer programcılar, BİZLER!) için iyidir. Örnek problemimizde $v0$ yerine $ilk\\_hiz$, $t$ yerine $zaman$, $y$ yerine $dusey\\_konum$, $g$ yerine $yercekimi\\_ivmesi$ kullanirsak daha aciklayici olur\n", "* Python için saklı kelimeleri değişken ismi olarak kullanamazsınız (and, as, assert, break, class, continue, def, del, elif, else, except, False, finally, for, from, global, if, import, in, is, lambda, None, nonlocal, not, or, pass, raise, return, True, try, with, while, yield). Çok istiyorsanız sonlarına bir “_” işareti koymak işi çözer!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Değişken İsimlendirmeleri'ne Örnekler

\n", "\n", "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." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n" ] } ], "source": [ "başlangıç_hızı = 5\n", "print(başlangıç_hızı)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Aşağıdaki değişken isimlendirmelerinin doğruluğunu kontrol ediniz. \n", "\n", "* 1a = 2\n", "* _ = ((d-45)/c + 32))\n", "* a1 = b\n", "* sale = 6%\n", "* x = 3\n", "* doviz = 10$\n", "* y = X + 4\n", "* eposta = somebody@somewhere.com\n", "* pi = \"3.141\"\n", "* and = \"ve\"\n", "* c = 5 \\** 2 \\** 0.5 \\** 3\n", "* Degisken = x > 0\n", "\n", "[Başa Dön](#Formüllerle-Hesaplar)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Yorum İfadeleri #\n", "\n", "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." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.2342\n" ] } ], "source": [ "# havaya dogru bir ilk hizla atilan cismin t anindaki \n", "# yuksekligini hesaplayan program\n", "v0 = 5 # ilk hiz\n", "g = 9.81 # yercekimi ivmesi\n", "t = 0.6 # zaman\n", "y = v0*t - 0.5*g*t**2 # dusey konum\n", "print y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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!\n", "\n", "[Başa Dön](#Formüllerle-Hesaplar)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Metin ve Sayı Formatlama #\n", "## printf fonksiyonalitesi ##\n", "\n", "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.\n", "\n", "Sonuç olarak dikine atış programımızı istenen çıktıyı verecek şekilde aşağıdaki gibi düzenleyebiliriz." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "t = 0.6 saniyede cismin yuksekligi 1.23 metredir\n", "t = 0.6 saniyede cismin yuksekligi 1.2342 metredir\n", "t = 0.595 saniyede cismin yuksekligi 1.24 metredir\n", "Cismin yuksekligi 1.2342 metredir\n", "y = 1.2342\n" ] } ], "source": [ "# havaya bir ilk hizla atilan cismin t anindaki \n", "# yuksekligini hesaplayan program\n", "v0 = 5 # ilk hiz\n", "g = 9.81 # yercekimi ivmesi\n", "t = 0.6 # zaman\n", "y = v0*t - 0.5*g*t**2 # cismin dusey konumu\n", "# dusey konum\n", "print(\"t = %g saniyede cismin yuksekligi %.2f metredir\" % (t,y))\n", "# buradan sonrasi 10 Ekim 2018 tarihli dersten\n", "# degisken yerine tum ifadeyi de %'den sonra koyabiliriz\n", "print(\"t = %g saniyede cismin yuksekligi %.4f metredir\" % \\\n", " (t,v0*t - 0.5*g*t**2))\n", "# t'yi 0.595 yapip sayinin nasil yuvarlandigini gorelim\n", "t = 0.595\n", "print(\"t = %g saniyede cismin yuksekligi %.2f metredir\" % \\\n", " (t,v0*t - 0.5*g*t**2))\n", "# Tek bir yer tutucu kullanildigi zaman paranteze alma zorunlulugu yoktur\n", "# t'yi degistirdigimize ama y'yi degistirmedigimize dikkat ediniz\n", "print(\"Cismin yuksekligi %.4f metredir\" % y)\n", "# Metnin sonuna basit bir syntax'la nesne degeri yazdirabilirsiniz\n", "print('y = ', y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Aşağıda en sık kullanılan bazı \"YER TUTUCULARI\" görüyorsunuz:\n", "\n", "%s \t\t: Metin değişkenler için yer tutucu
\n", "%d \t\t: Tamsayı değişkenler için yer tutucu
\n", "%0xd \t: Önüne getirilen “0” rakamları ile birlikte x basamak yer kaplayacak tam sayı yer tutucusu
\n", "%f \t\t: Noktadan sonra 6 basamak kaplayacak şekilde yazılmak istenen noktalı sayı yer tutucusu
\n", "%e\t\t: Kompakt bilimsel gösterim yer tutucusu
\n", "%E\t\t: Kompakt bilimsel gösterim yer tutucusu (üssü belirtmek üzere e yerine E kullanılır)
\n", "%g\t\t: Reel bir sayı için olası en kompakt yazımı veren yer tutucu
\n", "%G\t\t: %g ile aynı sadece üs gerektiğinde belirtmek üzere e yerine E kullanılır
\n", "%x\t\t: Bir tam sayı nesnesini (int) metne (string) dönüştürüp onaltılık (hexadecimal) sistemde göstermek için kullanılır
\n", "%%\t\t: yüzde (%) işaretini yazdırmak gerektiğinde kullanılır
\n", "\n", "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." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "v0=5.000E+00 m/s ilk hizla firlatilan cismin\n", "t=0.600000 saniyedeki yuksekligi\n", "1.23 metredir.\n", "\n" ] } ], "source": [ "v0 = 5\n", "g = 9.81\n", "t = 0.6\n", "y = v0*t - 0.5*g*t**2\n", "print(\"\"\"\n", "v0=%.3E m/s ilk hizla firlatilan cismin\n", "t=%f saniyedeki yuksekligi\n", "%.2f metredir.\n", "\"\"\" % (v0, t, y))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Formüllerle-Hesaplar)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## str.format yöntemi ##\n", "\n", "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. \n", "\n", "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." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "t = 0.6 saniyede cismin yuksekligi 1.23 metredir.\n", "t = 0.6 saniyede cismin yuksekligi 1.23 metredir.\n" ] } ], "source": [ "print(\"t = {1:g} saniyede cismin yuksekligi {0:.2f} metredir.\".format(y,t))\n", "# siralamayi printf yonteminde oldugu gibi de kullanabiliriz\n", "print(\"t = {:g} saniyede cismin yuksekligi {:.2f} metredir.\".format(t,y))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Bu yöntemde herhangi bir metni hizalamak için \"-\" ve \"+\" işaretleri yerine \"<\" ve \">\" işaretleri kullanılır. " ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "test \n", "test \n", " test\n", " test\n" ] } ], "source": [ "print('%-10s' % ('test')) # printf stili\n", "print('{:<10s}'.format('test')) # str.format yontemi\n", "print('%10s' % ('test'))\n", "print('{:>10s}'.format('test'))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "test______\n", " test \n", "003.14\n", "-23\n", "+42\n", "+ 18\n" ] } ], "source": [ "print('{:_<10s}'.format('test'))\n", "print('{:^10s}'.format('test'))\n", "print('{:06.2f}'.format(3.141592653589793))\n", "print('{: d}'.format((- 23)))\n", "print('{:+d}'.format(42))\n", "print('{:=+8d}'.format((18)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Yer tutucular bu formatla isimlendirilebilir ve adlarıyla atıfta bulunularak kullanılabilir." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Ad Soyad\n", "Ad Soyad\n" ] } ], "source": [ "print('{birinci} {ikinci}'.format(birinci='Ad', ikinci='Soyad'))\n", "print('{birinci} {ikinci}'.format(ikinci='Soyad', birinci='Ad'))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Bu yöntemle ayrıca format parametreleri parametrik şekilde de kullanılabilir." ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " test \n", "Sayi = 2.72\n", " 3.14\n", " +2.72\n", " +2.72\n" ] } ], "source": [ "print('{:{hiza}{genislik}}'.format('test', hiza='^', genislik='10'))\n", "print('{} = {:.{hassasiyet}f}'.format('Sayi ', 2.7182, hassasiyet=2))\n", "print('{:{genislik}.{hassasiyet}f}'.format(3.14159, genislik=8, hassasiyet=2))\n", "print('{:{}{}{}.{}}'.format(2.7182818284, '>', '+', 10, 3))\n", "print('{:{}{isaret}{}.{}}'.format(2.7182818284, '>', 10, 3, isaret='+'))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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. \n", "\n", "[Başa Dön](#Formüllerle-Hesaplar)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Matematiksel İşlemler #\n", "\n", "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.\n", "\n", "
\n", "$$F = \\frac{9}{5} C + 32$$\n", "
\n", "\n", "Bu problemi C = 21° için basit bir Python koduyla çözmeye çalışalım." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "132.8\n" ] } ], "source": [ "C = 56\n", "F = (9 / 5)*C + 32\n", "print(F)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Tam Sayı Bölmesi ##\n", "\n", "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.\n", "\n", "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." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "\n", "1.0\n", "\n" ] } ], "source": [ "x = 9//5\n", "print(x), print(type(x))\n", "y = 9.//5\n", "print(y)\n", "print(type(y))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " “Bir Python programı yazmak, nesneler oluşturmak ve bu nesnelerin değerlerini değiştirmektir”\n", " \n", " [Başa Dön](#Formüllerle-Hesaplar)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Aritmetik Operatörlerin Öncelik Sırası #\n", "\n", "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.\n", "\n", "Örnek 1\n", "\n", "
\n", " $$\\frac{4}{8} + 2*\\frac{3^{4}}{9}$$\n", " $$\\frac{4}{8} = 0.5 → 3^{4} = 81 → 2*81 = 162 → \\frac{162}{9} = 18 → 0.5 + 18 = 18.5$$\n", "
\n", "\n", "Örnek 2\n", "\n", "
\n", " $$\\frac{4}{(6 + 2)} + 2*4^{\\frac{4}{8}}$$\n", " $$\\frac{4}{(6 + 2)} = \\frac{4}{(8)} = 0.5 → 4^{\\frac{4}{8}} = 4^{0.5} = 2 → 2*2 = 4 = → 0.5 + 4 = 4.5$$\n", "
\n", "\n", "Şimdi bu işlemleri Python ile yapalım." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "18.5\n", "4.5\n" ] } ], "source": [ "# Ornek 1\n", "print(4 / 8 + 2*3**4/9)\n", "# Ornek 2\n", "print(4/(6+2) + 2*4**(4/8))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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.\n", "\n", "[Başa Dön](#Formüllerle-Hesaplar)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Standart Matematiksel Fonksiyonlar #\n", "\n", "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.\n", "\n", "Bu amaçla\n", "\n", "
\n", " $$y(t) = V_{0} t - \\frac{1}{2} g t^{2}$$\n", " $$\\frac{1}{2} g t^{2} - V_{0} t + y = 0$$\n", "
\n", "\n", "ikinci derece denklemini çözmemiz gerekir. Bu denklemin çözümü\n", "\n", "
\n", " $$t_{1, 2} = (V_{0} \\pm (V_{0}^{2} - 2 g y)^{1/2}) / g$$\n", "
\n", "\n", "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." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Modül Fonksiyonları #\n", "\n", "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." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Merhaba Dunya!\n", "5 \n", "5 \n", "5.0 \n" ] } ], "source": [ "# Standart (built-in) Python Fonksiyonu Ornekleri\n", "print(\"Merhaba Dunya!\")\n", "x = 5\n", "print(x, type(x))\n", "x = str(x)\n", "print(x, type(x))\n", "x = float(x)\n", "print(x, type(x))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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. \n", "\n", "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.\n", "\n", "Bir modüldeki fonksiyonları kullanabilmek için öncelikle onu çağırmak (import etmek) gereklidir. Bu işlem en basit şekliyle\n", "\n", "
\n", " import modul_adi\n", "
\n", "\n", "ifadesiyle yapılır.\n", "\n", "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!)\n", "\n", "Ö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. " ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "t=0.0417064 saniye ve 0.977662 saniyede cismin yuksekligi 0.2 metredir\n" ] } ], "source": [ "# Dikey atis problemi, cismin verilen bir yukseklikten (y)\n", "# gectigi zamanlarin (t1 ve t2) bulunmasi\n", "v0 = 5 # m/s\n", "g = 9.81 # m/s^2\n", "yc = 0.2 # m\n", "import math\n", "t1 = (v0 - math.sqrt(v0**2 - 2*g*yc))/g\n", "t2 = (v0 + math.sqrt(v0**2 - 2*g*yc))/g\n", "print('t={:g} saniye ve {:g} saniyede cismin yuksekligi {:g} metredir'.\\\n", " format(t1, t2, yc))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Formüllerle-Hesaplar)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Modül Çağırma #\n", "## Modül Fonksiyonları Kullanma Yöntemleri ##\n", "\n", "import modul_adi şeklindeki modül çağırma ifadesinin yanı sıra başka modül çağırma şekilleri de vardır.\n", "\n", "En sık kullanılan modül çağırma şekillerinden biri \n", "\n", "
\n", " from modul_adi import fonksiyon_adi1,fonksiyon_adi2, ... \n", "
" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.4142135623730951\n", "sin (90) = 1\n", "ln(e^2) = 2\n", "e^5 = 148.413\n", "0.0\n" ] } ], "source": [ "from math import sqrt,sin,exp,log,e,sin,pi\n", "print(sqrt(2))\n", "print(\"sin (90) = {:g}\".format(sin(0.5*pi)))\n", "print(\"ln(e^2) = {:g}\".format(log(e**2,e)))\n", "print(\"e^5 = {:g}\".format(exp(5)))\n", "print(log(sin(pi/2.),10))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Bu şekilde bir modüldeki tüm fonksiyonları from modul_adi import * ifadesiyle de çağrımak mümkündür.\n", "\n", "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.\n", "\n", "Bu probleme biraz yakından bakalım: \n", "\n", "* 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..\n", "\n", "* 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... \n", "\n", "* 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.\n", "\n", "* İ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." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Yaricapi 10 olan cemberin cevresi 62.8319\n", "Alani ise 314.159 'dir\n" ] } ], "source": [ "import math as m\n", "yaricap = 10\n", "cevre = 2*m.pi*yaricap\n", "alan = m.pi*yaricap**2\n", "print(\"Yaricapi {:d} olan cemberin cevresi {:g}\".format(yaricap,cevre))\n", "print(\"Alani ise {:g} 'dir\".format(alan))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Formüllerle-Hesaplar)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Yuvarlama Hataları #\n", "\n", "Matematiksel olarak sinüs hiperbolik fonksiyonu (sin h)\n", "\n", "
\n", " $$sinh(x) = \\frac{(e^{x} - e^{-x})}{2}$$\n", "
\n", "\n", "şeklinde tanımlanır. Şimdi x = 2$\\pi$ için sinh(x) 'i farklı şekillerde hesaplayalım." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "267.74489404 267.74489404 267.74489404\n", "267.7448940410164369 267.7448940410164369 267.7448940410163232\n" ] } ], "source": [ "from math import sinh, exp, e, pi\n", "x = 2*pi\n", "r1 = sinh(x)\n", "r2 = 0.5*(exp(x) - exp(-x))\n", "r3 = 0.5*(e**x - e**(-x))\n", "print(\"{:.8f} {:.8f} {:.8f}\".format(r1,r2,r3))\n", "print(\"{:.16f} {:.16f} {:.16f}\".format(r1,r2,r3))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "İşte bu ilginç! Matematiksel olarak eşit olduğunu bildiğimiz üç ifadeden sonuncusu 12. basamaktan sonra diğerlerinden farklılaşan bir sonuç verdi!\n", "\n", "Bir başka örneğe bakalım. Aşağıdaki iki ifadenin aynı sonucu vermesi gerek:\n", "\n", "
\n", "$$\\frac{1}{49.} * 49. = \\frac{1}{51.} * 51 = 1.0000000000000000$$\n", "
" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.9999999999999999\n", "1.0\n" ] } ], "source": [ "print(1./49.*49.)\n", "print(1./51.*51.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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. \n", "\n", "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!\n", "\n", "## round() Fonksiyonu ##\n", "\n", "$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. " ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3.14\n", "3\n" ] } ], "source": [ "print(round(3.1415926535, 2)) # iki basamaga yuvarlama\n", "print(round(3.1415926535)) # tam sayiya yuvarlama" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n", "2\n" ] } ], "source": [ "print(round(1.5)) # 1.5 sayisini tamsayiya yuvarlama\n", "print(round(2.5)) # 2.5 sayisini tamsayiya yuvarlama" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.30000000000000004" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "0.1 + 0.1 + 0.1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## math.ceil() ve math.floor() Fonksiyonları ##\n", "\n", "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." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3\n", "2\n", "-2\n", "-3\n" ] } ], "source": [ "import math\n", "print(math.ceil(2.5)) # yukariya yuvarlama\n", "print(math.floor(2.5)) # asagiya yuvarlama\n", "print(math.ceil(-2.5)) # negatif sayi yukariya yuvarlama\n", "print(math.floor(-2.5)) # negatif sayi asagiya yuvarlama" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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.\n", "\n", "[Başa Dön](#Formüllerle-Hesaplar)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Değişken Türleri ve Dönüşümler #\n", "\n", "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." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "21 \n", "0.2 \n", "Python ogreniyorum! \n", "21 \n", "212121\n", "63\n", "\"21\"\n", "Ugur'un bir maruzati var!\n" ] } ], "source": [ "C = 21\n", "print(C, type(C))\n", "t = 0.2\n", "print(t,type(t))\n", "s = \"Python ogreniyorum!\"\n", "print(s, type(s))\n", "Cs = '21'\n", "print(Cs, type(Cs))\n", "print(Cs*3)\n", "print(C*3)\n", "print('\"21\"')\n", "print(\"Ugur'un bir maruzati var!\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "21.0 \n", "0 \n", "0\n", "-1\n", "-1.7\n" ] } ], "source": [ "D = float(C)\n", "print(D, type(D))\n", "T = int(t)\n", "print(T, type(T)) # sonucta noktadan sonraki basamaklar atildigina dikkat ediniz\n", "t2 = 0.6\n", "print(int(t2)) # int fonksiyonunun yuvarlama islemi degil kesip atma islemi yaptigina dikkat ediniz\n", "t3 = -1.7\n", "print(int(t3)) # durum negatif sayilar icin de aynidir\n", "print(t3) # t3'un kendisi degistirilmedi!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Formüllerle-Hesaplar)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Karmaşık Sayılar (Opsiyonel)#\n", "\n", "Bilindiği gibi karmaşık sayılar i = $\\sqrt{-1}$ olmak üzere,\n", "\n", "
\n", " $$a \\pm ib$$\n", "
\n", "\n", "şeklinde ifade edilirler. \n", "\n", "
\n", " $u = a + ib$ ve $v = c + id$ olmak üzere,
\n", " * $u = v \\Rightarrow (a = b)$ ve $(c = d)$
\n", " * $-u = -a – ib$
\n", " * $u^{*} = a - ib$ (kompleks eşlenik)
\n", " * $u + v = (a + c) + (b + d)i$
\n", " * $u - v = (a - c) + (b – d)i$
\n", " * $uv = (ac − bd) + (bc + ad)i$
\n", " * $\\frac{u}{v} = \\frac{ac + bd}{c^{2} + d^{2}} + \\frac{bc − ad}{c^{2} + d^{2}}$
\n", " * $|u| = \\sqrt{a^{2} + b{2}}$
\n", " * $e^{iq}$ = cos q + i sin q$
\n", "
" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(4.5+3j)\n", "(-2+0.5j)\n", "(-2+0.5j)\n", "-2.0\n", "0.5\n", "(-2-0.5j)\n" ] } ], "source": [ "u = 2.5 + 3j # python'da karmasik sayilar i yerine j ile yazilir\n", "v = 2 # bu bir tam sayi\n", "w = u + v # karmasik sayi + tam sayi\n", "print(w)\n", "a = -2\n", "b = 0.5\n", "s = a + b*1j # karmasik sayi olustur. Dikkat j degil 1j\n", "print(s)\n", "s = complex(a,b) # bu sekilde de karmasik sayi olusturulabilir\n", "print(s)\n", "s*w # iki karmasik sayinin carpimi\n", "s/w # iki karmasik sayinin bolumu\n", "print(s.real) # karmasik sayinin reel kismini verir\n", "print(s.imag) # karmasik sayinin imajiner kismini verir\n", "print(s.conjugate())# karmasik sayinin kompleks eslenigini verir" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Python'da karmaşık sayılarla işlemler için cmath modülü fonksiyonları da sıklıkla kullanılır." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "can't convert complex to float", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mmath\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0msin\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mw\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# math modulundeki sinus karmasik sayilarla calismaz\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: can't convert complex to float" ] } ], "source": [ "from math import sin\n", "r = sin(w) # math modulundeki sinus karmasik sayilarla calismaz" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1490.4788257895502j\n", "1490.4788257895502j\n", "(-0.14550003380861354+0.9893582466233818j)\n", "(-0.14550003380861354+0.9893582466233818j)\n" ] }, { "data": { "text/plain": [ "(-1+1.2246467991473532e-16j)" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from cmath import sin,sinh\n", "r1 = sin(8j)\n", "print(r1)\n", "r2 = 1j * sinh(8)\n", "print(r2)\n", "from cmath import exp,cos,sin,pi\n", "q = 8 # rastgele secilmis bir sayi\n", "print(exp(1j*q)) # e^iq\n", "print(cos(q) + 1j*sin(q))\n", "exp(pi*1j) # Euler esitliginin sonucu sizce neden -1 degil?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Python'da karmaşık sayılarla reel sayıların birlikte kullanıldığı işlemler için numpy.lib.scimath fonksiyonları da kullanmaktadır." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2.0\n" ] }, { "ename": "ValueError", "evalue": "math domain error", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mmath\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0msqrt\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# 4'un karekoku reel sayidir\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# hata vermesini bekleriz\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mValueError\u001b[0m: math domain error" ] } ], "source": [ "from math import sqrt\n", "print(sqrt(4)) # 4'un karekoku reel sayidir\n", "print(sqrt(-1)) # hata vermesini bekleriz" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(2+0j)\n", "1j\n", "2.0\n", "1j\n" ] } ], "source": [ "from cmath import sqrt\n", "print(sqrt(4)) # 4'un karekoku reel sayi ama karmasik sekilde yazilabilir\n", "print(sqrt(-1)) # sonucun bu kez dogru cikmasini bekliyoruz\n", "from numpy.lib.scimath import sqrt\n", "print(sqrt(4)) # Bu modul sonucu reelse reel,\n", "print(sqrt(-1)) # karmasiksa karmasik sayi olarak verir." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Formüllerle-Hesaplar)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Örnek: 2. Dereceden Denklem Çözümü #\n", "\n", "Aşağıdaki ikinci dereceden denklemi a, b, c'nin farklı değerli için çözmek isitiyor olalım.\n", "\n", "
\n", " $$ax^{2} + bx + c = 0$$\n", "
" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Denklemin cozumu: r1 = -1+3j, r2 = -1-3j\n", "Denklemin cozumu: r1 = -0.267949, r2 = -3.73205\n" ] } ], "source": [ "from numpy.lib.scimath import sqrt\n", "a = 1; b = 2; c = 10 # polinom katsayilari\n", "r1 = (-b + sqrt(b**2 - 4*a*c))/(2*a)\n", "r2 = (-b - sqrt(b**2 - 4*a*c))/(2*a)\n", "print(\"Denklemin cozumu: r1 = {:g}, r2 = {:g}\".format(r1,r2))\n", "\n", "a = 1; b = 4; c = 1 # polinom katsayilarini degistirelim\n", "r1 = (-b + sqrt(b**2 - 4*a*c))/(2*a)\n", "r2 = (-b - sqrt(b**2 - 4*a*c))/(2*a)\n", "print(\"Denklemin cozumu: r1 = {:g}, r2 = {:g}\".format(r1,r2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Formüllerle-Hesaplar)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Alıştırmalar #\n", "\n", "1. 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).\n", "\n", "2. 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.\n", "\n", "3. Aşağıda verilen programdaki hataları bulup, düzeltiniz ve programı çalıştırınız.\n", "\n", "```\n", "x=1\n", "print('sin(%g)=%g' % (x, sin(x))\n", "```\n", "\n", "4. 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.\n", "\n", " a) $sin^{2} + cos^{2} = 1?$\n", "\n", " ```\n", " from math import sin, cos\n", " x = pi/4\n", " 1_val = math.sin^2(x) + math.cos^2(x)\n", " print 1_VAL\n", " ```\n", " \n", " b) $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.\n", " \n", "\n", " ```\n", " v0 = 3 m/s\n", " t = 1 s\n", " a = 2 m/s**2\n", " s = v0.t + 0,5.a.t**2\n", " print s\n", " ``` \n", " c) Aşağıdaki ifadeleri doğrulayınız\n", " \n", " $$(a + b)^{2} = a^{2} + 2ab + b^{2}$$\n", " $$(a − b)^{2} = a^{2} − 2ab + b^{2}$$\n", " \n", "\n", " ```\n", " a = 3,3 b = 5,3\n", " a2 = a**2\n", " b2 = b**2\n", " eq1_sum = a2 + 2ab + b2\n", " eq2_sum = a2 - 2ab + b2\n", " eq1_pow = (a + b)**2\n", " eq2_pow = (a - b)**2\n", " print('Birinci ifade: %g = %g', % (eq1_sum, eq1_pow))\n", " print('Ikinci ifade: %h = %h', % (eq2_pow, eq2_pow))\n", " ``` \n", " \n", "5. Gauss fonksiyonu aşağıdaki ifade ile verilir ve neredeyse her bilim dalında en sık kullanılan fonksiyonlardan biridir. Bu fonksiyonu $\\mu = 0$ ortalama değeri, $\\sigma = 2$ standart sapması ve $x = 1$ için hesaplayan bir program yazınız.\n", "\n", "$$f(x) = \\frac{1}{\\sqrt{2 \\pi} \\sigma} exp[- \\frac{1}{2}( \\frac{x - \\mu}{\\sigma} )]$$\n", "\n", "6. Aşağıda Santigrat dereceyi Fahrenheit'a dönüştüren bazı kod satırları verilmiştir. Doğru çalışmayacak olan satırları bulup, düzeltiniz ve çalıştırınız.\n", "\n", "```\n", "C = 21; F = 9/5*C + 32; print F\n", "C = 21.0; F = (9/5)*C + 32; print F\n", "C = 21.0; F = 9*C/5 + 32; print(F)\n", "C = 21.0; F = 9.*(C/5.0) + 32;print('.2f' % F)\n", "C = 21.0; F = 9.0*C/5.0 + 32; print(\"{:.2f}.format(F))\n", "C = 21; F = 9*C/5 + 32; print(F)\n", "C = 21.0; F = (1/5)*9*C + 32; print('%3.2f' % F)\n", "C = 21; F = (1./5)*9*C + 32; print(\"{:d}.format(F)\")\n", "```\n", "\n", "7. Aşağıda verilen Python ifadelerindeki yanlışları bulunuz ve düzeltiniz.\n", "\n", "```\n", "3b = 2\n", "b2 = b\n", "x = 2\n", "y = X + 4 # 6 eder mi?\n", "from Math import sin\n", "print sin(pi)\n", "pi = \"3.1416’\n", "print sin(pi)\n", "c = 2**3**4**3\n", "_ = ((c-180)/c + 32))\n", "indirim_orani = 5%\n", "fiyat = 20.-\n", "etiket_fiyati = 50€\n", "address = www.ozgur.astrotux.org\n", "and = AST415\n", "sinif = 'AST415 Astronomi'de Sayisal Cozumleme-I'\n", "dogrulukdegeri_ = x > 0\n", "cat = kedi = True\n", "Turkce = ['bir dil']\n", "true = cat is kedi\n", "```\n", "\n", "8. Aşağıdaki formülllere denk Python kodlarının doğru verilip verilmediğini kontrol ediniz. Değillerse düzeltiniz.\n", "\n", "$$ax^{2} + bx + c = 0$$\n", "$$x_{1, 2} = \\frac{-b \\pm \\sqrt{b^{2} - 4ac}}{2a}$$\n", "\n", "```\n", "a = 2; b = 1; c = 2\n", "from math import sqrt\n", "q = b*b - 4*a*c\n", "q_sr = sqrt(q)\n", "x1 = (-b + q_sr)/2*a\n", "x2 = (-b - q_sr)/2*a\n", "print x1, x2\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Formüllerle-Hesaplar)" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.9" } }, "nbformat": 4, "nbformat_minor": 1 }