import pandas as pd
import sys
import datetime as dt
import numpy as np
import matplotlib.pyplot as plt
import matplotlib

%matplotlib inline

print("Versión de Python:     ", sys.version)
print("Versión de Pandas:     ", pd.version.short_version)
print("Versión de Numpy:      ", np.version.short_version)
print("Versión de Matplotlib: ", matplotlib.__version__)

from IPython.display import HTML
HTML("<iframe src=http://pandas.pydata.org width=800 height=350></iframe>")

# serie con índices automáticos
serie = pd.Series(np.random.randn(10))
print(u'Serie con índices automáticos \n{} \n'.format(serie))
print(type(serie))

# serie con índices definidos por mi
serie = pd.Series(np.random.randn(4), index = ['itzi','kikolas','dieguete','nicolasete'])
print(u'Serie con índices definidos \n{} \n'.format(serie))
print(type(serie))

# serie(serie temporal) con índices que son fechas
serie = pd.Series(np.random.randn(31), index = pd.date_range('2013/01/01', periods = 31))
print(u'Serie temporal con índices de fechas \n{} \n'.format(serie))
print(type(serie))

serie_lista = pd.Series([i*i for i in range(10)])
print('Serie a partir de una lista \n{} \n'.format(serie_lista))

dicc = {'cuadrado de {}'.format(i) : i*i for i in range(10)}
serie_dicc = pd.Series(dicc)
print('Serie a partir de un diccionario \n{} \n'.format(serie_dicc))

serie_serie = pd.Series(serie_dicc.values)
print('Serie a partir de los valores de otra (pandas)serie \n{} \n'.format(serie_serie))

serie_cte = pd.Series(-999, index = np.arange(10))
print('Serie a partir de un valor constante \n{} \n'.format(serie_cte))

#...

serie = pd.Series(np.random.randn(10), index = ['a','b','c','d','e','f','g','h','i','j'])
print('Serie que vamos a usar en este ejemplo: \n{}\n\n'.format(serie))

# Ejemplos de comportamiento como numpy array
print('Se comporta como un numpy array:')
print('================================')
print('>>> serie.max()\n{}'.format(serie.max()))
print('>>> serie.sum()\n{}'.format(serie.sum()))
print('>>> serie.abs()\n{}'.format(serie.abs()))
print('>>> serie[serie > 0]\n{}'.format(serie[serie > 0]))
#...

print('\n')

# Ejemplos de comportamiento como diccionario
print("Se comporta como un diccionario:")
print("================================")
print(">>> serie['a']\n{}".format(serie['a']))
print(">>> 'a' in serie\n{}".format('a' in serie))
print(">>> 'z' in serie\n{}".format('z' in serie))

s1 = serie[1:]
s2 = serie[:-1]
suma = s1 + s2
print('       s1                      s2                  s1 + s2')
print('------------------     ------------------     ------------------')
for clave in sorted(set(list(s1.keys()) + list(s2.keys()))):
    print('{0:1}  {1:20}  +  {0:1}  {2:20}  =  {0:1}  {3:20}'.format(clave, 
                                                                     s1.get(clave), 
                                                                     s2.get(clave), 
                                                                     suma.get(clave)))
# En la anterior línea de código uso el método get para no obtener un KeyError 
# como sí obtendría si uso, p.e., s1['a']

df_lista = pd.DataFrame({'a': [11,12,13], 'b': [21,22,23]})
print('DataFrame a partir de un diccionario de listas \n{} \n'.format(df_lista))

df_np1D = pd.DataFrame({'a': np.arange(3)**2, 'b': np.random.randn(3)})
print('DataFrame a partir de un diccionario de 1D ndarrays \n{} \n'.format(df_np1D))

df_np2D = pd.DataFrame(np.empty((5,3)), 
                       index = ['primero','segundo','tercero','cuarto','quinto'], 
                       columns = ['velocidad', 'temperatura','presion'])
print('DataFrame a partir de un 2D ndarray \n{} \n'.format(df_np2D))

df_df = pd.DataFrame(df_np2D, index = ['primero','segundo','tercero'])
df_df.index = ['first','second','third']
print('DataFrame a partir de los valores de otro (pandas)DataFrame \n{} \n'.format(df_df))

#...

