Python2016_Wyklad-07.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Język Python - Wykład 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python3: \"A general goal is to reduce feature duplication by removing old ways of doing things\" (PEP 3100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Różnice Python 2.x i 3.x\n",
    "  - https://docs.python.org/3/whatsnew/3.0.html\n",
    "  - https://wiki.python.org/moin/Python2orPython3\n",
    "  - http://python-notes.curiousefficiency.org/en/latest/python3/questions_and_answers.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - UTF i kodowanie\n",
    " - dzielenie\n",
    " - print vs print()\n",
    " - zip vs zip_longest\n",
    " - metaklasy\n",
    " - nowe i stare klasy\n",
    " - slowa kluczowe, True i False\n",
    " - biblioteki"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ciąg znaków - przypomnienie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s = \"ala ma kota\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "s[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "s[0] = 'b'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kodowanie znaków\n",
    "Unicode - konsorcjum/standard. Kodowania:\n",
    "  - UTF-8\n",
    "  - UTF-16 / USC-2\n",
    "  - UTF-32 / USC-4\n",
    "  \n",
    "Inne popularne kodowania:\n",
    "  - ASCII\n",
    "  - ISO 8859-2 (latin2)\n",
    "  - Windows 1250"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ASCII\n",
    "  - kod 7-bitowy (1968, USA)\n",
    "  - znaki sterujące: 0-31 i 127\n",
    "  - znaki drukowalne: 32-126\n",
    "  - https://pl.wikipedia.org/wiki/ASCII"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\" \".join(chr(i) for i in range(32,127))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(\"a\\nb\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(\"a\\r\\nb\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(\"a\\r\\rb\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## klasa *bytes* \n",
    "ciągi 8-bitowych liczb z zakresu 0 <= x < 255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "bytes(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "help(bytes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "bytes([10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "bytes([65])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "tmp = bytes([1,2,3,4])\n",
    "s = \"1234\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "type(tmp),type(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "tmp[1],type(tmp[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "s[1],type(s[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "tmp[1:],type(tmp[1:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "list(tmp)[1],type(list(tmp)[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Windows 1250\n",
    "  - Microsoft\n",
    "  - 8-bit\n",
    "  - alfabety w środkowej i centralnej Europie (polski, czeski itp)\n",
    "  - kompatybilny z ASCII"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b1 = \"agh\".encode(\"cp1250\")\n",
    "b1, list(b1),len(b1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b2 = \"ąę\".encode(\"cp1250\")\n",
    "b2, list(b2),len(b2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b'\\xbf'.decode('cp1250')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ISO 8859-2 / ISO Latin2\n",
    "  - standard ISO\n",
    "  - 8-bit\n",
    "  - alfabety w środkowej i centralnej Europie (polski, czeski itp)\n",
    "  - kompatybilny z ASCII"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b1 = \"agh\".encode(\"iso8859-2\")\n",
    "b1, list(b1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b2 = \"ąę\".encode(\"iso8859-2\")\n",
    "b2, list(b2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "iso8859_codes = [bytes([x]).decode(\"iso8859-2\", errors='replace') for x in range(255)] \n",
    "cp1250_codes = [bytes([x]).decode(\"cp1250\", errors='replace') for x in range(255)] \n",
    "[ (i,it) for i,it in enumerate(zip(iso8859_codes,cp1250_codes)) if it[0] != it[1]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## UTF-8\n",
    "  - standard UNICODE\n",
    "  - zmiennej długości (1-4 bajtów)\n",
    "  - kompatybilny z ASCII\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b1 = \"agh\".encode(\"utf-8\")\n",
    "b1, list(b1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b2 = \"ąę\".encode(\"utf-8\")\n",
    "b2, list(b2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## UTF-16\n",
    "  - standard UNICODE\n",
    "  - zmiennej długości (2-4 bajtów)\n",
    "  - nie kompatybilny z ASCII"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b1 = \"agh\".encode(\"utf-16\")\n",
    "b1, list(b1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b2 = \"ąę\".encode(\"utf-16\")\n",
    "b2, list(b2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## UTF-32 / USC-4\n",
    "  - stałej długości (4 bajty)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b1 = \"agh\".encode(\"utf-32\")\n",
    "b1, list(b1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b2 = \"ąę\".encode(\"utf-32\")\n",
    "b2, list(b2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hint\n",
    "Software should only work with Unicode strings internally, decoding the input data as soon as possible and encoding the output only at the end.\n",
    " - https://docs.python.org/3/howto/unicode.html\n",
    " - http://farmdev.com/talks/unicode/\n",
    " - http://lucumr.pocoo.org/2014/5/12/everything-about-unicode/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python 3.x\n",
    "  - Unicode domyślnie (w tym ASCII) - str\n",
    "  - osobny typ dla danych binarnych - bytes\n",
    "  - wewnętrzna reprezentacja str:\n",
    "     - do 3.3 - zależnie od kompilacji USC-2 albo USC-4\n",
    "     - od 3.3 - PEP 0393 - 1 (ASCII),2(USC-2) albo 4(USC-4) bajty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "type(\"Python\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "print(sys.getdefaultencoding())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "type(\"ąę\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "répertoire = \"/tmp/records.log\"\n",
    "with open(répertoire, \"w\") as f:\n",
    "    f.write(\"test\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"\\N{GREEK CAPITAL LETTER DELTA}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"\\u0394\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ord('Δ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "chr(916)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "kodowanie pliku:\n",
    "    #!/usr/bin/env python\n",
    "    # -*- coding: latin-1 -*-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "names = ['Leszek', 'Łukasz', 'Maria']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "sorted(names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Collation - definiuje porządek sortowania\n",
    "  - https://en.wikipedia.org/wiki/Collation\n",
    "  - https://en.wikipedia.org/wiki/Unicode_collation_algorithm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python 2.x\n",
    "  - ASCII domyślnie\n",
    "  - dane binarnie domyślnie\n",
    "  - osobny typ dla Unicode (spoza ASCII)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "print type(\"Python\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "import sys\n",
    "print sys.getdefaultencoding()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "print type(u\"aa\\u0107\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "d = u\"au\\u0107\"\n",
    "print type(d),len(d)\n",
    "\n",
    "# encode : unicode -> str\n",
    "\n",
    "e = d.encode(\"utf-8\")\n",
    "print e,type(e),len(e)\n",
    "\n",
    "# decode : str -> unicode\n",
    "\n",
    "dd = e.decode(\"utf-8\")\n",
    "print type(dd),len(dd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "f = open('1.txt','r')\n",
    "tmp = f.read()\n",
    "print tmp\n",
    "print len(tmp),type(tmp)\n",
    "f.close()\n",
    "print tmp[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "import codecs\n",
    "f = codecs.open('1.txt','r',encoding=\"utf-8\")\n",
    "tmp = f.read()\n",
    "print len(tmp),type(tmp)\n",
    "f.close()\n",
    "print tmp[0].encode('utf-8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "f = open('2.txt','w')\n",
    "f.write(u'au\\u0107')\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "names = [u'\\u0141ukasz', u'Maria',u'Leszek']\n",
    "print names\n",
    "print sorted(names)\n",
    "import locale\n",
    "locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')\n",
    "print sorted(names,cmp=locale.strcoll)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Varia\n",
    "http://www.laurentluce.com/posts/python-string-objects-implementation/\n",
    "\"Wow, the sophistication of the implementation contrasted with the simplicity of the API reminds me how much I am standing on the shoulders of giants every time I program in Python.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## print"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arguments (PEP 3105 -- Make print a function):\n",
    "  - print is the only application-level functionality that has a statement (syntax!) dedicated to it. Syntax should cover only necessary items. \n",
    "  - print() can be easily replaced by more sophisticated functions, while print doesn't (>> syntax!)\n",
    "  - in print - not easy to change separator from space to other character"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print('Hello world', 'here I come', sep=\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "print 'Hello world','here I come'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def printnew(*args, **kwargs):\n",
    "    __builtins__.print('Python')\n",
    "    return __builtins__.print(*args, **kwargs)\n",
    "print = printnew\n",
    "print('Hello world')\n",
    "print = __builtins__.print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "def printnew(*args):\n",
    "    print 'Python'\n",
    "    print args\n",
    "print = printnew\n",
    "print 'Hello world'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Chevron print"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chevron (pl. szewron) - naszywka na rękawie lub naramienniku munduru, w kształcie prostej lub odwróconej litery \"V\"\n",
    "https://pl.wikipedia.org/wiki/Szewron_(naszywka) https://en.wikipedia.org/wiki/Chevron_(insignia)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "print('Error!', file=sys.stderr)\n",
    "print('Not an error', file=sys.stdout)\n",
    "print('Error!', file=sys.stderr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "import sys\n",
    "print >> sys.stderr, 'Error!'\n",
    "print >> sys.stdout, 'Not an error'\n",
    "print >> sys.stderr, 'Error!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## map, filter, reduce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Views And Iterators Instead Of Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "isPrime=lambda x: all(x % i != 0 for i in range(int(x**0.5)+1)[2:])\n",
    "import numpy as np\n",
    "print np.array(filter(isPrime,[10,20,30,13,7]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "isPrime=lambda x: all(x % i != 0 for i in range(int(x**0.5)+1)[2:])\n",
    "import numpy as np\n",
    "print(np.array(list(filter(isPrime,[10,20,30,13,7]))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "def p(*args):\n",
    "   print [str(x) for x in args]\n",
    "list(map( p, [1,2,3,4],[100] ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def p(*args):\n",
    "   print([str(x) for x in args])\n",
    "list(map( p, [1,2,3,4],[100] ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "def transposed(matrix):\n",
    "    \"\"\"Return transposed matrix (list of lists).\n",
    "\n",
    "    This function can handle non-square matrices.\n",
    "    In this case it fills shorter list with None.\n",
    "\n",
    "    >>> transposed( [[1,2,3], [3,4]] )\n",
    "    [[1, 3], [2, 4], [3, None]]\n",
    "    \"\"\"\n",
    "    return map(lambda *row: list(row), *matrix)\n",
    "print transposed( [[1,2,3], [3,4]] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from itertools import zip_longest\n",
    "def transposed(matrix):\n",
    "    \"\"\"Return transposed matrix (list of lists).\n",
    "\n",
    "    This function can handle non-square matrices.\n",
    "    In this case it fills shorter list with None.\n",
    "\n",
    "    >>> transposed( [[1,2,3], [3,4]] )\n",
    "    [[1, 3], [2, 4], [3, None]]\n",
    "    \"\"\"\n",
    "    return list(map(list, zip_longest(*matrix)))\n",
    "print(transposed( [[1,2,3], [3,4]] ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### reduce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 3000 FAQ\n",
    "http://www.artima.com/weblogs/viewpost.jsp?thread=211200\n",
    "\n",
    "Q. If you're killing reduce(), why are you keeping map() and filter()?\n",
    "\n",
    "A. I'm not killing reduce() because I hate functional programming; I'm killing it because almost all code using reduce() is less readable than the same thing written out using a for loop and an accumulator variable. On the other hand, map() and filter() are often useful and when used with a pre-existing function (e.g. a built-in) they are clearer than a list comprehension or generator expression. (Don't use these with a lambda though; then a list comprehension is clearer and faster.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "def mul(x,y): return x/2.0+1/x\n",
    "x = reduce(mul, range(1, 11))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import functools\n",
    "def mul(x,y): return x/2.0+1/x\n",
    "x = functools.reduce(mul, range(1, 11))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def mul(x,y): return x/2.0+1/x\n",
    "result = 1\n",
    "for x in range(1,11):\n",
    "    result = mul(result, x)\n",
    "x =result\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "range(10)\n",
    "xrange(10)\n",
    "print [x for x in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(range(10))\n",
    "print(xrange(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "A = [1,2,3,4]\n",
    "B = ['a','b','c']\n",
    "zip(A,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "A = [1,2,3]\n",
    "B = ['a','b','c']\n",
    "zip(A,B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## map, filter, reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "print 1 < 'a'\n",
    "print sorted([3,1,2,'b','a','c'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(1 < 'a')\n",
    "print(sorted([3,1,2,'b','a','c']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## integers\n",
    "long renamed to int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "int(\"100\")\n",
    "long(\"100\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "int(\"100\")\n",
    "long(\"100\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://www.python.org/dev/peps/pep-0238/\n",
    "The current division (/) operator has an ambiguous meaning for\n",
    "    numerical arguments: it returns the floor of the mathematical\n",
    "    result of division if the arguments are ints or longs, but it\n",
    "    returns a reasonable approximation of the division result if the\n",
    "    arguments are floats or complex.  This makes expressions expecting\n",
    "    float or complex results error-prone when integers are not\n",
    "    expected but possible as inputs.\n",
    "    \n",
    "    The problem is unique to dynamically typed languages: in a\n",
    "    statically typed language like C, the inputs, typically function\n",
    "    arguments, would be declared as double or float, and when a call\n",
    "    passes an integer argument, it is converted to double or float at\n",
    "    the time of the call.\n",
    "    \n",
    "    The correct work-around is subtle: casting an argument to float()\n",
    "    is wrong if it could be a complex number; adding 0.0 to an\n",
    "    argument doesn't preserve the sign of the argument if it was minus\n",
    "    zero.  The only solution without either downside is multiplying an\n",
    "    argument (typically the first) by 1.0.  This leaves the value and\n",
    "    sign unchanged for float and complex, and turns int and long into\n",
    "    a float with the corresponding value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "print 1/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(1/2, 1//2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import math\n",
    "print(math.atan2(0.0,-0.0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import math\n",
    "print(math.atan2(-0.0,-0.0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "0.0 == -0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wyjatki\n",
    "\n",
    "One of Python's guiding maxims is \"there should be one -- and preferably only one -- obvious way to do it\" [1] . Python 2.x's raise statement violates this principle, permitting multiple ways of expressing the same thought"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "class MyEx(Exception):\n",
    "    x = 0\n",
    "    y = 0\n",
    "    \n",
    "einst = MyEx()\n",
    "einst.x = 1\n",
    "einst.y = 1\n",
    "\n",
    "try:\n",
    "    raise einst\n",
    "#    raise MyEx, einst\n",
    "except MyEx, e:\n",
    "    print e.x, e.y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class MyEx(Exception):\n",
    "    x = 0\n",
    "    y = 0\n",
    "    \n",
    "einst = MyEx()\n",
    "einst.x = 1\n",
    "einst.y = 1\n",
    "\n",
    "try:\n",
    "    raise einst\n",
    "except MyEx as e:\n",
    "    print(e.x, e.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "try:\n",
    "    1/0\n",
    "except Exception:\n",
    "    raise TypeError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "class FooException(Exception):\n",
    "    pass\n",
    "\n",
    "class BarException(Exception):\n",
    "    pass\n",
    "\n",
    "class foo(object):\n",
    "    def d(self):\n",
    "       self.e()\n",
    "\n",
    "    def e(self):\n",
    "       self.f()\n",
    "\n",
    "    def f(self):\n",
    "       raise FooException('Problem')\n",
    "\n",
    "class bar(object):\n",
    "    def a(self):\n",
    "       self.c()\n",
    "\n",
    "    def b(self):\n",
    "       self.c()\n",
    "\n",
    "    def c(self):\n",
    "        try:\n",
    "            f = foo()\n",
    "            f.d()\n",
    "        except FooException as e:\n",
    "            raise BarException(e)\n",
    "\n",
    "bar().a()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 'before'\n",
    "a = [x for x in [1, 2, 3]]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Rozpakowywanie krotek\n",
    "PEP 3113 -- Removal of Tuple Parameter Unpacking\n",
    "Unfortunately this feature of Python's rich function signature abilities, while handy in some situations, causes more issues than they are worth. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%python2\n",
    "def middle( (a,b), (c,d) ):\n",
    "    return 0.5*(a+c),0.5*(b+d)\n",
    "print middle( (1,0), (13,-4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def middle( p1, p2 ):\n",
    "    a,b = p1\n",
    "    c,d = p2\n",
    "    return 0.5*(a+c),0.5*(b+d)\n",
    "print(middle( (1,0), (13,-4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}