Guía completa de arrays en Python | Diferencias y uso de listas, tuplas y NumPy

1. Introducción

Python es un lenguaje de programación con una sintaxis simple e intuitiva que se utiliza en muchos campos. Entre ellos, el «arreglo» juega un papel importante en la gestión y manipulación de datos.

Sin embargo, en Python no existe un «tipo de arreglo» como en C, en su lugar se utilizan estructuras de datos como listas (List) · tuplas (Tuple) · arreglos de NumPy (ndarray), etc. Cada una de estas estructuras de datos tiene características y usos diferentes, por lo que es importante seleccionar la adecuada.

¿Qué son los arreglos en Python?

• Lista (List): Estructura de datos mutable (modificable) y altamente flexible
• Tupla (Tuple): Inmutable (no modificable) y con alta velocidad de procesamiento
• Arreglo de NumPy (ndarray): Tipo de arreglo especializado en cálculos numéricos y análisis de datos

En este artículo, realizaremos una guía completa de los arreglos en Python, desde los fundamentos hasta las aplicaciones. Para que sea fácil de entender para principiantes, explicaremos intercalando ejemplos de código específicos.

2. ¿Qué son los arrays en Python? (Lista, Tupla, NumPy)

En Python, el tipo de datos llamado «array (Array)» no se proporciona de forma estándar. Por lo tanto, en general, se utiliza lista (List) para manejar datos como si fueran arrays.

Además, para manejar datos inmutables se utiliza tupla (Tuple), y para realizar operaciones numéricas de manera eficiente se utiliza ndarray de NumPy.

Estructuras de datos utilizadas como arrays en Python

Uso básico de listas, tuplas y arrays de NumPy

En Python, se pueden crear listas, tuplas y arrays de NumPy de la siguiente manera.

import numpy as np

# Creación de lista
my_list = [1, 2, 3, 4, 5]

# Creación de tupla
my_tuple = (1, 2, 3, 4, 5)

# Creación de array de NumPy
my_array = np.array([1, 2, 3, 4, 5])

print(my_list)   # [1, 2, 3, 4, 5]
print(my_tuple)  # (1, 2, 3, 4, 5)
print(my_array)  # [1 2 3 4 5]

Diferencias entre listas, tuplas y arrays de NumPy

3. Entender las listas (List) de Python

Las listas (List) de Python son una estructura de datos similar a un array de longitud variable (modificable). Al usar listas, se pueden almacenar tipos de datos diferentes, como números o cadenas, en una sola estructura de datos. Las listas son una de las estructuras de datos más básicas y comúnmente usadas en Python.

Lo básico de las listas

Cómo crear listas

En Python, las listas se crean usando corchetes [].

# Crear una lista vacía
empty_list = []

# Lista que contiene números
numbers = [1, 2, 3, 4, 5]

# Lista que contiene cadenas
fruits = ["apple", "banana", "cherry"]

# También es posible mezclar tipos de datos diferentes
mixed_list = [1, "hello", 3.14, True]

print(numbers)      # [1, 2, 3, 4, 5]
print(fruits)       # ['apple', 'banana', 'cherry']
print(mixed_list)   # [1, 'hello', 3.14, True]

Acceder a los elementos de la lista

Se puede acceder a cada elemento de la lista usando un índice (subíndice). Los índices de Python comienzan desde 0, y es posible acceder desde el final usando índices negativos.

fruits = ["apple", "banana", "cherry"]

# Obtener un elemento especificando el índice
print(fruits[0])   # apple
print(fruits[1])   # banana

# Usar índice negativo (acceder desde el final)
print(fruits[-1])  # cherry
print(fruits[-2])  # banana

Las rebanadas (slicing) de la lista (obtención parcial)

Usando rebanadas (slice), se puede obtener una parte de la lista.

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Obtener los primeros 5 elementos
print(numbers[:5])  # [0, 1, 2, 3, 4]

