14_idiomy_i_wzorce_projektowe.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Język Python\n",
    "## Idiomy i wzorce projektowe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Uruchamianie i import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo():\n",
    "    pass\n",
    "    \n",
    "print('W module: ', __name__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    print('W module: ', __name__)\n",
    "    \n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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",
    "\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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Modyfikowalna wartość domyślna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# VERY BAD\n",
    "def f(arg=[]):\n",
    "    arg += [1]\n",
    "    return arg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# ALSO BAD\n",
    "def g(arg=None):\n",
    "    arg = arg or []\n",
    "    arg += [1]\n",
    "    return arg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# GOOD\n",
    "def h(arg=None):\n",
    "    if arg is None:\n",
    "        arg = []\n",
    "    arg += [1]\n",
    "    return arg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "h()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Łączenie list"
   ]
  },
  {
   "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(\"{} is {} years old\".format(pet, age))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Iteracja z indeksem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GOOD\n",
    "pets = ['Dog', 'Cat', 'Hamster']\n",
    "for i, elem in enumerate(pets):\n",
    "    print(i, elem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOT SO GOOD\n",
    "pets = ['Dog', 'Cat', 'Hamster']\n",
    "for i in range(len(pets)):\n",
    "    print(i, pets[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A jeśli się da, to użyjmy generatora"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "number_type = '?'\n",
    "converters = defaultdict(lambda: complex, {\n",
    "    'floating_point' : float,\n",
    "    'integer' : int,\n",
    "})\n",
    "converters[number_type](\"12\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Singleton"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definicja:\n",
    " -  jeden obiekt danej klasy\n",
    "\n",
    "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)\n",
    " \n",
    "Bywa nadużywany i stosowany w zastępstwie zmiennych globalnych."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Singleton():\n",
    "    \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": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "o1 = Singleton()\n",
    "o2 = Singleton()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "o1.x = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(o2.x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "id(o1),id(o2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "o1 is o2, o1 == o2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Dzielenie stanu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Borg():\n",
    "    \n",
    "    _shared_state = {}\n",
    "    \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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "b1 = Borg()\n",
    "b2 = Borg()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "b1.x = 3\n",
    "b2.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "id(b1), id(b2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "b1 is b2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "https://chromium.googlesource.com/external/googleappengine/python/+/master/google/pyglib/singleton.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "controller = Controller(Model(), ViewOther())\n",
    "controller.get_product_list()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Strategia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bisection(line):\n",
    "    return 5.5, 6.6\n",
    "\n",
    "def conjugate_gradient(line):\n",
    "    return 3.3, 4.4\n",
    "\n",
    "def test():\n",
    "    solver = conjugate_gradient\n",
    "    print(solver((5.5, 5.5)))\n",
    "    solver = bisection\n",
    "    print(solver((5.5, 5.5)))\n",
    "\n",
    "test() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Observer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point():\n",
    "    \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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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",
    "    \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)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}