Última revisión de 20:36 4 jun 2024

Autor: Marisol OSMAN (a partir del trabajo de Anthony SCHRAPFFER)
Año: 2024
Contacto: osman@cima.fcen.uba.ar

Si tienen sugerencias, correcciones o comentarios, no duden en contactarse !

En las Ciencias de la Tierra se suele trabajar con muchos datos (observaciones, salidas de modelo, etc.) y para analizar estos datos y comunicar resultados vía gráficos o mapas uno necesita una herramienta adecuada. Al buen trabajador, las buenas herramientas: esta página les presenta Python.

Esta guía intenta darles un entendimiento básico de Python, y algunas herramientas prácticas para las áreas de las Ciencias de la Tierra para facilitar un primer uso de este lenguaje de programación. Para ir más allá, pueden ir a buscar soluciones a sus problemas en la comunidad de usuarios cercanos o en línea.

Contenido

1 Introducción
2 Para empezar
3 Basic Python
4 Librerías
5 Para ir más lejos
- 5.1 f2py3
- 5.2 cython
6 Algunos tips
- 6.1 import this
7 Ejercicios

[editar] Introducción

[editar] Presentaciones

Presentación

Ejemplos python

Ejemplo xarray

[editar] Paquete a instalar

Paquetes basicos:


sudo apt-get install python3 python3-scipy python3-numpy

Instalador de paquete pip:


sudo apt-get install python3-pip

Mas paquetes:


pip3 install netcdf4 matplotlib pandas
pip3 install xarray cartopy pooch

[editar] Historia

Python es un lenguaje de programación iniciado por Guido van Rossum. Tiene su nombre por la famosa serie de televisión Monty Python's Flying Circus, pero la serpiente marcó más su imaginación y por esta razón el lenguaje termina adoptándola como logo.

El lenguaje python es un lenguaje interpretado muy versátil y cada vez más utilizado en actividades de Ciencias de la Tierra y muchas otras disciplinas. Existen dos versiones del lenguaje (2.x y 3.x) las cuáles no son compatibles. Los cambios son menores (ej.: print 'Hola' --> print('Hola')), pero requiere una recodificación de los scripts. En este curso vamos por lo más moderno, python 3 ya que la versión 2 no es actualizada desde 2020.

Python es un lenguaje muy rico, porque está constituido por aportes de usuarixs de todo el mundo en forma de paquetes fáciles de instalar.

[editar] Por qué 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 está basado)

Por la estructura de los datos:

numerosos tipos de objetos disponibles (ya integrado o en librerías) y posibilidad de crear clases

Por la gran comunidad que lo usa:

mucha información en internet, libros, librerías disponibles y actualizadas

[editar] Para empezar

[editar] A saber antes de empezar

Python es un Lenguaje de alto nivel por lo que no hay necesidad de definir todo lo que hacemos, interpreta mucho pero CUIDADO, hay que estar atento con lo que estamos manipulando. Si dejamos a Python interpretar el tipo de una variable, puede influir en las operaciones que podremos aplicar a esta variable.
El lenguaje reconoce minúsculas y MAYÚSCULAS
Python empieza a contar desde 0, así el primer elemento de una lista, arreglo, etc. es el elemento 0 !
Los espacios a principio de línea cuentan para definir los bloques
Se puede ("se debe") comentar con :

 # para que el resto de la línea sea considerada como comentario


"""
Esto permite
Comentar sobre varias líneas
"""

Si queremos cortar una línea de código en varias se puede usar \ y empezar la línea siguiente a un nivel más alto (recuerdan que los espacios a principio de linea permiten definir los bloques)
Para imprimir en pantalla una o más variables se usa la función print(variable) . Se pueden imprimir en pantalla diferentes variables en una sola llamada con : print(variable1, variable2)
Cada tipo de elemento tiene sus propias características y métodos.
Se pueden escribir varios comandos en una sola linea, solo hace falta separarlas con el símbolo ;
Cuando se usa un comando como un for, if, while etc. la línea llamando a este comando se termina por : y los comandos utilizados adentro de esta condición se definen en un bloque de nivel más alto, para que quede más claro esta noción de bloque siguen dos ejemplos :


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

out:
>>> 3


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

out:
>>> 1
>>> 2
>>> 3

Otra noción importante es la diferencia entre función y método, ambas pueden pueden devolver números, listas, etc., pero:
- Una función puede aceptar cero o más parametros de entrada y no está asociada a un objeto en particular. Ej.:


sum(a,b) # función retornando la suma de a y b

- Un método se aplica a un objeto, y puede tener parámetros de entrada. Ej.:


Lista = []      # creo una lista vacía
Lista.append(1) # agrego 1 a la Lista

[editar] Como usarlo

[editar] En la terminal

Se puede llamar a python desde la terminal

 user@cima:~$ python3

Para después hacer las operaciones que queremos :

 
>>> 1+2 
 3

Y para salir basta con un

 
exit()
# o un 
quit()

Trabajar en la terminal permite probar algunas lineas de códigos, funciones ... Pero para poder trabajar de manera mas eficiente podemos usar los scripts.

[editar] En script

Un script de python es un documento texto con el formato : name_script.py

Es importante empezar el documento especificando con que entorno python lo queremos leer :

 #!/usr/bin/env python3

También se puede especificar el formato de codificación de caracteres, por ejemplo

 # -*- coding: utf-8 -*-

Después se tienen que importar las librerías que usamos en el script (si es que usamos): import this

Y finalmente viene el código !

Se puede agregar al final del documento lo siguiente


if __name__ == "__main__":

Lo incluido dentro de este bloque se ejecutará solo si el script es ejecutado. Si este script es importado como modulo desde otro script lo incluido en esta parte del código no se ejecutará. Sirve, por ejemplo, para probar las funciones que integran el código (debug).

[editar] Ayudándose de un IDE

Los IDE (Integrated Development Environment a.k.a. Entorno de desarrollo integrado) son muy útiles para facilitar el desarrollo de un script, contienen en general:

una parte con múltiples pestañas para poder navegar entre los diferentes scripts
un terminal para ir probando comandos
la posibilidad de leer todo o parte del script, visualizando los output en la terminal
opciones para visualizar ciertas variables, tablas etc.

Algunos ejemplos de IDE son :

Jupyter
pycharm
Spyder

[editar] En los servidores

Se puede usar en los servidores, se recomienda instalar Python y las librerías desde anaconda, para más detalles se recomienda 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 investigar en el artículo siguiente los entornos Python :

entornos_python

[editar] Basic Python

[editar] Tipos de Objetos

Existen varios tipos de objetos ya incluidos en python, cada tipo de objeto es una clase con su propio tipo de datos, sus propios métodos, funciones y operaciones para interactuar entre objetos similares o de otro tipo.

Para conocer la clase de un objeto python, se puede utilizar la función siguiente que retorna la informacion deseada para el objeto obj : type(obj)

[editar] 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; y si el número no tiene decimales se puede definirlo como float agragandole un "." al final.


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

# Para convertir los números
float(a) # retorna un número flotante valiendo 5.
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 hacer simplificaciones por ej. para la impresión en pantalla
round(4.5578945, 3) # reduce a 3 numero decimales el flotante
> 4.557

[editar] Condiciones y Boolean

Los boolean (o tipo de dato lógico) son True y False, y también pueden ser representados respectivamente como 1 y 0.

Se puede evaluar una expresión utilizando diferentes símbolos de comparación, lo que nos retorna un boolean :


<
>
==
!=
in / not in 
is / is not

Funciones verificando otros aspectos pueden retornar un boolean.

Se puede evaluar matrices gracias a Numpy (más detalles en otra parte), lo que nos devuelve una matriz de boolean, o un solo boolean si especificamos : .any() o .all()


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

[editar] String : Cadenas de caracteres

El formato de datos que contiene caracteres se llama String. Se puede definir un string de dos maneras : 'string' o "string".


# Para trabajar con un ejemplo
word1 = "Hola"
word2 = "Mundo"

Se pueden agregar varios string gracias al +


print(word1 + "_" + word2)
> output : "Hola Mundo"

Pueden ser vistos como una lista de caracteres simples


print(word1[0])
> output : "H"

word.upper(), word.lower() devuelven una copia de word en mayúscula / minúscula
Varios métodos permiten verificar ciertas características del string, devuelven un boolean:
- word1.isalnum() : True si solamente caracteres son alfanuméricos
- word1.isalpha() : True si solo caracteres alfabetices
- word1.islower() : True si todo en minúscula
- word1.isnumeric() : True si todos son caracteres numéricos
- word1.isupper() : True si todo en mayúscula
- ...
separador.join(Lista_de-string) : devuelve un string con los elementos de las lista separado por el separador


print("-".joint([word1, word2]))
> output : "Hola-Mundo"

string.split(separador) : devuelve una lista con los elementos de string entre cada separador, " " es utilizado si no hay separador especificado:


print("Ahora-podemos-probar".split("-"))
> output : ["Ahora", "podemos", "probar"]

frase.replace(str1, str2) : 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 str() :


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

A partir de python 3.6 también se pueden usar el formato "f-strings" para concatenar de manera más simple y clara:


a = 2+3
Resultado = f"La suma es {a}."
print(Resultado)
>>> output :  La suma es 5.

[editar] 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

[editar] Listas

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


# 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

Se puede hacer fácilmente loop con las listas :


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

> output : 
 "file1"
 "file2"
 "file3"

Se puede acortar una lista a una o más elementos :


# 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

Recuerden que un string puede ser considerado como una lista.

[editar] Tuple

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


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"

La principal diferencia es que los elementos no pueden ser modificados ni se pueden agregar nuevos elementos, hay que redefinir la lista si se quiere cambiar sus elementos.

[editar] Diccionarios

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


# Diccionario vacío
D = {}

# Inicialización de un diccionario
# 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"]

D.keys() devuelve la lista de los identificadores

D.values() devuelve la lista de los diferentes valores

D.items() devuelve un tuples con los diferentes items

Por ejemplo :


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

[editar] Error de principiante:

copiar listas y diccionarios de manera errónea e introducir cambios en los elementos.


