Arreglos en Python

En muchas aplicaciones de Ingeniería es de suma importancia poder realizar 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, o int) es el arreglo.

Los arreglos tienen varias características:

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

• los elementos se pueden recorrer usando un ciclo for.

También tienen algunas restricciones:

• todos los elementos del arreglo deben tener el mismo tipo

• en general el tamaño del arreglo es fijo
• se emplean principalmente para almacenar datos numéricos

Los arreglos son los equivalentes en programación de las matrices (arreglos de dos
dimensiones) y vectores (arreglos de una dimensión) 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.

Arreglos de una dimensión (llamado vector o simplemente arreglo)

Declaración básica:

miArreglo = []

Con ésta línea de código se declara un arreglo llamado “miArreglo” vacío o bien de
tamaño 0.

También se puede declarar un arreglo con datos (cualquier tipo {numéricos, flotantes,
caracteres, strings} con un tamaño predefinido, por ejemplo:

miArreglo = [1,2,3,4,5,6,7,8,9,10]

Con ésta línea de código se declara un arreglo llamado “miArreglo” de tamaño 10 (o

sea 10 elementos) de números enteros.
Así como se declaran arreglos numéricos enteros, se pueden declarar arreglos de otros tipos
de datos:

miArregloF = [23.12, 0.34, 3.4 ,9982.2]

Arreglo de tamaño 4 de números flotantes

miArregloS = [“texto1”, “texto2”, “texto3”]

Arreglo de tamaño 3 de cadenas de caracteres {strings}

miArregloC = [´a´, ´b´, ´c´, ´d´, ´e´]

Arreglo de tamaño 5 de caracteres {char}

Recorrido de arreglos

La manera más común y sencilla de recorrer (acceder a sus elementos, ya sea para leer o
escribir información) un arreglo, es mediante ciclos o bucles, siendo el ciclo FOR el más
usado, aunque también el WHILE se puede emplear. Se utiliza el índice o posición de cada
elemento del arreglo para acceder a su valor, iniciando con el 0 hasta N, dónde N es el
tamaño del arreglo menos 1.

Ejemplo recorrido:
myArray = [1,2,3,4,5,6,7,8,9,10]

longitud = len(myArray)

for i in range(0,longitud):

print(myArray[i])

En el ejemplo se usa la función len(arreglo) para obtener el tamaño {cantidad de

elementos} del arreglo, con este dato se puede obtener el límite máximo del índice
del arreglo para recorrer el arreglo.

Es más sencillo realizar un esquema gráfico para ilustrar mejor cómo se vería un arreglo y
sus índices:

myArray:
INDICE 0 1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9 10

Cada elemento del arreglo se accede a través de el nombre del arreglo y la posición a
acceder entre paréntesis cuadrados: myArray[índice], en el caso del recorrido por un ciclo,
para representar el índice se usa la variable iteradora, en este caso la “i”.

Ejemplo recorrido para asignar datos a cada elemento del arreglo:

 myArray = [1,2,3,4,5,6,7,8,9,10]

longitud = len(myArray)

for i in range(0,longitud):

myArray[i] = pow(myArray[i],2)

En el ejemplo anterior se recorre el arreglo y se asigna a cada elemento el resultado

de elevar al cuadrado (con la función pow(base,exponente) ) el valor del iterador.

Ejemplo de arreglo de Strings:

myStringArr = ["lunes","08","octubre","de","2018"]

longitud = len(myStringArr)

for i in range(0,longitud):

print( myStringArr[i] )

Como se puede observar, el manejo y recorrido es idéntico, solamente es tener

cuidado con los tipos de datos usados, dada la flexibilidad del compilador.

Algunas funciones o métodos de arreglos

append:

Para añadir un elemento a un arreglo, se usa el método o función append(), por

ejemplo:
miArreglo = []

miArreglo. append(23)

miArreglo. append(32)

Ahora el arreglo tiene dos elementos enteros [23,32] y su tamaño es precisamente

2.

clear:

Mediante el método o función clear() se pueden eliminar todos los elementos de un

arreglo y por ende, dejar su tamaño en 0 (arreglo vacío):
miArreglo. clear()

remove:

Mediente el método o función remove(valor), es posible eliminar un elemento del

arreglo igual al parámetro valor.
Existen otros métodos o funciones útiles de los arreglos básicos:

Ejemplo de método para crear un arreglo y retornarlo:

import random

def crearArreglo(N):

arreglo = []

for i in range(N):

arreglo.append(random.randint(0, 10))

return arreglo
 En el ejemplo anterior se declara una función que recibe como parámetro un número
N que sería el tamaño de un arreglo que se declara y se retorna, antes se llena el
mismo con números aleatorios del 0 al 10, para esto se usa la función
random.randint(0, 10) y al inicio del programa se importa la librería random de Python {
import random}

Arreglos de dos dimensiones (también llamado matriz)

Una matriz es básicamente un arreglo de dos dimensiones {similar a los ejes x-y en un
plano}:

miArreglo

INDICE 0 1 2 3 4 5 6 7 8 9
0 A1 B1 C1 D1 E1 F1 G1 H1 I1 J1
1 A2 B2 C2 D2 E2 F2 G2 H2 I2 J2
2 A3 B3 C3 D3 E3 F3 G3 H3 I3 J3
3 A4 B4 C4 D4 E4 F4 G4 H4 I4 J4
4 A5 B5 C5 D5 E5 F5 G5 H5 I5 J5

Debemos recordar que las representaciones gráficas que les damos a los arreglos no son
precisamente cómo se almacena la información en el computador, son básicamente
convenciones sencillas.

Las matrices en Python no son una estructura de datos nativa, sino que se declaran como
arreglos de arreglos:
miMatriz = [ [1,2,3],[4,5,6],[7,8,9] ]

El ejemplo anterior declara una matriz de 3x3 (3 filas y 3 columnas) e inicializa cada celda
ó campo con los números del 1 al 9, gráficamente se podría expresar así:

1 2 3
4 5 6
7 8 9

Como se puede ver, cada fila es un arreglo de 3 espacios y a su vez cada columna es un
arreglo también.
Para recorrer una matriz se usa el concepto de anidación de ciclos, o sea, un ciclo {o más}
dentro de otro, de igual manera como se recorre un arreglo simple. Las variables iteradoras
i y también j sirven como los índices (filas y columnas) a la hora de recorrer y acceder los
valores de cada campo:
miMatriz = [ [1,2,3],[4,5,6],[7,8,9] ]
for i in range( len(miMatriz) ):
for j in range( len(miMatriz[i]) ):
print (miMatriz[i][j])

El ejemplo anterior muestra el recorrido de una matriz de 3x3, para ello se usa el tamaño
del primer arreglo y se accede a cada elemento {que también es un arreglo}, y una vez
accedido dicho elemento se obtiene su tamaño, para luego acceder al elemento mediante
sus índices i – j {equivalente a las coordenadas x,y de un punto}.

Una buena práctica, y muy útil, es usar funciones auxiliares para la construcción de arreglos,
las siguientes funciones muestran dos declaraciones simples, la primera para crear un
arreglo de tamaño N recibido como parámetro, llenarlo con números aleatorios y retornarlo,
mientras que la segunda crea un arreglo de arreglos {matriz de tamaño NxM recibidos como
parámetros} usando como auxiliar la función anterior y también retornando el arreglo:
def crearArreglo(N):
arreglo = []
for i in range(N):
arreglo.append(random.randint(0, 10))
return arreglo

def crearMatriz(N, M):

Matriz = []
for i in range(N):
Matriz.append(crearLista(M))
return Matriz

En la función creaMatriz(N,M) se puede agregar unas líneas de código luego de la creación

dela matriz para desplegar en pantalla cada valor:
def crearMatriz(N, M):
Matriz = []
for i in range(N):
Matriz.append(crearLista(M))
for i in range(N):
Fila = ""
for j in range(M):
Espacios = ' ' * (5 - len(str(Matriz[i][j])))
Fila = Fila + Espacios + str(Matriz[i][j])
print(Fila)
return Matriz