%%writefile dummy.data
cabecero estúpido
901001 0000  7.54 -11.67  1.07  4.27
901001 0600 19.61 -2.74 27.87 -8.96
901001 1200 -4.34  0.73 -6.58  0.17
901001 1800 -4.99  3.24 10.62 -6.13
901002 0000 -3.54 10.39 -12.05 -13.35
901002 0600 12.55  3.80  4.92 -8.18
901002 1200 1.06 23.75 -8.03 -8.67
901002 1800 -1.12  1.82  7.09 -6.06
901003 0600 -5.90  2.38 19.33  6.84
901003 1200 -9.51 -2.72 -7.13 -0.35
901003 1800  6.49 -12.01 -13.62 -0.93

data = pd.read_csv('dummy.data', sep = '\s*', 
                   names = ['fecha', 'hora', 'rec1', 'rec2', 'rec3', 'rec4'],
                   skiprows = 1, parse_dates = [[0, 1]], index_col = 0)

print(data)

data.index

data.columns

#data[data.index >= dt.datetime(1990, 10, 2)]
data[data.index >= "1990-10-02"]

data.to_csv('dummy.csv')

%load dummy.csv

fecha_hora,rec1,rec2,rec3,rec4
1990-10-01 00:00:00,7.54,-11.67,1.07,4.27
1990-10-01 06:00:00,19.61,-2.74,27.87,-8.96
1990-10-01 12:00:00,-4.34,0.73,-6.58,0.17
1990-10-01 18:00:00,-4.99,3.24,10.62,-6.13
1990-10-02 00:00:00,-3.54,10.39,-12.05,-13.35
1990-10-02 06:00:00,12.55,3.8,4.92,-8.18
1990-10-02 12:00:00,1.06,23.75,-8.03,-8.67
1990-10-02 18:00:00,-1.12,1.82,7.09,-6.06
1990-10-03 06:00:00,-5.9,2.38,19.33,6.84
1990-10-03 12:00:00,-9.51,-2.72,-7.13,-0.35
1990-10-03 18:00:00,6.49,-12.01,-13.62,-0.93

df = pd.DataFrame(np.random.randn(5,3), 
                       index = ['primero','segundo','tercero','cuarto','quinto'], 
                       columns = ['velocidad', 'temperatura','presion'])
df['velocidad']

# Forma alternativa
df.velocidad

df['velocidad_maxima'] = np.random.randn(df.shape[0])
print(df)

# forma 1 (borramos la columna 'velocidad_maxima' que está al final del df usando del)
#         (Colocamos la columna eliminada en la posición que especifiquemos)
print(df)
columna = df['velocidad_maxima']
del df['velocidad_maxima']
print(df)
print(columna)
df.insert(1, 'velocidad_maxima', columna)
print(df)

# forma 2 (borramos usando el método pop y añadimos la columna borrada en la última posición de nuevo)
print(df)
columna = df.pop('velocidad_maxima')
print(df)
print(columna)
df.insert(3, 'velocidad_maxima', columna)
print(df)

print('Seleccionamos la columna de velocidades')
print(df['velocidad'])

print(u'Seleccionamos todas las columnas cuyo índice es igual a tercero')
print(df.xs('tercero'))

print(u'Seleccionamos todas las columnas cuyo índice está entre tercero y quinto')
print(u'Daos cuenta que en este caso los índices son inclusivos')
print(df.ix['tercero':'quinto'])

print(u'Seleccionamos todos los valores de velocidad donde la temperatura > 0')
print(df[df['temperatura'] > 0]['velocidad'])

print('Seleccionamos todos los valores de una columna por índice usando una')
print('rebanada (slice) de enteros')
print('Daos cuenta que en este caso el límite superior de la rebanada no se')
print('incluye (Python tradicional)')
print(df.ix[1:3])

print(u'Seleccionamos filas y columnas')
print(df.ix[1:3, ['velocidad', 'presion']])

# Algunas de las cosas anteriores se pueden realizar sin usar los métodos .ix() o .xs()
print(df['velocidad'][1:3])

# Da igual si colocamos el slice primero y después las columnas:
df['velocidad'][1:3] == df[1:3]['velocidad']

# Vista, ¡Cuidado!
a = np.random.rand(5)
data = a[0:2]
data[:] = -999
print(a)

# Copias
a = np.random.rand(5)
data = a[0:2].copy()
data[:] = -999
print(a)

a = np.random.rand(5)
data = 1 * a[0:2]
data[:] = -999
print(a)

