Arreglos

Arreglos
Introduccion
Las estructuras de datos que hemos visto hasta ahora (listas, tuplas, diccionarios,
conjuntos) permiten manipular datos de manera muy flexible. Combinándolas y
anidándolas, es posible organizar información de manera estructurada para
representar sistemas del mundo real.
En muchas aplicaciones de Ingeniería, por otra parte, más importante que la

organización de los datos es la capacidad de hacer muchas operaciones a la vez sobre
grandes conjuntos de datos numéricos de manera eficiente. Algunos ejemplos de
problemas que requieren manipular grandes secuencias de números son: la predicción
del clima, la construcción de edificios, y el análisis de indicadores financieros entre
muchos otros.
La estructura de datos que sirve para almacenar estas grandes secuencias de números
(generalmente de tipo float) es el arreglo.
Los arreglos tienen algunas similitudes con las listas:
 los elementos tienen un orden y se pueden acceder mediante su posición,

 los elementos se pueden recorrer usando un ciclo for.
Sin embargo, también tienen algunas restricciones:
 todos los elementos del arreglo deben tener el mismo tipo,

 en general, el tamaño del arreglo es fijo (no van creciendo dinámicamente como
las listas),
 se ocupan principalmente para almacenar datos numéricos.
A la vez, los arreglos tienen muchas ventajas por sobre las listas, que iremos
descubriendo a medida que avancemos en la materia.
Los arreglos son los equivalentes en programación de las matrices y vectores de las
matemáticas. Precisamente, una gran motivación para usar arreglos es que hay mucha
teoría detrás de ellos que puede ser usada en el diseño de algoritmos para resolver
problemas verdaderamente interesantes.
Crear arreglos
El módulo que provee las estructuras de datos y las funciones para trabajar con arreglos
se llama NumPy, y no viene incluído con Python, por lo que hay que instalarlo por
separado.
Descargue el instalador apropiado para su versión de Python desde la página de

descargas de NumPy. Para ver qué versión de Python tiene instalada, vea la primera
línea que aparece al abrir una consola.
Para usar las funciones provistas por NumPy, debemos importarlas al principio del
programa:
from numpy import array
Como estaremos usando frecuentemente muchas funciones de este módulo, conviene

importarlas todas de una vez usando la siguiente sentencia:
from numpy import *
(Si no recuerda cómo usar el import, puede repasar la materia sobre módulos).
El tipo de datos de los arreglos se llama array. Para crear un arreglo nuevo, se puede
usar la función array pasándole como parámetro la lista de valores que deseamos
agregar al arreglo:
>>> a = array([6, 1, 3, 9, 8])

>>> a
array([6, 1, 3, 9, 8])
Todos los elementos del arreglo tienen exactamente el mismo tipo. Para crear un
arreglo de números reales, basta con que uno de los valores lo sea:
>>> b = array([6.0, 1, 3, 9, 8])

>>> b
array([ 6., 1., 3., 9., 8.])
Otra opción es convertir el arreglo a otro tipo usando el método astype:
>>> a
array([6, 1, 3, 9, 8])
>>> a.astype(float)
array([ 6., 1., 3., 9., 8.])
>>> a.astype(complex)
array([ 6.+0.j, 1.+0.j, 3.+0.j, 9.+0.j, 8.+0.j])
Hay muchas formas de arreglos que aparecen a menudo en la práctica, por lo que
existen funciones especiales para crearlos:
 zeros(n) crea un arreglo de n ceros;

 ones(n) crea un arreglo de n unos;
 arange(a, b, c) crea un arreglo de forma similar a la función range, con las
diferencias que a, b y c pueden ser reales, y que el resultado es un arreglo y no
una lista;
 linspace(a, b, n) crea un arreglo de n valores equiespaciados entre a y b.
>>> zeros(6)
array([ 0., 0., 0., 0., 0., 0.])
>>> ones(5)
array([ 1., 1., 1., 1., 1.])
>>> arange(3.0, 9.0)

array([ 3., 4., 5., 6., 7., 8.])
>>> linspace(1, 2, 5)
array([ 1. , 1.25, 1.5 , 1.75, 2. ])
Operaciones con arreglos

Las limitaciones que tienen los arreglos respecto de las listas son compensadas por la
cantidad de operaciones convenientes que permiten realizar sobre ellos.
Las operaciones aritméticas entre arreglos se aplican elemento a elemento:
>>> a = array([55, 21, 19, 11, 9])

