L7.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "J\u0119zyk Python - Wyk\u0142ad 7. Metaclass"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "(Opracowanie oparte na \u015bwietnym wpisie StackOverflow @e-satis: http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Tim Peters (ten od PEP 20 - Zen of Python oraz od timsort!)\n",
      "\n",
      "\n",
      "<img src=\"files/L7_img/tim.jpg\">\n",
      "\n",
      "\n",
      "powiedzia\u0142:\n",
      "\n",
      "***Metaclasses are deeper magic than 99% of users should ever worry about. If you wonder whether you need them, you don't (the people who actually need them know with certainty that they need them, and don't need an explanation about why).***"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Klasy jako obiekty"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Definicje klas s\u0142u\u017c\u0105 nam zwykle jako kod, za pomoc\u0105 kt\u00f3rego tworzone s\u0105 obiekty:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class ObjectCreator(object):\n",
      "    pass"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print ObjectCreator()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Ale klasy s\u0105 tak\u017ce same w sobie... obiektami!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print ObjectCreator"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Oznacza to, \u017ce obiekt reprezentuj\u0105cy klas\u0119 ma umiej\u0119tno\u015b\u0107 samemu tworzenia (instancjonowania) innych obiekt\u00f3w. Z tego powodu jest w\u0142a\u015bnie klas\u0105!\n",
      "\n",
      "Ale skoro ka\u017cda klasa jest obiektem to oczywi\u015bcie mo\u017cemy:\n",
      " \n",
      " * przypisa\u0107\u00a0j\u0105 do zmiennej,\n",
      " * skopiowa\u0107 j\u0105,\n",
      " * doda\u0107 do niej\u00a0atrybut,\n",
      " * przekaza\u0107 j\u0105 jako argument funkcji.\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "FooCreator = ObjectCreator\n",
      "print FooCreator()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print hasattr(ObjectCreator, 'bar')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ObjectCreator.bar = 'baz'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print hasattr(ObjectCreator, 'bar')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def echo(x):\n",
      "    print x\n",
      "\n",
      "echo(ObjectCreator)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Dynamiczne tworzenie klas"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Poniewa\u017c klasy s\u0105 obiektami, mo\u017cna je tworzy\u0107 dynamicznie (w run-time):"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def choose_class(name):\n",
      "    if name == 'foo':\n",
      "        class Foo(object):\n",
      "            pass\n",
      "        return Foo # return the class, not an instance\n",
      "    else:\n",
      "        class Bar(object):\n",
      "            pass\n",
      "        return Bar"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print choose_class('foo')\n",
      "print choose_class('bar')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print choose_class('bar')()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "To podej\u015bcie nie jest jednak w pe\u0142ni dynamiczne, bo nadal gdzie\u015b\u00a0jest explicite napisany kod definiuj\u0105cy t\u0105 klas\u0119.\n",
      "\n",
      "Poniewa\u017c klasy s\u0105\u00a0obiektami, to tak\u017ce i one musz\u0105\u00a0by\u0107 przez co\u015b tworzone. Gdy piszemy deklaracj\u0119 klasy i u\u017cywamy s\u0142owa kluczowego **class** interpreter Pythona wywo\u0142uje pewny kod, kt\u00f3ry tworzy t\u0119 klas\u0119\u00a0i zapisuje j\u0105 pod podan\u0105\u00a0nazw\u0105 w namespace (podobnie jak dekorator, wywo\u0142uje kod i zwraca obiekt callable do podstawienia pod dan\u0105\u00a0nazw\u0105).\n",
      "\n",
      "W Pythonie tworzenie obiektu klasy odbywa si\u0119\u00a0explicite poprzez u\u017cycie funkcji type."
     ]
    },
    {
     "cell_type": "raw",
     "metadata": {},
     "source": [
      "type(object) -> the object's type\n",
      "type(name, bases, dict) -> a new type"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print type(1)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print type(\"1\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print type(u\"1\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print type(ObjectCreator())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print type(ObjectCreator)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class MyShinyClass(object):\n",
      "    pass\n",
      "print MyShinyClass"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print type('MyShinyClass', (), {})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ms = type('MyShinyClass', (), {})\n",
      "print ms()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Foo(object):\n",
      "    bar = True\n",
      "\n",
      "class FooChild(Foo):\n",
      "    baz = False"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "FooChild = type('FooChild', (Foo,), {'baz': False})\n",
      "ob = FooChild()\n",
      "print ob.bar, ob.baz"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Czym s\u0105\u00a0metaklasy?"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Metaklasa jest tym czym\u015b co tworzy obiekt reprezentuj\u0105cy klas\u0119 w Pythonie.**\n",
      "\n",
      "Mo\u017cna to sobie wyobrazi\u0107 w ten spos\u00f3b:"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "```\n",
      "MyClass = MetaClass()\n",
      "MyObject = MyClass()\n",
      "```"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Pr\u00f3wnajmy to z tym co ju\u017c\u00a0wiemy o tworzeniu klas:"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "```\n",
      "MyClass = type('MyClass', (), {})\n",
      "```"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Z tego wynika, \u017ce samo **type** jest metaklas\u0105\u00a0w Pythonie. Co wi\u0119cej jest ono domy\u015bln\u0105 metaklas\u0105 u\u017cywan\u0105\u00a0zawsze standardowo, gdy Python stara si\u0119\u00a0utworzy\u0107 jak\u0105\u015b klas\u0119\u00a0z jej deklaracji i definicji.\n",
      "\n",
      "**Dlaczego type() jest przeci\u0105\u017cone?**\n",
      "\n",
      "Ze wzgl\u0119du zasz\u0142o\u015bci j\u0119zykowych i kompatybilno\u015bci wstecznej\n",
      "\n",
      "**Dlaczego type() jest pisane z ma\u0142ej litery skoro to metaklasa?**\n",
      "\n",
      "Ze wzgl\u0119du na konwencj\u0119 innych typ\u00f3w, int, str, unicode (to by\u0142o pisane z ma\u0142ej litery w Pythonie)."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "age = 35\n",
      "print age.__class__"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "name = 'bob'\n",
      "print name.__class__"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def foo(): pass\n",
      "print foo.__class__"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print ObjectCreator().__class__"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "W takim razie - jaka jest klasa obiektu reprezentuj\u0105ca klas\u0119 klasy? "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print ObjectCreator.__class__.__class__"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print age.__class__.__class__"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print name.__class__.__class__"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A wi\u0119c podsumowuj\u0105c - metaklasa to nic innego jak \"fabryka klas\". **type** jest standardowa\u00a0metaklas\u0105 w Pythonie, ale Python pozwala nam j\u0105\u00a0podmieni\u0107 je\u015bli chcemy!"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "``__metaclass__``"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Za pomoc\u0105\u00a0specjalnego atrybutu klasy  ``__metaclass__`` mo\u017cna wskaza\u0107 jakiej metaklasy ma u\u017cy\u0107 Python do tworzenia tej klasy."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "```\n",
      "class Foo(object):\n",
      "    __metaclass__ = some_metaclass\n",
      "    ...\n",
      "```"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Uwaga - jest to pewien hack j\u0119zyka. W momencie deklaracji klasy **class Foo(object)** tak naprawd\u0119\u00a0obiekt tej klasy nie jest jeszcze tworzony. Najpierw przeszukiwana jest jej definicja czy znajduje si\u0119\u00a0tam **``__metaclass__``** - je\u015bli tak, jest dopiero wtedy u\u017cywana do utworzenia obiektu/klasy Foo. Je\u015bli nie ma - u\u017cyty zostanie **type**.\n",
      "\n",
      "A co z dziedziczeniem?\n",
      "\n",
      "```\n",
      "class Bar(Foo):\n",
      "    pass\n",
      "```\n",
      "\n",
      "Python sprawdzi:\n",
      "\n",
      " * Czy Bar zawiera atrybut ``__metaclass__``? \n",
      " * Czy dowolny rodzic klasy (np. Foo) zawiera atrybut ``__metaclass__``? \n",
      " * Czy modu\u0142 zawiera atrybut ``__metaclass__``?\n",
      " * Je\u015bli \u017cadne z powy\u017cszych si\u0119 nie powiod\u0142o - u\u017cyje **type**."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Tworzenie w\u0142asnej metaklasy"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Metaklas mo\u017cemy potrzebowa\u0107, je\u015bli chcemy modyfikowa\u0107 obiekty reprezentuj\u0105ce klasy podczas ich tworzenia. Jest to szczeg\u00f3lnie pomocne przy tworzeniu API. Django ORM (modele) zosta\u0142y utworzone w\u0142a\u015bnie z u\u017cyciem metaklas.\n",
      "\n",
      "Dla uproszczenia przyjmijmy, \u017ce chcemy utworzy\u0107 metaklas\u0119, kt\u00f3ra zapewni, \u017ce wszystkie atrybuty klasy b\u0119d\u0105 mia\u0142y w nazwie tylko WIELKIE LITERY, niezale\u017cnie od tego jak programista napisz\u0119\u00a0definicj\u0119\u00a0klasy."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Metaklas\u0105** (pomimo nazwy) mo\u017ce by\u0107 cokolwiek co da si\u0119\u00a0wywo\u0142a\u0107 (jest callable) i przyjmie argumenty takie same jak **type(name, bases, dict)**"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# the metaclass will automatically get passed the same argument\n",
      "# that you usually pass to `type`\n",
      "def upper_attr(future_class_name, future_class_parents, future_class_attr):\n",
      "  \"\"\"\n",
      "    Return a class object, with the list of its attribute turned \n",
      "    into uppercase.\n",
      "  \"\"\"\n",
      "\n",
      "  # pick up any attribute that doesn't start with '__' and uppercase it\n",
      "  uppercase_attr = {}\n",
      "  for name, val in future_class_attr.items():\n",
      "      if not name.startswith('__'):\n",
      "          uppercase_attr[name.upper()] = val\n",
      "      else:\n",
      "          uppercase_attr[name] = val\n",
      "\n",
      "  # let `type` do the class creation\n",
      "  return type(future_class_name, future_class_parents, uppercase_attr)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Foo(object):\n",
      "    __metaclass__ = upper_attr\n",
      "    \n",
      "    foo = 1\n",
      "    bar = 2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "Foo.FOO"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "Foo.BAR"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "hasattr(Foo, 'bar')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dir(Foo())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Metaklasa nie nazywa\u0142a by si\u0119\u00a0meta**klas\u0105** je\u015bli tego samego nie mo\u017cna by by\u0142o osi\u0105gn\u0105\u0107 u\u017cywaj\u0105c **klasy** zamiast **funkcji**."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# remember that `type` is actually a class like `str` and `int`\n",
      "# so you can inherit from it\n",
      "class UpperAttrMetaclass(type): \n",
      "    # __new__ is the method called before __init__\n",
      "    # it's the method that creates the object and returns it\n",
      "    # while __init__ just initializes the object passed as parameter\n",
      "    # you rarely use __new__, except when you want to control how the object\n",
      "    # is created.\n",
      "    # here the created object is the class, and we want to customize it\n",
      "    # so we override __new__\n",
      "    # you can do some stuff in __init__ too if you wish\n",
      "    # some advanced use involves overriding __call__ as well, but we won't\n",
      "    # see this\n",
      "    def __new__(upperattr_metaclass, future_class_name, \n",
      "                future_class_parents, future_class_attr):\n",
      "\n",
      "        uppercase_attr = {}\n",
      "        for name, val in future_class_attr.items():\n",
      "            if not name.startswith('__'):\n",
      "                uppercase_attr[name.upper()] = val\n",
      "            else:\n",
      "                uppercase_attr[name] = val\n",
      "\n",
      "        return type.__new__(future_class_name, future_class_parents, uppercase_attr)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class UpperAttrMetaclass(type): \n",
      "\n",
      "    def __new__(cls, clsname, bases, dct):\n",
      "\n",
      "        uppercase_attr = {}\n",
      "        for name, val in dct.items():\n",
      "            if not name.startswith('__'):\n",
      "                uppercase_attr[name.upper()] = val\n",
      "            else:\n",
      "                uppercase_attr[name] = val\n",
      "\n",
      "        return super(UpperAttrMetaclass, cls).__new__(cls, \n",
      "                clsname, bases, uppercase_attr)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "\"That's it\"\n",
      "\n",
      "\n",
      "<img src=\"files/L7_img/okay-thats-it-everyone-out-of-the-gene-pool.jpg\"> "
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Metaklasy - raz jeszcze, kr\u00f3cej"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "1. Przechwytujemy akt tworzenia klasy\n",
      "2. Modyfikujemy nowo tworzon\u0105 klas\u0119\n",
      "3. Zwracamy (podstawiamy) "
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Zastosowanie metaklas"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Metaklasy w Pytonie to czarna magia, je\u015bli pytasz po co masz to stosowa\u0107, to oznacza, \u017ce napewno nie powiniene\u015b\u00a0tego stosowa\u0107. Przypomnijmy raz jeszcze co powiedzia\u0142 Tim Peters:\n",
      "\n",
      "*Metaclasses are deeper magic than 99% of users should ever worry about. If you wonder whether you need them, you don't (the people who actually need them know with certainty that they need them, and don't need an explanation about why).*"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Jedynym sensownym u\u017cyciem metaklas jest tworzenie API. Raz jeszcze o django ORM:\n",
      "\n",
      "```\n",
      "class Book(models.Model):\n",
      "    name = models.CharField(max_length=50)\n",
      "    pages = models.IntegerField()\n",
      "\n",
      "django_book = Book(name='The Django', pages='333')\n",
      ">>> print django_book.pages\n",
      "333\n",
      "```"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Zwykle nie ma sensu u\u017cywa\u0107 metaklas. S\u0105 zbyt skomplikowane. Klasy mo\u017cemy spokojnie modyfikowa\u0107 z u\u017cyciem:\n",
      "\n",
      " * dekorator\u00f3w klas\n",
      " * monkey patchingu"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Materia\u0142y wideo"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "\n",
      "\n",
      "<iframe\n",
      "                width=\"640\"\n",
      "                height=\"480\"\n",
      "                src=\"http://www.youtube.com/embed/j82bS2jzS2I\"\n",
      "                frameborder=\"0\"\n",
      "                allowfullscreen\n",
      "            ></iframe>"
     ]
    }
   ],
   "metadata": {}
  }
 ]
}