import matplotlib.pyplot as plt

import numpy as np

from pylab import *

import matplotlib.pyplot as plt

plt.isinteractive()

plt.plot([1,2,3,4])

plt.ishold()

plt.plot(np.random.rand(10))
plt.plot(np.random.rand(10))

plt.figure('scatter') # Crea una ventana titulada 'scatter'
plt.figure('plot')    # Crea una ventana titulada 'plot'
a = np.random.rand(100) # Generamos un vector de valores aleatorios
b = np.random.rand(100) # Generamos otro vector de valores aleatorios
plt.figure('scatter') # Le decimos que la ventana activa en la que vamos a dibujar es la ventana 'scatter'
plt.scatter(a,b)  # Dibujamos un scatterplot en la ventana 'scatter'
plt.figure('plot') # Ahora cambiamos a la ventana 'plot'
plt.plot(a,b)

plt.ion()  # Nos ponemos en modo interactivo
plt.subplot(1,2,1)  # Dividimos la ventana en una fila y dos columnas y dibujamos el primer gráfico
plt.plot((1,2,3,4,5))
plt.subplot(1,2,2)  # Dividimos la ventana en una fila y dos columnas y dibujamos el segundo gráfico
plt.plot((5,4,3,2,1))

plt.ion()  # Nos ponemos en modo interactivo
plt.figure('valores por defecto')  # Creamos una ventana donde dibujamos el gráfico con la configuración por defecto
plt.rc('lines', linewidth = 1)  # A partir de aquí todas las líneas que dibujemos irán con ancho doble
plt.rc('font', size = 10)  # A partir de aquí las fuentes que aparezcan en cualquier gráfico en la misma sesión tendrán este tamaño
plt.suptitle('Titulo valores por defecto')  # Esto sirve para poner título dentro de la ventana
plt.plot((1,2,3,4,5), label = 'por defecto')  # Hacemos el plot
plt.legend(loc = 2)  # Colocamos la leyenda en la esquina superior izquierda

plt.rc('lines', linewidth = 2)  # A partir de aquí todas las líneas que dibujemos irán con ancho doble
plt.rc('font', size = 18)  # A partir de aquí las fuentes que aparezcan en cualquier gráfico en la misma sesión tendrán mayor tamaño
plt.figure('valores modificados')  # Creamos una ventana donde dibujamos el gráfico con la configuración por defecto
plt.suptitle('Titulo valores modificados')  # Esto sirve para poner título dentro de la ventana
plt.plot((1,2,3,4,5), label = u'linea más ancha y letra más grande')  # Hacemos el plot
plt.legend(loc = 2)  # Colocamos la leyenda en la esquina superior izquierda

plt.axes()  # Coloca un área de gráfico con los valores por defecto
plt.plot(np.exp(np.linspace(0,10,100)))  # Dibuja una exponencial de 0 a 10
plt.axes([0.2,0.55,0.3,0.3], axisbg = 'gray')  # Dibuja una nueva área de gráfica colocada y con ancho y largo definido por [0.2,0.55,0.3,0.3] y con gris como color de fondo
plt.plot(np.sin(np.linspace(0,10,100)), 'b-o', linewidth = 2)

plt.plot(np.arange(100), 'b')  # Dibujamos una línea recta azul
plt.xlabel('Valores de x')  # Ponemos etiqueta al eje x
plt.ylabel(u'Línea azul')  # Ponemos etiqueta al eje y
plt.twinx()  # Creamos un segundo eje y
plt.plot(np.exp(np.linspace(0,5,100)), 'g')  # Dibuja una exponencial de 0 a 5 con la y representada en el segundo eje y
plt.ylabel(u'Línea verde')  # Ponemos etiqueta al segundo eje y
plt.xlim(-10,110)  # Limitamos los valores del eje x para que vayan desde -10 a 110

