Exemplos AED.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Análise Estatística de Dados\n",
    "## Pós Graduação em Ciência de Dados e Big Data - PUC Minas\n",
    "\n",
    "Datasets:\n",
    "* https://www.kaggle.com/PromptCloudHQ/imdb-data\n",
    "\n",
    "Referências:\n",
    "* http://www.scipy-lectures.org/packages/statistics/index.html\n",
    "\n",
    "Dicas:\n",
    "* https://github.com/JosPolfliet/pandas-profiling\n",
    "\n",
    "### Índice:\n",
    "* [Tabelas de frequências](#Resumo-de-dados-com-tabelas-de-frequências)\n",
    "* [Medidas de Tendência Central](#Medidas-de-tendência-central)\n",
    "    * [Média](#Média)\n",
    "    * [Mediana](#Mediana)\n",
    "    * [Moda](#Moda)\n",
    "* [Medidas de posição](#Medidas-de-posição)\n",
    "    * [Separatrizes](#Separatrizes)\n",
    "    * [Score z](#Score-z)\n",
    "* [Medidas de dispersão](#Medidas-de-dispersão)\n",
    "    * [Amplitude](#Amplitude)\n",
    "    * [Desvio padrão](#Desvio-padrão)\n",
    "* [Correlação](#Correlação)\n",
    "* [Representações gráficas](#Representações-gráficas)\n",
    "    * [Gráfico de linhas](#Gráfico-de-linhas)\n",
    "    * [Gráfico de barras](#Gráfico-de-barras)\n",
    "    * [Gráfico de setores](#Gráfico-de-setores)\n",
    "    * [Histograma](#Histograma)\n",
    "    * [Diagrama de dispersão](#Diagrama-de-dispersão)\n",
    "    * [Boxplot](#Boxplot)\n",
    "* [Probabilidades](#Probabilidades)\n",
    "    * [Simulações](#Simulações)\n",
    "    * [O problema de Monty Hall](#O-problema-de-Monty-Hall)\n",
    "* [Inferência](#Inferência)\n",
    "    * [Intervalos de confiança](#Intervalos-de-confiança)\n",
    "    * [Testes de hipóteses](#Testes-de-hipóteses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import math\n",
    "import random\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import style\n",
    "import pandas as pd\n",
    "import scipy\n",
    "import scipy.stats\n",
    "import numpy as np\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "imdb_data = pd.read_csv('datasets/IMDB-Movie-Data.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "imdb_data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "imdb_data.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "imdb_data['main_genre'] = imdb_data.Genre.apply(lambda x: x.split(',')[0]).values\n",
    "imdb_data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resumo de dados com tabelas de frequências\n",
    "\n",
    "### Dados discretos: Gênero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# O método value_counts de um pandas DataFrame ou pandas Series retorna os valores e a frequência\n",
    "#  de ocorrência dos mesmos ordenado do mais frequente para o menos frequente\n",
    "\n",
    "imdb_data.main_genre.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Para a frequência relativa é só usar o parâmetro normalize=True\n",
    "\n",
    "imdb_data.main_genre.value_counts(normalize=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Pandas possui a função cumsum() para fazer a soma cumulativa\n",
    "# Com isso podemos fazer a Frequência acumulada\n",
    "\n",
    "imdb_data.main_genre.value_counts().cumsum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Gerando um DataFrame com todas essas frequências\n",
    "pd.DataFrame({'Fa': imdb_data.main_genre.value_counts(),\n",
    "              'Fac': imdb_data.main_genre.value_counts().cumsum(),\n",
    "              'Fr': imdb_data.main_genre.value_counts(normalize=True)})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dados contínuos: Rating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import math\n",
    "n = imdb_data.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Para dados contínuos precisamos definir os limites de classes ou, ao menos, a quantidade de classes\n",
    "\n",
    "# Calculando apenas a quantidade de classes através da raiz de n\n",
    "# Usamos o sort=False para que os dados fiquem ordenados pela classe e não pela frequência\n",
    "# Passamos também o parâmetro bins com a quantidade de classes\n",
    "imdb_data.Rating.value_counts(sort=False, bins=math.sqrt(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Uma outra forma mais \"bonitinha\" é usar a função pd.cut\n",
    "# \n",
    "# Esta função identifica em qual bin está o dado. Porém ela retorna uma pd.Series com os bins \n",
    "# onde os dados estão. Temos, então, que fazer o value_counts.\n",
    "\n",
    "pd.cut(imdb_data.Rating, bins=math.sqrt(n)).value_counts(sort=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Outra vantagem do pd.cut é que podemos passar os limites das classes e não apenas o intervalo de classes.\n",
    "\n",
    "# Vamos calcular \"na unha\" as classes para a coluna Rating\n",
    "k = math.sqrt(n)\n",
    "k = 20 if k > 20 else int(k) # Limita a quantidade de classes em 20. Opcional\n",
    "h = (imdb_data.Rating.max() - imdb_data.Rating.min()) / (k - 1)\n",
    "bins = [imdb_data.Rating.min() - h/2]\n",
    "for i in range(k):\n",
    "    bins.append(bins[i] + h)\n",
    "pd.cut(imdb_data.Rating, bins).value_counts(sort=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# A função pd.cut é útil para transformar uma variável contínua em discreta no seu DataFrame\n",
    "\n",
    "imdb_data['Rating Bin'] = pd.cut(imdb_data.Rating, bins)\n",
    "imdb_data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Voltar](#Índice:)\n",
    "\n",
    "## Medidas de tendência central\n",
    "\n",
    "### Média"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# pandas DataFrames e pandas Series têm métodos específicos para calcular a média das colunas\n",
    "\n",
    "imdb_data.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Se, por algum motivo, quiser calcular a média das linhas\n",
    "\n",
    "imdb_data.mean(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Se não for um pandas DataFrame, precisa da biblioteca Numpy para alta performance\n",
    "# ou do módulo statistics sem precisar instalar nada\n",
    "\n",
    "import numpy as np\n",
    "import statistics\n",
    "\n",
    "data_list_ímpar = [1, 2, 3, 4, 5]\n",
    "data_list_par = [1, 2, 3, 4]\n",
    "\n",
    "print(np.mean(data_list_ímpar))\n",
    "print(np.mean(data_list_par))\n",
    "print(statistics.mean(data_list_ímpar))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Cuidado com os missings. \n",
    "statistics.mean(imdb_data.Metascore)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# numpy.mean já resiste bem aos missings\n",
    "np.mean(imdb_data.Metascore)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Gerando dados para comparar a performance\n",
    "big_data = [random.gauss(0, 1) for i in range(1000000)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%timeit\n",
    "np.mean(big_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%timeit\n",
    "statistics.mean(big_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Propriedades algébricas da média"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "big_média = np.mean(big_data)\n",
    "desvios = [data - big_média for data in big_data]\n",
    "print(\"Soma dos desvios em relação à média: {:0.8f}\".format(sum(desvios)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "constantes = [random.gauss(0, 0.1) for i in range(10)]\n",
    "\n",
    "for constante in constantes:\n",
    "    print(\"Soma dos quadrados dos desvios em relação a {:0.3f}: {:0.8f}\".format(constante,\n",
    "                                                                                sum([(data - constante)**2 for data in big_data])))\n",
    "    \n",
    "print(\"Soma dos quadrados dos desvios em relação à média: {:0.8f}\".format(constante,\n",
    "                                                                            sum([(data - big_média)**2 for data in big_data])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(\"Média dos dados:\", big_média)\n",
    "média3 = np.mean([np.multiply(data, 3) for data in big_data])\n",
    "print(\"Média dos dados multiplicados por três:\", média3)\n",
    "print(\"Diferença entre essa média e big_média x 3:\", média3 - (big_média * 3.0))\n",
    "print('Essa média é \"igual\" a big_média x 3?', math.isclose(média3, big_média*3))\n",
    "print()\n",
    "média2 = np.mean([data/2 for data in big_data])\n",
    "print(\"Média dos dados divididos por dois:\", média2)\n",
    "print(\"Diferença entre essa média e big_média / 2:\", média2 - big_média/2)\n",
    "print('Essa média é \"igual\" a big_média / 2?', math.isclose(média2, big_média/2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mediana"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Mesma coisa com a mediana\n",
    "imdb_data.median()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(np.median(data_list_ímpar))\n",
    "print(np.median(data_list_par))\n",
    "print(statistics.median(data_list_par))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Cuidado com dados faltantes\n",
    "\n",
    "np.median(imdb_data.Metascore)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Pra isso numpy tem uma série de métodos que começam com numpy.nan\n",
    "np.nanmedian(imdb_data.Metascore)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Como a média e a mediana se comportam com dados extremos?\n",
    "data = [2, 3, 4, 2, 3, 1, 3]\n",
    "print(\"Média de {}: {:0.2f}\".format(data, np.mean(data)))\n",
    "print(\"Mediana de {}: {}\".format(data, np.median(data)))\n",
    "data_extremo = data + [1000]\n",
    "print(\"Média de {}: {}:\".format(data_extremo, np.mean(data_extremo)))\n",
    "print(\"Mediana de {}: {}\".format(data_extremo, np.median(data_extremo)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Moda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "imdb_data.mode()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Numpy não tem um método para cálculo da moda. Esse método está no módulo scipy.stats\n",
    "from scipy import stats\n",
    "moda = stats.mode(['a', 'b', 'c', 'd', 'e', 'e', 'f', 'f', 'f', 'g', 'h'])\n",
    "print(\"Moda: {[0]}\".format(moda))\n",
    "print(\"Frequência: {[1]}\".format(moda))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "statistics.mode(['a', 'b', 'c', 'd', 'e', 'e', 'f', 'f', 'f', 'g', 'h'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# O problema do método mode do módulo statistics é que se existir mais de uma moda\n",
    "# o código gera uma exceção\n",
    "\n",
    "\n",
    "statistics.mode(['a', 'b', 'c', 'd', 'e', 'e', 'f', 'f', 'g', 'g', 'h'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Numpy/Scipy retornam a primeira moda, não retornam todas 😒\n",
    "stats.mode(['a', 'b', 'c', 'd', 'e', 'e', 'f', 'f', 'g', 'g', 'h'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%timeit\n",
    "statistics.mode([1, 2, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 7, 7, 8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%timeit\n",
    "stats.mode([1, 2, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 7, 7, 8])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Medidas de posição\n",
    "### Separatrizes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# No método quantile do pandas DataFrame ou pandas Series o percentil vai de 0 a 1\n",
    "imdb_data.quantile(0.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# No numpy.percentile ou numpy.nanpercentile já é de 0 a 100\n",
    "np.nanpercentile(imdb_data['Revenue (Millions)'], 25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "data_list_par"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Comparando o manual com o automático\n",
    "\n",
    "#Usando a interpolação 'midpoint' para comparar com o que nós convencionamos\n",
    "np.percentile(data_list_par, 75, interpolation='midpoint')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Fazendo 'na unha'\n",
    "\n",
    "\n",
    "def percentil(data, i):\n",
    "    n = len(data)\n",
    "    # Econtrando a posição\n",
    "    P = i * (n + 1) / 100\n",
    "    if P == int(P):\n",
    "        percent = data[P-1]\n",
    "    else:\n",
    "        P = int(P)\n",
    "        percent = (data[P-1] + data[P])/2\n",
    "\n",
    "    return percent\n",
    "\n",
    "percentil(data_list_par, 75)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "percentil(data_list_ímpar, 75)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "np.percentile(data_list_ímpar, 75)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "data_list_ímpar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### _Score_ z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# O pandas não tem uma função pronta mas é relativamente fácil fazer a transformação\n",
    "imdb_data[['Runtime (Minutes)', 'Rating', 'Votes',\n",
    "       'Revenue (Millions)', 'Metascore']].apply(lambda col: (col - col.mean())/col.std())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Numpy também não, então tem que apelar para o scipy.stats\n",
    "# O problema é que ele não consegue as colunas com missing\n",
    "\n",
    "print(stats.zscore(imdb_data[['Runtime (Minutes)', 'Rating', 'Votes',\n",
    "       'Revenue (Millions)', 'Metascore']], ddof=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Neste caso a melhor opção é usar o scikit-learn pois ele armazena\n",
    "# a média e o desvio padrão usados na transformação\n",
    "\n",
    "# O 'problema' é que não aceita valores missing....\n",
    "\n",
    "from sklearn import preprocessing\n",
    "\n",
    "# Cria a instância do objeto StandardScaler\n",
    "zscorer = preprocessing.StandardScaler()\n",
    "\n",
    "# Armazena os dados de média e desvio padrão das colunas\n",
    "zscorer.fit(imdb_data[['Runtime (Minutes)', 'Rating', 'Votes']])\n",
    "\n",
    "# Efetivamente aplica a transformação utilizando a média e desvio armazenados\n",
    "# Você pode aplicar o método transform em bases futuras com as mesmas variáveis!\n",
    "zscorer.transform(imdb_data[['Runtime (Minutes)', 'Rating', 'Votes']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Medidas de dispersão\n",
    "### Amplitude"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# pandas não nos fornece um método para calcular a amplitude...\n",
    "\n",
    "imdb_data[['Rank', 'Year', 'Runtime (Minutes)', 'Rating', 'Votes',\n",
    "       'Revenue (Millions)', 'Metascore']].apply(lambda col: col.max() - col.min())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# numpy.ptp não funcionou diretamente com o DataFrame. Tive que transformar em um array\n",
    "\n",
    "# Novamente o problema com os dados faltantes\n",
    "np.ptp(imdb_data[['Rank', 'Year', 'Runtime (Minutes)', 'Rating', 'Votes', 'Revenue (Millions)', 'Metascore']].values, axis=0)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Desvio padrão"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Aqui aparece a questão do ddof. O denominador da fórmula do\n",
    "# desvio padrão é n-ddof. Como na fórmula que definimos o\n",
    "# denominador é n-1 recomendo usar ddof=1; mas só para efeitos\n",
    "# acadêmicos. Para efeitos práticos em um projeto de DS pode\n",
    "# deixar ddof=0 pois o desvio padrão nesses casos é um orientador\n",
    "# e não um número sobre o qual efetivamente se tomarão decisões\n",
    "# erradas com base em diferenças na segunda ou terceira casa decimal\n",
    "\n",
    "imdb_data.std(ddof=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "np.std(imdb_data.Metascore, ddof=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "np.std([1, 2, 3, 4], ddof=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "k = [1, 2, 3, 4]\n",
    "np.sqrt(sum([(i-2.5)**2 for i in k])/3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Correlação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "imdb_data[['Year', 'Runtime (Minutes)', 'Rating', 'Votes', 'Revenue (Millions)', 'Metascore']].corr()"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}