# Obtener elementos desde el 3º hasta el 7º
print(numbers[2:7])  # [2, 3, 4, 5, 6]

# Obtener los últimos 3 elementos
print(numbers[-3:])  # [7, 8, 9]

# Obtener elementos saltando de 2 en 2
print(numbers[::2])  # [0, 2, 4, 6, 8]

Cambiar elementos de la lista

Las listas son mutables (modificables), por lo que se pueden cambiar los elementos.

fruits = ["apple", "banana", "cherry"]

# Cambiar el segundo elemento
fruits[1] = "orange"
print(fruits)  # ['apple', 'orange', 'cherry']

Agregar y eliminar de la lista

Agregar elementos

En las listas de Python, se pueden agregar elementos usando append() o insert().

fruits = ["apple", "banana"]

# Agregar un elemento al final de la lista
fruits.append("cherry")
print(fruits)  # ['apple', 'banana', 'cherry']

# Agregar un elemento en una posición especificada
fruits.insert(1, "orange")
print(fruits)  # ['apple', 'orange', 'banana', 'cherry']

Eliminar elementos

Para eliminar elementos de la lista, se usa remove() o pop().

fruits = ["apple", "banana", "cherry"]

# Eliminar el elemento con el valor especificado
fruits.remove("banana")
print(fruits)  # ['apple', 'cherry']

# Eliminar el elemento en el índice especificado
fruits.pop(1)
print(fruits)  # ['apple']

Concatenación y copia de listas

Concatenación de listas

Se pueden concatenar listas usando el operador +.

list1 = [1, 2, 3]
list2 = [4, 5, 6]

combined_list = list1 + list2
print(combined_list)  # [1, 2, 3, 4, 5, 6]

Copia de listas

Al copiar una lista, es seguro usar la rebanada [:].

original_list = [1, 2, 3]
copied_list = original_list[:]

print(copied_list)  # [1, 2, 3]

Resumen

• Las listas son estructuras de datos de longitud variable, y es posible agregar, eliminar y cambiar elementos
• Acceder a los elementos usando índices o rebanadas
• Aprendimos métodos eficientes para operar con listas (agregar, eliminar, concatenar, ordenar, etc.)

4. Entender las tuplas (Tuple) en Python

Las tuplas (Tuple) en Python son una estructura de datos que puede almacenar múltiples valores, similar a las listas, pero tienen la característica de ser inmutables (immutable).
Es decir, una vez creada una tupla, sus elementos no se pueden modificar, agregar ni eliminar.

Gracias a esta característica, las tuplas se utilizan en situaciones donde es necesario garantizar la inmutabilidad de los datos. Además, tienen la ventaja de ser más eficientes en memoria y más rápidas en procesamiento que las listas.

Conceptos básicos de las tuplas

Cómo crear tuplas

Las tuplas se crean utilizando paréntesis ().

# Creación de tuplas
fruits = ("apple", "banana", "cherry")
numbers = (1, 2, 3, 4, 5)

print(fruits)   # ('apple', 'banana', 'cherry')
print(numbers)  # (1, 2, 3, 4, 5)

Cómo crear una tupla con un solo elemento

Al crear una tupla, si hay solo un elemento, se necesita precaución.
Si no se agrega una coma ,, se tratará como un simple número o cadena.

single_value = (42)      # No es una tupla, es un entero
correct_tuple = (42,)    # Esta es una tupla

print(type(single_value))  # <class 'int'="">
print(type(correct_tuple))  # <class 'tuple'="">

Acceder a los elementos de una tupla

Se puede acceder a cada elemento de la tupla usando índices (subíndices). Al igual que en las listas, los índices en Python comienzan desde 0.

colors = ("red", "green", "blue")

# Acceso especificando índice
print(colors[0])  # red
print(colors[1])  # green

# Usar índice negativo
print(colors[-1])  # blue
print(colors[-2])  # green

Rebanado (slicing) de tuplas (obtención parcial)

