path: root/es-es/pythonstatcomp-es.html.markdown

---
language: Statistical computing with Python
contributors:
    - ["e99n09", "https://github.com/e99n09"]
filename: pythonstatcomp-es.py
translators:
    - ["Damaso Sanoja", "https://github.com/damasosanoja"]
lang: es-es
---

Este es un tutorial de como realizar tareas típicas de programación estadística usando Python. Está destinado a personas con cierta familiaridad con Python y con experiencia en programación estadística en lenguajes como R, Stata, SAS, SPSS, or MATLAB.

```python

# 0. Cómo configurar ====

""" Configurar con IPython y pip install lo siguiente: numpy, scipy, pandas,
    matplotlib, seaborn, requests.
        Asegúrese de realizar este tutorial con el IPython notebook para tener fácil
    acceso a las ayudas en tiempo real y la documentación respectiva.
"""

# 1. Captura de datos ====

""" Muchos prefieren Python sobre R ya que quieren interactuar mucho
    con la web, bien sea haciendo webscraping o solicitando datos mediante
    un API. Esto se puede hacer en R, pero en el contexto de un proyecto
    que ya usa Python, existen beneficios al mantener un solo lenguaje.
"""

import requests # para llamados HTTP (webscraping, APIs)
import os

# webscraping
r = requests.get("https://github.com/adambard/learnxinyminutes-docs")
r.status_code # si es 200, el llamado ha sido exitoso
r.text # código fuente de la página
print(r.text) # formateado y embellecido
# graba el código fuente en un fichero:
os.getcwd() # verifica cual es el directorio de trabajo
f = open("learnxinyminutes.html","wb")
f.write(r.text.encode("UTF-8"))
f.close()

# descargando un csv
fp = "https://raw.githubusercontent.com/adambard/learnxinyminutes-docs/master/"
fn = "pets.csv"
r = requests.get(fp + fn)
print(r.text)
f = open(fn,"wb")
f.write(r.text.encode("UTF-8"))
f.close()

""" para saber más del módulo de peticiones, incluyendo APIs, ver
    http://docs.python-requests.org/en/latest/user/quickstart/
"""

# 2. Leyendo un fichero CSV ====

""" El paquete pandas de Wes McKinney brinda objetos 'DataFrame' en Python. Si
    has usado R, ya estarás familiarizado con la idea de "data.frame".
"""

import pandas as pd, numpy as np, scipy as sp
pets = pd.read_csv(fn)
pets
#       nombre edad  peso especies
# 0    fluffy     3    14      cat
# 1  vesuvius     6    23     fish
# 2       rex     5    34      dog

""" Usuarios de R: notar que Python, al igual que otros lenguajes de programación
    normales, comienza indexando desde 0. R de forma inusual comienza desde 1.
"""

# dos formas distintas de imprimir una columna
pets.age
pets["age"]

pets.head(2) # imprime las primeras dos filas
pets.tail(1) # imprime la última fila

pets.name[1] # 'vesuvius'
pets.species[0] # 'cat'
pets["weight"][2] # 34

# en R, puedes esperar obtener 3 filas haciendo esto, pero aquí obtienes 2:
pets.age[0:2]
# 0    3
# 1    6

sum(pets.age)*2 # 28
max(pets.weight) - min(pets.weight) # 20

""" Si estás procesando grandes cantidades de cálculos de álgebra lineal, podrías
    querer usar matrices, no DataFrames. Los DataFrames son ideales para combinar
    columnas de diferentes tipos.
"""

# 3. Gráficas ====

import matplotlib as mpl, matplotlib.pyplot as plt
%matplotlib inline

# Para hacer virtualización de datos en Python, usa matplotlib

plt.hist(pets.age);

plt.boxplot(pets.weight);

plt.scatter(pets.age, pets.weight); plt.xlabel("age"); plt.ylabel("weight");

# seaborn está por encima de matplotlib y logra mejores gráficos

import seaborn as sns

plt.scatter(pets.age, pets.weight); plt.xlabel("age"); plt.ylabel("weight");

# también hay algunas funciones gráficas específicas de seaborn
# nota como seaborn etiqueta automáticamente el eje x en este gráfico de barras
sns.barplot(pets["age"])

# los veteranos de R pueden seguir usando ggplot
from ggplot import *
ggplot(aes(x="age",y="weight"), data=pets) + geom_point() + labs(title="pets")
# fuente: https://pypi.python.org/pypi/ggplot

# incluso hay un porteo d3.js: https://github.com/mikedewar/d3py

# 4. Limpieza simple de datos y análisis exploratorio ====

""" Tenemos ahora un ejemplo más complicado que demuestra un flujo básico para
    limpieza de datos que lleva a la creación de algunos gráficos exploratorios
    y la ejecución de una regresión lineal.
        El conjunto de datos fue transcrito de Wikipedia a mano. Contiene
    todos los Emperadores Romanos Sagrados y fechas claves en sus vidas
    (nacimiento, muerte, coronación, etc.).
        El objetivo del análisis es explorar si existe alguna relación
    entre el año de nacimiento del Emperador y su tiempo de vida.
    fuente de datos: https://en.wikipedia.org/wiki/Holy_Roman_Emperor
"""

# cargar algunos datos de los Emperadores Romanos Sagrados
url = "https://raw.githubusercontent.com/e99n09/R-notes/master/data/hre.csv"
r = requests.get(url)
fp = "hre.csv"
f = open(fp,"wb")
f.write(r.text.encode("UTF-8"))
f.close()

hre = pd.read_csv(fp)

hre.head()
"""
   Ix      Dynasty        Name        Birth             Death Election 1  
0 NaN  Carolingian   Charles I  2 April 742    28 January 814        NaN   
1 NaN  Carolingian     Louis I          778       20 June 840        NaN   
2 NaN  Carolingian   Lothair I          795  29 September 855        NaN   
3 NaN  Carolingian    Louis II          825     12 August 875        NaN   
4 NaN  Carolingian  Charles II  13 June 823     6 October 877        NaN   

  Election 2      Coronation 1   Coronation 2 Ceased to be Emperor  
0        NaN   25 December 800            NaN       28 January 814   
1        NaN  11 September 813  5 October 816          20 June 840   
2        NaN       5 April 823            NaN     29 September 855   
3        NaN        Easter 850     18 May 872        12 August 875   
4        NaN   29 December 875            NaN        6 October 877   

  Descent from whom 1 Descent how 1 Descent from whom 2 Descent how 2  
0                 NaN           NaN                 NaN           NaN  
1           Charles I           son                 NaN           NaN  
2             Louis I           son                 NaN           NaN  
3           Lothair I           son                 NaN           NaN  
4             Louis I           son                 NaN           NaN  
"""

# limpiar las columnas de Nacimiento y Muerte

import re # módulo para expresiones regulares

rx = re.compile(r'\d+$') # coincidencia de últimos dígitos

""" Esta función aplica una expresión regular a una columna de entrada (Birth,
    Death), nivela la lista resultante, la convierte en un objeto Series, y
    finalmente convierte el tipo del objeto Series de string a entero. Para
    más información sobre que hace cada parte del código, ver:
      - 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
"""
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)

# hacer una columna decir la edad estimada
hre["EstAge"] = hre.DeathY.astype(int) - hre.BirthY.astype(int)

# gráfica de dispersión simple, sin línea de tendencia, el color representa dinastía
sns.lmplot("BirthY", "EstAge", data=hre, hue="Dynasty", fit_reg=False);

# usa scipy para hacer regresiones lineales
from scipy import stats
(slope,intercept,rval,pval,stderr)=stats.linregress(hre.BirthY,hre.EstAge)
# código fuente: http://wiki.scipy.org/Cookbook/LinearRegression

# verifica la pendiente (slope)
slope # 0.0057672618839073328

# verifica el valor R^2 :
rval**2 # 0.020363950027333586

# verifica el valor p
pval # 0.34971812581498452

# usa seaborn para hacer un gráfico de dispersión y dibujar una regresión lineal
# de la tendencia
sns.lmplot("BirthY", "EstAge", data=hre);

""" Para más información sobre seaborn, ver
      - http://web.stanford.edu/~mwaskom/software/seaborn/
      - https://github.com/mwaskom/seaborn
    Para más información sobre SciPy, ver
      - http://wiki.scipy.org/SciPy
      - http://wiki.scipy.org/Cookbook/
    Para ver una versión del análisis de los Emperadores Romanos usando R, ver
      - http://github.com/e99n09/R-notes/blob/master/holy_roman_emperors_dates.R
"""
```

Si quieres aprender más, obtén _Python for Data Analysis_ por Wes McKinney. Es un extraordinario recurso usado como referencia para escribir este tutorial.

También puedes encontrar gran cantidad de tutoriales interactivos de IPython en temas específicos a tus intereses, como Pilon de Cam Davidson <a href="http://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/" Title="Probabilistic Programming and Bayesian Methods for Hackers">Probabilistic Programming and Bayesian Methods for Hackers</a>.

Ver más módulos para investigar:
   - análisis de texto y procesamiento natural del lenguaje: nltk, http://www.nltk.org
   - análisis de redes sociales: igraph, http://igraph.org/python/