a = np.random.rand(5)
np.copyto(data, a[0:2]) # En este caso, data tiene que existir
data[:] = -999
print(a)

a = np.random.rand(5)
data = np.array(a[0:2])
data[:] = -999
print(a)

df.index

df.columns

datos1 = pd.DataFrame(np.random.randn(5,3))
datos2 = pd.DataFrame(np.random.randn(5,3))
piezas = [datos1, datos2]
datos_concatenados_a = pd.concat(piezas)
print('datos1\n {}'.format(datos1))
print('datos2\n {}'.format(datos2))
print('datos_concatenados\n {}'.format(datos_concatenados_a))

datos_concatenados_a.ix[0]

datos_concatenados_aa = datos_concatenados_a
datos_concatenados_aa.index = range(datos_concatenados_aa.shape[0])
print('datos_concatenados\n {}'.format(datos_concatenados_aa))

datos_concatenados_aa = pd.concat(piezas, ignore_index = True)
print(datos_concatenados_aa)

#datos1 = pd.DataFrame(np.random.randn(5,3))
#datos2 = pd.DataFrame(np.random.randn(5,3))
#piezas = [datos1, datos2]
datos_concatenados_b = pd.concat(piezas, keys = ['datos1', 'datos2'])
print('datos1\n {}'.format(datos1))
print('datos2\n {}'.format(datos2))
print('datos_concatenados\n {}'.format(datos_concatenados_b))

print(datos_concatenados_b.ix['datos1'].ix[0])

print(datos_concatenados_b.ix['datos1'][0])

datos_concatenados_b.index

datos1 = pd.DataFrame(np.random.randn(5,3))
datos2 = pd.DataFrame(np.random.randn(5,4))
piezas = [datos1, datos2]
datos_concatenados_c = pd.concat(piezas, ignore_index = True)
print('datos1\n {}'.format(datos1))
print('datos2\n {}'.format(datos2))
print('datos_concatenados\n {}'.format(datos_concatenados_c))

datos1 = pd.DataFrame(np.random.randn(5,3))
datos2 = pd.DataFrame(np.random.randn(5,4))
datos_concatenados_d = datos1.append(datos2, ignore_index = True)
print('datos1\n {}'.format(datos1))
print('datos2\n {}'.format(datos2))
print('datos_concatenados\n {}'.format(datos_concatenados_d))

datos1 = pd.DataFrame(np.random.randn(10), columns = ['columna1'])
datos2 = pd.DataFrame(np.random.randn(14), columns = ['columna2'], index = np.arange(1,15))
datos1j = datos1.join(datos2)
datos2j = datos2.join(datos1)
print('datos1j \n{}\n'.format(datos1j))
print('datos2j \n{}'.format(datos2j))

datos3j1 = datos1.join(datos2, how = 'outer')
datos3j2 = datos2.join(datos1, how = 'outer')
print('datos3j1 \n{}\n'.format(datos3j1))
print('datos3j2 recolocados\n{}\n'.format(datos3j2.ix[:, ['columna1','columna2']]))
print('datos3j2 \n{}'.format(datos3j2))

datos4j1 = datos1.join(datos2, how = 'inner')
datos4j2 = datos2.join(datos1, how = 'inner')
print('datos4j1 \n{}\n'.format(datos4j1))
print('datos4j2 recolocados\n{}\n'.format(datos4j2.ix[:, ['columna1','columna2']]))
print('datos4j2 \n{}'.format(datos4j2))

datos1 = pd.DataFrame(np.random.randn(10), columns = ['columna1'])
datos1['otra_columna'] = ['hola', 'mundo'] * 5
datos2 = pd.DataFrame(np.random.randn(2,2), columns = ['col1', 'col2'], index = ['hola', 'mundo'])
print('datos1 \n {} \n'.format(datos1))
print('datos2 \n {} \n'.format(datos2))
print(u'Unión de datos \n {} \n'.format(datos1.join(datos2, on = 'otra_columna')))

datos_dcha = pd.DataFrame({'clave': ['foo'] * 3, 'valor_dcha': np.arange(3)})
datos_izda = pd.DataFrame({'clave': ['foo'] * 3, 'valor_izda': np.arange(5, 8)})
datos_unidos = pd.merge(datos_izda, datos_dcha, on = 'clave')
print('datos_dcha \n {} \n'.format(datos_dcha))
print('datos_izda \n {} \n'.format(datos_izda))
print('datos_unidos \n {}'.format(datos_unidos))

