SKN  Statystyki - Python 2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Warsztaty Python w Data Science"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# https://github.com/MichalKorzycki/WarsztatPythonDataScience"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Język Python 2 \n",
    "- ### instrukcje sterujące\n",
    "- ### obsługa błędów\n",
    "- ### Korzystanie z pythona – notebooks, skrypty\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zadanie 1"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Napisać funkcję co policzy ilość wystąpień na liście\n",
    "Przykład\n",
    "\n",
    "zlicz( [1, 2, 3, 4, 1, 2, 1] )\n",
    "\n",
    "{ 1: 3, 2: 2, 3: 1, 4: 1 }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def zlicz(lista):\n",
    "    ilosc_wystapien = {}\n",
    "    for x in lista:\n",
    "        ilosc = ilosc_wystapien.get(x, 0)\n",
    "        ilosc = ilosc + 1\n",
    "        ilosc_wystapien[x] = ilosc\n",
    "    return ilosc_wystapien\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zlicz( [1] * 10 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zlicz( [1, 2, 3, 4, 1, 2, 1] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def zlicz(lista):\n",
    "    ilosc_wystapien = {}\n",
    "    for x in lista:\n",
    "        ilosc = ilosc_wystapien.get(x, 0)\n",
    "        ilosc = ilosc + 1\n",
    "        print \"x:\", x, \"wystapil:\", ilosc, \"razy\"\n",
    "        ilosc_wystapien[x] = ilosc\n",
    "    return ilosc_wystapien"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zlicz( [1] * 10 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zlicz( [1, 2, 3, 4, 1, 2, 1] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 1\n",
    "n = n + 1\n",
    "n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n += 1\n",
    "n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dodaj 1 i podstaw \n",
    "n += 1\n",
    "# Odejmij 1 i podstaw \n",
    "n -= 1\n",
    "# Pomnóż i podstaw\n",
    "n *= 2\n",
    "# Podziel przez i podstaw\n",
    "n /= 2\n",
    "# Weź modulo (resztę z dzielenia) i podstaw\n",
    "n %= 2\n",
    "# Podnieś do potęgi i podstaw\n",
    "n **= 2\n",
    "# Podziel bez reszty i podstaw\n",
    "n //= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def zlicz(lista):\n",
    "    ilosc_wystapien = {}\n",
    "    for x in lista:\n",
    "        ilosc = ilosc_wystapien.get(x, 0)\n",
    "        ilosc += 1\n",
    "        ilosc_wystapien[x] = ilosc\n",
    "    return ilosc_wystapien"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zadanie 2"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\n",
    "Napisać funkcję co wypisze choinkę o odpowiedniej wysokości\n",
    "\n",
    "choinka(7)\n",
    "\n",
    "\n",
    "       *\n",
    "\n",
    "      ***\n",
    "      \n",
    "     *****\n",
    "     \n",
    "    *******\n",
    "    \n",
    "   *********\n",
    "   \n",
    "  ***********\n",
    "  \n",
    " *************\n",
    " \n",
    "       *\n",
    "       \n",
    "      ***\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def choinka(poziom):\n",
    "    for i in range(1,poziom+1):\n",
    "        print \" \"*(poziom-i)+ \"*\"*(2*i-1)\n",
    "    print \" \"*(poziom-1)+\"*\"\n",
    "    print \" \"*(poziom-2)+\"***\"    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "choinka(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def choinka(poziom = 7):\n",
    "    wynik = \"\"\n",
    "    for i in range(poziom):\n",
    "        for j in range(poziom-i+1):\n",
    "            wynik += \" \"\n",
    "        for j in range(2*i+1):\n",
    "            wynik += \"*\"\n",
    "        wynik += '\\n'\n",
    "    \n",
    "    for i in range(poziom+1):\n",
    "        wynik += \" \"\n",
    "    wynik += '*\\n'\n",
    "    for i in range(poziom):\n",
    "        wynik += \" \"\n",
    "    wynik += '***'\n",
    "    \n",
    "    print wynik    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "choinka()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Argumenty Funkcji"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_var_args(farg, *args):\n",
    "    print \"formal arg:\", farg\n",
    "    for arg in args:\n",
    "        print \"another arg:\", arg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_var_args(1, \"two\", 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_var_kwargs(farg, **kwargs):\n",
    "    print \"formal arg:\", farg\n",
    "    for key in kwargs:\n",
    "       print \"another keyword arg: %s: %s\" % (key, kwargs[key])\n",
    "    print kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_var_kwargs(farg=1, myarg2=\"two\", myarg3=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def test_var_args_call(arg1, arg2, arg3):\n",
    "    print \"arg1:\", arg1\n",
    "    print \"arg2:\", arg2\n",
    "    print \"arg3:\", arg3\n",
    "args = (\"two\", 3)\n",
    "test_var_args_call(1, *args)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kwargs = {\"arg3\": 3, \"arg2\": \"two\"}\n",
    "test_var_args_call(1, **kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instrukcje sterujące"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 1\n",
    "if n % 2 == 2:\n",
    "    print \"Parzyste\"\n",
    "else:\n",
    "    print \"Nieparzyste\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 1\n",
    "m = 2\n",
    "if n % 2 == 0:\n",
    "    print \"N Parzyste\"\n",
    "elif m % 2 == 0:\n",
    "    print \"M parzyste\"\n",
    "else:\n",
    "    print \"Obie Nieparzyste\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 3 if m == 3 else 1\n",
    "print n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 0\n",
    "while n < 5:\n",
    "    print n\n",
    "    n += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 0\n",
    "while True:\n",
    "    print n\n",
    "    n += 1\n",
    "    if n >= 5:\n",
    "        break\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 0\n",
    "while True:\n",
    "    print n\n",
    "    n += 1\n",
    "    if n < 5:\n",
    "        continue\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 0\n",
    "while n < 5:\n",
    "    print n\n",
    "    n += 1\n",
    "else:\n",
    "    print \"Else\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print i\n",
    "else:\n",
    "    print \"Else\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteratory i Generatory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print xrange(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in xrange(5):\n",
    "    print i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generatory są mechanizmem\n",
    "* tworzenia iteratorów\n",
    "* Zwraca dane przez yield\n",
    "* Każde wywołanie next() zaczyna od miejsca gdzie skończył poprzedni krok\n",
    "* next() tworzona jest automatycznie\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reverse(data):\n",
    "    for index in range(len(data)-1, -1, -1):\n",
    "        yield data[index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for c in reverse('Python'):\n",
    "    print c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib(n):\n",
    "    if n == 0 or n == 1:\n",
    "        return n\n",
    "    else:\n",
    "       return fib(n-1) + fib(n-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(36):\n",
    "   print \"n=%d => %d\" % (i, fib(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib(n):\n",
    "    a, b = 0, 1\n",
    "    i=0\n",
    "    while i < n:\n",
    "        yield (i, a)\n",
    "        a, b = b, a + b\n",
    "        i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, f in fib(36):\n",
    "   print \"n=%d => %d\" % (i, f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generator Expressions\n",
    "\n",
    "x*x for x in range(10)\n",
    "\n",
    "(x*y for x in range(10) for y in range(x))\n",
    "\n",
    "x*x for x in range(10) if x % 2 == 0\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List + Generator Expression\n",
    "\n",
    "           =\n",
    "           \n",
    "    List comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[ x*x for x in range(10) if x % 2 == 0 ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{ x:x*x for x in range(10) if x % 2 == 0 }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(x*y for x in range(10) for y in range(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[(x,y,x*y) for x in range(10) for y in range(x)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Obsluga bledow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1, 2, 3, 4]\n",
    "l[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    l = [ 1, 2, 3, 4 ]\n",
    "    l[5]\n",
    "except IndexError as e:\n",
    "    print e\n",
    "    print \"ale idziemy dalej\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    l = [ 1, 2, 3, 4 ]\n",
    "    l[5]\n",
    "except IndexError as e:\n",
    "    print e\n",
    "    print \"ale idziemy dalej\"\n",
    "finally:\n",
    "    print \"doszlismy do konca\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wez5(l):\n",
    "    try:\n",
    "        return l[5]\n",
    "    finally:\n",
    "        print \"w srodku\"\n",
    "try:\n",
    "    l = [ 1, 2, 3, 4 ]\n",
    "    wez5(l)\n",
    "except IndexError as e:\n",
    "    print e\n",
    "    print \"ale idziemy dalej\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Rzucaj jak najwcześniej (jak najniżej)\n",
    "2. Łap jak najpóźniej (jak najwyżej)\n",
    "3. Finally sprząta!\n",
    "4. Łap konkretne błędy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wez5(l):\n",
    "    try:\n",
    "        return l[5]\n",
    "    except IndexError as e:\n",
    "        print \"przerzucam dalej\"\n",
    "        raise e\n",
    "    finally:\n",
    "        print \"finally w srodku\"\n",
    "try:\n",
    "    l = [ 1, 2, 3, 4 ]\n",
    "    wez5(l)\n",
    "except IndexError as e:\n",
    "    print e\n",
    "    print \"ale idziemy dalej\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Anatomia skryptu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "m = { \"a\":1, \"b\":2 }\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    print m\n",
    "    print\n",
    "    print sys.argv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type, zbiory, lista jako stos albo kolejka"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stack=[3, 4, 5, 6, 7]\n",
    "stack.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stack.append(7)\n",
    "stack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "queue=[3, 4, 5, 6, 7]\n",
    "queue.pop(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "queue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del queue[0]\n",
    "queue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print type(\"\")\n",
    "print type(queue)\n",
    "print type(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zbior = set()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zbior.add(3)\n",
    "zbior.add(4)\n",
    "zbior.add(3)\n",
    "zbior"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zadanie 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stworz funkcję która zwróci drugi najmniejszy element listy\n",
    "\n",
    "druginajmniejszy([1, 2, 3, 4, 6])\n",
    "\n",
    "2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zadanie 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stworz funkcję która usunie z listy najmniejszy element listy\n",
    "\n",
    "l = [4, 1, 2, 3]\n",
    "\n",
    "usun_min(l)\n",
    "\n",
    "l\n",
    "\n",
    "[4, 2, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zadanie 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stworz funkcję która usunie \"wyplaszczy\" zagnieżdzone listy\n",
    "\n",
    "l = [4, 1, [ 2, [7] ], 3]\n",
    "\n",
    "wyplaszcz(l)\n",
    "\n",
    "l\n",
    "\n",
    "[4, 1, 2, 7, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}