lista1 = [0, 1, 2, 3]
lista2 = lista1
lista2[2] = lista2[2]*100
print(lista2)
>>> output:
   [0, 1, 200, 3]
print(lista1)
>>> output:
    [0, 1, 200, 3]

Las variables lista1 y lista2 apuntan al mismo objeto en la memoria. Por lo tanto, los cambios en los elementos de una se aplican a la otra. La solución es usar copy() o deepcopy() (de la libreria copy) dependiendo el caso. Ej:


lista1 = [0, 1, 2, 3]
lista2 = lista1.copy()
lista2[2] = lista2[2]*100
print(lista2)
>>> output:
   [0, 1, 200, 3]
print(lista1)
>>> output:
    [0, 1, 2, 3]

[editar] Loops: bucles

[editar] for x in

Para recorrer una lista de elementos se puede usar el comando for


for x in List:
   instrucciones utilizando x

El loop va a recorrer la lista utilizando sus elementos uno a uno refiriéndose a ellos como x.

Construyendo lista de enteros fácilmente con la función range podemos escribir :


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

También se puede recorrer dos listas en simultaneo utilizando la función zip :


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"

[editar] while

Se puede también utilizar una condición para hacer un loop, mientras la condición siga siendo válida se sigue ejecutando el comando del loop :


while 'condition':
    instrucción

Tener cuidado con poder siempre salir del loop, sino el script seguirá corriendo sin fin. Hay que verificar que por lo menos un elemento de la función llega a cambiar y que llega a no cumplir la condición para salir del bucle.

[editar] Parar una loop

Se puede parar una loop con el uso de break .


while 'condición':
   instrucciones
   if 'condición de stop':
       break

[editar] Más herramientas

Manipular estos diferentes objetos es esencial, pero para trabajar de manera eficiente hay otras herramientas disponibles.

[editar] 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 en memoria, pero cuando utilizamos una función sólo los elementos retornados quedan guardados en memoria.
Una vez que la función termina de ejecutarse, las variables locales son borradas.

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


def nombre_función(variables_entrantes):
   # Noten que termino la linea anterior con ":"
   # Noten que paso a otro nivel de código
   código
   return output

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 :


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 prolijos : 
c = mi_funcion(a = 1, b = 3)
print(c)
> 4

[editar] Clases

Python ofrece la posibilidad de crear sus propios tipos de objetos via las clases. Permite tener una versión operacional y muy personalizada para gestionar los datos que manipulamos. Se crea una clase de la manera siguiente :


class MiClase:
   def __init__(self, input):
       # Método de inicialización
       self.parametro_a = input
       self.metodo_adicional_1()

   # Operaciones del método adicional 1 
   def metodo_adicional_1(self):
       print(f"Método adicional 1. Parametro_a: {self.parametro_a}")

   # Operaciones del método adicional 2
   def metodo_adicional_2(self, input2):
       print(f"Método adicional 2 con {input2}")

Para utilizarla se puede iniciar un objeto de la manera siguiente :


# Creación de un objeto de la clase MiClase
mi_obj = MiClase(input="mi_entrada")
>>> output: Método adicional 1. Parametro_a: mi_entrada

# Uso de un método de la clase
mi_obj.metodo_adicional_1()
>>> output: Método adicional 1. Parametro_a: mi_entrada

# Uso de otro método de la clase
mi_obj.metodo_adicional_2(input2="otra_entrada")
>>> output: Método adicional 2 llamado con otra_entrada

[editar] Mejorar sus scripts

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

Funciona de la manera siguiente :


try:
   'Codigo'
except:
   'En cualquier caso de error, corro estas instrucciones'

Por ejemplo :


print(a)
> output : NameError: name 'a' is not defined


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"

Permitió correr el código sin que éste se detenga por el error.

[editar] Librerías

[editar] Instalar Librerías

En Debian :

En general las librerías se encuentran con el nombre python3-nombre.

Primero, entrar al modo superuser (su)


su root
Entrar contraseña para acceder al modo superuser

Buscar la libreria para conocer el nombre exacto :


apt-get search LIBRARY
Encontrar el nombre exacto de la librería buscada

Instalar la libreria :


apt-get install LIBRARY_NAME

En anaconda :


conda search LIBRARY
conda install LIBRARY_NAME

Con pip :

pip es un gestionador de paquetes para python


pip3 search LIBRARY
pip3 install LIBRARY_NAME

CUIDADO !!

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

Anaconda puede tener problemas de compatibilidad entre versiones, se resuelve buscando versiones compatibles especificando numero de versiones, puede convenir utilizar diferentes entornos_python. Se recomienda instalar todas las librerías deseadas de una vez en el mismo comando conda install LYBRARY1 LYBRARY2 LIBRARY3 para evitar conflictos de versiones

En general, se instalan automáticamente los paquetes necesarios para el funcionamiento de la librería que queremos instalar, pero a veces hay que instalarlo aparte.

[editar] Numpy

Numpy es la librería más usada para gestionar 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 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.

[editar] Básico


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) # 10 filas y 5 columnas
A = np.zeros(shape)

print(A)
> output: 
array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]])

# full permite crear una matriz llena del número que indicamos, en esta caso 5 
A = np.full(shape, 5) 

print(A)
> output:
array([[5, 5, 5, 5, 5],
       [5, 5, 5, 5, 5],
       [5, 5, 5, 5, 5],
       [5, 5, 5, 5, 5],
       [5, 5, 5, 5, 5],
       [5, 5, 5, 5, 5],
       [5, 5, 5, 5, 5],
       [5, 5, 5, 5, 5],
       [5, 5, 5, 5, 5],
       [5, 5, 5, 5, 5]])

# Obtener la estructura de una matriz 
print(A.shape)
> output: (10, 5)

# Obtener el número de elementos
print(A.size)
> output: 50

[editar]  Funciones 
Existen numerosas funciones, si buscan algo en particular ver : 
https://docs.scipy.org/doc/numpy/reference/
Entre otras : 

 mean
 multiply
 true_divide
...

[editar]  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 booleans indicando cuáles son los elementos enmascarados.
<code>

import numpy as np
import numpy.ma as ma

A = np.random.rand(4,3) # matriz random con valores entre 0-1

A_masked = ma.masked_where(A <0.5, A)

# ver el promedio de los elementos de A que son superiores a 0.5 : 
ma.mean(A_masked)

[editar] Pandas

Pandas es una librería que facilita el trabajo con datos.

[editar] Series

Un tipo de datos en pandas son las series, indexada por números enteros por defecto, pero se puede especificar indices personalizados.


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

[editar] 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 números 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


df2 =  pd.DataFrame({"A" : [1.], "B": ["hola"]})
print(df2)
> output:
       A  B
  0  1.0  a

[editar] Visualización

Para ver las primeras lineas : df.head()
Para las ultimas : df.tail()
Para el index : df.index
Para las columnas : df.columns
Para convertir en un array numpy (se pierde el index y las columnas): df.to_numpy()
Para tener un resumen estadísticos rapido : df.describe()


              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

Para transponer datos : df.T
Para ordenar según las valores de un axis (index) : df.sort_index(axis = 1, ascending = False )
Para ordenar por valores de una columna, por ejemplo si quiero ordenar por los valores de la columna referenciada como "B" : df.sort_values(by="B")

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

Datos faltantes
- Para dejar las lineas con datos faltantes : df.
- Para rellenar los datos faltantes :

Operaciones
- Existen todo tipo de operaciones matemáticas y estadísticas (promedio, standard deviation) que se pueden aplicar sobre una o varias columnas/lineas.

[editar] Graficar

Time Series


# Se puede realizar el time serie simple via : 
ts.plot() # Para una serie de datos
df.plot() # Para un dataframe

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á basado en matplotlib.

[editar] Importar/Exportar

CSV


# 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 = ";")

Excel


# 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')

[editar] NetCDF

NetCDF es un formato de almacenamiento de datos muy común en Ciencias de la Tierra. Para más detalle ver : netCDF

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

[editar] Leer un NetCDF desde python


# 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: uno 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

Finalmente para cerrar el archivo :


ncfile.close()

[editar] Para modificar un NetCDF


# 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()

[editar] Para escribir un NetCDF


from netcdf4 import Dataset as NetCDFFile
import numpy as np

Empezar a escribir el archivo netcdf al lugar indicado, "w" es para writing. CUIDADO Si ya existía un archivo en esta dirección, sera sobrescrito !


foo = NetCDFFile('data/test.nc','w')

Para crear las dimensiones, con el nombre de las dimensiones y la dimensión. En caso de ser una variable ilimitada, se inscribe None.


level = foo.createDimension('level', 10)
lat = foo.createDimension('lat', 73)
lon = foo.createDimension('lon', 144)
time = foo.createDimension('time', None)

Para crear las variables, con el nombre, el tipo de datos y las dimensiones relacionadas. Agregando zlib = True al final autoriza la compresión del archivo, es decir que los espacios sin datos no ocupan espacio.

Primero no agregar las variables detallando las dimensiones, agrego un 's' a sus nombres para no confundirlas con las dimensiones. times = foo.createVariable('time', np.float64, ('time',), zlib = True) levels = foo.createVariable('level', np.int32, ('level',)) latitudes = foo.createVariable('latitude', np.float32,('lat',)) longitudes = foo.createVariable('longitude', np.float32,('lon',))

Después se puede crear las variables que queremos guardar :


 temp = dataset.createVariable('temp', np.float32,('time','level','lat','lon'))

Para ponerles valores es muy simple, por ejemplo :


lats = np.arange(-90,91,2.5)
lons = np.arange(-180,180,2.5)
latitudes[:] = lats
longitudes[:] = lons

# Y si tengo T un array a 4 dimensiones con las buenos dimensiones, en el buen orden (time, level, lat, lon) : 
temp[:,:,:,:] = T

Después es importante describir las variables y el archivo via los atributos.

Para los atributos globales :


foo.description = 'Mean temperature datasets'
foo.history = 'Created 13/06/2019'
foo.source = 'netCDF4 python example'

Para las variables :


