{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# AST415 Astronomide Sayısal Çözümleme - I #\n",
"## Ders - 04 Şartlı İfadeler ve Fonksiyonlar ##"
]
},
{
"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",
"## Fonksiyonlar ve Şartlı İfadeler ##\n",
"\n",
"* [Fonksiyonlar](#Fonksiyonlar)\n",
" * [Tek Değişkenli Fonksiyonlar](#Tek-Değişkenli-Fonksiyonlar)\n",
" * [Fonksiyon Çağırmak](#Fonksiyon-Çağırmak)\n",
" * [Yerel ve Global Nesneler](#Yerel-ve-Global-Nesneler)\n",
" * [Fonksiyona Birden Fazla Nesne Göndermek](#Fonksiyona-Birden-Fazla-Nesne-Göndermek)\n",
" * [Fonksiyondan Birden Fazla Nesne Döndürmek](#Fonksiyondan-Birden-Fazla-Nesne-Döndürmek)\n",
" * [Örnekler 1](#Örnekler-1)\n",
" * [Değer Döndürmeyen Fonksiyonlar](#Değer-Döndürmeyen-Fonksiyonlar)\n",
" * [Anahtar Kelime Argümanları](#Anahtar-Kelime-Argümanları)\n",
" * [Belirsiz Sayıda Fonksiyon Argümanı](#Belirsiz-Sayıda-Fonksiyon-Argümanı)\n",
" * [Örnekler 2](#Örnekler-2)\n",
"* [İç Dokümantasyon İfadeleri](#İç-Dokümantasyon-İfadeleri)\n",
"* [Lambda Fonksiyonları](#Lambda-Fonksiyonları)\n",
" * [Opsiyonel: Lambda Fonksiyonları ve Eşleştirme: Mapping](#Lambda-Fonksiyonları-ve-Eşleştirme:-Mapping)\n",
" * [Opsiyonel: Lambda Fonksiyonları ve Filtreleme: Filtering](#Lambda-Fonksiyonları-ve-Filtreleme:-Filtering)\n",
" * [Opsiyonel: Lambda Fonksiyonları ve İndirgeme: Reducing](#Lambda-Fonksiyonları-ve-İndirgeme:-Reducing)\n",
"* [Şartlı Yapılar: if, elif, else](#Şartlı-Yapılar:-if,-elif,-else)\n",
"* [Alıştırmalar](#Alıştırmalar)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Fonksiyonlar #\n",
"\n",
"Programlama dillerinde fonksiyon matematikteki fonksiyonlardan daha farklı bir anlam taşır. Fonksiyon bir programda istediğiniz zaman ve istediğiniz yerde kullanabileceğiniz ifadeler bütünüdür. Fonksiyona isterseniz nesneler yollayarak fonksiyon içerisindeki kullanımlarıyla hesaplamaları etkileyebilir ve fonksiyondan programa nesneler döndürebilirsiniz. \n",
" \n",
"Fonksiyonlar belirli bir işi yapan bir kod bütününü birden fazla kez yazmayı önler. Bu strateji sizi defalarca kez aynı şeyi yazmaktan ya da kopyalamaktan ve kodunuzun giderek daha fazla yer kaplamasından kurtarır.\n",
"\n",
"Ayrıca fonksiyonlar, tekrarlama gerektiren işlerde yapacağınız bir değişiklikte, tüm bu kodları tek tek bulup değiştirmeniz yerine tek bir yerde (fonksiyon yapısı içinde) ve kolayca değiştirmenize de olanak sağlarlar.\n",
"\n",
"Ayrıca programınızı daha küçük parçalara bölmeniz sayesinde daha rahat yönetebilir ve daha “temiz” düşüebilirsiniz. Bu bölümde daha önce gördüğünüz $sqrt$, $len$, $range$ gibi fonksiyonlara ilaveten kendi fonksiyonlarınızı nasıl yazacağınızı öğreneceksiniz."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[Başa Dön](#Fonksiyonlar-ve-Şartlı-İfadeler)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Tek Değişkenli Fonksiyonlar ##\n",
"\n",
"Önceki derslerden Santigrat derece / Fahrenheit derece dönüşümünü hatırlıyorsunuz. Böyle bir dönüşüm için bir fonksiyon yazmak akılcıdır. Çünkü bu dönüşümü programlarınız içinde defalarca kullanmanız gerekebilir."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"def F(C):\n",
" fahr = (9.0/5)*C + 32\n",
" return fahr"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Kullanıcı tarafından yazılan tüm fonksiyonlar $def$ ifadesiyle, yani fonksiyonun tanımıyla başlar. Daha sonra fonksiyonun adı (örneğimizde $F$), parantez içerisinde fonksiyona programdan gönderilen nesne(ler)in (argümanlar) fonksiyon içerisinde kullanılacak isimleri (birden fazla olması durumunda virgülle ayrılır) ve en sonda da \":\" işareti bulunur. Döngülerden de hatırlayacağınız gibi bu işaret (:) yorumlayıcıya yeni bir kod bloğuna geçeceğinizi söyler. Dolayısı ile fonksiyonlarda da tıpkı döngülerde olduğu gibi, fonksiyon içerisinde çalışması istenen tüm ifadeler bir blok \\\"\" ya da 4 boşluk standarttır) içeri yazılır.\n",
"\n",
"Her fonksiyon için zorunlu olmasa da çoğu fonksiyon programa nesne(ler) de döndüebilir. Bunun için $return$ ifadesi kullanılır. Birden fazla nesne döndürülmek istendiğinde bu nesneler virgüllerle birbirinden ayrılır.\n",
"\n",
"$def$ ile başlayan satır fonksiyonun başlığı (header), bir blok içeri yazılan her şey ise fonksiyonun yapısı (body) olarak adlandırılır.\n",
"\n",
"[Başa Dön](#Fonksiyonlar-ve-Şartlı-İfadeler)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Fonksiyon Çağırmak ##\n",
"\n",
"Bir fonksiyonu kullanmak ve ondan değer alabilmek için o fonksiyonu “çağırmanız\" gerekir. Tipik birkaç örnek aşağıda verilmiştir."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"50.0\n",
"68.0\n",
"118.0\n",
"[23.0, 32.0, 41.0, 50.0, 59.0, 68.0, 77.0, 86.0, 95.0, 104.0]\n"
]
}
],
"source": [
"santigrad = 10\n",
"fahrenheit = F(10) # ile asagidaki ifade aynidir\n",
"fahrenheit = F(santigrad) # zira santigrad 10 olarak tanimlanmis\n",
"print(fahrenheit)\n",
"print(F(santigrad+10.0))\n",
"toplam_sicaklik = F(10) + F(20)\n",
"print(toplam_sicaklik)\n",
"Cderece = range(-5,41,5)\n",
"Fderece = [F(C) for C in Cderece]\n",
"print(Fderece)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"İstenildiği takdirde fonksiyon formatlı bir metin döndürecek şekilde yazılabilir, fonksiyonun içinde de nesneler tanımlanabilir. "
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"21.0 santigrad derece 69.8 fahrenheit derecedir\n"
]
}
],
"source": [
"def F2(sant):\n",
" fahr = (9.0/5)*sant + 32\n",
" return \"{:.1f} santigrad derece {:.1f} fahrenheit derecedir\".format(sant, fahr)\n",
"metin = F2(21.0)\n",
"print(metin)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[Başa Dön](#Fonksiyonlar-ve-Şartlı-İfadeler)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Yerel ve Global Nesneler ##\n",
"\n",
"Bir önceki örnekte $F2$ fonksiyonu içerisinde yarattığımız $fahr$ değişkeni fonksiyonun içinde yerel bir nesnedir. Bu nesnenin değerine fonksiyonun dışında programın herhangi başka bir yerinden ulaşmak istenirse bir hata mesajı alınır."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"santigrad = 21.0\n",
"metin = F2(santigrad)\n",
"print(metin)\n",
"print(fahr)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Yerel değişkenler fonksiyonun içinde yaratılırken, fonksiyon terk edildiği anda “yok edilirler”. Bu olguyu anlamak için aşağıdaki örneği inceleyelim."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def F3(C):\n",
" F_deger = (9.0/5)*C + 32\n",
" print('F3 fonksiyonunda: C={:.1f}, F_deger={:.1f}, r={:d}'.format(C, F_deger, r))\n",
" return '{:.1f} derece santigrad {:.1f} fahrenheit derecedir.'.format(C, F_deger)\n",
"C = 60 # C global tamsayi nesnesini olusturalim.\n",
"r = 21 # bir baska global nesne\n",
"s3 = F3(r)\n",
"print(s3)\n",
"print(C)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Aynı isme sahip birden fazla nesneniz olduğunda Python öncelikle yerel nesneler arasında bir arama yapar, sonra global değişkenlere bakar ve son olarak da hazır (built-in: kullanıcı tarafından tanımlanmamış) Python fonksiyonlarına bakar. Aşağıda bu kural, $sum$ isminin birden fazla nesneye verildiği bir örnekle anlatılmaktadır. "
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"Fonksiyonun disinda global tamsayi nesnesi sum: 500\n",
"Fonksiyonun icinde yerel nesnesi sum: 3\n",
"Fonksiyonun disinda onun gonderdigi degeri tutan global nesne sum: 4\n"
]
}
],
"source": [
"print(sum) # sum hazir (built-in) bir Python fonksiyonudur\n",
"sum = 500 # sum burada bir global tamsayi nesnesi olarak tanimlanmaktadir\n",
"print(\"Fonksiyonun disinda global tamsayi nesnesi sum: \",sum)\n",
"def fonk1(n):\n",
" sum = n + 1\n",
" print(\"Fonksiyonun icinde yerel nesnesi sum: \", sum) # sum bir yerel nesne olarak tanimlanmaktadir\n",
" return sum\n",
"sum = fonk1(2) + 1 # global nesne sum'a yeni deger ataniyor\n",
"print(\"Fonksiyonun disinda onun gonderdigi degeri tutan global nesne sum: \", sum)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Global nesnelere bir fonksiyon içerisinden erişmek mümkün olduğu halde (gördüğünüz gibi!), onların değerini fonksiyon içerisinde değiştirmek için değişkenin global olduğunu ayrıca belirtmeniz gerekir. Bu uygulama global değişkenlerin özellikle uzun programlar içinde kontrol etme zorluğu nedeniyle önerilmez, ancak gerçekten gerektiğinin düşünüldüğü durumlarda ve dikkatli bir şekilde, iç dokümantasyonla kontrol altında tutularak kullanılmalıdır."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"a = 20\n",
"f1(3) = 60.5\n",
"a = 20\n",
"f2(3) = 60.5\n",
"a = 21\n"
]
}
],
"source": [
"a = 20; b = -2.5 # global tamsayi ve kayan sayi nesneleri\n",
"\n",
"def f1(x):\n",
" a = 21 # a yeni bir yerel tamsayi nesnesi olarak yaratiliyor\n",
" return a*x + b # 21*x - 2.5 degeri dondurecek\n",
"\n",
"print(\"a = \", a) # a 20 degerini alir, zira 21 degerine f1 icinde atandi!\n",
" # alacagi deger global degeri olacaktir.\n",
"\n",
"def f2(x):\n",
" global a # simdi a'nin global bir nesne oldugu belirtiliyor\n",
" a = 21 # ve bu nedenle degeri tum program icin\n",
" # fonksiyon icinden dahi degistirilebiliyor\n",
" return a*x + b # Yine 21*x - 2.5 degeri dondurecek\n",
"\n",
"print(\"f1(3) = \", f1(3))\n",
"print(\"a = \", a) # a icin 20 basilir\n",
" # zira henuz a degerini global olarak degistiren\n",
" # f2 cagirilmadi\n",
"print(\"f2(3) = \", f2(3))\n",
"print(\"a = \", a) # a icin 21 basilir zira f2 a degiskeninin degerini\n",
" # global olarak degistirebiliyor!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[Başa Dön](#Fonksiyonlar-ve-Şartlı-İfadeler)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Fonksiyona Birden Fazla Nesne Göndermek ##\n",
"\n",
"Şu ana kadar tanımladığımız fonksiyonlar argüman olarak sadece bir nesne alıyorlardı. Oysa ki Python'da bir fonksiyona istediğiniz sayıda nesne geçirebilirsiniz. Bunun için tek yapmanız gereken argüman olarak geçirmek istediğiniz nesnelerin isimlerini virgüllerle birbirinden ayırmaktır."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"y = 0.55095\n",
"y = 0.55095\n",
"y = 0.55095\n",
"y = 0.55095\n"
]
}
],
"source": [
"def fonk(t, v0):\n",
" g = 9.81 \n",
" return v0*t - 0.5*g*t**2\n",
"# Bu fonksiyonu asagidaki sekillerde cagirabilirsiniz\n",
"# Hepsi ayni degeri (0.55095) basacaktir\n",
"y = fonk(0.1, 6)\n",
"print(\"y = {:.5f}\".format(y))\n",
"y = fonk(0.1, v0=6)\n",
"print(\"y = {:.5f}\".format(y))\n",
"y = fonk(t=0.1, v0=6)\n",
"print(\"y = {:.5f}\".format(y))\n",
"y = fonk(v0=6, t=0.1)\n",
"print(\"y = {:.5f}\".format(y))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Uyarı: Fonksiyonu çağırırken $arguman = deger$ yapısını kullanmak büyük bir esneklik sağlar. Bu şekilde fonksiyona geçirmek istediğiniz tüm argümanları böyle geçirdiğiniz sürece sıralamanın bir önemi kalmaz. Ancak bu yapı yerine sadece değer geçirirseniz, bu değerleri fonksiyonun tanımındaki sıralamaya riayet ederek geçirmek zorunda kalırsınız! \n",
"\n",
"Şu ana kadar sadece matematiksel fonksiyonlara tam ya da reel sayılar geçirip, onlardan tam ya da reel sayı geri dönüşler aldık ya da ekrana değerler bastırdık. Ancak fonkisyonlar bu işlemlerin ötesinde de kullanılabilir."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def listeyap(baslangic, son, adim):\n",
" # verilen son dahil olmak uzere baslangic ile son arasinda \n",
" # adim degeri kadar artimlarla liste olusturan fonksiyon\n",
" eleman = baslangic\n",
" liste = []\n",
" while eleman <= son:\n",
" liste.append(eleman)\n",
" eleman += adim\n",
" return liste\n",
"listem = listeyap(0, 10, 2)\n",
"print(listem)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Bu örnekte $baslangic$, $son$, $adim$, $eleman$ ve $liste$ nesneleri yerel; $listem$ nesnesi ise globaldir.\n",
"\n",
"[Başa Dön](#Fonksiyonlar-ve-Şartlı-İfadeler)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Fonksiyondan Birden Fazla Nesne Döndürmek ##\n",
"\n",
"Şu ana kadar yazdığımız tüm fonksiyonlar tek bir değer döndürüyor. Oysa Python fonkisyonları birden fazla değeri döndürebilir. Dikey atış probleminde cismin $t$ zamanda aldığı toplam yolun yanı sıra bunun zamana göre türevini de (yani t anındaki hızını!) döndürmek istiyor olalım."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Cismin t=0.6 saniyedeki konumu 1.83, hizi 0.11 tir\n",
"(1.8341999999999996, 0.11399999999999988)\n"
]
}
],
"source": [
"def fonk(t, v0):\n",
" g = 9.81\n",
" y = v0*t - 0.5*g*t**2\n",
" dydt = v0 - g*t\n",
" return y, dydt\n",
"\n",
"# Bu fonksiyondan deger dondururken iki degiskene ihtiyac duyariz\n",
"konum, v0 = fonk(0.6, 6)\n",
"print(\"Cismin t={:.1f} saniyedeki konumu {:.2f}, hizi {:.2f} tir\".format(0.6, konum, hiz))\n",
"# Coklu nesne donduren fonksiyonlardan dondurulen bir demet degiskendir\n",
"demet = fonk(0.6, 6)\n",
"print(demet)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[Başa Dön](#Fonksiyonlar-ve-Şartlı-İfadeler)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Örnekler 1 ##\n",
"### ln(1 + x) 'in Seriye Açılımı ###\n",
"\n",
"$$L(x;n) = \\sum\\limits_{i=1}^n \\frac{1}{i} (\\frac{x}{1 + x})^i$$\n",
"\n",
"$$ln(1 + x) = \\lim_{n\\to\\infty} L(x;n)$$\n",
"\n",
"ln(1 + x)'in yukarıdaki ifadelerle seriye açılması için aşağıdaki bir döngü yapısına ihtiyaç duyulur:\n",
"\n",
"```\n",
"s = 0\n",
"for i in range(1, n+1):\n",
" s += (1.0/i)*(x/(1.0 +x ))**i\n",
"```\n",
"\n",
"Aşağıdaki gibi $x$ ve $n$'i birer argüman olarak alıp toplamı döndüren bir fonksiyon işi oldukça kolaylaştırır."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def L(x, n):\n",
" s = 0\n",
" for i in range(1, n + 1):\n",
" s += (1.0/i)*(x/(1.0 + x))**i\n",
" return s"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Bir matematiksel fonksiyonun değerinin seriye açılarak hesaplanmasıyla elde edilen sonuç, $n$ → ∞ olamayacağı için her zaman bir hata taşır. Bu hatayı ve $n$'in herhangi bir değeri için ihmal edilen ilk terimi döndüren bir fonksiyon matematiksel olarak çok daha “fonksiyonel” olacaktır."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Sonuc: 1.79, yaklasik hatasi: 0.0000000000996260, hatasi: 0.0000000005709522 tir\n"
]
}
],
"source": [
"def L(x, n):\n",
" s = 0\n",
" for i in range(1, n + 1):\n",
" s += (1.0/i)*(x/(1.0 + x))**i\n",
" toplam = s\n",
" ihmal_edilen_ilk_terim = (1.0/(n + 1))*(x/(1.0 + x))**(n + 1)\n",
" from math import log\n",
" hata = log(1 +x ) - toplam\n",
" return toplam, ihmal_edilen_ilk_terim, hata\n",
"\n",
"# n = 100 ve x = 5, icin ln(1+x)\n",
"sonuc, tahmini_hata, tam_hata = L(x = 5, n = 100)\n",
"print(\"Sonuc: {:.2f}, yaklasik hatasi: {:.16f}, hatasi: {:.16f} tir\"\\\n",
" .format(sonuc, tahmini_hata, tam_hata))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[Başa Dön](#Fonksiyonlar-ve-Şartlı-İfadeler)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Değer Döndürmeyen Fonksiyonlar ##\n",
"\n",
"Tüm fonksiyonlar değer döndürmek zorunda değildir. Bu durumda $return$ ifadesi verilmeyebilir. Bazı programcılık dillerinde (fortran, C) bu tür fonksiyonlara subroutine ya da procedure da denir."
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"x=5, ln(1+x)=1.79176\n",
"n=1 0.833333 (bir sonraki terim: 3.47e-01 hata: 9.58e-01\n",
"n=2 1.18056 (bir sonraki terim: 1.93e-01 hata: 6.11e-01\n",
"n=10 1.73684 (bir sonraki terim: 1.22e-02 hata: 5.49e-02\n",
"n=100 1.79176 (bir sonraki terim: 9.96e-11 hata: 5.71e-10\n",
"n=500 1.79176 (bir sonraki terim: 4.27e-43 hata: 2.22e-16\n"
]
}
],
"source": [
"def tablo(x):\n",
" # Deger dondurmeyen fonksiyon\n",
" from math import log\n",
" print('\\nx={:g}, ln(1+x)={:g}'.format(x, log(1+x)))\n",
" for n in [1, 2, 10, 100, 500]:\n",
" sonuc, terim, hata = L(x, n)\n",
" print('n={:<4d} {:<10g} (bir sonraki terim: {:8.2e} hata: {:8.2e}'.\\\n",
" format(n, sonuc, terim, hata))\n",
"tablo(5)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Bu fonksiyonu $L$ fonksiyonu ile aynı programa yazıp, çağırırsanız $n = 1, 2, 10, 50, 100$ terim kullanarak ln(1+x) değerini verilen seriyle hesaplar. (Deneyiniz!) \n",
"\n",
"Python return ifadesi olmayan fonksiyonlara gerçekte $return None$ şeklinde gizli bir ifade ekler. $None$ özel bir Python nesnesidir."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[Başa Dön](#Fonksiyonlar-ve-Şartlı-İfadeler)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Anahtar Kelime Argümanları ##\n",
"\n",
"İhtiyacımıza göre fonksiyonlarda anahtar kelimeler kullanıp, bunları her zaman değiştirmek istemediğmiz için varsayılan değerlere atayabiliriz. Böylece fonksiyonu bu değerleri değiştirmeden çağıracağımız vakit bu değişkenleri kullanmak zorunda kalmayız! Tipik bir örnek aşağıdaki gibidir."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def fonk(arg1, arg2, kwarg1=True, kwarg2=0):\n",
" print(arg1, arg2, kwarg1, kwarg2)\n",
"fonk('Merhaba', [1,2])\n",
"fonk('Merhaba', [1,2], kwarg1='Selam')\n",
"fonk('Merhaba', [1,2], kwarg2='Selam')\n",
"fonk('Merhaba', [1,2], kwarg2='Selam', kwarg1=6)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$arg1$,$arg2$ normal, sıradan argümanlarken (positional arguments: konum argümanları), $kwarg1$ ve $kwarg2$, anahtar kelime argümanları (keyword arguments) olarak adlandırılır. Fonksiyon tanımlarında anahtar kelime argümanları, konum argümanlarından sonra yazılmalıdır."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[Başa Dön](#Fonksiyonlar-ve-Şartlı-İfadeler)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Örnekler 2 ##\n",
"### Fourier Fonksiyonu ve Harmonik Hareket ###\n",
"\n",
"Fourrier fonksiyonunu $t$'yi bağımsız değişken yapıp $A$, $a$ ve $\\omega$ için uygun varsayılan değerlerin verildiği bir fonksiyonla yazıp, bir yerlerde saklayabiliriz. Astronomide muhakkak işimize yarayacaktır! \n",
"\n",
"$$f(t, A, a, \\omega) = A e^{-a t} sin(\\omega t)$$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from math import pi, exp, sin\n",
"def f(t, A=1, a=1, omega=2*pi):\n",
" return A*exp(-a*t)*sin(omega*t)\n",
"\n",
"# Bu fonksiyon icin alternatif cagirma ifadeleri\n",
"v1 = f(0.2)\n",
"v2 = f(0.2, omega=1)\n",
"v3 = f(1, A=5, omega=pi, a=pi**2)\n",
"v4 = f(A=5, a=2, t=0.01, omega=0.1)\n",
"v5 = f(0.2, 0.5, 1, 1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Belirsiz Sayıda Fonksiyon Argümanı ##\n",
"\n",
"Fonksiyonlarınızda zaman zaman sayısını bilmediğiniz argüman üzerinde işlem yapma olasılığı oluşabilir. $*args$ ve $**kwargs$ şeklinde iki ayrı yazımla (syntax) belirsiz sayıda argüman fonksiyona geçirilebilir. $*args$ şeklinde, tek bir yıldız (asterisk, \\*) anahtar kelime argümanı olmayan, belirsiz sayıdaki argümanı bir fonksiyona geçirmek için kullanılırken; iki yıldız (asterisk, \\*\\*) belirsiz sayıdaki anahtar kelime argümanını bir fonksiyona geçirmek için kullanılır. \n",
"\n",
"### 1. Belirsiz Sayıda (Anahtar Kelime Argümanı Olmayan) Argüman (ing. Positional Arguments) İçeren Fonksiyonlar ###\n",
"\n",
"Bir fonksiyona değişken (belirsiz) sayıda, bulunduğu konuma göre değer alan (anahtar kelime argümanı olmayan) argüman geçirilmek istendiğinde bu argümanların toplanacağı demet nesnesinin isminin önüne bir * işareti konulur. Bu demet nesnesi fonksiyona gönderilen, bulundukları konuma göre değer alan ya da anahtar kelime olarak tanımlanmış argümanların dışındaki tüm değerleri bir arada tutar. Fonksiyonun içerisinde ona bu demet değişken üzerinden gönderilen her bir değere demet değişken fonksyonları, dilimleme ya da klasik $for$ ve $while$ döngüleri yoluyla ulaşılablir.\n",
"\n",
"Aşağıda biri tek bir nesne değer ($normarg$), diğeri ise varsayılan birer değeri olmayan ve belirsiz sayıda nesne değerini bir demet nesnesi argümanında ($*args$) tutan argümanlar üzerinden çalışan $test\\_args$ isimli bir fonksyon tanımlanmıştır. Fonksiyon öncelikle $normarg$ yerel değişkenine aktarılan nesne değerini ekrana yazdırmakta, sonra da bir $for$ döngüsü içerisinde belirsiz sayıda nesne değerini tutan $*args$ demet nesnesindeki değerleri tek tek ekrana yazdırmaktadır. Program $for$ döngüsü sonrası ekrana çalışmasını döngünün tamamlandığını bildiren bir dizi $\"-\"$ işareti getirmektedir. Son olarak ise $args$ nesnesinin tüm bu değerleri tutan bir demet nesnesi olduğu bir $print$ ifadesi ile gösterilmektedir. Örnek bu fonksiyon programa herhangi bir değer döndürmemektedir, ancak bu belirsiz sayıda argüman içeren fonksiyonların programa değer döndüremedikleri anlamına da gelmez."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Normal bir arguman: 1\n",
"Diger Argumanlar: iki\n",
"Diger Argumanlar: 3\n",
"Diger Argumanlar: 4.5\n",
"---------------------------------\n",
"('iki', 3, 4.5)\n"
]
}
],
"source": [
"def test_args(normarg, *args):\n",
" print(\"Normal bir arguman:\", normarg)\n",
" # Belirsiz sayida argumanin sirayla alinmasi\n",
" for arg in args:\n",
" print(\"Diger Argumanlar:\", arg)\n",
" print(\"---------------------------------\")\n",
" print(args)\n",
"test_args(1, \"iki\", 3, 4.5,)\n",
"#test_args(1)\n",
"#test_args(1, ['x','y','z'])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Aşağıdaki örnekte belirsiz sayıda tam ya da kayan noktalı sayıyı toplayan ve programda çağrıldığı noktaya döndüren bir fonksiyon ($topla$) görülmektedir. Görüldüğü üzere fonksiyon 4 ya da 1 sayı argümanı için çalıştığı gibi hiç argüman gönderilmese dahi hata vermeden çalışmaktadır. "
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Toplam = 22.80\n",
"2\n",
"0\n"
]
}
],
"source": [
"# Belirsiz sayida sayiyi toplayan kucuk bir kod parcasi\n",
"def topla(*sayilar):\n",
" toplam = 0\n",
" for sayi in sayilar:\n",
" toplam += sayi\n",
" return toplam\n",
"\n",
"print(\"Toplam = {:.2f}\".format(topla(1.2, 3,5 ,5,1 , 7.6)))\n",
"print(topla(2))\n",
"print(topla())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2. Belirsiz Sayıda Anahtar Kelime Argümanı İçeren (ing. Keyword Arguments) Fonksiyonlar\n",
"\n",
"Bir fonksiyona değişken (belirsiz) sayıda, ancak anahtar kelime argümanı yapısında ve $anahtar = deger$ şeklinde tanımlanan argümanlar geçirilmek istendiğinde bu argümanların toplanacağı sözlük nesnesinin ($dictionaries$) isminin önüne iki $**$ işareti konulur. Bu sözlük nesnesi fonksiyona gönderilen, bulundukları konuma göre değer alan ya da anahtar kelime olarak tanımlanmış argümanların dışındaki tüm değerleri bir arada tutar. Fonksiyonun içerisinde bu sözlük nesnesinin elemanlarına sözlük fonksyonları (henüz sözlük nesnesi verilmemiş olduğu için bu fonksiyonları şu aşamada bilmek zorunda değilsiniz), ya da $sozlukadi[anahtar]$ ifadesiyle ulaşılablir.\n",
"\n",
"Aşağıda biri tek bir nesne değer ($normarg$), diğeri ise tuttuğu belirsiz sayıda nesne değerini bir sözlük nesnesi yapsında saklayan ($**kwargs$) argümanlar üzerinden çalışan $test\\_kwargs$ isimli bir fonksyon tanımlanmıştır. Fonksiyon öncelikle $normarg$ yerel değişkenine aktarılan nesne değerini ekrana yazdırmakta, sonra da bir $for$ döngüsü içerisinde, $**kwargs$ sözlük nesnesindeki belirsiz sayıdaki nesnenin anahtarlarını ($key$) ve anahtarlara karışılık gelen değerleri ($value$) tek tek ekrana yazdırmaktadır. Program $for$ döngüsü sonrası ekrana çalışmasını döngünün tamamlandığını bildiren bir dizi $\"-\"$ işareti getirmektedir. Son olarak ise $kwargs$ nesnesinin tüm bu değerleri tutan bir sözlük nesnesi olduğu bir $print$ ifadesi ile gösterilmektedir. Tıpkı anahtar kelime argümanı olmayan ve belirsiz sayıda argüman içeren $args$ demet değişkenin tanımlanmasında olduğu gibi tanım ifadesinde $**$ karakteri başa gelecek şekilde tanımlanmakta, ancak bu karakterler fonksiyon içerisinde söz konusu sözlük değişkenine ulaşılırken kullanılmamaktadır."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Normal bir arguman: 1\n",
"Anahtar kelime argumani arg2: iki\n",
"Anahtar kelime argumani arg3: 3\n",
"---------------------------------\n",
"{'arg2': 'iki', 'arg3': 3}\n"
]
}
],
"source": [
"def test_kwargs(normarg, **kwargs):\n",
" print(\"Normal bir arguman:\", normarg)\n",
" for key in kwargs:\n",
" print(\"Anahtar kelime argumani {:}: {:}\".format(key, kwargs[key]))\n",
" print(\"---------------------------------\")\n",
" print(kwargs)\n",
" \n",
"test_kwargs(normarg=1, arg2=\"iki\", arg3=3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Aşağıdaki örnekte belirsiz sayıda öğrencinin öğrenci numaralarına karşılık ad soyadlarını ekrana yazdıran bir fonksiyon (print_ogrenciler) görülmektedir. Görüldüğü üzere fonksiyona öğrencilerin numaraları (anahtar) ve ad-soyadları (değer) $anahtar = deger$ ($key = value$) yapısında gönderilmektedir. Bu anahtar kelime argümanları için tipik bir yapıdır ve dikey atış probleminde cismin t anındaki konumunu bulan fonksiyonda yerçekim ivmesi de ($g = 9.81$) aynı şekilde tanımlanmıştır. Öğrenci numaralarının önüne \"\\_\" işaretinin konmasının tek sebebi değişken isimlerinin sadece sayılardan oluşamaması kuralıdır ve başkaca bir sebebi yoktur. $for$ döngüsü dahilinde $ogrenciler$ sözlük değişkeninde toplanan belirsiz sayıda nesnenin anahtarları (ing. key) $ogrno$ nesnesine aktarılıp basılmaktadır Baştaki \"\\_\" karakterini atlamak için yazdırmaya 1. indeksten başlandığına dikkat ediniz. Sonrasında döngünün tamamlandığını bildiren bir dizi \"---\" işareti ve son olarak ise belirsiz sayıdaki anahtar kelime argümanını tutan $ogrenciler$ sözlük nesnesi bir $print$ ifadesi ile gösterilmektedir.\n",
"\n",
"Dikkat edilmesi gereken hususlardan biri de ister anahtar kelime argümanı olsun, ister olmasın, bir kural olmamakla birlikte, argümanları tutan demet ve sözlük nesnelerini sırasıyla $*args$ ve $**kwargs$ isimlerindeki yer değişkenler olmasıdır. Aşağıdaki örnekte $kwargs$ yerine $ogrenciler$, yukarıdaki $topla$ fonksiyonunda ise $*args$ yerine $sayilar$ degişkenleri bu amaçla kullanılmıştır."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'_11050013': 'Umut Akdemir', '_12050566': 'Pinar Tunc', '_15050021': 'Buse Sayar'}\n",
"Ogrenci no: 11050013\t Ad Soyad: Umut Akdemir\n",
"Ogrenci no: 12050566\t Ad Soyad: Pinar Tunc\n",
"Ogrenci no: 15050021\t Ad Soyad: Buse Sayar\n"
]
}
],
"source": [
"# Derse gelen ogrencilerin adini yazdiran fonksyon\n",
"def print_ogrenciler(**ogrenciler):\n",
" \n",
" for ogrno in ogrenciler:\n",
" print(\"Ogrenci no: {:s}\\t Ad Soyad: {:s}\"\\\n",
" .format(ogrno[1:], ogrenciler[ogrno]))\n",
" print(\"---------------------------------\")\n",
" print(ogrenciler)\n",
" \n",
"print_ogrenciler(\n",
" # degisken isimleri sayi olamayacagi icin\n",
" # baslarina _ isareti koaylim\n",
" _11050013 = \"Umut Akdemir\",\n",
" _12050566 = \"Pinar Tunc\",\n",
" _15050021 = \"Buse Sayar\"\n",
" )"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[Başa Dön](#Fonksiyonlar-ve-Şartlı-İfadeler)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# İç Dokümantasyon İfadeleri #\n",
"\n",
"Python'da bir fonksiyonun ne yaptığını kodu yazan kişinin kendisine ve o kodu okuyan başkalarına anlatmak için kullandığı standart bir yapı vardır. İç dokümantasyon (ing. Doc String) denen bu ifadeler \\\"\\\"\\\" (üç tırnak) arasına yazılırlar."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def C2F(C):\n",
" \"\"\"Santigrad dereceyi (C) Fahrenheit dereceye cevirir.\"\"\"\n",
" return (9.0/5)*C + 32\n",
"\n",
"def line(x0, y0, x1, y1):\n",
" \"\"\"\n",
" (x0,y0) ve (x1,y1) noktalarindan gecen bir dogrunun\n",
" denklemini ax + b seklinde ifade ederken kullanilan\n",
" a ve b katsayilarini hesaplar ve dondurur.\n",
" x0, y0: dogru uzerinde bir nokta (her ikisi de float)\n",
" x1, y1: dogru uzerinde diger nokta (her ikisi de float)\n",
" return: y = ax + b dogrusu icin a ve b katsayilari (float)\n",
" \"\"\"\n",
" a = (y1 - y0)/float(x1 - x0)\n",
" b = y0 - a*x0\n",
" return a, b"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[Başa Dön](#Fonksiyonlar-ve-Şartlı-İfadeler)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Fonksiyonların Fonksiyon Argümanları #\n",
"\n",
"Python'da bir fonksiyonun argümanı herhangi bir nesne olabilir (tam sayı, reel sayı, metin, liste, demet hiç farketmez. Bu nedenle bir fonksiyonun fonksiyon argümanı da olabilir ve bu özellikle bazı matematiksel problemlerin nümerik çözümünde oldukça da kullanışlıdır. Örnek olarak bir fonkisyonun ikinci türevinin tanımını ele alalım.\n",
"\n",
"$$f''(x) \\approx \\frac{f(x - h) - 2f(x) + f(x + h)}{h^2}$$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def diff2(f, x, h=1E-6):\n",
" r = (f(x-h) - 2*f(x) + f(x+h))/float(h*h)\n",
" return r\n",
"\n",
"def g(t):\n",
" return t**(-6)\n",
"\n",
"t = 1.2\n",
"print(\"t^-6 fonksiyonunun ikinci turevinde {:.1f}\".format(t))\n",
"d2g = diff2(g, t)\n",
"print(\"g’’({:f}) = {:.1f}\".format(t, d2g))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[Başa Dön](#Fonksiyonlar-ve-Şartlı-İfadeler)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Lambda Fonksiyonları #\n",
"\n",
"Python'da oldukça hızlı bir fonksiyon tanımlama yöntemi bulunmaktadır. Lambda fonksiyonu adı verilen bu fonksiyonlar, sınırlı kabiliyetlerine rağmen, basit işleri yapmak üzere çok hızlı (tek satırda) tanımlanabildikeri için oldukça kullanışlıdırlar."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"f = lambda x: x**2 + 4\n",
"print(f(2))\n",
"def f2(x): \n",
" # verilen lambda fonksiyonuna ozdes fonksiyon\n",
" return x**2 + 4\n",
"print(f2(2))\n",
"f = lambda x, y : x + y\n",
"print(f(1,1))\n",
"F = lambda C: (9./5)*C + 32\n",
"print(F(21.0))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[Başa Dön](#Fonksiyonlar-ve-Şartlı-İfadeler)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Lambda Fonksiyonları ve Eşleştirme: Mapping ##\n",
"\n",
"Eşleştirme (mapping), filtreleme (filtering) ve indirgeme (reducing) Python 2.x'te de yer alan pratik fonksiyonlardır. Ancak aralarında Python'un yaratıcısı Guido van Rossum'un da yer aldığı bazı Python programcıları, bu fonksiyonlarla gelen fonksiyonalitenin hızlı ve kompakt bir yazımla liste oluşturmayı sağlayan list comprehensions ile de elde edilebileceği nedeniyle kullanımlarını önermemektedirler. AST415 dersinde de öğrenciler bu yapılardan sorumlu tutulmamıştır ve öğrenilmesi takip edenlerin isteğine bırakılmıştır. Ayrıca bu fonksiyonlara özdeş sonuçların hızlı liste oluşturma yöntemleri (list comprehensions) nasıl oluşturulabileceğine ilişkin örnekler bu dersin [Alıştırmalar](#Alıştırmalar) bölümünde yer almaktadır.\n",
"\n",
"Eşleştirme (mapping): Lambda fonksiyonlarının özellikle listelerle birlikte çok efektif bir şekilde kullanımını sağlayan bir yöntemdir. Bu işlem $map$ fonksiyonu ile yapılır. $map$ fonksiyonu bir fonksiyonun bir dizinin bütün elemanları üzerinde uygulanmasını sağlar. Sonuç fonksiyon uygulandıktan sonra oluşan bir dizidir. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"Cderece = list(range(-5,41,5))\n",
"Fderece = list(map(lambda x: (float(9)/5)*x + 32, Cderece))\n",
"print(Fderece)\n",
"a = [1,2,3,4]\n",
"b = [17,12,11,10]\n",
"c = [-1,-4,5,9]\n",
"print(list(map(lambda x,y:x+y, a,b)))\n",
"print(list(map(lambda x,y,z:x+y+z, a,b,c)))\n",
"print(list(map(lambda x,y,z:x+y-z, a,b,c)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[Başa Dön](#Fonksiyonlar-ve-Şartlı-İfadeler)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Lambda Fonksiyonları ve Filtreleme: Filtering ##\n",
"\n",
"Filtreleme (filtering): Bir fonksiyonun $True$ döndürdüğü değerlere göre bir liste içinden eleme yapmak oldukça “zarif” bir yöntemdir. Bu işlem $filter$ fonksiyonu ile yapılır ve lambda fonksiyonları bu işlemde önemli bir kolaylık sağlarlar."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fib = [0,1,1,2,3,5,8,13,21,34,55]\n",
"ikiye_tam_bolunenler = list(filter(lambda x: x % 2 == 0, fib))\n",
"print(ikiye_tam_bolunenler)\n",
"ikiye_tam_bolunmeyenler = list(filter(lambda x: x % 2, fib))\n",
"print(ikiye_tam_bolunmeyenler)\n",
"a = range(-5,5)\n",
"negatifler = list(filter(lambda x: x<0, a))\n",
"print(negatifler)\n",
"pozitifler = list(filter(lambda x: x>0, a))\n",
"print(pozitifler)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[Başa Dön](#Fonksiyonlar-ve-Şartlı-İfadeler)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Lambda Fonksiyonları ve İndirgeme: Reducing ##\n",
"\n",
"İndirgeme (reducing): Bu fonksiyon Python 3.x ile birlikte herhangi bir paket kullanılmadan çalışan, hazır (built-in) bir fonksiyon olmaktan çıkarılmış ve $functools$ modülüne taşınmıştır. Dolayısı ile kullanılması için bu modülden çağrılması ($import$ edilmesi) gereklidir. $reduce(fonksiyon, dizi)$ fonksiyonu argüman olarak verilen dizi üzerinde sürekli uygular ve tek bir değer döndürür. Dizi argüman $s = [ s1, s2, s3, ... , sn ]$ şeklinde tanımlanmış bir Python listesi olsun. Öncelikle argüman olarak verilen fonksiyon $s1$ ve $s2$ üzerine uygulanır. Fonksiyon bu değerlerden birini seçer. Daha sonra fonksiyon seçilen bu değer ile $s3$ üzerine uygulanır (fonksiyon((fonksiyon(s1,s2),s3)). Bir sonraki adımda bu kez seçilen değer ile $s4$'e uygulanır ve bu işlem verilen listede tek bir eleman kalıncaya kadar devam eder."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from functools import reduce\n",
"gauss_toplam = reduce(lambda x, y: x+y, range(1,101))\n",
"print(gauss_toplam)\n",
"L = ['Python ', 'programlama ', 'dili ', 'bir ', 'harika ', 'dostum!']\n",
"birlesik = reduce(lambda x,y:x+y, L)\n",
"print(birlesik)\n",
"carpim = reduce(lambda x, y: x * y, [1, 2, 3, 4])\n",
"print(carpim)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[Başa Dön](#Fonksiyonlar-ve-Şartlı-İfadeler)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Şartlı Yapılar: if, elif, else #\n",
"\n",
"Aşağıdaki şekilde tanımlanmış bir f(x) parçalı fonksiyonu olsun.\n",
"\n",
"$$ f(x) = sin(x), 0 \\le x \\le \\pi$$\n",
"$$ f(x) = 0, x \\lt 0 , \\pi \\lt x $$\n",
"\n",
"Bu parçalı fonksiyonu bir Python fonksiyonu olarak yazmak için şartlı ifade yapısı kullanmak gereklidir."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from math import pi, sin\n",
"def f(x):\n",
" if 0 <= x <= pi:\n",
" return sin(x)\n",
" else:\n",
" return 0"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Bir başka örnekte şartlı yapıyı, santigrad-fahrenheit derece dönüşümünde fiziksel olmayan sonuçları denetleyip ayıklamakta kullanalım."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def F(C):\n",
" if C < -273.15:\n",
" print('{:g} derece santigrad fiziksel degildir!'.format(C))\n",
" print('Fahrenheit dereceye donusturme islemi yapilamaz')\n",
" else:\n",
" F = 9.0/5*C + 32\n",
" return F"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Bir başka örnekte aşağıdaki parçalı fonksiyon, bir Python fonksiyonu olarak yazılmak isteniyor olsun.\n",
"\n",
"$$ f(x) = 0, x \\le 0$$\n",
"$$ f(x) = x, 0 \\le x \\lt 1 $$\n",
"$$ f(x) = 2 - x, 1 \\le x \\lt 2 $$\n",
"$$ f(x) = 0, 2 \\le x $$\n",
"\n",
"Bu durumda yapılması gereken $if$ ve $else$ yapılarının yanı sıra $elif$ yapısını da kullanmaktır."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def N(x):\n",
" if x < 0:\n",
" return 0.0\n",
" elif 0 <= x < 1:\n",
" return x\n",
" elif 1 <= x < 2:\n",
" return 2 - x\n",
" elif x >= 2:\n",
" return 0.0"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$if$ – $else$ yapısı Python'da (ve diğer tüm programlama dillerinde) çok kullanılan bir yapı olduğu için Python bu yapı için tek satırlık bir ifade sağlamıştır."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from math import pi, sin\n",
"def f(x):\n",
" return (sin(x) if 0 <= x <= pi else 0)\n",
"print(\"sin(pi/2) = \", f(pi/2.))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Alıştırmalar #\n",
"\n",
"1. Sıcaklığı Kelvin cinsinden verilen bir karacismin ışınımının maksimumunun dalgaobyunu cm cinsinden Wien kayma yasası uyarınca hesaplayan ve döndüren bir fonksiyon yazınız.\n",
"\n",
"2. Görsel parlaklığı (m) kadir cinsinden ve uzaklığı (d) parsek cinsinden verilen bir yıldızın mutlak parlaklığını uzaklık modülünü kullanarak hesaplayan ve döndüren bir fonksiyon yazınız.\n",
"\n",
"3. Verilen iki sayının eşitliğini belirli bir tolerans değeri çerçevesinde denetleyen, bu iki sayının arasındaki farkın multak değeri verilen tolerans değerinden küçükse $True$, değilse $False$ döndüren bir fonksiyon yazınız. Tolerans değerini bir anahtar kelime argümanı (ing. keyword argument) olarak, varsayılan değeri $10^{-6}$ olacak şekilde tanımlayınız. Fonksiyonunuzu test etmek için 1.0 ile 1 / 49 x 49 işleminin sonucunun eşit olup olmadığını denetlemek üzere varsayılan tolerans değeri ve $10^{-16}$ tolerans değerini kullanınız.\n",
"\n",
"4. İki sayıyı argüman olarak alıp, toplamlarını döndüren bir normal fonksiyon bir de onun özdeşi $lambda$ fonksiyonu yazınız.\n",
"\n",
"5. Santigrad dereceyi Fahrenheit'a dönüştüren bir normal fonksiyon bir de özdeşi $lambda$ fonksiyonu yazınız.\n",
"\n",
"6. İlk hızı $V_{0}$ olan bir cismin dikey atış formülünü kullanarak t anındaki konumunu bulan bir fonksiyon yazınız. Fonksiyonunuzun son argümanı varsayılan değeri 9.81 $m/s^{2}$ olan yerçekimi ivmesi ($g = 9.81$) olmalıdır. $yol$ adını vereceğinizi bu fonksiyona özdeş bir de $lambda$ fonksiyonu yazarak, testini $V_{0} = 5 m/s$, $t = 1 s$ ve $g = 10 m/s^{2}$ için fonksiyonlarınızın hesaplayacağı değeri ekrana yazdırmak suretiyle yapınız.\n",
"\n",
"7. Aynı uzunlukta üç listenin karşılıklı elemanlarını toplayarak bir listeye atan ve programda çağrıldığı noktaya döndüren bir fonksiyon yazınız. Fonksiyonunuzu $a = [1,2,3,4], b = [17,12,11,10], c = [-1,-4,5,9]$ listeleri üzerinden test ediniz.\n",
"\n",
"8. $fib = [0,1,1,2,3,5,8,13,21,34,55]$ listesindeki ikiyle bölünebilen sayıları $ikiyle$\\_$tam$\\_$bolunenler$ listesinde bölünmeyenleri $ikiyle$\\_$tam$\\_$bolunmeyenler$ listesinde toplayınız ve bu listeleri ekrana yazdırınız.\n",
"\n",
"9. $a = [0.1, 9.0, -4.2, 0.5, -2.3, 3.1, 11.0]$ listesinde -2'den küçük sayıları, -2 ile 2 arasındaki sayıları (-2 ve 2 dahil) ve 2'den büyük sayıları ekrana yazdıran bir program yazınız. \n",
"\n",
"10. Belirli integral alabilmek için kullanılan yöntemlerden biri de yamuk yöntemidir. $x = a$ ile $x = b$ arasında tanımlı, sürekli ve integrallanebilir bir $f$ fonksiyonunun bu aralıktaki belirli integrali yamuk yöntemiyle aşağıdaki şekilde hesaplanabilir.\n",
"\n",
"$$\\int_{a}^{b} f(x) dx \\approx \\frac{1}{2} \\frac{f(a) + f(b)}{b - a}$$\n",
"\n",
"Bu ifadeyle integral hesaplayan ve programda çağrıldığı yere döndüren bir fonksiyon yazınız. Fonksiyonunuzu a) $math$ kütüphanesindeki $sin$ fonksyonunun $0$ ile $\\pi / 2$ değerleri arasındaki integralini alarak, b) argüman olarak verilen bir $x$ için $x^3$ 'ü hesaplayıp döndüren kendi yazacağınız bir fonksiyonun $1$ ile $3$ değerleri arasındaki integralini hesaplayarak test ediniz.\n",
"\n",
"11. Verilen iki aynı tür nesneyi o nesnelerin toplamına ilişkin kurallar dahilinde toplayıp çağrıldığı noktaya döndüren bir fonksyon yazınız. a) Fonksiyonunuzu iki tam, iki kayan sayı, iki liste ve iki metin nesnesi toplayarak test ediniz. b) Fonksiyonunuzu hiçbir sayı göndermeden, sırasıyla tek bir tane ve üç tane sayı göndererek test ediniz. Çalışmıyorsa neden çalşmadığını anlamaya çalışınız.\n",
"\n",
"12. Bir önceki soruda yazdığınız $toplam$ fonksiyonunu belirsiz sayıda ve anahtar kelime argümanı içermeyen sayıyı (tam ya da kayan noktalı) toplayacak şekilde düzenleyiniz.Fonksiyonunuzu hiçbir sayı göndermeden, sırasıyla tek bir tane, iki tane ve üç tane sayı göndererek test ediniz.\n",
"\n",
"13. Belirsiz sayıda rengi anahtar kelime ($keyword$), bu renklere karşılık HTML renk kodlarını ise değer ($value$) olarak $anahtar = deger$ şeklinde tanımlanan anahtar elime argümanlarını alarak her renk ve ona karşılık renk kodunu ekrana yazdıran bir fonksiyon yazınız. Fonksiyonunuzu kırmızı, beyaz ve siyah renkleri için test ediniz.\n",
"\n",
"14. Belirsiz sayıda anahtar kelime argümanları olarak tanımlayacağınız nesneyi alan ve sırasıyla sadece anahtar isimlerini ekrana yazdıran $sabitler$ isimli bir fonksiyon yazınız. Fonksiyonunuzu yer çekimi sabiti ($g$), evrensel çekim sabiti ($G$), Boltzman sabiti ($k$) ve ışık hızı ($c$) ile test ediniz.\n",
"\n",
"15. Bir önceki soruda yazdığnız fonksiyonu gönderdiğiniz sabitlerin sadece değerlerini ekrana yazdıracak şekilde düzenleyiniz.\n",
"\n",
"16. Bir önceki soruda yazdığınız fonksiyonu gönderdiğiniz sabitler ve değerlerini birlikte ekrana yazdıracak şekilde düzenleyiniz.\n",
"\n",
"17. Program tarafında gönderilen bir n tam sayısına kadar (n hariç) tam sayılar içerisinden 5 ile bölünebilenleri ekrana yazdıran (listeye atmanız ya da programa döndürmeniz istenmemektedir) $beslebolunenler$ isimli bir fonksiyon yazınız. n'in pozitif bir sayı olabileceği gibi negatif bir sayı da olabileceğine; n'in pozitif olması durumunda n'e sayacınızı arttırarak, negatif olması durumunda ise azaltarak ulaşabileceğinize dikkat ediniz. Fonksiyonunuzu $n = 102$ ve $n = -102$ için test ediniz.\n",
"\n",
"18. Kenar uzunlukları verilen bir üçgenin türünü (eşkenar, ikizkenar ya da çeşitkenar) ekrana yazdıran bir fonksiyon yazınız. Fonksiyonunuzu bir eşkenar, bir ikizkenar, bir de çeşitkenar üçgen için test ediniz. \n",
"\n",
"19. \"Eratosthenes'in eleği\" 2'den bir N pozitif tam sayısına kadar (N dahil) tüm asal sayıları veren bir algoritmadır. Verilen bir N pozitif tam sayısı için Eratosthenes'in eleği algoritması ile belirlediği N'den küçük veya eşit tüm asal sayıları bir liste içerisine toplayan ve programda çağrıldığı yere döndüren bir Python fonksiyonu yazınız. Fonksiyonunuzu N = 100 için test ediniz.\n",
"\n",
"20. Aşağıda bazı yıldızlar, parsek (pc) cinsinden uzaklıkları ve gezegen içerip içermediklerine iişkin Boolean bir değerden oluşan demet nesnelerini içeren bir Python listesi içerisinde verilmiştir. Bu yıldızlardan gezegen barındıran ve varsayılan değeri 5 pc'lik bir uzaklıktan yakın olanlarını ekrana yazdıran bir fonksiyon yazınız. Fonksiyonunuzu bu varsayılan uzaklık değeri için ve bu değeri 3 ve 20 pc olacak şekilde değiştirerek test ediniz.\n",
"\n",
"veri = \\[\n",
"('Proxima', 1.30, True),\n",
"('Alfa Cen A', 1.32, False),\n",
"('Alfa Cen B', 1.32, False),\n",
"('Barnard Yildizi', 1.83, True),\n",
"('Wolf 359', 2.59, False),\n",
"('Wolf 940', 12.39, True),\n",
"('Wolf 503', 42.68, True),\n",
"('Wolf 1061', 4.31, True),\n",
"('Ross 128', 3.31, True),\n",
"('Lalande 21185', 2.55, False),\n",
"('GJ 3779', 13.75, True),\n",
"('Sirius', 2.64, False),\n",
"('Ross 154', 2.98, False),\n",
"('Epsilon Eridani', 3.22, True),\n",
"('EZ Aqr', 3.40, False),\n",
"('Procyon', 3.52, False),\n",
"('Tau Ceti', 3.65, True),\n",
"('Gliese 832', 4.96, False),\n",
"('HD 2685', 198.2, True),\n",
"('K2 136', 59.4, True),\n",
"('HD 219134', 6.55, True),\n",
"('Vega', 7.68, False)\n",
"\\]\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[Başa Dön](#Fonksiyonlar-ve-Şartlı-İfadeler)"
]
}
],
"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": 2
}