plt.scatter(np.random.randn(1000), np.random.randn(1000))  # Dibujamos un scatterplot de valores aleatorios
plt.axvline(-0.5, color = 'g')  # Dibujamos una línea vertical verde centrada en x = -0.5
plt.axvline(-0.5, color = 'g')  # Dibujamos una línea vertical verde centrada en x = 0.5
plt.axhline(-0.5, color = 'g')  # Dibujamos una línea horizontal verde centrada en x = -0.5
plt.axhline(-0.5, color = 'g')  # Dibujamos una línea horizontal verde centrada en x = 0.5
plt.axvspan(-0.5,0.5, alpha = 0.25)  #  Dibujamos un recuadro azul vertical entre x[-0.5,0.5] con transparencia 0.25
plt.axhspan(-0.5,0.5, alpha = 0.25)  #  Dibujamos un recuadro azul horizontal entre x[-0.5,0.5] con transparencia 0.25

import calendar
dias = [np.array(calendar.mdays)[0:i].sum() + 1 for i in np.arange(12)+1]  # Para generar el lugar del primer días de cada mes en un año
meses = calendar.month_name[1:13]  # Creamos una lista con los nombres de los meses
plt.axes([0.1,0.2,0.8,0.65])
plt.plot(np.arange(1,366), np.random.rand(365), label = 'valores al azar')  # Creamos un plot con 365 valores
plt.xlim(-5,370)  # Los valores del eje y variarán entre -5 y 370
plt.ylim(0,1.2)  # Los valores del eje y variarán entre 0 y 1.2
plt.legend()  # Creamos la caja con la leyenda
plt.title(u'Ejemplo de título')  # Ponemos un título
plt.suptitle(u'Ejemplo de título superior')  # Ponemos un título superior
plt.minorticks_on()  # Pedimos que se vean subrrayas de división en los ejes
plt.xticks(dias, meses, size = 'small', color = 'b', rotation = 45)  # Colocamos las etiquetas, meses, en las posiciones, dias, con color azul y rotadas 45º
plt.xlabel(u't (días)')
plt.ylabel('Media diaria')

x = np.arange(100)  # Valores de x
y = np.random.rand(100)  # Valores de y
plt.plot(x,y, color = 'black', label = '(x, f(x)')  # Dibujamos la evolución de f(x), frente a x
plt.plot(x[y > 0.9], y[y > 0.9], 'bo', label = 'f(x) > 0.9')  # Destacamos los valores por encima de 0.9 colocándoles un marcador circular azul
plt.axhspan(0.9, 1, alpha = 0.1)  # Colocamos una banda de color para los valores f(x) > 0.9
plt.ylim(0,1.2)  # Limitamos el eje x
plt.legend()  # Colocamos la leyenda
plt.title(u'Representación de (x, f(x))')  # Colocamos el título del gráfico
plt.xlabel('valores x')  # Colocamos la etiqueta en el eje x
plt.ylabel('valores f(x)')  # Colocamos la etiqueta en el eje y

x = np.arange(25) + 1  # Valores de x
y = np.random.rand(25) * 10.  # Valores de y
y_norm = (y - y.mean()) / y.std()  # Valores de y normalizados. Esta nueva serie tiene media 0 y desvicación estándar 1 (comprobadlo como ejercicio)
plt.xlim(np.min(x) - 1, np.max(x) + 1)  # Colocamos los límites del eje x
plt.ylim(np.min(y_norm)-1, np.max(y_norm)+1)  # Colocamos los límites del eje y
plt.stem(x[y_norm > 0],y_norm[y_norm > 0], linefmt='k-.', markerfmt='go', basefmt='b-')  # Dibujamos los valores por encima de la media
plt.stem(x[y_norm < 0],y_norm[y_norm < 0], linefmt='k-.', markerfmt='ro', basefmt='b-')  # Dibujamos los valores por debajo de la media
plt.title(u'Representación de (x, f(x))')  # Colocamos el título del gráfico
plt.xlabel('valores x')  # Colocamos la etiqueta en el eje x
plt.ylabel('valores f(x)')  # Colocamos la etiqueta en el eje y

