2020-10-21 05:18:37 +03:00
---
2024-04-15 02:39:27 +03:00
category: framework
2024-10-21 00:46:35 +03:00
framework: Statistical computing with Python
2020-10-21 05:18:37 +03:00
contributors:
- ["e99n09", "https://github.com/e99n09"]
translators:
- ["waltercjunior", "https://github.com/waltercjunior"]
2022-07-10 13:14:08 +03:00
filename: pythonstatcomp-pt.py
2022-07-12 00:33:07 +03:00
lang: pt-br
2020-10-21 05:18:37 +03:00
---
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.
```python
# 0. Preparando-se ====
2024-06-03 22:31:20 +03:00
""" Para começar, instale o seguinte : jupyther, numpy, scipy, pandas,
2020-10-21 05:18:37 +03:00
matplotlib, seaborn, requests.
Certifique-se de executar este tutorial utilizando o Jupyther notebook para
2024-06-03 22:31:20 +03:00
que você utilize os gráficos embarcados e ter uma fácil consulta à
2020-10-21 05:18:37 +03:00
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
2024-06-03 22:31:20 +03:00
dados utilizando uma API. Você pode fazer estas coisas em R, mas no
2020-10-21 05:18:37 +03:00
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
2024-06-03 22:31:20 +03:00
""" Usuários R: observe que o Python, como a maioria das linguagens de programação
2020-10-21 05:18:37 +03:00
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
2024-06-03 22:31:20 +03:00
""" Se você está fazendo alguma álgebra linear séria e processamento de
2020-10-21 05:18:37 +03:00
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.
2024-06-03 22:31:20 +03:00
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 ](http://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/ ).
2020-10-21 05:18:37 +03:00
Mais alguns módulos para pesquisar:
2024-06-03 22:31:20 +03:00
- análise de texto e processamento de linguagem natural: [nltk ](http://www.nltk.org )
- análise de rede social: [igraph ](http://igraph.org/python/ )