9. Obiekty.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wszystko jest obiektem.\n",
    "\n",
    "Duck Typing - liczy się interfejs a nie typ\n",
    "\n",
    "W pythonie 2 wyróżna się 2 typy klass - old style i new style. Klasy starego typu są odradzane, jako że są dosyć ograniczone. Różnica pomiędzy definicją klasy nowego a starego typu to dziedziczenie po *object* (klasy nowego typu)\n",
    "\n",
    "W Pythonie 3 wszystkie klasy są nowego typu - nie ma konieczności dziedziczenia po object, ale można\n",
    "\n",
    "\n",
    "Definicja klasy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "# klasa o nazwie Nazwa dziedzicząca po object i nie posiadająca zadnych atrybutóœ i metod zdefiniowanych przez użytkownika\n",
    "\n",
    "# Python 2\n",
    "class Nazwa(object):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 3\n",
    "class Nazwa:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wszystkie atrybuty klasy i instancji są publiczne, a określanie atrybutów jako prywatne i protected to tylko konwencja nazewnictwa:\n",
    "\n",
    "atrybuty zaczynające się od pojedyńczego podkreślnika \\_atrybut - są to atrybuty protected\n",
    "atrybuty zaczynające się od dwóch podkreslników \\_\\_atrybut - są to atrybuty prywatne - Python wspiera prywatnosć atrybutów przez mechanizm *name mangling* - ale nie ze wzgledu na dostęp z zewnątrz, tylko w celu uniknięcia kolizji nazw w przypadku dziedziczenia - Jeżeli nazwa klasy składa się tylko z podkreślników, to *name mangling* nie jest stosowane. Jeżeli nazwa po manglingu byłaby zbyt długa, to podlega skróceniu\n",
    "\n",
    "atrybuty zaczynające się i kończące \\_\\_ (tzw. dunder) to specjalne atrybuty zarezerwowane dla interpretera (np. przeciążanie operatorów itp.)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(object):\n",
    "    def __init__(self, x):\n",
    "        self.__x = x\n",
    "        self.y = 2 * x\n",
    "        self._z = x ** 2\n",
    "        \n",
    "a = A(1)\n",
    "# name mangling przed nazwą atrybutu doczepia _ z nazwą klasy (żeby uniknąć kolizji w klasach dziedziczących)\n",
    "dir(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Atrybuty obiektu przechowywane są w specjalnym słowniku \\_\\_dict\\_\\_. Słownik ten możńa modyfikować:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(A.__dict__)\n",
    "\n",
    "print(a.__dict__)\n",
    "\n",
    "a.__dict__['a'] = 13\n",
    "print(a.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W bloku klasy można też umieszczać wywołania funkcji i inny kod pythonowy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(object):\n",
    "    print('blok')\n",
    "    2 + 2\n",
    "    x = 3\n",
    "    if x > 2:\n",
    "        print('x:', x)  # x to zmienna klasy, ale w bloku klasy odwołanie jest jak do zmiennej lokalnej"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Klasa po utworzeniu jest przekazywana do dekoratorów (jeżlei zostały sprecyzowane)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dekorator(cls):\n",
    "    print(cls)\n",
    "    return cls\n",
    "\n",
    "\n",
    "@dekorator\n",
    "class A(object):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Monkey Patching\n",
    "  \n",
    "To dodawanie metod po definicji klasy, w praktyce wyglada to następująco:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(object):\n",
    "    pass\n",
    "\n",
    "a = A()\n",
    "\n",
    "def f(self):  # wyglada jak metoda, ale jest definiowane poza blokiem klasy\n",
    "    print(self)\n",
    "    \n",
    "A.f = f  # przypięcie funkcji do klasy, to utworzenie nowej metody\n",
    "\n",
    "\n",
    "a.f()  # wywołanie metody - zdefiniowanej poza blokiem klasy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jak dodajemy metody do instancji to bez parametru self:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(object):\n",
    "    pass\n",
    "\n",
    "a = A()\n",
    "\n",
    "def f(self):  # taka sama definicja jak wcześniej\n",
    "    print('f')\n",
    "    \n",
    "    \n",
    "a.f = f  # przypinamy do instancji\n",
    "\n",
    "a.f()  # Błąd - brakuje argumentu *self* - f to nie metoda tylko wywoływalny atrybut!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# próba obejścia:\n",
    "# A, f z poprzedniej komórki\n",
    "\n",
    "from functools import partial\n",
    "\n",
    "a.f = partial(f, a)  # wrzucamy obiekt *a* jako parametr funkcji f\n",
    "a.f()  # działa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**UWAGA - Python 3**\n",
    "\n",
    "W przypadku definiowania metody na zewnątrz klasy - nie można używać *super* bez argumentów (składnia z Pythona 3) \n",
    "i potem przypinać tej metody - skutkuje to RuntimeError:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 3\n",
    "\n",
    "def metoda(self):\n",
    "    super()\n",
    "    \n",
    "\n",
    "class A:\n",
    "    pass\n",
    "\n",
    "A.metoda = metoda\n",
    "a = A()\n",
    "a.metoda()  # RuntimeError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 3\n",
    "# użycie składni takiej jak w Pythonie 2 działa - atrybut __class__ jest opisany niżej\n",
    "\n",
    "def metoda(self):\n",
    "    super(self.__class__, self)\n",
    "    \n",
    "\n",
    "class A:\n",
    "    pass\n",
    "\n",
    "A.metoda = metoda\n",
    "a = A()\n",
    "a.metoda()  # działa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Magiczne (dunder) Metody\n",
    "\n",
    "Metody, wykorzystywane przez interpreter - przysłanianie magicznych metod w instancjach nie ma sensu - zawsze są one wywoływane z przestrzeni klasy\n",
    "```\n",
    "class A:\n",
    "    def __len__(self):\n",
    "        return 5\n",
    "        \n",
    "a = A()\n",
    "a.__len__ = lambda: 4\n",
    "len(a)  # 5```\n",
    "wywoływanie magicznych metod implicite omija również metodę \\_\\_getattribute\\_\\_\n",
    "\n",
    "\n",
    "\\_\\_new\\_\\_ - tworzenie obiektu - jest to metoda klasy z automatu (na etapie tworzenia instancji, jeszcze przecież jej niema)\n",
    "\n",
    "\\_\\_init\\_\\_ - inicjalizacja\n",
    "\n",
    "\\_\\_str\\_\\_, \\_\\_repr\\_\\_, \\_\\_unicode\\_\\_, \\_\\_format\\_\\_ - reprezentacja tekstowa\n",
    "\n",
    "\\_\\_iter\\_\\_ - rzutowanie na listę/krotkę\n",
    "\n",
    "\n",
    "### 3 typy operatorów:\n",
    "* \"normalne\": \\_\\_add\\_\\_, \\_\\_mul\\_\\_\n",
    "* \"i\" - inplace: \\_\\_iadd\\_\\_, \\_\\_imul\\_\\_\n",
    "* \"r\" - reversed: \\_\\_radd\\_\\_, \\_\\_rmul\\_\\_\n",
    "\n",
    "\n",
    "\\_\\_call\\_\\_ - wywoływanie obiektu jak funkcji\n",
    "\n",
    "\\_\\_getitem\\_\\_, \\_\\_setitem\\_\\_, \\_\\_delitem\\_\\_ - dostęp jak do słownika\n",
    "\n",
    "\\_\\_getattr\\_\\_, \\_\\_setattr\\_\\_, \\_\\_delattr\\_\\_, \\_\\_getattribute\\_\\_ - dostęp do atrybutów. Jeżeli przy dostępie do atrybutu, wyrzucony zostanie wyjątek AttributeError, to nasępuje wywołanie metody \\_\\_getattr\\_\\_ z nazwą feralnego atrybutu (ale nie przy usuwaniu nieistniejącego atrybutu).\n",
    "\n",
    "\\_\\_hash\\_\\_ - wyznaczanie hashu obiektu - metoda wywoływana przez wbudowaną funkcję hash(). \\_\\_hash\\_\\_ i \\_\\_eq\\_\\_ są potrzebne do umieszczenia obiektu w zbiorze/słowniku. Jeżeli obiekt nie posiada metody \\_\\_eq\\_\\_ to nie powienien też posiadać metody \\_\\_hash\\_\\_. \n",
    "Jeżeli posiada obie, to \\_\\_hash\\_\\_ powinien byc ten sam dla obiektów, które są równe.\n",
    "Obiekt możę mieć zdefiniowane samo \\_\\_eq\\_\\_, ale wtedy nie jest obiektem haszowalnym.\n",
    "Jeżeli obiekt jest mutowalny, nie powinien mieć zdefiniowanego \\_\\_hash\\_\\_. \n",
    "Obiekty użytkownika mają domyślnie zdefiniowane obydwie metody w ten sposób, że wszystkie instancje są uznawane za różne a \\_\\_hash\\_\\_ oblicznay jest na podstawie miejsca w pamięci - jeżeli obikty są równe to mają też ten sam \\_\\_hash\\_\\_ i id. Jeżeli obiekt definiuje tylko \\_\\_eq\\_\\_, to \\_\\_hash\\_\\_ jest ustawiane na None. Jeżeli klasa potomna implementuje \\_\\_eq\\_\\_ ale chce zachować \\_\\_hash\\_\\_ rodzica, to trzeba to explicite ustawić: \\_\\_hash\\_\\_ = Parent.\\_\\_hash\\_\\_. Jeżeli klasa chce być siłą niehaszowalna, należy przypisać None: \\_\\_hash\\_\\_ = None. Domyślnie hash bytes'ów, stringów i datetime jest \"solony\" - w celu uniknięcia powtarzalności haszu pomiędzy kolejnymi uruchomieniami interpretera i możliwości takiego spreparowania stringów, że czas wsadzania do słownika ma złożoność O(n^2): http://ocert.org/advisories/ocert-2011-003.html\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "### sekwencje\n",
    "definiuje:\n",
    "\n",
    "\\_\\_len\\_\\_ - długosć sekwencji, jeżeli \\_\\_len\\_\\_ zwróci liczbę większą niż sys.maxsize to spowoduje to wyjątek OverflowError\n",
    "\n",
    "\\_\\_length\\_hint\\_\\_ - Python 3.4+ - wywoływane przez operator.length_hint - przybliżona długość - nie musi być dokładna, ale musi być >= 0\n",
    "\n",
    "\\_\\_getitem\\_\\_ - wybieranie elementu z sekwencji - liczba lub slice\n",
    "\n",
    "jeżeli sekwencja nie ma metody \\_\\_iter\\_\\_ to iterowanie następuje przez wrzucanie kolejnych liczb całkowitych od 0 do metody \\_\\_getitem\\_\\_ aż do skutku.\n",
    "\n",
    "sekwencja może dodatkowo zdefiniować metodę \\_\\_contains\\_\\_ do obsługi operatora **in**.\n",
    "Jeżeli w klasie nie ma \\_\\_contains\\_\\_ ale jest \\_\\_iter\\_\\_ to zostanie to wykorzystane do sprawdzania zawierania.\n",
    "\n",
    "Dobrą praktyką, w przypadku mutowalnych sekwencji, jest dopisanie metod jakie ma  lista: append, count, index, extend, insert, pop, remove, reverse, sort, ale nie jest to wymagane.\n",
    "Można również dopisać metody na konkatenację (z rodziny \\_\\_add\\_\\_) i powtarzanie (z rodziny \\_\\_mul\\_\\_)\n",
    "\n",
    "\n",
    "### Mapping\n",
    "\n",
    "typ słownikopodobny - pary klucz-wartość - nie ma potrzeby definiowania magicznych/dunder metod.\n",
    "MutableMapping z modułu collections pozwala na eleganckie stworzenie słownika definiując metody: \\_\\_getitem\\_\\_, \\_\\_setitem\\_\\_, \\_\\_delitem\\_\\_ i keys.\n",
    "\n",
    "może zdefiniować \\_\\_contains\\_\\_ do obsługi operatora *in*\n",
    "\n",
    "\\_\\_missing\\_\\_ - metoda wywoływana  w przypadku kiedy klucza nie ma w słowniku - tylko dla podklas dict'u. przyjmuje brakujący klucz\n",
    "\n",
    "\n",
    "\n",
    "### obiekt iterowalny\n",
    "definiuje:\n",
    "\n",
    "\\_\\_iter\\_\\_ - ma zwracać iterator a nie sekwencję (np. listę)\n",
    "\n",
    "\\_\\_getitem\\_\\_  - jeżeli w klasie nie ma \\_\\_iter\\_\\_ to przy iteracji pętlą for python wrzuca liczby od 0, aż nie zostanie wyrzucony wyjątek IndexError\n",
    "\n",
    "\n",
    "### iterator:\n",
    "definiuje:\n",
    "\n",
    "\\_\\_next\\_\\_ (Python3), next (Python2)- zwraca kolejny element obiektu po którym ma iterować\n",
    "\\_\\_iter\\_\\_ - zwraca self\n",
    "\n",
    "Wyjątek StopIteration oznacza, że juz jest koniec iteracji - jest to automatycznie przechwytywane i obsługiwane przez petlę for\n",
    "\n",
    "w pythonie 3, funkcjonują też asynchroniczne iteratory - wykorzystywane przez ```async for```:\n",
    "\n",
    "\\_\\_aiter\\_\\_ - musi zwrócić asynchroniczny iterator - też siebie\n",
    "\n",
    "\\_\\_anext\\_\\_ - zwraca kolejną wartosć iteratora\n",
    "\n",
    "Asynchroniczny iterator na końcu iteracji powinien wyrzucić StopAsyncIteration\n",
    "\n",
    "\n",
    "### Typ logiczny:\n",
    "\\_\\_bool\\_\\_ - wywoływane przez funkcję bool(); służy do sprawdzania prawdziwości logicznej obiektu; jeżeli obiekt nie ma \\_\\_bool\\_\\_ sprawdzane jest \\_\\_len\\_\\_. Jeżeli nie ma żadnej z tych metod, to obiekt ma wartosć True. \\_\\_bool\\_\\_ powinien zwracać True albo False\n",
    "\n",
    "\n",
    "### Awaitable i korutyny  - Python 3.5+\n",
    "\n",
    "implementują metodę \\_\\_await\\_\\_ - musi ona zwrócić iterotor. ta metoda jest wywoływana podczas wyrażenia await.\n",
    "potem nastęĻuje iteracja po tym iteratorze, który na samym końcu powinien wyrzucić StopIteration. Nie można awaitować w dwóch miejscach na raz na tę samą korutynę\n",
    "\n",
    "metoda *send* rozpoczyna/wznawia działanie korutyny\n",
    "metoda *throw* wyrzuca wyjątek wewnątrz korutyny\n",
    "metoda *close* powoduje zakończenie korutyny i wywołanie metody *throw* wewnątrz iteratora albo wyrzuca GeneratorExit, jeżeli iterator nie ma metody throw\n",
    "\n",
    "\n",
    "### inne atrybuty i metody\n",
    "\n",
    "\\_\\_class\\_\\_  - przechowuje klasę obiektu. np. a = A(); to a.\\_\\_class\\_\\_ to A (obiekt, a nie string)\n",
    "\n",
    "\n",
    "## NotImplemented vs NotImplementedError\n",
    "NotImplemented jest obiektem, który powinna zwracać metoda jezeli nie implementuje danej operacji (np dodawanie), ponieważ wtedy interpreter jest wstanie podjąć akcje mające na celu zwrócenie wyniku (np w przypadku dodawania).\n",
    "\n",
    "NotImplementedError to bład, który jest wyrzucany, kiedy interpreter nie jest juz w stanie zapewnić wyniku operacji - można go obsłuzyć:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(object):    \n",
    "    def __eq__(self, other):\n",
    "        print('A.__eq__')\n",
    "        if not isinstance(other, A):\n",
    "            return NotImplemented\n",
    "        return True\n",
    "        \n",
    "\n",
    "class B(object):\n",
    "    def __eq__(self, other):\n",
    "        print('B.__eq__')\n",
    "        if not isinstance(other, B):\n",
    "            return False\n",
    "        return True\n",
    "    \n",
    "a = A()\n",
    "b = B()\n",
    "\n",
    "a == b  # klasa A zwraca NotImplemented - to próba porównania używając metody z klasy B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Atrybuty Klasy\n",
    "\n",
    "Tak jak instancja ma atrybuty, tak i klasa może mieć atrybuty.\n",
    "\n",
    "Atrybuty klasą są współdzielone pomiędzy instancjami (coś w stylu atrybutów statycznych).\n",
    "\n",
    "Atrybuty klasy definiowane są w bloku klasy/przyczepiane do klasy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(object):\n",
    "    x = 2\n",
    "    y = 3\n",
    "    \n",
    "A.z = 4  # metody też tak były przyczepiane\n",
    "\n",
    "print(A.x, A.y, A.z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do atrybutów klasy można odwoływać się przez klasę i przez instancję (jezeli instancja nie ma juz zdefinowanych atrybutów o tej samej nazwie)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = A()\n",
    "\n",
    "print(A.x)\n",
    "print(a.x)\n",
    "\n",
    "a.x = 4  # przysłonięcie atrybutu klasy - przypisanie obiektu do atrybutu instancji o tej samej nazwie co\n",
    "         # atrybut w klasie przysłąnia atrybut klasy\n",
    "print(a.x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = A()\n",
    "print(b.x)\n",
    "\n",
    "print(a.y)\n",
    "print(b.y)\n",
    "\n",
    "A.y = 33\n",
    "print(a.y)\n",
    "print(b.y)\n",
    "\n",
    "print('A.z, a.z, b.z', A.z, a.z, b.z)  # wszystkie obiekty mają ten sam atrybut z - wzięty z klasy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W przypadku kiedy w instancji jest przysłonięty atrybut klasy, można atrybut klasy wybrać bezpośrednio z klasy używając \\_\\_class\\_\\_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(object):\n",
    "    x = 33\n",
    "    \n",
    "    def f(self):\n",
    "        return self.x\n",
    "    \n",
    "    def g(self):\n",
    "        return self.__class__.x\n",
    "    \n",
    "a = A()\n",
    "a.x = 44\n",
    "\n",
    "print(a.x)\n",
    "print(a.__class__.x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### comprehensions i generator expression wykonane w bloku klasy\n",
    "\n",
    "Wiemy już że atrybuty klasy to zmienne lokalne zdefiniowane w bloku klasy - ale z poziomu metod trzeba odwoływać się do nich przez *self* albo self.\\_\\_class\\_\\_ itp.\n",
    "\n",
    "Wspomniane też zostało, że generator expressions (a w pythonie 3 również pozostałę comprehensions) są zaimplementowane jako funkcje - używając ich w bloku klasy, nie można odwoływać się do atrybutów klasy jako zmiennych lokalnych"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2/3\n",
    "try:\n",
    "    del A  # usuwanie klasy z poprzedniego przykładu\n",
    "except NameError:\n",
    "    pass\n",
    "\n",
    "class A(object):\n",
    "    x_ = 1\n",
    "    y_ = list(x_ + i for i in range(10))  # rozwijanie generator expression do listy\n",
    "    \n",
    "# klasa się w ogóle nie stworzy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2/3\n",
    "try:\n",
    "    del A  # usuwanie klasy z poprzedniego przykładu\n",
    "except NameError:\n",
    "    pass\n",
    "\n",
    "class A(object):\n",
    "    x_ = 1\n",
    "    y_ = (x_ + i for i in range(10))\n",
    "    \n",
    "list(A.y_)  # klasa się stworzy, ale x_ nie jest zdefiniowane"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2/3\n",
    "try:\n",
    "    del A  # usuwanie klasy z poprzedniego przykładu\n",
    "except NameError:\n",
    "    pass\n",
    "\n",
    "class A(object):\n",
    "    x_ = 1\n",
    "    y_ = (A.x_ + i for i in range(10))\n",
    "    \n",
    "list(A.y_)  # teraz działa - jest odwołanie się do x_ przez klasę A - działa to tylko dlatego, że na etapie \n",
    "            # rozwijania generator expression do listy jest po stworzeniu klasy - czyli już A.x_ istnieje"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2/3\n",
    "try:\n",
    "    del A  # usuwanie klasy z poprzedniego przykładu\n",
    "except NameError:\n",
    "    pass\n",
    "\n",
    "class A(object):\n",
    "    x_ = 1\n",
    "    y_ = list(A.x_ + i for i in range(10))  # NameError - A is not definied - na etapie tworzenia klasy odwołujemy\n",
    "                                            # się do niej, ale ona jeszcze się nie utworzyłą i nie istnieje\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2\n",
    "try:\n",
    "    del A  # usuwanie klasy z poprzedniego przykładu\n",
    "except NameError:\n",
    "    pass\n",
    "\n",
    "class A(object):\n",
    "    x_ = 1\n",
    "    y_ = [x_ + i for i in range(10)]  # zadziala - bo w Pythonie 2 list comprehension nie jest zaimplementowane\n",
    "                                      # jako funkcja i bierze zmienną klasy jako lokalne "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 3\n",
    "try:\n",
    "    del A  # usuwanie klasy z poprzedniego przykładu\n",
    "except NameError:\n",
    "    pass\n",
    "\n",
    "class A(object):\n",
    "    x_ = 1\n",
    "    y_ = [x_ + i for i in range(10)]  # Nie przejdzie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Jak odróżnić atrybuty klasy od atrybutów instancji?\n",
    "\n",
    "\n",
    "Atrybuty instancji są przypisywane do instancji - są to wszystkie atrybuty przypisane wewnątrz metod do *self*, np ```self.x = 33``` - ten kod tworzy atrybut instancji o nazwie *x* i przypisuje mu wartosć 33,\n",
    "oraz atrybuty przypisane do instancji poza metodami, np: ```a = A(); a.x = 33``` - stworzenie nowego atrybutu instancji *a* o nazwie *x* i przypisanie mu wartości 33\n",
    "\n",
    "\n",
    "\n",
    "Z kolei Atrybuty klasy, to atrybuty stworzone w bloku klasy, np:\n",
    "```\n",
    "class A(object):\n",
    "    x = 33\n",
    "```\n",
    "tutaj to utworzenie klasy z atrybutem klasy o nazwie *x* i wartości 33.\n",
    "Atrybuty klasy można tworzyc również przez bezpośrednie dopisywanie atrybutów do klasy:\n",
    "\n",
    "A.x = 33  - stworzenie atrybutu klasy o nazwie *x* i przyisaniemu wartości 33.\n",
    "ponieważ do klasy można sie również dobrać przez atrybut \\_\\_class\\_\\_ to można atrybut klasy ustawić też następujaco:\n",
    "```\n",
    "a = A()\n",
    "a.__class__.x = 33\n",
    "```\n",
    "tak jak wcześniej - ustawiamy atrybut klasy o nazwie *x* na wartosć 33"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### classmethods i staticmethods\n",
    "\n",
    "Poza standardowymi metodami, istnieja też metody statyczne i klasy.\n",
    "\n",
    "classmethods przyjmują jako pierwszy argument klasę (a nie instancję) a metody statyczne nie przyjmują żadnej z powyższych. Metody statyczne i klasowe tworzy się używając dekoratorów. Obydwa typy metod można wywoływać zarówno z poziomu klasy i instancji - mają ten sam efekt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(object):\n",
    "    @classmethod\n",
    "    def f(cls):  # cls zamiast self\n",
    "        print(cls)\n",
    "    \n",
    "    @staticmethod\n",
    "    def g():  # brak self i cls\n",
    "        print('g')\n",
    "        \n",
    "\n",
    "a = A()\n",
    "a.f()  # wypisze nazwę klasy i tak\n",
    "A.f()\n",
    "a.g()  # wypisze g\n",
    "A.g()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dziedziczenie\n",
    "\n",
    "W Pythonie klasy bazowe są określane w nawiasie koło nazwy klasy. W Pythonie jedna klasa może mieć wiele klas bazowych.\n",
    "W celu określenia kolejności poszukiwania metod używa się mro (method resolution order)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(object):\n",
    "    def f(self):\n",
    "        print(\"A.f\")\n",
    "    pass\n",
    "\n",
    "class B(object):\n",
    "    pass\n",
    "\n",
    "class C(A):\n",
    "    def f(self):\n",
    "        print(\"C.f\")\n",
    "        pass\n",
    "        \n",
    "class D(B):\n",
    "        pass\n",
    "        \n",
    "class E(C, D):\n",
    "    pass\n",
    "        \n",
    "        \n",
    "print(E.mro())  # metoda mro() pokazuje kolejkę klas do przeszukiwania - w przypadku braku atrybutu/metody w\n",
    "                # jednej z nich Python przeszukuje następną w kolejności - jeżeli nie ma takiego atrybutu/metody\n",
    "                # wyrzucany jest AttributeError\n",
    "E().f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# metoda super wywołuje inną metodę z kalsy bazowej - w Pythonie 2 obowiązkowe jest podanie 2 argumentów, \n",
    "# w pythonie 3 można wywoływać bez argumentów (ale z argumentami też można)\n",
    "\n",
    "class A(object):\n",
    "    def f(self):\n",
    "        print('A.f')\n",
    "        super(A, self).f()  # będzie AttributeError bo chce wywołać metodę f z obiektu object - a tam nie ma takiej\n",
    "\n",
    "class B(object):\n",
    "    def f(self):\n",
    "        print('B.f')\n",
    "        super(B, self).f()\n",
    "\n",
    "class C(A):\n",
    "    def f(self):\n",
    "        print('C.f')\n",
    "        super(C, self).f()\n",
    "        \n",
    "class D(B):\n",
    "    def f(self):\n",
    "        print('D.f')\n",
    "        super(D, self).f()\n",
    "        \n",
    "class E(C, D):\n",
    "    def f(self):\n",
    "        print('E.f')\n",
    "        super(E, self).f()\n",
    "        \n",
    "class F(C, D):\n",
    "    def f(self):\n",
    "        print('F.f')\n",
    "        super(C, self).f()\n",
    "        \n",
    "        \n",
    "print(E.mro())\n",
    "try:\n",
    "    E().f()\n",
    "except AttributeError as e:\n",
    "    print('AttributeError: ', e)\n",
    "\n",
    "print()\n",
    "print()\n",
    "    \n",
    "print(F.mro())\n",
    "try:\n",
    "    F().f()\n",
    "except AttributeError as e:\n",
    "    print('AttributeError: ', e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Managery kontekstu\n",
    "\n",
    "Managery kontekstu funkcjonują w połaczeniu z wyrażeniem *with*.\n",
    "Interfejs managera to 2 metody: \\_\\_enter\\_\\_ i \\_\\_exit\\_\\_.\n",
    "\n",
    "Obiekt, który będzie zwrócony w metodzie enter będzie przypisany do zmiennej po 'as'.\n",
    "\n",
    "Metoda \\_\\_exit\\_\\_ przyjmuje informacje o wyjątku jaki został wyrzucony w bloku kontekstu i nie obsłuzony przez nic (albo same None jeżeli nie byo wyjątku) a zwraca True - jeżeli (ewentualny) wyjątek został przez nią obsłużony albo False jeżeli nie został - taki wyjątek bedzie ponownie wyrzucony. W przypadku pojawienia się wyjątku, działanie managera kontekstu jest przerywane a po obsłudze wyjątku w \\_\\_exit\\_\\_ wykonywany jest kod spoza bloku with\n",
    "\n",
    "Jeżeli zostanie wyrzucony wyjątek w metodzie \\_\\_enter\\_\\_ to nie jest automatycznie wywoływane \\_\\_exit\\_\\_ z tym wyjątkiem - \\_\\_exit\\_\\_ zostanie wywołane tylko wtedy kiedy \\_\\_enter\\_\\_ zakończy się sukcesem.\n",
    "\n",
    "\n",
    "Jeżeli blok with się skończy wykonywać, ale nie z powodu wyjątku, to wtedy wartość zwrócona przez \\_\\_exit\\_\\_ nie jest brana pod uwagę.\n",
    "\n",
    "\n",
    "w Pythonie 3.5 nowe są asynchroniczne managery kontekstu - zawierają one metody \\_\\_aenter\\_\\_ i \\_\\_aexit\\_\\_.\n",
    "wywoływane są przy wejściu i wyjści z asynchronicznego kontekstu: ```async with```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Manager(object):\n",
    "    def __enter__(self):  # __enter__ podczas wejscia do kontekstu - with\n",
    "        print('Manager.__enter__')\n",
    "        return 22  # to co tu zostanie zwrócone będzie przypisane do zmiennej\n",
    "    \n",
    "    def __exit__(self, exc_type, exc_value, traceback):\n",
    "        # exc_type to klasa wyjątku\n",
    "        # exc_value to instancja wyjątku\n",
    "        # traceback to traceback\n",
    "        if exc_type is KeyboardInterrupt:\n",
    "            print('ctrl c')\n",
    "            return True  # oznaczamy wywołanie jako będące sukcesem\n",
    "        print('Exception not handled')\n",
    "        return False\n",
    "        \n",
    "        \n",
    "with Manager() as x:\n",
    "    print(x)  # nic nie wyrzuci wyjątku w bloku - metoda __exit__ zwróci False, ale ponieważ nie było wyjątku to\n",
    "              # nic się nie stanie\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with Manager() as x:\n",
    "    print(x)\n",
    "    raise KeyboardInterrupt('stop')  # KeyboardInterrupt jest obsłużony w metodzie __exit__ - dla neigo metoda\n",
    "                                     # zwraca True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with Manager() as x:  # nie obsługuję błędów automatycznie\n",
    "    print(x)\n",
    "    {}[1]  # KeyError nie jest obsłużony - dla niego metoda __exit__ zwróci False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# managery kontekstu mozna inicjalizować poza blokiem with:\n",
    "\n",
    "man = Manager()\n",
    "with man as x:  # to samo co with Manager() as x\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# można używać kilku managerów w jendym kontekscie:\n",
    "\n",
    "class Manager(object):\n",
    "    def __init__(self, id_):\n",
    "        self.id_ = id_\n",
    "        \n",
    "    def __enter__(self):\n",
    "        print('Manager id:', self.id_)  # na potrzeby identyfikacji managerów\n",
    "        return self.id_\n",
    "    \n",
    "    def __exit__(self, *exc_info):\n",
    "        return True\n",
    "    \n",
    "\n",
    "with Manager(1) as m1, Manager(2) as m2, Manager(3), Manager(4) as m4:  # nie jest wymagane przypisywanie wyników\n",
    "                                                                        # __enter__ do zmiennych\n",
    "    print(m1)  # 1\n",
    "    print(m2)  # 2\n",
    "    print(m4)  # 4\n",
    "    \n",
    "# Manager 3 się tylko wypisał - wynik __enter__ w tym przypadku nie był przypisany do żadnej zmiennej"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# alternatywnie można użyć dekoratora - contextmanager\n",
    "# to co jest przed yield będzie wykonywane jako __enter__\n",
    "# to co jest yield'owane będzie przypisane do zmiennej po 'as'\n",
    "# to co po yield bedzie traktowane jak __exit__\n",
    "from contextlib import contextmanager\n",
    "\n",
    "@contextmanager\n",
    "def manager(arg):\n",
    "    print('__enter__')\n",
    "    print(arg)\n",
    "    yield arg ** 2\n",
    "    print('__exit__')\n",
    "    \n",
    "with manager(2) as x:\n",
    "    print(x)\n",
    "\n",
    "\n",
    "# najcześćiej taki manager kontekstu przyjmuje następującą formę (try/except pozwala obsługiwać wyjątki):\n",
    "@contextmanager\n",
    "def manager(arg):\n",
    "    print('__enter__')\n",
    "    print(arg)\n",
    "    try:\n",
    "        yield arg ** 2\n",
    "    except KeyError:\n",
    "        print('obsługa KeyError')\n",
    "    print('__exit__')\n",
    "    \n",
    "    \n",
    "with manager(2) as x:\n",
    "    {}[1]  # KeyError, ale będzie obsłużony"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deskryptory\n",
    "Deskryptory to klasy, które maja zaimplementowaną co najmniej jedną z metod: \\_\\_get\\_\\_, \\_\\_set\\_\\_.\n",
    "Mogą mieć również zaimplementowane \\_\\_delete\\_\\_.\n",
    "\n",
    "Desktyptory służą do obsłużenia przypisywania, odczytywania i usuwania atrybutu.\n",
    "Pozwalają zachować interfejs klasy bez zmian w wypadku, kiedy do wyznaczenia jakiegoś atrybutu jest potrzeba wykonania jakiejś operacji, a wcześniej nie trzeba było (i był to zwykły obiekt - np int/str)\n",
    "Przypisywane są do atrybutu klasy:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ogolny flow odczytu atrybutu\n",
    "\n",
    "normalnie, kiedy atrybut ```a.x``` nie jest deskryptorem, to wyszukiwanie atrybutu odbywa się w kolejności:\n",
    "1. przeszukiwanie instancji\n",
    "2. przeszukiwanie klasy\n",
    "3. przeszukiwanie klas bazowych\n",
    "Metaklasy nie są przeszukiwane.\n",
    "\n",
    "Jeżeli atrybut jest deskryptorem to flow jest inny niż normalnie:\n",
    "* można wywołać desktyptor ręcznie ```x.__get__(a)```\n",
    "* przy wywołaniu ```a.x``` jest transformowane do ```type(a).__dict__['x'].__get__(a, type(A))```\n",
    "* ```A.x``` jest przekształcane do ```A.__dict__['x'].__get__(None, A)```\n",
    "* przy wywoływaniu desktyptora z klasy bazowej (przez super lub nie) do deksryptora przekazywane są instancja i klasa z której jest to wywoływane a nie klasa bazowa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Deskryptor(object):\n",
    "    def __get__(self, instance, cls):\n",
    "        # instance to insatncja klasy, do której jest przypisany deskryptor i na rzecz której odbywa się odczyt\n",
    "                # atrybutu-deskryptora\n",
    "        # cls to klasa do której jest przypisany deskryptor\n",
    "        print('get:')\n",
    "        print(self, instance, cls)\n",
    "        \n",
    "    def __set__(self, instance, value):\n",
    "        # instance - tak jak prz __get__\n",
    "        # value - obiekt, który jest przypisywany do atrybutu-deskryptora\n",
    "        print('set:')\n",
    "        print(self, instance, value)\n",
    "        \n",
    "    def __delete__(self, instance):\n",
    "        # instance - j.w.\n",
    "        print('delete:')\n",
    "        print(self, instance)\n",
    "        \n",
    "        \n",
    "\n",
    "class A(object):\n",
    "    attr = Deskryptor()  # instancja deskryptora przypisana do atrybutu klasy\n",
    "    \n",
    "\n",
    "a = A()\n",
    "a.attr  # odczytywanie atrybutu klasy (będącego deskryptorem) z instancji\n",
    "a.attr = 24  # próba przysłonienia atrybutu klasy (deskryptora) w instancji\n",
    "a.attr  # nie wyszło - dalej jest to deskryptor\n",
    "del a.attr\n",
    "\n",
    "# a.attr - tutaj do metody __get__ deskryptora jest przekazywane - *instance* to obiekt *a*, *cls* to klasa *A*\n",
    "# a.attr = 24 - tutaj do metody __set__ jako *instance* jest przkazywany obiekt *a* a jako value liczba 24\n",
    "# del a.attr - do metody __delete__ przekazywany jest obiekt *a* jako instance\n",
    "# w każdym z powyższych przypadków, self to instancja deskryptora czyli attr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W Pythonie 3.6 w deksryptorze można zaimplementować metodę \\_\\_set\\_name\\_\\_, do której przekazywana jest klasa i nazwa atrybutu klasy, który będzie deskryptorem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 3.6\n",
    "\n",
    "class Deskryptor:\n",
    "    def __set_name__(self, class_, name):\n",
    "        print('class:', class_, 'name:', name)\n",
    "\n",
    "class A:\n",
    "    d = Deskryptor()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Do pisania deskryptorów nie jest konieczne pisanie klasy od poczatku - można zastosować dekorator *property* i stworzyć deskryptor z funkcji"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A(object):\n",
    "    @property\n",
    "    def x(self):  # nowy deskryptor o nazwie x - jest to przy okazji definicja metody __get__\n",
    "        print('x getter')\n",
    "        return 23\n",
    "    \n",
    "    @x.setter  # definicja metody __set__ - uwaga! - w dekoratorze jest nazwa desktyptora!\n",
    "    def x(self, value):  # taka sama nazwa jak nazwa deskryptora\n",
    "        print('x setter')\n",
    "    \n",
    "    @x.deleter\n",
    "    def x(self):\n",
    "        print('x delete')\n",
    "        \n",
    "a = A()\n",
    "a.x\n",
    "a.x = 24\n",
    "del a.x\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# alternatywnie:\n",
    "def getter(self):\n",
    "    print('x getter')\n",
    "    return 23\n",
    "    \n",
    "def setter(self, value):\n",
    "    print('x setter')\n",
    "    \n",
    "def deleter(self):\n",
    "    print('x delete')\n",
    "\n",
    "class A(object):\n",
    "    x = property(getter, setter, deleter)\n",
    "    # x = property(fget=getter, fset=setter, fdel=deleter)\n",
    "        \n",
    "a = A()\n",
    "a.x\n",
    "a.x = 24\n",
    "del a.x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kombinacje metod deskryptora - jeżeli deskryptora nie ma metody \\_\\_get\\_\\_ to odczyt zwraca niego samego, chyba, że instancja, z której jest odczytywany ma atrybut o takiej nazwie\n",
    "\n",
    "deskryptor mający \\_\\_set\\_\\_ i/lub \\_\\_delete\\_\\_ to tzw. data descriptor.\n",
    "\n",
    "jeżeli deksryptor nie ma powyższych metod to jest to tzw. non-data descriptor - taki deskryptor ma tylko \\_\\_get\\_\\_\n",
    "\n",
    "deskryptor mający \\_\\_get\\_\\_ i \\_\\_set\\_\\_ daje pełną kontrolę nad dostępem do atrybutu i przysłaniają atrybut o takiej samej nazwie w instancji, natomiast non-data descriptors mogą być przysłaniane w instancjach.\n",
    "\n",
    "Żeby przyspieszyć odczyt atrybutu, którego obliczenie może być czasochłonne a wartosć nie będzie się zmienać w czasie (np połaczenie sieciowe), można do atrybutu przypisać Deskryptor, który implementuje tylko metodę \\_\\_set\\_\\_, oblicza wartosć i przypisuje do atrybutu instancji o tej samej nazwie, lub zaimplementować deskryptor z \\_\\_get\\_\\_ i przypisać wartość do atrybutu w instancji. W obydwóch przypadkach, przypisanie atrybutu do instancji odbywa się przez jej \\_\\_dict\\_\\_.\n",
    "\n",
    "Sztuczki te nie działaja w przypadku użycia @property (bo to data-descriptor):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from time import sleep\n",
    "\n",
    "\n",
    "class SetDescriptor(object):\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        \n",
    "    def __set__(self, instance, value):\n",
    "        print('setting')\n",
    "        sleep(3)\n",
    "        instance.__dict__[self.name] = value\n",
    "     \n",
    "    \n",
    "class GetDescriptor(object):\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        \n",
    "    def __get__(self, instance, owner):\n",
    "        print(\"get\")\n",
    "        sleep(3)\n",
    "        val = 22\n",
    "        instance.__dict__[self.name] = val\n",
    "        return val\n",
    "    \n",
    "    \n",
    "def getter(self):\n",
    "    print(\"get\")\n",
    "    sleep(3)\n",
    "    # self.g_prop = 23  - nie można przypisać wartosci do @property niemającego __set__\n",
    "    return 23\n",
    "\n",
    "\n",
    "def setter(self, value):\n",
    "    print('setting')\n",
    "    sleep(3)\n",
    "    self.__dict__['s_prop'] = value\n",
    "    \n",
    "\n",
    "class A(object):\n",
    "    s_desc = SetDescriptor('s_desc')\n",
    "    g_desc = GetDescriptor('g_desc')\n",
    "    g_prop = property(fget=getter)\n",
    "    s_prop = property(fset=setter)\n",
    "    \n",
    "\n",
    "a = A()\n",
    "print(vars(a))\n",
    "print(a.g_desc)  # oczekiwanie przez 3 sekundy\n",
    "#a.g_desc = 25\n",
    "print(a.g_desc)  # wartosć otrzymana od razu\n",
    "print(vars(a))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = A()\n",
    "print(vars(a))  # instancja nie ma żadnych dodatkowych atrybutów\n",
    "print(a.s_desc)  # <__main__.SetDescriptor object at ...>\n",
    "a.s_desc = 55\n",
    "print(a.s_desc)  # teraz odczyt atrybutu instancji, ponieważ deskryptor nie ma metody __get__\n",
    "print(vars(a))  # instancja ma dodatkowy atrybut\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = A()\n",
    "print(vars(a))\n",
    "print(a.g_prop)\n",
    "#a.g_prop = 25  # AttributeError Can't set attribute\n",
    "print(a.g_prop)\n",
    "print(vars(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = A()\n",
    "print( vars(a))\n",
    "#print(a.s_prop)  # AttributeError - Unreadable attribute\n",
    "a.s_prop = 25\n",
    "print(vars(a))  # s_prop jest w słowniku, ale nie można tego odczytać metodą \"konwencjonalną\"\n",
    "print(a.s_prop)  # AttributeError - Unreadable attribute - pomimo przypisania do atrybutu - @property blokuje dostęp\n",
    "\n",
    "# Python najpierw sprawdza czy dany atrybut nie jest deskryptorem i jezeli nie jest to dopiero \n",
    "# sprawdza atrybut w instancji -> klasie -> klasach bazowych"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Przykład klasy z zaimplementowanymi metodami specjalnymi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AIterator(object):\n",
    "    \"\"\"\n",
    "    iterator do iteracji po obiekcie A\n",
    "    \"\"\"\n",
    "    def __init__(self, a):\n",
    "        self.a = a\n",
    "        self.fields = ['x', 'y', 'z']\n",
    "        self.index = 0\n",
    "    \n",
    "    def __iter__(self):\n",
    "        \"\"\"\n",
    "        metoda __iter__ iteratora powinna zwracać self\n",
    "        \"\"\"\n",
    "        return self\n",
    "    \n",
    "    def __next__(self):\n",
    "        if self.index < len(self.fields):\n",
    "            self.index += 1\n",
    "            return self.fields[self.index - 1]\n",
    "        else:\n",
    "            raise StopIteration()\n",
    "            \n",
    "    next = __next__  # kompatybilne z python2 i 3\n",
    "\n",
    "\n",
    "class A(object):\n",
    "    \"\"\"\n",
    "    obiekt A\n",
    "    \"\"\"\n",
    "    def __new__(cls, x, y, z):  # __new__ to metoda klasy, chociaż nie jest bezpośrednio udekorowana\n",
    "        \"\"\"\n",
    "        __new__ to metoda klasy, chociaż nie jest dekorowana @classmethod\n",
    "        \"\"\"\n",
    "        return super(A, cls).__new__(cls)\n",
    "    \n",
    "    def __init__(self, x, y, z):\n",
    "        \"\"\"\n",
    "        __init__ inicjalizuje instancję\n",
    "        \"\"\"\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        self.z = z\n",
    "        \n",
    "    def __unicode__(self):\n",
    "        \"\"\"\n",
    "        __unicode__ rzutuje na unicode\n",
    "        \"\"\"\n",
    "        return u'unicoded'\n",
    "    \n",
    "    def __str__(self):\n",
    "        \"\"\"\n",
    "        __str__ rzutuje na str\n",
    "        \"\"\"\n",
    "        return 'stringed'\n",
    "    \n",
    "    def __format__(self, spec):\n",
    "        \"\"\"\n",
    "        '{:error}'.format(self) -> self.__format__('error')\n",
    "        \"\"\"\n",
    "        if spec == 'error':\n",
    "            raise Exception()\n",
    "        return 'A(x={}, y={}, z={})'.format(self.x, self.y, self.z)\n",
    "    \n",
    "    def __float__(self):\n",
    "        \"\"\"\n",
    "        rzutuje na float\n",
    "        \"\"\"\n",
    "        return self.x\n",
    "    \n",
    "    def __int__(self):\n",
    "        \"\"\"\n",
    "        rzutuje na int\n",
    "        \"\"\"\n",
    "        return int(float(self))\n",
    "    \n",
    "    def __hash__(self):\n",
    "        \"\"\"\n",
    "        haszuje na potrzeby zbioru i słownika\n",
    "        \"\"\"\n",
    "        return int(self) ** 2\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        \"\"\"\n",
    "        self == other\n",
    "        \"\"\"\n",
    "        return self.x == other.x\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        if isinstance(other, A):\n",
    "            return self.x + other.x\n",
    "        return NotImplemented\n",
    "    \n",
    "    __radd__ = __add__ # alias - teraz a.__radd__ to samo co a.__add__\n",
    "    \n",
    "    def __iter__(self):\n",
    "        \"\"\"\n",
    "        zwraca iterator do iterowania po obiekcie i rzutowania na listę/krotkę.\n",
    "        \"\"\"\n",
    "        return (i for i in [self.x, self.y, self.z])\n",
    "\n",
    "#    alternatywna implementacja\n",
    "#    def __iter__(self):\n",
    "#        \"\"\"\n",
    "#        zwraca iterator do iterowania po obiekcie.\n",
    "#        \"\"\"\n",
    "#        for i in [self.x, self.y, self.z]:\n",
    "#            yield i\n",
    "\n",
    "#    alternatywna implementacja 2\n",
    "#    def __iter__(self):\n",
    "#        \"\"\"\n",
    "#        zwraca iterator do iterowania po obiekcie.\n",
    "#        \"\"\"\n",
    "#        return AIterator(self)\n",
    "\n",
    "    def __len__(self):\n",
    "        \"\"\"\n",
    "        len(self)\n",
    "        \"\"\"\n",
    "        return 3\n",
    "    \n",
    "    def __getitem__(self, item):\n",
    "        \"\"\"\n",
    "        __getitem__ -> self[item]\n",
    "        jeżeli wywołane self[start:stop:step] to item to slice(start, stop, step)\n",
    "        \"\"\"\n",
    "        \n",
    "        if isinstance(item, slice):\n",
    "            return [self.x, self.y, self.z][item]\n",
    "        else:\n",
    "            return [self.x, self.y, self.z][item]\n",
    "        \n",
    "    def __setitem__(self, item, val):\n",
    "        \"\"\"\n",
    "        __setitem__ -> self[item] = val\n",
    "        \"\"\"\n",
    "        [self.x, self.y, self.z][item] = val\n",
    "        \n",
    "    def __getattribute__(self, attr):\n",
    "        \"\"\"\n",
    "        -> self.attr\n",
    "        \"\"\"\n",
    "        return getattr(self, attr)\n",
    "    \n",
    "    def __setattr__(self, attr, val):\n",
    "        \"\"\"\n",
    "        -> self.attr = val\n",
    "        \"\"\"\n",
    "        return setattr(self, attr)\n",
    "    \n",
    "    def __getattr__(self, attr):\n",
    "        \"\"\"\n",
    "        obsługa braku atrybutu attr, \n",
    "        np\n",
    "        a = A(1, 2, 3)\n",
    "        a.a -> a.__getattr__('a')\n",
    "        \"\"\"\n",
    "        return 22\n",
    "    \n",
    "    def __contains__(self, item):\n",
    "        \"\"\"\n",
    "        item in self\n",
    "        \"\"\"\n",
    "        return item in [self.x, self.y, self.z]\n",
    "    \n",
    "    def __dir__(self):\n",
    "        \"\"\"\n",
    "        wywoływana przez funkcję dir. zwrócona sekwencja jest zamieniana na listę i sortowana\n",
    "        \"\"\""
   ]
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}