2.1: Estructuras de datos secuenciales

En la parte anterior del tutorial, se trabajó a través de un ejemplo sencillo de un programa Scipy que calcula el potencial eléctrico producido por una colección de cargas en 1D. En ese momento, no explicamos mucho sobre las estructuras de datos que estábamos usando para almacenar información numérica (como los valores del potencial eléctrico en varios puntos). Hagámoslo ahora.

Hay tres estructuras de datos comunes que se utilizarán en un programa Scipy para computación científica: matrices, listas y tuplas. Estas estructuras almacenan secuencias lineales de objetos Python, similares al concepto de “vectores” en física y matemáticas. Sin embargo, estos tres tipos de estructuras de datos tienen propiedades ligeramente diferentes, que debe tener en cuenta.

2.1.1 Arreglos

Una matriz es una estructura de datos que contiene una secuencia de números. Hagamos un resumen rápido. Desde un nuevo símbolo del sistema de Python, escriba lo siguiente:

>>> from scipy import *
>>> x = linspace(-0.5, 0.5, 9)
>>> x
array([-0.5  , -0.375, -0.25 , -0.125,  0.   ,  0.125,  0.25 ,  0.375,  0.5  ])

La primera línea, como de costumbre, se utiliza para importar el módulo scipy. La segunda línea crea una matriz llamada x llamando a linspace, que es una función definida por scipy. Con las entradas dadas, la función devuelve una matriz de 9 números entre -0.5 y 0.5, inclusive. La tercera línea muestra el valor resultante de x.

La estructura de datos de matriz es proporcionada específicamente por el módulo de computación científica Scipy. Las matrices solo pueden contener números (además, cada matriz individual solo puede contener números de un tipo, por ejemplo, enteros o números complejos; discutiremos esto en el próximo artículo). Las matrices también admiten instalaciones especiales para realizar álgebra lineal numérica. Comúnmente se crean usando una de estas funciones desde el módulo scipy:

• linspace, que crea una matriz de valores espaciados uniformemente entre dos puntos finales.
• arange, que crea una matriz de enteros en un rango especificado.
• ceros, lo que crea una matriz cuyos elementos son todos\(0.0\).
• ones, que crea una matriz cuyos elementos son todos\(1.0\).
• empty, que crea una matriz cuyos elementos están sin inicializar (esto se usa generalmente cuando se quiere establecer los elementos más adelante).

De estos, anteriormente hemos visto ejemplos de las funciones linspace y ceros que se están utilizando. Como otro ejemplo, para crear una matriz de 500 elementos que contengan el número\(-1.2\), puede usar la función ones y una operación de multiplicación:

x = -1.2 * ones(500)

Un método alternativo, que es un poco más rápido, es generar la matriz usando empty y luego usar el método fill para rellenarla:

x = empty(500); x.fill(-1.2)

Una de las cosas más importantes que hay que saber sobre una matriz es que su tamaño es fijo en el momento de su creación. Al crear una matriz, debe especificar exactamente cuántos números desea almacenar. Si alguna vez necesitas revisar este tamaño, debes crear una nueva matriz y transferir el contenido de la matriz anterior. (Para matrices muy grandes, esta podría ser una operación lenta, ya que implica copiar muchos números entre diferentes partes de la memoria de la computadora).

Puede pasar matrices como entradas a funciones de la manera habitual (por ejemplo, suministrando su nombre como argumento a una llamada a una función). Ya nos hemos encontrado con la función len, que toma una entrada de matriz y devuelve la longitud de la matriz (un entero). También hemos encontrado la función abs, que acepta una entrada de matriz y devuelve una nueva matriz que contiene los valores absolutos correspondientes. Similar a abs, muchas funciones y operaciones matemáticas aceptan matrices como entradas; generalmente, esto tiene el efecto de aplicar la función u operación a cada elemento de la matriz de entrada, y devolver el resultado como otra matriz. La matriz devuelta tiene el mismo tamaño que la matriz de entrada. Por ejemplo, la función sin con una entrada de matriz x devuelve otra matriz cuyos elementos son los senos de los elementos de x:

>>> y = sin(x)
>>> y
array([-0.47942554, -0.36627253, -0.24740396, -0.12467473,  0.        ,
        0.12467473,  0.24740396,  0.36627253,  0.47942554])

Se puede acceder a elementos individuales de una matriz con la notación a [j], donde a es el nombre de la variable y j es un índice entero (donde el primer elemento tiene índice 0, el segundo elemento tiene índice 1, etc.). Por ejemplo, el siguiente código establece el primer elemento de la matriz y en el valor de su segundo elemento:

>>> y[0] = y[1]
>>> y
array([-0.36627253, -0.36627253, -0.24740396, -0.12467473,  0.        ,
        0.12467473,  0.24740396,  0.36627253,  0.47942554])

Los índices negativos cuentan hacia atrás desde el final de la matriz. Por ejemplo:

>>> y[-1]
0.47942553860420301

En lugar de establecer o recuperar valores individuales de una matriz, también puede establecer o recuperar una secuencia de valores. Esto se conoce como rebanado, y se describe en detalle en la documentación de Scipy. La idea básica se puede demostrar con algunos ejemplos:

>>> x[0:3] = 2.0
>>> x
array([ 2.   ,  2.   ,  2.   , -0.125,  0.   ,  0.125,  0.25 ,  0.375,  0.5  ])

El código anterior accede a los elementos en la matriz x, comenzando desde el índice 0 hasta pero sin incluir 3 (es decir, los índices 0, 1 y 2), y les asigna el valor de 2.0. Esto cambia el contenido de la matriz x.

>>> z = x[0:5:2]
>>> z
array([ 2.,  2.,  0.])

El código anterior recupera un subconjunto de los elementos en la matriz x, comenzando desde el índice 0 hasta pero sin incluir 5, y escalando por 2 (es decir, los índices 0, 2 y 4), y luego agrupa esos elementos en una matriz llamada z. A partir de entonces, z puede tratarse como una matriz.

Por último, las matrices también pueden ser multidimensionales. Si pensamos en una matriz ordinaria (1D) como un vector, entonces una matriz 2D es equivalente a una matriz, y las matrices de dimensiones superiores son como tensores. Veremos ejemplos prácticos de matrices de dimensiones superiores más adelante. Por ahora, aquí hay un ejemplo sencillo:

>>> y = zeros((4,2))     # Create a 2D array of size 4x2
>>> y[2,0] = 1.0
>>> y[0,1] = 2.0
>>> y
array([[ 0.,  2.],
       [ 0.,  0.],
       [ 1.,  0.],
       [ 0.,  0.]])

2.1.2: Listas

Hay otro tipo de estructura de datos llamada lista. A diferencia de las matrices, las listas están integradas en el propio lenguaje de programación Python y no son específicas del módulo Scipy. Las listas son estructuras de datos de propósito general que no están optimizadas para la computación científica (por ejemplo, necesitaremos usar matrices, no listas, cuando queremos hacer álgebra lineal).

Lo más conveniente de las listas de Python es que puedes especificarlas explícitamente, usando [...] notación. Por ejemplo, el siguiente código crea una lista llamada u, que contiene los enteros\(1,\: 1,\: 2,\: 3,\) y\(5\):

>>> u = [1, 1, 2, 3, 5]
>>> u
[1, 1, 2, 3, 5]

Esta forma de crear listas también es útil para crear matrices de Scipy. La función array acepta una lista como entrada y devuelve una matriz que contiene los mismos elementos que la lista de entrada. Por ejemplo, para crear una matriz que contenga los números\(0.2,\: 0.1,\) y\(0.0\):

>>> x = array([0.2, 0.1, 0.0])
>>> x
array([ 0.2,  0.1,  0. ])

