=Editores de Texto=

Los editores de texto son aplicaciones utilizadas para la creación y edición de archivos de texto sencillo y sin formato. La mayoría de los sistemas operativos incluyen al menos un editor de texto que permite la creación, edición, lectura y guardado de archivos. En general, soportan funciones adicionales como copiar-pegar, búsqueda y uso de macros.

==Diferencia con Procesadores de Texto==
Los editores de texto son aplicaciones utilizadas para la creación y edición de archivos de texto sencillo y sin formato. La mayoría de los sistemas operativos incluyen al menos un editor de texto que permite la creación, edición, lectura y guardado de archivos. En general, soportan funciones adicionales como copiar-pegar, búsqueda y uso de macros.

[[Screenshot editor de texto]]

A pesar de las restricciones en los editores de texto, el uso de texto sin formato posee ventajas prácticas. Los archivos creados por un editor de texto en general pueden ser utilizados por otros editores o procesadores de texto sin generar ningún tipo de conflicto. En programación, debido a que el código fuente no requiere ningún tipo de formato, es común -y necesario- utilizar editores de texto para escribir y editar código. La carencia de interfaz gráfica en los editores de texto permite además utilizarlos para editar archivos remotamente. Es posible así, por ejemplo, ingresar a un servidor y editar archivos de texto sin la necesidad de transferir por red el entorno gráfico, reduciendo significativamente el consumo de ancho de red.

=Procesadores de texto en Linux=
Existe una amplia variadad de editores de texto para Linux. En esta parte, describiremos brevemente los siguientes editores:

*'''Gedit''', editor de texto con interfacie grafica
*'''Vi / Vim''', editor de texto en la terminal
*'''Emacs''', otro editor de texto en la terminal

==Gedit==

'''Gedit''' es el editor de textos por defecto en los entornos GNOME (uno de los entornos disponibles en Debian). Cuenta con una interfaz relativamente amigable para nuevos usuarios. En gedit es posible Abrir y Guardar archivos, Buscar y reemplazar palabras, Seleccionar partes del texto, entre muchas opciones utilizando sólo el mouse.