latitudes.units = 'degree_north'
longitudes.units = 'degree_east'
levels.units = 'hPa'
temp.units = 'K'
times.units = 'seconds since 1900-01-01 00:00:00'
times.calendar = 'gregorian'

Una dificuldad para describir el tiempo, hay que convertir las fechas en un formato compatible (en general secundos desde una cierta fecha, cf ejemplo). Nos ayudara la función siguiente para convertir estas fechas :


from netcdf4 import date2num
from datetime import datetime, timedelta

Para el ejemplo, creo una lista de fechas :


Dates = [datetime(2001, 3, 1)+n*timedelta(hours=12) for n in range(10)]
times[:] = date2num(Dates, units = times.units)

Para terminar, no olvidar sincronizar y cerrar :


foo.sync()
foo.close()

En el caso de que una variable sea ilimitada, se puede ir agregando nuevos datos. No olviden definir nueva descripción de los pasos temporales en la variable asociada con el tiempo.

[editar] xarray

xarray es un paquete de Python pensado para trabajar fácilmente con arreglos multidimensionales con etiquetas en forma de dimensiones, coordenadas y atributos. Es especialmente útil para trabajar con datos grillados georeferenciados, particularmente archivos netCDF.

xarray toma funciones de Numpy y Pandas para trabajar fácil y eficientemente e integra la librería Dask para computación en paralelo y manejo de grandes archivos.

Sitio web: http://xarray.pydata.org

[editar] ¿A qué nos referimos con todo esto?

xarray es capaz de leer la metadata incluída en los archivos netCDF y posee poderosas herramientas para fácilmente seleccionar variables, recortar dimensiones y hacer cálculos básicos pero laboriosos en una sola línea, entre otras cosas.

[editar] Ejemplo

Se puede ver un tutorial en formato html (abrir con el navegador) o de manera interactiva en Jupyter Notebook usando los archivos del siguiente link: Introducción a xarray en html y Jupyter Notebook

[editar] Comandos básicos

[editar] Abrir un archivo


# Cargamos los paquetes
import xarray as xr

# Abrimos un archivo
data_xr = xr.open_dataset('archivo.nc', engine='netcdf4')

# Si es un .grib: (debemos tener los paquetes cfgrib y eccodes instalados)
data_grib = xr.open_dataset('example.grib', engine='cfgrib')

# en este tutorial abrimos un dataset que xarray tiene de ejemplo
ds = xr.tutorial.load_dataset("air_temperature")


# Vemos la metadata
ds

<xarray.Dataset>
Dimensions:  (lat: 25, time: 2920, lon: 53)
Coordinates:
  * lat      (lat) float32 75.0 72.5 70.0 67.5 65.0 ... 25.0 22.5 20.0 17.5 15.0
  * lon      (lon) float32 200.0 202.5 205.0 207.5 ... 322.5 325.0 327.5 330.0
  * time     (time) datetime64[ns] 2013-01-01 ... 2014-12-31T18:00:00
Data variables:
    air      (time, lat, lon) float32 ...
Attributes:
    Conventions:  COARDS
    title:        4x daily NMC reanalysis (1948)
    description:  Data is from NMC initialized reanalysis\n(4x/day).  These a...
    platform:     Model
    references:   http://www.esrl.noaa.gov/psd/data/gridded/data.ncep.reanaly...


# Podemos extraer la variable y sus dimensiones de esta forma
tas = ds['air'] 

lon = ds['lon']
lat = ds['lat']


# También se puede convertir, por ejemplo, un numpy array a un xarray usando:
import numpy as np
data_xrnp = xr.DataArray(np.random.randn(2, 3), coords={'x': ['a', 'b']}, dims=('x', 'y'))

[editar] Cómo recortar un dominio espacial o temporal


# Recortamos el dominio
ds_cut = ds.loc[{'time':slice('2013-03-01','2013-03-07'), 'lat':slice(75, 60, -1), 'lon':slice(210,220)}]

# También se puede usar el método .sel() de manera similar
ds_cut = ds.sel(time=slice('2013-03-01','2013-03-07'), lat=slice(75, 60, -1), lon=slice(210,220))

Al usar slice(a,b) le estamos indicando que tome todos los valores comprendidos entre a y b. Si, además, le agregamos "-1", slice(a,b,-1), le indicamos que nos de vuelta esa coordenada. Le agrego el -1 para dar vuelta la coordenada latitud y quede de menor a mayor, al igual que la longitud.

[editar] Cálculos básicos

Los arreglos de xarray funcionan de manera similar a los de numpy, sumado a que ciertas operaciones se pueden hacer especificando los nombres de las dimensiones en lugar de sus índices.


# Podemos calcular la media total en el tiempo de estas dos maneras:
tas_mean = tas.mean(axis=0) # Porque sabemos que 'time' es la primer coordenada, es decir la coordenada 0
tas_mean = tas.mean(dim='time')

# Graficamos directamente desde xarray (gráficos básicos para visualizar rápido)
tas_mean.plot.pcolormesh(vmax=310, cmap='YlGnBu') # vmax es el máximo de la colorbar, cmap el mapa de colores


# También podemos hacer otras operaciones como suma y restas
tas_sum = tas.sum(dim='time')

[editar] groupby y resample

xarray ya tiene manejo de dimensiones tipo calendario y nos brinda útiles herramientas para hacer cálculos en una sola línea


# Calcular el ciclo diurno medio:
tas_hour_means = tas.groupby('time.hour').mean(axis=0)


# Pasar a datos diarios
tas_daily = tas.resample(time='1D').mean(axis=0) # o time='24H'

# Pasar a datos estacionales
tas_seas = tas.resample(time='QS').mean(axis=0)  # QS : quarter start

[editar] Guardar en un netCDF


# Para guardar en un archivo netCDF:
tas_seas.to_netcdf('tas_seas.nc')

[editar] Cómo cargar múltiples archivos y/o usar Dask

Lo que hace Dask es dividir en bloques nuestro dataset y realizar los cálculos de manera paralela, es decir, envía a cada núcleo del procesador uno de estos bloques y va calculando en simultáneo. Luego une el resultado final. Esto permite que sea mucho más rápido en sus cálculos al dividir el trabajo entre los múltiples núcleos del procesador. Se recomienda usarlo siempre que sus archivos sean pesados, ya que las funciones y métodos aplican de la misma forma que si uno no tuviera Dask activo y ganará en rendimiento al hacer cálculos.

Para activar dask usar la opción 'chunks' dentro de .open_dataset().

El método .open_mfdataset() abre múltiples archivos y ya activa Dask asignando por defecto un bloque = un archivo, pero conviene especificar 'chunks' para que sea más eficiente al calcular. En el sitio de xarray recomiendan que cada bloque contenga aproximadamente un millón de elementos.

Al abrir una serie de archivos con .open_mfdataset() automáticamente se concatenan a lo largo de las dimensiones posibles.


# Abrir un dataset de múltiples archivos (poner * como wildcard)
data_mf = xr.open_mfdataset('total_precipitation_year_198*.nc', chunks={'time':20})

xarray con Dask activado funciona de forma "perezosa" o "lazy", quiere decir que no hace ningún cómputo hasta que le pedimos los datos explícitamente (al graficar, guardar en un archivo o con .compute())


# De esta forma no se hace el cómputo todavía
tp_mfmean = data_mf['tp'].loc[{'latitude':slice(-30,0,-1), 'longitude':slice(-60,-40)}].mean(axis=0)

# Si especifico .compute() sí hace el cáculo:
tp_mfmean = data_mf['tp'].loc[{'latitude':slice(-30,0,-1), 'longitude':slice(-60,-40)}].mean(axis=0).compute()

[editar] Otros

Eso es todo por ahora! Hay muchas otras herramientas para hacer selecciones de los datos, transformar los arreglos, mover o modificar las coordenadas, etc. Por ejemplo:

Concatenar, unir, combinar:

Para combinar datasets o data arrays a lo largo de una dimensión: xr.concat()  
Para combinar datasets con distintas variables: xr.merge()  
Para combinar datasets o data arrays con diferentes índices o valores faltantes: xr.combine()  
http://xarray.pydata.org/en/stable/combining.html

Interpolar:

Con el método .interp() podemos interpolar un DataArray a una nueva grilla, mientras que con .interp_like() podemos interpolar un DataArray a las coordenadas de otro DataArray. Este método utiliza los métodos de interpolación del paquete Scipy, los cuales son métodos simples (lineal, cúbica).

[editar] Matplotlib

Es LA librería gráfica de python, indispensable para graficar. Otras librerías integran funciones de gráficos (seaborn, numpy..) pero en general están basadas en matplotlib.

Existen una infinidad de posibilidades con matplotlib, el objetivo de esta parte es dejar unas bases para que cada uno después busque como personalizar a su gusto su gráfico.

[editar] Empezar una figura


# para importar la librería
import matplotlib.pyplot as plt

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

# Se puede hacer subplot (poner varios gráfico en una sola figura)
# Por ejemplo 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, acá el número dos sería el subplot arriba a la derecha
plt.subplot(2, 2, 1)

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

[editar] Para graficar

Gráficos 1D

Para graficar una serie de punto, x son los valores del eje horizontal y y del eje vertical : x = np.arange(10) y = x**2


 (Opcional) Se pueden especificar varios parámetros, como el color, el estilo de linea ...

plt.plot(x, y, color = ‘green’ , linewidth = 2, linestyle = “-”)

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

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 :


# 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)

Personalización

Si se especifica en la función que usé para graficar un parámetro label, puedo mostrar la leyenda del gráfico con :


plt.legend()

Se puede definir un label para los diferentes axis con :


plt.ylabel('Precipitación', fontsize = 15) #for y label
plt.xlabel('Time', fontsize = 15) #for x label

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


# 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”])


# 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

Para guardar la figura :


plt.savefig('plot1.jpg')

Finalmente para cerrar :


plt.close()

[editar] 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 librerías basadas en Matplotlib están disponible, como seaborn.

[editar] Cartopy

Cartopy es la librería para trabajar con mapas. La librería anterior es Basemap, utilizada en muchos scripts, pero ya no será actualizada y entonces porque no empezar directamente con cartopy??

