Warsztat 1-07.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Warsztat 7 – NumPy - wprowadzenie<a id=top></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=2>Przed pracą z notatnikiem polecam wykonać kod w ostatniej komórce (zawiera html i css), dzięki czemu całość będzie bardziej estetyczna :)</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href='#Warsztat-1---podstawy-programowania'>Warsztat 7</a>\n",
    "<ul>\n",
    "<li><a href='#Czym-jest-NumPy'><span>Czym jest NumPy</span></a></li>\n",
    "<li><a href='#Tablica'><span>Tablica</span></a></li>\n",
    "<li><a href='#Inne-metody-tworzenia-tablic'><span>Inne metody tworzenia tablic</span></a></li>\n",
    "<li><a href='#Liczby-losowe'><span>Liczby losowe</span></a></li>\n",
    "<li><a href='#Typy-danych'><span>Typy danych</span></a></li>\n",
    "<li><a href='#Slicing'><span>Slicing</span></a></li>\n",
    "<li><a href='#Widoki-i-kopiowanie'><span>Widoki i kopiowanie</span></a></li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Czym jest NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"http://bids.berkeley.edu/sites/default/files/styles/400x225/public/projects/numpy_project_page.jpg?itok=flrdydei\" width=15% height=15%>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy to jeden z modułów zawartych w pakieie SciPy (ang. scientific Python), który jest zbiorem narzędzi dedykowanych pracy naukowej oraz bardziej rozbudowanym obliczeniom. Sam NumPy ma służyć pracy z danymi numerycznymi, która nie jest możliwa przy użyciu standardowego Pythona.<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Żeby rozpocząć pracę należy zaimportować NumPy podobnie jak inne biblioteki. Zwyczajowo przypisuje się jej skrót np, ale oczywiście możecie wybrać dowolny sposób dołączenia modułu do bieżącej pracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy rozszerza możliwości Pythona w dwóch podstawowych spektach:<br>\n",
    "1. oddaje do użytku dwie nowe struktury danych - tablicę (ang. array) oraz macierz (ang. matrix), które w istotny sposób zwiększają możliwość tworzenia danych numerycznych oraz ułatwiają pracę z nimi;<br>\n",
    "2. wprowadza szereg funkcji przydatnych do obliczeń (np. stałe matematyczne, ważne operacje matematyczne czy przekształcenia)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do tego większość biblioteki napisana jest w języku C, dzięki czemu operacje w NumPy wykonywane są dużo szybciej niż w przypadku kodu w czystym Pythonie (co będzie miało ogromne znaczenie w przypadku dużych danych czy skomplikowanych operacji numerycznych).<br>\n",
    "Możemy to zobaczyć za pomocą poniższego prostego testu wydajności."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = range(10000)\n",
    "%timeit [i**2 for i in x]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(10000)\n",
    "%timeit x**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href='#top' style='float: right; font-size: 13px;'>Do początku</a>  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tablica"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tablica może być rozumiana jako wielowymiarowa lista.<br>\n",
    "Tworzymy ją za pomocą funkcji <b>array( )</b> a wewnątrz umieszczamy listę obiektów, które mają się znaleźć w tablicy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = range(16)\n",
    "print(type(x), x)\n",
    "tablica = np.array(x)\n",
    "print(type(tablica), tablica)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Charakterystycznym parametrem tablicy są jej wymiary. NumPy pozwala tworzyć dane o dowolnych rozmiarach, ale co wazniejsze, również o dowolnej liczbie wymiarów (wymiary naszej tablicy sprawdzamy metodą <b>.ndim</b>).<br>\n",
    "1 wymiar - tablica stworzona z pojedynczej listy (nawet pustej)<br>\n",
    "2 wymiar - tablica złożona z co najmniej dwóch list o takiej samej długości<br>\n",
    "3 wymiar - tablica złożona z co najmniej dwóch tablic 2-wymiarowych<br>\n",
    "..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([])\n",
    "y = np.array([1,2,3,4])\n",
    "z = np.array([[1,2,3,4],[2,2,2,2]])\n",
    "v = np.array([[[1,2,3,4],[2,2,2,2]],[[1,2,3,4],[2,2,2,2]]])\n",
    "print ('x = ', x, '\\n')\n",
    "print ('y = ', y, '\\n')\n",
    "print ('z = ', z, '\\n')\n",
    "print ('v = ', v, '\\n')\n",
    "print (\"Wymiar x = \",x.ndim,\", y = \", y.ndim,\", z = \", z.ndim,\", v = \", v.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1-D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica = np.array([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15])\n",
    "print (tablica)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (tablica.ndim) #zwraca wymiar tablicy\n",
    "\n",
    "print (tablica.shape) #zwraca długość poszczególnych wymiarów tablicy\n",
    "\n",
    "print (len(tablica)) #zwraca długość pierwszego wymiaru tablicy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jak widać powyżej, jednowymiarowa tablica wygląda bardzo podobnie do zwykłej listy - różni ją tylko brak przecinków.<br>\n",
    "Żeby stworzyć tablice o wyższych wymiarach, mamy do wyboru dwie główne strategie."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2-D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Możemy do funkcji **array** przekazać zamiast listy elementów, listę list o równej ilości elementów. Wtedy NumPy intuicyjnie utworzy dwuwymiarową tablicę, której poszczególne wiersze będą przekazywanymi listami."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica2d = np.array([[0,1,2,3,4,5,6,7],[8,9,10,11,12,13,14,15]])\n",
    "print (tablica2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (tablica2d.ndim)\n",
    "\n",
    "print (tablica2d.shape)\n",
    "\n",
    "print (len(tablica2d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Możemy również podać dane w postaci jednej długiej listy a następnie \"uformować\" ją we właściwy kształt za pomocą polecenia <b>.shape( )</b>.<br> Należy jednak pamiętać, że operacja ta uda się tylko wtedy, kiedy nie będzie trzeba zmieniać ilości elementów tablicy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica.shape = (4,4)\n",
    "print (tablica)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podobny efekt możemy uzyskać za pomocą metody <b>.reshape(</b>wartości wymiarów<b>)</b>. Tutaj również trzeba zachować liczbę elementów tablicy.<br>\n",
    "Tymi metodami możemy uzyskać dowolny wymiar naszej tablicy, o ile będziemy mieli dość danych.<br><br>\n",
    "**Ważne:** kolejność podawania argumentów do metody shape() i reshape() jest nieintuicyjna - w poniższym przykładzie przekazujemy (2,4,2,1) tworząc 4-wymiarową tablicę. Jednak jak widać, przy n wymiarach kolejność jest następująca: (n, n-1, n-2,..., rząd, kolumna)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica.reshape(2,4,2,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href='#top' style='float: right; font-size: 13px;'>Do początku</a>  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ćwiczenie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stwórz tablicę złożoną z 12 dowolnych elementów. Uformuj trzy wersje o wskazanych wymiarach: 6x2, 3x4 oraz 2x2x3.<br>\n",
    "Wykorzystaj komendy **shape**, **ndim** oraz **len**, żeby sprawdzić efekt każdej zmiany."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inne metody tworzenia tablic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wprowadzanie ręcznie danych do tablicy rzadko kiedy jest pożądaną i sensowną czynnością. Zamiast tego, możemy wspomóc się różnymi funkcjami w celu wygenerowania tablic o interesującym nas kształcie czy zawartości. Poniżej przyjrzymy się kilku przykładom."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jedną z opcji może być funkcja <b>arange( )</b>, czyli numpy'owy odpowiednik standardowego **range( )**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica_ar = np.arange(100)\n",
    "tablica_ar.shape = (10,10)\n",
    "tablica_ar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kolejną opcją jest funkcja <b>linspace( )</b>, która tworzy nam listę równooddalonych od siebie punktów we wskazanym zakresie. Składnia tej funkcji wygląda następująco:\n",
    "<center>**linspace(** początek, koniec, ilość punktów **)**</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica_ls = np.linspace(1,5,11)\n",
    "tablica_ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dodanie do atrybutów **endpoint = False** sprawi, że górna granica ciągu nie będzie elementem tablicy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "tablica_ls = np.linspace(1,5,10, endpoint = False)\n",
    "tablica_ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Istnieje też kilka funkcji tworzących tablice uniformiczne - np. o wszystkich elementach równych sobie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica_zer = np.zeros((5,5))\n",
    "tablica_zer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica_jedynek = np.ones((3,3,3))\n",
    "tablica_jedynek"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica_ein = np.eye(4)\n",
    "tablica_ein"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica_prze = np.diag(np.array([1,2,3,4]))\n",
    "tablica_prze"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Liczby losowe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Możemy też wykorzystać funkcje generujące liczby losowe. NumPy ma wbudowane porządne algorytmy generowania liczb pseudo-losowych, dzięki czemu mogą być one wykorzystywane w obliczeniach naukowych."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.random(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Powyższa funkcja generuje liczby z przedziału [0,1) i jednorodnej dystrybucji (tzn. każda liczba ma podobne prawdopodobieństwo pojawienia się przy losowaniu).<br>\n",
    "Jeśli chcemy mieć większą kontrolę nad zakresem i sposobem losowania, możemy wykorzystać np. funkcję <b>uniform</b>, w której możemy ustalić zakres oraz wielkość pobieranej próbki."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.uniform(1,100,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Z perspektywy nauk społecznych, najbardziej przydatną dystrybucją jest oczywiście krzywa rozkładu normalnego (tzw. krzywa Gaussa czy krzywa dzwonowa). Do wygenerowania próbki z tej dystrybucji wykorzystamy funkcję <b>normal</b>, której parametrami są **średnia, odchylenie standardowe oraz wielkość próbki**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.random.uniform(5,1,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy dysponuje wieloma różnymi rozkładami, których spis i sposób użycia można znaleźć <a href=\"http://docs.scipy.org/doc/numpy-1.10.1/reference/routines.random.html\">pod tym linkiem</a>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href='#top' style='float: right; font-size: 13px;'>Do początku</a>  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ćwiczenie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wygeneruj tablicę z wartościami o dowolnym losowym rozkładzie i ukształtuj ją w format 10x10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poniższy kod produkuje histogram obrazujący rozkład jednorodny o podanych charakterystykach. Zmodyfikuj kod, aby spełniał poniższe warunki:\n",
    "- <span>Zmień zakres próbkowania na liczby większe od 0 i mniejsze od 35.</span>\n",
    "- <span>Zwiększ wielkość próbki o dwa rzędy wielkości.</span>\n",
    "- <span>Czy masz pomysł, co należałoby zmienić, żeby wykres był \"mniej kanciasty\"? Spróbuj zmodyfikować kod i przetestować swój pomysł.</span>\n",
    "- <span>Zamień typ rozkładu na normalny o M = 10 i SD = 3.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=np.random.uniform(5,10,10000)\n",
    "a = np.histogram(x, bins=100)[0]\n",
    "b = np.histogram(x, bins=100)[1][:-1]\n",
    "plt.plot(b,a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Typy danych"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Szybkość NumPy'a wynika między innymi z bardziej restrykcyjnego zarządzania typami danych wewnątrz obiektów. Dlatego możliwe jest określenie, jakiego typu dane będą przechowywane wewnątrz tablicy. Kod został jednak tak pomyślany, że NumPy najczęściej sam 'wydedukuje', jakiego typu są wprowadzone dane.<br>\n",
    "Wiadomo, że najczęściej tablice będą wypełnione liczbami zmiennoprzecinkowymi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([1,2,3])\n",
    "a.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.array([1.,2,3])\n",
    "b.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = np.ones(3)\n",
    "c.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = np.array([1+1j,2,3]) #liczby złożone (składające się z części rzeczywistej i urojonej)\n",
    "d.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e = np.array([True, False, False])\n",
    "e.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = np.array(['asdf','asdfg','qwerty']) #tablica stringów o maksymalnej długości 6\n",
    "f.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href='#top' style='float: right; font-size: 13px;'>Do początku</a>  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podobnie jak listy, tablice możemy dzielić na mniejsze części oraz wybierać z nich elementy według interesujących nas zasad.<br>\n",
    "Zacznijmy od indeksowania, które jest podstawowym sposobem dotarcia do elementów w tablicy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica = np.arange(1,17)\n",
    "tablica"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (tablica[4])\n",
    "print (tablica[-1])\n",
    "print (tablica[::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dodanie kolejnych liczb po przecinkach, pozwoli nam określić, jak ograniczyć tablicę ze względu na inne wymiary.<br>\n",
    "Bardzo istotne jest zapamiętanie, że pierwszy parametr to <b>numer rzędu</b> a drugi to **numer kolumny**.<br>\n",
    "Kolejne numery będą odwoływać się do następnych wymiarów tablicy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica = tablica.reshape(4,4)\n",
    "tablica"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print tablica[2,2]\n",
    "print tablica[1:,3]\n",
    "print tablica[3:,::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tablica zachowuje się w identyczny sposób jak lista także pod względem zmiany wartości wewnątrz jej komórek. Dokonuje się to poprzez znak <b>=</b>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica[3,3]=17\n",
    "tablica"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Możemy połączyć obie te metody by podmienić więcej niż jeden element w tym samym momencie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica[1:,2]=99\n",
    "tablica"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Widoki i kopiowanie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Powyższe zabiegi są możliwe dlatego, że slicing tworzy tylko <b>podgląd</b> na oryginalną tablicę.<br>\n",
    "Zobaczmy, jak wygląda manipulacja tablicami stworzonymi z innych talbic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica2 = tablica[0:2,2:]\n",
    "tablica2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica2[:,:] = -5\n",
    "tablica2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Widzimy, że pomimo przypisania slicingu do nowej zmiennej, ta operacja nie tworzy nowej tablicy, wyłącznie podgląd. Dlatego modyfikacja tablica2 modyfikuje także tablica. Żeby uniknąć tego efektu trzeba wymusić kopiowanie za pomocą metody <b>.copy( )</b>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica3 = tablica[2:,2:].copy()\n",
    "tablica3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica3[:,:] = 100\n",
    "tablica3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tablica"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href='#top' style='float: right; font-size: 13px;'>Do początku</a>  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\r\n",
       "@import url(http://fonts.googleapis.com/css?family=Titillium+Web:400,700,800,400italic&subset=latin-ext,latin);\r\n",
       "@import url(http://fonts.googleapis.com/css?family=Anonymous+Pro:400,700,800,400italic&subset=latin-ext,latin);\r\n",
       "\r\n",
       ".filename {\r\n",
       "    font-family: Titillium Web;\r\n",
       "    font-variant: small-caps;\r\n",
       "    letter-spacing: 0.1em;\r\n",
       "}\r\n",
       "\r\n",
       "b {\r\n",
       "    color: #cc0000;\r\n",
       "}\r\n",
       "\r\n",
       "em {\r\n",
       "    color:#0000cc;\r\n",
       "}\r\n",
       "\r\n",
       "ul {\r\n",
       "\tlist-style-type: square !important;\r\n",
       "}\r\n",
       "\r\n",
       ".rendered_html ul li {\r\n",
       "\tfont-size: 8px;\r\n",
       "}\r\n",
       "\r\n",
       "li span {\r\n",
       "\tfont-size: 14px;\r\n",
       "}\r\n",
       "\r\n",
       "/* tekst w markdown */\r\n",
       ".rendered_html {\r\n",
       "    font-family: Titillium Web, serif;\r\n",
       "    }\r\n",
       "\r\n",
       ".rendered_html p {\r\n",
       "    font-size: 16px;\r\n",
       "    text-align: justify;\r\n",
       "    text-decoration: none;\r\n",
       "    }\r\n",
       "\r\n",
       ".rendered_html :link {\r\n",
       "    text-decoration: none;\r\n",
       "    }\r\n",
       "\r\n",
       ".rendered_html :visited {\r\n",
       "    text-decoration: none;\r\n",
       "    }\r\n",
       "    \r\n",
       "/* tekst w code cell */\r\n",
       ".code_cell {\r\n",
       "    font-family: Anonymous Pro, monospace;\r\n",
       "    font-size: 14px;\r\n",
       "    }\r\n",
       "\r\n",
       "code, pre, .CodeMirror {\r\n",
       "    font-family: Anonymous Pro, monospace;\r\n",
       "    font-size: 14px;\r\n",
       "}\r\n",
       "\r\n",
       "</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "from urllib.request import urlopen\n",
    "HTML(urlopen(\"https://raw.githubusercontent.com/mkoculak/Warsztat-programowania/master/ipython.css\").read().decode(\"utf-8\"))"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}