Ders4 - İsimsiz fonksiyonlar.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fonksiyonların her zaman `def` komutuyla tanımlanması gerekmez. Başka bir yol, `lambda` komutunu kullanarak isimsiz (\"anonymous\" - belli bir isme bağlı olmayan) fonksiyonlar yaratmaktır. İsimsiz fonksiyonlar, `def` komutuyla üretilen fonksiyonlara göre daha kısıtlıdırlar. Buna karşılık, bir fonksiyon nesnesi gereken yerlerde bazı kolaylıklar sağlarlar.\n",
    "\n",
    "\n",
    "Fonksiyonların `lambda` komutuyla üretilmesine basit bir örnek olarak, aşağıdaki ifadeyi ele alalım. Burada, aldığı parametrenin karesini döndüren bir fonksiyon yaratıyoruz ve buna `f` ismini atıyoruz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "f = lambda x: x*x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bundan sonra `f` alıştığımız şekilde bir fonksiyon olarak kullanılabilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.44, 16, 256)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(1.2), f(4), f(f(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nitekim aynı `f` fonksiyonunu `def` ile de tanımlayabilirdik."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def f(x): return x*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.44, 16, 256)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(1.2), f(4), f(f(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python dinamik bir dildir. Bunun anlamı, verdiğimiz komutların anında işlenmesi, ve gerekli nesnelerin bellekte o anda yaratılıyor olmasıdır. Python'daki her şey gibi fonksiyonlar da (yazılım geliştirmedeki anlamıyla) birer nesnedir. Yukarıdaki `lambda x: x*x` ifadesi bellekte bir _fonksiyon nesnesi_ yaratır, ve bu nesne ile `f` ismi birbirine bağlanır. Öz olarak bunun `s = \"merhaba\"` komutundan farkı yok; burada da önce bellekte `\"merhaba\"` değerini tutan bir dize nesnesi yaratılır, sonra bu nesne `s` ismi ile eşleştirilir.\n",
    "\n",
    "Elbette `lambda` ile yaratılan fonksiyon nesnesi tek başına da kullanılabilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.44"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lambda x: x*x)(1.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ama böyle bir kullanımda fonksiyon her seferinde baştan oluşturulacağından programın verimi azalır.\n",
    "\n",
    "İsimsiz fonksiyonlar, `def` ile tanımladığımız genel amaçlı fonksiyonlardan daha kısıtlıdırlar. Genel amaçlı fonksiyonlarda Python'da tanımlı olan her türlü işlemi kullanabiliriz. İsimsiz fonksiyonlarda ise komut (\"statement\") bulunamaz, yani mesela atama yapamayız veya `if-else`, `while`, `for` yapılarını kullanamayız. Sadece bir ifade (\"expression\", geriye bir değer veren bir işlem) bulunabilir.\n",
    "\n",
    "O zaman isimsiz fonksiyonların faydası ne? Bunlar, özellikle **fonksiyon alan fonksiyonlara verilen parametreler** olarak kullanışlıdırlar.\n",
    "\n",
    "İlk okuyuşta çok egzotik bir kullanım gibi görünebilir ama değil. İsimsiz fonksiyonların kullanılabildiği yerlere birkaç örnek verelim.\n",
    "\n",
    "**Örnek: Seriler**\n",
    "\n",
    "Fonksiyon alan bir fonksiyon tanımlamıştık. Özel olarak, $f$ reel sayı alıp reel sayı veren herhangi bir fonksiyon olmak üzere, $f(a) + f(a+1) + f(a+2) +\\cdots + f(b)$ toplamını hesaplayan bir fonksiyon yazdık. Bu fonksiyon sadece başlangıç ve bitiş değerleri olan `a` ve `b`'yi değil, aynı zamanda `f` fonksiyonunu da parametre olarak alıyor. Böylece herhangi bir fonksiyon için bu toplamı hesaplayabiliyoruz.\n",
    "\n",
    "Bu toplamı veren fonksiyonu şöyle tanımlayabiliriz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def seritoplam(f, a, b):\n",
    "    toplam = 0\n",
    "    x = a\n",
    "    while x<=b:\n",
    "        toplam += f(x)\n",
    "        x += 1\n",
    "    return toplam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tanımladığımız `seritoplam` fonksiyonu, matematiksel terimle bir \"fonksiyonel\"dir, yani fonksiyon alıp sayı veren bir fonksiyon. Bunu kullanarak, $\\sum_{x=a}^b 2^{-x}$ değerini hesaplayalım. Bu toplam için `f` parametresi olarak $2^{-x}$ olarak tanımlanmış bir fonksiyon verilmeli."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.9990234375"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def g(x): return 2.0**(-x)\n",
    "\n",
    "seritoplam(g, 0, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aynısını bir isimsiz fonksiyonla şöyle yapabiliriz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.9990234375"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seritoplam( lambda x: 2.0**(-x), 0, 10 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Burada `lambda` ifadesini doğrudan doğruya `seritoplam`'a bir parametre olarak verdiğimize dikkat edin. Bunu doğrudan `def` ile yapamayız, yani\n",
    "\n",
    "    seritoplam( def f(x): 2.0**(-x), 0, 10 )\n",
    "yazmak hatalıdır, çünkü `def` yapısı bir fonksiyon nesnesi döndürmez. Buna karşılık `lambda` bir ifadedir (\"expression\"); konduğu yerde bir fonksiyon nesnesi yaratır.\n",
    "\n",
    "`seritoplam` fonksiyonunu birçok farklı fonksiyon parametresi vererek denemek istiyor olabilirsiniz. Mesela $ 1+ 1/2 + 1/3 + \\cdots + 1/10$ toplamını bulalım:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.9289682539682538"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seritoplam( lambda x: 1/x, 1, 10 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elbette deneyeceğiniz her türlü fonksiyonu `def` ile tanımlayarak da aynı sonuca ulaşabilirsiniz. Ama `lambda` kullanmak burada daha fazla kolaylık sağlıyor.\n",
    "\n",
    "**Örnek: Sıralama**\n",
    "\n",
    "Listelere kısaca değinmiştik. Bir listenin elemanlarını sıralamak için `sorted` fonksiyonu kullanılabilir. Söz gelişi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-5.6, -3.4, -1.2, 2.3, 4.0, 6.1, 7.8, 8.5]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [ 6.1, 2.3, -5.6, 8.5, 4.0, -1.2, -3.4, 7.8]\n",
    "sorted(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bazen alışılageldik sırayla değil de, başka bir düzene göre sıralamak isteyebilirsiniz. `sorted` fonksiyonunun `key` parametresine bir fonksiyon verirseniz, bu fonksiyon bütün elemanlara tek tek uygulanır ve sıralama bu sonuçlara göre yapılır. Söz gelişi, yukarıdaki listeyi sayıların _mutlak değerlerine_ göre sıralamak için `key` parametresine `abs` fonksiyonunu verebilirsiniz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1.2, 2.3, -3.4, 4.0, -5.6, 6.1, 7.8, 8.5]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(L, key=abs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gördüğünüz gibi burada da fonksiyon alan bir fonksiyonumuz var. Aynı sıralamayı bir isimsiz fonksiyonla şöyle elde ederdik."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1.2, 2.3, -3.4, 4.0, -5.6, 6.1, 7.8, 8.5]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(L, key=lambda x: x if x>0 else -x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Üçlü if-else yapısını daha ayrıntılı işlemiştik.\n",
    "\n",
    "Başka bir örnek olarak, listelerden oluşan bir listeyi sıralamayı ele alalım. `key` parametresini kullanmadan `sorted` ilk elemana göre sıralama yapar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[-2, 'guten tag'], [1, 'merhaba'], [6, 'hello']]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [ [1, \"merhaba\"], [6, \"hello\"], [-2, \"guten tag\"] ]\n",
    "sorted(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eğer ikinci elemana göre sıralama yapmak istiyorsak, `key` parametresine listenin ikinci elemanını (1 indeksli) veren bir fonksiyon koyarız."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[-2, 'guten tag'], [6, 'hello'], [1, 'merhaba']]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(L, key = lambda i: i[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Örnek: Sayısal integral hesaplama**\n",
    "\n",
    "Bir _belirli integral_ $\\int_a^b f(x)\\mathrm{d}x$ matematiksel olarak bir \"fonksiyonel\"dir: Bir fonksiyon alır ve bir sayı verir. Bir fonksiyonun integralini alırken de isimsiz fonksiyonlar kullanabiliriz.\n",
    "\n",
    "Bir belirli integrali sayısal olarak hesaplamanın pek çok yöntemi vardır. Bunlara şimdilik hiç girmeden, SciPy paketi içindeki integral alma modülünü kullanalım ve $\\int_{-2}^4 6x^3 - 4x^2\\, \\mathrm{d}x$ integralini hesaplayalım."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(264.00000000000006, 3.703317987014864e-12)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import scipy.integrate\n",
    "\n",
    "scipy.integrate.quad(lambda x: 6*x**3 - 4*x**2, -2, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "İlk sayı belirli integralin değeri, ikinci sayı ise tahmini hata miktarıdır.\n",
    "\n",
    "<hr />\n",
    "\n",
    "Örnekler çoğaltılabilir: Bir fonksiyonun optimal noktalarını bulan bir fonksiyon, türev alan bir fonksiyon, veya bir fonksiyonun grafiğini çizen bir fonksiyon, isimsiz fonksiyonlar alarak daha kolay şekilde işlenebilirler. Ayrıca grafik arayüz oluştururken de isimsiz fonksiyonlar kolaylık sağlar.\n",
    "\n",
    "İsimsiz fonksiyonların iyi ve kötü taraflarını şöyle özetleyebiliriz:\n",
    "\n",
    "* `lambda` bir fonksiyon nesnesi döndürür, `def` ise bir komuttur, bir değer döndürmez. Bu yüzden `lambda` ile tanımlanan isimsiz fonksiyonları başka ifadelerin içine, söz gelişi atamalara veya fonksiyon parametrelerine yerleştirebiliriz.\n",
    "* İsimsiz fonksiyonlarla karmaşık işlemler yapılamaz. Kısa, bir seferlik kullan-at fonksiyonlar tanımlamak için daha uygundurlar.\n",
    "* İsimsiz fonksiyonlarla kodunuz daha okunaklı olabilir. Sıralama vb. işlemlerde `def` ile farklı fonksiyonlar tanımlamak isim alanının bir sürü tek kullanımlık fonksiyon ismiyle dolmasına sebep olur. Dahası, kaynak kodunuz uzunsa, fonksiyonun tanımlandığı yer ile kullanıldığı yer arasında kalan mesafe yüzünden, kodda ne yapıldığını anlamak için yukarı aşağı kaydırmak gerekebilir. Bu tür küçük işlerde `lambda` ifadeleri kullanmak, fonksiyonun yapısını açıkça gösterdiği için kodun anlaşılırlığını artırır.\n",
    "\n",
    "İsimsiz fonksiyonlarda parametre kullanımı kuralları isimli fonksiyonlardakilerle aynıdır. Örneğin birden fazla parametre alabilirler."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = lambda x, y: x+y\n",
    "f(4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'helloworld'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(\"hello\",\"world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parametre paketleme / parametre çözme kuralları isimsiz fonksiyonlarda da aynen geçerlidir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.25"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = lambda *p : sum(p)\n",
    "g(0.25, 2, 13)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parametrelere varsayılan değerler atanabilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "243\n"
     ]
    }
   ],
   "source": [
    "h = lambda x, n=2: x**n  # üst alma. Varsayılan kuvvet 2.\n",
    "print(h(3)) # 3**2\n",
    "print(h(3,5)) # 3**5"
   ]
  }
 ],
 "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}