>>> b = array([12, -9, 0, 22, -9])
# sumar los dos arreglos elemento a elemento

>>> a + b
array([67, 12, 19, 33, 0])
# multiplicar elemento a elemento

>>> a * b
array([ 660, -189, 0, 242, -81])
# restar elemento a elemento

>>> a - b
array([ 43, 30, 19, -11, 18])
Las operaciones entre un arreglo y un valor simple funcionan aplicando la operación a

todos los elementos del arreglo, usando el valor simple como operando todas las veces:
>>> a
array([55, 21, 19, 11, 9])
# multiplicar por 0.1 todos los elementos

>>> 0.1 * a
array([ 5.5, 2.1, 1.9, 1.1, 0.9])
# restar 9.0 a todos los elementos

>>> a - 9.0
array([ 46., 12., 10., 2., 0.])
Note que si quisiéramos hacer estas operaciones usando listas, necesitaríamos usar un
ciclo para hacer las operaciones elemento a elemento.
Las operaciones relacionales también se aplican elemento a elemento, y retornan un

arreglo de valores booleanos:
>>> a = array([5.1, 2.4, 3.8, 3.9])

>>> b = array([4.2, 8.7, 3.9, 0.3])
>>> c = array([5, 2, 4, 4]) + array([1, 4, -2, -1]) / 10.0
>>> a < b
array([False, True, True, False], dtype=bool)
>>> a == c
array([ True, True, True, True], dtype=bool)
Para reducir el arreglo de booleanos a un único valor, se puede usar las funciones any y
all. any retorna True si al menos uno de los elementos es verdadero, mientras que all
retorna True sólo si todos lo son (en inglés, any signfica «alguno», y all significa «todos»):
>>> any(a < b)

True
>>> any(a == b)
False
>>> all(a == c)
True
Funciones sobre arreglos

NumPy provee muchas funciones matemáticas que también operan elemento a
elemento. Por ejemplo, podemos obtener el seno de 9 valores equiespaciados entre 0 y
π/2 con una sola llamada a la función sin:
>>> from numpy import linspace, pi, sin
>>> x = linspace(0, pi/2, 9)

>>> x
array([ 0. , 0.19634954, 0.39269908,
0.58904862, 0.78539816, 0.9817477 ,
1.17809725, 1.37444679, 1.57079633])
>>> sin(x)
array([ 0. , 0.19509032, 0.38268343,
0.55557023, 0.70710678, 0.83146961,
0.92387953, 0.98078528, 1. ])
Como puede ver, los valores obtenidos crecen desde 0 hasta 1, que es justamente como
se comporta la función seno en el intervalo [0, π/2].
Aquí también se hace evidente otra de las ventajas de los arreglos: al mostrarlos en la
consola o al imprimirlos, los valores aparecen perfectamente alineados. Con las listas,
esto no ocurre:
>>> list(sin(x))
[0.0, 0.19509032201612825, 0.38268343236508978, 0.5555702330
1960218, 0.70710678118654746, 0.83146961230254524, 0.9238795
3251128674, 0.98078528040323043, 1.0]
Arreglos aleatorios
El módulo NumPy contiene a su vez otros módulos que proveen funcionalidad adicional
a los arreglos y funciones básicos.
El módulo numpy.random provee funciones para crear números aleatorios (es decir,
generados al azar), de las cuales la más usada es la función random, que entrega un
arreglo de números al azar distribuidos uniformemente entre 0 y 1:
>>> from numpy.random import random
>>> random(3)
array([ 0.53077263, 0.22039319, 0.81268786])
>>> random(3)
array([ 0.07405763, 0.04083838, 0.72962968])
>>> random(3)
array([ 0.51886706, 0.46220545, 0.95818726])
Obtener elementos de un arreglo

Cada elemento del arreglo tiene un índice, al igual que en las listas. El primer elemento
tiene índice 0. Los elementos también pueden numerarse desde el final hasta el
principio usando índices negativos. El último elemento tiene índice —1:
>>> a = array([6.2, -2.3, 3.4, 4.7, 9.8])
>>> a[0]
6.2
>>> a[1]
-2.3
>>> a[-2]
4.7
>>> a[3]
4.7
Una seccion del arreglo puede ser obtenida usando el operador de rebanado a[i:j]. Los
índices i y j indican el rango de valores que serán entregados:
>>> a
array([ 6.2, -2.3, 3.4, 4.7, 9.8])
>>> a[1:4]
array([-2.3, 3.4, 4.7])
>>> a[2:-2]
array([ 3.4])
Si el primer índice es omitido, el rebanado comienza desde el principio del arreglo. Si el

