PYTHON-INTERMEDIATE2-0-CLASS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Class\n",
    "*python은 모든 것이 객체입니다.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140499869223144\n",
      "4478747816\n",
      "4478747760\n"
     ]
    }
   ],
   "source": [
    "# 간단한 클래스 생성, 인스턴스 생성\n",
    "class MyClass:\n",
    "    pass\n",
    "\n",
    "my1 = MyClass()\n",
    "my2 = MyClass()\n",
    "\n",
    "print(id(MyClass))\n",
    "print(id(my1))\n",
    "print(id(my2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('c', 'c')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 인스턴스가 아닌 클래스 자체도 동적으로 생성이 가능하고 실행중에도 변경이 가능합니다.\n",
    "# Hello = type('Hello', (object,), {})\n",
    "class MyClass:\n",
    "    pass\n",
    "\n",
    "# 클래스변수\n",
    "my0 = MyClass()\n",
    "MyClass.variable = 'c'\n",
    "my1 = MyClass()\n",
    "(\n",
    "    # my0은 변경전에 만들었지만\n",
    "    # 참조도 동적으로 이루어지기 때문에 결과가 아래와 같습니다.\n",
    "    my0.variable, my1.variable\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "hello() takes 1 positional argument but 2 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-10-67421422be36>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mmy\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMyClass\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mmy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhello\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# hello() 인자를 하나 받도록 설계했는데 없이 호출합니다.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mmy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhello\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'self?'\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# 하나만 받는데 두개를 줬다고 에러를 냅니다.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: hello() takes 1 positional argument but 2 were given"
     ]
    }
   ],
   "source": [
    "# 메서드 탑재. 메서드의 첫번째 인자를 보세요\n",
    "class MyClass:\n",
    "    def hello(self):\n",
    "        return 'world'\n",
    "\n",
    "my = MyClass()\n",
    "my.hello()  # hello() 인자를 하나 받도록 설계했는데 없이 호출합니다.\n",
    "my.hello('self?')  # 하나만 받는데 두개를 줬다고 에러를 냅니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# self의 정체\n",
    "class MyClass:\n",
    "    def hello(self):\n",
    "        return self\n",
    "\n",
    "my = MyClass()\n",
    "my.hello() == my"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "class 안에 선언된 메서드는 기본적으로 첫번째 인자를 **인스턴스**로 받습니다. 꼭 self라고 이름지을 필요는 없는데 self라고 대부분 약속하고 사용합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Object is created. (1, 2, 3) {'keyword': 'hello'}\n"
     ]
    }
   ],
   "source": [
    "# 생성자 (생성 시점에 호출)\n",
    "class MyClass:\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        print('Object is created.', args, kwargs)\n",
    "\n",
    "my1 = MyClass(1,2,3,keyword='hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('hello', 4474043896, 'hello', 4474043896, 'hello', 4474043896)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 클래스변수\n",
    "class MyClass:\n",
    "    variable = \"blah\"\n",
    "\n",
    "my1 = MyClass()\n",
    "my2 = MyClass()\n",
    "MyClass.variable = 'hello'\n",
    "\n",
    "# 세 개가 모두 같은 id입니다.\n",
    "(\n",
    "    my1.variable, id(my1.variable),\n",
    "    my2.variable, id(my2.variable),\n",
    "    MyClass.variable, id(MyClass.variable),\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<bound method MyClass.function of <__main__.MyClass object at 0x1049452b0>>,\n",
       " <bound method MyClass.function of <__main__.MyClass object at 0x104945278>>,\n",
       " <function __main__.MyClass.function>)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#! 이건 그냥 나중에 설명하는게 좋을듯\n",
    "\n",
    "class MyClass:\n",
    "    variable = \"blah\"\n",
    "\n",
    "    # 인스턴스변수 레벨의 변수를 선언\n",
    "    def function(self):\n",
    "        print(\"This is a message inside the class.\")\n",
    "\n",
    "my1 = MyClass()\n",
    "my2 = MyClass()\n",
    "\n",
    "# 인스턴스에서 참조하는 함수와, 클래스에서 참조하는 함수는 repr이 다릅니다.\n",
    "# 나중에 차이를 알아봅시다.\n",
    "(\n",
    "    my1.function, \n",
    "    my2.function, \n",
    "    MyClass.function,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('hello', 'blah', 'helloworld')"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 인스턴스 레벨의 변수는 self에 binding합니다.\n",
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        # 기본적으로는 여기서 정의합니다.\n",
    "        self.world = 'hello'\n",
    "\n",
    "    def function(self):\n",
    "        # 동적인 언어 특성상 어디서든 선언은 가능해요\n",
    "        # 사용하기 전에만 만들어놓으면 됩니다.\n",
    "        # 그렇지만 이런 식으로 하면 관리가 어려워요.\n",
    "        self.hello = 'world'\n",
    "        return self.world + self.hello\n",
    "\n",
    "my1 = MyClass()\n",
    "my2 = MyClass()\n",
    "my2.world = 'blah'\n",
    "my2.another_hello = 'world'  # self에 선언하는것과 같은 효과\n",
    "(\n",
    "    my1.world,\n",
    "    my2.world,\n",
    "    my1.function() or my1.hello  # my1의 return은 None\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('hello', 'world', True, True)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 기본적으로 모든 것이 public합니다.\n",
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self.world = 'hello'\n",
    "        self.hello = 'world'\n",
    "\n",
    "my1 = MyClass()\n",
    "(\n",
    "    my1.world,\n",
    "    my1.hello, \n",
    "    'hello' in dir(my1),\n",
    "    'world' in dir(my1),\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'MyClass' object has no attribute '__world'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-17-4b5834d2b45d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mmy1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMyClass\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mmy1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__world\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmy1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__hello\u001b[0m  \u001b[0;31m# 보이지 않습니다.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'MyClass' object has no attribute '__world'"
     ]
    }
   ],
   "source": [
    "# private하게 만들어봅시다.\n",
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self.__world = 'hello'\n",
    "        self.__hello = 'world'\n",
    "\n",
    "my1 = MyClass()\n",
    "my1.__world, my1.__hello  # 보이지 않습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['_MyClass__hello', '_MyClass__world']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'world2'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self.__world = 'hello'\n",
    "        self.__hello = 'world2'\n",
    "\n",
    "my1 = MyClass()\n",
    "\n",
    "# 이상한 이름이 발견됩니다.\n",
    "print([\n",
    "    name for name in dir(my1) \n",
    "    if 'hello' in name or 'world' in name\n",
    "])\n",
    "\n",
    "# private하다더니 요기 숨어있었네?\n",
    "my1._MyClass__hello"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "class에서 __로 시작하는 속성의 이름은 Python이 변조를 수행합니다. (mangling한다고 합니다.)\n",
    " * class이름을 앞에 붙여서 변조를 합니다.\n",
    " * 그렇지만 강제로 접근하고자 하면 막을 방법은 없습니다.\n",
    " * <span class=\"mark\">**사용자가 실수하는 것은 막지만, 꼭 접근해야 한다면 하게 해줍니다.**</span>\n",
    " * 테스트 등에서도 유용합니다. (접근할 별다른 코드를 작성하지 않아도 되니까요)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![](img/safety-switch.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![](img/python-private-method.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "그렇지만 __는 소스를 어지럽게 하고, 이름을 바꾸는 요상한 행위때문에 사용을 권장하지는 않습니다. _ 하나로 시작되는 이름의 속성을 일반적으로 (관습상, 합의하에) 비공개 속성으로 인지합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('world', 'hello')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self._world = 'hello'\n",
    "        self._hello = 'world'\n",
    "\n",
    "my1 = MyClass()\n",
    "my1._hello, my1._world"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## class에 정의된 method\n",
    "사실 그냥 function입니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<bound method MyClass.function of <__main__.MyClass object at 0x1060b9eb8>>\n",
      "<function MyClass.function at 0x1061f6510>\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def function(self):\n",
    "        print(\"This is a message inside the class.\")\n",
    "\n",
    "my = MyClass()\n",
    "\n",
    "# repr이 다르다는 것은 아까 확인했습니다.\n",
    "print(my.function, MyClass.function, sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "(python 내부적으로)\n",
    "bound method는 함수의 첫번째 인자를 instance로 대체해서 호출해 줍니다.\n",
    "```\n",
    "my = MyClass()\n",
    "my.function() # bound-method\n",
    "```\n",
    "->\n",
    "```\n",
    "my = MyClass()\n",
    "MyClass.function(my)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a message inside the class\n",
      "This is a message inside the class\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['function', 'variable']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MyClass:\n",
    "    variable = \"blah\"\n",
    "    def function(self):\n",
    "        print(\"This is a message inside the class\")\n",
    "\n",
    "my = MyClass()\n",
    "\n",
    "# 그래서 다음 두 개는 같은 효과입니다.\n",
    "my.function()\n",
    "MyClass.function(my)\n",
    "[prop for prop in dir(my) if not prop.startswith('__')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a message inside the class\n",
      "This is a message inside the class\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['function', 'variable']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MyClass:\n",
    "    variable = \"blah\"\n",
    "\n",
    "# 따라서 꼭 class안에 선언할 필요없이 별도로 분리도 가능합니다.\n",
    "def function(self):\n",
    "    print(\"This is a message inside the class\")\n",
    "MyClass.function = function\n",
    "\n",
    "my = MyClass()\n",
    "\n",
    "# 그래서 다음 두 개는 같은 효과입니다.\n",
    "my.function()\n",
    "MyClass.function(my)\n",
    "[prop for prop in dir(my) if not prop.startswith('__')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a message inside the class\n",
      "This is a new function\n"
     ]
    }
   ],
   "source": [
    "# 인스턴스는 수행시점에 method를 찾습니다.\n",
    "# 클래스메서드는 객체에서 바라보는 것과 클래스 선언부가 다른 id를 갖지만,\n",
    "# 실제로는 같은 참조고리로 연결되어 있습니다. class function을 bound한 것을 instance에서 보관\n",
    "class MyClass:\n",
    "    def function(self):\n",
    "        print(\"This is a message inside the class\")\n",
    "\n",
    "my = MyClass()\n",
    "\n",
    "# 인스턴스생성 후 class변조\n",
    "def new_function(self):\n",
    "    print(\"This is a new function\")\n",
    "MyClass.old_function = MyClass.function\n",
    "MyClass.function = new_function\n",
    "\n",
    "# 수행결과는?\n",
    "my.old_function()\n",
    "my.function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 클래스/인스턴스는 assign되는 내용을 dict타입의 객체로 관리해요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'instance_var': 2, 'dynamic_var': 0, 'dynamic_method': <function <lambda> at 0x10370cc80>}\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    static_var = 1\n",
    "    def __init__(self):\n",
    "        self.instance_var = 2\n",
    "    def method(self):\n",
    "        pass\n",
    "\n",
    "# my1은 실제 self와 동일하기 때문에 이렇게 넣은 것도 관리대상입니다.\n",
    "# 안에서 넣던 밖에서 넣던 동일한 결과\n",
    "my1 = MyClass()\n",
    "my1.dynamic_var = 0\n",
    "my1.dynamic_method = lambda x: print('x')\n",
    "\n",
    "# 최종 확인\n",
    "print(my1.__dict__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mappingproxy({'__dict__': <attribute '__dict__' of 'MyClass' objects>,\n",
       "              '__doc__': None,\n",
       "              '__init__': <function __main__.MyClass.__init__>,\n",
       "              '__module__': '__main__',\n",
       "              '__weakref__': <attribute '__weakref__' of 'MyClass' objects>,\n",
       "              'another_static_var': 3,\n",
       "              'method': <function __main__.MyClass.method>,\n",
       "              'static_var': 1})"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 인스턴스가 아닌 클래스 자체도\n",
    "# dictionary처럼 동작하는 내부 자료구조를 갖고 있습니다.\n",
    "class MyClass:\n",
    "    static_var = 1\n",
    "    def __init__(self):\n",
    "        self.instance_var = 2\n",
    "    def method(self):\n",
    "        pass\n",
    "\n",
    "# 최종확인\n",
    "MyClass.another_static_var = 3\n",
    "MyClass.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "그래서 뭐가 좋은건가요?\n",
    "\n",
    "- 변수(함수를 포함)를 자유롭게 dict처럼 다루어서 클래스, 객체를 변조할 수 있습니다.\n",
    "- 수행시점에! 필요한 시점에!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "다음 builtin function을 알고 있으면 편리합니다.\n",
    " - hasattr\n",
    " - setattr\n",
    " - getattr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(None, True, False, 'world')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MyClass:\n",
    "    pass\n",
    "\n",
    "(\n",
    "    setattr(MyClass, 'hello', 'world'),  # MyClass.hello = 'world'\n",
    "    hasattr(MyClass, 'hello'),\n",
    "    hasattr(MyClass, 'world'),\n",
    "    getattr(MyClass, 'hello'),\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 상속 그리고 classmethod, staticmethod"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 1, 10)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# subclass\n",
    "class Bike():\n",
    "    num_passengers = 1\n",
    "\n",
    "class Car(Bike):\n",
    "    pass\n",
    "\n",
    "class Bus(Bike):\n",
    "    num_passengers = 10\n",
    "\n",
    "\n",
    "bike, car = Bike(), Car()\n",
    "bike.num_passengers, car.num_passengers, Bus().num_passengers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 다중상속\n",
    "class Hybrid(Bus, Car):\n",
    "    def passengers_count(self):\n",
    "        return self.num_passengers\n",
    "\n",
    "Hybrid().passengers_count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[__main__.Hybrid, __main__.Bus, __main__.Car, __main__.Bike, object]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# mro를 이용해서 상속관계의 우선순위를 파악할 수 있습니다.\n",
    "Hybrid.mro()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Cannot create a consistent method resolution\norder (MRO) for bases Bike, Bus",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-19-5b2148ef7b89>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# 똑똑한 다중상속\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# http://stackoverflow.com/questions/29214888/typeerror-cannot-create-a-consistent-method-resolution-order-mro\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mclass\u001b[0m \u001b[0mHybrid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBike\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mBus\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mpassengers_count\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnum_passengers\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: Cannot create a consistent method resolution\norder (MRO) for bases Bike, Bus"
     ]
    }
   ],
   "source": [
    "# 똑똑한 다중상속\n",
    "# http://stackoverflow.com/questions/29214888/typeerror-cannot-create-a-consistent-method-resolution-order-mro\n",
    "class Hybrid(Bike, Bus):\n",
    "    def passengers_count(self):\n",
    "        return self.num_passengers\n",
    "\n",
    "# Bus는 필요없다는 것을 자동으로 detect\n",
    "Hybrid().passengers_count(), Hybrid.mro()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 1\n",
      "1 2 1\n",
      "3 2 3\n"
     ]
    }
   ],
   "source": [
    "#다중상속\n",
    "class A:\n",
    "    x = 1\n",
    "class B(A):\n",
    "    pass\n",
    "class C(A):\n",
    "    pass\n",
    "\n",
    "print(A.x, B.x, C.x)\n",
    "B.x = 2\n",
    "print(A.x, B.x, C.x)\n",
    "A.x = 3\n",
    "print(A.x, B.x, C.x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([__main__.C, __main__.A, object],\n",
       " [__main__.B, __main__.A, object],\n",
       " mappingproxy({'__doc__': None, '__module__': '__main__'}),\n",
       " mappingproxy({'__doc__': None, '__module__': '__main__', 'x': 2}),\n",
       " mappingproxy({'__dict__': <attribute '__dict__' of 'A' objects>,\n",
       "               '__doc__': None,\n",
       "               '__module__': '__main__',\n",
       "               '__weakref__': <attribute '__weakref__' of 'A' objects>,\n",
       "               'x': 3}))"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 종종 할당으로 인한 문제발생시\n",
    "# 원인분석은 mro와 __dict__를 활용하면 편리합니다.\n",
    "C.mro(), B.mro(), C.__dict__, B.__dict__, A.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "다중상속이 가능하다는 것은 알지만, 잘 활용하지는 않습니다. mro자체도 복잡한 상속관계가 아니면 굳이 따지지 않아도 잘 보이니까요."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![tk-class-inheritance](img/tk-class-inheritance.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "대신에 MixIn 패턴을 많이 사용합니다. MixIn은 독립적인 sub객체를 붙여서 기능을 완성하는 개념입니다. 문법적인 지원요소는 없고 클래스이름 끝에 -mixin이라고 이름 붙여서 다중상속형태로 사용합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function MyClass.function1 at 0x10affe9d8>\n",
      "<function MyClass.function2 at 0x10affea60>\n",
      "<bound method MyClass.function1 of <__main__.MyClass object at 0x10af44da0>>\n",
      "<function MyClass.function2 at 0x10affea60>\n"
     ]
    }
   ],
   "source": [
    "# staticmethod, bound되지 않은 method는 기본적으로 일반 function입니다. (from python3.)\n",
    "class MyClass:\n",
    "    variable = \"blah\"\n",
    "\n",
    "    def function1():\n",
    "        print(\"This is a message inside the class.\")\n",
    "\n",
    "    @staticmethod\n",
    "    def function2():\n",
    "        print(\"This is a message inside the class(staticmethod)\")\n",
    "\n",
    "print(MyClass.function1)\n",
    "print(MyClass.function2)\n",
    "print(MyClass().function1)\n",
    "print(MyClass().function2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "staticmethod는 instnace에 붙어있으나 class에 붙어있으나 똑같이 그냥 함수입니다. 클래스, 인스턴스와 어떤 연결고리도 가질 수가 없기 때문에 ** 잘 사용하지 않습니다.** 굳이 class안에 둘 필요가 없으니까요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<__main__.MyClass object at 0x10af78320> world'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# classmethod\n",
    "class MyClass:\n",
    "    @classmethod\n",
    "    def make_myclass(cls):\n",
    "        return cls()\n",
    "\n",
    "    def hello(self):\n",
    "        return '{} world'.format(self)\n",
    "\n",
    "# factory-pattern으로 사용할 수 있습니다.\n",
    "my = MyClass.make_myclass()\n",
    "my.hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('hello python', 'python')"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# properties\n",
    "class MyClass:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "    def hello(self):\n",
    "        return f'hello {self.name}'\n",
    "\n",
    "MyClass('python').hello(), MyClass('python').name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello python'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# properties\n",
    "class MyClass:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "    @property\n",
    "    def hello(self):\n",
    "        return f'hello {self.name}'\n",
    "\n",
    "my1 = MyClass('python')\n",
    "my1.hello\n",
    "# my1.hello = 'world' # 불가능합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'MyClass' object has no attribute 'name'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-13-c72760d80282>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mmy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhello\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 20\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhello\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-13-c72760d80282>\u001b[0m in \u001b[0;36mhello\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mhello\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0;34mf'hello {self.name}'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mhello\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msetter\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mhello\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'MyClass' object has no attribute 'name'"
     ]
    }
   ],
   "source": [
    "# properties에 대한 상세 제어\n",
    "class MyClass:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "    @property\n",
    "    def hello(self):\n",
    "        return f'hello {self.name}'\n",
    "    @hello.setter\n",
    "    def hello(self, value):\n",
    "        self.name = value\n",
    "    @hello.deleter\n",
    "    def hello(self):\n",
    "        del self.name\n",
    "\n",
    "my = MyClass('python')\n",
    "my.hello = 'world'\n",
    "print(my.hello)\n",
    "\n",
    "del my.hello\n",
    "print(my.hello)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: hello python\n",
      "Name: hello python, Length: 12\n"
     ]
    }
   ],
   "source": [
    "obj = MyClass('python')\n",
    "\n",
    "\n",
    "# 객체와 문자열 format 쉽게하기\n",
    "print('Name: {user.hello}'.format(user=obj))\n",
    "\n",
    "# 에러발생, \n",
    "# print('Length: {len(user.hello)})'.format(user=obj))\n",
    "\n",
    "# f-string은 강력하니 많이 활용하세요. 3.6을 사용하고 있다면.\n",
    "print(f'Name: {obj.hello}, Length: {len(obj.hello)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## class는 dynamic하게 다룰 수 있습니다. \n",
    "*Python은 dynamic하니까요!*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('blah', 'blah')"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MyClass:\n",
    "    variable = \"blah\"\n",
    "    def function(self):\n",
    "        print(\"This is a message inside the class.\")\n",
    "\n",
    "my1 = MyClass()\n",
    "my2 = MyClass()\n",
    "\n",
    "my1.variable, my2.variable # 같습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "blah2 blah2 blah2 oops\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "({}, {}, {})"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MyClass:\n",
    "    variable = \"blah\"\n",
    "\n",
    "    def function(self):\n",
    "        print(\"This is a message inside the class.\")\n",
    "\n",
    "my1 = MyClass()\n",
    "my2 = MyClass()\n",
    "my3 = MyClass()\n",
    "\n",
    "# 클래스밖에서 만들고, 바꾸기\n",
    "MyClass.hello = \"oops\"\n",
    "MyClass.variable = 'blah2'\n",
    "print(my1.variable, my2.variable, my3.variable, my1.hello)\n",
    "my1.__dict__, my2.__dict__, my3.__dict__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hack!\n",
      "This is a message inside the class.\n",
      "This is a message inside the class.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'function': <function __main__.<lambda>>}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MyClass:\n",
    "    variable = \"blah\"\n",
    "\n",
    "    def function(self):\n",
    "        print(\"This is a message inside the class.\")\n",
    "\n",
    "my1 = MyClass()\n",
    "my2 = MyClass()\n",
    "\n",
    "# my1(인스턴스)만 특별함수를 갖게 되었습니다.\n",
    "my1.function = lambda : print('hack!')\n",
    "\n",
    "my1.function()\n",
    "my2.function()\n",
    "MyClass().function() # 새로운 객체도 영향받지 않습니다.\n",
    "\n",
    "my1.__dict__ # 이 안에 뭐가 있는지 보세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x 1\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    static_var = 1\n",
    "    def __init__(self):\n",
    "        self.instance_var = 2\n",
    "    def method(self):\n",
    "        pass\n",
    "\n",
    "my1 = MyClass()\n",
    "my1.dynamic_var = 0\n",
    "my1.dynamic_method = lambda x: print('x', x)\n",
    "my1.dynamic_method('1')  # self를 참조하는 bound-method가 아닙니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(<bound method new_method of <__main__.MyClass object at 0x1038a3ba8>>,\n",
       " <bound method new_method of <__main__.MyClass object at 0x1038a3ba8>>,\n",
       " None,\n",
       " None)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MyClass:\n",
    "    static_var = 1\n",
    "    def __init__(self):\n",
    "        self.instance_var = 2\n",
    "    def method(self):\n",
    "        pass\n",
    "\n",
    "def new_method(self):\n",
    "    print(self.instance_var)\n",
    "\n",
    "my1 = MyClass()\n",
    "\n",
    "MyClass.method = new_method\n",
    "MyClass.dynamic_method_to_class = new_method\n",
    "\n",
    "# 객체생성후 클래스를 바꾸었지만 동적 참조하므로\n",
    "# 클래스method를 바꾸었는데 bound-method로 관찰할 수 있습니다.\n",
    "# 즉 bound-method는 동적으로 판단하고 결정하는 속성입니다.\n",
    "# 인스턴스의 dict을 보고, 없으면 class의 dict을 보고 함수이면 bound처리하고 수행해주는 순서라고 추측\n",
    "(\n",
    "    my1.method, my1.dynamic_method_to_class,\n",
    "    my1.method(), my1.dynamic_method_to_class()\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "요약하자면,\n",
    "- 인스턴스의 변수는 접근시점에 어디서 가져올 수 있는지 판단합니다. (python은 동적인 언어이니까요.)\n",
    "- 인스턴스의 메서드는 접근시점에 어디서 가져올 수 있는지 판단합니다. 클래스의 메서드라면 bound처리합니다.\n",
    "\n",
    "각자의 `__dict__`를 탐색하는게 아닐까 싶습니다.\n",
    "- 인스턴스의 `__dict__`에서 찾고 없으면 클래스의 상속관계를 따라 올라가는식으로!\n",
    "- 접근하는 시점에 동적으로 계산합니다. 꼭 호출이 아니더라도 접근하는 시점에! 그렇기때문에 class에 선언된 method와 인스턴스의 method의 id가 달랐습니다. (접근하는 시점에 wrapping을 하는것으로 보입니다.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "class의 구현내용을 임의로 변경하는 방법을 monkey-patching이라고도 합니다. 때때로 외부 라이브러리의 긴급patch를 적용하고자 할 때 유용할 수 있습니다. 물론 설계의 복잡도가 높아지므로 권장하지는 않습니다. javascript처럼 builtin-type에 대한 재정의는 불가능합니다. (문자열 객체를 바꿀 수 없어요 ㅠ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "인스턴스 레벨의 함수 동적바인딩은 필요에 따라 종종 사용할 수도 있지만, unbound된 함수가 아니어서 사실상 쓸모도 없고, 사용자 실수로 인한 경우가 많으며 오동작할 때 분석할 수 있을 정도로만 이해해주어도 좋습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "내부 동작을 이해하고 있으면 Troubleshooting에 강해져요!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function custom_function at 0x10b004400>\n",
      "<bound method custom_function of <__main__.MyClass object at 0x10af44d30>>\n",
      "hello world\n"
     ]
    }
   ],
   "source": [
    "def custom_function(self, value):\n",
    "    print('hello {}'.format(value))\n",
    "\n",
    "# 클래스 자체에도 동적으로 함수를 붙일 수 있습니다.\n",
    "MyClass.custom_function = custom_function\n",
    "\n",
    "print(MyClass.custom_function)\n",
    "\n",
    "# 이전에 만들어두었던 객체도 참조할 수 있습니다.\n",
    "# 호출 시점에 찾으니까요.\n",
    "print(my1.custom_function)\n",
    "my1.custom_function('world')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "blah\n",
      "blahblah\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    variable = \"blah\"\n",
    "\n",
    "    def function(self):\n",
    "        print(\"This is a message inside the class.\")\n",
    "\n",
    "print(MyClass.variable)\n",
    "# 객체의 모든 것은 접근 가능하고, 수정가능합니다.\n",
    "MyClass.variable = 'blahblah'\n",
    "print(MyClass.variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "blahblah\n",
      "blahblah\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    variable = \"blah\"\n",
    "\n",
    "    def function(self):\n",
    "        print(\"This is a message inside the class.\")\n",
    "\n",
    "\n",
    "myobjectx = MyClass()\n",
    "\n",
    "MyClass.variable = 'blahblah'\n",
    "\n",
    "myobjecty = MyClass()\n",
    "\n",
    "# 항상 호출시점에 찾기때문에 이전,\n",
    "# 이후 인스턴스 모두 값이 바뀌어 있습니다.\n",
    "print(myobjecty.variable)\n",
    "print(myobjectx.variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "blahblah\n",
      "blahblah\n",
      "hurray {'variable': 'hurray'}\n",
      "blahblah\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    variable = \"blah\"\n",
    "\n",
    "    def function(self):\n",
    "        print(\"This is a message inside the class.\")\n",
    "        #(self.variable, MyClass.variable)\n",
    "\n",
    "myobjectx = MyClass()\n",
    "myobjectx.variable = 'hurray'  # shadowing\n",
    "MyClass.variable = 'blahblah'\n",
    "myobjecty = MyClass()\n",
    "\n",
    "print(MyClass.variable)\n",
    "print(myobjecty.variable)\n",
    "\n",
    "# 인스턴스에 바인딩된 변수\n",
    "print(myobjectx.variable, myobjectx.__dict__)\n",
    "# shadowing의 경우 인스턴스의 클래스를 접근해서 확인가능\n",
    "print(myobjectx.__class__.variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Can't instantiate abstract class Sample with abstract methods hello",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-35-09c24800880f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      7\u001b[0m         \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mSample\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: Can't instantiate abstract class Sample with abstract methods hello"
     ]
    }
   ],
   "source": [
    "# abstract class\n",
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Sample(ABC):\n",
    "    @abstractmethod\n",
    "    def hello(self, name):\n",
    "        pass\n",
    "\n",
    "Sample()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello world'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class SampleInherited(Sample):\n",
    "    def hello(self, name):\n",
    "        return 'hello {}'.format(name)\n",
    "SampleInherited().hello('world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<span class=\"mark\">closure와 class는 유사점이 많습니다. closure의 자유변수는 instance변수와 의미가 상통합니다. 그래서 바꾸어 구현할 수 있는 여지가 많습니다.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class SampleHello:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "    def hello(self):\n",
    "        return 'hello {}'.format(self.name)\n",
    "\n",
    "def sample_hello(name):\n",
    "    def inner():\n",
    "        return 'hello {}'.format(name)\n",
    "    return inner\n",
    "    \n",
    "SampleHello('python').hello() == sample_hello('python')()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## EXERCISE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sonata is a Red car worth $15000.00.\n",
      "Avante is a Black car worth $20000.00.\n",
      "Sonata is a Red car worth $15000.00.\n",
      "Avante is a Black car worth $20000.00.\n"
     ]
    }
   ],
   "source": [
    "# 클래스를 고쳐주세요. (코드작성)\n",
    "class Vehicle:\n",
    "    def __init__(self, name, color, kind, value):\n",
    "        self.name = name\n",
    "        self.color = color\n",
    "        self.kind = kind\n",
    "        self.value = value\n",
    "    \n",
    "    def description(self):\n",
    "        desc_str = \"%s is a %s %s worth $%.2f.\" % (\n",
    "            self.name, self.color, self.kind, self.value)\n",
    "        return desc_str\n",
    "\n",
    "# test code\n",
    "car1 = Vehicle(\"Sonata\", \"Red\", \"car\", 15000)\n",
    "car2 = Vehicle(\"Avante\", \"Black\", \"car\", 20000)\n",
    "\n",
    "print(car1.description())\n",
    "print(car2.description())\n",
    "\n",
    "# 한화기준으로 출력될 수 있도록\n",
    "# description 함수를 patch해봅시다. (클래스를 고치지 않는 별도 코드작성)\n",
    "# -> Sonata 자동차(색:Red, 종류:car)는 15000원입니다.\n",
    "\n",
    "def locale_description(self):\n",
    "    if self._locale == 'kr':\n",
    "        # -> Sonata 자동차(색:Red, 종류:car)는 15000원입니다.\n",
    "        return f'{self.name} 자동차(색:{self.color}, 종류:{self.kind})는 {self.value*1000}원입니다.'\n",
    "    else:\n",
    "        return self._orig_description()\n",
    "\n",
    "Vehicle._locale = 'en'\n",
    "Vehicle._orig_description = Vehicle.description\n",
    "Vehicle.description = locale_description\n",
    "\n",
    "# test code\n",
    "print(car1.description())\n",
    "print(car2.description())"
   ]
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}