wyklady/js-python_w05.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Języki skryptowe - Python\n",
    "## Wykład 5\n",
    "\n",
    "---\n",
    "\n",
    "* przestrzenie nazw\n",
    "* moduły"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Nazwy zmiennych\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "Hello World!\n",
      "Jestem funkcją.\n"
     ]
    }
   ],
   "source": [
    "zmienna = 10 # zmienna wskazuje na int\n",
    "\n",
    "print(zmienna)\n",
    "\n",
    "zmienna = \"Hello World!\" # zmienna wskazuje na str\n",
    "\n",
    "print(zmienna)\n",
    "\n",
    "def funkcja():\n",
    "    print(\"Jestem funkcją.\")\n",
    "    \n",
    "zmienna = funkcja # zmienna wskazuje na funkcje\n",
    "\n",
    "zmienna()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Niebezpieczne nadpisania\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jestem nową funkcją.\n"
     ]
    }
   ],
   "source": [
    "def moja_nazwa(): # moja_nazwa wskazuje na funkcję\n",
    "    print(\"Jestem funkcją.\")\n",
    "    \n",
    "def moja_nazwa(): # moja_nazwa wskazuje inną funkcję\n",
    "    print(\"Jestem nową funkcją.\")\n",
    "    \n",
    "moja_nazwa()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' object is not callable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-d535b594ed2f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mmoja_nazwa\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m10\u001b[0m \u001b[0;31m# moja_nazwa wskazuje na int\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mmoja_nazwa\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# TypeError: 'int' object is not callable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'int' object is not callable"
     ]
    }
   ],
   "source": [
    "moja_nazwa = 10 # moja_nazwa wskazuje na int \n",
    "\n",
    "moja_nazwa() # TypeError: 'int' object is not callable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Moduły - *import* ...\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "def sin(x):\n",
    "    \"\"\"Zwraca x.\"\"\"\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sin(math.pi / 2) # wywołanie [moduł].[funkcja]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5707963267948966"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sin(math.pi / 2) # wywołanie [funkcja]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Moduły - *from ... import ...*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5707963267948966"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sin\n",
    "\n",
    "def sin(x): # nadpisuje sin z math\n",
    "    \"\"\"Zwraca x.\"\"\"\n",
    "    return x\n",
    "\n",
    "sin(math.pi / 2) # wywołanie funkcji sin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sin(x):\n",
    "    \"\"\"Zwraca x.\"\"\"\n",
    "    return x\n",
    "\n",
    "from math import sin # nadpisuje sin\n",
    "\n",
    "sin(math.pi / 2) # wywołanie math.sin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Przestrzenie nazw\n",
    "\n",
    "---\n",
    "\n",
    "* abstrakcyjna przestrzeń przechowująca nazwy\n",
    "* np. przestrzeń nazw wbudowanych"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'dreload', 'enumerate', 'eval', 'exec', 'filter', 'float', 'format', 'frozenset', 'get_ipython', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']\n"
     ]
    }
   ],
   "source": [
    "print(dir(__builtin__)[-72:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Uwaga: nadpisać można wszystko\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'y': 2, 'x': 1}\n"
     ]
    }
   ],
   "source": [
    "slownik = dict(x=1, y=2)\n",
    "\n",
    "print(slownik)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2)\n"
     ]
    }
   ],
   "source": [
    "def dict(x, y): # nazwy wbudowane też można nadpisać\n",
    "    return x, y\n",
    "\n",
    "slownik = dict(x=1, y=2)\n",
    "\n",
    "print(slownik)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Once deleted, variables cannot be recovered. Proceed (y/[n])? y\n"
     ]
    }
   ],
   "source": [
    "# usuń zmienne sesji jupyter\n",
    "%reset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Przestrzeń nazw lokalnych\n",
    "\n",
    "---\n",
    "\n",
    "* zmienne zdefiniowane wewnątrz funkcji (niedostępne poza nią)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'zmienna_lokalna' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-13-7a69ba8766dd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mzmienna_lokalna\u001b[0m \u001b[0;31m# w której zostały zdefiniowane\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"zmienna_lokalna =\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mzmienna_lokalna\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'zmienna_lokalna' is not defined"
     ]
    }
   ],
   "source": [
    "def funkcja():             # zmienne lokalne dostępne\n",
    "    zmienna_lokalna = 1    # są tylko wewnątrz funkcji\n",
    "    return zmienna_lokalna # w której zostały zdefiniowane\n",
    "\n",
    "print(\"zmienna_lokalna =\", zmienna_lokalna)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Przestrzeń nazw globalnych\n",
    "\n",
    "---\n",
    "\n",
    "* dostępne w całym module (pliku)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zmienna_globalna = \"Python\"\n",
    "\n",
    "def funkcja():\n",
    "    return zmienna_globalna\n",
    "\n",
    "# wewnątrz funkcji zmienne globalne są dostępne\n",
    "funkcja()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zmienne lokalne nadpisują globalne\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in funkcja: Nowy Python\n",
      "outside funkcja: Python\n"
     ]
    }
   ],
   "source": [
    "zmienna_globalna = \"Python\"\n",
    "\n",
    "def funkcja():\n",
    "    zmienna_globalna = \"Nowy Python\" # lokalna zmienna_globalna\n",
    "    print(\"in funkcja:\", zmienna_globalna)\n",
    "\n",
    "funkcja()\n",
    "\n",
    "print(\"outside funkcja:\", zmienna_globalna) # globalna bez zmian"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Albo *global* albo *local*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'zmienna_globalna' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-16-c9f400fd03ff>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"in funkcja:\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mzmienna_globalna\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# lokalna?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mfunkcja\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# UnboundLocalError: local variable 'zmienna_globalna'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m           \u001b[0;31m# referenced before assignment\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-16-c9f400fd03ff>\u001b[0m in \u001b[0;36mfunkcja\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfunkcja\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"in funkcja:\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mzmienna_globalna\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# globalna?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m     \u001b[0mzmienna_globalna\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"Nowy Python\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"in funkcja:\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mzmienna_globalna\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# lokalna?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'zmienna_globalna' referenced before assignment"
     ]
    }
   ],
   "source": [
    "zmienna_globalna = \"Python\"\n",
    "\n",
    "def funkcja():\n",
    "    print(\"in funkcja:\", zmienna_globalna) # globalna?\n",
    "    zmienna_globalna = \"Nowy Python\"\n",
    "    print(\"in funkcja:\", zmienna_globalna) # lokalna?\n",
    "\n",
    "funkcja() # UnboundLocalError: local variable 'zmienna_globalna'\n",
    "          # referenced before assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Kolejność przestrzeni\n",
    "\n",
    "---\n",
    "\n",
    "* nazwy lokalne, potem globalne, na końcu wbudowane"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type(list()) = <class 'tuple'>\n",
      "type(dict()) = <class 'float'>\n",
      "In funkcja:\n",
      "\ttype(dict()) = <class 'int'>\n",
      "\ttype(list()) = <class 'tuple'>\n",
      "\ttype(int()) = <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "list = tuple # zmienna globalna nadpisuje wbudowane list\n",
    "dict = float # zmienna globalna nadpisuje wbudowane dict\n",
    "\n",
    "print(\"type(list()) =\", type(list()))\n",
    "print(\"type(dict()) =\", type(dict()))\n",
    "\n",
    "def funkcja():\n",
    "    dict = int # zmienna lokalna nadpisuje globalne dict\n",
    "    print(\"In funkcja:\")\n",
    "    print(\"\\ttype(dict()) =\", type(dict())) # lokalna\n",
    "    print(\"\\ttype(list()) =\", type(list())) # globalna\n",
    "    print(\"\\ttype(int()) =\", type(int()))   # wbudowana\n",
    "\n",
    "funkcja()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Once deleted, variables cannot be recovered. Proceed (y/[n])? y\n"
     ]
    }
   ],
   "source": [
    "%reset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Wielokrotne zagnieżdżenie\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "local local a\n",
      "local b\n",
      "global c\n"
     ]
    }
   ],
   "source": [
    "a = \"global a\" # zasięg zmiennych a, b, c\n",
    "b = \"global b\" # jest globalny\n",
    "c = \"global c\"\n",
    "\n",
    "def funkcja():\n",
    "    a = \"local a\" # lokalne a, b dostępne w funkcji\n",
    "    b = \"local b\" # i w każdym kolejnym zagnieżdzeniu\n",
    "    \n",
    "    def funkcja_w_funkcji():\n",
    "        a = \"local local a\" # dostępna tylko w funkcja_w_funkcji\n",
    "        print(a, b, c, sep='\\n')\n",
    "    \n",
    "    funkcja_w_funkcji()\n",
    "    \n",
    "funkcja() # od \"najlokalniejszej\" do \"najglobalniejszej\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Uwaga na globalne mutowalne\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "['a', 'b', 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "y = ['a', 'b', 'c']\n",
    "\n",
    "def funkcja():\n",
    "    x = [1, 2, 3, 4] # przypisanie -> zmienna lokalna\n",
    "    y.append('d')    # modyfikacja -> ciągle globalna\n",
    "    \n",
    "funkcja()\n",
    "\n",
    "print(x, y, sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Wymuszanie zmiennej globalnej\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nowa globalna\n"
     ]
    }
   ],
   "source": [
    "zmienna = \"globalna\"\n",
    "\n",
    "def f():\n",
    "    global zmienna # przypisanie nie tworzy zmiennej lokalnej\n",
    "    zmienna = \"nowa globalna\" # ale modyfikuje globalną\n",
    "    \n",
    "f()\n",
    "\n",
    "print(zmienna)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Wymuszanie zmiennej \"nielokalnej\"\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in g(): local local a\n",
      "in f(): local a\n",
      "outside: global a\n"
     ]
    }
   ],
   "source": [
    "a = \"global a\" # globalna\n",
    "\n",
    "def f():\n",
    "    a = \"local a\" # lokalna w f\n",
    "    \n",
    "    def g():\n",
    "        a = \"local local a\" # lokalna w g\n",
    "        print(\"in g():\", a)\n",
    "        \n",
    "    g()\n",
    "        \n",
    "    print(\"in f():\", a)\n",
    "\n",
    "f()\n",
    "\n",
    "print(\"outside:\", a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Wymuszanie zmiennej \"nielokalnej\"\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in g(): local local a\n",
      "in f(): local a\n",
      "outside: local local a\n"
     ]
    }
   ],
   "source": [
    "a = \"global a\" # globalna\n",
    "\n",
    "def f():\n",
    "    a = \"local a\" # lokalna w f\n",
    "    \n",
    "    def g():\n",
    "        global a # używaj globalnej\n",
    "        a = \"local local a\" # modyfikuje globalną\n",
    "        print(\"in g():\", a)\n",
    "        \n",
    "    g()\n",
    "        \n",
    "    print(\"in f():\", a)\n",
    "\n",
    "f()\n",
    "\n",
    "print(\"outside:\", a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Wymuszanie zmiennej \"nielokalnej\"\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in g(): local local a\n",
      "in f(): local local a\n",
      "outside: global a\n"
     ]
    }
   ],
   "source": [
    "a = \"global a\" # globalna\n",
    "\n",
    "def f():\n",
    "    a = \"local a\" # lokalna w f\n",
    "    \n",
    "    def g():\n",
    "        nonlocal a # użyj a z poprzedniego zagnieżdżenia\n",
    "        a = \"local local a\" # modyfikuje a z f\n",
    "        print(\"in g():\", a)\n",
    "        \n",
    "    g()\n",
    "        \n",
    "    print(\"in f():\", a)\n",
    "\n",
    "f()\n",
    "\n",
    "print(\"outside:\", a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Uwaga dla programistów C/C++\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def funkcja(flag=True):\n",
    "    if flag:   # zmienna zdefiniowana w bloku\n",
    "        x = 10 # jest dostępna poza tym blokiem\n",
    "    else:\n",
    "        x = 20\n",
    "        \n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "funkcja() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "funkcja(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zasięg\n",
    "\n",
    "---\n",
    "\n",
    "* obszar dostępności danej przestrzeni nazw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "from math import cos\n",
    "\n",
    "a = 1 # zasięg -> cały plik\n",
    "\n",
    "def f():\n",
    "    # uwaga: zaleca się wszystkie importy robić na początku\n",
    "    from math import log # zasięg log(...) -> funkcja\n",
    "    b = 2 # zasięg -> funkcja\n",
    "    c = log(3) \n",
    "    \n",
    "d = math.sin(4) # sin(...) poza zasięgiem [moduł].[funkcja]\n",
    "e = cos(5)      # zasięg cos(...) -> cały plik\n",
    "# f = log(6)    # NameError: name 'log' is not defined"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Własny moduł\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting my_module.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile my_module.py\n",
    "\"\"\"To jest mój pierwszy moduł.\"\"\"\n",
    "\n",
    "zmienna_globalna = \"Unikaj zmiennych globalnych!\"\n",
    "\n",
    "def moja_funkcja():\n",
    "    \"\"\"Drukuje zmienną globalną.\"\"\"\n",
    "    print(zmienna_globalna)\n",
    "    \n",
    "def inna_funkcja(word=\"\", n=0):\n",
    "    \"\"\"Drukuje word n razy.\"\"\"\n",
    "    print(word * n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Importowanie własnego modułu\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Unikaj zmiennych globalnych!'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import my_module\n",
    "\n",
    "my_module.zmienna_globalna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unikaj zmiennych globalnych!\n"
     ]
    }
   ],
   "source": [
    "my_module.moja_funkcja()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------\n"
     ]
    }
   ],
   "source": [
    "my_module.inna_funkcja(\"-\", 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Dokumentacja modułu\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module my_module:\n",
      "\n",
      "NAME\n",
      "    my_module - To jest mój pierwszy moduł.\n",
      "\n",
      "FUNCTIONS\n",
      "    inna_funkcja(word='', n=0)\n",
      "        Drukuje word n razy.\n",
      "    \n",
      "    moja_funkcja()\n",
      "        Drukuje zmienną globalną.\n",
      "\n",
      "DATA\n",
      "    zmienna_globalna = 'Unikaj zmiennych globalnych!'\n",
      "\n",
      "FILE\n",
      "    /doc/insync/scratch/zajęcia/2016/języki skryptowe - python/js-python/my_module.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import my_module\n",
    "\n",
    "help(my_module)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zawartość modułu\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'inna_funkcja',\n",
       " 'moja_funkcja',\n",
       " 'zmienna_globalna']"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import my_module\n",
    "\n",
    "dir(my_module)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## *doc*, *file*, *name*, *package*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To jest mój pierwszy moduł.\n"
     ]
    }
   ],
   "source": [
    "print(my_module.__doc__) # dokumentacja modułu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/doc/insync/scratch/zajęcia/2016/języki skryptowe - python/js-python/my_module.py\n"
     ]
    }
   ],
   "source": [
    "print(my_module.__file__) # ścieżka do pliku źródłowego"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_module\n"
     ]
    }
   ],
   "source": [
    "print(my_module.__name__)  # nazwa modułu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "print(my_module.__package__) # paczka to zbiór modułów"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## *loader*, *spec*, *cached*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<_frozen_importlib_external.SourceFileLoader object at 0x7f134aded6a0>\n"
     ]
    }
   ],
   "source": [
    "# informacja o \"loaderze\", który został wykorzystany\n",
    "# do zaimportowania modułu    \n",
    "print(my_module.__loader__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ModuleSpec(name='my_module', loader=<_frozen_importlib_external.SourceFileLoader object at 0x7f134aded6a0>, origin='/doc/insync/scratch/zajęcia/2016/języki skryptowe - python/js-python/my_module.py')\n"
     ]
    }
   ],
   "source": [
    "print(my_module.__spec__) # ustalane w momencie importowanie modułu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/doc/insync/scratch/zajęcia/2016/języki skryptowe - python/js-python/__pycache__/my_module.cpython-35.pyc\n"
     ]
    }
   ],
   "source": [
    "print(my_module.__cached__) # ścieżka do pliku .pyc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Plik *pyc*\n",
    "\n",
    "---\n",
    "\n",
    "* plik *pyc* jest wynikiem kompilacji skryptu *py* do kodu bajtowego\n",
    "* przyp. kod masyznowy -> zrozumiały dla procesora\n",
    "* kod bajtowy -> zrozumiały dla maszyny wirtualnej / interpretera"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Kompilowany czy interpretowany?\n",
    "\n",
    "---\n",
    "\n",
    "* uwaga: implementacja języka (a nie język sam w sobie) może być kompilowany lub interpretowany"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 2.38.0 (20140413.2041)\n",
       " -->\n",
       "<!-- Title: interpreter Pages: 1 -->\n",
       "<svg width=\"550pt\" height=\"44pt\"\n",
       " viewBox=\"0.00 0.00 550.00 44.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 40)\">\n",
       "<title>interpreter</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-40 546,-40 546,4 -4,4\"/>\n",
       "<!-- kod źródłowy -->\n",
       "<g id=\"node1\" class=\"node\"><title>kod źródłowy</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"92,-36 0,-36 0,-0 92,-0 92,-36\"/>\n",
       "<text text-anchor=\"middle\" x=\"46\" y=\"-14.3\" font-family=\"Times,serif\" font-size=\"14.00\">kod źródłowy</text>\n",
       "</g>\n",
       "<!-- kompilator -->\n",
       "<g id=\"node2\" class=\"node\"><title>kompilator</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"205,-36 128,-36 128,-0 205,-0 205,-36\"/>\n",
       "<text text-anchor=\"middle\" x=\"166.5\" y=\"-14.3\" font-family=\"Times,serif\" font-size=\"14.00\">kompilator</text>\n",
       "</g>\n",
       "<!-- kod źródłowy&#45;&gt;kompilator -->\n",
       "<g id=\"edge1\" class=\"edge\"><title>kod źródłowy&#45;&gt;kompilator</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M92.1378,-18C100.508,-18 109.277,-18 117.722,-18\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"117.815,-21.5001 127.815,-18 117.815,-14.5001 117.815,-21.5001\"/>\n",
       "</g>\n",
       "<!-- kod bajtowy -->\n",
       "<g id=\"node3\" class=\"node\"><title>kod bajtowy</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"325,-36 241,-36 241,-0 325,-0 325,-36\"/>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-14.3\" font-family=\"Times,serif\" font-size=\"14.00\">kod bajtowy</text>\n",
       "</g>\n",
       "<!-- kompilator&#45;&gt;kod bajtowy -->\n",
       "<g id=\"edge2\" class=\"edge\"><title>kompilator&#45;&gt;kod bajtowy</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M205.309,-18C213.367,-18 222.008,-18 230.48,-18\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"230.679,-21.5001 240.679,-18 230.679,-14.5001 230.679,-21.5001\"/>\n",
       "</g>\n",
       "<!-- interpreter -->\n",
       "<g id=\"node4\" class=\"node\"><title>interpreter</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"434,-36 361,-36 361,-0 434,-0 434,-36\"/>\n",
       "<text text-anchor=\"middle\" x=\"397.5\" y=\"-14.3\" font-family=\"Times,serif\" font-size=\"14.00\">interpreter</text>\n",
       "</g>\n",
       "<!-- kod bajtowy&#45;&gt;interpreter -->\n",
       "<g id=\"edge3\" class=\"edge\"><title>kod bajtowy&#45;&gt;interpreter</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M325.252,-18C333.544,-18 342.306,-18 350.741,-18\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"350.815,-21.5001 360.815,-18 350.815,-14.5001 350.815,-21.5001\"/>\n",
       "</g>\n",
       "<!-- wynik -->\n",
       "<g id=\"node5\" class=\"node\"><title>wynik</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"542,-36 470,-36 470,-0 542,-0 542,-36\"/>\n",
       "<text text-anchor=\"middle\" x=\"506\" y=\"-14.3\" font-family=\"Times,serif\" font-size=\"14.00\">wynik</text>\n",
       "</g>\n",
       "<!-- interpreter&#45;&gt;wynik -->\n",
       "<g id=\"edge4\" class=\"edge\"><title>interpreter&#45;&gt;wynik</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M434.259,-18C442.422,-18 451.201,-18 459.704,-18\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"459.878,-21.5001 469.878,-18 459.878,-14.5001 459.878,-21.5001\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.files.Source at 0x7fdea431bf98>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from graphviz import Source\n",
    "\n",
    "Source('digraph \"interpreter\" { rankdir=LR; node [shape=\"box\", width=1]; \\\n",
    "        \"kod źródłowy\" -> \"kompilator\" -> \"kod bajtowy\" -> \"interpreter\" -> \"wynik\"}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Skrypt jako \"zbior definicji\"\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting my_module.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile my_module.py\n",
    "\"\"\"To jest mój pierwszy moduł.\"\"\"\n",
    "\n",
    "zmienna_globalna = \"Unikaj zmiennych globalnych!\"\n",
    "\n",
    "def moja_funkcja():\n",
    "    \"\"\"Drukuje zmienną globalną.\"\"\"\n",
    "    print(zmienna_globalna)\n",
    "    \n",
    "def inna_funkcja(word=\"\", n=0):\n",
    "    \"\"\"Drukuje word n razy.\"\"\"\n",
    "    print(word * n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "%run my_module.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Skrypt wykonujący operacje\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting my_module.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile my_module.py\n",
    "\"\"\"To jest mój pierwszy moduł.\"\"\"\n",
    "\n",
    "zmienna_globalna = \"Unikaj zmiennych globalnych!\"\n",
    "\n",
    "def moja_funkcja():\n",
    "    \"\"\"Drukuje zmienną globalną.\"\"\"\n",
    "    print(zmienna_globalna)\n",
    "    \n",
    "def inna_funkcja(word=\"\", n=0):\n",
    "    \"\"\"Drukuje word n razy.\"\"\"\n",
    "    print(word * n)\n",
    "    \n",
    "inna_funkcja('-', 10)\n",
    "moja_funkcja()\n",
    "inna_funkcja('-', 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------\n",
      "Unikaj zmiennych globalnych!\n",
      "----------\n"
     ]
    }
   ],
   "source": [
    "%run my_module.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Wykonywanie podczas importowania\n",
    "\n",
    "---\n",
    "\n",
    "```\n",
    "Python 3.5.2 |Anaconda 4.2.0 (64-bit)| (default, Jul  2 2016, 17:53:06) \n",
    "[GCC 4.4.7 20120313 (Red Hat 4.4.7-1)] on linux\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>> import my_module\n",
    "----------\n",
    "Unikaj zmiennych globalnych!\n",
    "----------\n",
    ">>> \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## \"Funkcja *main*\"\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting my_module.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile my_module.py\n",
    "\"\"\"To jest mój pierwszy moduł.\"\"\"\n",
    "\n",
    "zmienna_globalna = \"Unikaj zmiennych globalnych!\"\n",
    "\n",
    "def moja_funkcja():\n",
    "    \"\"\"Drukuje zmienną globalną.\"\"\"\n",
    "    print(zmienna_globalna)\n",
    "    \n",
    "def inna_funkcja(word=\"\", n=0):\n",
    "    \"\"\"Drukuje word n razy.\"\"\"\n",
    "    print(word * n)\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    inna_funkcja('-', 10)\n",
    "    moja_funkcja()\n",
    "    inna_funkcja('-', 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------\n",
      "Unikaj zmiennych globalnych!\n",
      "----------\n"
     ]
    }
   ],
   "source": [
    "%run my_module.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Importowanie a *main*\n",
    "\n",
    "---\n",
    "\n",
    "* instrukcje w *main* nie zostaną wykonane podczas importowania (bo `__name__` = nazwa modułu)\n",
    "\n",
    "```\n",
    "Python 3.5.2 |Anaconda 4.2.0 (64-bit)| (default, Jul  2 2016, 17:53:06) \n",
    "[GCC 4.4.7 20120313 (Red Hat 4.4.7-1)] on linux\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>> import my_module\n",
    ">>> \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Prywatność\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting private.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile private.py\n",
    "\n",
    "public = \"public\"\n",
    "# _ przed nazwą -> from ... import * pomija\n",
    "_internal = \"internal use\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from private import * # importuj wszystko "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'public'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "public"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name '_internal' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-52-69fdfd559f34>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0m_internal\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name '_internal' is not defined"
     ]
    }
   ],
   "source": [
    "_internal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Gdzie interpreter szuka modułów?\n",
    "\n",
    "---\n",
    "\n",
    "1. bieżący katalog\n",
    "2. w katalogach określonych w zmiennej środowiskowej `PYTHONPATH`\n",
    "3. w katalogach określonych w trakcie instalacji (np. `/usr/lib/python`)\n",
    "4. w katalogach określonych w zmiennej `sys.path`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zmienne środowiskowe\n",
    "\n",
    "---\n",
    "\n",
    "* zmienne powłoki systemowej\n",
    "\n",
    "```bash\n",
    "goran@goran-ift:~$ export MOJA_ZMIENNA=\"wartość mojej zmiennej\"\n",
    "goran@goran-ift:~$ echo $MOJA_ZMIENNA \n",
    "wartość mojej zmiennej\n",
    "```\n",
    "\n",
    "* część zmiennych jest inicjowana przy starcie powłoki, np\n",
    "\n",
    "```bash\n",
    "goran@goran-ift:~$ echo $PATH\n",
    "/home/goran/soft/anaconda3/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zmienne środowiskowe\n",
    "\n",
    "---\n",
    "\n",
    "* zmienne można aktualizować\n",
    "\n",
    "```bash\n",
    "goran@goran-ift:~$ export PATH=/newpath/:$PATH\n",
    "goran@goran-ift:~$ echo $PATH\n",
    "/newpath/:/home/goran/soft/anaconda3/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## *sys.path*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['',\n",
       " '/home/goran/soft/anaconda3/lib/python35.zip',\n",
       " '/home/goran/soft/anaconda3/lib/python3.5',\n",
       " '/home/goran/soft/anaconda3/lib/python3.5/plat-linux',\n",
       " '/home/goran/soft/anaconda3/lib/python3.5/lib-dynload',\n",
       " '/home/goran/soft/anaconda3/lib/python3.5/site-packages',\n",
       " '/home/goran/soft/anaconda3/lib/python3.5/site-packages/Sphinx-1.4.6-py3.5.egg',\n",
       " '/home/goran/soft/anaconda3/lib/python3.5/site-packages/setuptools-27.2.0-py3.5.egg',\n",
       " '/home/goran/soft/anaconda3/lib/python3.5/site-packages/IPython/extensions',\n",
       " '/home/goran/.ipython']"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "sys.path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## *sys.path*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['',\n",
       " '/home/goran/soft/anaconda3/lib/python35.zip',\n",
       " '/home/goran/soft/anaconda3/lib/python3.5',\n",
       " '/home/goran/soft/anaconda3/lib/python3.5/plat-linux',\n",
       " '/home/goran/soft/anaconda3/lib/python3.5/lib-dynload',\n",
       " '/home/goran/soft/anaconda3/lib/python3.5/site-packages',\n",
       " '/home/goran/soft/anaconda3/lib/python3.5/site-packages/Sphinx-1.4.6-py3.5.egg',\n",
       " '/home/goran/soft/anaconda3/lib/python3.5/site-packages/setuptools-27.2.0-py3.5.egg',\n",
       " '/home/goran/soft/anaconda3/lib/python3.5/site-packages/IPython/extensions',\n",
       " '/home/goran/.ipython',\n",
       " '/moja/sciezka/do/modulow']"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.path.append(\"/moja/sciezka/do/modulow\")\n",
    "\n",
    "sys.path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Moduł poza katalogiem roboczym\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting /home/goran/trojmian.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile /home/goran/trojmian.py\n",
    "\"\"\"Moduł do obsługi trómianu kwadratowego.\"\"\"\n",
    "\n",
    "from math import sqrt\n",
    "\n",
    "def _delta(a, b, c):\n",
    "    \"\"\"Liczy wyróżnik trójmianu.\"\"\"\n",
    "    return b**2 - 4*a*c\n",
    "\n",
    "def _solve(a, b, d):\n",
    "    \"\"\"Liczy miejsca zerowe.\"\"\"\n",
    "    d = sqrt(d)\n",
    "    return (-b + d) / 2 / a, (-b - d) / 2 / a\n",
    "\n",
    "def solution(a, b, c):\n",
    "    \"\"\"Zwraca miejsca zerowe.\"\"\"\n",
    "    d = _delta(a, b, c)\n",
    "    \n",
    "    if d < 0:return None\n",
    "    elif d == 0: return -b / 2 / a\n",
    "    else: return _solve(a, b, d) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Moduł poza katalogiem roboczym\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "ImportError",
     "evalue": "No module named 'trojmian'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mImportError\u001b[0m                               Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-56-e2dca95631fe>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# nie ma w katalogu roboczym ani w PYTHONPATH itd\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mtrojmian\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mImportError\u001b[0m: No module named 'trojmian'"
     ]
    }
   ],
   "source": [
    "# nie ma w katalogu roboczym ani w PYTHONPATH itd\n",
    "import trojmian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append(\"/home/goran/\") # dodajemy ścieżkę do sys.path\n",
    "import trojmian # teraz działa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Trójmian w akcji\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module trojmian:\n",
      "\n",
      "NAME\n",
      "    trojmian - Moduł do obsługi trómianu kwadratowego.\n",
      "\n",
      "FUNCTIONS\n",
      "    solution(a, b, c)\n",
      "        Zwraca miejsca zerowe.\n",
      "    \n",
      "    sqrt(...)\n",
      "        sqrt(x)\n",
      "        \n",
      "        Return the square root of x.\n",
      "\n",
      "FILE\n",
      "    /home/goran/trojmian.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(trojmian) # nie ma _delta, ale jest sqrt!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Trójmian w akcji\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from trojmian import * # importuj wszystko"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solution(1, 2, 1) # dostęp do solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(4) # dostęp do sqrt z math!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name '_delta' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-62-a5950f05b403>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0m_delta\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# ale _delta nie została zaimportowana\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name '_delta' is not defined"
     ]
    }
   ],
   "source": [
    "_delta(1, 2, 1) # ale _delta nie została zaimportowana"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Paczka\n",
    "\n",
    "---\n",
    "\n",
    "* uporządkowany zbiór modułów\n",
    "\n",
    "```\n",
    "package_name/     # top-level\n",
    "    __init__.py   # wymagane (może być puste)\n",
    "    subpackage1/\n",
    "        __init__.py\n",
    "        module1.py\n",
    "        module2.py\n",
    "        ...\n",
    "    subpackage2/\n",
    "        __init__.py\n",
    "        ...\n",
    "``` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## __init__.py\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting listy_zadan/__init__.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile listy_zadan/__init__.py\n",
    "\"\"\"Inicjalizacja paczki listy_zadan\"\"\"\n",
    "import math # można np. importować moduły"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Lista 4\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting listy_zadan/lista4/__init__.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile listy_zadan/lista4/__init__.py\n",
    "\"\"\"Inicjalizacja podpaczki lista4\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Lista 4 - zadanie 2\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting listy_zadan/lista4/zad2.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile listy_zadan/lista4/zad2.py\n",
    "\"\"\"Napisz funkcję, która znajduje mniejszą liczbę z dwóch podanych.\"\"\"\n",
    "\n",
    "def min2(a, b):\n",
    "    \"\"\"Zwraca mniejszą z dwóch podanych liczb.\"\"\"\n",
    "    if a > b:\n",
    "        return b\n",
    "    return a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Lista 4 - zadanie 3\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting listy_zadan/lista4/zad3.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile listy_zadan/lista4/zad3.py\n",
    "\"\"\"Napisz funkcję, która z podanych liczb (ilość dowolna) znajduje najmniejszą.\"\"\"\n",
    "\n",
    "from listy_zadan.lista4.zad2 import min2\n",
    "\n",
    "def min(*a):\n",
    "    \"\"\"Zwraca najmniejszą z podanych liczb.\"\"\"\n",
    "    current_min = a[0]\n",
    "    \n",
    "    for x in a:\n",
    "        current_min = min2(current_min, x)\n",
    "    \n",
    "    return current_min"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Importowanie\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zad2 = 1\n",
      "Zad3 = 2\n"
     ]
    }
   ],
   "source": [
    "import listy_zadan.lista4.zad2\n",
    "import listy_zadan.lista4.zad3 as zad3\n",
    "\n",
    "print(\"Zad2 =\", listy_zadan.lista4.zad2.min2(1, 5))\n",
    "print(\"Zad3 =\", zad3.min(6, 2, 6, 3, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'scroll': True}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from notebook.services.config import ConfigManager\n",
    "cm = ConfigManager()\n",
    "cm.update('livereveal', {\n",
    "              'scroll': True,\n",
    "})"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Slideshow",
  "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": 1
}