mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 09:41:36 +00:00
8.6 KiB
8.6 KiB
| contributors | translators | filename | ||||||
|---|---|---|---|---|---|---|---|---|
|
|
pythonstatcomp-pt.py |
Este é um tutorial sobre como fazer algumas tarefas típicas de programação estatística usando Python. É destinado basicamente à pessoas familizarizadas com Python e experientes com programação estatística em linguagens como R, Stata, SAS, SPSS ou MATLAB.
# 0. Preparando-se ====
""" Para começar, instale o seguinte : jupyther, numpy, scipy, pandas,
matplotlib, seaborn, requests.
Certifique-se de executar este tutorial utilizando o Jupyther notebook para
que você utilize os gráficos embarcados e ter uma fácil consulta à
documentação.
O comando para abrir é simplesmente '`jupyter notebook`, quando abrir então
clique em 'New -> Python'.
"""
# 1. Aquisição de dados ====
""" A única razão das pessoas optarem por Python no lugar de R é que pretendem
interagir com o ambiente web, copiando páginas diretamente ou solicitando
dados utilizando uma API. Você pode fazer estas coisas em R, mas no
contexto de um projeto já usando Python, há uma vantagem em se ater uma
linguágem única.
"""
import requests # para requisições HTTP (web scraping, APIs)
import os
# web scraping
r = requests.get("https://github.com/adambard/learnxinyminutes-docs")
r.status_code # se retornou código 200, a requisição foi bem sucedida
r.text # código fonte bruto da página
print(r.text) # formatado bonitinho
# salve a o código fonte d apágina em um arquivo:
os.getcwd() # verifique qual é o diretório de trabalho
with open("learnxinyminutes.html", "wb") as f:
f.write(r.text.encode("UTF-8"))
# Baixar um arquivo csv
fp = "https://raw.githubusercontent.com/adambard/learnxinyminutes-docs/master/"
fn = "pets.csv"
r = requests.get(fp + fn)
print(r.text)
with open(fn, "wb") as f:
f.write(r.text.encode("UTF-8"))
""" para mais informações sobre o módulo de solicitações, incluindo API's, veja em
http://docs.python-requests.org/en/latest/user/quickstart/
"""
# 2. Lendo um arquivo formato CSV ====
""" Um pacote de pandas da Wes McKinney lhe dá um objeto 'DataFrame' em Python.
Se você já usou R, já deve estar familiarizado com a ideia de "data.frame".
"""
import pandas as pd
import numpy as np
import scipy as sp
pets = pd.read_csv(fn)
pets
# name age weight species
# 0 fluffy 3 14 cat
# 1 vesuvius 6 23 fish
# 2 rex 5 34 dog
""" Usuários R: observe que o Python, como a maioria das linguagens de programação
influenciada pelo C, a indexação começa de 0. Em R, começa a indexar em 1
devido à influência do Fortran.
"""
# duas maneiras diferentes de imprimir uma coluna
pets.age
pets["age"]
pets.head(2) # imprima as 2 primeiras linhas
pets.tail(1) # imprima a última linha
pets.name[1] # 'vesuvius'
pets.species[0] # 'cat'
pets["weight"][2] # 34
# Em R, você esperaria obter 3 linhas fazendo isso, mas aqui você obtem 2:
pets.age[0:2]
# 0 3
# 1 6
sum(pets.age) * 2 # 28
max(pets.weight) - min(pets.weight) # 20
""" Se você está fazendo alguma álgebra linear séria e processamento de
números você pode desejar apenas arrays, não DataFrames. DataFrames são
ideais para combinar colunas de diferentes tipos de dados.
"""
# 3. Gráficos ====
import matplotlib as mpl
import matplotlib.pyplot as plt
%matplotlib inline
# Para fazer a visualiação de dados em Python, use matplotlib
plt.hist(pets.age);
plt.boxplot(pets.weight);
plt.scatter(pets.age, pets.weight)
plt.xlabel("age")
plt.ylabel("weight");
# seaborn utiliza a biblioteca do matplotlib e torna os enredos mais bonitos
import seaborn as sns
plt.scatter(pets.age, pets.weight)
plt.xlabel("age")
plt.ylabel("weight");
# também existem algumas funções de plotagem específicas do seaborn
# observe como o seaborn automaticamenteo o eixto x neste gráfico de barras
sns.barplot(pets["age"])
# Veteranos em R ainda podem usar o ggplot
from ggplot import *
ggplot(aes(x="age",y="weight"), data=pets) + geom_point() + labs(title="pets")
# fonte: https://pypi.python.org/pypi/ggplot
# há até um d3.js veja em: https://github.com/mikedewar/d3py
# 4. Limpeza de dados simples e análise exploratória ====
""" Aqui está um exemplo mais complicado que demonstra dados básicos
fluxo de trabalho de limpeza levando à criação de algumas parcelas
e a execução de uma regressão linear.
O conjunto de dados foi transcrito da Wikipedia à mão. Contém
todos os sagrados imperadores romanos e os marcos importantes em suas vidas
(birth, death, coronation, etc.).
O objetivo da análise será explorar se um relacionamento existe
entre o ano de nascimento (birth year) e a expectativa de vida (lifespam)
do imperador.
Fonte de dados: https://en.wikipedia.org/wiki/Holy_Roman_Emperor
"""
# carregue alguns dados dos sagrados imperadores romanos
url = "https://raw.githubusercontent.com/adambard/learnxinyminutes-docs/master/hre.csv"
r = requests.get(url)
fp = "hre.csv"
with open(fp, "wb") as f:
f.write(r.text.encode("UTF-8"))
hre = pd.read_csv(fp)
hre.head()
"""
Ix Dynasty Name Birth Death
0 NaN Carolingian Charles I 2 April 742 28 January 814
1 NaN Carolingian Louis I 778 20 June 840
2 NaN Carolingian Lothair I 795 29 September 855
3 NaN Carolingian Louis II 825 12 August 875
4 NaN Carolingian Charles II 13 June 823 6 October 877
Coronation 1 Coronation 2 Ceased to be Emperor
0 25 December 800 NaN 28 January 814
1 11 September 813 5 October 816 20 June 840
2 5 April 823 NaN 29 September 855
3 Easter 850 18 May 872 12 August 875
4 29 December 875 NaN 6 October 877
"""
# limpar as colunas Birth e Death
import re # módulo para expressões regulares
rx = re.compile(r'\d+$') # conincidir com os códigos finais
""" Esta função aplia a expressão reguar a uma coluna de entrada (here Birth,
Death), nivela a lista resultante, converte-a em uma lista de objetos, e
finalmente converte o tipo do objeto da lista de String para inteiro. para
mais informações sobre o que as diferentes partes do código fazer, veja em:
- https://docs.python.org/2/howto/regex.html
- http://stackoverflow.com/questions/11860476/how-to-unlist-a-python-list
- http://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.html
"""
from functools import reduce
def extractYear(v):
return(pd.Series(reduce(lambda x, y: x + y, map(rx.findall, v), [])).astype(int))
hre["BirthY"] = extractYear(hre.Birth)
hre["DeathY"] = extractYear(hre.Death)
# faça uma coluna infomrnado a idade estimada ("EstAge")
hre["EstAge"] = hre.DeathY.astype(int) - hre.BirthY.astype(int)
# gráfico de dispersão simples, sem linha de tendência, cor representa dinastia
sns.lmplot("BirthY", "EstAge", data=hre, hue="Dynasty", fit_reg=False)
# use o scipy para executar uma regrassão linear
from scipy import stats
(slope, intercept, rval, pval, stderr) = stats.linregress(hre.BirthY, hre.EstAge)
# código fonte: http://wiki.scipy.org/Cookbook/LinearRegression
# varifique o declive (slope)
slope # 0.0057672618839073328
# varifique o valor R^2:
rval**2 # 0.020363950027333586
# varifique o valor p-value
pval # 0.34971812581498452
# use o seaborn para fazer um gráfico de dispersão e traçar a linha de tendência de regrassão linear
sns.lmplot("BirthY", "EstAge", data=hre)
""" Para mais informações sobre o seaborn, veja
- http://web.stanford.edu/~mwaskom/software/seaborn/
- https://github.com/mwaskom/seaborn
Para mais informações sobre o SciPy, veja
- http://wiki.scipy.org/SciPy
- http://wiki.scipy.org/Cookbook/
Para ver uma versão da análise dos sagrados imperadores romanos usando R, consulte
- http://github.com/e99n09/R-notes/blob/master/holy_roman_emperors_dates.R
"""
Se você quiser saber mais, obtenha o Python para análise de dados de Wes McKinney. É um excelente recurso e usei-o como referência ao escrever este tutorial.
Você também pode encontrar muitos tutoriais interativos de IPython sobre assuntos específicos de seus interesses, como Cam Davidson-Pilon's Programação Probabilística e Métodos Bayesianos para Hackers.
Mais alguns módulos para pesquisar: