Creación de un Array Personalizado en Python

Curso de Estructuras de Datos Lineales con Python

Contenido del curso

Introducción a las estructuras de datos

Arrays

Linked lists

Stacks

Queues

Próximos pasos

23
Estructuras de Datos Lineales: Nodos y Arrays
01:51 min

Tomar examen

Creación de un Array Personalizado en Python

Resumen

¿Por qué crear nuestro propio array en Python?

Si bien Python nos ofrece un módulo de arrays, crear el nuestro nos da la oportunidad de entender realmente su funcionamiento interno. Al definir nuestros métodos, comprendemos mejor estructuras como la capacidad, representación en string, el manejo de índices y el reemplazo de elementos. Así que, ¡manos a la obra! Vamos a construir nuestro propio array desde cero.

¿Cómo definir la clase array?

Para comenzar, utilizamos un editor de texto como Visual Studio Code, y creamos un archivo llamado array.py. Dentro de este archivo, vamos a definir una clase Array que representará nuestro array. El corazón de esta clase está en el método constructor y los métodos que creamos para gestionarla.

class Array:
    def __init__(self, capacidad, fill_value=None):
        self.capacidad = capacidad
        self.fill_value = fill_value
        self.items = [fill_value] * capacidad

__init__: Define los atributos capacidad y fill_value, con este último predeterminado a None. Los elementos del array se guardarán en una lista vacía, que inicializaremos con el fill_value.

¿Cuáles son los métodos básicos a implementar?

¿Cómo obtener y representar el tamaño?

Un array necesita conocer su tamaño o longitud con facilidad. Para ello, empleamos un método privado que solo consulta su tamaño:

def _longitud(self):
    return len(self.items)

¿Cómo representar el array como un string?

Convertir el array a su representación de cadena es útil para visualizar sus elementos:

def __str__(self):
    return str(self.items)

¿Cómo crear un iterador para el array?

Un iterador nos permite recorrer la estructura fácilmente:

def __iter__(self):
    return iter(self.items)

Utilizamos iter() para que Python genere un iterador de nuestros elementos.

¿Cómo acceder y modificar elementos del array?

Para obtener un elemento específico, utilizamos un método que recibe el índice como argumento:

def getItem(self, index):
    return self.items[index]

Y para reemplazar un elemento:

def setItem(self, index, elemento):
    self.items[index] = elemento

Estos métodos son esenciales para gestionar el contenido de nuestro array.

¿Cómo probar nuestro array en Python?

Ahora que tenemos nuestra clase Array implementada, podemos probarla en la terminal de Python. Creamos una instancia de Array y comprobamos sus métodos:

from array import Array

# Crear instancia del array
menu = Array(5)

# Obtener longitud
print(len(menu))  # Output: 5

# Representación del array
print(menu)  # Output: [None, None, None, None, None]

# Iterar y modificar elementos
for i in range(len(menu)):
    menu.setItem(i, i + 1)

print(menu.getItem(0))  # Output: 1
print(menu.getItem(2))  # Output: 3

¿Cuál es el siguiente reto?

Ahora que has creado y manejado exitosamente un array, es momento de expandir tus habilidades. Te ánimo a desarrollar un método que reemplace los valores de los elementos por números aleatorios o consecutivos. Además, intenta implementar un método para sumar todos los elementos del array, independiente de que sean números o caracteres. Recuerda, recorrer el array es clave, y el uso del iterador puede facilitar esta tarea.

¡Continúa explorando y desafiando tus conocimientos! En la próxima fase, crearemos un array de dos dimensiones, llevando tu comprensión de estructuras de datos a otro nivel.

Alejandro Giraldo Londoño

Estudiante

Resumen: ■■■■■■■

Creando un array

Al crear el array por nosotros mismos podremos entender como es que funciona un arreglo y le podremos dar vida según nuestras necesidades. Los métodos que se crearán para el arreglo de ejemplo e incluyendo los métodos adicionales en el reto son:

Clase padre

Crearse
Longitud
Representación string
Pertenencia
índice
Reemplazo

Instancia de la clase Array

Estas funciones no sobre escriben métodos, heredan todas las funcionalidades de la clase padre, es decir, todos los métodos. Los aprovecharemos para crear lo métodos del challenge.

Randomizar
Sumar

Nota: Recuerda que en este script estamos hablando e módulos de python por lo que es buena idea tener tu archivo __init__.py para python trate los directorios que contienen archivos como paquetes. Este archivo puede estar vacío o inicializar código para todo el paquete. ¿Quieres saber más? consulta en: Modules

Clase Padre

class Array:
    def __init__(self, capacity, fill_value=None):
        """
        
        capacity = Será la capacidad que deseamos almacenar en el array.
        fill_value =None Existe para que por defecto nuestro array no tenga nada.


        """

        # CREACIÓN:
        # 1. Estos items se guardaran en una lista vacía, pero usaremos métodos propios.
        self.items = list()

        # 2. Llenaremos nuestra lista vacía con los valores:
 
	# generados según la capacidad deseada para el arreglo.
        # Se añade fill_value para darle esos espacios donde 
	# se almacenaran nuestros datos.
        # Es como hacer hoyos en la tierra donde plantar, 
	# aún no existe la planta, pero si el espacio que ocupará.

        for i in range(capacity):
            self.items.append(fill_value)

        
        # LONGITUD:
        # 1. Definimos método privado usando __len__,
	# usando dundders para que nadie acceda a este.
        # Me define la longitud del arreglo.

        def __len__(self):
            return len(self.items)


        # REPRESENTACIÓN STRING
        # 1. Representación en cadena de caracteres.
        # Parseo el items  a un str.

        def __str__(self):
            return str(self.items)

        # ITERADOR
        # Nos servirá para recorrer la estructura.
        # El método  iter me permitirá recorrer la estructura con su método interno next()

        def __iter__(self):
            return iter(self.items)

        # OBTENER ELEMENTO
        # Para obtener elemento necesito el elemento y el índice 
	# al cual llamo con la notación de []
        # Con el fin de saber su ubicación
        def __getitem__(self, index):
            return self.items[index]

        # REEMPLAZAR ELEMENTOS
        # Suscribimos elementos en el indice con el nuevo elemento.
        def __setitem__(self, index, new_item):
            self.items[index] = new_item




if __name__ == '__main__':
    arreglo = Array(3)
    # Ubicación en memoria
    print(arreglo) #<__main__.Array object at 0x0000020954591FA0>
    
    # Me retorna los espacios vacíos del array, los hoyos de para las plantas.
    print(arreglo.items) #[None, None, None]
    

    # Para llenar los datos debo usar .items o lista vacía,
    # para poder acceder a los elementos del arreglo.
    # Aquí evidencio como se llenan los datos.
    # [1, None, None]
    # [1, 2, None]
    # [1, 2, 3]
    for i in range(0, len(arreglo.items)):
        arreglo.items[i] = i + 1
        print(arreglo.items)
       


    # Usando los métodos que creamos para el arreglo.
    length = arreglo.items.__len__()
    print("El arreglo tiene como largo : "+ str(length))

    # Retorno un str
    strings = arreglo.items.__str__()
    print(type(strings))

    # Creo un Objeto lista iterador y lo recorro con next
    iterador = arreglo.items.__iter__()
    print(iterador)
    print(next(iterador))
   
    # Consigo el elemnto en la posición 1
    consigo_elemento = arreglo.items.__getitem__(1)
    print(consigo_elemento)

    # Ingreso un elemento específicado.
    arreglo.items.__setitem__(1,"Arreglo terminado!")
    print(arreglo.items)

Instancia del padre

'''
1. Crear un array 
2. Incorporar un método para poblar sus slots con números aleatorios o secuenciales
3. Incluye un método que sume todos lo valores del array.

'''
from arrays_custom import Array
import random as r



class Array_challenge(Array):

    def __random_sequential__(self,randomize=False, sequential=False):
        self.randomize = randomize
        self.sequential = sequential
        

        # Busco el largo para tener un límite claro.
        # Si el parámetro randomize es True entonces
        # Creo números aleatorios usando l como número base
        # Uso setitems para insertar elementos por cada elemento
        l = self.items.__len__()
        if randomize:
            for index in range(0,l):
                number = r.randrange(l**l)
                self.items.__setitem__(index, number)

        if sequential:
            # Aquí se puede optimizar para un algoritmo de 
	    # ordenamiento más efectivo, en función del tamaño del arreglo
	    # Ver por ejemplo MergeSort.
            self.items = sorted(self.items)

        return self.items

    def __sum_array__(self):
        return sum(self.items)

if __name__ == '__main__':
    solution = Array_challenge(3)
    print("""Solución:

    1. Creo números aleatorios y/u ordenados dependiendo de los dos parámetros (True)
    Así obtengo números aleatorios, o números aleatorios y ordenados secuencialmente.

    2. Retorno la suma de os valores aleatorios.
    """)

    print("1: ", solution.__random_sequential__(True,True))
    print("2: ", solution.__sum_array__())

David Pedroza Segoviano

Alejandro Vargas

Juan Pablo Alvarez Ovalle

Mario Andrés Castro Martínez

Pedro Alvarado Garcia

Mario Restrepo

Juan Pablo Leyva

Sebastian Penagos

Diego Perozo

Daniel Eduardo Duran

Nahuel Seoane

Javier Manobanda

Julian Camilo Hermida Delgado

Saúl Mendoza

Juan Pablo Pérez Durán

Carlos Guillermo Coello Valenzuela

Omar Daniel Centeno

Camilo Jaramillo

Claudio Jesus Vázquez Villanueva

Ricardo Rito Anguiano

Leslie Paz Ore

DAVID STEVEN BOCAREJO IBAÑEZ

Héctor Daniel Vega Quiñones

Profesor

David Campos

Armando José Arenas Sánchez

Jhon Freddy Tavera Blandon

Erick Carrillo

Jared Arturo Olmos Villagran

Mauricio Gonzalez Falcon

Oscar Eduardo Barrios Blanco

Creación de un Array Personalizado en Python

Introducción a las estructuras de datos

Estructuras de Datos Lineales con Python: Arrays, Listas y Pilas

Estructuras de Datos y Colecciones en Python

Tipos y Estructuras de Colecciones de Datos en Programación

Operaciones esenciales en colecciones de Python

Colecciones en Python: Listas, Tuplas, Conjuntos y Diccionarios

Arrays

Arrays: Estructuras de Datos Lineales y sus Aplicaciones