segundo índice es omitido, el rebanado termina al final del arreglo:
>>> a[:2]
array([ 6.2, -2.3])
>>> a[2:]
array([ 3.4, 4.7, 9.8])
Un tercer índice puede indicar cada cuántos elementos serán incluídos en el resultado:
>>> a = linspace(0, 1, 9)
>>> a
array([ 0. , 0.125, 0.25 , 0.375, 0.5 , 0.625, 0.75 , 0.875, 1. ])
>>> a[1:7:2]
array([ 0.125, 0.375, 0.625])
>>> a[::3]
array([ 0. , 0.375, 0.75 ])
>>> a[-2::-2]
array([ 0.875, 0.625, 0.375, 0.125])
>>> a[::-1]
array([ 1. , 0.875, 0.75 , 0.625, 0.5 , 0.375, 0.25 , 0.125, 0. ])
Una manera simple de recordar cómo funciona el rebanado es considerar que los
índices no se refieren a los elementos, sino a los espacios entre los elementos:
>>> b = array([17.41, 2.19, 10.99, -2.29, 3.86, 11.10])

>>> b[2:5]
array([ 10.99, -2.29, 3.86])
>>> b[:5]
array([ 17.41, 2.19, 10.99, -2.29, 3.86])
>>> b[1:1]
array([], dtype=float64)
>>> b[1:5:2]
array([ 2.19, -2.29])
Algunos métodos convenientes
Los arreglos proveen algunos métodos útiles que conviene conocer.
Los métodos min y max, entregan respectivamente el mínimo y el máximo de los

elementos del arreglo:
>>> a = array([4.1, 2.7, 8.4, pi, -2.5, 3, 5.2])

>>> a.min()
-2.5
>>> a.max()
8.4000000000000004
Los métodos argmin y argmax entregan respectivamente la posición del mínimo y del
máximo:
>>> a.argmin()
4
>>> a.argmax()
2
Los métodos sum y prod entregan respectivamente la suma y el producto de los

elementos:
>>> a.sum()
24.041592653589795
>>> a.prod()
-11393.086289208301

Arreglos

Cargado por

Copyright:

Formatos disponibles

Arreglos

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Arreglos

Cargado por

Copyright:

Formatos disponibles

Arreglos

En muchas aplicaciones de Ingeniería, por otra parte, más importante que la

Los arreglos tienen algunas similitudes con las listas:

 los elementos tienen un orden y se pueden acceder mediante su posición,

Sin embargo, también tienen algunas restricciones:

 todos los elementos del arreglo deben tener el mismo tipo,

Descargue el instalador apropiado para su versión de Python desde la página de

from numpy import array

Como estaremos usando frecuentemente muchas funciones de este módulo, conviene

from numpy import *

>>> a = array([6, 1, 3, 9, 8])

>>> b = array([6.0, 1, 3, 9, 8])

Otra opción es convertir el arreglo a otro tipo usando el método astype:

 zeros(n) crea un arreglo de n ceros;

>>> arange(3.0, 9.0)

Operaciones con arreglos

Las operaciones aritméticas entre arreglos se aplican elemento a elemento:

>>> a = array([55, 21, 19, 11, 9])

# sumar los dos arreglos elemento a elemento

# multiplicar elemento a elemento

# restar elemento a elemento

Las operaciones entre un arreglo y un valor simple funcionan aplicando la operación a

# multiplicar por 0.1 todos los elementos

# restar 9.0 a todos los elementos

Las operaciones relacionales también se aplican elemento a elemento, y retornan un

>>> a = array([5.1, 2.4, 3.8, 3.9])

>>> any(a < b)

Funciones sobre arreglos

>>> from numpy import linspace, pi, sin

>>> x = linspace(0, pi/2, 9)

>>> from numpy.random import random

Obtener elementos de un arreglo

>>> a = array([6.2, -2.3, 3.4, 4.7, 9.8])

Si el primer índice es omitido, el rebanado comienza desde el principio del arreglo. Si el

>>> b = array([17.41, 2.19, 10.99, -2.29, 3.86, 11.10])

Los métodos min y max, entregan respectivamente el mínimo y el máximo de los

>>> a = array([4.1, 2.7, 8.4, pi, -2.5, 3, 5.2])

Los métodos sum y prod entregan respectivamente la suma y el producto de los

También podría gustarte