Cartopy funciona con Matplotlib pero agrega la posibilidad de trabajar con datos geo-espaciales.

Por ejemplo si tengo un array numpy de datos de temperatura de 2 dimensiones llamado Temp de dos dimensiones, con sus respectivo lon y lat cada uno de una dimensión


import cartopy
import cartopy.crs as ccrs
import matplotlib.pyplot as plt
import numpy as np
import numpy.ma as ma
from netCDF4 import Dataset as NetCDFFile

ncfile = NetCDFFile(ncdir, "r")

# Suponemos que temp tiene por variable (time, lat, lon)
# Promedio temporal de la temperatura : 
temp = ma.mean(ncfile.variables["Temp"][:,:,:], axis = 0) 

# Para obtener las longitudes, latitudes
lon = ncfile.variables["lon"][:]
lat = ncfile.variables["lat"][:]

# Empezar la figura
fig = plt.figure(figsize= (20,10))

# Empezar con la proyección deseada
ax = plt.axes(projection=ccrs.PlateCarree())

# Por si queremos trabajar con subplot
ax1 = plt.subplot(2, 1, 1, projection=ccrs.PlateCarree())

# Si queremos poner color a la superficie terrestre
ax.add_feature(cartopy.feature.LAND)
# Si queremos poner color a los oceanos
ax.add_feature(cartopy.feature.OCEAN)
# Para graficar las costas
ax.add_feature(cartopy.feature.COASTLINE)

# Para graficar los datos, es posible que tengan que usar la opción "transform" si sus datos no están en la misma proyección. 
ax.contourf(lons, lats, temp)

plt.show()
plt.close()

Para graficas las longitudes / latitudes :


from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER
import matplotlib.ticker as mticker

# Armo la grilla con los detalles que me gustan
gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True,
     linewidth=1, color='k', alpha=0.7, linestyle='--')

# Preparo las locaciones de longitud / latitud
gl.ylocator = mticker.FixedLocator(np.arange(-90,90,10))
gl.xlocator = mticker.FixedLocator(np.arange(-180,0,10))

# Por si quiero o no latitud a la izq./der.
# Si puse True a draw_labels, todo están puesto directamente a True
gl.ylabels_right = False
gl.ylabels_left = True
gl.yformatter = LATITUDE_FORMATTER

# Lo mismo para la longitud
gl.xlabels_top = False
gl.xlabels_bottom = True
gl.xformatter = LONGITUDE_FORMATTER

Cartopy facilita la lectura de los datos GIS (shapefile ..), por ejemplo integra directamente la gestion de shapfile de Natural_earth


import cartopy.io.shapereader as shpreader

# Abrir la categoría deseada, con la resolución deseada
geo_reg_shp = shpreader.natural_earth(resolution='50m', category='physical',
                                       name='geography_regions_polys')
# Abrirlo
geo_reg = shpreader.Reader(geo_reg_shp)
# ax es el eje en uso, para graficar
ax = plt.gca()
# graficar todos los elementos, se puede seleccionar ciertos elementos con un if
# si queremos solo borde poner edgecolor = color de borde deseado y facecolor = 'none'
# hacer el contrario si solo queremos rellenar la forma
for rec in geo_reg.records():
   ax.add_geometries( [rec.geometry], ccrs.PlateCarree(), edgecolor="r", facecolor='none')

[editar] Para ir más lejos

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

Sirve también a paralelizar ciertas funciones manualmente.

[editar] f2py3

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

Primero compilar con f2py3 algún modulo fortran con las subroutinas que nos interesen. Por ejemplo : MODULE_one.f90


module one

contains

subroutine func(x,y, z)
    real(8), intent(in) :: x,y
    real(8), intent(out) ::z
    z = x*y
end subroutine
end module

Es importante explicitar las variables de entrada y de salida con intent(in), intent(out). La compilación nos da un archivo en .so

Después se puede importar el modulo desde python para utilizarla directamente como : from MODULE_one import *

result = one.func(x = 2, y = 3)

[editar] cython

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

[editar] Algunos tips

[editar] import this


The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

