23- 📊 Arrays en Python: Guía Básica

Acordeón de los Índices

Índice de los temas

• Arrays
• What is an Array?
• Access the Elements of an Array
• The Length of an Array
• Looping Array Elements
• Adding Array Elements
• Removing Array Elements
• Array Methods

---

Arrays

🔢 Arrays en Python: Estructuras de Datos Ordenadas

Cuando hablamos de "arrays" en el contexto de muchos lenguajes de programación, nos referimos a estructuras de datos que almacenan una colección de elementos del mismo tipo. Sin embargo, en Python, la estructura de datos que más se asemeja a un array tradicional es la lista. Las listas en Python son más flexibles que los arrays típicos de otros lenguajes, ya que pueden contener elementos de diferentes tipos.

Aunque Python no tiene un tipo de dato "array" incorporado directamente con la misma rigidez que en C++ o Java, el módulo array de la biblioteca estándar proporciona una forma de crear arrays que almacenan elementos de un tipo numérico específico de manera más eficiente en términos de memoria para ciertos casos.

En esta lección, principalmente nos centraremos en cómo usar las listas de Python como si fueran arrays, ya que son la estructura de datos más común y versátil para almacenar secuencias de elementos.

¿Por Qué Usar Listas como Arrays?

• Ordenadas: Los elementos en una lista tienen un orden específico, y ese orden se mantiene.
• Indexadas: Puedes acceder a cada elemento de la lista utilizando un índice (posición), comenzando desde 0.
• Mutables: Puedes cambiar, añadir o eliminar elementos de una lista después de su creación.
• Permiten duplicados: Las listas pueden contener elementos con el mismo valor.
• Flexibles en tipo (por defecto): Aunque en el módulo array los elementos deben ser del mismo tipo, las listas de Python pueden contener elementos de diferentes tipos (aunque a menudo se usan para almacenar elementos del mismo tipo por consistencia).

Ejemplo de Creación de una Lista (Usándola como Array):

      
# Una lista de números enteros
numeros = [10, 20, 30, 40, 50]
print(numeros)

# Una lista de cadenas
frutas = ["manzana", "banana", "cereza"]
print(frutas)

# Una lista mixta (aunque no es el uso típico de un array)
datos_mixtos = [1, "hola", 3.14, True]
print(datos_mixtos)
      
     

A lo largo de esta lección, exploraremos cómo acceder a los elementos de estas listas, cómo modificarlas, cómo recorrerlas y algunas de las operaciones más comunes que se realizan con ellas, tratándolas en muchos aspectos como si fueran los arrays que encontrarías en otros lenguajes.

What is an Array?

🧐 ¿Qué es un Array (en el Contexto de Python)?

Como mencionamos en el tema anterior, en Python, la estructura de datos que utilizamos de manera similar a un array tradicional es la lista. Si bien el módulo array existe para casos específicos de almacenamiento numérico eficiente, la flexibilidad y el uso generalizado de las listas hacen que sean la "navaja suiza" para secuencias de datos ordenadas.

Características Fundamentales de las Listas (como Arrays):

• Colección de Elementos: Una lista es un contenedor que puede almacenar múltiples elementos bajo un solo nombre de variable.
• Ordenada: Los elementos dentro de una lista mantienen un orden específico. El orden en que se añaden los elementos es el orden en el que se almacenan y se acceden a ellos.
• Indexada: Cada elemento en una lista tiene una posición o índice. Los índices comienzan desde 0 para el primer elemento, 1 para el segundo, y así sucesivamente. Esto permite acceder a elementos específicos utilizando su índice.
• Mutable: Las listas son mutables, lo que significa que puedes cambiar, añadir o eliminar elementos de una lista después de que ha sido creada. Esta es una diferencia clave con otras estructuras de datos secuenciales en Python, como las tuplas, que son inmutables.
• Permiten Elementos Duplicados: A diferencia de los conjuntos (sets), las listas pueden contener múltiples ocurrencias del mismo valor.

La Diferencia con los Arrays del Módulo array:

Es importante mencionar brevemente el módulo array de Python:

• Homogéneo en Tipo: Los arrays creados con el módulo array están diseñados para contener elementos del mismo tipo de dato numérico (por ejemplo, todos enteros, todos números de punto flotante). Esto los hace más eficientes en términos de memoria para grandes secuencias numéricas.
• Menos Funcionalidades Incorporadas: Las listas tienen muchas más funcionalidades incorporadas (métodos como append(), insert(), pop(), etc.) en comparación con los objetos de tipo array del módulo array.

Debido a la versatilidad de las listas y su amplia utilización en la programación Python, nos centraremos en ellas como nuestra principal forma de trabajar con colecciones ordenadas de elementos, análogas a los arrays en otros lenguajes.

Ejemplo para Ilustrar las Características:

      
# Creación de una lista (array)
mi_lista = ["Python", 3.7, True, "es", 100]

# Ordenada: el orden de los elementos se mantiene
print(mi_lista)
# Output: ['Python', 3.7, True, 'es', 100]

# Indexada: podemos acceder a elementos por su posición
primer_elemento = mi_lista[0]
print(f"El primer elemento es: {primer_elemento}")
# Output: El primer elemento es: Python

# Mutable: podemos cambiar un elemento
mi_lista[1] = 3.8
print(f"Lista después del cambio: {mi_lista}")
# Output: Lista después del cambio: ['Python', 3.8, True, 'es', 100]

# Permite duplicados:
otra_lista = [1, 2, 2, 3, 1]
print(otra_lista)
# Output: [1, 2, 2, 3, 1]
      
     

En resumen, cuando hablemos de arrays en las siguientes secciones, estaremos refiriéndonos al uso de las listas de Python para almacenar y manipular colecciones ordenadas de elementos.

Access the Elements of an Array

🔑 Acceder a los Elementos de un Array (Lista)

Como las listas en Python son estructuras de datos indexadas, podemos acceder a cada uno de sus elementos utilizando su índice. Recuerda que la indexación en Python (y en muchos otros lenguajes de programación) comienza desde 0.

Acceso por Índice Positivo:

Para acceder a un elemento específico, simplemente colocamos el índice del elemento entre corchetes [] después del nombre de la lista.

      
frutas = ["manzana", "banana", "cereza"]

primer_elemento = frutas[0]  # Accede al elemento en el índice 0 (la "manzana")
print(f"El primer elemento es: {primer_elemento}")

segundo_elemento = frutas[1] # Accede al elemento en el índice 1 (la "banana")
print(f"El segundo elemento es: {segundo_elemento}")

tercer_elemento = frutas[2]  # Accede al elemento en el índice 2 (la "cereza")
print(f"El tercer elemento es: {tercer_elemento}")
      
     

Acceso por Índice Negativo:

Python también permite acceder a los elementos de una lista utilizando índices negativos. Esto es útil para acceder a los elementos desde el final de la lista:

• -1 se refiere al último elemento.
• -2 se refiere al penúltimo elemento.
• Y así sucesivamente...

      
frutas = ["manzana", "banana", "cereza"]

ultimo_elemento = frutas[-1]  # Accede al último elemento ("cereza")
print(f"El último elemento es: {ultimo_elemento}")

penultimo_elemento = frutas[-2] # Accede al penúltimo elemento ("banana")
print(f"El penúltimo elemento es: {penultimo_elemento}")

antepenultimo_elemento = frutas[-3] # Accede al antepenúltimo elemento ("manzana")
print(f"El antepenúltimo elemento es: {antepenultimo_elemento}")
      
     

IndexError: Cuando el Índice Está Fuera de Rango:

Si intentas acceder a un índice que no existe en la lista (es decir, un índice que es menor que el negativo de la longitud de la lista o mayor o igual que la longitud de la lista), Python generará un error llamado IndexError.

      
frutas = ["manzana", "banana", "cereza"]

# Intentar acceder a un índice fuera de rango
# error = frutas[3]  # Esto generará un IndexError
# error_negativo = frutas[-4] # Esto también generará un IndexError
      
     

Es importante asegurarse de que el índice al que intentas acceder esté dentro de los límites válidos de la lista para evitar este error.

Slicing (Rebanado) de Listas:

Además de acceder a elementos individuales, también puedes acceder a una porción de una lista utilizando la técnica de "slicing". Esto se hace especificando un rango de índices:

lista[inicio:fin:paso]
    

• inicio: El índice donde comienza el slice (inclusive). Si se omite, comienza desde el principio.
• fin: El índice donde termina el slice (exclusivo). Si se omite, termina al final.
• paso: La diferencia entre los índices de los elementos incluidos en el slice. Si se omite, el valor por defecto es 1.

      
numeros = [10, 20, 30, 40, 50, 60, 70, 80]

sublista1 = numeros[1:4]   # Elementos desde el índice 1 hasta el 3 (20, 30, 40)
print(f"Sublista 1: {sublista1}")

sublista2 = numeros[:3]    # Elementos desde el inicio hasta el índice 2 (10, 20, 30)
print(f"Sublista 2: {sublista2}")

sublista3 = numeros[4:]    # Elementos desde el índice 4 hasta el final (50, 60, 70, 80)
print(f"Sublista 3: {sublista3}")

sublista4 = numeros[::2]   # Cada segundo elemento (10, 30, 50, 70)
print(f"Sublista 4: {sublista4}")

sublista5 = numeros[::-1]  # La lista en orden inverso (80, 70, 60, 50, 40, 30, 20, 10)
print(f"Sublista 5: {sublista5}")
      
     

Acceder a los elementos por índice y utilizar el slicing son operaciones fundamentales para trabajar con listas en Python.

The Length of an Array

📏 La Longitud de un Array (Lista)

A menudo, al trabajar con arrays (listas), necesitamos saber cuántos elementos contiene. En Python, podemos obtener la longitud de una lista utilizando la función incorporada len().

Usando la Función len():

La función len() toma una lista como argumento y devuelve un entero que representa el número de elementos en esa lista.

      
frutas = ["manzana", "banana", "cereza"]
longitud_frutas = len(frutas)
print(f"La longitud de la lista de frutas es: {longitud_frutas}")
# Output: La longitud de la lista de frutas es: 3

numeros = [10, 20, 30, 40, 50, 60]
longitud_numeros = len(numeros)
print(f"La longitud de la lista de números es: {longitud_numeros}")
# Output: La longitud de la lista de números es: 6

lista_vacia = []
longitud_vacia = len(lista_vacia)
print(f"La longitud de la lista vacía es: {longitud_vacia}")
# Output: La longitud de la lista vacía es: 0
      
     

Importancia de Conocer la Longitud:

Conocer la longitud de una lista es fundamental por varias razones:

• Iteración: A menudo se utiliza la longitud para controlar bucles que recorren los elementos de la lista.
• Validación de índices: Antes de acceder a un elemento por su índice, es útil verificar que el índice esté dentro del rango válido (de 0 a len(lista) - 1) para evitar errores IndexError.
• Cálculos basados en el tamaño: En algunos algoritmos, la longitud de la lista es necesaria para realizar cálculos o tomar decisiones.

Ejemplo de Uso con Iteración:

      
colores = ["rojo", "verde", "azul", "amarillo"]
longitud_colores = len(colores)

for i in range(longitud_colores):
    print(f"El color en el índice {i} es: {colores[i]}")
      
     

Consideraciones:

• La función len() opera en tiempo constante \(O(1)\) para las listas en Python. Esto significa que el tiempo que tarda en ejecutarse no depende del tamaño de la lista.
• len() es una función general de Python y se puede usar con otros tipos de colecciones como cadenas, tuplas, diccionarios y conjuntos para obtener su número de elementos o longitud.

En resumen, la función len() es una herramienta esencial para trabajar con listas (y otras colecciones) en Python, permitiéndonos conocer su tamaño de manera eficiente.

Looping Array Elements

🔄 Recorrer los Elementos de un Array (Lista)

Una de las tareas más comunes al trabajar con arrays (listas) es iterar a través de sus elementos para realizar alguna operación con cada uno de ellos. Python ofrece varias formas de lograr esto utilizando bucles.

Bucle for Directo (Iterando sobre los elementos):

La forma más sencilla y Pythonica de recorrer los elementos de una lista es utilizando un bucle for directamente sobre la lista. En cada iteración, la variable del bucle tomará el valor del siguiente elemento de la lista.

      
frutas = ["manzana", "banana", "cereza"]