En la primera línea, los corchetes crean un objeto list que contiene los números\(0.2,\: 0.1,\) y\(0.0\), luego pasa esa lista directamente como entrada a la función array. Por lo tanto, el código anterior es equivalente a lo siguiente:

>>> inputlist = [0.2, 0.1, 0.0]
>>> inputlist
[0.2, 0.1, 0.0]
>>> x = array(inputlist)
>>> x
array([ 0.2,  0.1,  0. ])

Por lo general, haremos el procesamiento de números usando matrices en lugar de listas. No obstante, a veces es útil trabajar directamente con listas. Una cosa conveniente de las listas es que pueden contener objetos Python arbitrarios, de cualquier tipo de datos; por el contrario, las matrices solo pueden contener datos numéricos.

Por ejemplo, una lista de Python puede almacenar cadenas de caracteres:

>>> u = [1, 2, 'abracadabra', 3]
>>> u
[1, 2, 'abracadabra', 3]

Y puedes establecer o recuperar elementos individuales de una lista de Python de la misma manera que una matriz:

>>> u[1] = 0
>>> u
[1, 0, 'abracadabra', 3]

Otra gran ventaja de las listas es que, a diferencia de las matrices, se puede aumentar o disminuir dinámicamente el tamaño de una lista:

>>> u.append(99)                    # Add 99 to the end of the list u
>>> u.insert(0, -99)                # Insert -99 at the front (index 0) of the list u
>>> u
[-99, 1, 0, 'abracadabra', 3, 99]
>>> z = u.pop(3)                    # Remove element 3 from list u, and name it z
>>> u
[-99, 1, 0, 3, 99]
>>> z
'abracadabra'

Aparte: Acerca de los métodos

En el ejemplo anterior, append, insert y pop se llaman métodos. Se puede pensar en un método como un tipo especial de función que está “unida” a un objeto y se basa en él de alguna manera. Al igual que una función, un método puede aceptar entradas y dar un valor de retorno. Por ejemplo, cuando u es una lista, el código

z = u.pop(3)

significa tomar la lista u, encontrar el índice de elemento 3 (especificado por la entrada al método), eliminarlo de la lista y devolver el elemento de lista eliminado. En este caso, el elemento devuelto se denomina z. Consulta aquí un resumen de los métodos de lista de Python. Veremos más ejemplos de métodos a medida que avanzamos.

2.1.3 Tuplas

Aparte de las listas, Python proporciona otro tipo de estructura de datos llamada tupla. Mientras que las listas se pueden construir usando corchete [...] notación, las tuplas se pueden construir usando paréntesis (...) notación:

>>> v = (1, 2, 'abracadabra', 3)
>>> v
(1, 2, 'abracadabra', 3)

Al igual que las listas, las tuplas pueden contener cualquier tipo de tipo de datos. Pero mientras que el tamaño de una lista se puede cambiar (usando métodos como append, insert y pop, como se describe en la subsección anterior), el tamaño de una tupla se fija una vez que se crea, al igual que una matriz.

Las tuplas se utilizan principalmente como una forma conveniente de “agrupar” o “desagrupar” variables nombradas. Supongamos que queremos dividir el contenido de v en cuatro variables con nombre separadas. Podríamos hacerlo así:

>>> dog, cat, apple, banana = v
>>> dog
1
>>> cat
2
>>> apple 
'abracadabra'
>>> banana
3

En el lado izquierdo del signo =, en realidad estamos especificando una tupla de cuatro variables, llamadas perro, gato, manzana y plátano. En casos como este, está bien omitir los paréntesis; cuando Python ve un grupo de nombres de variables separados por comas, automáticamente trata ese grupo como una tupla. Por lo tanto, la línea anterior equivale a

>>> (dog, cat, apple, banana) = v

Vimos un ejemplo similar en la parte anterior del tutorial, donde había una línea de código como esta:

pmin, pmax = -50, 50

Esto asigna el valor\(-50\) a la variable llamada pmin, y\(50\) a la variable llamada pmax. Veremos más ejemplos de uso de tuplas a medida que avanzamos.