x = np.arange(25) + 1  # Valores de x
y1 = np.random.rand(25) * 10.  # Valores de y1
y2 = np.random.rand(25) * 10.  # Valores de y2
plt.xlim(np.min(x) - 1, np.max(x) + 1)  # Colocamos los límites del eje x
plt.ylim(np.min([y1, y2])-1, np.max([y1, y2])+1)  # Colocamos los límites del eje y
plt.plot(x, y1, 'k-', linewidth = 2, label = 'Serie 1')  # Dibujamos los valores de (x,y1) con una línea contínua
plt.plot(x, y2, 'k-.', linewidth = 2, label = 'Serie 2')  # Dibujamos los valores de (x,y2) con una línea de punto y raya
plt.fill_between(x, y1, y2, where = (y1 < y2), color = 'g', interpolate = True)  # Pinta polígonos color verde entre las líneas cuando y1 < y2 
plt.fill_between(x, y1, y2, where = (y1 > y2), color = 'r', interpolate = True)  # Pinta polígonos color rojo entre las líneas cuando y1 > y2
plt.legend()
plt.title('Ejemplo de plt.fill_between()')  # Colocamos el título del gráfico
plt.xlabel('valores x')  # Colocamos la etiqueta en el eje x
plt.ylabel('valores y')  # Colocamos la etiqueta en el eje y

s1x = [0.3,0.3,0.7,0.7,0.5,0.5,1,1,0.7,0.7]
s1y = [0.5,1.4,1.4,1.5,1.5,1.9,1.9,1.1,1.1,0.5]
o1x = [0.6,0.6,0.7,0.7]
o1y = [1.7,1.8,1.8,1.7]
s2x = [0.8,0.8,1.1,1.1,1.5,1.5,1.1,1.1,1.3,1.3]
s2y = [0.2,1,1,1.6,1.6,0.7,0.7,0.6,0.6,0.2]
o2x = [1.1,1.1,1.2,1.2]
o2y = [0.3,0.4,0.4,0.3]
plt.fill(s1x, s1y, color = 'b')
plt.fill(o1x,o1y, color = 'w')
plt.fill(s2x, s2y, color = 'g')
plt.fill(o2x,o2y, color = 'w')
plt.title(u'Símbolo de python cutre')
plt.ylim(0.1,2)

alt_esp = np.random.randn(100)+165 + np.random.randn(100) * 10  # Creamos unos valores para la altura de 100 españolas
alt_ale = np.random.randn(100)+172 + np.random.randn(100) * 12  # Creamos unos valores para la altura de 100 alemanas
alt_tai = np.random.randn(100)+159 + np.random.randn(100) * 9   # Creamos unos valores para la altura de 100 tailandesas
plt.boxplot([alt_esp, alt_ale, alt_tai], sym = 'ko', whis = 1.5)  # El valor por defecto para los bigotes es 1.5*IQR pero lo escribimos explícitamente
plt.xticks([1,2,3], ['Esp', 'Ale', 'Tai'], size = 'small', color = 'k')  # Colocamos las etiquetas para cada distribución
plt.ylabel(u'Altura (cm)')

x = np.random.randn(10000)  # Definimos un vector de números aleatorios de una distribución normal
plt.hist(x, bins = 20)  # Dibuja un histograma dividiendo el vector x en 20 intervalos del mismo ancho

import datetime as dt  # Importamos el módulo datetime
prima = 600 + np.random.randn(5) * 10  # Valores inventados para la prima de riesgo
fechas = (dt.date.today() - dt.timedelta(5)) + dt.timedelta(1) * np.arange(5) # generamos las fechas de los últimos cinco días
plt.axes((0.1, 0.3, 0.8, 0.6))  # Definimos la posición de los ejes
plt.bar(np.arange(5), prima)  # Dibujamos el gráfico de barras
plt.ylim(550,650)  # Limitamos los valores del eje y al range definido [450, 550]
plt.title('prima de riesgo')  # Colocamos el título
plt.xticks(np.arange(5), fechas, rotation = 45)  # Colocamos las etiquetas del eje x, en este caso, las fechas