Las tuplas también pueden realizar rebanado (slicing) (obtención parcial) al igual que las listas.

numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

# Obtener los primeros 5 elementos
print(numbers[:5])  # (0, 1, 2, 3, 4)

Conversión entre tuplas y listas

Las tuplas y listas se pueden convertir mutuamente usando tuple() o list().

# Lista → Tupla
numbers_list = [1, 2, 3]
numbers_tuple = tuple(numbers_list)
print(numbers_tuple)  # (1, 2, 3)

# Tupla → Lista
fruits_tuple = ("apple", "banana", "cherry")
fruits_list = list(fruits_tuple)
print(fruits_list)  # ['apple', 'banana', 'cherry']

Resumen

• Las tuplas son inmutables (immutable) y no se pueden modificar después de su creación
• Son más eficientes en memoria y más rápidas en procesamiento que las listas
• Se utilizan en situaciones que garantizan la inmutabilidad de los datos (constantes, claves de diccionarios, valores de retorno de funciones, etc.)
• Es posible la conversión mutua con listas, pero si hay posibilidad de modificación, se debe usar listas

5. 【Tabla de comparación】Lista vs Tupla – ¿Cuál usar?

En Python, tanto la lista (List) como la tupla (Tuple) se pueden usar como arrays. Sin embargo, hay diferencias importantes entre ellas, y es importante distinguir su uso adecuadamente.

Diferencias entre lista y tupla

Primero, organizamos las diferencias principales entre lista y tupla en una tabla de comparación.

Distinción de uso entre lista y tupla

✅ Casos en los que usar lista

1. Cuando sea necesario cambiar los datos

users = ["Alice", "Bob", "Charlie"]
users.append("David")  # Agregar un nuevo usuario
print(users)  # ['Alice', 'Bob', 'Charlie', 'David']

1. Cuando se manejen datos de longitud variable

user_input = []
while True:
    data = input("Ingrese datos (salir: exit):")
    if data == "exit":
        break
    user_input.append(data)
print(user_input)

✅ Casos en los que usar tupla

1. Datos que no deben cambiarse

weekdays = ("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday")

1. Cuando se use como clave de diccionario

location_data = {
    (35.6895, 139.6917): "Tokyo",
    (40.7128, -74.0060): "New York"
}
print(location_data[(35.6895, 139.6917)])  # Tokyo

Resumen

• La lista es mutable y permite agregar, eliminar y cambiar datos en la estructura de datos.
• La tupla es inmutable y se utiliza para datos que no necesitan cambiarse o como clave de diccionario.
• Para manejar datos dinámicos, la lista es más adecuada.

6. Aplicaciones de la manipulación de arrays

Al dominar las listas (List) y tuplas (Tuple) de Python, se pueden realizar procesamientos de datos más avanzados. En esta sección, se introducen técnicas avanzadas de manipulación de arrays para que se puedan utilizar en programas prácticos.

Notación de comprensión de listas (Generación eficiente de listas)

# Generación normal de listas
squares = []
for x in range(10):
    squares.append(x**2)
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Notación de comprensión de listas
squares = [x**2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Manejo de listas multidimensionales

# Crear una matriz de 3x3
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print(matrix[0])  # [1, 2, 3]
print(matrix[1][2])  # 6

Conversión mutua entre listas y diccionarios

# Convertir dos listas en un diccionario
keys = ["name", "age", "city"]
values = ["Alice", 25, "Tokyo"]
person_dict = dict(zip(keys, values))
print(person_dict)  # {'name': 'Alice', 'age': 25, 'city': 'Tokyo'}

Ordenación de listas y operaciones aleatorias

import random

numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)
print(numbers)  # Ejemplo: [3, 1, 5, 2, 4]

random_choice = random.choice(numbers)
print(random_choice)  # Ejemplo: 2

Resumen