@@ Línea 1: / Línea 1: @@
-= Introduction =
+<!--
-== Histórico ==
+\Wc{}: &copy;Windows
+\W{}: Windows<SUP>TM</SUP>
+\L{}: Linux
+-->
+<PRE>
+Autor: Marisol OSMAN (a partir del trabajo de Anthony SCHRAPFFER)
+Año: 2024
+Contacto: osman@cima.fcen.uba.ar
+</PRE>
+''Si tienen sugerencias, correcciones o comentarios, no duden en contactarse !''
-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.
+En las Ciencias de la Tierra se suele trabajar con muchos datos (observaciones, salidas de modelo, etc.) y para analizar estos datos y comunicar resultados vía gráficos o mapas uno necesita una herramienta adecuada. Al buen trabajador, las buenas herramientas: esta página les presenta '''Python'''.
-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.
+Esta guía intenta darles un entendimiento básico de Python, y algunas herramientas prácticas para las áreas de las Ciencias de la Tierra para facilitar un primer uso de este lenguaje de programación. Para ir más allá, pueden ir a buscar soluciones a sus problemas en la comunidad de usuarios cercanos o en línea.
-La presentación se puede descargar desde este enlace [[File:python-TUX.pdf]]
-== Por que elegir Python ? ==
+= Introducción =
+== Presentaciones ==
+[https://drive.google.com/open?id=1Dh0L63zBGkcva1k6YMCBNJRjXytxg-fQ Presentación]
+[https://drive.google.com/open?id=15e7yXxeUbgJ28KYdTj0cSkMoabSoFxNT Ejemplos python]
+[https://drive.google.com/open?id=17PTCQMhewB6RpPv_QZAPsTt52s3HnRWe Ejemplo xarray]
+== Paquete a instalar ==
+Paquetes basicos:
+<code>
+ sudo apt-get install python3 python3-scipy python3-numpy
+</code>
+Instalador de paquete pip:
+<code>
+ sudo apt-get install python3-pip
+</code>
+Mas paquetes:
+<code>
+ pip3 install netcdf4 matplotlib pandas
+ pip3 install xarray cartopy pooch
+</code>
+<!--
+IDE Spyder:
+<code>
+ sudo apt-get install spyder3
+</code>
+-->
+== Historia ==
+Python es un lenguaje de programación iniciado por Guido van Rossum. Tiene su nombre por la famosa serie de televisión ''Monty Python's Flying Circus'', pero la serpiente marcó más su imaginación y por esta razón el lenguaje termina adoptándola 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 y muchas otras disciplinas. 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 los scripts. En este curso vamos por lo más moderno, '''python 3''' ya que la versión 2 no es actualizada desde 2020.
+Python es un lenguaje muy rico, porque está constituido por aportes de usuarixs de todo el mundo en forma de paquetes fáciles de instalar.
+== Por qué elegir Python ? ==
 *Por el diseño del lenguaje:
@@ Línea 22: / Línea 20: @@
 *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)''
+''puede funcionar con otros tipos de lenguajes de programación (C con cython, Fortran con f2py, en los cuales está basado)''
 *Por la estructura de los datos:
-''numerosos tipos de objetos disponibles''
+''numerosos tipos de objetos disponibles (ya integrado o en librerías) y posibilidad de crear clases''
-*Por la grande comunidad que lo usa:
+*Por la gran comunidad que lo usa:
-''mucha información en internet, libros, librerias disponibles y actualizadas''
+''mucha información en internet, libros, librerías 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.
+* Python es un '''Lenguaje de alto nivel''' por lo que no hay necesidad de definir todo lo que hacemos, interpreta mucho pero '''CUIDADO''', hay que estar atento con lo que estamos manipulando. Si dejamos a Python interpretar el tipo de una variable, puede influir en las operaciones que podremos aplicar a esta variable.
-* El lenguaje reconoce minusculas y mayusculas
+* El lenguaje reconoce minúsculas y MAYÚSCULAS
-* Python empieza a contar a 0, así el primer elemento de una lista es el elemento 0 !
+* Python empieza a contar desde 0, así el primer elemento de una lista, arreglo, etc. es el elemento 0 !
-* los espacios a principio de linea cuentan para definir los bloques
+* Los espacios a principio de línea cuentan para definir los bloques
-* se puede ("debe") comentar con :
+* Se puede ("se debe") comentar con :
- <code> # para que lo resto de la linea sea considerado como comentario </code>
+ <code> # para que el resto de la línea sea considerada como comentario </code>
- <code>"""
+ <code>
- Eso permite
+ """
- Comentar sobre varias lineas
+ Esto permite
+ Comentar sobre varias líneas
  """
 </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)
+* Si queremos cortar una línea de código en varias se puede usar <code> \ </code>  y empezar la línea siguiente a un nivel más alto (recuerdan que los espacios a principio de linea permiten definir los bloques)
-* 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>
+* Para imprimir en pantalla una o más variables se usa la función <code> print(variable) </code>. Se pueden imprimir en pantalla diferentes variables en una sola llamada con : <code> print(variable1, variable2) </code>
-* Cada tipo de elemento tiene sus propias caracteristicas y metodos.
+* Cada tipo de elemento tiene sus propias características y métodos.
-* Se puede escribir varios comandos en una sola linea gracias al simbolo <code> ;</code>
+* Se pueden escribir varios comandos en una sola linea, solo hace falta separarlas con el símbolo <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 :
+* Cuando se usa un comando como un ''for'', ''if'', ''while'' etc. la línea llamando a este comando se termina por ''':''' y los comandos utilizados adentro de esta condición se definen en un bloque de nivel más alto, para que quede más claro esta noción de bloque siguen dos ejemplos :
 <code>
@@ Línea 59: / Línea 57: @@
  ''out:
- > 3''
+ >>> 3''
 </code>
@@ Línea 69: / Línea 67: @@
  ''out:
- > 1
+ >>> 1
- > 2
+ >>> 2
- > 3''
+ >>> 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 :
+* Otra noción importante es la diferencia entre función y método, ambas pueden pueden devolver números, listas, etc., pero:
-** Una función puede tener entre 0 y lo que se desea de variables / parametros en input :
+** Una función puede aceptar cero o más parametros de entrada y no está asociada a un objeto en particular. Ej.:
-*:-<code>  sum(a,b) # función retornando la suma de a y b </code>
+<code>
-** Un método se aplica a un objeto, mismo si puede tener parametros en input
+ sum(a,b) # función retornando la suma de a y b
+</code>
+** Un método se aplica a un objeto, y puede tener parámetros de entrada. Ej.:
 <code>
  Lista = []      # creo una lista vacía
@@ Línea 84: / Línea 82: @@
 == Como usarlo ==
-=== En un terminal ===
+=== En la 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
+ <code>
+ >>> 1+2
 </code>
 Y para salir basta con un
- <code>exit()
+ <code>
- o un
+ exit()
- quit() </code>
+ # 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.
+Trabajar en la terminal permite probar algunas lineas de códigos, funciones ... Pero para poder trabajar de manera mas eficiente podemos usar los scripts.
 === En script ===
@@ Línea 108: / Línea 106: @@
  <code> # -*- coding: utf-8 -*- </code>
-Después se tienen que importar las librerias que usamos en el script (si es que usamos):
+Después se tienen que importar las librerías que usamos en el script (si es que usamos):
 <code> import this </code>
@@ Línea 116: / Línea 114: @@
 <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>
+Lo incluido dentro de este bloque se ejecutará solo si el script es ejecutado. Si este script es importado como modulo desde otro script lo incluido en esta parte del código no se ejecutará. Sirve, por ejemplo,  para probar las funciones que integran el código (debug).
+=== Ayudándose de un IDE ===
-=== Ayudandose de un IDE ===
+Los IDE (Integrated Development Environment a.k.a. Entorno de desarrollo integrado) son muy útiles para facilitar el desarrollo de un script, contienen en general:
-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 múltiples pestañas para poder navegar entre los diferentes scripts
-* 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
+* la posibilidad de leer todo o parte del script, visualizando los output en la terminal
-* Opciones para visualizar ciertas variables, tablas etc.
+* opciones para visualizar ciertas variables, tablas etc.
 Algunos ejemplos de IDE son :
+* Jupyter
+* pycharm
 * 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 :
+Se puede usar en los servidores, se recomienda instalar Python y las librerías desde anaconda, para más detalles se recomienda 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 :
+Por otro lado, si quieren usar diferentes configuraciones de las versiones de librerías utilizadas con linux pueden investigar en el artículo siguiente los entornos Python :
 [[entornos_python]]
 = Basic Python =
-== Tipos de variables ==
+== Tipos de Objetos ==
-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.
+Existen varios tipos de objetos ya incluidos en python, cada tipo de objeto es una clase con su propio tipo de datos, sus propios métodos, funciones y operaciones para interactuar entre objetos similares o de otro tipo.
-Para conocer la clase de un objeto python, se puede utilizar la función siguiente que retorna la informacion deseada :
+Para conocer la clase de un objeto python, se puede utilizar la función siguiente que retorna la informacion deseada para el objeto ''obj'' :
-<code> type(objeto) </code>
+<code> type(obj) </code>
 === Números ===
@@ Línea 153: / Línea 150: @@
 * 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.
+* los números flotantes (''float'') que se pueden definir poniendo un "." entre enteros y decimales; y si el número no tiene decimales se puede definirlo como float agragandole un "." al final.
 <code>
@@ Línea 160: / Línea 157: @@
  c = 4.5  # c es claramente un flotante
- # Para convertir los numeros
+ # Para convertir los números
- float(a) # retorna un numero flotante valiendo a
+ float(a) # retorna un número flotante valiendo 5.
  int(c)   # retorna la parte entera de c, en este caso 4
@@ Línea 178: / Línea 175: @@
  > 1
- # Para facilitar la impresión en pantalla
+ # Para hacer simplificaciones por ej. para la impresión en pantalla
  round(4.5578945, 3) # reduce a 3 numero decimales el flotante
  > 4.557
@@ Línea 184: / Línea 181: @@
 === Condiciones y Boolean ===
-Los boolean son ''True'' y ''False', también pueden ser referenciados respectivamente como 1 y 0.
+Los boolean (o tipo de dato lógico) son ''True'' y ''False'', y también pueden ser representados 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 :
+Se puede evaluar una expresión utilizando diferentes símbolos de comparación, lo que nos retorna un boolean :
 <code>
  <
@@ Línea 196: / Línea 193: @@
 </code>
-Otras funciones pueden retornar un boolean.
+Funciones verificando otros aspectos 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()''
+Se puede evaluar matrices gracias a ''Numpy'' (más detalles en otra parte), lo que nos devuelve una matriz 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]
+ > [True, True, False, False, False, False]
  print(c.any())
- >True
+ > True
  print(c.all())
- >False
+ > False
 </code>
@@ Línea 226: / Línea 224: @@
  > output : "Hola Mundo"
 </code>
-* Pueden ser visto como una lista de caracteres simples
+* Pueden ser vistos 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
+* <code>word.upper()</code>, <code>word.lower()</code> devuelven una copia de word en mayúscula / minúscula
-* Varios métodos permiten verificar ciertas caracteristicas del string, devuelven un boolean:
+* Varios métodos permiten verificar ciertas características del string, devuelven un boolean:
-** <code>word1.isalnum()</code> : True si solamente caracteres son alphanumericos
+** <code>word1.isalnum()</code> : True si solamente caracteres son alfanuméricos
-** <code>word1.isalpha()</code>	: True si solo caracteres alphabeticos
+** <code>word1.isalpha()</code>	: True si solo caracteres alfabetices
-** <code>word1.islower()</code>	: True si todo en minuscula
+** <code>word1.islower()</code>	: True si todo en minúscula
-** <code>word1.isnumeric()</code> : True si todos son caracteres numericos
+** <code>word1.isnumeric()</code> : True si todos son caracteres numéricos
-** <code>word1.isupper()</code> : True si todo en mayuscula
+** <code>word1.isupper()</code> : True si todo en mayúscula
 ** ...
 * separador.join(Lista_de-string) : devuelve un string con los elementos de las lista separado por el separador
@@ Línea 255: / Línea 253: @@
 <code>
  a = 2+3
- Resultado = "La suma es " + str(a)+"."
+ Resultado = "La suma es " + str(a) + "."
  print(Resultado)
  > output : La suma es 5.
+</code>
+A partir de python 3.6 también se pueden usar el formato "f-strings" para concatenar de manera más simple y clara:
+<code>
+ a = 2+3
+ Resultado = f"La suma es {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 :
+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
@@ Línea 270: / Línea 277: @@
 ==== Listas ====
 Las listas se definen gracias a los símbolos "[" y "]".
-La listas son contenedores referenciado gracias a un indice numérico.
+La listas son contenedores referenciados gracias a un indice numérico.
 <code>
@@ Línea 306: / Línea 313: @@
  L = ["file1", "file2", "file3"]
  for element in L:
-    print(f)
+    print(element)
  > output :
@@ Línea 329: / Línea 336: @@
 ==== Tuple ====
-Los '''tuples''' son unas listas que no pueden ser modificadas, se definen entre paréntesis.
+Los '''tuples''' son listas que no pueden ser modificadas, se definen entre paréntesis.
 <code>
@@ Línea 346: / Línea 353: @@
 </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.
+La principal diferencia es que los elementos no pueden ser modificados ni se pueden agregar nuevos elementos, hay que redefinir la lista si se quiere cambiar sus 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.
+En los diccionarios, los elementos no son referenciados por su índice sino por un identificador, 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.
+Los diccionarios se crean con los símbolos "{" y "}". Los identificadores pueden ser diferentes tipos de objetos, por ejemplo string o enteros.
 <code>
@@ Línea 357: / Línea 364: @@
  D = {}
- # Inicialización de un diccionarios
+ # Inicialización de un diccionario
  # se pone id : valor
  D = {'Manzana': 3, 'Naranja': 10}
@@ Línea 368: / Línea 375: @@
 </code>
-D.keys() devuelve la lista de los identificante
+D.keys() devuelve la lista de los identificadores
-D.values() devuelve la lista de los diferentes valores
-D.items() devuelve un tuples con los diferentes items
+D.values() devuelve la lista de los diferentes valores
+D.items() devuelve un tuples con los diferentes items
 Por ejemplo :
@@ Línea 379: / Línea 386: @@
   "Manzana" 3
   "Naranja" 10
+</code>
+=== Error de principiante: ===
+copiar listas y diccionarios de manera errónea e introducir cambios en los elementos.
+<code>
+ lista1 = [0, 1, 2, 3]
+ lista2 = lista1
+ lista2[2] = lista2[2]*100
+ print(lista2)
+ >>> output:
+    [0, 1, 200, 3]
+ print(lista1)
+ >>> output:
+     [0, 1, 200, 3]
+</code>
+Las variables lista1 y lista2 apuntan al mismo objeto en la memoria. Por lo tanto, los cambios en los elementos de una se aplican a la otra.
+La solución es usar copy() o deepcopy() (de la libreria copy) dependiendo el caso. Ej:
+<code>
+ lista1 = [0, 1, 2, 3]
+ lista2 = lista1.copy()
+ lista2[2] = lista2[2]*100
+ print(lista2)
+ >>> output:
+    [0, 1, 200, 3]
+ print(lista1)
+ >>> output:
+     [0, 1, 2, 3]
+</code>
-== Loops ==
+== Loops: bucles ==
 === for x in ===
-Para recorrer una lista de elementos se puede usar el <code>for</code>
+Para recorrer una lista de elementos se puede usar el comando <code>for</code>
 <code>
@@ Línea 390: / Línea 428: @@
 </code>
-El loop va a recorrer la lista utilizando sus elementos uno a uno refiriendose a ellos como x.
+El loop va a recorrer la lista utilizando sus elementos uno a uno refiriéndose a ellos como x.
-Construyendo lista de enteros facilmente con la función range podemos escribir :
+Construyendo lista de enteros fácilmente con la función ''range'' podemos escribir :
 <code>
@@ Línea 417: / Línea 455: @@
 === while ===
-Se puede también utilizar una condición para hacer una loop, mientras está la condición se corre de nuevo la loop :
+Se puede también utilizar una condición para hacer un loop, mientras la condición siga siendo válida se sigue ejecutando el comando del loop :
 <code>
  while 'condition':
@@ Línea 423: / Línea 461: @@
 </code>
-Cuidado a poder siempre salir de la loop, sino el script seguira corriendo sin fin.
+Tener cuidado con poder siempre salir del loop, sino el script seguirá 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
+Hay que verificar que por lo menos un elemento de la función llega a cambiar y que llega a no cumplir la condición para salir del bucle.
 === Parar una loop ===
@@ Línea 433: / Línea 471: @@
  while 'condición':
     instrucciones
-    if 'condición de no se pasa como quiero':
+    if 'condición de stop':
         break
 </code>
 == Más herramientas ==
+Manipular estos diferentes objetos es esencial, pero para trabajar de manera eficiente hay otras herramientas disponibles.
 === 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.
+'''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.
+<PRE>
+Python guarda todas las variables en memoria, pero cuando utilizamos una función sólo los elementos retornados quedan guardados en memoria.
+Una vez que la función termina de ejecutarse, las variables locales son borradas.
+</PRE>
 La estructura básica de una función es :
 <code>
- def nombre_funcion(variable_entrantes):
+ def nombre_función(variables_entrantes):
     # Noten que termino la linea anterior con ":"
-    # Noten que paso a otro nivél de código
+    # Noten que paso a otro nivel 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 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 :
@@ Línea 466: / Línea 506: @@
  > 3
- # Se puede indicar las variables entrantes si queremos ser más detallosos :
+ # Se puede indicar las variables entrantes si queremos ser más prolijos :
  c = mi_funcion(a = 1, b = 3)
  print(c)
@@ Línea 473: / Línea 513: @@
 === Clases ===
-También es posible gestionar sus propias clases de datos de la manera siguiente :
+Python ofrece la posibilidad de crear sus propios tipos de objetos via las clases. Permite tener una versión operacional y muy personalizada para gestionar los datos que manipulamos. Se crea una clase de la manera siguiente :
 <code>
- class name_class:
+ class MiClase:
     def __init__(self, input):
-        #Initialization method
+        # Método de inicialización
-        self.parameter_a = "hola"
+        self.parametro_a = input
-        self.additional_method_1()
+        self.metodo_adicional_1()
-    def additional_method_1(self, input):
+    # Operaciones del método adicional 1
-        operations
+    def metodo_adicional_1(self):
+        print(f"Método adicional 1. Parametro_a: {self.parametro_a}")
-    def additional_method_2(self, input):
+    # Operaciones del método adicional 2
-        operations
+    def metodo_adicional_2(self, input2):
+        print(f"Método adicional 2 con {input2}")
+</code>
+Para utilizarla se puede iniciar un objeto de la manera siguiente :
+<code>
+ # Creación de un objeto de la clase MiClase
+ mi_obj = MiClase(input="mi_entrada")
+ >>> output: Método adicional 1. Parametro_a: mi_entrada
+ # Uso de un método de la clase
+ mi_obj.metodo_adicional_1()
+ >>> output: Método adicional 1. Parametro_a: mi_entrada
+ # Uso de otro método de la clase
+ mi_obj.metodo_adicional_2(input2="otra_entrada")
+ >>> output: Método adicional 2 llamado con otra_entrada
 </code>
 == Mejorar sus scripts ==
-Para mejorar sus scripts y mejor gestionar los errores se puede usar 'try' y 'except'.
+Para mejorar sus scripts y gestionar mejor los errores se puede usar 'try' y 'except'.
 Funciona de la manera siguiente :
@@ Línea 505: / Línea 560: @@
 <code>
  print(a)
- > output : Error porque no defini a
+ > output : NameError: name 'a' is not defined
 </code>
@@ Línea 519: / Línea 574: @@
 </code>
-Permitió correr el codigo sin que este parado por el error.
+Permitió correr el código sin que éste se detenga por el error.
-= Librerias =
+= Librerías =
 == Instalar Librerías ==
-* En debian : en general las librerías se encuentran con el nombre ''python3-nombre''
+* '''En Debian''' :
+En general las librerías se encuentran con el nombre ''python3-nombre''.
+Primero, entrar al modo superuser (''su'')
 <code>
  su root
  ''Entrar contraseña para acceder al modo superuser''
+</code>
+Buscar la libreria para conocer el nombre exacto :
+<code>
  apt-get search ''LIBRARY''
  ''Encontrar el nombre exacto de la librería buscada''
+</code>
+Instalar la libreria :
+<code>
  apt-get install ''LIBRARY_NAME''
 </code>
-* En anaconda :
+* '''En anaconda''' :
 <code>
  conda search ''LIBRARY''
@@ Línea 539: / Línea 602: @@
 </code>
-* Con pip :
+* '''Con pip''' :
+pip es un gestionador de paquetes para python
 <code>
  pip3 search ''LIBRARY''
@@ Línea 547: / Línea 610: @@
 '''CUIDADO !! '''
-Debian no tiene siempre las últimas versiones, pero siempre son compatibles.
+*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]]
+*Anaconda puede tener problemas de compatibilidad entre versiones, se resuelve buscando versiones compatibles especificando numero de versiones, puede convenir utilizar diferentes [[entornos_python]]. Se recomienda instalar todas las librerías deseadas de una vez en el mismo comando <code>conda install LYBRARY1 LYBRARY2 LIBRARY3</code> para evitar conflictos de versiones
-En general instalan las librerías necesarias al funcionamiento de lo que queremos instalar, pero a veces hay que instalarlo aparte.
+*En general, se instalan automáticamente los paquetes necesarios para el funcionamiento de la librería que queremos instalar, '''pero''' a veces hay que instalarlo aparte.
-== numpy ==
+== Numpy ==
-Numpy es la librería gestionando matrices.
+Numpy es la librería más usada para gestionar 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.
+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.
+En vez de recorrer los elementos de las matrices uno a uno para hacer 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
+ shape = (10,5) # 10 filas y 5 columnas
  A = np.zeros(shape)
+ print(A)
+ > output:
+ array([[0., 0., 0., 0., 0.],
+        [0., 0., 0., 0., 0.],
+        [0., 0., 0., 0., 0.],
+        [0., 0., 0., 0., 0.],
+        [0., 0., 0., 0., 0.],
+        [0., 0., 0., 0., 0.],
+        [0., 0., 0., 0., 0.],
+        [0., 0., 0., 0., 0.],
+        [0., 0., 0., 0., 0.],
+        [0., 0., 0., 0., 0.]])
  # full permite crear una matriz llena del número que indicamos, en esta caso 5
  A = np.full(shape, 5)
+ print(A)
+ > output:
+ array([[5, 5, 5, 5, 5],
+        [5, 5, 5, 5, 5],
+        [5, 5, 5, 5, 5],
+        [5, 5, 5, 5, 5],
+        [5, 5, 5, 5, 5],
+        [5, 5, 5, 5, 5],
+        [5, 5, 5, 5, 5],
+        [5, 5, 5, 5, 5],
+        [5, 5, 5, 5, 5],
+        [5, 5, 5, 5, 5]])
  # Obtener la estructura de una matriz
- A.shape
+ print(A.shape)
+ > output: (10, 5)
  # Obtener el número de elementos
- A.size
+ print(A.size)
+ > output: 50
 === Funciones ===
@@ Línea 592: / Línea 669: @@
 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
+Una matriz enmascarada se define por una matriz numpy con los valores no enmascarados y una matriz numpy de booleans indicando cuáles son los elementos enmascarados.
 <code>
  import numpy as np
  import numpy.ma as ma
- A = np.random((4,3))
+ A = np.random.rand(4,3) # matriz random con valores entre 0-1
  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))
