Warsztat 1-10.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Warsztat 10 – Pandas - analiza statystyczna i wizualizacja<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-10-–-Pandas---analiza-statystyczna-i-wizualizacja'>Warsztat 10</a>\n",
    "<ul>\n",
    "<li><a href='#Indeksowanie-i-filtrowanie'><span>Indeksowanie i filtrowanie</span></a></li>\n",
    "<li><a href='#Grupowanie-danych'><span>Grupowanie danych</span></a></li>\n",
    "<li><a href='#Podstawowe-analizy'><span>Podstawowe analizy</span></a></li>\n",
    "<li><a href='#'><span></span></a></li>\n",
    "<li><a href='#Materiały-do-dalszej-nauki'><span>Materiały do dalszej nauki</span></a></li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poprzedni notatnik zawierał podstawowe informacje o tym, jak wczytać dane, dokonać inspekcji surowych danych (zarówno wartości zmiennych oraz ich prostej wizualizacji) oraz wyczyścić z niepotrzebnych wartości (przede wszystkim braków danych).  \n",
    "Teraz wprowadzimy bardziej zaawansowane funkcje pakietu pandas, które pozwolą na filtrowanie, grupowanie i przekształcanie danych.  \n",
    "Następnie przeprowadzimy kilka analiz statystycznych w samym pythonie oraz zobaczymy w jaki sposób włączyć do procesu analizy w R."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Będzie nam potrzebny bardziej złożony zbiór danych, więc rozbudujemy przykład ze wzrostem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane = pd.read_excel(\"./wzrost_multi.xlsx\", parse_cols=[1,2,3])\n",
    "dane.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nasza ramka z danymi ma trzy kolumny: płeć ankietowanego, pochodzenie - miejsce zamieszkania, wzrost wyrażony w centymetrach.  \n",
    "Spójrzmy, jakie wartości w naszym zbiorze przyjmują zmienne kategorialne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.Płeć.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.Pochodzenie.value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do danych liczbowych lepiej użyć metody describe(), która poda nam znacznie więcej szczegółów."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.Wzrost.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mamy teraz podstawową wiedzę o zawartości naszych danych, jednak te dane wydają się zbyt ogólne. W końcu nie interesują nas tak bardzo informacje na temat zbioru całej naszej próby, ale raczej poszczególnych podgrup, np. kobiet z Hollywood. Musimy zatem pogrupować nasze dane tak, by te informacje wydobyć."
   ]
  },
  {
   "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": [
    "## Indeksowanie i filtrowanie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nie zawsze interesuje nas cały zbiór danych, tylko jakaś jedna jego część. Pandas oferuje szeroki wachlarz sposobów do wyboru podzbiorów."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bardzo dobrym podejściem do analizy danych jest utrzymywanie **\"uporządkowanych\" zbiorów danych** (ang. tidy data). Oznacza to, że każda kolumna zawiera inną zmienną, natomiast każdy wiersz zawiera pojedynczą obserwację.  \n",
    "Nasze dane spełniają ten warunek. Dzięki temu, możemy swobodnie wybierać z nich tylko niektóre kolumny przy ciągłym zachowaniu spójności. Możemy to zrobić na kilka sposobów. Pierwszy polega na użyciu nawiasów kwadratowych, w które wpiszemy po prostu nazwy interesujących nas zmiennych."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane['Wzrost'].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wybierając tylko jedną kolumnę zawsze otrzymamy **serię**, czyli jednowymiarowy typ danych pandas (w odróżnieniu od ramki z danymi, która jest dwuwymiarowa). Ramkę tworzy wiele takich serii.  \n",
    "Jeśli chcemy tą metodą wybrać więcej kolumn, musimy przekazać ich listę."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane[['Pochodzenie','Płeć']].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Innym sposobem wybrania pojedynczej kolumny może być użycie jej nazwy jako metody samego zbioru.  \n",
    "Choć on nie będzie działał we wszystkich przypadkach (np. kiedy nazwa kolumny posiada spację lub inny znak specjalny)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.Wzrost.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bardziej ogólnym i uniwersalnym sposobem wyboru kolumn jest użycie metody <b>.loc[ , ]</b>.  \n",
    "Do nawiasu kwadratowego zawsze podajemy dwie wartości, pierwsza oznacza wiersz (lub zakres wierszy), które chcemy wybrać. Druga oznacza to samo dla kolumn. Jeśli chcemy wybrać wszystkie elementy, możemy użyć znaku **dwukropka**.\n",
    "\n",
    "Spróbujmy najpierw odtworzyć wybór kolumn z wcześniej."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.loc[:,'Wzrost'].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.loc[:,['Pochodzenie', 'Płeć']].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Teraz spróbujmy wybrać kilka różnych wierszy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.loc[5,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.loc[5:10,:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ważne**: Metoda loc operuje na <b>nazwach</b> zarówno indeksów wierszy jak i nazw kolumn. Nasze dane mają nazwy indeksów w formie numerów, dlatego może to powodować lekką konfuzję. Metoda loc traktuje te numery jako nazwy wierszy a nie ich liczbę porządkową.\n",
    "\n",
    "Teraz jeszcze jeden przykład z kombinacją indeksów i nazw kolumn. Warto zwrócić uwagę, że kolejność wpisanych kolumn jest dowolna i możemy je tym sposobem przestawiać."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.loc[7:13,['Wzrost','Pochodzenie']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas udostępnia też możliwość wykorzystania indeksowania numerycznego - czyli wskazania numerów wierszy i kolumn, które chcemy wybrać do podzbioru bezpośrednio. Służy do tego metoda <b>.iloc[ , ]</b>. Jej działanie jest identyczne do loc, z tym wyjątkiem, że posługujemy się numerami a nie nazwami."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.iloc[6:10,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.iloc[6:10,1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Działa tutaj ten sam system wskazywania zakresów liczbowych jak w całym pythonie - pierwszym elementem jest 0, natomiast koniec zakresu nie jest uwzględniany w nowym podzbiorze. Dlatego loc[8:10,:] i iloc[8:10,:] dadzą inne wyniki."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.loc[8:10,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.iloc[8:10,:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Etykiety zachowują się tu całkiem podobnie do zakresów liczbowych - możemy wybrać od której do której nazwy kolumny chcemy wybrać podzbiór i pandas wybierze dla nas wskazane kolumny i wszystkie, które znajdują się pomiędzy nimi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.loc[8:10,'Płeć':'Pochodzenie']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podobnie jak przy filtrowaniu elementów listy, możemy tutaj dołożyć trzeci argument, który wskaże wielkość kroku - np. wybieranie co drugiego czy co trzeciego elementu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.loc[5:25:4,:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Część pierwsza zawierała już przykłady wybierania elementów kolumn na podstawie warunków logicznych.  \n",
    "Tutaj jednak powtórzymy to sobie i poszerzymy trochę tamte wiadomości."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Możemy dowolnie wybierać podzbiory kolumn czy wierszy na podstawie wartości zawartych w poszczególnych komórkach.  \n",
    "Dla przykładu, możemy chcieć wybrać podzbiór składający się wyłącznie z danych kobiet. W tym celu musimy przefiltrować kolumnę płeć."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "dane['Płeć'] == 'Kobieta'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otrzymujemy serię wartości boolowskich, które identyfikują czy w danej komórce wartość płci jest równa kobiecie. Teraz możemy użyć tych danych, żeby wyświetlić tylko te wiersze, dla których jest to prawda. Możemy tej maski użyć zamiast wartości dla wierszy w metodzie loc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "dane.loc[dane['Płeć'] == 'Kobieta',:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W identyczny sposób możemy wybrać np. wszystkie obserwacje, w których mężczyźni mają poniżej 175 cm wzrostu.  \n",
    "Najpierw stworzymy zmienną zawierającą naszą maskę z wartościami boolowskimi, a potem użyjemy jej do odfiltrowania danych."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "maska = (dane['Płeć'] == 'Mężczyzna') & (dane['Wzrost'] < 175)\n",
    "maska"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.loc[maska,:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kolejnym sposobem filtrowania treści jest wybieranie wierszy/kolumn na podstawie zawartości elementów z wcześniej wskazanego zbioru. Służy do tego metoda <b>.isin( )</b>. Spróbujemy za jej pomocą wybrać tylko te wiersze, które zawierają konkretne wartości wzrostu osób badanych."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [178, 185, 159]\n",
    "dane.loc[dane['Wzrost'].isin(lista),:]"
   ]
  },
  {
   "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": [
    "## Grupowanie danych"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podstawowym narzędziem do grupowania danych będzie metoda <b>.groupby( )</b>, która posortuje dane względem wskazanej zmiennej. Co istotne, sama funkcja nie tworzy nowych zbiorów danych, a jedynie pozwala wykonać wybrane operacje na podgrupach. To, co dostajemy na końcu to wynik tych operacji dla każdej wyróżnionej podgrupy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Spróbujmy na początek podzielić nasze dane ze względu na płeć. Żeby to zrobić, przekazujemy metodzie groupby nazwę kolumny, która zawiera kategorie płci."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.groupby('Płeć')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Metoda ta zwraca nam obiekt grupujący - instrukcję, które wiersze należą do której grupy. Teraz możemy wykonać na nim odpowiednie operacje. Spróbujmy policzyć średnią dla każdej podgrupy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.groupby('Płeć').mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otrzymujemy średnią dla każdej podgrupy, a skoro mamy tylko dwie, to dostajemy dwie wartości. Warto pamiętać, że tym sposobem uzyskamy średnie ze wszystkich kolumn zawierających dane numeryczne. Nie dostaliśmy średniej z kolumny 'Pochodzenie', ponieważ jest kategorialna."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wykorzystajmy ją jednak to dalszego podziału naszych danych na mniejsze grupy. Metoda groupby przyjmuje wprawdzie tylko jeden argument, ale może on być też listą kolumn, wedle których chcemy zgrupować nasze dane. Kolejność wyboru kolumn określi też kolejność podziału.  \n",
    "Poniżej możemy zobaczyć podział na 4 podgrupy, na których użyjemy metody **describe()**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.groupby(['Pochodzenie','Płeć']).describe().unstack()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Metoda **unstack()** pozwala zamienić kolumny w rzędy. W naszym przypadku przenosimy do rzędu kolumnę ze statystykiami podanymi przez desribe. Jeśli podamy do unstack nazwę kolumny jako argument, to będziemy mogli wybrać kolumnę do przeniesienia (albo grupę kolumn). Bez podania argumentu, metoda wybierze pierwszą dostępną kolumnę."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.groupby(['Pochodzenie','Płeć']).describe().unstack(['Pochodzenie', 'Płeć'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zwizualizujmy sobie poszczególne grupy za pomocą histogramu. Będziemy do tego potrzebowali surowych danych i każdej podgrupy w osobnej kolumnie. Zobaczmy raz jeszcze, jak wyglądają same dane."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Żeby to osiągnąć będziemy musieli stworzyć nowy indeks dla danych. Chcemy podzielić dane na 4 grupy, jednak nie ma niczego, co mogłoby pomóc pandas zgrupować kilka wartości w jednym rzędzie. Dlatego przekażemy jako indeks czterokrotnie powieloną listę indeksów (w naszym przypadku od 0 do 29). Nie jest to najbardziej eleganckie rozwiązanie, ale na chwilę obecną pozwoli nam nie wychodzić poza pandas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "index = list(range(30))*4\n",
    "x = dane.set_index([index,dane.Płeć, dane.Pochodzenie])['Wzrost'].unstack(['Płeć', 'Pochodzenie'])\n",
    "x.plot.hist(figsize=(10,14), bins=8, alpha=0.7, subplots=True);\n",
    "x.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.plot.kde(figsize=(10,8));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wyciągnięcie poszczególnych grup jest możliwe poprzez użycie metody <b>.get_group( )</b>.  \n",
    "Ważne jest by zapamiętać, że przy grupowaniu więcej niż jedną zmienną, musimy też podać tyle samo wartości, co mamy grup. W poniższym przykładzie nie możemy wyłącznie wyświetlić grupy 'Kobieta', ponieważ jest ona podzielona na dwie podgrupy zgodnie z pochodzeniem. Jeśli przekazujemy do get_group więcej niż jeden argument, musimy to zrobić w krotce (okrągłe nawiasy), gdzie kolejność ma znaczenie (jeśli pierwszą zmienną kategoryzacyjną jest 'Płeć', to 'Kobieta' musi się pojawić jako pierwsza w krotce)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "dane.groupby(['Płeć','Pochodzenie']).get_group(('Kobieta', 'Polska'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wracając jeszcze na chwilę do możliwości wykonywania operacji na pogrupowanych obiektach.  \n",
    "Powyżej widzieliśmy zastosowanie metody **.mean( )**, ale dostępne są też różne inne metody, np. sumowanie, wyliczanie odchylenia standardowego, minimalnych i maksymalnych elementów itd. Ich pełną listę można znaleźć w dokumentacji pandas. Poniżej przykład podliczania ilości elementów."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.groupby(['Płeć','Pochodzenie']).count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W tym kontekście użyteczna jest metoda <b>.aggregate( )</b> lub w wersji skróconej <b>.agg( )</b>. Jeśli przekażemy im jeden argument, efekt będzie bardzo podobny do powyższego z tą różnicą, że możemy tu użyć dowolnej funkcji dostępnej w pythonie, która poradzi sobie ze zbiorem danych.\n",
    "Poniżej widzimy działanie funkcji **max** z pakietu Numpy, która wyświetla największy argument w danym zbiorze."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.groupby(['Płeć','Pochodzenie']).aggregate(np.max)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nie musimy się jednak ograniczać tylko do jednej funkcji, możemy przekazać ich kilka w liście."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dane.groupby(['Płeć','Pochodzenie']).aggregate([np.max, np.min, np.median])"
   ]
  },
  {
   "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": [
    "## Podstawowe analizy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pakiet pandas służy przede wszystkim do organizacji i manipulowania danymi tabularycznymi. Posiada trochę podstawowych funkcji wizualizacyjnych czy statystycznych, jeśli jednak chcemy wykonać nawet podstawowe testy, musimy skorzystać z innych pakietów.  \n",
    "Jednym z takich pakietów jest SciPy, biblioteka przeznaczona do różnych zastosowań naukowych. My skorzystamy z modułu stats."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.stats as st"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Najbardziej popularnym testem statystycznym jest niewątpliwie **test t**, dzięki któremu możemy oszacować prawdopodobieństwo, z jakim dwie próby pochodzą z tej samej populacji. Nasze dane pozwalają na kilka prostych porównań, dlatego spróbujemy zobaczyć czy możemy uznać, że różne nasze podgrupy są od siebie różne czy nie."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Spróbujmy najpierw zobaczyć czy kobiety i mężczyźni różnią się wzrostem. Zacznijmy od wyboru odpowiednich grup."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = pd.DataFrame({'mezczyzni':dane.loc[dane['Płeć']=='Mężczyzna','Wzrost'].values})\n",
    "test['kobiety'] = dane.loc[dane['Płeć']=='Kobieta','Wzrost'].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test.boxplot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Odpowiedni dla naszej sytuacji jest test t dla próbek indywidualnych. Właściwa funkcja użyta jest poniżej.  \n",
    "Jedyne, co musimy jej przekazać to zmienne zawierające poszczególne grupy, które chcemy porównać."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "st.ttest_ind(test.mezczyzni,test.kobiety)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from statsmodels.formula.api import ols\n",
    "from statsmodels.stats.anova import anova_lm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "formula = 'Wzrost ~ C(Płeć) + C(Pochodzenie) + C(Płeć):C(Pochodzenie)'\n",
    "model = ols(formula, dane).fit()\n",
    "aov_table = anova_lm(model, typ=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(aov_table)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import statsmodels.api as sm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "res = model.resid\n",
    "fig = sm.qqplot(res, line='s')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Excersize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "drug = pd.read_csv('./drug.txt', sep='\\t')\n",
    "drug"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Integracja z R"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import rpy2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lsmagic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%R\n",
    "data <- read.csv2('./wzrost_multi.csv',header = TRUE)\n",
    "fit <- lm(Wzrost ~ Pochodzenie*Plec, data=data)\n",
    "summary(fit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from rpy2.robjects import pandas2ri\n",
    "pandas2ri.activate()\n",
    "r_dataframe = pandas2ri.py2ri(dane)\n",
    "print(r_dataframe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import rpy2.robjects as robjects\n",
    "from rpy2.robjects.packages import importr\n",
    "stats = importr('stats')\n",
    "base = importr('base')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aov = robjects.r['aov']\n",
    "lm = robjects.r['lm']\n",
    "summary = robjects.r['summary']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fit = lm(\"1 - Wzrost ~ Pochodzenie*Płeć\",data=r_dataframe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(base.summary(fit))"
   ]
  },
  {
   "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": [
    "## Materiały do dalszej nauki"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pakiet pandas dysponuje dużo większymi możliwościami, niż przedstawione tutaj. Poniżej zebrałem kilka zasobów internetowych, które są dla mnie najbardziej przydatne przy pracy z tym pakietem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Najważniejszym źródłem informacji zawsze jest <a href=\"http://pandas.pydata.org/pandas-docs/stable/index.html\">**Oficjalna dokumentacja**</a>, a pakiet pandas jest bardzo dobrze opisany.  \n",
    "Szczególnie przydatny jest szybki przegląd najważniejszych funkcji pandas <a href=\"http://pandas.pydata.org/pandas-docs/stable/10min.html\">**na tej podstronie**</a>. W innych zakładkach najdziecie też bardziej rozbudowane przeglądy, tutoriale, zbiory gotowych \"przepisów\" na osiągnięcie konkretnych, bardziej złożonych rezultatów.\n",
    "\n",
    "Podstawowe informacje o tym, jak wykonywać bazowe operacje można mieć zawsze pod ręką w postaci tzw. cheatsheet'a.  \n",
    "Tutaj znajdziecie <a href=\"https://github.com/pandas-dev/pandas/raw/master/doc/cheatsheet/Pandas_Cheat_Sheet.pdf\">**ten oficjalny**</a>.  \n",
    "Tutaj natomiast wersja przygotowana przez <a href=\"https://assets.datacamp.com/blog_assets/PandasPythonForDataScience.pdf\">**portal DataCamp**</a>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filmy tutorialowe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Osobiście jestem wielkim fanem tutoriali w formie wideo, których sporo można znaleźć na Youtube. Z każdym rokiem pojawia się ich coraz więcej, bo bardzo często są elementem konrefencji poświęconych Pythonowi czy analizie danych. Bez problemu można je wyszukać w samym serwisie, poniżej jednak wrzucę Wam kilka linków do moich ulubionych."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bardzo dobrze prowadzony <a href=\"https://youtu.be/5JnMutdy6Fw\">**tutorial Brandona Rhodesa**</a> z 2015 roku. Z tego powodu nie ma w nim nowych funkcji, ale podstawowe operacje są ciągle aktualne i dokładnie wytłumaczone. W opisie nagrania są linki do materiałów użytych w tutorialu (tak będzie też dla prawie wszystkich materiałów wideo poniżej)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://youtu.be/6ohWS7J1hVA\">**Tutorial Johnatana Rochera**</a> z 2016 roku ma trochę szybsze tempo i porusza więcej kwestii, niemniej ciągle jest skierowany do początkujących, więc nie powinniście mieć problemu ze śledzeniem akcji."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Najnowszy <a href=\"https://youtu.be/dye7rDktJ2E\">**tutorial Daniela Chena**</a> jest trochę krótszy niż poprzednie i odwołuje się do prawie najnowszej wersji pandas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dla osób, które będą się czuć w pandas bardziej swobodnie, warty obejrzenia jest <a href=\"https://youtu.be/7vuO9QXDN50\">**tutorial Toma Augspurgera**</a>. Choć zaczyna się dość podstawowo, poziom skomplikowania dość szybko rośnie, dzięki czemu można zobaczyć bardziej zaawansowane rzeczy, które można zrobić w tym pakiecie."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tutoriale pisane"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podobnie ma się sytuacja z materiałami pisanymi. Pojawia się coraz więcej przewodników po pandas, dlatego też zostawię tutaj tylko kilka przykładów, z których albo korzystałem sam, albo wydały mi się dobre na początek przygody z tym pakietem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dwuczęściowy tutorial autorstwa Vika Paruchuri:  \n",
    "<a href=\"https://www.dataquest.io/blog/pandas-python-tutorial/\">**Część 1**</a>,\n",
    "<a href=\"https://www.dataquest.io/blog/pandas-tutorial-python-2/\">**Część 2**</a>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bardzo rozbudowany <a href=\"http://nbviewer.jupyter.org/github/fonnesbeck/Bios8366/tree/master/notebooks/\">**tutorial Chrisa Fonnesbecka**</a> powiązany z kursem zaawansowanego przetwarzania danych w pythonie. Notatniki z sekcji drugiej dotyczą różnych aspektów obsługi pakietu pandas i zawierają sporo materiałów wykraczających poza treści omawiane tutaj. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Całkiem rozbudowany <a href=\"http://tomaugspurger.github.io/modern-1.html\">**tutorial**</a> wspomnianego wcześniej Toma Augspurgera. Tutaj również znajdziecie trochę bardziej zaawansowanych materiałów."
   ]
  },
  {
   "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": "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.5"
  },
  "latex_envs": {
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 0
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}