Arreglos - csrg

Arreglos
●
Son Estructuras de Datos parecidas a las
Listas...
●
●
●
… pero sólo pueden contener elementos del
mismo tipo, y no son modificables.
Representan en Python los conceptos
matemáticos de vectores y matrices
No son parte de Python, se tienen que
importar desde numpy
Arreglos
●
Primero, se debe importar la librería:
●
●
Para crear el arreglo, se pasa una lista de valores
a la función array()
●
●
from numpy import *
a = array([4, 8, 15, 15, 23, 42])
El arreglo toma el tipo según los datos: si hay por
lo menos un float, todos los valores pasan a ser
float.
●
También se puede modificar, usando: a.astype(float) o
a.astype(complex)
Arreglos especiales
●
Numpy define algunos arreglos especiales:
●
zeros(n): arreglo compuesto de n ceros
●
ones(n): arreglo compuesto de n unos
●
●
arange(a, b, c): análogo al range, sólo que los
valores pueden ser float y el resultado es un
arreglo (no una lista)
linspace(a, b, n): arreglo de n valores, entre a y b,
con la misma distancia entre uno y otro
–
linspace(1, 2, 5) devuelve array([1., 1.25, 1.5, 1.75, 2.])
Operatoria
●
●
Los arreglos casi siempre se utilizan con valores
numéricos, por lo que es razonable que tengan
buenas operaciones matemáticas, como:
●
Suma de arreglos (a + b), término a término
●
Multiplicación (a*b), también término a término
●
Resta de arreglos (a-b), término a término
Estas mismas operaciones se pueden aplicar
usando escalares:
●
a = linspace(1, 2, 5)
●
b = a- 1
Ordenamiento
●
●
Las operaciones de orden (<, > , ==) se ejecutan término
a término, y devuelven un arreglo con la comparación:
●
a = array([1, 2, 3, 4])
●
b = array([4, 2, 1, 4])
●
a == b # devuelve array([False, True, False, True])
Para obtener un único valor de verdad, usamos any() o
all():
●
any(operación) nos devuelve true si al menos un valor es true
●
all(operación) nos devuelve true si todos los valores son true
Funciones sobre arreglos
●
●
Podemos aplicar funciones de numpy a todo un arreglo
(parecido a lo que hace map())
●
x = linspace(0, pi/2, 9)
●
y = sin(x)
Algunas otras funciones importantes:
●
a = array([4.1, 2.7, 8.4, pi, -2.5, 3, 5.2])
●
a.min() #devuelve el menor valor
●
a.max() #devuelve el mayor valor
●
a.argmin() #devuelve posición del menor
●
a.argmax() #devuelve posición del mayor
●
a.sum() #suma todos los valores
●
a.pord() #multiplica todos los valores
Elementos en un arreglo
●
●
Se usan los índices y las rebanadas igual que
en las listas normales.
Un caso especial, es un tercer parámetro en el
rebanado, que indica cada cuántos elementos
se van a considerar:
●
a = array([1, 2, 3, 4, 5, 6])
●
b = a[::2] #b es array([1, 3, 5])
Arreglos bidimensionales –
Matrices
●
Son “arreglos dentro de arreglos”: cada elemento del
primer arreglo son otros arreglos.
●
a = array([[5.1, 7.4, 3.2, 9.9],
[1.9, 6.8, 4.1, 2.3],
[2.9, 6.4, 4.3, 1.4]])
●
●
●
Todas las filas deben ser del mismo largo
Con a.shape, sabemos de qué tipo es la matriz
(len(a) nos arroja sólo la cantidad de filas)
Podemos usar las funciones de arreglos normales
(como zeros()) para matrices, agregando un
parámetro extra.
Operatoria de matrices
●
●
●
Las operaciones matriz con escalar son iguales a las de
arreglos.
Para operar matrices con matrices, es necesario que
ambas sean del mismo orden.
Para obtener la posición de un elemento de una matriz,
usamos a[i,j], donde 'i' es la fila y 'j' es la columna:
●
●
a[3,2] es 6.4
Para rebanar la matriz, usamos el operador 'a:b:c' en
ambos lados del elemento
●
a[0:2, 1:3] es array([7.4, 3.2], [6.8, 4.1])
Funciones de matrices
●
a.transpose()
●
●
a.reshape((x, y))
●
●
Transpone la matriz 'a' (cambia filas por columnas)
Rehace la matriz 'a' en una matriz de forma x,y
diag(a)
●
Devuelve una matriz con la diagonal de 'a'
Multiplicación de arreglos
●
Para la multiplicación interna de arreglos, se
usa la función dot(a, b)
●
●
Si a y b son vectores (matrices unidimensionales),
el resultado es el producto punto de ambos
vectores
Si a es una matriz y b es un vector (o viceversa), o
si a y b son matrices, el resultado es el producto
matricial de ambos.
Resolución de sistemas lineales
●
Usando el producto matriz-vector, podemos
calcular un sistema lineal del tipo Ax=b
usando la función solve():
a = array([[ 36. ,
51. ,
13. ],
[ 52. ,
34. ,
74. ],
[
b = array([
0. ,
3.,
x = solve(a, b)
7. ,
45.,
1.1]])
33.])