wyklady/js-python_w02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Języki skryptowe - Python\n",
    "## Wykład 2\n",
    "\n",
    "---\n",
    "\n",
    "* sekwencyjne typy danych\n",
    "* system binarny i szesnastkowy\n",
    "* wyrażenia logiczne"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Ostatnio\n",
    "\n",
    "---\n",
    "\n",
    "* wprowadzone zostały 4 typy zmiennych: *int*, *float*, *complex* i *str*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# [zmienna] [operator przypisania] [wartość]\n",
    "# typowanie dynamiczne\n",
    "\n",
    "n = 10  # liczba całkowita\n",
    "x = 1.5 # liczba zmiennoprzecinkowa\n",
    "c = 2j  # liczba zespolona\n",
    "\n",
    "s = \"Python\" # łańcuch znaków"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Łańuch znaków\n",
    "\n",
    "---\n",
    "\n",
    "* zmienna *str* przechowuje tak naprawdę ciąg znaków\n",
    "* w którym każdy znak ma określoną pozycję"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'P'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"Python\"\n",
    "\n",
    "s[0] # str[i] -> i-ty znak w ciągu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'y'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1] # pierwszy to drugi?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'t'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Indeksowanie\n",
    "\n",
    "---\n",
    "\n",
    "* indeksowanie zaczyna się od 0 a kończy na *n-1*, gdzie *n* - długość ciągu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "s = \"Python\"\n",
    "\n",
    "n = len(s) # długość łańcucha s\n",
    "\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'n'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[n-1] # ostatni element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-7-1dea7ae0782c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# poza zakresem\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "s[n] # poza zakresem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Wycinki\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'th'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"Python\"\n",
    "\n",
    "s[2:4] # elementy od 2 do 3 (czyli \"od 3 do 4\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'thon'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[2:] # od indeksu 2 do końca"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Py'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:2] # od początku do 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'thon'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[2:1000] # nie ma błędu o wyjściu poza zakres"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Wycinki z krokiem\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'246'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"0123456789\"\n",
    "\n",
    "s[2:8:2] # sekwencja[początek:koniec:krok]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'258'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[2::3] # od 2 do końca co 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'02468'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[::2] # od początu do końca co 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Indeksy ujemne\n",
    "\n",
    "---\n",
    "\n",
    "* indeks $-k$ oznacza $n-k$, gdzie $n$ - długość łańcucha"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'n'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"Python\"\n",
    "\n",
    "s[-1] # 6 - 1 = 5 -> ostatni znak"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'o'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[-2] # 6 - 2 = 4 -> przedostatni"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'on'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[-2:] # od 4 do końca -> dwa ostatnie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pyth'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:-2] # wszystko oprócz dwóch ostatnich"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dygresja o klasach\n",
    "\n",
    "---\n",
    "\n",
    "* więcej o klasach będzie na dalszych wykładach\n",
    "* klasa definuje obiekt\n",
    "* przypisując wartość zmiennej tworzymy obiekt danej klasy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "n = 10 # tworzymy obiekt klasy int"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Dygresja o klasach\n",
    "\n",
    "---\n",
    "\n",
    "* klasa może posiadać zmienne i metody (czyli funkcje działające na obiekt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1.0 # tworzymy obiekt klasy float\n",
    "\n",
    "# metody/zmienne klasy wywołujemy .\n",
    "x.is_integer() # [obiekt].metoda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pyyyyython'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"Python\" # tworzymy obiekt klasy str\n",
    "\n",
    "s.replace('yt', 'yyyyyt') # [obiekt].metoda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lista (*list*)\n",
    "\n",
    "---\n",
    "\n",
    "* sekwencja zmiennych dowolnego typu\n",
    "* dynamiczny rozmiar\n",
    "* inicjowana jest:\n",
    "    * nawiasy kwadratowe\n",
    "    * jawnie *list([iterable])* (czyli konstruktor klasy *list*)\n",
    "    * lista składana (*list comprehension*)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Lista przez [ ]\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "lista = [1, 2, 'a', \"Python\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(lista) # długość listy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista[0] # pierwszy element listy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista[-1] # ostatni element listy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Lista przez konstruktor\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "lista = list([1,2,3]) # bez sensu, ale można\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['P', 'y', 't', 'h', 'o', 'n']\n"
     ]
    }
   ],
   "source": [
    "lista = list(\"Python\") # można stworzyć listę ze string\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-28-5b92e1b521a9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlista\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# ale już nie z int\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'int' object is not iterable"
     ]
    }
   ],
   "source": [
    "lista = list(1) # ale już nie z int"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Lista składana\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "cyfry = [\"jeden\", \"dwa\", \"trzy\"] # definiujemy listę\n",
    "\n",
    "# [wartość] dla [obiektu] z [listy]\n",
    "# pętle zostaną szerzej omówione na kolejnych wykładach\n",
    "dlugosc = [len(cyfra) for cyfra in cyfry]\n",
    "\n",
    "print(dlugosc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 4]\n"
     ]
    }
   ],
   "source": [
    "cyfry = [\"jeden\", \"dwa\", \"trzy\"] # definiujemy listę\n",
    "\n",
    "# [wartość] dla [obiektu] z [listy] jeśli [warunek]\n",
    "# warunki zostaną szerzej omówione pod koniec wykładu\n",
    "dlugosc = [len(cyfra) for cyfra in cyfry if cyfra != 'dwa']\n",
    "\n",
    "print(dlugosc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Lista jako rezultat funkcji\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method_descriptor:\n",
      "\n",
      "split(...)\n",
      "    S.split(sep=None, maxsplit=-1) -> list of strings\n",
      "    \n",
      "    Return a list of the words in S, using sep as the\n",
      "    delimiter string.  If maxsplit is given, at most maxsplit\n",
      "    splits are done. If sep is not specified or is None, any\n",
      "    whitespace string is a separator and empty strings are\n",
      "    removed from the result.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(str.split)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Python', 'is', 'awesome,', 'fast,', 'and', 'friendly!']"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(\"Python is awesome, fast, and friendly!\").split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Python is awesome', ' fast', ' and friendly!']"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(\"Python is awesome, fast, and friendly!\").split(',')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Krotka (*tuple*)\n",
    "\n",
    "---\n",
    "\n",
    "* sekwencja zmiennych dowolnego typu\n",
    "* stały rozmiar\n",
    "* inicjowana jest:\n",
    "    * nawiasy okrągłe\n",
    "    * ciąg elementów oddzielonych przecinkiem\n",
    "    * jawnie *tuple([iterable])*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Krotka\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 'Python')\n"
     ]
    }
   ],
   "source": [
    "krotka = (1, 2, 3, \"Python\") # jak lista, ale () zamiast []\n",
    "\n",
    "print(krotka)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 'Python')\n"
     ]
    }
   ],
   "source": [
    "krotka = 1, 2, 3, \"Python\" # brak nawiasów = tuple\n",
    "\n",
    "print(krotka)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['P', 'y', 't', 'h', 'o', 'n']\n",
      "('P', 'y', 't', 'h', 'o', 'n')\n"
     ]
    }
   ],
   "source": [
    "lista = list(\"Python\") # lista ze stringa\n",
    "\n",
    "krotka = tuple(lista)  # krotka z listy\n",
    "\n",
    "print(lista)\n",
    "print(krotka)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Lista vs Krotka\n",
    "\n",
    "---\n",
    "\n",
    "* krotka ma stały rozmiar a lista jest dynamiczna\n",
    "* krotka jest \"niezmienna\" (*immutable*) w przeciwieństwie do listy (*mutable*)\n",
    "* więcej o *mutable* vs *immutable* w dalszej części wykładu\n",
    "* jeśli sekwencja obiektów jest stała w czasie działania programu, lepiej używać krotek\n",
    "    * szybsze\n",
    "    * bezpieczniejsze\n",
    "    * mogą być kluczami w słowniku *(o słownikach na kolejnych wykładach)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Lista vs Krotka\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[2, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3]\n",
    "\n",
    "print(lista)\n",
    "\n",
    "lista[0] = 2\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-38-9a057d2d95b0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mkrotka\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mkrotka\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "krotka = (1, 2, 3)\n",
    "\n",
    "krotka[0] = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Range\n",
    "\n",
    "---\n",
    "\n",
    "* uwaga: w Pythonie 2 *range()* jest funkcją wbudowaną; w Pythonie 3 jest to typ danych (klasa)\n",
    "* reprezentuje (niezmienniczą) sekwencję liczb\n",
    "* zajmuje mniej pamięci niż *list* lub *tuple* (przechowuje tylko informację o początku, końcu i kroku)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Range\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 10)\n"
     ]
    }
   ],
   "source": [
    "x = range(10) # od 0 do 10\n",
    "\n",
    "print(x) # w Pythonie 2 zobaczylibyśmy [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "print(list(x)) # zrzutujemy na listę, żeby wydrukować"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'range' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-41-3a9de573c036>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;31m# range jest immutable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'range' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "x[0] = 1 # range jest immutable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Range\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[2, 4, 6, 8]\n",
      "[1, 3, 5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "cyfry = range(0, 10)       # range(początek = 0, koniec) \n",
    "parzyste = range(2, 10, 2) # range(początek, koniec, krok)\n",
    "nieparzyste = range(1, 10, 2)\n",
    "\n",
    "print(list(cyfry))\n",
    "print(list(parzyste))\n",
    "print(list(nieparzyste))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sekwencyjne typy danych\n",
    "\n",
    "---\n",
    "\n",
    "* *list* - dynamiczny ciąg zmiennych dowolnego typu\n",
    "* *tuple* - niezmienniczy ciąg zmiennych dowolnego typu\n",
    "* *range* - niezmienniczy ciąg liczba całkowitych\n",
    "* *str* - niezmienniczy ciąg znaków\n",
    "* (dla kompletności) są jeszcze binarne sekwencyjne typy danych: *bytes*, *bytearray*, *memoryview*\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Operacje na sekwencjach\n",
    "\n",
    "---\n",
    "\n",
    "* *in* - prawda jeśli element należy do sekwencji, inaczej fałsz\n",
    "* *not in* - fałsz jeśli element należy do sekwencji, inaczej prawda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"Python\"\n",
    "\n",
    "\"y\" in s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"p\" not in s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* więcej o prawdzie i fałszu w dalszej części wykładu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Operacje na sekwencjach\n",
    "\n",
    "---\n",
    "\n",
    "* splot (*concatenation*)\n",
    "* nie dla *range*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python is awesome!'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "begin = \"Python \"\n",
    "middle = \"is \"\n",
    "end = \"awesome!\"\n",
    "\n",
    "begin + middle + end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7, 8, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = [1, 2, 3, 4]\n",
    "dodatek = [5, 6, 7, 8]\n",
    "\n",
    "dodatek + lista # kolejność ma znaczenie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Operacje na sekwencjach\n",
    "\n",
    "---\n",
    "\n",
    "* mnożenie przez liczbę calkowitą\n",
    "* nie dla *range*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'----------'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "znak = '-'\n",
    "\n",
    "znak * 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 1, 2, 3)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "krotka = (1, 2, 3)\n",
    "\n",
    "2 * krotka"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Operacje na sekwencjach\n",
    "\n",
    "---\n",
    "\n",
    "* wycinki"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = [1, 2, 3, \"Python\"]\n",
    "\n",
    "lista[:2] # dwa pierwsze"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'on'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista[3][-2:] # dwa ostatnie ostatniego"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(3, 9, 3)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(3, 15, 3)[:2] # dla range też działa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Funkcje wbudowane dla sekwencji\n",
    "\n",
    "---\n",
    "\n",
    "* *len* - długość sekwencji\n",
    "* *min*, *max* - najmniejszy, największy element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len([1,2,-3]) # liczba elementów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min([1,2,-3]) # minimum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'y'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(\"Python\") # maximum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Wspólne funkcje klasowe sekwencji\n",
    "\n",
    "---\n",
    "\n",
    "* *index* - indeks pierwszego znalezionego elementu\n",
    "* *count* - ilość wystąpień elementu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3, 4, 5] * 2\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.count(4) # liczba 4 pojawia się 2 razy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.index(4) # pierwszy raz dla i=3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Operacje na sekwencjach \"zmiennych\" (*mutable*)\n",
    "\n",
    "---\n",
    "\n",
    "* na razie znamy: *list*\n",
    "* ale na kolejnych wykładach poznamy kolejne\n",
    "* sekwencje \"niezmienne\" (*immutable*): *tuple*, *range* i *str*\n",
    "* ale na kolejnych wykładach poznamy kolejne\n",
    "* więcej o *mutable* vs *immutable* w dalszej części wykładu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Operacje na sekwencjach \"zmiennych\" (*mutable*)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 3]\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3]\n",
    "\n",
    "lista[1] = 4 # zamień wartość drugiego elementu\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 5, 5, 3]\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3]\n",
    "\n",
    "lista[1:2] = [5, 5] # zamień wycinek\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Operacje na sekwencjach \"zmiennych\" (*mutable*)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3]\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3]\n",
    "\n",
    "del lista[1:2] # usuń wycinek\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "lista = list(range(10))\n",
    "\n",
    "del lista[::2] # usuń co drugi element\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Funkcje klasowe sekwencji \"zmiennych\" (*mutable*)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n",
      "[1, 2, 3, 4, 5, 6, [7, 8, 9]]\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3, 4, 5]\n",
    "\n",
    "lista.append(6) # append dodaje element na koniec listy\n",
    "\n",
    "print(lista)\n",
    "\n",
    "lista.append([7, 8, 9]) # lista dodana jako element\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3, 4, 5]\n",
    "\n",
    "lista.extend([6, 7, 8, 9]) # extend rozwija listę \n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Funkcje klasowe sekwencji \"zmiennych\" (*mutable*)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3]\n",
    "\n",
    "lista.clear() # usuwa wszystkie elementy\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3]\n",
    "\n",
    "kopia = lista.copy() # kopiuje całą listę\n",
    "\n",
    "print(kopia)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Funkcje klasowe sekwencji \"zmiennych\" (*mutable*)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3]\n",
    "\n",
    "lista.insert(1, 4) # wstaw 4 pod indeks 2\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = [1, 2, 3]\n",
    "\n",
    "lista.pop(1) # zwróć i usuń *i*-ty element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3]\n"
     ]
    }
   ],
   "source": [
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Funkcje klasowe sekwencji \"zmiennych\" (*mutable*)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 3, 'a', 'b', 3, 'a', 'b', 3]\n",
      "['a', 3, 'a', 'b', 3, 'a', 'b', 3]\n"
     ]
    }
   ],
   "source": [
    "lista = ['a', 'b', 3] * 3\n",
    "\n",
    "print(lista)\n",
    "\n",
    "lista.remove('b') # usuń element (pierwsze wystąpienie)\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3]\n",
    "\n",
    "lista.reverse() # odwróć kolejność\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Funkcja *sort* - tylko dla list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method_descriptor:\n",
      "\n",
      "sort(...)\n",
      "    L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(list.sort)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['C', 'D', 'a', 'b', 'e']\n",
      "['a', 'b', 'C', 'D', 'e']\n"
     ]
    }
   ],
   "source": [
    "lista = ['e', 'D', 'a', 'b', 'C']\n",
    "\n",
    "lista.sort() # sortuj \n",
    "\n",
    "print(lista)\n",
    "\n",
    "lista.sort(key=str.lower) # sortuj wg funkcji key\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## System dziesiętny\n",
    "\n",
    "---\n",
    "\n",
    "* ogólnie: $$a_n...a_2a_1a_0 = \\sum\\limits_{i = 0}^{n} a_i \\cdot 10^{i} \\text{ , gdzie } a_i \\in \\{0,...,9\\}$$\n",
    "\n",
    "* np. $$438 = 4 \\cdot 10^2 + 3 \\cdot 10^1 + 8 \\cdot 10^0$$\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "* przykład zastosowania: warzywniak"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## System dwójkowy (binarny)\n",
    "\n",
    "---\n",
    "\n",
    "* ogólnie: $$a_n...a_2a_1a_0 = \\sum\\limits_{i = 0}^n a_i \\cdot 2^i \\text{ , gdzie } a_i \\in \\{0,1\\}$$\n",
    "\n",
    "* np. $$110110110_2 = 1 \\cdot 2^8 + 1 \\cdot 2^7 + 0 \\cdot 2^6 + 1 \\cdot 2^5 + 1 \\cdot 2^4 + 0 \\cdot 2^3 + 1 \\cdot 2^2 + 1 \\cdot 2^1 + 0 \\cdot 2^0 = 256 + 128 + 32 + 16 + 4 + 2 = 438$$\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "* przykład zastosowania: elektronika cyfrowa\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Bit (*binary digit*) i bajt (*byte*)\n",
    "\n",
    "---\n",
    "\n",
    "* dwa równie prawdopodobne stany: $\\{0, 1\\}$\n",
    "* 1B = 8b (1 bajt = 8 bitów)\n",
    "* myląca konwencja informatyków:\n",
    "    * 1KB = 1024B\n",
    "    * 1MB = 1024KB = 1024 * 1024B = 1048576B\n",
    "    * 1GB = 1024MB = 1073741824B\n",
    "* [przedrostki binarne](https://en.wikipedia.org/wiki/Binary_prefix): kibi, mebi, gibi... nie do końca się przyjęły "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zmienne w pamięci operacyjnej\n",
    "\n",
    "---\n",
    "\n",
    "* każda zmienna przechowywana jest w pamięci operacyjnej w postaci bitowej\n",
    "* przy czym bajt jest najmniejszym adresowalnym \"fragmentem\" pamięci\n",
    "* np. $438 = 110110110_2$ zajmie co najmniej 2B = 16b (a nie 9 bitów)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from graphviz import Source\n",
    "\n",
    "pamiec = Source('digraph \"pamiec\" \\\n",
    "                { rankdir=LR; node [shape=\"box\"; fontsize=40;]; splines=none; \\\n",
    "                \"0000001\" -> \"10110110\"}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 2.38.0 (20140413.2041)\n",
       " -->\n",
       "<!-- Title: pamiec Pages: 1 -->\n",
       "<svg width=\"381pt\" height=\"60pt\"\n",
       " viewBox=\"0.00 0.00 381.00 60.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 56)\">\n",
       "<title>pamiec</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-56 377,-56 377,4 -4,4\"/>\n",
       "<!-- 0000001 -->\n",
       "<g id=\"node1\" class=\"node\"><title>0000001</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"158,-52 1.42109e-14,-52 1.42109e-14,-0 158,-0 158,-52\"/>\n",
       "<text text-anchor=\"middle\" x=\"79\" y=\"-16\" font-family=\"Times,serif\" font-size=\"40.00\">0000001</text>\n",
       "</g>\n",
       "<!-- 10110110 -->\n",
       "<g id=\"node2\" class=\"node\"><title>10110110</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"373,-52 194,-52 194,-0 373,-0 373,-52\"/>\n",
       "<text text-anchor=\"middle\" x=\"283.5\" y=\"-16\" font-family=\"Times,serif\" font-size=\"40.00\">10110110</text>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.files.Source at 0x7ff3e8613a58>"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pamiec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Int (long int) w C++\n",
    "\n",
    "---\n",
    "\n",
    "* zajmuje 32 bity\n",
    "* stąd 438 = 00000000 00000000 00000001 10110110\n",
    "* bez znaku: $(0, 2^{32} - 1) = (0, 4294967295)$\n",
    "* ze znakiem: $(-2^{31} - 1, 2^{31} - 1) = (-2147483647, 2147483647)$\n",
    "* w C++ występują również: char (8 bitów), short int (8 bitów), long long int (64 bity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Czas uniksowy\n",
    "\n",
    "---\n",
    "\n",
    "* liczba sekund od epoki Uniksa (01.01.1970 UTC)\n",
    "* 32-bitowa liczba ze znakiem\n",
    "* 2147483647 sekund minie 19 stycznia 2038 o godz. 03:14:07 UTC\n",
    "* ciekawostka: iPhone 1970 bug\n",
    "\n",
    "> Manually changing the date to May 1970 or earlier can prevent your iOS device from turning on after a restart."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Limit pamięci\n",
    "\n",
    "---\n",
    "\n",
    "* Architektura 32-bitowa dysponuje $2^{32}$ adresami"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4096.0"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = 1          # bajt\n",
    "KB = 1024 * B  # kilobajt\n",
    "MB = 1024 * KB # megabajt\n",
    "\n",
    "2**32 / MB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* stąd limit pamięci operacyjnej w systemach 32-bitowych to ok. 4GB\n",
    "* co często daje limit na pamięć RAM rzędu 3GB (bo karta graficzna)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Int w Pythonie\n",
    "\n",
    "---\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function getsizeof in module sys:\n",
      "\n",
      "getsizeof(...)\n",
      "    getsizeof(object, default) -> int\n",
      "    \n",
      "    Return the size of object in bytes.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# zwróć uwagę na sposób importowania:\n",
    "# from [moduł] import [funkcja] as [nazwa]\n",
    "from sys import getsizeof as rozmiar\n",
    "\n",
    "help(rozmiar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rozmiar(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rozmiar(2**100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## System szesnastkowy (heksadecymalny)\n",
    "\n",
    "---\n",
    "\n",
    "* ogólnie: $$a_n...a_2a_1a_0 = \\sum\\limits_{i = 0}^n a_i \\cdot 16^i \\text{ , gdzie } a_i \\in \\{0,...,9,A,...,F\\}$$\n",
    "\n",
    "* np. $$1\\text{b}6_{16} = 1 \\cdot 16^2 + 11 \\cdot 16^1 + 6 \\cdot 16^0 = 256 + 176 + 6 = 438$$\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "* przykład zastosowania: adres MAC (*Media Access Control*), grafika komputerowa (kolory RGB)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Kolory RGB\n",
    "\n",
    "---\n",
    "\n",
    "* w 24-bitowym RGB:\n",
    "    * czerwony: 0 - 255\n",
    "    * zielony: 0 - 255\n",
    "    * niebieski: 0 - 255\n",
    "* czemu do 255? 1 bajt = 8 bitów\n",
    "\n",
    "$$11111111_2 = 255$$\n",
    "\n",
    "* w 32-bitowym dochodzi kanał alpha (przezroczystość)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Kolory RGB\n",
    "\n",
    "---\n",
    "\n",
    "* często spotka się zapis: `#RRGGBB`\n",
    "* gdzie `RR` - kolor czerwony w zapisie szesnastkowym itd.\n",
    "* np. `#ff96cb`\n",
    "    * czerwony: $\\text{ff}_{16} = 255$\n",
    "    * zielony: $96_{16} = 150$\n",
    "    * niebieski: $\\text{cb}_{16} = 203$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Kolory RGB\n",
    "\n",
    "---\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.patches.Rectangle at 0x7ff3e862cdd8>"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIgAAAB8CAYAAACyufhdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAAPYQAAD2EBqD+naQAAAZZJREFUeJzt1rttQkEURdHhE1ACkSUyk1KRa3Et7omQlA6cMa6AHRk9\nsNcq4OoEW5pZzTkH3LNeegDPTSAkgZAEQhIISSAkgZAEQhIISSAkgZAEQhIISSAkgZAEQtouPeCe\nzXrzfZu33dI7Xsmcc/XbN582kNu87b4+Psdxf1h6yks4Xy8Pufu0gYwxxnF/GKe396Vn/Gv+ICSB\nkARCEghJICSBkARCEghJICSBkARCEghJICSBkARCEghJICSBkARCEghJICSBkARCEghJICSBkARC\nEghJICSBkARCEghJICSBkARCEghJICSBkARCEghJICSBkARCEghJICSBkARCEghJICSBkARCEghJ\nICSBkARCEghJICSBkARCEghJICSBkARCEghJICSBkARCEghJICSBkARCEghJIKTt0gPK+XpZesLL\nOF8v4/SAu6s55wPO8ld4YkgCIQmEJBCSQEgCIQmEJBCSQEgCIQmEJBCSQEgCIQmEJBCSQEgCIQmE\nJBCSQEgCIQmEJBCSQEgCIQmEJBCSQEg/LqwbylU5dgwAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7ff3c772fb70>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# rysuj bezpośrednio w Jupyter\n",
    "%matplotlib inline\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as patches\n",
    "\n",
    "# zdefiniuj kwadrat\n",
    "kwadrat = patches.Rectangle(\n",
    "    (0.0, 0.0),   # wierzchołek\n",
    "    1.0,          # szerokość\n",
    "    1.0,          # wysokość\n",
    "    facecolor=\"#ff96cb\" # kolor wypełnienia\n",
    ")\n",
    "\n",
    "plt.figure(figsize=(1,1)) # rozmiar\n",
    "plt.axis('off')           # wyłącz osie\n",
    "\n",
    "# narysuj kwadrat; gca -> get currect axis\n",
    "plt.gca().add_patch(kwadrat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Systemy liczbowe w Pythonie\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0b110110110'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(438) # liczba 438 w systemie binarnym"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "438"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0b110110110 # 0b sygnalizuje system binarny"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "438"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0b0000000000110110110 # wiodące zera nic nie zmieniają"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0x1b6'"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hex(438) # liczba 438 w systemie heksadecymalnym"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "438"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0x1b6 # 0x sygnalizuje system szesnastkowy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Typ logiczny (boolowski, *boolean*)\n",
    "\n",
    "---\n",
    "\n",
    "* przyjmuje wartości: prawda lub fałsz\n",
    "* w Pythonie następujące wartości są utożsamiane z fałszem:\n",
    "    * False\n",
    "    * None\n",
    "    * zero dowolnego typu (0, 0.0, 0j)\n",
    "    * pusta sekwencja '', (), [] lub mapowanie {}\n",
    "* pozostałe wartości uznawane są za prawdę"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Operacje logiczne\n",
    "\n",
    "---\n",
    "\n",
    "| Operacja | Wynik |\n",
    "|:--------:|:-----:|\n",
    "| x or y   | jeśli x jest fałszem, to y, inaczej x |\n",
    "| x and y  | jeśli x jest fałszem, to x, inaczej y |\n",
    "| not x    | jeśli x jest fałszem, to True, inaczej False |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Operacje logiczne - or\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 or 0 -> 0\n",
      "1 or 0 -> 1\n",
      "0 or 1 -> 1\n",
      "1 or 1 -> 1\n"
     ]
    }
   ],
   "source": [
    "print(\"0 or 0 -> \" + str(0 or 0))\n",
    "print(\"1 or 0 -> \" + str(1 or 0))\n",
    "print(\"0 or 1 -> \" + str(0 or 1))\n",
    "print(\"1 or 1 -> \" + str(1 or 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Operacje logiczne - and\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "print(\"0 and 0 -> \" + str(0 and 0))\n",
    "print(\"1 and 0 -> \" + str(1 and 0))\n",
    "print(\"0 and 1 -> \" + str(0 and 1))\n",
    "print(\"1 and 1 -> \" + str(1 and 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Operacje logiczne - not\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Dygresja - słowa kluczowe / zastrzeżone\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "can't assign to keyword (<ipython-input-88-6d6e4a6b0a3f>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-88-6d6e4a6b0a3f>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m    False = 3 # zmiennej False przypusz wartość 3\u001b[0m\n\u001b[0m                                                 ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m can't assign to keyword\n"
     ]
    }
   ],
   "source": [
    "x = 1     # zmiennej x przypisz wartość 1\n",
    "y = 2     # zmiennej y przypisz wartość 2\n",
    "False = 3 # zmiennej False przypusz wartość 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
     ]
    }
   ],
   "source": [
    "import keyword\n",
    "print(keyword.kwlist) # lista słów kluczowych w Pythonie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Dygresja - niedozwolone nazwy zmiennych\n",
    "\n",
    "---\n",
    "\n",
    "* słowa kluczowe\n",
    "* zaczynające się od cyfry\n",
    "* zawierające polskie znaki\n",
    "* zawierające cokolwiek innego niż litery, cyfry i `_`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Porównania\n",
    "\n",
    "---\n",
    "\n",
    "| Operacja | Znaczenie |\n",
    "|:--------:|:---------:|\n",
    "| ==       | równe     |\n",
    "| !=       | różne     |\n",
    "| <        | mniejsze  |\n",
    "| >        | większe   |\n",
    "| <=       | mniejsze lub równe |\n",
    "| >=       | większe lub równe  |\n",
    "| is       | ten sam identyfikator |\n",
    "| is not   | inny identyfikator |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Porównania\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 > 0 # większy niż"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Prowadzący\" > \"Student\" # znak po znaku"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"prowadzący\" > \"Student\" # wielkość ma znaczenie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"prowadzący\" > \"2 studentów\" # litera > cyfra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Identyfikator zmiennej\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function id in module builtins:\n",
      "\n",
      "id(obj, /)\n",
      "    Return the identity of an object.\n",
      "    \n",
      "    This is guaranteed to be unique among simultaneously existing objects.\n",
      "    (CPython uses the object's memory address.)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140685772794432"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 2 # zmiennej x przypisz wartość 2\n",
    "id(x) # wyświetl jej id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## id dla int\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140685772794432"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 2 # zmiennej x przypisz wartość 2\n",
    "id(x) # wyświetl jej id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140685772794432"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = 2 \n",
    "id(y) # to samo id co x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x is y # zmienne x i y wskazują w to samo miejsce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## id dla list\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1, 2, 3] # lista\n",
    "y = [1, 2, 3] # taka sama lista\n",
    "\n",
    "x == y # rzeczywiście taka sama"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x is y # ale nie ta sama"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140685552423752 140684962057672\n"
     ]
    }
   ],
   "source": [
    "print(id(x), id(y)) # listy mają różne id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0] is y[0] # ale elementy już nie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = y # przypisz zmiennej x obieky y\n",
    "\n",
    "x is y # teraz x i y wskazują to samo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Mutable vs Immutable\n",
    "\n",
    "---\n",
    "\n",
    "* immutable: *int*, *float*, *complex*, *str*, *tuple*, (*frozen set*, *bytes*)\n",
    "    * przypisanie zmiennej nowej wartości tworzy nowy obiekt w pamięci\n",
    "* mutable: *list*, (*set*, *dict*, *byte array*)\n",
    "    * możliwa modyfikacja obiektu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Mutable vs Immutable\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140685772794432"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 2\n",
    "id(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140685772794464"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3\n",
    "id(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140685552461384"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [2]\n",
    "id(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140685552461384"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.append(3)\n",
    "id(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Konsekwencje\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "x = 2 # uwtórz obiekt typu int\n",
    "y = x # y wskazuje na to samo co x\n",
    "\n",
    "y = 5 # zmieniam y - nowe miejsce w pamięci\n",
    "\n",
    "print(x) # x dalej wskazuje na 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140684962055816 140684962055816\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3] # utwórz obiekt typu list\n",
    "y = x # y wskazuje na to samo co x\n",
    "\n",
    "print(id(x), id(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "y[0] = 4 # modyfikuję y\n",
    "\n",
    "print(x) # a zmienia się x..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Funkcja *copy*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140685552556616 140685552460232\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3] # utwórz obiekt typu list\n",
    "y = x.copy()  # stwórz kopię tego obiektu\n",
    "\n",
    "print(id(x), id(y)) # teraz są to dwa różne obiekty"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Slideshow",
  "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": 1
}