for fruta in frutas:
    print(f"Me gusta la {fruta}")
      
     

Bucle for con Índices (Usando range() y len()):

Si necesitas acceder al índice de cada elemento mientras lo recorres (por ejemplo, para modificar el elemento en su posición original o para comparar elementos con sus vecinos), puedes usar un bucle for combinado con la función range() y la longitud de la lista obtenida con len().

      
colores = ["rojo", "verde", "azul"]
longitud_colores = len(colores)

for i in range(longitud_colores):
    print(f"El color en el índice {i} es: {colores[i]}")
      
     

Bucle while:

Aunque menos común para la iteración simple sobre listas, también puedes usar un bucle while para recorrer los elementos utilizando un índice que se incrementa en cada iteración. Sin embargo, debes tener cuidado de no exceder los límites de la lista para evitar un IndexError.

      
animales = ["gato", "perro", "pájaro"]
indice = 0
longitud_animales = len(animales)

while indice < longitud_animales:
    print(f"El animal en el índice {indice} es: {animales[indice]}")
    indice += 1
      
     

List Comprehension (Comprensión de Listas):

Aunque no es un bucle en sí mismo, la comprensión de listas proporciona una forma concisa de crear nuevas listas basadas en los elementos de una lista existente (o cualquier otro iterable). También se puede usar para realizar una operación en cada elemento.

      
numeros = [1, 2, 3, 4, 5]
cuadrados = [numero**2 for numero in numeros]
print(f"Los cuadrados son: {cuadrados}")

# También se puede usar para realizar una acción (aunque no es su uso principal)
[print(f"Número: {n}") for n in numeros]
      
     

enumerate() para obtener índice y valor:

La función enumerate() es muy útil cuando necesitas tanto el índice como el valor de cada elemento mientras iteras sobre una lista. Devuelve una secuencia de tuplas, donde cada tupla contiene el índice y el elemento correspondiente.

      
dias_semana = ["lunes", "martes", "miércoles"]

for indice, dia in enumerate(dias_semana):
    print(f"El día {dia} está en el índice {indice}")
      
     

Estas son las principales formas de recorrer los elementos de una lista (array) en Python. La elección del método dependerá de si solo necesitas el valor del elemento, también necesitas su índice, o si estás creando una nueva lista basada en la original.

Adding Array Elements

➕ Añadir Elementos a un Array (Lista)

Las listas en Python son mutables, lo que significa que podemos añadir nuevos elementos a ellas después de su creación. Python proporciona varios métodos para agregar elementos a una lista, dependiendo de dónde queramos insertarlos.

append(): Añadir al Final

El método append() se utiliza para añadir un elemento al final de la lista. Es la forma más común y eficiente de agregar un solo elemento.

      
frutas = ["manzana", "banana", "cereza"]
frutas.append("naranja")
print(frutas)
# Output: ['manzana', 'banana', 'cereza', 'naranja']

numeros = [1, 2, 3]
numeros.append(4)
print(numeros)
# Output: [1, 2, 3, 4]
      
     

insert(): Añadir en una Posición Específica

El método insert() se utiliza para añadir un elemento en una posición específica de la lista. Requiere dos argumentos: el índice donde se insertará el elemento y el elemento a insertar. Los elementos existentes a partir de esa posición se desplazan hacia la derecha.

      
colores = ["rojo", "amarillo"]
colores.insert(1, "verde")  # Inserta "verde" en el índice 1
print(colores)
# Output: ['rojo', 'verde', 'amarillo']

animales = ["gato", "pájaro"]
animales.insert(0, "perro") # Inserta "perro" al principio (índice 0)
print(animales)
# Output: ['perro', 'gato', 'pájaro']
      
     

extend(): Añadir Elementos de Otra Lista (o Iterable)

El método extend() se utiliza para añadir todos los elementos de otra lista (o cualquier iterable como una tupla o una cadena) al final de la lista actual. Es útil cuando quieres combinar dos listas.

      
lista1 = [1, 2, 3]
lista2 = [4, 5, 6]
lista1.extend(lista2)
print(lista1)
# Output: [1, 2, 3, 4, 5, 6]

