Python2016_Wyklad-01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Język Python - Wykład 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sprawy organizacyjne"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Prowadzący:\n",
    "    * dr Jacek Śmietański, jacek.smietanski@ii.uj.edu.pl\n",
    "* Materiały i informacje: \n",
    "\t * regulamin kursu: na stronie przedmiotu [http://jaceksmietanski.net/python](http://jaceksmietanski.net/python)\n",
    "\t * materiały do wykładu i laboratoriów (publiczne): na moim profilu na [githubie](http://github.com/dadoskawina/Python-lecture)\n",
    "     * tematy projektów zaliczeniowych: [forum na Pegazie](http://pegaz.uj.edu.pl/mod/forum/view.php?id=678687)\n",
    "\n",
    "Materiały do kursu opierają się na opracowaniach [dra inż. Krzysztofa Dorosza z AGH](https://github.com/agh-glk/python-lecture) (wykłady 1-7), [dra Wojciecha Czarneckiego](https://github.com/gmum/python-lecture) (wykłady 8-11, laboratoria 1-11) oraz [Mateusza Fliegera i Jacka Rzeszutka](https://github.com/Nozdi/first-steps-with-pandas-workshop) (wykład i laboratorium 12).\n",
    "\n",
    "W przypadku zauważenia błędów w materiałach, proszę o ich zgłaszanie przez githuba (fork + pull request)\n",
    "\n",
    "Kurs dostosowany jest do pythona w wersji co najmniej 3.3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Przedsmak Pythona"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fun(list):\n",
    "    if not list:\n",
    "        return []\n",
    "    else:\n",
    "        tmp = list[0]\n",
    "        less = [x for x in list     if x <  tmp]\n",
    "        more = [x for x in list[1:] if x >= tmp]\n",
    "        return fun(less) + [tmp] + fun(more)\n",
    "    \n",
    "fun([3,2,1,4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Co takiego robi powyższy kod?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python jest językiem..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Wysokopoziomowym (programowanie funkcjonalne!)\n",
    "* Skryptowym (ale ma bytecode jak Java)\n",
    "    * Bo można w nim pisać skrypty...\n",
    "    * ... ale i duże aplikacje\n",
    "* Ogólnego zastosowania (!), o wysokiej czytelności składni\n",
    "* Dynamicznie typowanym\n",
    "    * ... gdzie używa się wcięć zamiast bloków"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Zalety:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " * Szybsze pisanie kodu - zwykle około 2-10 razy krótszy kod (w porównaniu do C, C++, Java wg Guido)  \n",
    " * Łatwiejsze utrzymanie kodu - nacisk na czytelność\n",
    " * Duża szybkość uczenia się\n",
    " * Język o dużej ekspresji - idealny do prototypowania\n",
    " * Community, community, community\n",
    " * Batteries included - ogromna liczba bibliotek\n",
    " * Dojrzałe frameworki webowe (jak Django)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Wady:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Nie jest tak szybki jak C/C++\n",
    "\n",
    "* Dynamiczna typizacja może być niebezpieczna\n",
    "\n",
    "* Global Interpreter Lock"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import antigravity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Przyczyny powstania - historia języka i jego twórca"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* BDFL - **Guido van Rossum**\n",
    "    * Benevolent Dictator For Life\n",
    "* Centrum Wiskunde & Informatica – Amsterdam Hollandia\n",
    "\n",
    "![caption](W01_files/guido1.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Pierwsza implementacja - XII 1989\n",
    "\n",
    "> \"Over six years ago, in December 1989, I was looking for a \"hobby\" programming project that would keep me occupied during the week around Christmas. My office (a government-run research lab in Amsterdam) would be closed, but I had a home computer, and not much else on my hands. I decided to write an interpreter for the new scripting language I had been thinking about lately: a descendant of ABC that would appeal to Unix/C hackers. I chose Python as a working title for the project, being in a slightly irreverent mood (and a big fan of Monty Python's Flying Circus).\" Guido van Rossum\n",
    "\n",
    "Źródło: https://www.python.org/doc/essays/foreword/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Język ABC\n",
    "\n",
    "```\n",
    "HOW TO RETURN words document:\n",
    "   PUT {} IN collection\n",
    "   FOR line IN document:\n",
    "      FOR word IN split line:\n",
    "         IF word not.in collection:\n",
    "            INSERT word IN collection\n",
    "   RETURN collection\n",
    "```\n",
    "źródło: https://en.wikipedia.org/wiki/ABC_(programming_language)\n",
    "\n",
    "* Dla porównania: bardzo niezawodny zawodny system, napisany w bardzo nieczytelnym języku przez Margaret Hamilton:\n",
    "https://github.com/rburkey2005/virtualagc  http://www.ibiblio.org/apollo/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Interpreter napisany w języku C, najstarszy (14.10.1990) kod interpretera dostępny tutaj:\n",
    "https://github.com/python/cpython/tree/daadddf7ae82f9e352e660d14a8a27285d992b2f\n",
    "\n",
    "* Wersja 0.9.0 - II 1991\n",
    "* Wersja 1.0 – I 1994\n",
    "* Wersja 2.0 – 16 X 2000\n",
    "    * Zbieranie nieużytków (Garbage collector)\n",
    "    * Zwykłe ciągi znaków oraz Unicode\n",
    "    * 2.2 wszystko stało się obiektem, generatory\n",
    "* Wersja 3.0 – 3 XII 2008\n",
    "    * *print* jest funkcją a nie slowem kluczowym\n",
    "    * tylko Unicode\n",
    "    * nowy operator dzielenia /\n",
    "    * nowa składnia raise/except"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python ZEN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PEP - Python Enhancement Proposal - system dokumentów (podobna idea jak w RFC), zawierający pomysły na rozwój środowiska Python\n",
    "\n",
    "\n",
    "PEP 20 - http://www.python.org/dev/peps/pep-0020/\n",
    "\n",
    "***Long time Pythoneer Tim Peters succinctly channels the BDFL's guiding principles for Python's design into 20 aphorisms, only 19 of which have been written down.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interpreter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* podręczny kalkulator\n",
    "* piaskownica do testowania fragmentów kodu\n",
    "* tokeny, AST (prawie jak kompilator), bytecode, wykonanie w maszynie wirtualnej"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pętla WHILE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "number = 23\n",
    "running = True\n",
    "\n",
    "while running:\n",
    "    guess = int(input('Enter an integer : '))\n",
    "\n",
    "    if guess == number:\n",
    "        print('Congratulations, you guessed it.')\n",
    "        running = False # this causes the while loop to stop\n",
    "        #break # - but we can't use break here -> no else then \n",
    "    elif guess < number:\n",
    "        print('No, it is a little higher than that.')\n",
    "    else:\n",
    "        print('No, it is a little lower than that.')\n",
    "else:\n",
    "    print('The while loop is over.')\n",
    "# Do anything else you want to do here\n",
    "\n",
    "print('Done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pętla FOR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Typowa pętla po liczbach:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(1, 5):\n",
    "    print(i)\n",
    "else:\n",
    "    print('The for loop is over')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W praktyce najczęściej iterujemy po elementach:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for e in ['apple', 'orange', 'peach']:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W takiej pętli nie mamy dostępu do indeksu elementu w liście, ale możemy taki uzyskać, odpowiednio mapując kolekcję za pomocą enumerate (generator):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "list(enumerate(['apple', 'orange', 'peach']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i, e in enumerate(['apple', 'orange', 'peach']):\n",
    "    print(i, e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**W for może wystąpić dowolny typ sekwencyjny:**\n",
    "\n",
    "* `str`, `list`, `tuple`, `range`, `bytes`, `bytearray`\n",
    "*  krotka tworzona operatorem `,`: `1,2,3` albo  `(3,)` albo `()`\n",
    "* `'ala'`, `”makota”` \n",
    "* Operacje na sekwencjach:\n",
    "    * Operacje: \n",
    "        * `x in s`,  `x not in s` \n",
    "        * `s + t`\n",
    "        * `s * n`\n",
    "        * `s[i]`, `s[i:j]`, `s[i:j:k]`\n",
    "    * Operacje: \n",
    "        * `len(s)`\n",
    "        * `min(s)`, `max(s)`\n",
    "        * `s.index(x[, i[, j]])`\n",
    "        * `s.count(x)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Typy sekwencyjne\n",
    "źródło: https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listy - list (mutable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "l = list()\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l = [137]\n",
    "print(l)\n",
    "print(l[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "l = [\"h\",137,[1,2,3]]\n",
    "print(l)\n",
    "print(l[2])\n",
    "print(l[2][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ll = [[]] * 3\n",
    "print(ll)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ll[0].append(3)\n",
    "print(ll)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ll = [[], [], []]\n",
    "ll[0].append(3)\n",
    "ll[1].append(5)\n",
    "ll[2].append(7)\n",
    "print(ll)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Krotka - tuple (immutable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "t = tuple() \n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "t = (137)\n",
    "print(t)\n",
    "print(t[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`(137)` nie jest jednoelementową krotką. Jak ją stworzyć?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "t = (\"h\",137,(1,2,3))\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tuples = (1,)\n",
    "print(tuples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "two_tuples = tuples + (\"dwa\",)\n",
    "print(two_tuples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(two_tuples[0])\n",
    "print(two_tuples[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "two_tuples[1] = \"trzy\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pakowanie i rozpakowywanie krotek:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "j, d = two_tuples\n",
    "print(\"j =\", j)\n",
    "print(\"d =\", d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ponieważ mamy krotki, w języku Python zamianę zmiennych wykonujemy z użyciem idiomu:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "d, j = j, d\n",
    "print(\"j =\", j)\n",
    "print(\"d =\", d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W innych językach musielibyśmy napisać:\n",
    "    \n",
    "    temp = j\n",
    "    j = d\n",
    "    d = temp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Szatkowanie (\"slicing\") na typach sekwencyjnych"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "     +---+---+---+---+---+\n",
    "     | H | e | l | l | o |\n",
    "     +---+---+---+---+---+\n",
    "     0   1   2   3   4   5\n",
    "    -5  -4  -3  -2  -1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "word = \"Hello\"\n",
    "word[0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "word[2:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "word[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "word[2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "word[-2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "word[:-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "word[1:5:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Typ słownikowy  - dict (mutable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print({'yellow': 2, 'blue': 3})\n",
    "print(dict(yellow=2, blue=3))\n",
    "print(dict({'yellow': 2, 'blue': 3}))\n",
    "print(dict(zip(('yellow', 'blue'), (2, 3))))\n",
    "print(dict([['blue', 3], ['yellow', 2]]))\n",
    "print(dict((('blue', 3), ('yellow', 2))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for item in zip(('yellow', 'blue'), (2, 3)):\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "m = {'yellow': 2, 'blue': 3}\n",
    "m.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "m.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(m['yellow'])\n",
    "print(m.get('yellow', 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(m['black'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(m.get('black', 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "'yellow' in m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "len(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "m['orange'] = 5\n",
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Klucz typu słownikowego"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kluczem (w skrócie) może być wszystko, co ma swoją reprezentację jako hash, a dokładniej:\n",
    "\n",
    "> An object is hashable if it has a hash value which never changes during its lifetime (it needs a __hash__() method), and can be compared to other objects (it needs an __eq__() or __cmp__() method). Hashable objects which compare equal must have the same hash value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "coordinate_xy = (2, 3)\n",
    "board_map= {}\n",
    "board_map[coordinate_xy] = True\n",
    "board_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "coordinate_xy = [2, 3]\n",
    "board_map= {}\n",
    "board_map[coordinate_xy] = True\n",
    "board_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "all_board_maps = {}\n",
    "all_board_maps[board_map] = True\n",
    "all_board_maps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zbiory set (mutable), frozenset (immutable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(set([1,2,3,5,4,3,1]))\n",
    "print({1,2,3,5,4,3,1})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s = set([1,2,3,5,4,3,1])\n",
    "2 in s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "list(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funkcje"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def say(message, times=1):\n",
    "    print((message + ' ') * times)\n",
    "    \n",
    "say('developers')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "say('developers', 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "say('developers', times=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "say(times=3, 'developers')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "say(times=3, message='developers')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Argumenty \\*args, \\**kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def say_more(times, *args):\n",
    "    print((', '.join(args) + ' | ') * times)\n",
    "say_more(3, 'one', 'two')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def say_even_more(*args, **kwargs):\n",
    "    print(args) #lista\n",
    "    print(kwargs) #mapa\n",
    " \n",
    "say_even_more(1, 2, 3, foo=4, bar=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Zmienne globalne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def func():\n",
    "    global x\n",
    "    print('x is', x)\n",
    "    x = 2\n",
    "    print('Changed global x to', x)\n",
    "x = 50\n",
    "func()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CBO - Call by object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "my_list = [1, 2, 3]\n",
    "def add_something(variable, value):\n",
    "    variable += value\n",
    "    print(\"Inside add_something\", variable)\n",
    "\n",
    "print(my_list)\n",
    "add_something(my_list, [4])\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "my_int = 3\n",
    "print(my_int)\n",
    "add_something(my_int, 4)\n",
    "print(my_int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![caption](W01_files/img040.gif) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a_list = []\n",
    "b_list = a_list\n",
    "a_list.extend([1, 2, 3])  \n",
    "print(a_list, id(a_list))\n",
    "print(b_list, id(b_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a_list = []\n",
    "b_list = a_list[:]\n",
    "a_list.extend([1, 2, 3])  \n",
    "print(a_list, id(a_list))\n",
    "print(b_list, id(b_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from copy import copy\n",
    "a_list = []\n",
    "b_list = copy(a_list)\n",
    "a_list.extend([1, 2, 3])  \n",
    "print(a_list, id(a_list))\n",
    "print(b_list, id(b_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![caption](W01_files/img041.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dynamiczna typizacja zmiennych"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Python, Groovy, JavaScript, Ruby są **dynamicznie typowalne (dynamic typing)**\n",
    "    * Typ związany z wartością – nie zmienną\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 5\n",
    "print(x, type(x), repr(x))\n",
    "x = \"5\"\n",
    "print(x, type(x), repr(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* C/C++, Java są **statycznie typowalne (static typing)**\n",
    "     * Typ związany ze zmienną – nie wartością, czasem niejawnie:\n",
    "            \n",
    "```\n",
    "int main() {\n",
    "          int x = 5;\n",
    "          float y = 1.2;\n",
    "          auto z = x*y;\n",
    "          return 0;\n",
    "      }\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Python jest **silnie typowalny (strongly typed)**\n",
    "    * Kontrola, czy operacje są wykonalne na danym typie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = \"a\"\n",
    "a = a + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "* JavaScript jest **słabo typowalny (weakly typed)**\n",
    "    * Rzutowania wykonywane są w locie\n",
    "\n",
    "* Python ma **bezpieczną typizację (type-safe)**\n",
    "* C **nie ma bezpiecznej typizacji (type-unsafe)**\n",
    "    * rzutowanie z/na void*            \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Duck Typing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Duck:\n",
    "    def quack(self): \n",
    "        print(\"Quaaaaaack!\")\n",
    "    def feathers(self): \n",
    "        print(\"The duck has white and gray feathers.\")\n",
    " \n",
    "class Person:\n",
    "    def quack(self):\n",
    "        print(\"The person imitates a duck.\")\n",
    "    def feathers(self): \n",
    "        print(\"The person takes a feather and shows it.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def in_the_forest(duck):\n",
    "    duck.quack()\n",
    "    duck.feathers()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def game():\n",
    "    donald = Duck()\n",
    "    john = Person()\n",
    "    in_the_forest(donald)\n",
    "    in_the_forest(john)\n",
    "\n",
    "game()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Moduły i pakiety"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Wyrażenie import"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Zmienna __name__ zawiera nazwę bieżącego pakietu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    #!/usr/bin/python\n",
    "    # Filename: using_name.py\n",
    "    \n",
    "    if __name__ == '__main__':\n",
    "        print('This program is being run by itself')\n",
    "    else:\n",
    "        print('I am being imported from another module')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Przykładowe uruchomienia:\n",
    "    \n",
    "    $ python using_name.py\n",
    "    This program is being run by itself\n",
    "    \n",
    "    $ python\n",
    "    >>> import using_name\n",
    "    I am being imported from another module\n",
    "    >>>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    sound/                   Top-level package\n",
    "      __init__.py            Initialize the sound package\n",
    "      formats/               Subpackage for format conversions\n",
    "          __init__.py\n",
    "          wavread.py\n",
    "          wavwrite.py\n",
    "          aiffread.py\n",
    "          aiffwrite.py\n",
    "          auread.py\n",
    "          auwrite.py\n",
    "\n",
    "    >>> from sound.formats import wavwrite"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **import**\n",
    "    * dołącza plik z $PYTHONPATH: .:/usr/local/lib/python\n",
    "    \n",
    "* **import test**\n",
    "    * Do x w test odwołujemy się przez \"test.x\"\n",
    "    \n",
    "* **from test import x**\n",
    "    * Do x w test odwołujemy się przez \"x\"\n",
    "    \n",
    "* ** import test.x.y ** \n",
    "    * Do y odwołujemy się przez \"test.x.y\"    \n",
    "    \n",
    "* **from test import * **\n",
    "    * Wczytuje wszystko z test. Do x w test odwołujemy się przez \"x\" (nie zalecane)\n",
    "    \n",
    "* ** import test as theTest** \n",
    "    * Do x w test odwołujemy się przez \"theTest.x\"\n",
    "\n",
    "    \n",
    "   \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Kolekcja modułów (pakiet) znajduje się w katalogu\n",
    "* Katalog z modułem musi zawierać plik \\__init\\__.py\n",
    "* Moduł może zawierać podmoduły\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### dir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "dir(sys) # get list of attributes for sys module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sx pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sx ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sx mkdir -p agh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%cd agh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sx pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%writefile __init__.py\n",
    "pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%writefile student.py\n",
    "\n",
    "def _opinion():\n",
    "    return \" rocks!\"\n",
    "\n",
    "def scream():\n",
    "    print(\"AGH\" + _opinion())\n",
    "    \n",
    "print(\"Name:\", __name__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%cd .."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from agh import student\n",
    "student.scream()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from agh.student import scream\n",
    "scream()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from agh import student.scream"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import agh.student\n",
    "agh.student.scream()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%run agh/student.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "student.scream()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "student._opinion()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%reset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Alternatywne implementacje Pythona"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* CPython - standardowa implementacja jest często w kontekście innych alternatywnych nazywana CPython\n",
    "\n",
    "* RPython - Restricted Python, statycznie typowany podzbiór języka Python, JIT \n",
    "\n",
    "* PyPy - interpreter Pythona napisany w ... Pythonie (dokładnie w RPythonie), it's all about speed, JIT\n",
    "\n",
    "* Jython – interpreter napisany na JVM\n",
    "\n",
    "* Stackless Python - nie używa C call stack, skierowany na wielowątkowość (microthreads)\n",
    "\n",
    "* Unladen Swallow - sponsorowany przez Googla zawieszony po 2009 roku projekt, który miał dostarczyć super wydajną wersję CPythona. Nie wyszło.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}