• Al utilizar la notación de comprensión de listas, se pueden crear listas de manera eficiente.
• Se pueden manejar datos de matrices o tablas utilizando listas multidimensionales.
• Al convertir mutuamente listas y diccionarios, se puede gestionar los datos de forma flexible.
• Al utilizar la reordenación de listas y el procesamiento aleatorio, se pueden realizar procesamientos de datos avanzados.

7. Preguntas frecuentes (FAQ)

Las listas y tuplas de Python son estructuras de datos muy convenientes, pero puede que haya muchas dudas sobre su uso .
En esta sección, explicamos las preguntas frecuentes sobre listas y tuplas en Python en formato de Q&A.

Q1: ¿Cuál es la diferencia entre listas y tuplas?

A: Las listas son mutables (modificables), las tuplas son inmutables (no modificables) ese es el mayor diferencia.

# Lista (modificable)
my_list = [1, 2, 3]
my_list[0] = 100  # Modificable
print(my_list)  # [100, 2, 3]

# Tupla (no modificable)
my_tuple = (1, 2, 3)
my_tuple[0] = 100  # TypeError: 'tuple' object does not support item assignment

Q2: ¿Cuál es el método correcto para copiar una lista?

A: copy() o el slice [:] son seguros de usar.

# Usar slice
list_a = [1, 2, 3]
list_b = list_a[:]
list_b[0] = 100
print(list_a)  # [1, 2, 3] ← ¡La lista original no cambia!

Q3: ¿Qué es la notación de comprensión de listas?

# Generación normal de listas
squares = []
for x in range(10):
    squares.append(x**2)

# ✅ Usar notación de comprensión de listas permite escribirlo de manera concisa
squares = [x**2 for x in range(10)]

Q4: ¿Cómo convertir una lista a formato JSON en Python?

import json

data = [1, 2, 3, 4, 5]
json_data = json.dumps(data)
print(json_data)  # "[1, 2, 3, 4, 5]"

Q5: ¿Cómo barajar aleatoriamente los elementos de una lista?

import random

numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)
print(numbers)  # Ejemplo: [3, 1, 5, 2, 4]

Q6: ¿Cuál es la diferencia entre arrays de NumPy y listas?

import numpy as np

arr = np.array([1, 2, 3, 4, 5])
print(arr * 2)  # [2 4 6 8 10]

Resumen

En esta sección de FAQ, hemos explicado las dudas comunes sobre listas y tuplas en Python y sus soluciones .

• Diferencia entre listas y tuplas → Diferencia en la mutabilidad
• Copia de listas → Usar copy() o slice [:]
• Notación de comprensión de listas → Más concisa que bucles for
• Conversión de listas a JSON → Usar json.dumps() / json.loads()
• Diferencia entre arrays de NumPy y listas → NumPy es rápido y orientado a cálculos numéricos

8. Resumen

En este artículo, hemos explicado en detalle desde los fundamentos hasta las aplicaciones de los arrays (listas, tuplas, arrays de NumPy) en Python.

Lo aprendido en este artículo

✅ ¿Qué son los arrays en Python?

• En Python no existe un «tipo de array» como en C
• En su lugar, se utilizan «listas (List)», «tuplas (Tuple)» y «arrays de NumPy (ndarray)»

✅ Las listas en Python

• Estructura de datos de longitud variable (modificable)
• Es posible agregar, eliminar y modificar elementos

✅ Las tuplas en Python

• Estructura de datos inmutable (no modificable)
• Puede usarse como clave de diccionario
• Velocidad de procesamiento rápida y bajo uso de memoria

✅ Comparación entre listas y tuplas

Enlaces de referencia para aprender más

📘 Documentación oficial de Python

• Listas (List)
• Tuplas (Tuple)
• Documentación oficial de NumPy

Finalmente

Al entender los arrays de Python (listas, tuplas, NumPy) y saber cómo usarlos adecuadamente, la gestión y el procesamiento de datos se volverán más simples y eficientes.

¡Por favor, prueba escribiendo código real!