datos_dcha = pd.DataFrame({'clave1': ['foo', 'foo', 'bar', 'bar'],
                           'clave2': ['one', 'one', 'one', 'two'],
                           'val_dcha': [4, 5, 6, 7]})
datos_izda = pd.DataFrame({'clave1': ['foo', 'foo', 'bar'],
                           'clave2': ['one', 'two', 'one'],
                           'val_izda': [1, 2, 3]})
datos_unidos = pd.merge(datos_izda, datos_dcha, how='outer')
print('datos_dcha \n {} \n'.format(datos_dcha))
print('datos_izda \n {} \n'.format(datos_izda))
print('datos_unidos \n {}'.format(datos_unidos))

nenas = pd.read_excel('nombres_recien_nacidos.xlsx', 'Niñas', header = 0, skiprows = 1)
nenes = pd.read_excel('nombres_recien_nacidos.xlsx', 'Niños', header = 0, skiprows = 1)

nenas.head(5)

cols_1 = []
for i in range(2012,2001,-1):
    cols_1.append((str(i),'nombre'))
    cols_1.append((str(i), 'numero'))
cols = pd.MultiIndex.from_tuples(cols_1, names=['año','campo'])

nenes.columns = cols
nenas.columns = cols
nenes.index = range(1,101)
nenas.index = range(1,101)

nenes.tail(5)

nenas.T.xs('nombre', level = 'campo')

indices = nenas.T.xs('nombre', level = 'campo') == 'LUCIA'

plt.figure(figsize = (20,6))
nenas.T.xs('numero',level = 'campo')[indices].sum().plot(kind='bar')
print(nenas.T.xs('numero',level = 'campo')[indices].sum().sum())

plt.figure(figsize = (20,6))
indices = nenas.T.xs('nombre', level = 'campo') == 'LUCIA'
#nenas.T.xs('numero',level = 'campo')[indices].sum(axis = 1).plot(kind = 'bar', color = 'k')
nenas.T.xs('numero',level = 'campo')[indices].sum(axis = 1).plot(color = 'k')
print(nenas.T.xs('numero',level = 'campo')[indices].sum().sum())
indices = nenas.T.xs('nombre', level = 'campo') == 'MARIA'
#nenas.T.xs('numero',level = 'campo')[indices].sum(axis = 1).plot(kind = 'bar', color = 'y', alpha = 0.75)
nenas.T.xs('numero',level = 'campo')[indices].sum(axis = 1).plot(color = 'y')
print(nenas.T.xs('numero',level = 'campo')[indices].sum().sum())
indices = nenas.T.xs('nombre', level = 'campo') == 'PAULA'
#nenas.T.xs('numero',level = 'campo')[indices].sum(axis = 1).plot(kind = 'bar', color = 'y', alpha = 0.75)
nenas.T.xs('numero',level = 'campo')[indices].sum(axis = 1).plot(color = 'b')
print(nenas.T.xs('numero',level = 'campo')[indices].sum().sum())

nenes.T.xs('nombre', level = 'campo')

plt.figure(figsize = (20,6))
indices = nenes.T.xs('nombre', level = 'campo') == 'DANIEL'
nenes.T.xs('numero',level = 'campo')[indices].sum(axis = 1).plot(color = 'k')
print(nenes.T.xs('numero',level = 'campo')[indices].sum().sum())
indices = nenes.T.xs('nombre', level = 'campo') == 'ALEJANDRO'
nenes.T.xs('numero',level = 'campo')[indices].sum(axis = 1).plot(color = 'y', alpha = 0.5)
print(nenes.T.xs('numero',level = 'campo')[indices].sum().sum())
indices = nenes.T.xs('nombre', level = 'campo') == 'PABLO'
nenes.T.xs('numero',level = 'campo')[indices].sum(axis = 1).plot(color = 'b', alpha = 0.5)
print(nenes.T.xs('numero',level = 'campo')[indices].sum().sum())
indices = nenes.T.xs('nombre', level = 'campo') == 'HUGO'
nenes.T.xs('numero',level = 'campo')[indices].sum(axis = 1).plot(color = 'g', alpha = 0.5)
print(nenes.T.xs('numero',level = 'campo')[indices].sum().sum())