plt.axes((0.2,0.1,0.7,0.8))  # Creamos los ejes en la posición que queremos
plt.title(u'Evolución para hoy de los tipos de nubosidad')  # Ponemos un título al gráfico
plt.broken_barh([(0,1),(3,3), (10,5), (21,3)], (9500, 1000))  # Dibujamos los momentos en que ha habido nubes altas
plt.broken_barh([(0,24)], (4500, 1000))  # Dibujamos los momentos en que ha habido nubes medias
plt.broken_barh([(0,9), (12,5), (20,2)], (1500, 1000))  # Dibujamos los momentos en que ha habido nubes bajas
plt.xlim(-1,25)  # Limitamos el rango de valores del eje x
plt.yticks([2000, 5000, 10000], ['nubes bajas', 'nubes medias','nubes altas'])  # Colocamos etiquetas en el eje y
plt.xlabel('t(h)')  # Y finalmente ponemos un título al eje x, el eje de tiempos

x = np.arange(10) + 1
y = np.random.rand(10)
plt.step(x, y, where = 'mid', color = 'r', linewidth = 3)
plt.title(u"Gráfico ejemplo de \'escaleras\'")
plt.xlim(0,11)

visitas = [43.97, 9.70, 7.42, 6.68, 3.91, 3.85, 3.62, 3.43, 3.16, 3.04] # Definimos un vector con el % de visitas del top ten de países
visitas = np.append(visitas, 100. - np.sum(visitas)) # Introducimos un último elemento que recoge el % de visitas de otros países fuera del top ten
paises = [u'España', u'México', 'Chile', 'Argentina', 'Colombia', 'Ecuador', u'Perú', 'USA', 'Islandia', 'Venezuela', 'Otros']  # Etiquetas para los quesitos
explode = [0, 0, 0, 0, 0, 0, 0, 0.2, 0.2, 0, 0]  # Esto nos ayudará a destacar algunos quesitos
plt.pie(visitas, labels = paises, explode = explode)  # Dibuja un gráfico de quesitos
plt.title(u'Porcentaje de visitas por país')

x = np.random.rand(20)  # posiciones X de nuestra red de medidas
y = np.random.rand(20)  # posiciones Y de nuestra red de medidas
t = np.random.rand(20)*3000  # valores de Temperatura (ºK) en las posiciones (X, Y)
plt.tricontourf(x, y, t)  # Pintamos las triangulaciones con contornos de color
plt.tricontour(x, y, t, colors = 'k')  # Pintamos las líneas de contorno en color negro
plt.scatter(x, y)  # Pintamos la posición de las estaciones de medida.

x = np.sort(np.random.randn(25))  # Valores de x que vamos a usar posteriormente para crear la matriz
y = np.sort(np.random.randn(25))  # Valores de y que vamos a usar posteriormente para crear la matriz
mat1, mat2 = np.meshgrid(x, y)  # Creamos dos matrices cuadradas que vamos a cruzar
mat = np.sqrt( mat1**2 + mat2 **2)  # Creamos una matriz final a partir de las dos anteriores
plt.matshow(mat)  # Representamos la última matriz con matshow
plt.contour(np.arange(25), np.arange(25), mat, 10, colors = 'k')  # Colocamos líneas de contorno para la matriz mat
plt.matshow(mat)  # Representamos la última matriz con matshow

x = np.random.randn(10000)  # Creamos un vector de 10000 elementos distribuidos de forma normal
y = np.random.randn(10000)  # Creamos un vector de 10000 elementos distribuidos de forma normal
plt.hexbin(x,y, gridsize = 20)  # Representamos como están distribuidos bidimensionalmente con ayuda de hexbin, en este caso definimos un tamaño del grid de 20 (esto se puede elegir como se prefiera)
plt.colorbar()  # Colocamos una barra de colores para saber a qué valor corresponden los colores

