Ch09.클래스와 매직 메서드.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9.1 클래스와 객체 기본 문법"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    pass\n",
    "\n",
    "class Cat:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "car1 = Car()\n",
    "car2 = Car()\n",
    "car3 = Car()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dog = Dog()\n",
    "yr_dog = Dog()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    accel = 3.0\n",
    "    mpg = 25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "car1.accel = 3.0\n",
      "car2.accel = 3.0\n",
      "car1.mpg = 25\n",
      "car2.mpg = 25\n"
     ]
    }
   ],
   "source": [
    "print('car1.accel =', car1.accel)\n",
    "print('car2.accel =', car2.accel)\n",
    "print('car1.mpg =', car1.mpg)\n",
    "print('car2.mpg =', car2.mpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_car = Car()\n",
    "yr_car = Car()\n",
    "my_car.accel = 5.0\n",
    "yr_car.accel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9.2 인스턴스 변수에 대해 더 알아보자"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    pass\n",
    "\n",
    "my_dog = Dog()\n",
    "my_dog.name = 'Champ the Wonder Dog'\n",
    "my_dog.breed = 'Great Dane'\n",
    "my_dog.age = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Breed and age are Great Dane and 5.\n"
     ]
    }
   ],
   "source": [
    "print('Breed and age are {} and {}.'.format(my_dog.breed, my_dog.age))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "yr_dog = Dog()\n",
    "top_dog = Dog()\n",
    "hot_dog = Dog()\n",
    "hot_dog.name = 'Hotty Totty'\n",
    "hot_dog.breed = 'Dachshund'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9.3 __init__ 메서드와 __new__메서드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    def __init__(self, name, breed, age):\n",
    "        self.name = name\n",
    "        self.breed = breed\n",
    "        self.age = age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "top_dog = Dog('Handsome Dan', 'Bulldog', 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "good_dog = Dog('Wonder Boy', 'Collie', 11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9.4 클래스와 선행 참조 문제"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Marriage:\n",
    "    def __init__(self):\n",
    "        self.wife = Person('f')\n",
    "        self.husband = Person('m')\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, gender):\n",
    "        self.gender = gender\n",
    "\n",
    "a_marriage = Marriage()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9.5 메서드 기본"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pretty:\n",
    "    \n",
    "    def __init__(self, prefix):\n",
    "        self.prefix = prefix\n",
    "        \n",
    "    def print_me(self, a, b, c):\n",
    "        print(self.prefix, a, sep='')\n",
    "        print(self.prefix, b, sep='')\n",
    "        print(self.prefix, c, sep='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-->10\n",
      "-->20\n",
      "-->30\n"
     ]
    }
   ],
   "source": [
    "printer = Pretty('-->')\n",
    "printer.print_me(10, 20, 30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9.6 전역 변수/메서드와 지역 변수/메서드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Odd:\n",
    "    def __init__(self):\n",
    "        self.x = 10\n",
    "        self.y = 20\n",
    "        self.__z = 30\n",
    "        \n",
    "    def pr(self):\n",
    "        print('__z =', self.__z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "o = Odd()\n",
    "o.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "o.y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o.__z   <-- 에러!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9.7 상속"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    " class Mammal:\n",
    "        def __init__(self, name, size):\n",
    "            self.name = name\n",
    "            self.size = size\n",
    "        \n",
    "        def speak(self):\n",
    "            print('My name is', name)\n",
    "            \n",
    "        def call_out(self):\n",
    "            self.speak()\n",
    "            self.speak()\n",
    "            self.speak()\n",
    "            \n",
    "class Dog(Mammal):\n",
    "    def speak(self):\n",
    "        print('ARF!!')\n",
    "        \n",
    "class Cat(Mammal):\n",
    "    def speak(self):\n",
    "        print('Purrrrrr!!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Purrrrrr!!\n",
      "Purrrrrr!!\n",
      "Purrrrrr!!\n"
     ]
    }
   ],
   "source": [
    "my_cat = Cat('Precious', 17.5)\n",
    "my_cat.call_out()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog(Mammal):\n",
    "    def speak(self):\n",
    "        print('ARF!')\n",
    "    \n",
    "    def __init__(self, name, size, breed):\n",
    "        super().__init__(name, size)\n",
    "        self.breed = breed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9.8 다중 상속"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "class Dog(Mammal, Pet, Carnivore):\n",
    "    def speak(self):\n",
    "        print('ARF!!')\n",
    "        \n",
    "    def __init__(self, name, size, breed):\n",
    "        Mammal.__init__(self, name, size)\n",
    "        self.breed = breed\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "def __init__(self, name, size, nickname, breed):\n",
    "    Mammal.__init__(self, name, size)\n",
    "    Pet.__init__(self, nickname)\n",
    "    self.breed = breed\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9.10  매직 메서드 상세"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.10.2 객체 표현 메서드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    big_prime_1 = 1200556037\n",
    "    big_prime_2 = 2444555677\n",
    "    \n",
    "    def __init__(self, x = 0, y = 0):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def __str__(self):\n",
    "        s = str(self.x) + ', '\n",
    "        s += str(self.y)\n",
    "        return s\n",
    "    \n",
    "    def __repr__(self):\n",
    "        s = 'Point(' + str(self.x) + ', '\n",
    "        s += str(self.y) + ')'\n",
    "        return s\n",
    "    \n",
    "    def __hash__(self):\n",
    "        n = self.x * big_prime_1\n",
    "        return (n + self.y) % big_prime_2\n",
    "    \n",
    "    def __bool__(self):\n",
    "        return x and y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(3, 4)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pt = Point(3, 4)\n",
    "pt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3, 4\n"
     ]
    }
   ],
   "source": [
    "print(pt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.10.3 비교 메서드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    def __init__(self, n):\n",
    "        self.n = n\n",
    "        \n",
    "    def __eq__(self, other):\n",
    "        '''==를 구현하면 !=를 자동으로 얻는다.'''\n",
    "        return self.n == other.n\n",
    "    \n",
    "    def __lt__(self, other):\n",
    "        '''<를 구현하면 >를 자동으로 얻는다.'''\n",
    "        return self.n < other.n\n",
    "    \n",
    "    def __le__(self, other):\n",
    "        '''<=를 구현하면 >=를 자동으로 얻는다.'''\n",
    "        return self.n <= other.n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    def __init__(self, d):\n",
    "        self.d = d\n",
    "    \n",
    "    def __gt__(self, other):\n",
    "        ''' Greater than (>). 대칭 규칙에 의해\n",
    "        less than 비교를 제공한다.\n",
    "        A > B면 B < A다.'''\n",
    "        if type(other) == Dog:\n",
    "            return self.d > other.d\n",
    "        else:\n",
    "            return self.d > other\n",
    "        \n",
    "    def __lt__(self, other):\n",
    "        ''' Less than (<). 숫자와 마찬가지로\n",
    "        이 메서드는 동일 클래스의 객체 간\n",
    "        비교를 제공한다.\n",
    "        '''\n",
    "        if type(other) == Dog:\n",
    "            return self.d < other.d\n",
    "        else:\n",
    "            return self.d < other\n",
    "        \n",
    "    # __repr__을 정의하는 것은 __str__도 갖게 되는 것이다.\n",
    "    def __repr__(self):\n",
    "        return \"Dog(\" + str(self.d) + \")\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-20, Dog(1), 3, Dog(5), Dog(10), 50, 100]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1, d5, d10 = Dog(1), Dog(5), Dog(10)\n",
    "a_list = [50, d5, 100, d1, -20, d10, 3]\n",
    "a_list.sort()\n",
    "a_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.10.4 산술 연산자 메서드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3/2\n",
      "5/2\n"
     ]
    }
   ],
   "source": [
    "import fractions\n",
    "\n",
    "f = fractions.Fraction(1, 2)\n",
    "print(f + 1)   # Fraction.__add__ 호출\n",
    "print(2 + f)   # Fraction.__radd__ 호출"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        '''self와 other의 x, y 좌표를 각각 더한 신규 포인트 반환.'''\n",
    "        newx = self.x + other.x\n",
    "        newy = self.y + other.y\n",
    "        return Point(newx, newy)\n",
    "    \n",
    "    def __sub__(self, other):\n",
    "        '''두 포인트의 거리 반환'''\n",
    "        dx = self.x - other.x\n",
    "        dy = self.y - other.y\n",
    "        return (dx * dx +dy * dy) ** 0.5\n",
    "    \n",
    "    def __mul__(self, n):\n",
    "        '''point 곱하기 스칼라 숫자 n.'''\n",
    "        newx = self.x * n\n",
    "        newy = self.y * n\n",
    "        return Point(newx, newy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "pt1 = Point(10, 15)\n",
    "pt2 = Point(0, 5)\n",
    "x = pt1 + pt2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.10.5 단항 산술 연산자"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        '''self와 other의 x, y 좌표를 각각 더한 신규 포인트 반환.'''\n",
    "        newx = self.x + other.x\n",
    "        newy = self.y + other.y\n",
    "        return Point(newx, newy)\n",
    "    \n",
    "    def __sub__(self, other):\n",
    "        '''두 포인트의 거리 반환'''\n",
    "        dx = self.x - other.x\n",
    "        dy = self.y - other.y\n",
    "        return (dx * dx +dy * dy) ** 0.5\n",
    "    \n",
    "    def __mul__(self, n):\n",
    "        '''point 곱하기 스칼라 숫자 n.'''\n",
    "        newx = self.x * n\n",
    "        newy = self.y * n\n",
    "        return Point(newx, newy)\n",
    "    \n",
    "    def __neg__(self):\n",
    "        newx = -self.x\n",
    "        newy = -self.y\n",
    "        return Point(newx, newy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3, -4\n"
     ]
    }
   ],
   "source": [
    "pt1 = Point(3, 4)\n",
    "pt2 = -pt1\n",
    "print(pt2.x, ', ', pt2.y, sep='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        '''self와 other의 x, y 좌표를 각각 더한 신규 포인트 반환.'''\n",
    "        newx = self.x + other.x\n",
    "        newy = self.y + other.y\n",
    "        return Point(newx, newy)\n",
    "    \n",
    "    def __sub__(self, other):\n",
    "        '''두 포인트의 거리 반환'''\n",
    "        dx = self.x - other.x\n",
    "        dy = self.y - other.y\n",
    "        return (dx * dx +dy * dy) ** 0.5\n",
    "    \n",
    "    def __mul__(self, n):\n",
    "        '''point 곱하기 스칼라 숫자 n.'''\n",
    "        newx = self.x * n\n",
    "        newy = self.y * n\n",
    "        return Point(newx, newy)\n",
    "    \n",
    "    def __neg__(self):\n",
    "        newx = -self.x\n",
    "        newy = -self.y\n",
    "        return Point(newx, newy)\n",
    "    \n",
    "    def __trunc__(self):\n",
    "        newx = self.x.__trunc__()\n",
    "        newy = self.y.__trunc__()\n",
    "        return Point(newx, newy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5, -6\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "pt1 = Point(5.5, -6.6)\n",
    "pt2 = math.trunc(pt1)\n",
    "print(pt2.x, ', ', pt2.y, sep='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.10.6 리플렉션(역방향) 메서드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        '''self와 other의 x, y 좌표를 각각 더한 신규 포인트 반환.'''\n",
    "        newx = self.x + other.x\n",
    "        newy = self.y + other.y\n",
    "        return Point(newx, newy)\n",
    "    \n",
    "    def __sub__(self, other):\n",
    "        '''두 포인트의 거리 반환'''\n",
    "        dx = self.x - other.x\n",
    "        dy = self.y - other.y\n",
    "        return (dx * dx +dy * dy) ** 0.5\n",
    "    \n",
    "    def __mul__(self, n):\n",
    "        '''point 곱하기 스칼라 숫자 n.'''\n",
    "        newx = self.x * n\n",
    "        newy = self.y * n\n",
    "        return Point(newx, newy)\n",
    "    \n",
    "    def __neg__(self):\n",
    "        newx = -self.x\n",
    "        newy = -self.y\n",
    "        return Point(newx, newy)\n",
    "    \n",
    "    def __trunc__(self):\n",
    "        newx = self.x.__trunc__()\n",
    "        newy = self.y.__trunc__()\n",
    "        return Point(newx, newy)\n",
    "    \n",
    "    def __rmul__(self, n):\n",
    "        '''포인트와 스칼라 숫자 n과 곱셈한 결과를 반환한다.'''\n",
    "        newx = self.x * n\n",
    "        newy = self.y * n\n",
    "        return Point(newx, newy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "pt1 = Point(1, 2)\n",
    "pt2 = Point(5, 10)\n",
    "pt3 = pt1 + pt2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "pt3 = pt1 * 5\n",
    "pt3 = 10 * pt1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.10.7 교체 연산자 메서드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        '''self와 other의 x, y 좌표를 각각 더한 신규 포인트 반환.'''\n",
    "        newx = self.x + other.x\n",
    "        newy = self.y + other.y\n",
    "        return Point(newx, newy)\n",
    "    \n",
    "    def __sub__(self, other):\n",
    "        '''두 포인트의 거리 반환'''\n",
    "        dx = self.x - other.x\n",
    "        dy = self.y - other.y\n",
    "        return (dx * dx +dy * dy) ** 0.5\n",
    "    \n",
    "    def __mul__(self, n):\n",
    "        '''point 곱하기 스칼라 숫자 n.'''\n",
    "        newx = self.x * n\n",
    "        newy = self.y * n\n",
    "        return Point(newx, newy)\n",
    "    \n",
    "    def __neg__(self):\n",
    "        newx = -self.x\n",
    "        newy = -self.y\n",
    "        return Point(newx, newy)\n",
    "    \n",
    "    def __trunc__(self):\n",
    "        newx = self.x.__trunc__()\n",
    "        newy = self.y.__trunc__()\n",
    "        return Point(newx, newy)\n",
    "    \n",
    "    def __rmul__(self, n):\n",
    "        '''포인트와 스칼라 숫자 n과 곱셈한 결과를 반환한다.'''\n",
    "        newx = self.x * n\n",
    "        newy = self.y * n\n",
    "        return Point(newx, newy)\n",
    "    \n",
    "    def __iadd__(self, other):\n",
    "        self.x += other.x\n",
    "        self.y += other.y\n",
    "        return self\n",
    "        \n",
    "    def __imul__(self, other):\n",
    "        self.x *= other\n",
    "        self.y *= other\n",
    "        return self"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.10.8 변환 메서드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, x = 0, y = 0):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def __int__(self):\n",
    "        return int(self.x) + int(self.y)\n",
    "    \n",
    "    def __float__(self):\n",
    "        return float(self.x) + float(self.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = Point(1, 2.5)\n",
    "int(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.10.9 컬렉션 클래스 메서드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Stack:\n",
    "    def __init__(self):\n",
    "        self.mylist = []\n",
    "        \n",
    "    def append(self, v):\n",
    "        self.mylist.append(v)\n",
    "        \n",
    "    def push(self, v):\n",
    "        self.mylist.append(v)\n",
    "        \n",
    "    def pop(self):\n",
    "        return self.mylist.pop()\n",
    "    \n",
    "    def peek(self):\n",
    "        return self.mylist[-1]\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.mylist)\n",
    "    \n",
    "    def __contains__(self, v):\n",
    "        return self.mylist.__contains__(v)  # 포함(containment)은 여기에서 사용된다!\n",
    "    \n",
    "    def __getitem__(self, k):\n",
    "        return self.mylist[k]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of stack is: 4\n",
      "First elem is: 10\n",
      "The top of the stack is: 40\n",
      "40\n",
      "30\n",
      "20\n",
      "Size of stack is: 1\n"
     ]
    }
   ],
   "source": [
    "st = Stack()\n",
    "st.push(10)\n",
    "st.push(20)\n",
    "st.push(30)\n",
    "st.push(40)\n",
    "print('Size of stack is:', len(st))\n",
    "print('First elem is:', st[0])\n",
    "print('The top of the stack is:', st.peek())\n",
    "print(st.pop())\n",
    "print(st.pop())\n",
    "print(st.pop())\n",
    "print('Size of stack is:', len(st))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Stack(list):\n",
    "    def push(self, v):\n",
    "        self.append(v)\n",
    "        \n",
    "    def peek(self):\n",
    "        return self[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.10.10 __iter__와 __next__ 구현하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Stack(list):\n",
    "    def __init__(self):\n",
    "        self.mylist = []\n",
    "        \n",
    "    def append(self, v):\n",
    "        self.mylist.append(v)\n",
    "        \n",
    "    def push(self, v):\n",
    "        self.mylist.append(v)\n",
    "        \n",
    "    def pop(self):\n",
    "        return self.mylist.pop()\n",
    "    \n",
    "    def peek(self):\n",
    "        return self.mylist[-1]\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.mylist)\n",
    "    \n",
    "    def __contains__(self, v):\n",
    "        return self.mylist.__contains__(v)  # 포함(containment)은 여기에서 사용된다!\n",
    "    \n",
    "    def __getitem__(self, k):\n",
    "        return self.mylist[k]\n",
    "    \n",
    "    def __iter__(self):\n",
    "        self.current = 0\n",
    "        \n",
    "    def __next__(self):\n",
    "        if self.current < len(self):\n",
    "            self.current += 1\n",
    "            return self.mylist[self.current - 1]\n",
    "        else:\n",
    "            raise StopIteration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9.11 다중 인수 타입 지원"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n is integer.\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "if type(n) == int:\n",
    "    print('n is integer.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n is an integer or derived from it.\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "if isinstance(n, int):\n",
    "    print('n is an integer or derived from it.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n is numeric.\n"
     ]
    }
   ],
   "source": [
    "if isinstance(n, (int, float)):\n",
    "    print('n is numeric.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def __mul__(self, other):\n",
    "        if type(other) == Point:\n",
    "            newx = self.x * other.x\n",
    "            newy = self.y * other.y\n",
    "            return Point(newx, newy)\n",
    "        elif type(other) == int or type(other) == float:\n",
    "            newx = self.x * other\n",
    "            newy = self.y * other\n",
    "            return Point(newx, newy)\n",
    "        else:\n",
    "            return NotImplemented"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def __mul__(self, other):\n",
    "    if isinstance(other, Point):\n",
    "        newx = self.x * other.x\n",
    "        newy = self.y * other.y\n",
    "        return Point(newx, newy)\n",
    "    elif isinstance(other, (int, float)):\n",
    "        newx = self.x * other\n",
    "        newy = self.y * other\n",
    "        return Point(newx, newy)\n",
    "    else:\n",
    "        return NotImplemented"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "pt2 = 5.5 * pt1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def __rmul__(self, other):\n",
    "    if isinstance(other, (int, float)):\n",
    "        newx = self.x * other\n",
    "        newy = self.y * other\n",
    "        return Point(newx, newy)\n",
    "    else:\n",
    "        return NotImplemented"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9.12 동적 속성 설정 및 조회"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = Dog()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "setattr(d, 'breed', 'Great Dane')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Great Dane'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getattr(d, 'breed')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "field = 'breed'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Great Dane'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getattr(d, field)"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}