I NTRODUCCIÓN A LA

P ROGRAMACIÓN
Arreglos
TEORÍA DE ARREGLOS

 Definición

Un arreglo es un grupo de posiciones en memoria relacionadas entre sí porque tienen el

mismo nombre y son del mismo tipo.

Para referirse a una posición en particular o elemento dentro del arreglo, especificaremos el
nombre del arreglo y el número de posición del elemento particular dentro del mismo.

a: nombre del arreglo

3 5 8 6 0 4 3

0 1 2 3 4 5 6 posición

a [ 1 ] = 5 contenido de la posición 1 del vector

a es un arreglo de enteros que contiene 7 elementos, Cualquiera de éstos elementos puede

ser referenciado dándole el nombre seguido por el número de posición de dicho elemento en
particular entre [ ].

El primer elemento de cualquier arreglo es el elemento de posición cero.

a [0], a [1],..., a [6]

El elemento de orden i se conoce como a [i-1].

El número que está entre los [ ] se llama subíndice y debe ser un entero o expresión entera.
Por ejemplo, para multiplicar el tercer elemento del arreglo por 4 y asignarlo a una variable x
escribimos:

x = a [2] * 4

Arreglos en Python

Para definir un arreglo en Python existen diferentes formas.

Una de ella es asignar a la variable de tipo arreglo los elementos escritos entre corchetes y
separados por coma

a = [1, 3, 5, 3, 4, 6]

De esta forma se asignan al arreglo a seis elementos que son 1, 3, 5, 3, 4 y 6, que ocupan las
posiciones 0, 1, 2, 3, 4, 5 respectivamente

Ejemplo:
Inicializar un arreglo de 5 elementos en cero y mostrarlo:

1
 a = [0, 0, 0, 0, 0]
for i in range(0, 5):
print (“\t”, a[i], end=””)

Si no se le asignan valores determinados al arreglo, primero se define la variable al comenzar

el programa como a = [ ] y luego se agregan los elementos al vector, como veremos más
adelante

 OPERACIONES CON ARREGLOS

Cuando trabajamos con variables de tipo arreglos, podemos realizar, entre otras, las
siguientes operaciones:

1) Cargar
2) Recorrer
3) Mostrar
4) Buscar un elemento
5) Desplazar
6) Intercambiar
7) Ordenar

Veamos cómo podemos proceder en cada caso:

1) Cargar un arreglo de n elementos.

Para guardar elementos en un arreglo se utiliza una instrucción repetitiva, por ejemplo
for.

La cantidad de elementos que tiene el arreglo se puede definir en el programa o se puede

ingresar por teclado.

a = []
n = int(input(“Ingrese la cantidad de elementos del vector”))
for i in range (0, n):
a.append (int (input (“Ingrese el valor de cada elemento \t)))

En el ejemplo anterior, la cantidad de elementos del arreglo se ingresa por teclado. En la

última línea, la función append permite ir agregando de a uno los elementos al arreglo

2) Recorrer el arreglo

Para recorrer el arreglo e individualizar uno por uno sus elementos, utilizamos, en
general, también un ciclo repetitivo que permita ir modificando el valor del subindice

Por ejemplo, si queremos sumar los elementos del arreglo, el código es:

2
 for i in range(0, n):
sum = sum + a[i]

El valor de la variable i del for nos permite acceder a los elementos del arreglo a desde
la posición 0 hasta la posición n – 1

3) Mostrar un arreglo

Para imprimir o mostrar el arreglo elemento a elemento también usamos un for, pues
debemos recorrerlo para mostrarlo.

for i in range(0, n):

print(“Elemento %d: %d” %(i, a[i]))

4) Buscar un elemento en un arreglo

Al buscar un elemento en el arreglo que cumpla con determinadas condiciones, es posible

que lo encontremos antes de terminar de recorrer el arreglo, por ello no es conveniente
hacerlo con un for. Es preferible utilizar un while pues nos permite comparar con la
condición y cortar la búsqueda al encontrarlo, sin necesidad de seguir recorriendo el
arreglo hasta el último elemento.

La búsqueda de un elemento no significa que ese elemento esté en el arreglo. Por eso la
condición del while debe ser doble, por un lado la condición contraria a pedida para el
elemento (seguirá buscando mientras no lo encuentre) y por el otro, una condición que
indique si terminamos de recorrer el arreglo.

Por ejemplo, si queremos encontrar la posición del primer múltiplo de 3 en un arreglo, el

programa deberá ejecutar las instrucciones del ciclo while mientras la variable que indica
las posiciones de los elementos del arreglo sea menor al tamaño del mismo y mientras el
elemento del arreglo no sea múltiplo de 3. La instrucción i = i + 1 permite ir avanzando
sobre las posiciones del arreglo

a = []
n = int(input(“Ingrese la cantidad de elementos del vector”))
for i in range(0, n):
a.append(int(input(“Ingrese el valor de cada elemento \t”)))
for i in range(0, n):
print(“Elemento %d: %d” % (i, a[i]))
i=0
while (i < n and a[i] % 3 != 0):
i=i+1
if i == n:
print(“El vector no tiene ningún elemento múltiplo de 3”)
else:
print(“El primer múltiplo de 3 está en la posición %d y es %d”, % (i, a[i]))