lon = np.arange(15) - 10.  # Creamos un vector de longitudes
lat = np.arange(15) + 30.  # Creamos un vector de latitudes
lon, lat = np.meshgrid(lon, lat)  # Creamos un array 2D para las longitudes y latitudes
u = np.random.randn(15 * 15)  # Componente x del vector viento que partirá desde una lon y una lat determinada
v = np.random.randn(15 * 15)  # Componente y del vector viento que partirá desde una lon y una lat determinada
colores = ['k','r','b','g','c','y','gray']  #  Definimos una serie de colores para las flechas
plt.title('Flechas de un viento un poco loco')  # Colocamos un título
plt.xlabel('longitud')  # Colocamos la etiqueta para el efe x
plt.ylabel('latitud')  # Colocamos la etiqueta para el eje y
plt.quiver(lon, lat, u, v, color = colores)  # Dibujamos las flechas 'locas'

import netCDF4 as nc
from mpl_toolkits.basemap import Basemap as Bm

url = 'http://nomads.ncdc.noaa.gov/thredds/dodsC/cfsr1hr/200912/wnd10m.l.gdas.200912.grb2' # Ruta al fichero que usaremos
datos = nc.Dataset(url) # Accedemos a los datos

u = datos.variables['U-component_of_wind'][0,:,:,:] # Guardamos en memoria el valor u del vector de viento para las 00:00 UTC del 01/12/2009
v = datos.variables['V-component_of_wind'][0,:,:,:] # Guardamos en memoria el valor v del vector de viento para las 00:00 UTC del 01/12/2009
lon = datos.variables['lon'][:] # Guardamos los valores de longitud
lat = datos.variables['lat'][:] # Guardamos los valores de latitud
lons, lats = np.meshgrid(lon, lat) # Hacemos una malla regular 2D para las latitudes y las longitudes

m = Bm(llcrnrlon = 260, llcrnrlat = -30, urcrnrlon = 320, urcrnrlat = 30, projection = 'mill') # Definimos el área del gráfico y la proyección
m.drawparallels(np.arange(-180,180,10),labels=[1,1,0,0]) # Dibujamos los paralelos
m.drawmeridians(np.arange(0,360,10),labels=[0,0,0,1]) # Dibujamos los meridianos
m.bluemarble() # Ponemos un mapa 'bonito' de fondo
x, y = m(lons, lats)
m.barbs(x, y, u[0,:,:], v[0,:,:],length=5,barbcolor='w',flagcolor='w',linewidth=0.5) # Y dibujamos los valores del vector viento

a = np.random.rand(10)  # Creamos una serie de 10 valores pseudo-aleatorios entre 0 y 1
plt.plot(a)  # Los dibujamos
plt.ylim(-0.2, 1.2)  # Definimos el rango de valores para el eje y
plt.text(np.argmin(a), np.min(a) - 0.1, u'Mínimo', 
         fontsize = 10, horizontalalignment='center', verticalalignment='center')  # Colocamos texto cerca del valor donde se encuentra el mínimo
plt.text(np.argmax(a), np.max(a) + 0.1, u'Máximo', 
         fontsize = 10, horizontalalignment='center', verticalalignment='center')  # Colocamos texto cerca del valor donde se encuentra el máximo

plt.plot(a)
plt.ylim(-0.5, 1.5)  # Extendemos un poco el rango del eje y
plt.text(np.argmax(a), np.max(a) + 0.4, u'Máximo', fontsize = 10, horizontalalignment='center', verticalalignment='center')  # Recolocamos el texto del máximo
plt.text(np.argmin(a), np.min(a) - 0.4, u'Mínimo', fontsize = 10, horizontalalignment='center', verticalalignment='center')  # Recolocamos el texto del mínimo
plt.arrow(np.argmax(a), np.max(a) + 0.3, 0, -0.3, length_includes_head = "True", shape = "full", width=0.07, head_width=0.1)  # Unimos el texto al valor representado
plt.arrow(np.argmin(a), np.min(a) - 0.3, 0, 0.3, length_includes_head = "True", shape = "full", width=0.07, head_width=0.1)  # Unimos el texto al valor representado

