Gardenkiak/Klaseak.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Objektuak eta Klaseak"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Klaseek objektu motak errepresentatzen dituzte\n",
    "* Klaseek objektuen egitura definitzen dute:\n",
    "   * Informazio bat baina gehiago bildu\n",
    "   * Berezkoa dituen akzioak definitu\n",
    "   * Eremu/atributu eta funtzioen bidez adierazi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Adibide bat: Point (bi dimentsiotako puntua)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Bi aldagai erabil genitzake, `x` eta `y`\n",
    "   * Aldagai bakarra egokiago"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5.4\n",
    "y = 1.8\n",
    "print(f'Point: ({x},{y})')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Bikote bat erabil genezake\n",
    "   * Berezko akziorik ez (nKote bat da)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = (5.4,1.8)\n",
    "print(f'Point: ({p[0]},{p[1]})')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Point datu mota sor dezakegu\n",
    "   * Aldagai bakarrez adierazi\n",
    "   * Berezko akzio guztiak definitzeko aukera"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Klasearen definizioa:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Point(object):\n",
    "    \"\"\"A 2-dimensional point\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Point in module __main__:\n",
      "\n",
      "class Point(builtins.object)\n",
      " |  A 2-dimensional point\n",
      " |  \n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Point)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "`Point` izeneko klase bat sortzean, `Point` *klase objektu* berezia sortzen da.\n",
    "   * Klase objektuak exekutagarriak dira\n",
    "      * Klase horretako objektu berriak sortu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Point motako objektuak sortzen..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Point object at 0x7fad001c7310> <class '__main__.Point'>\n"
     ]
    }
   ],
   "source": [
    "p = Point()\n",
    "print(p,type(p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Objektu batetan eremuak sor daitezke.\n",
    "   * Eremuak beste objektuen erreferentziak dira.\n",
    "   * Aldagaiak balira bezela"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point: (5.4,1.8)\n"
     ]
    }
   ],
   "source": [
    "p = Point()\n",
    "p.x = 5.4\n",
    "p.y = 1.8\n",
    "print(f'Point: ({p.x},{p.y})')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Objektu berri bat sortzen denean, bere funtzio eraikitzailea exekutatzen da: `__init__()`\n",
    "* Objektuaren eremuak hasieratzeko erabili ohi da\n",
    "* Klasea definitzean, objektuak izango dituen funtzioak defini daitezke"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Point(object):\n",
    "    \"\"\"A 2-dimensional point\"\"\"\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        self.x = x\n",
    "        self.y = y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point: (5.4,1.8)\n"
     ]
    }
   ],
   "source": [
    "p = Point(5.4,1.8)\n",
    "print(f'Point: ({p.x},{p.y})')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* `__init__(self,x,y)`-eko lehenengo argumentua, `self`, **berezia da**\n",
    "   * Sortu berri den `Point` objektuaren erreferentzia da, `__init__` funtzioak hasieratuko duena.\n",
    "   * Izenak berdin dio... baina pythoneko programazio estiloan beti `self` erabiltzen da.\n",
    "* `Point(5.4,1.8)` funtzioko 2 argumentuak `__init__(self,x,y)`-en argumentu bilakatzen dira (2. eta 3.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Point(object):\n",
    "    \"\"\"A 2-dimensional point\"\"\"\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "p = Point(5.4,1.8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Objektuen berezko akzioak definitzen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Klaseen barnean funtzioak sor ditzakegu\n",
    "* Objektu erreferentziak erabil ditzakegu funtzioak exekutatzeko:\n",
    "```python\n",
    "z = list(\"aeiou\")\n",
    "z.append(123)\n",
    "p = Point(5.4,1.8)\n",
    "p.funtzio_izena(argumentuak...)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Puntu baten testu errepresentazioa bueltatzen duen funtzio bat izatea interesgarria litzateke, adibidez:\n",
    "\n",
    "$$ p = Point(3,8) \\;\\; \\Rightarrow \\;\\; p.str() \\;\\equiv\\; \"(3,8)\" $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "\n",
    "class Point(object):\n",
    "    \"\"\"A 2-dimensional point\"\"\"\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def str(self):\n",
    "        return f'({self.x},{self.y})'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3,8)\n",
      "(3,8)\n"
     ]
    }
   ],
   "source": [
    "p = Point(3,8)\n",
    "print(p.str())\n",
    "print(Point.str(p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "```python\n",
    "    def str(self):\n",
    "        return f'({self.x},{self.y})'    \n",
    "\n",
    "p.str()\n",
    "```\n",
    "* Funtzioak `self` argumentu berezia du\n",
    "* Funtzioa `p` objektuaren bidez exekutatzean, argumentu bat gutxiago\n",
    "\n",
    "* `p.str()`  $\\equiv$  `Point.str(p)`\n",
    "\n",
    "* `p.funtzio_izena(a,b,c,d,e)`  $\\equiv$  `Point.funtzio_izena(p,a,b,c,d,e)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3,8) (3,8)\n"
     ]
    }
   ],
   "source": [
    "print(p.str(),Point.str(p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Puntu baten *modulua* ondoko moduan defini dezakegu:\n",
    "\n",
    "$$ |p| \\; = \\; \\sqrt{(x_p)^2 + (y_p)^2} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "\n",
    "class Point(object):\n",
    "    \"\"\"A 2-dimensional point\"\"\"\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def str(self):\n",
    "        return f'({self.x},{self.y})'\n",
    "    \n",
    "    def mod(self):\n",
    "        return sqrt(self.x*self.x + self.y*self.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.692099788303083 5.692099788303083\n"
     ]
    }
   ],
   "source": [
    "p = Point(5.4,1.8)\n",
    "print(p.mod() , Point.mod(p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Bi punturen batuketa eta kenketa ere defini ditzakegu:\n",
    "\n",
    "$$ p + q \\; \\equiv \\; (x_p+x_q) \\;,\\; (y_p+y_q) $$\n",
    "$$ p - q \\; \\equiv \\; (x_p-x_q) \\;,\\; (y_p-y_q) $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "&rarr; Funtzio hauen argumentua <ins>beste puntu bat</ins> izango da.\n",
    "\n",
    "&rarr; Funtzio hauek <ins>puntu berriak</ins> bueltatzen dituzte."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "\n",
    "class Point(object):\n",
    "    \"\"\"A 2-dimensional point\"\"\"\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def str(self):\n",
    "        return f'({self.x},{self.y})'\n",
    "\n",
    "    def mod(self):\n",
    "        return sqrt(self.x*self.x + self.y*self.y)\n",
    "    \n",
    "    def add(self,other):\n",
    "        return Point(self.x + other.x , self.y + other.y)\n",
    "    \n",
    "    def sub(self,other):\n",
    "        return Point(self.x - other.x , self.y - other.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1,2) + (3,5) = (4,7)\n",
      "(1,2) - (3,5) = (-2,-3)\n"
     ]
    }
   ],
   "source": [
    "p = Point(1,2)\n",
    "q = Point(3,5)\n",
    "r = p.add(q)\n",
    "s = p.sub(q)\n",
    "print(f'{p.str()} + {q.str()} = {r.str()}')\n",
    "print(f'{p.str()} - {q.str()} = {s.str()}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Baina... orain arte egin dugunarekin\n",
    "* Sortutako funtzioak esplizituki erabili beharko ditugu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(p.str())\n",
    "print(p)\n",
    "print(str(p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Python-eko eragileen konportamoldea ez da \"*zuzena*\" izango"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "p + q - p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Funtzio/Metodo bereziak I - *built-in* funtzioak"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Funtzio berezi bat, aurrez erabakitako izena duen klase-funtzioa besterik ez da.\n",
    "   * `__init__(...)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Built-in funtzio batzuek objektuen funtzio bereziak erabiliko dituzte:\n",
    "   * `str()` &rarr; `__str__()`\n",
    "   * `repr()` &rarr; `__repr__()`\n",
    "   * `len()` &rarr; `__len__()`\n",
    "* Funtzio hauek esistitzen ez badira:\n",
    "   * built-in funtzio batzuek errore bat sortuko dute\n",
    "   * besteak nolabait emaitza bat ematen saiatuko dira."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `str()` &rarr; `__str__()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Point(object):\n",
    "    \"\"\"A 2-dimensional point\"\"\"\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def str(self):\n",
    "        return f'({self.x},{self.y})'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Orain arteko  klasea ez zegoen `str` funtzioarekin _\"konektatua\"_.\n",
    "* Objektuak `__str__` funtzio bat definitua badu, `str`-k hori exekutatuko du.\n",
    "* Ez badu, mezu generiko bat bueltatuko du"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "p = Point(5.4,1.8)\n",
    "str(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "`__str__`funtzioa definitzen badugu, ordea:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Point(object):\n",
    "    \"\"\"A 2-dimensional point\"\"\"\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def __str__(self):\n",
    "        return f'({self.x},{self.y})'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Hemendik aurrera, `str` funtzioa erabili ahal izango dugu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5.4,1.8)\n",
      "(5.4,1.8)\n",
      "(5.4,1.8)\n",
      "(5.4,1.8)\n"
     ]
    }
   ],
   "source": [
    "p = Point(5.4,1.8)\n",
    "#str(p)\n",
    "print(p,str(p),p.__str__(),Point.__str__(p),sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Gainera, beste funtzio batzuk ere, `str` funtzioa erabiliko dute..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5.4,1.8)\n"
     ]
    }
   ],
   "source": [
    "print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Dena den, honekin ez dugu dena ebatzi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'kaixo', <__main__.Point object at 0x7fad00103390>]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"[1, 'kaixo', <__main__.Point object at 0x7fad00103390>]\""
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = [1 , 'kaixo' , p]\n",
    "print(z)\n",
    "str(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Zerrenden `__str__` funtzioak, `repr` funtzioa exekutatzen du elementu bakoitzaren gain.\n",
    "* Bestela ez genituzke komatxoak ikusiko `kaixo`-ren inguruan"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Esandakoaren froga:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "z = [1 , 'kaixo' , p]\n",
    "print(z)\n",
    "print(str(z))\n",
    "print(f'[{\", \".join(repr(x) for x in z)}]')\n",
    "print(f'[{\", \".join(str(x) for x in z)}]')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `repr()` &rarr; `__repr__()`\n",
    "\n",
    "* **Gogoratu:** `repr` &harr; `eval`\n",
    "* Puntua sortzeko `Point(5.4,1.8)` espresioa erabiltzen badugu...\n",
    "   * Hori bera da `repr`-ek bueltatu beharko lukeena"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Point(object):\n",
    "    \"\"\"A 2-dimensional point\"\"\"\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def __str__(self):\n",
    "        return f'({self.x},{self.y})'\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f'Point({self.x},{self.y})'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5.4,1.8)\n",
      "Point(5.4,1.8)\n"
     ]
    }
   ],
   "source": [
    "p = Point(5.4,1.8)\n",
    "print(str(p))\n",
    "print(repr(p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`repr` &harr; `eval` propietatea betetzen da:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5.4,1.8) (5.4,1.8) <class '__main__.Point'> <class '__main__.Point'>\n",
      "True True False\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q = eval(repr(p))\n",
    "print(p,q,type(p),type(q))\n",
    "print(p.x == q.x , p.y == q.y, p == q)\n",
    "eval(repr(p)) == p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `len()` &rarr; `__len__()`\n",
    "* Esan bezala, built-in funtzio batzuk errore bat sortuko dute dagokien funtzioa topatzen ez badute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Errore bat gertatuko da... \n",
    "len(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Gure `Point` klasean\n",
    "* Luzerarik gabe utzi genezake\n",
    "* Luzera eta modulua sinonimotzat har genitzake"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "\n",
    "class Point(object):\n",
    "    \"\"\"A 2-dimensional point\"\"\"\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def __str__(self):\n",
    "        return f'({self.x},{self.y})'\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f'Point({self.x},{self.y})'\n",
    "\n",
    "    def mod(self):\n",
    "        return sqrt(self.x*self.x + self.y*self.y)\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.mod()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "p = Point(5.4,1.8)\n",
    "# __len__ funtzioa sortu badugu ere, errore bat gertatuko da... \n",
    "print(p,'puntuaren luzera:',len(p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`__len__`funtzioak zenbaki oso bat bueltatu behar du, beraz azken aldaketa hau gaizki dago.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Funtzio/Metodo bereziak II - Eragileak"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Aurreko atalean, `repr` &harr; `eval` erlazioa ebatzi dugu:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "p = Point(5.4,1.8)\n",
    "q = eval(repr(p))\n",
    "print(p,repr(p),q)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Baina `p` eta `q` puntuak berdinak ote dira?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "print(p, q, p==q, p is q)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `==` eragileak ez daki ezertxo ere gure `Point` klaseaz\n",
    "* Guk adierazi beharko dugu bi objektu noiz diren berdinak"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Python-eko edozein eragile erabiltzean, objektuen funtzio bereziak exekutatzen dira\n",
    "   * Konparazio eragileak: `<` `<=` `>` `>=`  `==` `!=`\n",
    "   * Eragile aritmetikoak: `+` `-` `*` `/` `//` `%`\n",
    "   * Eragile monadikoak (eragigai bakarra): `+` `-`\n",
    "   * Indexazioa: `obj[key]`\n",
    "   * esleipen indexatua: `obj[key] = ...`\n",
    "   * ezabatze indexatua: `del obj[key]`\n",
    "   * *kidetasun* eragileak: `in` `not in`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Konparazio eragileak: `<` `<=` `>` `>=`  `==` `!=`\n",
    "\n",
    "* `a < b` &rarr; `a.__lt__(b)`\n",
    "* `a <= b` &rarr; `a.__le__(b)`\n",
    "* `a > b` &rarr; `a.__gt__(b)`\n",
    "* `a >= b` &rarr; `a.__ge__(b)`\n",
    "* `a == b` &rarr; `a.__eq__(b)`\n",
    "* `a != b` &rarr; `a.__ne__(b)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Funtzio hauek sortu ezean, eragileek (batzuk) erroreak sortuko dituzte:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = Point(1,2)\n",
    "b = Point(1,2)\n",
    "print(f'{a} == {b} : {a==b}')\n",
    "print(f'{a} == {a} : {a==a}')\n",
    "print(f'{a} != {b} : {a!=b}')\n",
    "print(f'{a} != {a} : {a!=a}')\n",
    "# honek errore bat sortuko du\n",
    "#print(f'a > b : {a>b}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `a == b` , $ \\;\\; \\nexists \\_\\_eq\\_\\_\\;$ &rarr; `a is b` \n",
    "* `a != b` , $ \\;\\; \\nexists \\_\\_ne\\_\\_\\;$ &rarr; `a is not b`\n",
    "* &rarr; `Point` klasean, ardatzeko balioak erabil genitzake puntuak konparatzeko...\n",
    "* &rarr; `Point` klasean, puntuen modulua erabil genezake puntuak konparatzeko..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Point(object):\n",
    "    \"\"\"A 2-dimensional point\"\"\"\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def __str__(self):\n",
    "        return f'({self.x},{self.y})'\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f'Point({self.x},{self.y})'\n",
    "\n",
    "    def mod(self):\n",
    "        return sqrt(self.x*self.x + self.y*self.y)\n",
    "    \n",
    "    def __eq__(self,other):\n",
    "        return self.x == other.x and self.y == other.y\n",
    "    def __ne__(self,other):\n",
    "        return self.x != other.x or self.y != other.y\n",
    "    \n",
    "    def __gt__(self,other):\n",
    "        return self.mod() > other.mod()\n",
    "    def __ge__(self,other):\n",
    "        return self.mod() >= other.mod()\n",
    "    def __lt__(self,other):\n",
    "        return self.mod() < other.mod()    \n",
    "    def __le__(self,other):\n",
    "        return self.mod() <= other.mod()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Orain, bai:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1,2) == (3,4) : False\n",
      "(1,2) != (3,4) : True\n",
      "(1,2) > (3,4) : False\n",
      "(1,2) >= (3,4) : False\n",
      "(1,2) < (3,4) : True\n",
      "(1,2) <= (3,4) : True\n"
     ]
    }
   ],
   "source": [
    "p = Point(1,2)\n",
    "q = Point(3,4)\n",
    "\n",
    "print(f'{p} == {q} : {p==q}')\n",
    "print(f'{p} != {q} : {p!=q}')\n",
    "print(f'{p} > {q} : {p>q}')\n",
    "print(f'{p} >= {q} : {p>=q}')\n",
    "print(f'{p} < {q} : {p<q}')\n",
    "print(f'{p} <= {q} : {p<=q}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Eragile aritmetikoak: `+` `-` `*` `/` `//` `%`\n",
    "\n",
    "* `a + b` &rarr; `a.__add__(b)`\n",
    "* `a - b` &rarr; `a.__sub__(b)`\n",
    "* `a * b` &rarr; `a.__mul__(b)`\n",
    "* `a / b` &rarr; `a.__truediv__(b)`\n",
    "* `a // b` &rarr; `a.__floordiv__(b)`\n",
    "* `a % b` &rarr; `a.__mod__(b)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Batuketa eta kenketa defini ditzakegu:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Point(object):\n",
    "    \"\"\"A 2-dimensional point\"\"\"\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def __str__(self):\n",
    "        return f'({self.x},{self.y})'\n",
    "    \n",
    "    def __add__(self,other):\n",
    "        return Point(self.x+other.x, self.y+other.y)\n",
    "    def __sub__(self,other):\n",
    "        return Point(self.x-other.x, self.y-other.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1,2) + (3,5) = (4,7)\n",
      "(1,2) - (3,5) = (-2,-3)\n"
     ]
    }
   ],
   "source": [
    "p = Point(1,2)\n",
    "q = Point(3,5)\n",
    "print(f'{p} + {q} = {p+q}')\n",
    "print(f'{p} - {q} = {p-q}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Eragile monadikoak (eragigai bakarra): `+` `-`\n",
    "\n",
    "* `+ a` &rarr; `a.__pos__()`\n",
    "* `- a` &rarr; `a.__neg__()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Point(object):\n",
    "    \"\"\"A 2-dimensional point\"\"\"\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def __str__(self):\n",
    "        return f'({self.x}, {self.y})'\n",
    "    \n",
    "    def __pos__(self):\n",
    "        #return Point(self.x, self.y)\n",
    "        return self\n",
    "    def __neg__(self):\n",
    "        return Point(-self.x, -self.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+(1, 2) = (1, 2)\n",
      "-(1, 2) = (-1, -2)\n"
     ]
    }
   ],
   "source": [
    "p = Point(1,2)\n",
    "print(f'+{p} = {+p}')\n",
    "print(f'-{p} = {-p}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Indexazioa: `obj[key]`\n",
    "\n",
    "* `a[key]` &rarr; `a.__getitem__(key)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Zentzurik ez badu ere puntu bat indexatzea, funtzioa sortu dezakegu `a[key]` patroia konprobatzeko:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Point(object):\n",
    "    \"\"\"A 2-dimensional point\"\"\"\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def __str__(self):\n",
    "        return f'({self.x},{self.y})'\n",
    "    \n",
    "    def __getitem__(self,key):\n",
    "        if key == 'x' :\n",
    "            return self.x\n",
    "        elif key == 'y' :\n",
    "            return self.y\n",
    "        else :\n",
    "            return None\n",
    "            #raise ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p[\"x\"] = 1\n",
      "p[\"y\"] = 2\n",
      "p[\"kk\"] = None\n",
      "p[1] = None\n"
     ]
    }
   ],
   "source": [
    "p = Point(1,2)\n",
    "print(f'p[\"x\"] = {p[\"x\"]}')\n",
    "print(f'p[\"y\"] = {p[\"y\"]}')\n",
    "print(f'p[\"kk\"] = {p[\"kk\"]}')\n",
    "print(f'p[1] = {p[1]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Esleipen indexatua: `obj[key] = ...`\n",
    "\n",
    "* `a[key] = value` &rarr; `a.__setitem__(key,value)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Berriro ere, ez du zentzu handirik, baina frogatzearren..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Point(object):\n",
    "    \"\"\"A 2-dimensional point\"\"\"\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def __str__(self):\n",
    "        return f'({self.x},{self.y})'\n",
    "    \n",
    "    def __setitem__(self,key,value):\n",
    "        if key == 'x' :\n",
    "            self.x = value\n",
    "        elif key == 'y' :\n",
    "            self.y = value\n",
    "        else :\n",
    "            # raise ....\n",
    "            print(f'??? Puntuko {repr(key)} gakoari {repr(value)} balioa esleitu nahi diozu?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1,2)\n",
      "(100,2)\n",
      "(100,200)\n",
      "??? Puntuko 0 gakoari 'kk' balioa esleitu nahi diozu?\n"
     ]
    }
   ],
   "source": [
    "p = Point(1,2)\n",
    "print(p)\n",
    "p[\"x\"] = 100\n",
    "print(p)\n",
    "p[\"y\"] = 200\n",
    "print(p)\n",
    "p[0] = \"kk\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Ezabatze indexatua: `del obj[key]`\n",
    "\n",
    "* `del a[key]` &rarr; `a.__delitem__(key)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Berriro ere, ez du zentzu handirik, baina frogatzearren..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Point(object):\n",
    "    \"\"\"A 2-dimensional point\"\"\"\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def __str__(self):\n",
    "        return f'({self.x},{self.y})'\n",
    "            \n",
    "    def __delitem__(self,key):\n",
    "        print(f'??? Puntuko {repr(key)} gakoari dagokion elementua ezabatu nahi duzu?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "??? Puntuko 'x' gakoari dagokion elementua ezabatu nahi duzu?\n",
      "??? Puntuko 0 gakoari dagokion elementua ezabatu nahi duzu?\n"
     ]
    }
   ],
   "source": [
    "p = Point(1,2)\n",
    "del p[\"x\"]\n",
    "del p[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### *kidetasun* eragileak: `in` `not in`\n",
    "\n",
    "* `value in a` &rarr; `a.__contains__(value)`\n",
    "* `value not in a` &rarr; `not a.__contains__(value)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Berriro ere, ez du zentzu handirik, baina frogatzearren..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Point(object):\n",
    "    \"\"\"A 2-dimensional point\"\"\"\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def __str__(self):\n",
    "        return f'({self.x},{self.y})'\n",
    "            \n",
    "    def __contains__(self,key):\n",
    "        return True if key == 'x' or key == 'y' else False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True True False False\n"
     ]
    }
   ],
   "source": [
    "p = Point(1,2)\n",
    "print('x' in p, 'y' in p, 'kk' in p , 1 in p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Egindako guztia bilduz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Point(object):\n",
    "    \"\"\"A 2-dimensional point\"\"\"\n",
    "    \n",
    "    def __init__(self,x=0,y=0):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def mod(self):\n",
    "        return sqrt(self.x*self.x + self.y*self.y)\n",
    "\n",
    "    def __str__(self):\n",
    "        return f'({self.x},{self.y})'  \n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f'Point({self.x},{self.y})'\n",
    "    \n",
    "    def __eq__(self,other):\n",
    "        return self.x == other.x and self.y == other.y\n",
    "    \n",
    "    def __ne__(self,other):\n",
    "        return self.x != other.x or self.y != other.y\n",
    "    \n",
    "    def __gt__(self,other):\n",
    "        return self.mod() > other.mod()\n",
    "    \n",
    "    def __ge__(self,other):\n",
    "        return self.mod() >= other.mod()\n",
    "    \n",
    "    def __lt__(self,other):\n",
    "        return self.mod() < other.mod() \n",
    "    \n",
    "    def __le__(self,other):\n",
    "        return self.mod() <= other.mod()\n",
    "    \n",
    "    def __add__(self,other):\n",
    "        return Point(self.x+other.x,self.y+other.y)\n",
    "    \n",
    "    def __sub__(self,other):\n",
    "        return Point(self.x-other.x,self.y-other.y)\n",
    "    \n",
    "    def __pos__(self):\n",
    "        return self\n",
    "    \n",
    "    def __neg__(self):\n",
    "        return Point(-self.x,-self.y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**GOGORATU:** Python-ek funtzio berezien erabilera handia egiten du\n",
    "\n",
    "https://docs.python.org/3/reference/datamodel.html#special-method-names"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.6"
  },
  "rise": {
   "autolaunch": false,
   "footer": "<h2 align=\"center\">Konputaziorako Sarrera</h2>",
   "scroll": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}