nombres = ["Ana", "Beto"]
nuevos_nombres = ("Carlos", "Diana")
nombres.extend(nuevos_nombres)
print(nombres)
# Output: ['Ana', 'Beto', 'Carlos', 'Diana']
      
     

Concatenación con el Operador +:

También puedes usar el operador + para concatenar dos listas, lo que crea una nueva lista que contiene todos los elementos de ambas listas. Sin embargo, a diferencia de append() y extend(), la concatenación crea una nueva lista en lugar de modificar la lista original.

      
letras1 = ["a", "b", "c"]
letras2 = ["d", "e"]
letras_combinadas = letras1 + letras2
print(letras_combinadas)
# Output: ['a', 'b', 'c', 'd', 'e']

print(letras1) # La lista original no se modifica
# Output: ['a', 'b', 'c']
      
     

Consideraciones de Rendimiento:

• append() es generalmente la operación más eficiente para añadir un solo elemento al final.
• insert() puede ser menos eficiente si se insertan elementos cerca del principio de listas grandes, ya que requiere desplazar todos los elementos siguientes.
• extend() es eficiente para añadir múltiples elementos al final.
• La concatenación con + crea una nueva lista, lo que puede ser menos eficiente en términos de memoria si se realiza repetidamente con listas grandes.

La elección del método para añadir elementos dependerá de tus necesidades específicas: si quieres añadir al final, en una posición específica o combinar listas.

Removing Array Elements

➖ Eliminar Elementos de un Array (Lista)

Dado que las listas son mutables, podemos eliminar elementos de ellas utilizando varios métodos. La elección del método dependerá de si conocemos el índice del elemento que queremos eliminar o su valor.

pop(): Eliminar por Índice (y Devolver el Elemento)

El método pop() elimina el elemento en un índice específico de la lista y también devuelve el elemento que fue eliminado. Si no se proporciona ningún índice, pop() elimina y devuelve el último elemento de la lista.

      
frutas = ["manzana", "banana", "cereza"]
elemento_eliminado = frutas.pop(1) # Elimina el elemento en el índice 1 ("banana")
print(frutas)
# Output: ['manzana', 'cereza']
print(f"Elemento eliminado: {elemento_eliminado}")
# Output: Elemento eliminado: banana

numeros = [10, 20, 30]
ultimo_eliminado = numeros.pop() # Elimina el último elemento (30)
print(numeros)
# Output: [10, 20]
print(f"Último elemento eliminado: {ultimo_eliminado}")
# Output: Último elemento eliminado: 30
      
     

del: Eliminar por Índice o Slice

La palabra clave del es una sentencia en Python que se puede usar para eliminar un elemento en un índice específico o para eliminar una porción de la lista (un slice).

      
colores = ["rojo", "verde", "azul", "amarillo"]
del colores[0] # Elimina el elemento en el índice 0 ("rojo")
print(colores)
# Output: ['verde', 'azul', 'amarillo']

numeros = [1, 2, 3, 4, 5]
del numeros[1:3] # Elimina los elementos desde el índice 1 hasta el 2 (2 y 3)
print(numeros)
# Output: [1, 4, 5]
      
     

remove(): Eliminar por Valor

El método remove() elimina la primera aparición de un elemento con un valor específico de la lista. Si el valor no se encuentra en la lista, se genera un error ValueError.

      
animales = ["gato", "perro", "gato", "pájaro"]
animales.remove("gato") # Elimina la primera aparición de "gato"
print(animales)
# Output: ['perro', 'gato', 'pájaro']

# Intentar eliminar un valor que no existe generará un error
# animales.remove("pez") # Esto generará un ValueError
      
     

clear(): Eliminar Todos los Elementos

El método clear() elimina todos los elementos de la lista, dejándola vacía.

      
mi_lista = [1, 2, 3, 4, 5]
mi_lista.clear()
print(mi_lista)
# Output: []
      
     

Consideraciones:

• pop(indice) es útil cuando necesitas el valor del elemento eliminado. Si se usa sin índice, es eficiente para eliminar el último elemento.
• del lista[indice] es una forma directa de eliminar un elemento por su índice sin devolver su valor. del lista[slice] es potente para eliminar múltiples elementos.
• remove(valor) es conveniente cuando conoces el valor del elemento que quieres eliminar, pero debes tener cuidado si el valor no existe en la lista.
• clear() es la forma más rápida de vaciar una lista completa.

La elección del método para eliminar elementos dependerá de si conoces el índice o el valor del elemento (o elementos) que deseas quitar, y si necesitas o no el valor del elemento eliminado.

Array Methods

🛠️ Métodos de Array (Lista) Adicionales

Además de los métodos que ya hemos visto para añadir y eliminar elementos, las listas en Python ofrecen una variedad de métodos incorporados que facilitan la manipulación y el análisis de los datos que contienen.

index(): Encontrar el Índice de un Elemento

El método index() devuelve el índice de la primera aparición de un valor especificado en la lista. Si el valor no se encuentra, genera un error ValueError.

      
frutas = ["manzana", "banana", "cereza", "banana"]
indice_banana = frutas.index("banana")
print(f"El índice de la primera 'banana' es: {indice_banana}")
# Output: El índice de la primera 'banana' es: 1

# Puedes especificar un inicio y un final para la búsqueda
indice_banana_desde_dos = frutas.index("banana", 2)
print(f"El índice de 'banana' buscando desde el índice 2 es: {indice_banana_desde_dos}")
# Output: El índice de 'banana' buscando desde el índice 2 es: 3

# Intentar encontrar un valor que no existe generará un error
# indice_uva = frutas.index("uva") # Esto generará un ValueError
      
     

count(): Contar Ocurrencias de un Elemento

El método count() devuelve el número de veces que un valor específico aparece en la lista.

      
numeros = [1, 2, 2, 3, 2, 4, 2]
conteo_dos = numeros.count(2)
print(f"El número 2 aparece {conteo_dos} veces.")
# Output: El número 2 aparece 4 veces.

conteo_uno = numeros.count(1)
print(f"El número 1 aparece {conteo_uno} vez.")
# Output: El número 1 aparece 1 vez.
      
     

sort(): Ordenar la Lista (In-place)

El método sort() ordena los elementos de la lista en su lugar (es decir, modifica la lista original). Por defecto, ordena los elementos en orden ascendente. Puedes usar el argumento reverse=True para ordenar en orden descendente.

      
letras = ["c", "a", "b"]
letras.sort()
print(f"Lista ordenada ascendentemente: {letras}")
# Output: Lista ordenada ascendentemente: ['a', 'b', 'c']

numeros = [3, 1, 4, 1, 5, 9, 2, 6]
numeros.sort(reverse=True)
print(f"Lista ordenada descendentemente: {numeros}")
# Output: Lista ordenada descendentemente: [9, 6, 5, 4, 3, 2, 1, 1]
      
     

reverse(): Invertir el Orden de la Lista (In-place)

El método reverse() invierte el orden de los elementos de la lista en su lugar.

      
mi_lista = [10, 20, 30, 40]
mi_lista.reverse()
print(f"Lista invertida: {mi_lista}")
# Output: Lista invertida: [40, 30, 20, 10]
      
     

copy(): Crear una Copia Superficial de la Lista

El método copy() devuelve una copia superficial de la lista. Esto significa que se crea un nuevo objeto lista con los mismos elementos que la lista original. Modificar la copia no afectará a la original (y viceversa) para los elementos inmutables.

      
lista_original = [1, 2, [3, 4]]
lista_copia = lista_original.copy()

lista_copia[0] = 10
lista_copia[2][0] = 30

print(f"Lista original: {lista_original}")
# Output: Lista original: [1, 2, [30, 4]]
print(f"Lista copia: {lista_copia}")
# Output: Lista copia: [10, 2, [30, 4]]
      
     

Nota sobre copy(): Para copias profundas (donde los objetos anidados también se copian recursivamente), puedes usar la función deepcopy() del módulo copy.

Estos métodos proporcionan herramientas poderosas para trabajar de manera eficiente con las listas en Python. Conocerlos te permitirá escribir código más conciso y realizar operaciones complejas de manera sencilla.

---

Ir al indice