• Author / Uploaded
• Alex M.

Citation preview

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

1 2

2 3

3 4

4 5

5 6

6 7

7 8

8 9

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