+ ma.mean(A_masked)
 </code>
-== pandas ==
+== Pandas ==
-Pandas es una libreria que facilita el trabajo con datos.
+Pandas es una librería que facilita el trabajo con datos.
-== netcdf ==
+=== Series ===
-NetCDF es un formato de almacenamiento de datos muy común en ciencias de la Tierra. Para más detalle ver : LINK
+Un tipo de datos en pandas son las series, indexada por números enteros por defecto, pero se puede especificar indices personalizados.
+<code>
+ import numpy as np
+ import pandas as pd
+ s = pd.Series([1, 3, 5, np.nan, 6, 8])
+ print(s)
+ > output :
+1.0
+3.0
+5.0
+NaN
+6.0
+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 números 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
+-01-01 -0.303859  1.541625 -0.158655 -0.106934
+-01-02 -0.614769 -1.461621 -0.516678 -0.239503
+-01-03 -0.678116  1.538130 -0.799381  0.610648
+-01-04  0.356464  0.320538  0.941156  0.303474
+-01-05 -1.138584 -0.001179  0.386963 -0.882730
+-01-06  0.318615  0.743327  0.401269  2.555924
+-01-07 -0.659930  0.925570 -1.514493  0.709833
+-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
+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 estadísticos 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
+%   -0.611510 -0.600794 -1.368714 -1.076610
+%    0.022070 -0.228039 -0.767252 -0.386188
+%    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 referenciada como "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 matemáticas y estadísticas (promedio, standard deviation) que se pueden aplicar sobre una o varias columnas/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á basado 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 : [https://www.unidata.ucar.edu/software/netcdf/ netCDF]
 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: uno 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 ===
