Python2016_Wyklad-06.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Język Python - Wykład 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Docstring"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* PEP 257"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Docstringi to komentarze służące do dokumentowania kodu. Zamieszczamy je bezpośrednio po definicji każdej funkcji, klasy czy metody. Oznaczamy je, używając potrójnych cudzysłowów.\n",
    "\n",
    "Dostringi jednolinijkowe:\n",
    "\n",
    "    * Używamy potrójnych cudzysłoów, nawet jeżeli teskt mieści się w jednej linii. Ułatwi to ewentualne rozszerzanie komentarza.\n",
    "    \n",
    "    * Zamykające nawiasy umieszczamy w tej samej linii co otwierające.\n",
    "    \n",
    "    * Nie dajemy pustej linii, przed ani po komentarzu\n",
    "\n",
    "    * Powinno to być zdanie kończące się kropką. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Not sa good\n",
    "def function(a, b):\n",
    "    \"\"\"function(a, b) -> list\"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Better\n",
    "def function(a, b):\n",
    "    \"\"\"Do X and return a list.\"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dokumentacja jest osiągalna przez metode specjalną __doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Foo:\n",
    "    \"\"\"Represents a Foo\"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Foo.__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo_function(arg):\n",
    "    \"\"\"Does foo and returns False\"\"\"\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo_function.__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo_multiline_doc(arg):\n",
    "    \"\"\"\n",
    "    Does foo\n",
    "    and returns \n",
    "    False\n",
    "    \"\"\"\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo_multiline_doc.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python *nie* wspiera docstringów dla zmiennych i atrybutów. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    attribute = 3\n",
    "    \"\"\"Attribute docstring\"\"\"\n",
    "    \n",
    "print(A.__doc__)\n",
    "print(A.attribute.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jednakże niektóre systemy dokumentowania kodu (np. sphinx, epydoc) potrafią parsując kod źródłowy użyć tak skonstruowanych docstringów (warning: it's a hack!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## \"One more thing\" (dekoracja)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_decorator(f):\n",
    "    def wrapper(*args, **kwds):\n",
    "        print('Calling decorated function')\n",
    "        return f(*args, **kwds)\n",
    "    return wrapper\n",
    "\n",
    "@my_decorator\n",
    "def example():\n",
    "    \"\"\"Docstring\"\"\"\n",
    "    print('Called example function')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(example.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(example.__name__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import wraps\n",
    "\n",
    "def my_decorator(f):\n",
    "    @wraps(f)\n",
    "    def wrapper(*args, **kwds):\n",
    "        print('Calling decorated function')\n",
    "        return f(*args, **kwds)\n",
    "    return wrapper\n",
    "\n",
    "@my_decorator\n",
    "def example():\n",
    "    \"\"\"Docstring\"\"\"\n",
    "    print('Called example function')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(example.__doc__)\n",
    "print(example.__name__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* przy pisaniu dekoratorów **powinniśmy** dekorować funkcję dekorującą dekoratorem wraps z argumentem funkcji dekorowanej\n",
    "* przypiszemy nowej funkcji wszystkie potrzebne atrybuty starej funkcji, żeby mogła ją całkowicie podmienić "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Idiomy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Uruchamianie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    print('W module: ', __name__)\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import module_with_very_long_name as vl\n",
    "vl.f()  # easier than module_with_very_long_name.f, but still robust"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Importujemy moduły, nie nazwy. \n",
    "\n",
    "Submoduły importujemy używając from."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from p import sm  # completely fine\n",
    "sm.f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Zamiana wartości"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5\n",
    "b = 7\n",
    "b, a = a, b\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dostęp do atrybutu dla niepewnej wartości"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Odwołanie do atrybutu (np. wywołanie metody) na wartosci, która może być obiektem, ale moze być też pusta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a and a.x\n",
    "a and a.f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W szczególności użyteczne dla wyrażeń regularnych"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "match and match.group(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Warunki logiczne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GOOD\n",
    "name = 'Safe'\n",
    "pets = ['Dog', 'Cat', 'Hamster']\n",
    "owners = {'Safe': 'Cat', 'George': 'Dog'}\n",
    "if name and pets and owners:\n",
    "    print('We have pets!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOT SO GOOD\n",
    "if name != '' and len(pets) > 0 and owners != {}:\n",
    "    print('We have pets!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Przynależność"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GOOD\n",
    "name = 'Safe Hammad'\n",
    "if 'H' in name:\n",
    "    print('This name has an H in it!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOT SO GOOD\n",
    "name = 'Safe Hammad'\n",
    "if name.find('H') != -1:\n",
    "    print('This name has an H in it!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GOOD\n",
    "pets = ['Dog', 'Cat', 'Hamster']\n",
    "ages = [5,2,3]\n",
    "for pet,age in zip(pets,ages):\n",
    "    print(pet, 'is', age, 'years old')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOT SO GOOD\n",
    "pets = ['Dog', 'Cat', 'Hamster']\n",
    "ages = [5,2,3]\n",
    "i = 0\n",
    "while i < len(pets):\n",
    "    print(pets[i], 'is', ages[i], 'years old')\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Składanie tekstu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GOOD\n",
    "chars = ['S', 'a', 'f', 'e']\n",
    "name = ''.join(chars)\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOT SO GOOD\n",
    "chars = ['S', 'a', 'f', 'e']\n",
    "name = ''\n",
    "for char in chars:\n",
    "    name += char\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexsowanie podczas iteracji"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EAFP vs LBYL\n",
    "“It's Easier to Ask for Forgiveness than\n",
    "Permission.”\n",
    "“Look Before You Leap”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GOOD\n",
    "d = {'x': '5'}\n",
    "try:\n",
    "    value = int(d['x'])\n",
    "except (KeyError, TypeError, ValueError):\n",
    "    value = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOT SO GOOD\n",
    "d = {'x': '5'}\n",
    "if 'x' in d and isinstance(d['x'], str) and d['x'].isdigit():\n",
    "    value = int(d['x'])\n",
    "else:\n",
    "    value = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GOOD\n",
    "data = [7, 20, 3, 15, 11]\n",
    "result = [i * 3 for i in data if i > 10]\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOT SO GOOD (MOST OF THE TIME)\n",
    "data = [7, 20, 3, 15, 11]\n",
    "result = []\n",
    "for i in data:\n",
    "    if i > 10:\n",
    "        result.append(i * 3)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Upraszczanie wyboru"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_type = '?'\n",
    "if number_type == 'floating_point':\n",
    "    converter = float\n",
    "elif number_type == 'integer':\n",
    "    converter = int\n",
    "else:\n",
    "    converter = complex\n",
    "converter(\"12\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_type = '?'\n",
    "converters = {\n",
    "    'floating_point' : float,\n",
    "    'integer' : int,\n",
    "}\n",
    "converter = converters.get( number_type , complex )\n",
    "converter(\"12\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wzorce projektowe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Wbudowane:\n",
    "  - iterator\n",
    "  - dekorator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Zasoby:\n",
    "    https://github.com/faif/python-patterns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Singleton"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definicja:\n",
    " -  jeden obiekt danej klasy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zastosowania:\n",
    " * potrzeba tylko jednego obiektu (np. połączenie do bazy danych, logger)\n",
    " * kontrola współbieżnego dostępu do współdzielonego zasobu\n",
    " * singleton tylko-do-odczytu dla globalnego stanu (np. strefa czasowa, język, stałe fizyczne) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Singleton():\n",
    "    def __new__(cls):\n",
    "        if not hasattr(cls, 'instance'):\n",
    "            cls.instance = super().__new__(cls)\n",
    "        return cls.instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "o1 = Singleton()\n",
    "o2 = Singleton()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "o1.x = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(o2.x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id(o1),id(o2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "o1 is o2, o1 == o2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dzielenie stanu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Borg():\n",
    "    _shared_state = {}\n",
    "    def __new__(cls, *args, **kwargs):\n",
    "        obj = super().__new__(cls, *args, **kwargs)\n",
    "        obj.__dict__ = cls._shared_state\n",
    "        return obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b1 = Borg()\n",
    "b2 = Borg()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b1.x = 3\n",
    "b2.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id(b1),id(b2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b1 is b2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://chromium.googlesource.com/external/googleappengine/python/+/master/google/pyglib/singleton.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MVC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definicja:\n",
    " - model  - DANE i LOGIKA BIZNESOWA (nie zależy od widoku i kontrolera)\n",
    " - widok (view) - PREZENTACJA (zależy od modelu)\n",
    " - kontroler (controller) - ŁĄCZY WIDOK i MODEL (zależy od modelu i widoku)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class View():\n",
    "\n",
    "    def product_list(self, product_list):\n",
    "        print('PRODUCT LIST:')\n",
    "        for product in product_list:\n",
    "            print(product)\n",
    "        print('')\n",
    "\n",
    "    def product_information(self, product, product_info):\n",
    "        print('PRODUCT INFORMATION:')\n",
    "        print('Name: %s, Price: %.2f, Quantity: %d\\n' %\n",
    "              (product.title(), product_info.get('price', 0),\n",
    "               product_info.get('quantity', 0)))\n",
    "\n",
    "    def product_not_found(self, product):\n",
    "        print('That product \"%s\" does not exist in the records' % product)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model():\n",
    "\n",
    "    products = {\n",
    "        'milk': {'price': 1.50, 'quantity': 10},\n",
    "        'eggs': {'price': 0.20, 'quantity': 100},\n",
    "        'cheese': {'price': 2.00, 'quantity': 10}\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Controller():\n",
    "\n",
    "    def __init__(self, model, view):\n",
    "        self.model = model\n",
    "        self.view = view\n",
    "\n",
    "    def get_product_list(self):\n",
    "        product_list = self.model.products.keys()\n",
    "        self.view.product_list(product_list)\n",
    "\n",
    "    def get_product_information(self, product):\n",
    "        product_info = self.model.products.get(product, None)\n",
    "        if product_info is not None:\n",
    "            self.view.product_information(product, product_info)\n",
    "        else:\n",
    "            self.view.product_not_found(product)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "controller = Controller(Model(),View())\n",
    "controller.get_product_list()\n",
    "controller.get_product_information('cheese')\n",
    "controller.get_product_information('eggs')\n",
    "controller.get_product_information('milk')\n",
    "controller.get_product_information('arepas')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ViewOther():\n",
    "\n",
    "    def product_list(self, product_list):\n",
    "        print('PRODUCT LIST:')\n",
    "        for product in product_list:\n",
    "            print(\" - \", product)\n",
    "        print('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "controller = Controller(Model(),ViewOther())\n",
    "controller.get_product_list()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Factory method pattern"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A():\n",
    "    def __init__(self):\n",
    "        self.a = \"Hello\"\n",
    "\n",
    "class B():\n",
    "    def __init__(self):\n",
    "        self.a = \" World\"\n",
    "    \n",
    "myfactory = {\n",
    "    \"greeting\" : A,\n",
    "    \"subject\" : B,\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfactory[\"greeting\"]().a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strategia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class StrategyExample:\n",
    "    def __init__(self, func=None):\n",
    "        if func:\n",
    "             self.execute = func\n",
    "\n",
    "    def execute(self):\n",
    "        print(\"Original execution\")\n",
    "\n",
    "def executeReplacement1():\n",
    "    print(\"Strategy 1\")\n",
    "\n",
    "def executeReplacement2():\n",
    "    print(\"Strategy 2\")\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    strat0 = StrategyExample()\n",
    "    strat1 = StrategyExample(executeReplacement1)\n",
    "    strat2 = StrategyExample(executeReplacement2)\n",
    "\n",
    "    strat0.execute()\n",
    "    strat1.execute()\n",
    "    strat2.execute()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Observer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point():\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def scale(self, n):\n",
    "        self.x = n * self.x\n",
    "        self.y = n * self.y\n",
    "        \n",
    "def notify(f):\n",
    "    def g(self, n):\n",
    "        print(\"executed\", n)\n",
    "        return f(self, n)\n",
    "    return g\n",
    "\n",
    "Point.scale = notify(Point.scale)\n",
    "p = Point(2.0, 3.0)\n",
    "p.scale(2.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def notify(f):\n",
    "    def g(self, n):\n",
    "        print(\"executed\", n)\n",
    "        return f(self, n)\n",
    "    return g\n",
    "\n",
    "class Point():\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    @notify\n",
    "    def scale(self, n):\n",
    "        self.x = n * self.x\n",
    "        self.y = n * self.y\n",
    "        \n",
    "\n",
    "p = Point(2.0, 3.0)\n",
    "p.scale(2.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ""
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3.0
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}