L2.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "J\u0119zyk Python - Wyk\u0142ad 2."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "PEP 8 - Zasady formatowania kodu"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* http://www.python.org/dev/peps/pep-0008/\n",
      "* 4 spacje na jedno wci\u0119cie kodu\n",
      "* Nie u\u017cywa\u0107 znak\u00f3w tabulacji (``\\t``)\n",
      "* Nigdy nie miesza\u0107 znak\u00f3w tabulacji ze spacjami do robienia wci\u0119\u0107 jednym kodzie\n",
      "* Jedna pusta linia pomi\u0119dzy kodem funkcji i metod\n",
      "* Dwie puste linie pomi\u0119dzy kodem klas\n",
      "* Znak spacji po znaku ``,`` w s\u0142ownikach, zbiorach, listach, tuplach, argumentach oraz po znaku ``:`` w s\u0142ownikach (nie przed!)\n",
      "\n",
      "    Dobrze:\n",
      "        [1, 2, 3, 4]\n",
      "        {'black': 5, 'orange': 10}\n",
      "        f(1, 4)\n",
      "    \n",
      "    \u0179le:\n",
      "        [1,2,3,4]\n",
      "        [ 1,2,3,4 ]\n",
      "        { 'black' : 5, 'orange' : 10 }\n",
      "        f(1,4)\n",
      "        f( 1 , 4 )\n",
      "    \n",
      "* Znaki spacji przed i po wyra\u017ceniach przypisania i por\u00f3wnania (z wyj\u0105tkiem listy argument\u00f3w)\n",
      "\n",
      "    Dobrze:\n",
      "        a = 5\n",
      "        b = [1, 2, 3, 4]\n",
      "        f(a=5, b=10)\n",
      "    \n",
      "    \u0179le:\n",
      "        a=5\n",
      "        a= 5\n",
      "        a =5\n",
      "        f(a = 5, b = 10)\n",
      "        f(a= 5, b= 10)\n",
      "\n",
      "* Bez spacji na brzegach nawiasowania i listy argument\u00f3w\n",
      "\n",
      "    Dobrze:\n",
      "        (a + 3) * (5 - b)\n",
      "        \n",
      "    \u0179le:\n",
      "        (a+3)*(5-b)\n",
      "        ( a + 3 ) * ( 5 - b )\n",
      "        \n",
      "\n",
      "* Bez spacji na brzegach docstring\u00f3w jednoliniowych (wi\u0119cej o zasadach pisania docstring\u00f3w w PEP 257 http://www.python.org/dev/peps/pep-0257/)\n",
      "\n",
      "    Dobrze:\n",
      "        def make_squares(key, value=0):\n",
      "            \"\"\"Return a dictionary and a list...\"\"\"\n",
      "            d = {key: value}\n",
      "            l = [key, value]\n",
      "            return d, l\n",
      "    \u0179le:\n",
      "        def make_squares(key, value=0):\n",
      "            \"\"\"\n",
      "                Return a dictionary and a list...\n",
      "            \"\"\"\n",
      "            d = {key: value}\n",
      "            l = [key, value]\n",
      "            return d, l\n",
      "            "
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Listy - zaawansowane u\u017cycie"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Przed\u0142u\u017canie listy"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "extend_list = [1, 2, 3]\n",
      "extend_list.extend([4, 5, 6])\n",
      "extend_list"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Usuwanie z listy"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "del extend_list[2]\n",
      "extend_list"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "del extend_list[1:3]\n",
      "extend_list"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "del extend_list\n",
      "print extend_list"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Lista jako stos"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "stack = [3, 4, 5, 6, 7]\n",
      "stack.pop()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "stack.pop()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "stack"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "stack.append(10)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "stack"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Lista jako kolejka"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "List\u0119\u00a0mo\u017cna u\u017cywa\u0107 jak kolejk\u0119, ale operacje na pocz\u0105tku listy s\u0105 nieefektywne:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "queue = [3, 4, 5, 6, 7]\n",
      "queue.pop(0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "queue.append(10)\n",
      "queue"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Zamiast tego lepiej u\u017cy\u0107 specjalnie do tego przeznaczon\u0105\u00a0strukture deque z modu\u0142u standardowego collections:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from collections import deque\n",
      "queue = deque([\"Eric\", \"John\", \"Michael\"])\n",
      "queue.append(\"Terry\")           # Terry arrives\n",
      "queue.append(\"Graham\")          # Graham arrives\n",
      "queue.popleft()                 # The first to arrive now leaves"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "queue.popleft()                 # The second to arrive now leaves"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "queue                           # Remaining queue in order of arrival"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "List comprehension"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Rozwijanie listy jest idiomem zast\u0119pujacym wyra\u017cenia p\u0119tli for buduj\u0105cej list\u0119:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "squares = []\n",
      "for x in range(10):\n",
      "    squares.append(x**2)\n",
      "\n",
      "squares"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "To samo mo\u017cna zapisa\u0107 pro\u015bciej:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "[x**2 for x in range(10)]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Mo\u017cna te\u017c tworzy\u0107 p\u0119tle zagnie\u017cdzone i u\u017cywa\u0107\u00a0konstrukcji warunkowych:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "[(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Sortowanie"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Sortowanie przez tworzenie nowej listy:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sorted([5, 2, 3, 1, 4])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Sortowanie w miejscu:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = [5, 2, 3, 1, 4]\n",
      "a.sort(reverse=True)\n",
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Sortowaniem z u\u017cyciem klucza:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "fruits = [('apple', 3), ('orange', 1), ('banana', 2)]\n",
      "sorted(fruits, key=lambda fruit: fruit[0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sorted(fruits, key=lambda fruit: fruit[1])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Kluczem mo\u017ce by\u0107 nawet callable, kt\u00f3ry go wygeneruje:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "chars = ['Z', 'z', 'C', 'c', 'A', 'a']\n",
      "sorted(chars)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sorted(chars, key=str.lower)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Python implementuje stabilne sortowanie:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from operator import itemgetter\n",
      "sorted([('red', 1), ('blue', 1), ('red', 2), ('blue', 2)], key=itemgetter(1))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Lambda wyra\u017cenia"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Funkcja nienazwana utworzona w miejscu (anonimowa)\n",
      "* Mo\u017cna j\u0105 przypisa\u0107 do zmiennej \n",
      "* Najcz\u0119\u015bciej u\u017cywamy jej przy programowaniu funkcyjnym (wstrzykujemy logik\u0119 kodu do do funkcji jako argument, np. patrz sortowanie)\n",
      "* Cia\u0142o funkcji lambda sk\u0142ada si\u0119\u00a0z pojedynczego wyra\u017cenia, kt\u00f3rego ewaluacja zwracana jest jako wynik funkcji"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "lambda x: x + 1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "operator_dodaj = lambda x, y: x + y\n",
      "operator_dodaj(1, 2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Programowanie funkcyjne"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* filter - filtrowanie kolekcji\n",
      "* map - zmiana formatu kolekcji\n",
      "* reduce - redukowanie kolekcji (wyliczanie warto\u015bci z jej element\u00f3w)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Policzy\u0107, ile owoc\u00f3w wsp\u00f3lnie ma Merry i Tom:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "fruits = {\n",
      "    'Merry': [\n",
      "        ('apple', 5),\n",
      "        ('orange', 3),\n",
      "    ],\n",
      "    'John': [\n",
      "        ('berries', 1),\n",
      "        ('orange', 10),\n",
      "    ],\n",
      "    'Tom' : [\n",
      "        ('peaches', 2),\n",
      "    ],\n",
      "}\n",
      "fruits.items()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Filtrujemy \"baz\u0119\" z owoc\u00f3w Johna:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Usuwamy imiona, nie s\u0105 nam ju\u017c\u00a0potrzebne:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "map(lambda y: y[1], \n",
      "        filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n",
      ")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Sklejamy list\u0119 list w jedn\u0105 list\u0119:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from itertools import chain\n",
      "list(chain(\n",
      "    *map(lambda y: y[1], \n",
      "        filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n",
      "    )\n",
      "))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Mapujemy list\u0119 tupli na list\u0119 liczb"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "map(lambda f: f[1], \n",
      "    chain(\n",
      "        *map(lambda y: y[1], \n",
      "            filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n",
      "        )\n",
      "    )\n",
      ")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Finalnie redukujemy list\u0119 do sumy element\u00f3w:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "reduce(lambda a, b: a + b, \n",
      "    map(lambda f: f[1], \n",
      "        chain(\n",
      "            *map(lambda y: y[1], \n",
      "                filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n",
      "            )\n",
      "        )\n",
      "    )\n",
      ")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Mo\u017cemy tak\u017ce u\u017cy\u0107 gotowego operatora dodawania z modu\u0142u operator:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import operator\n",
      "reduce(operator.add, \n",
      "    map(lambda f: f[1], \n",
      "        chain(\n",
      "            *map(lambda y: y[1], \n",
      "                filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n",
      "            )\n",
      "        )\n",
      "    )\n",
      ")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "S\u0142owniki (dict) - zaawansowane u\u017cycie"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Aktualizacja s\u0142ownika innym s\u0142ownikiem:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def some_function(**kwargs):\n",
      "    defaults = {\n",
      "        'apple': 1,\n",
      "        'orange': 2,\n",
      "        'peach': 3,\n",
      "    }\n",
      "    defaults.update(kwargs)\n",
      "    print defaults\n",
      "    print defaults.has_key('banana')\n",
      "\n",
      "some_function()\n",
      "some_function(apple=10)\n",
      "some_function(banana=4)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Napisy w Pythonie - unicode i str"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* W Pythonie 2.x wyr\u00f3\u017cniono (niestety) dwa typy do przechowywania danych tekstowych:\n",
      "    * str - napisy wyra\u017cone w konkretnym kodowaniu (kodowanie determinuje konkretne ci\u0105gi bajt\u00f3w),\n",
      "    * unicode - napisy z dowolnych znak\u00f3w z uniwersum znak\u00f3w Unicode.\n",
      "* Nale\u017cy wiedzie\u0107, \u017ce Unicode nie jest sam w sobie kodowaniem. Jest to pewna systematyka katalogowania wszystkich znanych znak\u00f3w (i jest bardzo skomplikowana)\n",
      "* Kodowania (jak np. UTF-8, UF-16, Latin2, ISO-8859-2) s\u0105 to konkretne mapowania pewnej grupy znak\u00f3w na warto\u015bci (sta\u0142o lub zmienno) bajtowe.\n",
      "* Nie wszystkie znaki z Unicode musz\u0105 by\u0107 reprezentowalne w danym kodowaniu. Np. \u017caden znak chi\u0144ski nie jest reprezentowany w ISO-88592-2\n",
      "* Nale\u017cy wi\u0119c traktowa\u0107, \u017ce ka\u017cdy napis str jest tylko ci\u0105giem bajt\u00f3w - wolno nam u\u017cywa\u0107 tego typu przy konwersjach na styku interfejs\u00f3w (np. czytanie z pliku, z API) i zawsze musimy zna\u0107 w jakim kodowaniu jest ten ci\u0105g bajt\u00f3w (inaczej nie mo\u017cemy go u\u017cy\u0107).\n",
      "* Nie przetwarzamy napis\u00f3w typu str bo b\u0119dzie powodwa\u0107 problemy. Zawsze dekodujemy go do python unicode w celu przetwarzania, a nast\u0119pnie kodujemy go do wymaganego kodowania.\n",
      "* W Pythonie 3.x ten problem zosta\u0142 rozwi\u0105zany, ka\u017cdy napis nie b\u0119d\u0105cy python unicde jest po prostu explicite ci\u0105giem bajt\u00f3w."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "plain_string = 'zwyk\u0142y'\n",
      "type(plain_string)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "unicode_string = u'zwyk\u0142y'\n",
      "type(unicode_string)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "plain_string == unicode_string"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "plain_string.decode('utf-8')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "plain_string.decode('utf-8') == unicode_string"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print unicode_string.encode('iso-8859-2')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "china = u'simplified Chinese: \u6c49\u8bed'\n",
      "print china.encode('utf-8')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print china.encode('iso-8859-2')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print china.encode('iso-8859-2',  errors='replace')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print china.encode('iso-8859-2',  errors='ignore')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ord(u'\u6c49')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print unichr(27721)\n",
      "unichr(27721)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Je\u015bli u\u017cywamy napis\u00f3w jako sta\u0142ych i tylko z ANSI 7-bit wtedy nie ma problemu w kodzie u\u017cywa\u0107 typu str (np. jako klucze do s\u0142ownik\u00f3w, kod jest wtedy czytelniejszy):"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "'key' == u'key'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "{'key': 2}['key']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "{'key': 2}[u'key']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Uwaga:** U\u017cywanie w kodzie (pliku tekstowym) znak\u00f3w spoza ANSI 7-bit wymaga okre\u015blenia w jakim kodowaniu zosta\u0142 opracowany ten plik tekstowy. Stosuje si\u0119 do tego specjalny znacznik w komentarzu na samym pocz\u0105tku pliku:\n",
      "\n",
      "    # -*- coding: utf-8 -*-\n",
      "    "
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Formatowanie string\u00f3w"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Proste formatowanie z u\u017cyciem typ\u00f3w:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "'Hi %s, you have %d apples' % ('Marry', 5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Formatowanie z u\u017cyciem namespace:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "'Hi %(name)s, you have %(fruit_count)d apples' % {'name': 'Marry', 'fruit_count': 5}"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "name = 'Marry'\n",
      "fruit_count = 5\n",
      "'Hi %(name)s, you have %(fruit_count)d apples' % locals()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "locals()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Metoda ``format()`` napisu:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "'Hi {0}, you have {1} apples'.format('Marry', 5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "'Hi {name}, you have {fruit_count} apples'.format(name='Marry', fruit_count=5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Generatory i iteratory"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Generator\u00f3w i iterator\u00f3w u\u017cywamy, aby oszcz\u0119dzi\u0107 pami\u0119ci (a tak\u017ce czasu potrzebnego na jej alokacj\u0119). \n",
      "* Zysk wydajno\u015bci powstaje przez omini\u0119cie potrzeby tworzenia tymczasowych struktur po\u015brednich w pami\u0119ci, gdy zamiast tego mo\u017cemy przeiterowa\u0107 kolejno po elementach i finalnie zapisa\u0107 tylko te kt\u00f3re s\u0105 potrzebne.\n",
      "* Iteratorem jest dowolny obiekt (kolekcja) dostarczaj\u0105cy nast\u0119puj\u0105cego interfejsu:\n",
      "    * ``__iter__()`` - zwraca obiekt iteratora (je\u015bli wywo\u0142ane na kolekcji)\n",
      "    * ``next()`` - zwraca kolejny element iteratora lub rzuca wyj\u0105tek StopIteration \n",
      "* Interfejsu iteratorow nie u\u017cywamy najcz\u0119\u015bciej sami w kodzie, obiekty iterator\u00f3w pojawiaj\u0105 si\u0119 w kontekstach iteracji i s\u0105 automatycznie u\u017cywane\n",
      "* Generatorem jest funkcja kt\u00f3ra zwraca iterator. Ka\u017cda funkcja posiadaj\u0105ca wyra\u017cenie yield jest generatorem"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "range(10)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "filter(lambda x: x % 4 == 0, range(10))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "map(lambda y: y*y, filter(lambda x: x % 4 == 0, range(10)))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Teraz to samo na iteratorach:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "xrange(10)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def range_10():\n",
      "    i = 0\n",
      "    while i < 10:\n",
      "        yield i\n",
      "        i += 1\n",
      "        \n",
      "range_10()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "list(range_10())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from itertools import imap, ifilter\n",
      "imap(lambda y: y*y, ifilter(lambda x: x % 4 == 0, xrange(10)))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "list(imap(lambda y: y*y, ifilter(lambda x: x % 4 == 0, xrange(10))))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Generator expression"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Generator mo\u017cna tak\u017ce wyrazi\u0107 za pomoc\u0105\u00a0konstrukcji `` wyra\u017cenie for zmienne in sekwencja``:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sum(i*i for i in range(10))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "List comprehension (jeszcze raz)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Technicznie wi\u0119c ujmuj\u0105c **list comprehension = lista + wyra\u017cenie generatora**:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "[i*i for i in range(10)]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Modu\u0142 itertools"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Szczeg\u00f3lnie warty uwagi jest modu\u0142 itertools, kt\u00f3ry dostarcza bardzo wiele ciekawych narz\u0119dzi pracuj\u0105cych na iteratorach pomocnych do zaawansowanego programowania funkcyjnego. Wybrane ciekawe funkcje:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from itertools import * # normalnie tak nie importujemy \n",
      "list(chain([1, 2, 3], [4, 5, 6]))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "list(combinations('ABCD', 2))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "list(permutations('ABCD', 2))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "list(combinations_with_replacement('ABCD', 2))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "list(groupby('AAAABBBCCDAABBB'))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for g in groupby('AAAABBBCCDAABBB'):\n",
      "    print g[0], list(g[1])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "list(islice(cycle('ABCD'), 0, 10))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "list(izip([1, 2, 3], 'ABC'))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "list(product('ABC', 'XY'))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "iterator = permutations('ABC', 2)\n",
      "print iterator\n",
      "print list(iterator)\n",
      "print list(iterator)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "iterator = permutations('ABC', 2)\n",
      "iterator1, iterator2 = tee(iterator, 2)\n",
      "print iterator1, iterator2\n",
      "print list(iterator1)\n",
      "print list(iterator2)\n",
      "print list(iterator)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}