+<code>
+ from netcdf4 import Dataset as NetCDFFile
+ import numpy as np
+</code>
+Empezar a escribir el archivo netcdf al lugar indicado, "w" es para writing.
+'''CUIDADO''' Si ya existía un archivo en esta dirección, sera sobrescrito !
+<code>
+ foo = NetCDFFile('data/test.nc','w')
+</code>
+Para crear las dimensiones, con el nombre de las dimensiones y la dimensión.
+En caso de ser una variable ''ilimitada'', se inscribe ''None''.
+<code>
+ level = foo.createDimension('level', 10)
+ lat = foo.createDimension('lat', 73)
+ lon = foo.createDimension('lon', 144)
+ time = foo.createDimension('time', None)
+</code>
+Para crear las variables, con el nombre, el tipo de datos y las dimensiones relacionadas.
+Agregando <code>zlib = True</code> al final autoriza la compresión del archivo, es decir que los ''espacios'' sin datos no ocupan espacio.
+Primero no agregar las variables detallando las dimensiones, agrego un 's' a sus nombres para no confundirlas con las dimensiones.
+<code>
+times = foo.createVariable('time', np.float64, ('time',), zlib = True)
+levels = foo.createVariable('level', np.int32, ('level',))
+latitudes = foo.createVariable('latitude', np.float32,('lat',))
+longitudes = foo.createVariable('longitude', np.float32,('lon',))
+</code>
+Después se puede crear las variables que queremos guardar :
+<code>
+  temp = dataset.createVariable('temp', np.float32,('time','level','lat','lon'))
+</code>
+Para ponerles valores es muy simple, por ejemplo :
+<code>
+ lats = np.arange(-90,91,2.5)
+ lons = np.arange(-180,180,2.5)
+ latitudes[:] = lats
+ longitudes[:] = lons
+ # Y si tengo T un array a 4 dimensiones con las buenos dimensiones, en el buen orden (time, level, lat, lon) :
+ temp[:,:,:,:] = T
+</code>
+Después es importante describir las variables y el archivo via los atributos.
+Para los atributos globales :
+<code>
+ foo.description = 'Mean temperature datasets'
+ foo.history = 'Created 13/06/2019'
+ foo.source = 'netCDF4 python example'
+</code>
+Para las variables :
+<code>
+ latitudes.units = 'degree_north'
+ longitudes.units = 'degree_east'
+ levels.units = 'hPa'
+ temp.units = 'K'
+ times.units = 'seconds since 1900-01-01 00:00:00'
+ times.calendar = 'gregorian'
+</code>
+Una dificuldad para describir el tiempo, hay que convertir las fechas en un formato compatible (en general secundos desde una cierta fecha, cf ejemplo).
+Nos ayudara la función siguiente para convertir estas fechas :
+<code>
+ from netcdf4 import date2num
+ from datetime import datetime, timedelta
+</code>
+Para el ejemplo, creo una lista de fechas :
+<code>
+ Dates = [datetime(2001, 3, 1)+n*timedelta(hours=12) for n in range(10)]
+ times[:] = date2num(Dates, units = times.units)
+</code>
+'''Para terminar, no olvidar sincronizar y cerrar : '''
+<code>
+ foo.sync()
+ foo.close()
+</code>
+En el caso de que una variable sea ilimitada, se puede ir agregando nuevos datos. No olviden definir nueva descripción de los pasos temporales en la variable asociada con el tiempo.
 == xarray ==
-Numpy mejorado para ciencias de la tierra, integra informaciones spacio-temporales y métodos de calculo simplificado que toma en cuenta estas informaciones.
+xarray es un paquete de Python pensado para trabajar fácilmente con arreglos multidimensionales con etiquetas en forma de dimensiones, coordenadas y atributos. Es especialmente útil para trabajar con datos grillados georeferenciados, particularmente archivos netCDF.
-== matplotlib ==
+xarray toma funciones de Numpy y Pandas para trabajar fácil y eficientemente e integra la librería Dask para computación en paralelo y manejo de grandes archivos.
-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.
-== cartopy ==
+Sitio web: http://xarray.pydata.org
-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??
-== tensorflow ==
+==== ¿A qué nos referimos con todo esto? ====
-Tensorflow es una libreria de machine learning.
-= Para ir más lejo =
+xarray es capaz de leer la metadata incluída en los archivos netCDF y posee poderosas herramientas para fácilmente seleccionar variables, recortar dimensiones y hacer cálculos básicos pero laboriosos en una sola línea, entre otras cosas.
-== f2py ==
+=== Ejemplo ===
+Se puede ver un tutorial en formato html (abrir con el navegador) o de manera interactiva en Jupyter Notebook usando los archivos del siguiente link:
+[https://drive.google.com/drive/folders/1fS0kf-fwpUrbbwaOa-mMfU5WH3enJtdW?usp=sharing Introducción a xarray en html y Jupyter Notebook]
+=== Comandos básicos ===
+==== Abrir un archivo ====
+<code>
+ # Cargamos los paquetes
+ import xarray as xr
+ # Abrimos un archivo
+ data_xr = xr.open_dataset('archivo.nc', engine='netcdf4')
+ # Si es un .grib: (debemos tener los paquetes cfgrib y eccodes instalados)
+ data_grib = xr.open_dataset('example.grib', engine='cfgrib')
+ # en este tutorial abrimos un dataset que xarray tiene de ejemplo
+ ds = xr.tutorial.load_dataset("air_temperature")
+</code>
+<code>
+ # Vemos la metadata
+ ds
+ <xarray.Dataset>
+ Dimensions:  (lat: 25, time: 2920, lon: 53)
+ Coordinates:
+   * lat      (lat) float32 75.0 72.5 70.0 67.5 65.0 ... 25.0 22.5 20.0 17.5 15.0
+   * lon      (lon) float32 200.0 202.5 205.0 207.5 ... 322.5 325.0 327.5 330.0
+   * time     (time) datetime64[ns] 2013-01-01 ... 2014-12-31T18:00:00
+ Data variables:
+     air      (time, lat, lon) float32 ...
+ Attributes:
+     Conventions:  COARDS
+     title:        4x daily NMC reanalysis (1948)
+     description:  Data is from NMC initialized reanalysis\n(4x/day).  These a...
+     platform:     Model
+     references:   http://www.esrl.noaa.gov/psd/data/gridded/data.ncep.reanaly...
+</code>
+<code>
+ # Podemos extraer la variable y sus dimensiones de esta forma
+ tas = ds['air']
+ lon = ds['lon']
+ lat = ds['lat']
+</code>
+<code>
+ # También se puede convertir, por ejemplo, un numpy array a un xarray usando:
+ import numpy as np
+ data_xrnp = xr.DataArray(np.random.randn(2, 3), coords={'x': ['a', 'b']}, dims=('x', 'y'))
+</code>
+==== Cómo recortar un dominio espacial o temporal ====
+<code>
+ # Recortamos el dominio
+ ds_cut = ds.loc[{'time':slice('2013-03-01','2013-03-07'), 'lat':slice(75, 60, -1), 'lon':slice(210,220)}]
+ # También se puede usar el método .sel() de manera similar
+ ds_cut = ds.sel(time=slice('2013-03-01','2013-03-07'), lat=slice(75, 60, -1), lon=slice(210,220))
+</code>
+Al usar slice(a,b) le estamos indicando que tome todos los valores comprendidos entre a y b. Si, además, le agregamos "-1", slice(a,b,-1), le indicamos que nos de vuelta esa coordenada. Le agrego el -1 para dar vuelta la coordenada latitud y quede de menor a mayor, al igual que la longitud.
+==== Cálculos básicos ====
+Los arreglos de xarray funcionan de manera similar a los de numpy, sumado a que ciertas operaciones se pueden hacer especificando los nombres de las dimensiones en lugar de sus índices.
+<code>
+ # Podemos calcular la media total en el tiempo de estas dos maneras:
+ tas_mean = tas.mean(axis=0) # Porque sabemos que 'time' es la primer coordenada, es decir la coordenada 0
+ tas_mean = tas.mean(dim='time')
+ # Graficamos directamente desde xarray (gráficos básicos para visualizar rápido)
+ tas_mean.plot.pcolormesh(vmax=310, cmap='YlGnBu') # vmax es el máximo de la colorbar, cmap el mapa de colores
+[[Archivo: xarray_plot1.png]]
+</code>
+<code>
+ # También podemos hacer otras operaciones como suma y restas
+ tas_sum = tas.sum(dim='time')
+</code>
+===== groupby y resample =====
+xarray ya tiene manejo de dimensiones tipo calendario y nos brinda útiles herramientas para hacer cálculos en una sola línea
+<code>
+ # Calcular el ciclo diurno medio:
+ tas_hour_means = tas.groupby('time.hour').mean(axis=0)
+</code>
+<code>
+ # Pasar a datos diarios
+ tas_daily = tas.resample(time='1D').mean(axis=0) # o time='24H'
+ # Pasar a datos estacionales
+ tas_seas = tas.resample(time='QS').mean(axis=0)  # QS : quarter start
+</code>
+===== Guardar en un netCDF =====
+<code>
+ # Para guardar en un archivo netCDF:
+ tas_seas.to_netcdf('tas_seas.nc')
+</code>
+==== Cómo cargar múltiples archivos y/o usar Dask ====
+Lo que hace Dask es dividir en bloques nuestro dataset y realizar los cálculos de manera paralela, es decir, envía a cada núcleo del procesador uno de estos bloques y va calculando en simultáneo. Luego une el resultado final. Esto permite que sea mucho más rápido en sus cálculos al dividir el trabajo entre los múltiples núcleos del procesador. Se recomienda usarlo siempre que sus archivos sean pesados, ya que las funciones y métodos aplican de la misma forma que si uno no tuviera Dask activo y ganará en rendimiento al hacer cálculos.
+[[Archivo: Bloques.png]]
+Para activar dask usar la opción 'chunks' dentro de .open_dataset().
+El método .open_mfdataset() abre múltiples archivos y ya activa Dask asignando por defecto un bloque = un archivo, pero conviene especificar 'chunks' para que sea más eficiente al calcular. En el sitio de xarray recomiendan que cada bloque contenga aproximadamente un millón de elementos.
+Al abrir una serie de archivos con .open_mfdataset() automáticamente se concatenan a lo largo de las dimensiones posibles.
+<code>
+ # Abrir un dataset de múltiples archivos (poner * como wildcard)
+ data_mf = xr.open_mfdataset('total_precipitation_year_198*.nc', chunks={'time':20})
+</code>
+xarray con Dask activado funciona de forma "perezosa" o "lazy", quiere decir que no hace ningún cómputo hasta que le pedimos los datos explícitamente (al graficar, guardar en un archivo o con .compute())
+<code>
+ # De esta forma no se hace el cómputo todavía
+ tp_mfmean = data_mf['tp'].loc[{'latitude':slice(-30,0,-1), 'longitude':slice(-60,-40)}].mean(axis=0)
+ # Si especifico .compute() sí hace el cáculo:
+ tp_mfmean = data_mf['tp'].loc[{'latitude':slice(-30,0,-1), 'longitude':slice(-60,-40)}].mean(axis=0).compute()
+</code>
+==== Otros ====
+Eso es todo por ahora!
+Hay muchas otras herramientas para hacer selecciones de los datos, transformar los arreglos, mover o modificar las coordenadas, etc. Por ejemplo:
+Concatenar, unir, combinar:
+ Para combinar datasets o data arrays a lo largo de una dimensión: xr.concat()
+ Para combinar datasets con distintas variables: xr.merge()
+ Para combinar datasets o data arrays con diferentes índices o valores faltantes: xr.combine()
+ http://xarray.pydata.org/en/stable/combining.html
+Interpolar:
+Con el método .interp() podemos interpolar un DataArray a una nueva grilla, mientras que con .interp_like() podemos interpolar un DataArray a las coordenadas de otro DataArray. Este método utiliza los métodos de interpolación del paquete Scipy, los cuales son métodos simples (lineal, cúbica).
+== Matplotlib ==
+Es '''LA''' librería gráfica de python, indispensable para graficar. Otras librerías integran funciones de gráficos (seaborn, numpy..) pero en general están basadas en matplotlib.
+Existen una infinidad de posibilidades con matplotlib, el objetivo de esta parte es dejar unas bases para que cada uno después busque como personalizar a su gusto su gráfico.
+=== 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 pulgadas
+ plt.figure(figsize=(20,10))
+ # Se puede hacer subplot (poner varios gráfico en una sola figura)
+ # Por ejemplo 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, acá 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 parámetros, 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 parámetro '''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>
+Finalmente para cerrar :
+<code>
+ plt.close()
+</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 librerías basadas en Matplotlib están disponible, como seaborn.
+== Cartopy ==
+Cartopy es la librería para trabajar con mapas. La librería anterior es Basemap, utilizada en muchos scripts, pero ya no será actualizada y entonces porque no empezar directamente con cartopy??
+Cartopy funciona con Matplotlib pero agrega la posibilidad de trabajar con datos geo-espaciales.
+Por ejemplo si tengo un array numpy de datos de temperatura de 2 dimensiones llamado ''Temp'' de dos dimensiones, con sus respectivo lon y lat cada uno de una dimensión
+<code>
+ import cartopy
+ import cartopy.crs as ccrs
+ import matplotlib.pyplot as plt
+ import numpy as np
+ import numpy.ma as ma
+ from netCDF4 import Dataset as NetCDFFile
+ ncfile = NetCDFFile(ncdir, "r")
+ # Suponemos que temp tiene por variable (time, lat, lon)
+ # Promedio temporal de la temperatura :
+ temp = ma.mean(ncfile.variables["Temp"][:,:,:], axis = 0)
+ # Para obtener las longitudes, latitudes
+ lon = ncfile.variables["lon"][:]
+ lat = ncfile.variables["lat"][:]
+ # Empezar la figura
+ fig = plt.figure(figsize= (20,10))
+ # Empezar con la proyección deseada
+ ax = plt.axes(projection=ccrs.PlateCarree())
+ # Por si queremos trabajar con subplot
+ ax1 = plt.subplot(2, 1, 1, projection=ccrs.PlateCarree())
+ # Si queremos poner color a la superficie terrestre
+ ax.add_feature(cartopy.feature.LAND)
+ # Si queremos poner color a los oceanos
+ ax.add_feature(cartopy.feature.OCEAN)
+ # Para graficar las costas
+ ax.add_feature(cartopy.feature.COASTLINE)
+ # Para graficar los datos, es posible que tengan que usar la opción "transform" si sus datos no están en la misma proyección.
+ ax.contourf(lons, lats, temp)
+ plt.show()
+ plt.close()
+</code>
+Para graficas las longitudes / latitudes :
+<code>
+ from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER
+ import matplotlib.ticker as mticker
+ # Armo la grilla con los detalles que me gustan
+ gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True,
+      linewidth=1, color='k', alpha=0.7, linestyle='--')
+ # Preparo las locaciones de longitud / latitud
+ gl.ylocator = mticker.FixedLocator(np.arange(-90,90,10))
+ gl.xlocator = mticker.FixedLocator(np.arange(-180,0,10))
+ # Por si quiero o no latitud a la izq./der.
+ # Si puse True a draw_labels, todo están puesto directamente a True
+ gl.ylabels_right = False
+ gl.ylabels_left = True
+ gl.yformatter = LATITUDE_FORMATTER
+ # Lo mismo para la longitud
+ gl.xlabels_top = False
+ gl.xlabels_bottom = True
+ gl.xformatter = LONGITUDE_FORMATTER
+</code>
+Cartopy facilita la lectura de los datos GIS (shapefile ..), por ejemplo integra directamente la gestion de shapfile de [https://www.naturalearthdata.com/ Natural_earth]
+<code>
+ import cartopy.io.shapereader as shpreader
+ # Abrir la categoría deseada, con la resolución deseada
+ geo_reg_shp = shpreader.natural_earth(resolution='50m', category='physical',
+                                        name='geography_regions_polys')
+ # Abrirlo
+ geo_reg = shpreader.Reader(geo_reg_shp)
+ # ax es el eje en uso, para graficar
+ ax = plt.gca()
+ # graficar todos los elementos, se puede seleccionar ciertos elementos con un if
+ # si queremos solo borde poner edgecolor = color de borde deseado y facecolor = 'none'
+ # hacer el contrario si solo queremos rellenar la forma
+ for rec in geo_reg.records():
+    ax.add_geometries( [rec.geometry], ccrs.PlateCarree(), edgecolor="r", facecolor='none')
+</code>
+= Para ir más lejos =
+Para desarollar funciones con más potencial se puede trabajar en languaje de más bajo nivel (recuerde que python es de alto nivel, es bastante flexible con la estructura de los códigos) 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).
+Sirve también a paralelizar ciertas funciones manualmente.
+== f2py3 ==
+f2py3 es la libreria para utilizar funciones de fortran en python.
+Primero compilar con f2py3 algún modulo fortran con las subroutinas que nos interesen. Por ejemplo :
+MODULE_one.f90
+<code>
+ module one
+ contains
+ subroutine func(x,y, z)
+     real(8), intent(in) :: x,y
+     real(8), intent(out) ::z
+     z = x*y
+ end subroutine
+ end module
+</code>
+Es importante explicitar las variables de entrada y de salida con intent(in), intent(out).
+La compilación nos da un archivo en .so
+Después se puede importar el modulo desde python para utilizarla directamente como :
+from MODULE_one import *
+result = one.func(x = 2, y = 3)
 == cython ==
