5. Pętle i wyrażenia warunkowe.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jak wiele innych języków Python również zawiera wyrażenia warunkowe.\n",
    "3 słowa kluczowe to: if, elif i else.\n",
    "\n",
    "W Pythonie nie funkcjonuje \"case\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "x = 1\n",
    "if x == 1:\n",
    "    print('x = 1')\n",
    "elif x == 2:\n",
    "    print('x = 2')\n",
    "else:\n",
    "    print('x to ani 1 ani 2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# część elif i else jest opcjonalna\n",
    "\n",
    "x = 2\n",
    "if x == 2:\n",
    "    print('x = 2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Warunek wyrażenia nie musi być porównaniem - może to byc dowolny obiekt Pythonowy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "if x:\n",
    "    print('x nie jest puste')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generalnie, typy wbudowane mają wartosć logiczną **Prawdziwą** jeżeli **nie są puste** (w przypadku sekwencji) lub są **różne od 0** (liczby).\n",
    "Klasy definiowane przez użytkownika mogą zaimplementować metodę \\__bool\\__, w celu określenia wartosći logicznej. W przypadku braku metody \\__bool\\__ sprawdzona zostaje metoda \\__len\\__.\n",
    "\n",
    "Do sprawdzenia wartosci logicznej 'ręcznie' można użyć funkcji _bool_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('bool(\"\"):', bool(\"\"))\n",
    "print('bool(\" \"):', bool(\" \"))\n",
    "print('bool([]):', bool([]))\n",
    "print('bool([1]):', bool([1]))\n",
    "print('bool(()):', bool(()))\n",
    "print('bool((1,)):', bool((1,)))  # UWAGA: krotka z jednym elementem musi zawierać , (przecinek)\n",
    "print('bool({}):', bool({}))\n",
    "print('bool({1:1}):', bool({1:1}))\n",
    "print('bool(set()):', bool(set()))\n",
    "print('bool({1}):', bool({1}))\n",
    "print('bool(0):', bool(0))\n",
    "print('bool(1):', bool(1))\n",
    "print('bool(-1):', bool(-1))\n",
    "print('bool(0.0):', bool(0.0))\n",
    "print('bool(1.4):', bool(1.4))\n",
    "print('bool(None):', bool(None))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W przypadku kiedy chcemy przyrównać coś do None uzywamy operatora **is** zamiast **==**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = None\n",
    "if x is None:\n",
    "    print('x to None')\n",
    "\n",
    "x = 2\n",
    "if x is not None:\n",
    "    print('x to nie None')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W Pythonie funkcjonuje róznież forma operatora trójargumentowego:\n",
    "[jeżeli warunek to True] if [warunek] else [jeżeli warunek to False]\n",
    "\n",
    "W tym wyrażeniu blok 'else' jest wymagany"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "y = 22 if x == 2 else 33\n",
    "print(y)\n",
    "\n",
    "y = 22 if x == 3 else 33\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operator trójargumentowy można zapisać też przy pomocy operatorów or i and:\n",
    "[warunek] and [wartosć jeżeli warunek prawdziwy] or [wartość jeżeli warunek fałszywy]\n",
    "\n",
    "Rozwiązanie to ma jedną wadę - jezeli wartosć dla warunku prawdziwego sama w sobie ma wartosć fałsz (np. 0 albo pusta sekwencja) to zwrócona zostanie wartość taka jak dla warunku fałszywego"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pożądane działanie operatora:\n",
    "x = 2\n",
    "y = x == 2 and 2 or None\n",
    "print(y)\n",
    "\n",
    "y = x != 2 and 2 or None\n",
    "print(y)\n",
    "\n",
    "# działanie niepożądane - spodziewamy się None a nie 2\n",
    "y = x != 2 and None or 2\n",
    "print(y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pętle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pętla for\n",
    "\n",
    "Python ma 2 rodzaje pętli: for i while.\n",
    "Pętla for, w przeciwieństwie do wielu języków, iteruje po kolekcji:\n",
    "\n",
    "```\n",
    "for [zmienna] in [kolekcja]:\n",
    "    # kod\n",
    "```\n",
    "w przypadku kiedy elementy kolekcji są krotkami, mozna skorzystać z \"tuple unpackingu\":\n",
    "```\n",
    "kolekcja = [(a, b), (a, b), (a, b)]\n",
    "\n",
    "for item1, item2 in kolekcja:\n",
    "    # item1 to a, item2 to b\n",
    "```    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"standardowa\" iteracja\n",
    "kolekcja = [1, 2, 3, 4, 5]\n",
    "for i in kolekcja:\n",
    "    print(i)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# iteracja po liście krotek 2-elementowych\n",
    "kolekcja = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)]\n",
    "for i in kolekcja:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"unpacking\" bezpośrednio w części for\n",
    "for i, j in kolekcja:\n",
    "    print(i, j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "do przerwania działąnia pętli słuzy słowo kluczowe _break_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1, 2, 3, 4, 5]\n",
    "for i in x:\n",
    "    print(i)\n",
    "    if i == 3:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dodatkiem do pętli for jest blok else: \n",
    "działa to na tej zasadzie, zę jeżeli pętla nie zostanie przerwana to python wykona\n",
    "kod z części else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pętal będzie przerwana\n",
    "x = range(5)\n",
    "for i in x:\n",
    "    if i == 3:\n",
    "        print('jest break')\n",
    "        break\n",
    "else:\n",
    "    print('nie było break')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pętla nie będzie przerwana\n",
    "x = range(5)\n",
    "for i in x:\n",
    "    if i == 6:\n",
    "        print('jest break')\n",
    "        break\n",
    "else:\n",
    "    print('nie było break')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For nie usuwa po sobie zmiennej \"iterującej\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    if i == 3:\n",
    "        break\n",
    "        \n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Iteracja ogólnie:**\n",
    "\n",
    "Pętla for działa na tej zasadzie, że do iteracji po obiekcie używa iteratora -\n",
    "wywołuje metodę \\_\\_iter\\_\\_ obiektu a potem tylko bierze kolejne elementy wywołując\n",
    "metodę *next* iteratora, dlatego można w prosty sposób, implementując metodę \\_\\_iter\\_\\_ obsłużyć proces iteracji"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ciekawostka**\n",
    "\n",
    "podczas iteracji, w cześci _for_ można przypisywać wartości do elementów słownika/listy itp."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {}\n",
    "for d[1] in range(3):\n",
    "    pass\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {}\n",
    "for  i in range(5):\n",
    "    for d[i] in range(i, i+1):\n",
    "        pass\n",
    "    \n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pętla while\n",
    "Pętla while wykonuje się tak długo jak wartość będąca w warunku jest prawdziwa:\n",
    "\n",
    "składnia:\n",
    "```\n",
    "while [warunek]:\n",
    "    # ....\n",
    "else:\n",
    "    # ...\n",
    "```    \n",
    "else w przypadku pętli while działa tak samo jak w przypadku pętli for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0\n",
    "while x < 5:\n",
    "    print(x)\n",
    "    x += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "while x:\n",
    "    print(x)\n",
    "    x -= 1\n",
    "else:\n",
    "    print('nie było break')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "while True:\n",
    "    print(x)\n",
    "    x -= 1\n",
    "    if x == 3:\n",
    "        break\n",
    "else:\n",
    "    print('nie było break')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comprehensions\n",
    "\n",
    "w Pythonie, funkcjonują 4 rodzaje comprehensions - są to udogodnienia to tworzenia nowych list, słowników i zbiorów.\n",
    "\n",
    "składnia jest następująca:\n",
    "\n",
    "### List comprehension:\n",
    "```\n",
    "nowa_lista = [Nnowy_element for element_starej_sekwencji in stara_sekwencja if warunek]\n",
    "```\n",
    "jest to równoważne z:\n",
    "```\n",
    "nowa_lista = []\n",
    "for element_starej_sekwencji in stara_sekwencja:\n",
    "    ...\n",
    "    ...\n",
    "    nowy_element = ...\n",
    "    ...\n",
    "    if warunek:  # jeżeli ten warunek jest - jeżeli nie to element zawsze zostanie dodany\n",
    "        nowa_lista.append(nowy_element)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [int(i) for i in '12345']\n",
    "print lista\n",
    "\n",
    "print 10 * '='\n",
    "lista = [int(i) for i in '12345' if i not in '24']\n",
    "print lista\n",
    "\n",
    "# pętle wewnątrz comprehension można zagnieżdżać\n",
    "print 10 * '='\n",
    "lista = [int(i) for j in ['123', '456', '789'] for i in j if i not in '2468']\n",
    "print lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dict comprehension\n",
    "Składnia jest dokłądnie taka sama jak w przypadku list comprehension z jedną drobnymi różnicami:\n",
    "* zmieniają się nawiasy [] na klamry {}\n",
    "* nowy element to para klucz:wartość"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {i: 2*i for i in range(15) if not i%2}\n",
    "print(d)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set comprehension\n",
    "Skłądnia jest bardzo podobna do dict i list comprehension:\n",
    "* nawiasy [] zmienione są na klamry {}\n",
    "* nowy element zbioru jest jednoczłonowy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zbior = {2*i for i in range(15) if not i%2}\n",
    "print(zbior)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Uwaga**\n",
    "\n",
    "pomiędzy pythonem 2 a 3 jest mały niuans przy usuwaniu \"pozostałości po iteracji\" w przypadku comprehensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# python2\n",
    "x = [i_ for i_ in range(4)]\n",
    "print(i_)  # i_ nie zostało usunięte - jest wprowadzone do lokalnego zakresu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#python2\n",
    "i_ = 5\n",
    "x = [i_ for i_ in range(4)]\n",
    "print(i_)  # i_ nzastąpiło implicite poprzednią wartość i_ - ustawioną celowo!! marnie !!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#python3\n",
    "x = [i__ for i__ in range(4)]\n",
    "print(i__)  # i__ zostało usunięte - jest NameError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W Pythonie 3 - wszystkie comprehensions (właczając generator expressions - wspomniane później) są zaimplementowane jako funkcje. Ma to wpływ przy tworzneiu klas\n",
    "\n",
    "W Pythonie 2 tylko generator expression jest zaimplementowane jako funkcja."
   ]
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}