plt.plot(a)
plt.ylim(-0.5, 1.5)  # Extendemos un poco el rango del eje y
plt.annotate(u'Máximo', xy = (np.argmax(a), np.max(a)), 
             xycoords = 'data', xytext = (np.argmax(a) - 1.5, 
             np.max(a) + 0.4), textcoords = 'data', arrowprops = dict(arrowstyle = "->"))
plt.annotate(u'Mínimo', xy = (np.argmin(a), np.min(a)), 
             xycoords = 'data', xytext = (np.argmin(a) + 1, 
             np.min(a) + 1.2), textcoords = 'data', arrowprops = dict(arrowstyle = "->"))

valores = [[np.argmax(a), np.argmin(a)], [np.max(a), np.min(a)]]
etiquetas_fil = ('x', 'y')
etiquetas_col = (u'Máximo', u'Mínimo')
plt.plot(a)
plt.table(cellText=valores, rowLabels=etiquetas_fil, colLabels = etiquetas_col, colWidths = [0.3]*len(a), loc='upper center')

background = plt.imread('imgs/Cc.large.png')  # Leemos la imagen que queremos usar de fondo, lo que escribáis entre comillas es la ruta a la imagen
x = np.arange(background.shape[1])  # Definimos valores de x
y = np.random.rand(background.shape[0]) * background.shape[0]  # Definimos valores de y
plt.plot(x, y)  # Dibujamos la serie
plt.imshow(background, alpha = 0.25)  # Creamos el fondo con una transparencia del 0.10 (1 es opaco y 0 es transparente)

plt.savefig('imgs/imagen_con_fondo_cc.png')

import matplotlib.pyplot as plt
from matplotlib import animation
from mpl_toolkits.mplot3d.axes3d import Axes3D
import numpy as np
from scipy.integrate import odeint

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
#ax = Axes3D(fig)
ax.azim = 45
ax.elev = 45
ax.set_xlabel('Eje X')
ax.set_ylabel('Eje Y')
ax.set_zlabel('Eje Z')
ax.set_xticklabels('')
ax.set_yticklabels('')
ax.set_zticklabels('')
linea, = ax.plot([], [], [], label = 'Lorenz', lw = 0.5)
ax.legend()
ax.set_xlim(-20,20)
ax.set_ylim(-30,30)
ax.set_zlim(0,50)

def integra(ccii, t):

    x = ccii[0]            ## Posición inicial
    y = ccii[1]            ## Posición inicial
    z = ccii[2]            ## Posición inicial

    sigma = 10             ## Parámetros que se pueden ver en:
    rho = 28               ## http://en.wikipedia.org/wiki/Lorenz_system
    beta = 8.0/3           ##

    dx = sigma * (y - x)   ## Sistema de ecuaciones
    dy = x * (rho -z) - y  ## diferenciales de
    dz = x * y - beta* z   ## Lorenz

    return [dx, dy, dz]

def anima(i, x0, y0, z0):

    t = np.arange(0, (i + 1) / 10., 0.01) ## Paso temporal
    ccii = [x0, y0, z0]                   ## Posición inicial

    ## Integración de las
    ## ecs. de Lorenz mediante
    ## scipy.integrate.odeint
    ## http://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.odeint.html
    ## odeint usa la función integra
    ## que hemos creado anteriormente
    ## con las condiciones iniciales (ccii)
    ## y los pasos temporales (t)
    soluc = odeint(integra, ccii, t)

    x = soluc[:,0]                        ## Posición x
    y = soluc[:,1]                        ## Posición y
    z = soluc[:,2]                        ## Posición z

    ax.elev = 45 + i / 2.                 ## Vamos rotando el
    ax.azim = 45 + i / 2.                 ## punto de vista

    linea.set_data(x, y)                  ## Asignamos datos para ir
    linea.set_3d_properties(z)            ## dibujando la trayectoria

    return linea, 

anim = animation.FuncAnimation(fig, anima, frames = 500, fargs = (0, 1, 1.05),
                               interval = 5, blit = True)

anim.save('imgs/Atractor_de_Lorenz(pybonacci).mp4', fps = 10)

from IPython.display import YouTubeVideo

YouTubeVideo("bFfCG-N8R8E")