[[Archivo:[gedit.png]]

==Vi y Vim==

Vi es el editor de textos estándar para la terminal incluido en -casi- todos los sistemas operativos UNIX. Su versión mejorada Vim (“Vi IMproved”) incluye más funcionalidades. Tanto Vi como Vim, carecen de interfaz gráfica. A diferencia de los editores de texto tradicionales, Vim posee tres modos de trabajo: modo Normal o de Comandos, modo Insertar y modo visual.

Para empezar con vi / vim escribir en la terminal :
<code>
vi file
</code>
o
<code>
vim file
</code>

Abre file si el archivo ya existe, en caso contrario permite crearlo si se decide guardarlo.

===Modo normal===
Es el modo principal de Vim y sólo desde aquí es posible ingresar a los otros modos.

En este modo, todas las teclas ingresadas son interpretadas como un comando. Desde aquí es posible guardar un archivo, copiar y pegar líneas, buscar palabras, deshacer-rehacer acciones, eliminar palabras y líneas, etc.

Para ingresar a este modo:
*Es el modo por defecto al iniciar el editor
*Para regresar a modo normal, basta con presionar la tecla ESC.

===Modo Insertar===
Este es el modo de escritura y edición de texto. Desde aquí, las teclas son interpretadas como el texto a insertar.

Para ingresar a este modo:
*Presionar la tecla '''i''' desde el modo Normal

===Modo Visual===
Ayuda a seleccionar visualmente partes del texto.

Imita al uso del mouse para seleccionar porciones de texto en editores de texto con interfaz gráfica.

Para ingresar a este modo:
*Presionar v, V o CTRL-v para acceder al modo visual y seleccionar caracteres, líneas o bloques de texto, respectivamente.

==Comandos principales==

{| class="wikitable"
|-
! Comando
! Teclas
|-
| Salir de Vim
| :q
|-
| Guardar archivo
| :w
|-
| Eliminar línea
| dd
|-
| Pegar
| p
|-
| Buscar
| /
|-
| Deshacer
| u
|-
| Rehacer
| C-r
|-
| Comenzar Macro
| q <una letra que identifique a la macro>
|-
| Finalizar Macro
| q
|-
| Ejecutar una Macro
| @ <letra que identifica a la macro>

|}

Otros comandos comunes pueden verse [https://www.fprintf.net/vimCheatSheet.html aquí]

==Emacs==
Desarrollado por Richard Stallman en 1976, Emacs es aún hoy uno de los editores de texto más completos disponibles.
Para iniciar el editor, se debe ejecutar el comando

<PRE>
$ emacs
</PRE>

Esto abrirá Emacs en modo gráfico. Con la interfaz gráfica de Emacs es posible ejecutar los comandos básicos utilizando los menúes despegables. Para ejecutar Emacs desde la terminal, deben ingresarse adicionalmente la opción -nw

<PRE>
$ emacs -nw
</PRE>
En el modo terminal, no es posible utilizar mouse, por lo que los comandos se deben acceder utilizando combinaciones de teclas. Por ejemplo para guardar un archivo deberá ingresarse C-X C-S. Esto es, tipear simultáneamente las teclas CTRL y X, seguida de CTRL y S.

Entre los comandos más básicos en Emacs se encuentran:

{| class="wikitable"
|-
! Comando
! Teclas
|-
| Iniciar Tutorial de Emacs
| C-h t
|-
| Salir de Emacs
| C-x C-c
|-
| Interrumpir comando
| C-g
|-
| Abrir un archivo
| C-x C-f
|-
| Guardar un archivo
| C-x C-s
|-
| Buscar en el texto
| C-s
|-
| Deshacer
| C-x u
|-
| Comenzar Macro
| F3
|-
| Finalizar Macro
| F4
|-
| Ejecutar última Macro
| F4

|}

Una lista exhaustiva de comandos puede encontrarse [https://www.gnu.org/software/emacs/refcards/pdf/refcard.pdf aquí]

2019-06-04T17:12:44Z

Anthony.schrapffer: /* tensorflow */

= Introduction =
== Histórico ==

Python es un lenguaje de programación iniciado por Guido van Rossum. Tiene su nombre de la famosa serie tele ''Monty Python's Flying Circus''. La serpiente marco mas la imaginación, por esta razón el lenguaje termina adoptándolo como logo.

El lenguaje [https://www.python.org/ python] es un lenguaje interpretado muy versátil y cada vez más utilizado en actividades de ciencias de la Tierra. Existen dos versiones del lenguaje 2.x y 3.x las cuáles no son compatibles. Los cambios son menores (ej.: <code>print 'Hola' --> print ('Hola')</code>), pero requiere una recodificación de las scripts. En este curso vamos por lo mas moderno, python3 ya que la versión 2 no sera mas actualizada a partir de 2020.

Python es un lenguaje muy rico, porque está constituido por aportaciones de usuarixs de todo el mundo en forma de paquetes fáciles de instalaciones. Estos paquetes se tuvieron que adaptar para python 3.x y esto a retrasado su uso. Pero ahora, este proceso de migración y adaptación ya casi terminó y ya se puede usar con tranquilidad python 3.

La presentación se puede descargar desde este enlace [[File:python-TUX.pdf]]

== Por que elegir Python ? ==

*Por el diseño del lenguaje:
''su simplicidad facilita la implementación de ideas''

*Por la facilidad de uso:
''es un lenguaje interpretado, no necesita ser compilado solo basta ejecutar el código''

*Por la facilidad de lectura:
''para poder compartirlo con otras personas, con la comunidad científica''

*Por la alta compatibilidad:
''puede funcionar con otros tipos de lenguajes de programación (C con cython, Fortran con f2py, en los cuales esta basado)''

*Por la estructura de los datos:
''numerosos tipos de objetos disponibles''

*Por la grande comunidad que lo usa:
''mucha información en internet, libros, librerias disponibles y actualizadas''

= Para empezar =
== A saber antes de empezar ==

* Lenguaje alto nivel, no necesidad de definir todo, interpreta mucho pero CUIDADO, hay que estar atento con lo que estamos manipulamos, si dejemos python interpretar el tipo de una variable, la operaciones de esta variable van a depender de como la definó python.
* El lenguaje reconoce minusculas y mayusculas
* Python empieza a contar a 0, así el primer elemento de una lista es el elemento 0 !
* los espacios a principio de linea cuentan para definir los bloques
* se puede ("debe") comentar con :
<code> # para que lo resto de la linea sea considerado como comentario </code>

<code>"""
Eso permite
Comentar sobre varias lineas
"""
</code>

* Si queremos cortar una linea de codigo en varias se puede usar <code> \ </code> y empezando la linea siguiente a un nivel màs alto (recuerdan que los espacios a principio de linea cuentan)
* Para imprimir en pantalla una o más variable se usa la función <code> print(variable) </code> se pueden imprimir en pantalla varias variables con una sola función <code> print(variable1, variable2) </code>
* Cada tipo de elemento tiene sus propias caracteristicas y metodos.
* Se puede escribir varios comandos en una sola linea gracias al simbolo <code> ;</code>
* Cuando se usa un comando como un for, ir while etc. la linea se termina por : y los comandos utilizados adentro de esta condicion se definen por más espacio a principio de linea (recuerdan que esto define los bloques), para que quede más claro esta noción de bloque siguen dos ejemplos :

<code>
i = 0
while i < 3:
i = i+1 # bloque del while
print(i) # Después del bloque del while

''out:
> 3''
</code>

<code>
i = 0
while i < 3:
i = i+1 # bloque del while
print(i) # Adentro del bloque del while

''out:
> 1
> 2
> 3''
</code>

* Otra noción importante, la diferencia entre función y métodos, las dos pueden retornar o no números, listas etc. pero :
** Una función puede tener entre 0 y lo que se desea de variables / parametros en input :
*:-<code> sum(a,b) # función retornando la suma de a y b </code>
** Un método se aplica a un objeto, mismo si puede tener parametros en input
<code>
Lista = [] # creo una lista vacía
Lista.append(1) # agrego 1 a la Lista
</code>

== Como usarlo ==
=== En un terminal ===
Se puede llamar a python desde la terminal
<code> user@cima:~$ python3 </code>
Para después hacer las operaciones que queremos :

<code> >>> 1+2
3</code>

Y para salir basta con un
<code>exit()
o un
quit() </code>

Trabajar en la terminal permite probar algunas lineas de codigos, funciones ... Pero para poder trabajar de manera màs eficiente podemos usar los scripts.

=== En script ===
Un script de python es un documento texto con el formato : <code> name_script.py </code>

Es importante empezar el documento especificando con que entorno python lo queremos leer :
<code> #!/usr/bin/env python3 </code>

También se puede especificar el formato de codificación de caracteres, por ejemplo
<code> # -*- coding: utf-8 -*- </code>

Después se tienen que importar las librerias que usamos en el script (si es que usamos):
<code> import this </code>

Y finalmente viene el código !

Se puede agregar al final del documento lo siguiente
<code>
if __name__ == "__main__":
Codigo a interpretar si este script es el script principal, no un script importado
# Sirve para dar un ejemplo de uso, probar las funciones (debug)
</code>

=== Ayudandose de un IDE ===
Los IDE (Integrated Development Environment aka Entorno de desarollo integrado) son muy útiles para facilitarse el desarollo de un script, contienen en general:
* una parte con multiples pestañas para poder navigar entre los diferentes scripts
* un terminal para ir probando comandos
* la posibilidad de leer todo o parte del script, visualizando los output en el terminal
* Opciones para visualizar ciertas variables, tablas etc.

Algunos ejemplos de IDE son :
* Spyder
* Jupyter

== En los servidores ==
Se puede usar en los servidores, se recomienda instalar Python y a las librerías que les interesan desde anaconda, para más detalles se recomiende ver a la pagina siguiente de la Wiki :

[[anaconda]]

Por otro lado, si quieren usar diferentes configuraciones de las versiones de librerías utilizadas con linux pueden fijarse en el articulo siguiente tratando de los entornos Python :

[[entornos_python]]

= Basic Python =
== Tipos de variables ==

Existen varios tipos de variables pre-existentes en python, cada tipo de variable es una clase con su propio tipo de data, sus propios métodos, funciones y operaciones para inter-actuar entre diferentes objetos de la misma clase.

Para conocer la clase de un objeto python, se puede utilizar la función siguiente que retorna la informacion deseada :
<code> type(objeto) </code>

=== Números ===

Python considera dos tipos de números :

* los números enteros (''int'') que se pueden definir utilizando el numero directamente sin "."
* los números flotantes (''float'') que se pueden definir poniendo un "." entre enteros y decimales, si el numero no tiene decimales, se puede definirlo como float agragandole un "." al final.

<code>
a = 5 # a es un entero
b = 2. # b es un flotante
c = 4.5 # c es claramente un flotante

# Para convertir los numeros
float(a) # retorna un numero flotante valiendo a
int(c) # retorna la parte entera de c, en este caso 4

# Operaciones entre flotante y enteros
a+b
> 7.
a-b
> 3.
a*b
> 10.
a/b
> 2.5
a//b # parte entera de la división
> 2
a%b # resto de la división
> 1

# Para facilitar la impresión en pantalla
round(4.5578945, 3) # reduce a 3 numero decimales el flotante
> 4.557
</code>

=== Condiciones y Boolean ===
Los boolean son ''True'' y ''False', también pueden ser referenciados respectivamente como 1 y 0.

Se puede evaluar una expresión gracias a diferentes símbolos de comparación, lo que nos retorna un boolean :
<code>
<
>
==
!=
in / not in
is / is not
</code>

Otras funciones pueden retornar un boolean.

Se puede evaluar matrices gracias a numpy (mas detalles en otra parte), lo que nos devuelve una matrice de boolean, o un solo boolean si especificamos : ''.any()'' o ''.all()''

<code>
A = np.array([1,2,3,4,5,6])
c = A < 3
print(c)
>[True, True, False, False, False, False]
print(c.any())
>True
print(c.all())
>False
</code>

=== String : Cadenas de caracteres ===
El formato de datos que contiene caracteres se llama '''String'''.
Se puede definir un string de dos maneras : <code>'string'</code> o <code>"string"</code>.

<code>
# Para trabajar con un ejemplo
word1 = "Hola"
word2 = "Mundo"
</code>

* Se pueden agregar varios string gracias al <code>+</code>
<code>
print(word1 + "_" + word2)
> output : "Hola Mundo"
</code>
* Pueden ser visto como una lista de caracteres simples
<code>
print(word1[0])
> output : "H"
</code>
* <code>word.upper()</code>, <code>word.lower()</code> devuelven una copia de word en mayuscula / minuscula
* Varios métodos permiten verificar ciertas caracteristicas del string, devuelven un boolean:
** <code>word1.isalnum()</code> : True si solamente caracteres son alphanumericos
** <code>word1.isalpha()</code> : True si solo caracteres alphabeticos
** <code>word1.islower()</code> : True si todo en minuscula
** <code>word1.isnumeric()</code> : True si todos son caracteres numericos
** <code>word1.isupper()</code> : True si todo en mayuscula
** ...
* separador.join(Lista_de-string) : devuelve un string con los elementos de las lista separado por el separador
<code>
print("-".joint([word1, word2]))
> output : "Hola-Mundo"
</code>
* <code>string.split(separador)</code> : devuelve una lista con los elementos de string entre cada separador, " " es utilizado si no hay separador especificado:
<code>
print("Ahora-podemos-probar".split("-"))
> output : ["Ahora", "podemos", "probar"]
</code>
* <code>frase.replace(str1, str2) </code> : devuelve un string que corresponde a frase en el cual str2 replaza a str1

Los otros tipos de variables pueden ser convertido en string gracias a la función <code>str()</code> :

<code>
a = 2+3
Resultado = "La suma es " + str(a)+"."
print(Resultado)
> output : La suma es 5.
</code>

=== Containers : Listas, Tuples, Diccionarios ===

Los containers ("contenedores") son objetos muy importantes, pueden contener otros objetos y así facilitan su uso. Básicamente, existen 3 grandes tipos de containers :

* las listas
* los tuple
* los diccionarios

==== Listas ====
Las listas se definen gracias a los símbolos "[" y "]".
La listas son contenedores referenciado gracias a un indice numérico.

<code>
# para definir una lista vacía
L = []

# para inicializar una lista, los elementos son separados por ","
L0 = [1, 2, 3]
# puede ser hecho con diferentes tipos de objetos, mismo otras listas
L = [1, 1.2, "Ritmo", L0]

# para agregar un objeto se utiliza el método append
L= ["A", "B"]
L.append("C")
print(L)

> output :
["A", "B", "C"]

# la función list permite facilitar la generación de lista :
L = list("abcdef")
print(L)
> output :
["a", "b", "c", "d", "e", "f"]

# la función len permite conocer el número de elementos
print(len(L))
> output :
6
</code>

Se puede hacer fácilmente loop con las listas :

<code>
L = ["file1", "file2", "file3"]
for element in L:
print(f)

> output :
"file1"
"file2"
"file3"
</code>

Se puede acortar una lista a una o más elementos :
<code>
# L1 una lista 1D
L1[0] # primer elemento de L1
L1[-1] # Ultimo elemento de L1
L1[1] # secundo elemento de L1
L1[:4] # todos los elementos hasta el cuarto (python empieza a contar a 0)
L1[2:] # todos los elementos a partir del tercero
L1[0::2] # todos los elementos a partir del 1ero, cada 2 elementos
</code>

Recuerden que un ''string'' puede ser considerado como una lista.

==== Tuple ====

Los '''tuples''' son unas listas que no pueden ser modificadas, se definen entre paréntesis.

<code>
t = ()
t = ("hola")
t = ("hola", "mundo")

# Extraer la información en t
word1, word2 = t

# Mismo acceso con índice como las listas
print(t[0])

> output :
"hola"
</code>

La principal diferencia es que los elementos no pueden ser cambiado ni agregado, hay que redefinir la lista si se quiere cambiar los elementos.

==== Diccionarios ====

En los diccionarios, los elementos no son referenciados por su indice sino por un identificante, no es un contenedor ordenado como las listas o los tuples.
Los diccionarios se crean con los simbolos "{" y "}". Los identificante pueden ser diferentes tipos de objetos, por ejemplo string o enteros.

<code>
# Diccionario vacío
D = {}

# Inicialización de un diccionarios
# se pone id : valor
D = {'Manzana': 3, 'Naranja': 10}

# se pueden definir uno a uno
D["Palta"] = 4

# Suprimir un elemento del diccionario
del D["Manzana"]
</code>

D.keys() devuelve la lista de los identificante
D.values() devuelve la lista de los diferentes valores
D.items() devuelve un tuples con los diferentes items

Por ejemplo :
<code>
for cle, value in D.items():
print(cle, value)
> output :
"Manzana" 3
"Naranja" 10

== Loops ==

=== for x in ===
Para recorrer una lista de elementos se puede usar el <code>for</code>

<code>
for x in List:
instrucciones utilizando x
</code>

El loop va a recorrer la lista utilizando sus elementos uno a uno refiriendose a ellos como x.

Construyendo lista de enteros facilmente con la función range podemos escribir :

<code>
for i in range(0,10,2): # para los enteros i entre 0 y 10 (excluido), cada 2
print(i)
> output :
0
2
4
6
8
</code>

También se puede recorrer dos listas en simultaneo utilizando la función <code> zip </code> :
<code>
for i, name in zip(range(3), ["To", "Ti", "To"]): # para los enteros i entre 0 y 10 (excluido), cada 2
print(i, name)
> output :
0, "To"
1, "Ti"
2, "To"
</code>

=== while ===

Se puede también utilizar una condición para hacer una loop, mientras está la condición se corre de nuevo la loop :
<code>
while 'condition':
instrucción
</code>

Cuidado a poder siempre salir de la loop, sino el script seguira corriendo sin fin.
Hay que verificar que a lo menos un elemento de la función llega a cambiar y que llega a no cumplir la condición

=== Parar una loop ===

Se puede parar una loop con el uso de <code> break </code>.

<code>
while 'condición':
instrucciones
if 'condición de no se pasa como quiero':
break
</code>

== Más herramientas ==

=== Funciones ===

Las funciones son una herramienta indispensable para trabajar con Python. Permiten no repetir partes del código y además permiten gestionar mejor la memoria en Python.

Python guarda todas las variables, informaciones en memoria, pero cuando utilizamos una función solo los elementos retornados están guardado en memoria una vez que termina corriendo, las variables locales están borradas.

La estructura básica de una función es :

<code>
def nombre_funcion(variable_entrantes):
# Noten que termino la linea anterior con ":"
# Noten que paso a otro nivél de código
código
return output
</code>

Se pueden retornar entre entre ninguna y varias variables, si no retornamos variables, el ''return'' es opcional.
Se pueden entrar entre ninguna y varias variables, es posible dar un valor por defecto a las variables entrantes :

<code>
def mi_funcion(a, b=1):
c = a+b
return c
c = mi_funcion(2)
print(c)
> 3

# Se puede indicar las variables entrantes si queremos ser más detallosos :
c = mi_funcion(a = 1, b = 3)
print(c)
> 4
</code>

=== Clases ===
También es posible gestionar sus propias clases de datos de la manera siguiente :

<code>
class name_class:
def __init__(self, input):
#Initialization method
self.parameter_a = "hola"
self.additional_method_1()

def additional_method_1(self, input):
operations

def additional_method_2(self, input):
operations

</code>

== Mejorar sus scripts ==

Para mejorar sus scripts y mejor gestionar los errores se puede usar 'try' y 'except'.

Funciona de la manera siguiente :
<code>
try:
'Codigo'
except:
'En cualquier caso de error, corro estas instrucciones'
</code>

Por ejemplo :
<code>
print(a)
> output : Error porque no defini a
</code>

<code>
try:
print(a)
except:
print("imposible de imprimir la variable en la pantalla")
print("verificar si esta definida")
> output :
"imposible de imprimir la variable en la pantalla"
"verificar si esta definida"
</code>

Permitió correr el codigo sin que este parado por el error.

= Librerias =

== Instalar Librerías ==
* En debian : en general las librerías se encuentran con el nombre ''python3-nombre''
<code>
su root
''Entrar contraseña para acceder al modo superuser''
apt-get search ''LIBRARY''
''Encontrar el nombre exacto de la librería buscada''
apt-get install ''LIBRARY_NAME''
</code>

* En anaconda :
<code>
conda search ''LIBRARY''
conda install ''LIBRARY_NAME''
</code>

* Con pip :
<code>
pip3 search ''LIBRARY''
pip3 install ''LIBRARY_NAME''
</code>

'''CUIDADO !! '''

Debian no tiene siempre las últimas versiones, pero siempre son compatibles.

Anaconda puede tener problemas de compatibilidad entre versiones, se resuelve buscando versiones compatible especificando numero de versiones, puede convenir utilizar diferentes [[entornos_python]]

En general instalan las librerías necesarias al funcionamiento de lo que queremos instalar, pero a veces hay que instalarlo aparte.

== numpy ==
Numpy es la librería gestionando matrices.
Un elemento de numpy es una matriz que contiene elementos del mismo tipo, contrariamente a las listas en las cuales se pueden mezclar los tipos de datos. En función del tipo de dato y del número de dimensiones diferentes métodos y funciones estarán disponibles.

En vez de recorrer los elementos de las matrices uno a uno para hacer una operaciones, las funciones están optimizadas para que todo se haga más rápido, por eso antes de hacer una operación sobre matrices por si solo, mejor verificar si no existe en numpy.

=== Básico ===
<code>
import numpy as np

# Convertir una lista en numpy array, los elementos tienen que ser del mismo tipo
A = np.array(List)

# Crear una matriz llena de 0 con una cierta estructura
shape = (10,5) # en este caso una matriz 10*5
A = np.zeros(shape)
# full permite crear una matriz llena del número que indicamos, en esta caso 5
A = np.full(shape, 5)

# Obtener la estructura de una matriz
A.shape
# Obtener el número de elementos
A.size

=== Funciones ===

Existen numerosas funciones, si buscan algo en particular ver :
https://docs.scipy.org/doc/numpy/reference/

Entre otras :
* mean
* multiply
* true_divide
*...

=== matrices enmascaradas ===

Otro aspecto interesante de las matrices en numpy son las matrices "enmascaradas".
Permiten gestionar elementos enmascarados y realizar las operaciones ignorando estos elementos.
Una matriz enmascarada se define por una matriz numpy con los valores no enmascarados y una matriz numpy de boolean indicando cuales son los elementos enmascarados

<code>
import numpy as np
import numpy.ma as ma
A = np.random((4,3))
A_masked = ma.masked_where(A <0.5, A)

# ver el promedio de los elementos de A que son superiores a 0.5 :
print(ma.mean(A))
</code>

== pandas ==
Pandas es una libreria que facilita el trabajo con datos.

=== Series ===

Un tipo de datos en pandas son las series, indexada por numeros interos por defecto.

<code>
import numpy as np
import pandas as pd
s = pd.Series([1, 3, 5, np.nan, 6, 8])

print(s)
> output :
0 1.0
1 3.0
2 5.0
3 NaN
4 6.0
5 8.0
dtype: float64
</code>

=== Dataframe ===
Otro tipo de datos son los dataframe, se pueden considerar como una tabla con diferentes columnas (datos) y distintos '''index'''.

# Por si queremos un index siendo fechas
dates = pd.date_range(start="1/1/2018", periods=8, freq="D")
var = ["ET", "T", "Q", "W"]

# Creación de un dataset con numeros aleatorios, con las fechas entre el 01/01/2018 y el 08/01/2018 y con las variables de var en columnas
df = pd.DataFrame(np.random.randn(8, 4), index=dates, columns=var)

print(df)
> output :
ET T Q W
2018-01-01 -0.303859 1.541625 -0.158655 -0.106934
2018-01-02 -0.614769 -1.461621 -0.516678 -0.239503
2018-01-03 -0.678116 1.538130 -0.799381 0.610648
2018-01-04 0.356464 0.320538 0.941156 0.303474
2018-01-05 -1.138584 -0.001179 0.386963 -0.882730
2018-01-06 0.318615 0.743327 0.401269 2.555924
2018-01-07 -0.659930 0.925570 -1.514493 0.709833
2018-01-08 -0.231210 1.592285 -0.055710 -1.201247

* Las columnas pueden tener diferentes tipos de data (string, date, enteros..)
* Para definir un dataframe manualmente se usa diccionarios
<code>
df2 = pd.DataFrame({"A" : [1.], "B": ["hola"]})
print(df2)
> output:
A B
0 1.0 a
</code>

=== Visualización ===
* Para ver las primeras lineas : <code> df.head() </code>
* Para las ultimas : <code> df.tail() </code>
* Para el index : <code> df.index </code>
* Para las columnas : <code> df.columns </code>
* Para convertir en un array numpy (se pierde el index y las columnas): <code> df.to_numpy() </code>
* Para tener un resumen estadisticos rapido : <code> df.describe() </code>
<code>
A B C D
count 6.000000 6.000000 6.000000 6.000000
mean 0.073711 -0.431125 -0.687758 -0.233103
std 0.843157 0.922818 0.779887 0.973118
min -0.861849 -2.104569 -1.509059 -1.135632
25% -0.611510 -0.600794 -1.368714 -1.076610
50% 0.022070 -0.228039 -0.767252 -0.386188
75% 0.658444 0.041933 -0.034326 0.461706
max 1.212112 0.567020 0.276232 1.071804
</code>
* Para transponer datos : <code> df.T </code>
* Para ordenar según las valores de un axis (index) : <code> df.sort_index(axis = 1, ascending = False ) </code>
* Para ordenar por valores de una columna, por ejemplo si quiero ordenar por los valores de la columna denombrada "B" : <code> df.sort_values(by="B") </code>

*Selección :
** Para seleccionar la columna "A" : df["A"]
** Para el axis (index) número 1 : <code> df.loc[0] </code>, si los index son fechas, tengo que poner a la fecha en indice.
** <code> df.loc[0, "A"] </code> : devuelve el valor de la columna "A" para el axis.

*Datos faltantes
** Para dejar las lineas con datos faltantes : <code> df. </code>
** Para rellenar los datos faltantes :

*Operaciones
** Existen todo tipo de operaciones matematicas y estadisticas (promedio, standard desviation) que se pueden aplicar sobre una o varias columas/lineas.

=== Graficar ===
* Time Series
<code>
# Se puede realizar el time serie simple via :
ts.plot() # Para una serie de datos
df.plot() # Para un dataframe
</code>

* Se pueden explicitar en la función plot el tipo de gráfico que queremos realizar via '''kind''' : el valor puede ser ‘bar’,’barh’,’pie’,’scatter’,’kde’ etc
* '''color''' para definir los colores
* '''linestyle''' para definir el estilo de linea ‘solid’, ‘dotted’, ‘dashed’
* '''xlim''', '''ylim''' son tuple para definir los limites del axis x y del axis y
* '''legend''' Boolean para mostrar o no la leyenda (nombre de cada columna con el color correspondiente)
* '''title''' Titulo del gráfico

Se combina también con funciones de matplotlib porque está baseado en matplotlib.

=== Importar/Exportar ===
*CSV
<code>
# Para leer un CSV
df = pandas.read_csv("/home/direccion/documento.csv")
# para guardar el dataframe df como un csv, definiendo el separador
df.to_csv('foo.csv', sep = ";")
</code>

*Excel
<code>
# Para leer un Excel
pandas.read_excel("/home/direccion/documento.xlsx")
# Para guardar un dataframe df como documento excel
df.to_excel('foo.xlsx', sheet_name='Sheet1')
</code>

== netcdf ==
NetCDF es un formato de almacenamiento de datos muy común en ciencias de la Tierra. Para más detalle ver : LINK

En python se puede trabajar directamente con los archivos netcdf, para leerlos, escribirlos, o modificarlos gracias a esta librería.

=== Leer un NetCDF desde python ===
<code>
# Importar la clase Dataset de netCDF4 bajo el nombre de NetCDFFile
from netCDF4 import Dataset as NetCDFFile

# Abrir el arquivo foo.nc, r de "reading"
ncfile = NetCDFFile("/home/anthony/foo.nc", "r")

# Este archivo contiene varios diccionarios: un para las variable, otro para las dimensiones, y también los atributos generales
ncfile.dimensions.keys() # permite ver las dimensiones
ncfile.variables.keys()

# si temp es una variable:
temp = ncfile.variables["temp"] #me permite acceder a esta variable y visualizar sus atributos y datos
# Pero sus datos no están cargados en la memoria
# Pero para acceder a sus datos necesito utilizar, por ejemplo si temp tiene dos dimensiones :
temp_data = ncfile.variables["temp"][:,:]

# Para ahorar memoria puedo decidir cargar unicamente la informacion que me es util :
temp_data = ncfile.variables["temp"][3:10,:]

# Para leer los atributos de una variable :
print dataset.variables['tcc']
> output :
<type 'netCDF4.Variable'>
float32 tcc(time, latitude, longitude
missing_value: 9.999e+20
name: tcc
title: Total cloud cover ((0-1))
unlimited dimensions: time
current shape = (1, 181, 360)
filling off
</code>

Finalmente para cerrar el archivo :
<code>
ncfile.close()
</code>

=== Para modificar un NetCDF ===
<code>
# Cargo el archivo en modo r+ que lee y abre la posibilidad a hacer modificaciones
ncfile = NetCDFFile("/home/anthony/foo.nc", "r+")
# Cargo la variable (no sus datos)
ncvar = ncfile.variables["var"]
# Cambio las valores que me interesan
ncvar[0,2] = 10.
# Sincronizo
ncfile.sync()
# Cierro
ncfile.close()
</code>

=== Para escribir un NetCDF ===

== xarray ==
Numpy mejorado para ciencias de la tierra, integra informaciones spacio-temporales y métodos de calculo simplificado que toma en cuenta estas informaciones.

== Matplotlib ==
Es '''LA''' librería gráfica de python, indispensable para graficar. Otras librerias integran funciones de graficos (seaborn, numpy..) pero en general están baseadas en matplotlib.

=== Empezar una figura ===
<code>
# para importar la librería
import matplotlib.pyplot as plt

# Para empezar la figura definiendo su tamaño, largo y alto en inches
plt.figure(figsize=(20,10))

# Se puede hacer subplot (poner varios gráfico en una sola figura)
# Por ejemplo ahí es el subplot 2 de una grilla de 2x2
# los números de los subplot van aumentando de la izquierda a la derecha y de arriba hacia abajo, aca el número dos sería el subplot arriba a la derecha
plt.subplot(2, 2, 1)
</code>

Este comando me ubica en este subplot para después graficar lo que especificare después.

=== Para graficar ===
'''Gráficos 1D'''

Para graficar una serie de punto, x son los valores del eje horizontal y y del eje vertical :
<code>
x = np.arange(10)
y = x**2
# (Opcional) Se pueden especificar varios parametros, como el color, el estilo de linea ...
plt.plot(x, y, color = ‘green’ , linewidth = 2, linestyle = “-”)
</code>

Para graficar una nube de puntos :
<code>
plt.scatter(x, y, marker = ‘o’, color = ‘red’)
</code>

'''Gráficos 2D'''

Para graficar datos 2D, existen varias funciones : ''contour'', ''contourf'', ''scatterplot'', ''imshow''...
Estas funciones toman por parámetro X, Y y C :
* X y Y son array 2D con las diferentes coordenadas horizontal y vertical
* C es un array 2D que contiene los datos correspondiente

Si solo se usa C, matplotlib puede dar una previsualización del gráfico en el cual consideró una grilla regular.

Por ejemplo :
<code>
# Colormap es para especificar la mapa de color
cs = plt.contourf(X, Y, C, colormap = "rainbow")
# Se puede después mostrar la escala de color con
plt.colorbar(cs)
</code>

'''Personalización'''

Si se especifica en la función que usé para graficar un parametro '''label''', puedo mostrar la leyenda del gráfico con :
<code>
plt.legend()
</code>

Se puede definir un label para los diferentes axis con :
<code>
plt.ylabel('Precipitación', fontsize = 15) #for y label
plt.xlabel('Time', fontsize = 15) #for x label
</code>

Se puede definir los diferentes xticks, y hasta cambiar sus nombres

<code>
# Definición de los yticks
plt.yticks([0,2,4,6,7,10])
# Definición de los xticks y cambio de nombre
plt.xticks([0,1,2,3,4,5], [“0”, “1oz”, "2oz”, “3oz”, “4oz”])
</code>

<code>
# definir los limites de los axis ''y'' y ''x''
plt.ylim(-1.0,1.0) #for y axis
plt.xlim(0, 50) #for x axis
</code>

Para guardar la figura
<code>
plt.savefig('plot1.jpg')
</code>

=== Para más ===
Ejemplo de código python disponible para todo tipo de gráficos en :
https://www.data-to-viz.com/

También se puede ver la págino oficial de la libreria :
https://matplotlib.org/examples/

Otras librerias basadas en Matplotlib están disponible, como seaborn.

== cartopy ==
Cartopy es la libreria para trabajar con cartas. La libreria anterior es basemap, utilizada en muchos scripts, pero ya no será actualizada, entonces porque no pasarte directamente a cartopy??

Cartopy funciona con Matplotlib pero agrega la posibilidad de trabajar con datos geospaciales.

= Para ir más lejo =
Para desarollar funciones con más potencial se puede trabajar en languaje de más bajo nivel (se recuerdan que python es de alto nivel, es bastante flexible con la estructura de los codigos) como Fortran o Cython.
Es muy útil a la hora de recorrer indices, cosa por la cual python es bastante lento (terminado los loops <code>for i in range(1000)</code> que duran una eternidad).

== f2py3 ==
f2py3 es la libreria para utilizar funciones de fortran en python.

== cython ==
cython es la librería para utilizar funciones de C en python.

= Algunos tips =

= Ejercicios =