+cython es la librería para utilizar funciones de C en python.
 = Algunos tips =
+== import this ==
+<code>
+ The Zen of Python, by Tim Peters
+ Beautiful is better than ugly.
+ Explicit is better than implicit.
+ Simple is better than complex.
+ Complex is better than complicated.
+ Flat is better than nested.
+ Sparse is better than dense.
+ Readability counts.
+ Special cases aren't special enough to break the rules.
+ Although practicality beats purity.
+ Errors should never pass silently.
+ Unless explicitly silenced.
+ In the face of ambiguity, refuse the temptation to guess.
+ There should be one-- and preferably only one --obvious way to do it.
+ Although that way may not be obvious at first unless you're Dutch.
+ Now is better than never.
+ Although never is often better than *right* now.
+ If the implementation is hard to explain, it's a bad idea.
+ If the implementation is easy to explain, it may be a good idea.
+ Namespaces are one honking great idea -- let's do more of those!
+</code>
 = Ejercicios =

python 3

Última revisión de 20:36 4 jun 2024

Contenido

[editar] Introducción

[editar] Presentaciones

[editar] Paquete a instalar

[editar] Historia

[editar] Por qué elegir Python ?

[editar] Para empezar

[editar] A saber antes de empezar

[editar] Como usarlo

[editar] En la terminal

[editar] En script

[editar] Ayudándose de un IDE

[editar] En los servidores

[editar] Basic Python

[editar] Tipos de Objetos

[editar] Números

[editar] Condiciones y Boolean

[editar] String : Cadenas de caracteres

[editar] Containers : Listas, Tuples, Diccionarios

[editar] Listas

[editar] Tuple

[editar] Diccionarios

[editar] Error de principiante:

[editar] Loops: bucles

[editar] for x in

[editar] while

[editar] Parar una loop

[editar] Más herramientas

[editar] Funciones

[editar] Clases

[editar] Mejorar sus scripts

[editar] Librerías

[editar] Instalar Librerías

[editar] Numpy

[editar] Básico

[editar] Funciones

[editar] matrices enmascaradas

[editar] Pandas

[editar] Series

[editar] Dataframe

[editar] Visualización

[editar] Graficar

[editar] Importar/Exportar

[editar] NetCDF

[editar] Leer un NetCDF desde python

[editar] Para modificar un NetCDF

[editar] Para escribir un NetCDF

[editar] xarray

[editar] ¿A qué nos referimos con todo esto?

[editar] Ejemplo

[editar] Comandos básicos

[editar] Abrir un archivo

[editar] Cómo recortar un dominio espacial o temporal

[editar] Cálculos básicos

[editar] groupby y resample

[editar] Guardar en un netCDF

[editar] Cómo cargar múltiples archivos y/o usar Dask

[editar] Otros

[editar] Matplotlib

[editar] Empezar una figura

[editar] Para graficar

[editar] Para más

[editar] Cartopy

[editar] Para ir más lejos

[editar] f2py3

[editar] cython

[editar] Algunos tips

[editar] import this

[editar] Ejercicios

Vistas

Herramientas personales

Navegación

Buscar

Herramientas