3
Una vez que sale del while debemos preguntar por cuál de las dos condiciones salió y
accionar según corresponda. En el ejemplo, si la instrucción if i == n resulta verdadera
significa que se terminó de recorrer el arreglo (dejo de cumplirse la condición i < n) y no
se encontró ningún múltiplo de 3 (no fue falsa la condición de que a[i] no sea múltiplo de
3 para ningún valor de i)

5) Intercambiar dos elementos del arreglo

Para intercambiar dos elementos de un arreglo deben conocerse las dos posiciones que se
quieren intercambiar.

Supongamos que quiero intercambiar el elemento de la posición 1 con el elemento de la

posición 2.

Si escribimos a [pos2] = a [pos1]

En la posición 2 queda el valor que está en la posición 1, pero el valor que tenía
originalmente la posición 2 se perdió y en la posición 1 sigue quedando su valor original.
Es decir, no logramos lo pedido.

Para poder intercambiar, sin perder ningún valor, debemos declarar una variable auxiliar
y guardar allí el valor de posición 2 antes de hacer la asignación.

Esto quedaría así:

aux = a[pos2]
a [pos2] = a [pos1]
a [pos1] = aux

6) Otras operaciones con arreglos en Python

En Python existen ciertas funciones para trabajar con arreglos que ya han sido
definidas, tales como insert, sort, reverse, remove, etc.

A continuación detallamos algunas de ellas:

 Insert
Esta función permite insertar un valor en una posición determinada del arreglo,
desplazando los elementos que están a la derecha del mismo.

Se escribe el nombre del arreglo seguido de un punto y la palabra insert. Entre

paréntesis se escriben los parámetros de la función que son la posición en la que se va a
insertar el valor y, separado por coma, el valor a insertar.

nombredelarreglo.insert (posición, valor)

Ejemplo: Ingresar un arreglo de n elementos y un valor y la posición en la que desea

insertar ese valor. Mostrar el nuevo arreglo

4
a = []
n = int(input(“Ingrese la cantidad de elementos del vector”))
for i in range(0, n):
a.append(int(input(“Ingrese el valor de cada elemento \t”)))
m = int(input(“Ingres el valor a insertar”))
pos = int(input(“Ingrese la posición en donde va a insertar el numero))
a.insert(pos, m)
for i in range(0, n + 1):
print(a[i])

 Reverse
Esta función permite invertir los elementos del arreglo. Se utiliza escribiendo el nombre
del arreglo seguido de un punto y la palabra reverse

nombredelarreglo.reverse()

 Sort
Esta función permite ordenar los elementos de un arreglo en forma creciente. Se escribe
el nombre del arreglo seguido de un punto y la palabra sort ()

Ejemplo: ingresar un arreglo de n elementos y mostrarlo ordenado en forma creciente

a = []
n = int(input(“Ingrese la cantidad de elementos del vector”))
for i in range(0, n):
a.append(int(input(“Ingrese el valor de cada elemento \t”)))
a.sort()
for i in range(0, n):
print(a[i])

Para ordenar el arreglo en forma decreciente podemos utilizar la función sort y luego la
función reverse

a = []
n = int(input(“Ingrese la cantidad de elementos del vector”))
for i in range(0, n):
a.append(int(input(“Ingrese el valor de cada elemento \t”)))
a.sort()
a.reverse()
for i in range(0, n):
print(a[i])

5
  Remove
Esta función permite eliminar un elemento determinado del arreglo. Se escribe el nombre
del arreglo seguido de un punto y la palabra remove. Entre paréntesis, el parámetro es el
elemento a eliminar (el valor y no la posición).

a = []
n = int(input(“Ingrese la cantidad de elementos del vector”))
for i in range(0, n):
a.append(int(input(“Ingrese el valor de cada elemento \t”)))
a.remove(3) elimina el primer 3 que encuentra
for i in range(0, len(a)):
print(a[i]) muestra como quedo el arreglo

 Pop
Esta función permite eliminar el elemento de un arreglo que está en una determinada
posición y devuelve el elemento eliminado. Se escribe el nombre del arreglo seguido
de un punto y la palabra pop. Luego entre paréntesis se escribe la posición del
elemento que se quiere eliminar.

Si en el ejemplo anterior escribimos a.pop(3) se elimina del arreglo a el elemento de

la posición 3. El nuevo arreglo tendrá un elemento menos que el original.

¿Cómo pasar arreglos en funciones?

Una vez definida la variable como arreglo en el programa principal, para pasarla como
argumento en una función, se escribe el nombre sin los corchetes. De igual manera en
la definición de la función, la variable que representa al arreglo se escribe como
parámetro sin los corchetes

Ejemplo:

Definir una función que sume las componentes de un arreglo y devuelva las suma al
programa principal.

def sumar(n ,a):

suma = 0
for i in range(0, n):
suma = suma + a[i]
return suma

#programa principal
vec= []
n = int(input(“Ingrese la cantidad de elementos del vector”))
for i in range(0, n):
vec.append(int(input(“Ingrese el valor de cada elemento \t”)))
suma = suma(n, vec)
print(“La suma de los elementos del vector es “, suma)

6
En el ejemplo, la variable vec está declarada como arreglo (vec = []). En la llamada a
la función sumar escribimos solo vec como argumento y en la definición de la función,
el parámetro a recibe las componentes del arreglo y funciona como tal. La función
puede modificar los elementos del arreglo que recibe como parámetro, sin tener que
devolverlo en el return.