Ú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.

[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

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