17. Optymalizacja.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Profilowanie CPU\n",
    "\n",
    "- dekorowanie funkcji z użyciem funkcji time.time()\n",
    "- cProfile i pstats\n",
    "- line_profiler\n",
    "- %timeit\n",
    "- dis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "# cProfiler wyświetla informacje o czaie wywołąnia fukncji\n",
    "\n",
    "# profiling/ex1.py\n",
    "def has_item(collection, item):\n",
    "    found = False\n",
    "    for i in collection:\n",
    "        if item == i:\n",
    "            found = True\n",
    "    return found\n",
    "\n",
    "\n",
    "#collection = range(100000000)\n",
    "#print has_item(collection, 100000000)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# profiling/ex1a.py\n",
    "def has_item(collection, item):\n",
    "    return item in collection\n",
    "\n",
    "\n",
    "#collection = range(100000000)\n",
    "#print has_item(collection, 100000000)\n",
    "\n",
    "\n",
    "\n",
    "# profiling/ex1.sh\n",
    "# python -m cProfile ex1.py\n",
    "\n",
    "# python -m cProfile ex1a.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# profiling/ex2.py\n",
    "# line profiler wyświetla czasy wykonania poszczagólnych linii\n",
    "# do wyprofilowania funkcji, należy ją udekorować dekoratorem @profile i uruchomić przez kernprof\n",
    "\n",
    "@profile  # ten dekorator nie jest z nikąd importowany\n",
    "def has_item(collection, item):\n",
    "    found = False\n",
    "    for i in collection:\n",
    "        if item == i:\n",
    "            found = True\n",
    "    return found\n",
    "\n",
    "\n",
    "#collection = range(100000000)\n",
    "#print has_item(collection, 100000000)\n",
    "\n",
    "\n",
    "# profiling/ex2.sh\n",
    "#kernprof -l -v ex2.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %timeit w IPythonie pozwala na profilowanie w sesji interaktywnego interpretera\n",
    "\n",
    "%timeit has_item(range(10000000), 10000000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# porównanie co szybsze - if czy obsługa wyjatku\n",
    "\n",
    "def raising(x):\n",
    "    try:\n",
    "        x.f()\n",
    "    except AttributeError:\n",
    "        pass\n",
    "    \n",
    "def ifing(x):\n",
    "    if hasattr(x, 'f'):\n",
    "        x.f()\n",
    "\n",
    "        \n",
    "%timeit raising([])\n",
    "\n",
    "%timeit ifing([])\n",
    "\n",
    "\n",
    "# If jest szybszy niz obsługa wyjatku...\n",
    "\n",
    "\n",
    "print('---')\n",
    "class X(object):\n",
    "    def f(self):\n",
    "        pass\n",
    "    \n",
    "x = X()    \n",
    "%timeit raising(x)\n",
    "\n",
    "%timeit ifing(x)\n",
    "\n",
    "# ... chyba, że wyjątek jest naprawdę sytuacją wyjątkową, a if jest używany za każdym razem\n",
    "# wtedy szybciej jest uzyć wyjątku bo nie ma dodatkowego sprawdzania warunku"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dis słuzy do deasemblacji kodu pythonowego na instrukcje dla maszyny wirtualnej\n",
    "import dis\n",
    "\n",
    "\n",
    "def f():\n",
    "    x = 1\n",
    "    y = []\n",
    "    y.append(x)\n",
    "    print(y)\n",
    "    return x ** 2\n",
    "\n",
    "\n",
    "dis.dis(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Profilowanie Pamięci\n",
    "\n",
    "- memory_profiler\n",
    "- %memit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# profiling/ex3.py\n",
    "# moduł psutil przyspiesza działąnie mempry_profilera\n",
    "\n",
    "def has_item(collection, item):\n",
    "    found = False\n",
    "    for i in collection:\n",
    "        if item == i:\n",
    "            found = True\n",
    "    return found\n",
    "\n",
    "\n",
    "@profile  # tak jak w przypadku linear_profiler dekorujemy funkcję nieimportowanym dekoratorem\n",
    "def main():\n",
    "    collection = range(100000000)\n",
    "    print has_item(collection, 100000000)\n",
    "\n",
    "\n",
    "#main()\n",
    "\n",
    "\n",
    "# profiling/ex3.sh\n",
    "#python -m memory_profiler ex3.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %memit działą w IPythonie\n",
    "%load_ext memory_profiler\n",
    "%memit [0] * 100000000  # nienajgorzej\n",
    "\n",
    "#%memit range(100000000)  # 3GB\n",
    "%memit\n",
    "\n",
    "# Generalnie tytpy podstawowe (int, float, string) jako typyt pythonowe są \"cięższe\"\n",
    "# niż ich odpowiedniki w C\n",
    "\n",
    "# moduł array przechowuje typy podstawowe bez opakowywania ich w obiektowość Pythonową -\n",
    "# do czasu aż nie zaczniemy ich stamtąd wybierać - wtedy liczby będą opakowane w typy Pythonowe\n",
    "# w Cythonie nie ma narzutu ramu przy wybieraniu obiektów z array\n",
    "\n",
    "print(\"array\")\n",
    "import array\n",
    "%memit array.array('l', xrange(100000000))  # nieźle, 700 MB zamiast 3GB\n",
    "\n",
    "print help(array)  # opisane jaka litera to jaki typ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Efektywne wykorzystanie typów wbudowanych i zasobów"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lista i Krotka\n",
    "lista jest alokowana z pewnym zapasem (dodatkowe puste pola), ale jeżeli zostanie zapełńiona, to zostaje zaalokowana nowa pamięć na jeszcze większą listę a oryginalna lista zostaje skopiowana z nowe miejsce. Krotka nie alokuje dodatkowego miejsca na nowe elementy (bo nie ma po co), dlatego w przypadku, kiedy lista ma byc niezmienna oszczedniej jest użyć krotki zamist listy. Złożoność obliczeniowa dostępu do doługości listy/krotki to O(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Słownik i zbiór\n",
    "\n",
    "Używają tablicy haszujacych do wsadzania/wyjmowania obiektów. Obiekt musi mieć zaimplementowane metody \\_\\_hash\\_\\_ i \\_\\_eq\\_\\_ żeby moża go było wsadzić do zbioru/słownika. Dzięki temu złozónosć obliczeniowa dodawania/usuwania ze zbioru/słownika to O(1) natomiast nie ma mozliwosći umieszczenia kiklu elementów o tym samym haszu. Dostęp do ilości elementów wynosi O(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generatory i Iteratory\n",
    "Są przydatne podczas iteracji, szczególnie, jeżeli element po którym jest iterowane miałby być użytyt tylko raz (np. for i in range(X)).\n",
    "\n",
    "Pozwalają zaoszczędzić czas i pamięć na tworzenie listy (Generatory/Iteratory, przechowują tylko stan a nie elementy sekwencji) a ponadto umożliwiają generowanie nieskończonych sekwencji i przerywanie wykonia aż do następnego wybudzenia."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optymalizacja własnych klas\n",
    "\n",
    "Jeżeli mamy własną klasę, która ma mieć określony zestaw atrybutów a instancji tej klasy ma być bardzo dużo, można użyc obiektu namedtuple z modułu collections lub we własnej klasie zdefiniować atrybut \\_\\_slots\\_\\_\n",
    "\n",
    "\\_\\_slots\\_\\_ rezerwują miejsce na atrybuty i zapobiega automatycznemu tworzeniu \\_\\_dict\\_\\_ i \\_\\_weakref\\_\\_.\n",
    "Można dodać \\_\\_dict\\_\\_ do slots'ów w celu umożliwienia dynamicznego dodawania atrybutów.\n",
    "Można dodać \\_\\_weakref\\_\\_ do slots'ów w celu umożliwienia używania słabych referencji.\n",
    "slots tworzy deskryptory dla każdego wylistowanego atrybutu.\n",
    "\\_\\_slots\\_\\_ jest dziedziczne - z tym, że w klsach potomnych \\_\\_dict\\_\\_ i \\_\\_weakref\\_\\_ są tworzone automatycznie. W celu dodania kolejnych slotsów w klasie pochodnej, należy stworzyć atrybut \\_\\_slots\\_\\_ i wpisać tam **TYLKO** nowe atrybuty. Zdefiniowanie w klasie potomnej slotu o takiej nazwie jak w klasie bazowej, przysłania slot z klasy bazowej. \n",
    "\n",
    "\\_\\_slots\\_\\_ nie działa w przypadku użycia w klasach dziedziczących po wbudowanych typach ze zmeinną długością np. int, tuple, bytes.\n",
    "\n",
    "do \\_\\_slots\\_\\_ można przypisywać słowniki - wtedy slotsami będą klucze.\n",
    "\n",
    "można podmieniać klasy w instancji (przypisanie do \\_\\_class\\_\\_) tylko wtedy jeżeli obydwie klasy mają takie same \\_\\_slots\\_\\_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import namedtuple\n",
    "\n",
    "A = namedtuple('A', 'a b c')  # zamiast stringa, może byc lista z nazwami atrybutów\n",
    "print(A)\n",
    "a = A(1, 2, 3)\n",
    "print(a, a[0], a.a)  # do atrybutów namedtuple można odwoływać się przez indeks albo nazwę\n",
    "\n",
    "print(50 * '=')\n",
    "\n",
    "class Slotted(object):\n",
    "    __slots__ = ['a', 'b', 'c']\n",
    "\n",
    "s = Slotted()\n",
    "s.a = 1\n",
    "s.b = 1\n",
    "s.c = 1\n",
    "\n",
    "print(s, s.a, s.b, s.c)\n",
    "s.d = 44  # AttributeError - nie możńa dodawać atrybutów"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inne metody optymalizacji"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uruchomienie kodu przez PyPy\n",
    "\n",
    "Implementacją, która często jest polecana przy problemach z wydajnością, jest impolementacja w Pythonie (PyPy). Dzięki kompilacji JIT (just in time - podczas wykonania kodu) rezultaty są często porównywalne do kodu napisanego w C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kompilacja kodu i rozszerzenia w C\n",
    "\n",
    "- Cython\n",
    "- C\n",
    "\n",
    "Do optymalizacji wąskich gardeł można wykorzystać kod napisany w Cythonie (język pośredni pomiędzy C i Pythonem), który następnie jest kompilowany do biblioteki .so, którą można zaimportować i używać bezposrednio w kodzie Pyhonowym.\n",
    "\n",
    "Do napisania modułu bezpośrednio w C konieczne jest dołączenie pliku nagłówkowego Python.h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uruchamianie interpretera z opcjami -O lub -OO to nie optymalizacja\n",
    "\n",
    "jak flagi -O lub -OO są ustawione to:\n",
    "- interpreter łąduje pliki .pyo zmaiast .pyc\n",
    "- ustawia zmienną \\_\\_debug\\_\\_ na False (pomija wszystkie if \\_\\_debug\\_\\_: ...)\n",
    "- usuwa asserty\n",
    "- usuwa docstringi (w przypadku -OO)\n"
   ]
  },
  {
   "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
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}