No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Crear un array

7/23
Recursos

Aportes 128

Preguntas 17

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Mmmmmmmmmmmmmmmmmmmmhhhh me quedó un mal sabor de boca de esta clase, no sé si lo explicará en alguna clase posterior o no, pero en realidad los métodos que escribimos con doble guion bajo, son precisamente para poder utilizar cosas como:

menu[1]
len(menu)
print(menu)

Por ejemplo, si no tuviéramos el método __getitem__ en nuestra clase, no deberíamos de ser capaces de hacer print(menu[2]), pero siento que el profe lo está haciendo ver como que son dos cosas distintas, como si Python por default tuviera este comportamiento: len(menu) y es diferente a cuando nosotros hacemos menu.__len__(), PERO PARECE SER QUE NO LO ES! No son diferentes, siento que es syntactic sugar, solamente para built in methods en clases en Python.

Por ejemplo, miren, escriban el siguiente método:

def __len__(self):
	print('hola')
	return 7	

y manden a llamar len(menu) y van a ver que imprime ‘hola’ y siempre regresa ese valor 7, no importa de qué tamaño sea el array…
Tonses pues ya, eso era lo que quería decir, muchas tardes, buenas gracias.

Solucion al reto:
Clase Array:

Programa principal

para los que les de error al importar: from array import Array
intentar cambiar el nombre del archivo array y la clases Array,
con eso funcionó para mi

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__())



Solución al reto

import random
from functools import reduce


class Array:
    def __init__(self, capacity, fill_value=None):
        self.items = list()

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

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

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

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

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

    def __setitem__(self, index, new_item):
        self.items[index] = new_item

    def __addRandomItems__(self, lower, upper):
        self.items = [random.randint(lower, upper)
                      for i in range(len(self.items))]

    def __sumItems__(self):
        return reduce(lambda a, b: a+b, self.items)


if __name__ == "__main__":
    menu = Array(5)
    print(menu)
    menu.__addRandomItems__(1, 5)
    print(menu)
    print(menu.__sumItems__())

Solución al reto aplicando también lo aprendido en el curso de Python Intermedio:

from random import randint
from functools import reduce


# Reto 1
class Array:
    def __init__(self, capacity, fill_value=None):
        self.capacity = capacity
        self.items = [fill_value for i in range(self.capacity)]


    # Reto 2
    def __random_fill__(self):
        self.aleatorios = [randint(0, 100) for i in range(self.capacity)]
        
        for i in range(self.capacity):
            self.items[i] = self.aleatorios[i]
        return self.items


    # Reto 3
    def __summation__(self):
        all_sum = reduce(lambda a, b: a + b, self.items)
        return all_sum


if __name__ == '__main__':
    menu = Array(10)
    print(menu.__random_fill__())
    print(menu.__summation__())

Mi solución al reto:

Agregando métodos al Array

.
Mi solución al reto fue utilizando el método __next__() el cual ayuda a recorrer los valores del elemento iterador.

    def __next__(self):
        """Replace and return the values of the array with a random number using __next__"""
        if self.n <= self.__len__() - 1:
            self.__setitem__(self.n, randint(1, 100))
            self.n += 1
            return self.items
        else:
            raise StopIteration

    def sum(self):
        """Return the sum of the elements inside the array"""
        self.suma = sum([x for x in self.items])
        return self.suma

Para sumar los elementos ya no me compliqué tanto y utilicé la built in function sum :smile

Por si ustedes también se preguntan, porque la implementación con dunder method.

  • len : Nos da la capacidad de saber la longitud del array.

  • str : Nos permite visualizar el objeto de una forma mas amigable.

  • iter: Nos permite recorrer los elementos, sin él no se permitiría la indexación.

  • setitem: Nos permite asignar un item, sin el no podríamos asignar un valor, ni con notación menu[2] =100

  • getitem: Nos permite obtener un elemento por índice, sin este no podríamos visualizar los elementos, ni con notación menu[2], nótese que sin el iterador esto tampoco es posible.

¡Métodos Mágicos!

IMPORTANTE

Al terminar el reto, como minimo deben tener los siguientes metodos en su clase array, ya que en la siguiente clase seran necesarios.

class Array(object):
    "Represents an array."

    def __init__(self, capacity, fill_value = None):
        """
        Args:
            capacity (int): static size of the array.
            fill_value (any, optional): value at each position. Defaults to None.
        """
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)

    def __len__(self):
        """Returns capacity of the array."""
        return len(self.items)

    def __str__(self):
        """Returns string representation of the array"""
        return str(self.items)

    def __iter__(self):
        """Supports traversal with a for loop."""
        return iter(self.items)

    def __getitem__(self, index):
        """Subscrit operator for access at index."""
        return self.items[index]

    def __setitem__(self, index, new_item):
        """Subscript operator for replacement at index."""
        self.items[index] = new_item

A diferencia de otros lenguajes de programación, en Python el Array y ArrayList forman una sola estructura llamada Lista.

https://www.youtube.com/watch?v=zg9ih6SVACc&t=8152s

import random

class MiArray:
    def __init__(self, size):
        self.size = size
        self.slots = []

    def poblar_aleatorio(self, limite):
        self.slots = [random.randint(0, limite) for _ in range(self.size)]

    def poblar_secuencial(self):
        self.slots = [i+1 for i in range(self.size)]

    def sumar_valores(self):
        return sum(self.slots)

#En este ejemplo, la clase MiArray tiene tres métodos principales:

#El método __init__ se utiliza para inicializar la instancia de la clase y toma un parámetro 
# size, que representa el tamaño del array.

#El método poblar_aleatorio se encarga de poblar los slots del array con números aleatorios. 
# Toma un parámetro limite, que establece el rango máximo de los números aleatorios generados.

#El método poblar_secuencial se utiliza para poblar los slots del array con números secuenciales, 
# desde 1 hasta el tamaño del array.

# El método sumar_valores calcula la suma de todos los valores presentes en el array y devuelve 
# el resultado.

# Aquí hay un ejemplo de cómo utilizar la clase MiArray:

# Crear una instancia de la clase MiArray
mi_array = MiArray(5)

# Poblar los slots del array con números aleatorios
mi_array.poblar_aleatorio(100)

# Imprimir el array
print(mi_array.slots)

# Sumar los valores del array
suma = mi_array.sumar_valores()
print("Suma:", suma)

Solución al reto de arrays

import random


class array:
    def __init__(self,capacity,fill_value = None):
        self.capacity = capacity
        self.items =list()
        for i in range(capacity):
            self.items.append(fill_value)

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

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

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

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

    def __setitem__(self,index,new_item):
        self.items[index] = new_item

    def __randomnumbers__(self):
        for i in range(self.capacity):
            self.__setitem__(i,random.randint(0,9))
        return self.items

    def __sumelements__(self):
        count = 0 
        for i in range(self.capacity):
            count += self.items[i]
        return count



if __name__ == '__main__':
    menu = array(5)
    menu.__setitem__(0,5)
    print(menu.__str__())
    print(menu.__randomnumbers__())
    print(menu.__sumelements__())


def __fill__(self):
	for i in range(self.capacity):
		self.items[i] = int(random.randint(0, self.capacity))

def __sum__(self):
	suma = 0
	for i in self.items:
		suma = suma + i
	return suma

Hice correcciones con el código de Mario Castro.

from random import randint
from functools import reduce

class Array:

    def __init__(self, capacity, fill_value=None):
        self.capacity = capacity
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)

    def __randreplace__(self, lower_random, upper_random) -> list:
        """
        Set a random int value in range[lower_random, upper_random] and return new list.
        """
        return [self.__setitem__(i, randint(lower_random, upper_random)) for i in range(self.__len__())]
        
    def __len__(self):
        return len(self.items)

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

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

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

    def __setitem__(self, index, new_item):
        self.items[index] = new_item

    def __sumelements__(self):
        return reduce(lambda a, b: a + b, self.items)

```python import random class Array: def __init__(self, capacity, fill_value=None): self.items = list() self.capacity = capacity for i in range(capacity): self.items.append(fill_value) def __len__(self): return len(self.items) def __repr__(self): length = self.__len__() blanks = ' ' result = f"<Array({self.capacity}) {hex(id(self))} >" result = f"{result}\n[" for d in self.items: result = f"{result}\n{blanks}{d}," result = f"{result}\n]" return result def __str__(self): return str(self.items) def __iter__(self): return iter(self.items) def __getitem__(self, index): return self.items[index] def __setitem__(self, index, new_item): self.items[index] = new_item def fill_random(self, min, max, function_random=random.randint): for i in range(self.capacity): self.items[i] = function_random(min, max) def fill(self, value=None): for i in range(self.capacity): self.items[i] = value def join(self, separator=' '): result = self.items[0] for item in self.items[1:]: result = f"{result}{separator}{item}" return result def sum(self): result = 0 for item in self.items: result = result + item return result def reduce(self, func, init_val=0): for index in range(0, self.capacity): init_val = func(init_val, self.items[index], index) return init_val collection = Array(10) collection.fill_random(0, 10) collection.fill() collection.fill(10) collection.sum() collection.join('\n') collection.reduce(lambda cont, curr, idx: cont+(curr*idx)) ```
```python import random class Array2: def __init__(self, capacity, fill_value=None): self.items = list() for i in range(capacity): self.items.append(fill_value) def __len__(self): return len(self.items) def __str__(self): return str(self.items) def __iter__(self): return iter(self.items) def __getitem__(self, index): return self.items[index] def __setitem__(self, index, new_item): self.items[index] = new_item def __setrandom__(self): for idx in range(self.__len__()): self.__setitem__(idx, random.randint(0, self.__len__())) def __setseq__(self): for idx in range(self.__len__()): self.__setitem__(idx, idx) def __sum__(self): if all(isinstance(i, int) for i in self.items): return sum(self.items) elif all(isinstance(i, float) for i in self.items): return sum(self.items) else: raise TypeError("No se puede sumar valor no numéricos") ```Mi aporte del Reto
![](https://static.platzi.com/media/user_upload/%7B11D0F255-4956-4798-8192-629F27E8D3DD%7D-502fd3fd-215f-4489-ab84-539e05593003.jpg)
```js import random class Array: def __init__(self, capacity, min_value=0, max_value=100): """ Inicializa el array con números aleatorios entre min_value y max_value. """ self.items = [random.randint(min_value, max_value) for _ in range(capacity)] def __len__(self): return len(self.items) def __str__(self): return str(self.items) def __getitem__(self, index): return self.items[index] def __setitem__(self, index, new_item): self.items[index] = new_item def es_par(self, index): """ Verifica si el número en el índice dado es par. """ if index < 0 or index >= len(self.items): raise IndexError("Índice fuera de rango.") return self.items[index] % 2 == 0 def es_impar(self, index): """ Verifica si el número en el índice dado es impar. """ return not self.es_par(index) # Crear un array de 10 números aleatorios entre 1 y 50 mi_array = Array(10, 1, 50) # Imprimir el array print("Array generado:", mi_array) # Verificar si cada número es par o impar for i in range(len(mi_array)): numero = mi_array[i] if mi_array.es_par(i): print(f"El número {numero} en la posición {i} es PAR.") else: print(f"El número {numero} en la posición {i} es IMPAR.") ```import random class Array:    def \_\_init\_\_(self, capacity, min\_value=0, max\_value=100):        """        Inicializa el array con números aleatorios entre min\_value y max\_value.        """        self.items = \[random.randint(min\_value, max\_value) for \_ in range(capacity)]     def \_\_len\_\_(self):        return len(self.items)     def \_\_str\_\_(self):        return str(self.items)     def \_\_getitem\_\_(self, index):        return self.items\[index]     def \_\_setitem\_\_(self, index, new\_item):        self.items\[index] = new\_item     def es\_par(self, index):        """        Verifica si el número en el índice dado es par.        """        if index < 0 or index >= len(self.items):            raise IndexError("Índice fuera de rango.")        return self.items\[index] % 2 == 0     def es\_impar(self, index):        """        Verifica si el número en el índice dado es impar.        """        return not self.es\_par(index) \# Crear un array de 10 números aleatorios entre 1 y 50mi\_array = Array(10, 1, 50) \# Imprimir el arrayprint("Array generado:", mi\_array) \# Verificar si cada número es par o imparfor i in range(len(mi\_array)):    numero = mi\_array\[i]    if mi\_array.es\_par(i):        print(f"El número {numero} en la posición {i} es PAR.")    else:        print(f"El número {numero} en la posición {i} es IMPAR.")
```js Modulo Array - Array.length - Array.push(elemento) - Array.pop() - Array.shift() - Array.unshift() - Array.indexOf(elemento) - Array.lastIndexOf(elemento) - Array.splice(inicio, cantidad, elemento) ```
**Reto 1:** ```python import random class Array: def __init__(self, capacity, fill_value=None): self.items = list() for _ in range(capacity): self.items.append(fill_value) def __len__(self): return len(self.items) def __str__(self): return str(self.items) def __iter__(self): return iter(self.items) def __getitem__(self, index): return self.items[index] def __setitem__(self, index, new_item): self.items[index] = new_item def __slots__(self): for i in range(self.__len__()): self.items[i] = random.randint(0, 100) def __sum__(self): suma = 0 for i in range(self.__len__()): suma += self.items[i] ```import random class Array:     def \_\_init\_\_(self, capacity, fill\_value=None):        self.items = list()        for \_ in range(capacity):            self.items.append(fill\_value)     def \_\_len\_\_(self):        return len(self.items)     def \_\_str\_\_(self):        return str(self.items)     def \_\_iter\_\_(self):        return iter(self.items)     def \_\_getitem\_\_(self, index):        return self.items\[index]     def \_\_setitem\_\_(self, index, new\_item):        self.items\[index] = new\_item     def \_\_slots\_\_(self):        for i in range(self.\_\_len\_\_()):            self.items\[i] = random.randint(0, 100)                def \_\_sum\_\_(self):        suma = 0                for i in range(self.\_\_len\_\_()):            suma += self.items\[i]
Se logro!!i ```js import random class Array: def __init__(self, capacidad, item = None): self.items = list() for i in range(capacidad): self.items.append(item) def __len__(self): return len(self.items) def __str__(self): return str(self.items) def __iter__ (self): return iter(self.items) def __getitem__(self, index): return self.items[index] def __setitem__(self, index, value): self.items[index] = value return self.items def __replace_item__(self): value = input("¿Como prefieres remplazar tus valores? Aleatorios -> A o Secuenciales -> S: ") value = value.upper() while value != "A" and value != "S": value = input("\nLos valores que me diste no son correctos; A para Aleatorios o S para Secuenciales: ") value = value.upper() if value == "A": for i in range(self.__len__()): self.items[i] = random.randint(1,100) return self.items elif value == "S": valor = 1 for i in range(self.__len__()): self.items[i] = valor valor += 1 return self.items def __sum_items__(self): iterator = self.__iter__() primer_v = next(iterator) if isinstance(primer_v,int): for elemento in iterator: primer_v += elemento return primer_v elif isinstance(primer_v,str): for elemento in iterator: primer_v += elemento return primer_v else: raise ValueError ("Todos los elementos deben ser del mismo tipo para ser sumados. ") array = Array(5) print(array.__len__()) print(array.__str__()) print(array.__getitem__(4)) print(array.__setitem__(3,"a")) print(array.__replace_item__()) print(array.__sum_items__()) iterador = array.__iter__() array[0] = "H" array[1] = "o" array[2] = "l" array[3] = "a" array[4] = "a" print(array.__str__()) print(array.__sum_items__()) ```
Debe haber un paso, de cierta importancia que omiten
copié el código línea por línea y no jaló
Alguien sabe qué versión de Python usan el maestro del curso¿? Por favor
Metodos: ```js def __replace__(self): # premplaza todos los valores del array por un rango aleatorio del (1-100). for i in range(len(self)): self.items[i] = random.randrange(0, 100) def __sumatoria__(self): # suma todas los elementos del array total = 0 for i in range(len(self)): total = total + self.items[i] return total ```
Reto de la clase completado 🏆🥳 ![](https://static.platzi.com/media/user_upload/image-8ad9aea9-39c5-475f-9a40-fca9e9909ee6.jpg)El output del código: ![](https://static.platzi.com/media/user_upload/image-4224f962-8ba7-4e1e-9417-c4c25f40207c.jpg)
en la terminal, hice un list comprehension al array... ```js menu = [(i+3)**2 for i in range(len(menu))] ```Pero, al hacer esto estoy conviertiendo al array a una lista... Raro pero funciona xd
Buen día, estimados. A continuación escribo mi solución. Creo que es algo básico, pero se ajusta a lo solicitado por el profesor. ```js import random class Array: def __init__(self,capacity,full_value=None): #super().__init__() self.items=list() # o self.items=[] for i in range(capacity): self.items.append(full_value) def __getitem__(self,index): return self.items[index] def __len__(self): return len(self.items) def __str__(self): return str(self.items) def __iter__(self): return iter(self.items) def __setitem__(self,index,value): self.items[index]=value def __fill_dinamic__(self): for i in range(len(self.items)): self.items[i]=random.randint(1,100) def __sum__(self): sum=0 for option in iter(self.items): sum +=option return sum ```import randomclass Array:    def \_\_init\_\_(self,capacity,full\_value=None):        #super().\_\_init\_\_()        self.items=list() # o self.items=\[]        for i in range(capacity):            self.items.append(full\_value)     def \_\_getitem\_\_(self,index):        return self.items\[index]        def \_\_len\_\_(self):        return len(self.items)        def \_\_str\_\_(self):        return str(self.items)        def \_\_iter\_\_(self):        return iter(self.items)        def \_\_setitem\_\_(self,index,value):        self.items\[index]=value     def \_\_fill\_dinamic\_\_(self):        for i in range(len(self.items)):            self.items\[i]=random.randint(1,100)     def \_\_sum\_\_(self):        sum=0        for option in iter(self.items):            sum +=option         return sum

en una lista los elementos se pueden repetir pero sus indices no asi que realice mi propia clase de lista sin usar ningun metodo de las listas sino creando todo desde 0, el resultado

```python import random from functools import reduce class Array: """ Implementación de un array con funcionalidades adicionales. Esta clase permite crear un array con una capacidad determinada y opcionalmente llenarlo con un valor predeterminado. Además de las operaciones básicas de un array, como la obtención y configuración de elementos, esta clase ofrece funcionalidades adicionales como la generación de valores aleatorios y el cálculo de la suma de los elementos. Args: capacity (int): Capacidad deseada para el array. fill_value (opcional): Valor con el que se llenará inicialmente el array. Por defecto es None. Attributes: capacity (int): Capacidad del array. items (list): Lista que almacena los elementos del array. """ def __init__(self, capacity, fill_value=None): """ Inicializa un nuevo array con la capacidad especificada. Args: capacity (int): Capacidad deseada para el array. fill_value (opcional): Valor con el que se llenará inicialmente el array. Por defecto es None. """ self.capacity = capacity self.items = list() for i in range(capacity): self.items.append(fill_value) def __len__(self): """ Devuelve la longitud del array. Returns: int: Longitud del array. """ return len(self.items) def __str__(self): """ Devuelve una representación en cadena del array. Returns: str: Representación en cadena del array. """ return str(self.items) def __iter__(self): """ Devuelve un iterador sobre los elementos del array. Returns: iterador: Iterador sobre los elementos del array. """ return iter(self.items) def __getitem__(self, index): """ Devuelve el elemento en la posición especificada del array. Args: index (int): Índice del elemento deseado. Returns: any: Elemento en la posición especificada del array. """ return self.items[index] def __setitem__(self, index, new_item): """ Establece el valor de un elemento en la posición especificada del array. Args: index (int): Índice del elemento a actualizar. new_item (any): Nuevo valor para el elemento. """ self.items[index] = new_item def __randReplace__(self): """ Llena el array con valores aleatorios en el rango [0, capacidad). """ return [self.__setitem__(i, random.randint(0, self.capacity)) for i in range(self.capacity)] def __sum__(self): """ Calcula la suma de los elementos del array. Returns: any: Suma de los elementos del array. """ try: return reduce(lambda x, y: x + y, self.items) except TypeError: return "No se puede sumar: los elementos del array deben ser números" def run(): """ Función principal para ejecutar el programa. Solicita al usuario el tamaño deseado para el array, crea un array con dicho tamaño, lo llena con valores aleatorios y muestra la longitud, el contenido y la suma de los elementos del array. """ size = int(input("¿Qué tamaño deseas para tu Array?: ")) array = Array(size) print("La longitud del Array es: ", len(array)) print("Arrays sin datos iniciales: ", array) array.__randReplace__() print("Arrays con datos aleatorios: ", array) print("Sumatoria del array: ", array.__sum__()) if __name__ == "__main__": run() ```
Asi quedo mi solución al reto 1. les aconsejo que como van aprendiendo se tomen descansos en momentos de estres o frustacion, tomen una ducha, hagan ejercicio. su mente debe liberarse para pensar mejor. aqui les dejo mi codigo ```js import random class array: def __init__(self,capacity, fill_value=None): # Constructor self.items= list() for i in range(capacity): self.items.append(fill_value) def __len__(self): return len(self.items) def __str__(self): return str(self.items) def __iter__(self): return iter(self.items) def __getitem__(self, index): return self.items[index] def __setitem__(self, index, new_item): self.items[index] = new_item def ran(self): for i in range(len(self)): self.items[i] = random.randint(1,100) def suma(self): suma = 0 for i in range(len(self)): suma = suma + self.items[i] return suma arrayPrueba = array(5) arrayPrueba.ran() print(arrayPrueba) print(arrayPrueba.suma()) ```import random class array: def \_\_init\_\_(self,capacity, fill\_value=None): # Constructor self.items= list() for i in range(capacity): self.items.append(fill\_value) def \_\_len\_\_(self): return len(self.items) def \_\_str\_\_(self): return str(self.items) def \_\_iter\_\_(self): return iter(self.items) def \_\_getitem\_\_(self, index): return self.items\[index] def \_\_setitem\_\_(self, index, new\_item): self.items\[index] = new\_item def ran(self): for i in range(len(self)): self.items\[i] = random.randint(1,100) def suma(self): suma = 0 for i in range(len(self)): suma = suma + self.items\[i] return suma arrayPrueba = array(5) arrayPrueba.ran() print(arrayPrueba) print(arrayPrueba.suma()) y mi resultado: ![](https://static.platzi.com/media/user_upload/image-a6c635ed-56d7-47f2-851b-a2c37320b50b.jpg)
Creo que me complique bastante tratando de generar los numeros aleatorios en cada slot del array pero pues la solucion puede ser bastante sencilla... tras mi frustación decide usar chat gpt 3 pues de una o otra manera se parendieron cosas y comparto mis aprendizajes ![](https://static.platzi.com/media/user_upload/Screenshot%20from%202024-01-16%2011-08-09-495a0148-3c4f-4d4a-a27d-fcfd4ff8b188.jpg) Uso de terminal en linux ![](https://static.platzi.com/media/user_upload/Screenshot%20from%202024-01-16%2011-05-32-a3297c77-9d2f-4ef8-b7ab-638b3ac57b55.jpg)

Mi solución al reto

Dejo mi aporte

import random
from functools import reduce


class Array:
    def __init__(self, capacity, fill_value=None):
        self.items = [fill_value for i in range(capacity)]

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

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

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

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

    def __setitem__(self, index, new_item):
        self.items[index] = new_item

    def __randomvalues__(self, init, end):
        self.items = [random.randint(init, end) for i in range(len(self.items))]

    def __sequentialvalues__(self):
        self.items = [i + 1 for i in range(len(self.items))]

    def __sumarray__(self):
        return reduce(lambda a, b: a + b, self.items)
```python import random class Array: def __init__(self,capacity, fill_value = None): self.items = list() for i in range(capacity): self.items.append(fill_value) def __len__(self): return 23092023 def __str__(self): return 'Otro tonto aprendiendo' def __iter__(self): return iter(self.items) def __getitem__(self,index): return self.items[index] def __setitem__(self,index,new_item): self.items[index] = new_item def fillrandom(self): for i in range(len(self.items)): self.items[i] = random.randint(0,10) return self.items def sumall(self): sum = 0 for i in range(len(self.items)): sum += self.items[i] return sum #Los "métodos mágicos" en Python se utilizan para personalizar y modificar el comportamiento de funciones y operaciones incorporadas en Python. Estos métodos mágicos se llaman automáticamente en ciertos contextos específicos cuando interactúas con objetos de una clase personalizada. ```
`import random` `class Array:` `def __init__(self,capacity, fill_value = None):` `self.items = list()` `for i in range(capacity):` `self.items.append(fill_value)` `def __len__(self):` `return 23092023` `def __str__(self):` `return 'Otro tonto aprendiendo'` `def __iter__(self):` `return iter(self.items)` `def __getitem__(self,index):` `return self.items[index]` `def __setitem__(self,index,new_item):` `self.items[index] = new_item` `def fillrandom(self):` `for i in range(len(self.items)):` `self.items[i] = random.randint(0,10)` `return self.items` `def sumall(self):` `sum = 0` `for i in range(len(self.items)):` `sum += self.items[i]` `return sum` `#Los "métodos mágicos" en Python se utilizan para personalizar y modificar el comportamiento de funciones y operaciones incorporadas en Python. Estos métodos mágicos se llaman automáticamente en ciertos contextos específicos cuando interactúas con objetos de una clase personalizada.`
import random
class Parray():
    def __init__(self, capacity, fill_value = None):
        self.item = list()
        self.capacity = capacity
        for i in range(capacity):
            self.item = fill_value
    def __RandomFilled__(self, Max, Min, Order = True):
        if Order:
            self.item = list(i for i in range(Min,Max+1))
        else:
            self.item = list(random.randint(Min,Max) for i in range(self.capacity))
        return self
    def __SumArray__(self):
        return sum(x for x in self.item)
    
    
    
Array = Parray(5)
print(Array.__RandomFilled__(5,1).item)
print(Array.__SumArray__())

Mi aporte

import random
from functools import reduce


class MyArray:
    def __init__(self, capacity, fill_value=None):
        self.capacity = capacity  # Almacena la capacidad como atributo
        self.items = [fill_value] * capacity  # Usando list comprehension se rellenan con valor con defecto

        
    def __len__(self):
        return len(self.items)#Regresa longitud de los items
    
    def __str__(self):
        return str(self.items)
    
    def __iter__(self):
        return iter(self.items)
    
    def __getitem__(self, index):
        return self.items[index]
    
    def __setitem__(self, index, new_item):
        self.items[index] = new_item

    def __addRandomItems__(self):
       self.items = [random.randint(0, self.capacity ) for i in range(self.capacity)]  # Genera numeros random y los asigna a items
        #cambiamos el valor del self.capacity en random para obtener otros valores
    def __sumItems__(self):
        return reduce(lambda a,b: a+b, self.items)
    


if __name__ == "__main__":
    arreglo = MyArray(10)
    print("Array inicial:", arreglo)
    arreglo.__addRandomItems__()
    print("Array con números aleatorios:", arreglo)
    total = arreglo.__sumItems__()
    print("Suma de los valores en el array:", total)

Mi aporte:

import random

class Array:
    def __init__(self, capacity, fill_value=None):
        self.capacity = capacity
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)

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

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

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

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

    def __setitem__(self, index, new_item):
        self.items[index] = new_item

    def __insert_data__(self):
        for i in range(len(self)):
            self.items[i] = random.randint(0,len(self))

    def __suma__(self):
        suma = 0
        for i in range(len(self)):
            suma += self.items[i]
        return suma

Escribo mi respuesta, que seguramente es muy similar a las ya escritas:

import random
from functools import reduce

class Array:
    def __init__(self, capacity, fill_value=0):
        self.items = list()
        for _ in range(capacity):
            self.items.append(random.randint(0, 100))
    def __len__(self):
        return len(self.items)

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

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

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

    def __setitem__(self, index, new_item):
        self.items[index] = new_item
        
    def __totalsum__(self):
        suma_total = reduce(lambda x, y: x + y, self.items)
        return print(suma_total)

Este es mi version del reto

class Array:

    def __init__(self, capacity, fill_value = None):
        self.capacity = capacity
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)

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

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

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

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

    def __setItem__(self, index, new_item):
        self.items[index] = new_item 

    def __sumItems__(self):
        if self.__len__() > 0:
            if type(self.__getItem__(0)) == int:
                suma = 0
            else:
                suma = ""  
        else:
            suma = 0
                
        for i in range(self.__len__()):
            suma = suma + self.__getItem__(i)
        return suma

    def __genItems__(self, element_type):
        if element_type == 'str':
            phrase = "the quick brown fox jumps over the lazy dog 1234567890"
            len_phrase = len(phrase)
            for i in range(self.__len__()):
                self.__setItem__(i, phrase[i % len_phrase])
        else:
            for i in range(self.__len__()):
                self.__setItem__(i, 3 * i + 1)

y aqui el script donde lo probe

arreglo = Array(60)
print(type(arreglo))

print(arreglo.__len__())
print(arreglo.__str__())

for i in range(arreglo.__len__()):
    arreglo.__setItem__(i, i*10)
for i in range(arreglo.__len__()):
    print(arreglo.__getItem__(i))

iterador = arreglo.__iter__()
while True:
    try:
        print(next(iterador))
    except StopIteration:
        print("Final del iterador")
        break
    
print(arreglo.__sumItems__())  

arreglo.__genItems__('str')
for i in range(arreglo.__len__()):
    print(arreglo.__getItem__(i))

print(arreglo.__sumItems__())  

Reto

Lo hice para no modificar la variable del array sino para re utilizarle:
.
Modulo arrays.py

Usando el modulo

No estoy seguro si esta bien asi pero esta es la solucion a la que llegue:

class Array2:
    def __init__(self, capacity, fill_value=None):
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)

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

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

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

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

    def __setitem__(self, index, new_item):
        self.items[index] = new_item
    # Metodo para rellenar los elementos
    def __fullfillitems__(self):
        for i in range(len(self.items)):
            self.items[i] = i + 1
    # Metodo para sumar todos los elementos.
    def __sumitems__(self):
        result = 0 
        for i in range(len(self.items)):
            result += self.items[i]
        return result

Les dejo mi solución del código

Cree la misma función con un parámetro que dice si quiere el array vacío o aleatorio

y el otro solo utilice un acumulador para sumar todos los números

import random
class Array:
    

    def __init__(self, capacity,select,fill_value=None):
        self.items = list()

        if(select==0):
          for i in range(capacity):
            self.items.append(fill_value)
        elif(select==1): 
          
          for i in range(capacity):
            cont=0   
            while(cont<=1):
             num1 = random.randint(2, 9)
             cont += 1
            self.items.append(num1)

            
    
    def __len__(self):
        return len(self.items)
    
    def __str__(self):
        return str(self.items)
    
    def __iter__(self):
        return iter(self.items)
    
    def __getitem__(self,index):
        return self.items[index]
    
    def __setitem__(self,index,new_item):
        self.items[index] = new_item
    
    def __suma__(self):
        acum=0
        
        for i in range(len(self.items)):
            acum = int(self.items[i]) + acum
            
        return print(acum)

Hola!

Les comparto el código de la clase y la solución a los retos.

from random import randint

# Crear una Clase de Array
class Array:
    def __init__(self, capacity, fill_value = None):
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)

    # Obtener el tamaño del array
    def __len__(self):
        return len(self.items)
    
    # Definir como string sus elementos
    def __str__(self):
        return str(self.items)
    
    # Iterador
    def __iter__(self):
        return iter(self.items)
    
    # Obtener un elemento en particular el array
    def __getitem__(self, index):
        return self.items[index] 
    
    # Reemplazar elementos
    def __setitems__(self, index, new_item):
        self.items[index] = new_item    
    
    # Poblar slots con numeros secuenciales
    def __secuentialfill__(self):
        for i in range(self.__len__()):
            self.items[i] = i + 2
        return str(self.items)
    
    # Poblar slots con numeros aleatorios
    def __randomfill__(self, lower, upper):
        self.items = [randint(lower, upper) for i in range (len(self.items))]
        return str(self.items)

    # Sumatoria
    def __sum__(self):
        return sum(self.items)
from Arrays import Array

def main():
    size = int(input("Ingrese el tamaño del arreglo: "))
    arreglo = Array(size)
    print("El tamaño del arreglo es: ", arreglo.__len__())
    print("El arreglo es: ", arreglo.__str__())
    print("El arreglo con datos secuenciales pares es: ", arreglo.__secuentialfill__())
    print("La sumatoria del arreglo secuencial es: ", arreglo.__sum__())
    print("El arreglo con datos aleatorios es: ", arreglo.__randomfill__(0, 100))
    print("La sumatoria del arreglo aleatorio es: ", arreglo.__sum__())
    

if __name__ == '__main__':
    main()

Una de las formas mas rápidas es la siguiente:

  • Clase y métodos:
import random
class Array(object):

    def __init__(self, capacity, fill_value = None):
        self.capacity = capacity
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)

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

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

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

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

    def __setitem__(self, index, new_item):
        self.items[index] = new_item

    def __randomenu__(self):
        for i in range(len(self.items)):
            self.items[i] = random.randint(0, self.capacity)
        return self.items
    
    def __sumNum__(self):
        return sum(self.items)
  • Principal:
from array import Array

menu = Array(5)
print(len(menu))
print(menu)
for i in range(len(menu)):
    menu[i] = i + 1


print(menu)
print(str(menu[2]) + "\n")

print(menu.__len__())
print(menu.__str__())
print(menu.__iter__())
print(menu.__getitem__(2))
print(menu.__sumNum__())

menu.__setitem__(2, 100)
print(str(menu.__getitem__(2)) + "\n")

print(menu.__randomenu__())

esta fue la forma en la que resolví

import random


class Array:
    def __init__(self, capacity, fill_value=None):
        self.item = list()
        for i in range(capacity):
            self.item.append(fill_value)

    def __len__(self):
        return len(self.item)
    
    def __str__(self) -> str:
        return str(self.item)
    
    def __getitem__(self, index):
        return self.item[index]
    
    def __setitem__(self, index, new_item):
        self.item[index] = new_item

    def random_items(self):
        for i in range(len(self.item)):
            self.item[i] = random.randint(0, 100)
        return self.item
    
    def sum_items(self):
        for i in range(len(self.item)):
            total = total + self.item[i]
        return total

Dejo los metodos del reto resueltos, Ek resto de la clase es la misma que la del profe. Importante para que funcione haber creado el metodo len() dado que es usado en los metodos del challenge…

    def __randomitem__(self):
        for i in range(self.items.__len__()):
            self.items[i] = random.randint(0,100)

    def __sumitems__(self):
        sum = 0
        for i in range(self.items.__len__()):
            sum += self.items[i]
        return sum

Dejo un ejemplo de los outputs de la prueba de estos metodos y la clase:

18:57:46 👽 with 🤖 mgobea 🐶 in develop/python/data_structs_python via data_structs_python …
➜ python
Python 3.10.6 (main, Mar 10 2023, 10:55:28) [GCC 11.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> from my_array import Array
>>> menu = Array(10)
>>> print(menu)
[None, None, None, None, None, None, None, None, None, None]
>>> menu.__randomitem__()
>>> print(menu)
[20, 98, 42, 92, 51, 35, 29, 62, 70, 93]
>>> print(menu.__sumitems__())
592

A los que le salió el mismo error que a mi al momento de ejecutar :

len(menu)

Error:

TypeError: object of type 'Array' has no len()

Es porque “menu” es la referencia la clase Array, por ende no es de tipo array para poder ejecutarle la función len, lo que se debe hacer es apuntar a la variable items que definimos en esa clase, haciendo uso del objeto “menu” que instanciamos:

len(menu.items)

Igualmente con “menu.items” podemos hacer uso de las demás opciones de array:

print(menu.items)

En una clase hijo “challenge” cree el método suma que detecte si hay solo números y los sume, en caso contrario realice otro tipo de suma

import random
from functools import reduce

class Arrays:
  def __init__(self, capacity, fill_value=None):
    self.items = list()
    for i in range(capacity):
      self.items.append(fill_value)

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

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

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

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

  def __setitem__(self, index, new_item):
    self.items[index] = new_item


class Challenge(Arrays):
  def __replace__(self):
    for i in range(len(self.items)):
      self.items[i] = random.randint(1,100)

  def __sum__(self):
    return sum(i for i in self.items if str(i).isdigit()) if all(str(i).isdigit() for i in self.items) else reduce(lambda a, b: str(a) + str(b), self.items)

Aporte!

import random
from functools import reduce

class Array:
    def __init__(self, capacity, values=None):  
        self.items = list()
        self.capacity = capacity
        for i in range(capacity):
            self.items.append(values)
        
    def __convert2int__(self, value):
            if isinstance(value, str):
                return int(value) if value.isdigit() else 0
            if isinstance(value, float):
                return int(value)
            if isinstance(value, int):
                return value
            return 0
    
    def __len__(self):
        """Returns capacity of the array."""
        return len(self.items)
    
    def __str__(self):
        """Returns string representation of the array"""
        return str(self.items)
    
    def __iter__(self):
        """Supports traversal with a for loop."""
        return iter(self.items)
    
    def __getitem__(self, index):
        """Subscrit operator for access at index."""
        return self.items[index]
    
    def __setitem__(self, index, new_item):
        """Subscript operator for replacement at index."""
        self.items[index] = new_item
    
    def __random_replace__(self):
        return [ self.__setitem__(i, random.randint(0, self.capacity)) for i in range(self.capacity)]
    
    def __sum__(self):
        return reduce(lambda total, item: total + self.__convert2int__(item), self.items)

if __name__ == '__main__':
    array_size = int(input('Tamaño del array: '))
    custom_array = Array(array_size)
    def change(self):
        limit = len(self.items) - 1
        for i in range(0, limit):
            self.items[i] = random.randint(0, 100)

Recuerden que lo que hacemos es modificar el comportamiento de métodos. Para mejor comprensión del tema OOP es fundamental.

Si por ejemplo quisiéramos imprimir un objeto de la clase Array con un mensaje extra, lo que debemos hacer es modificar el comportamiento de la función que se encarga de imprimir. Para profundizar en el tema buscar métodos mágicos o dunder methods

__str__ 
    def __str__(self):
        return str(self.items) + ' hey'

Cree mi propio reduce y lo importe a el script del array

Script de suma
nombre: reduce_py

class suma:
    initial_missing = object()
    def __init__(self,funcion, lista, inicial=initial_missing):
        self.funcion = funcion
        self.lista = lista
        self.initial_missing = inicial
        
    
    def suma (self):
        it = iter(self.lista)

        if self.initial_missing is self.initial_missing :
            try:
                value = next(it)
            except StopIteration:
                raise TypeError("suma() of empty sequence with no initial value") from None
        else:
            value = self.initial_missing

        for element in it:
            value = self.funcion(value, element)

        return value

Script de array
nombre: array_py

import random
from reduce import suma


class Array:

    def __init__(self, capacity, fill_value=None):
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)

    def __len__(self):
        return len(self.items)
    
    def __str__(self):
        return str(self.items)
    
    def __iter__(self):
        return iter(self.items)
    
    def __getitem__(self, index):
        return self.items[index]
    
    def __setitem__(self, index, new_item):
        self.items[index] = new_item

    def __random__(self,random_values):
        for i in range(len(self.items)):
            self.items[i] = random.randint(0,random_values)

    def __sum__(self):
        sumar = suma(lambda a,b: a+b, self.items)
        return sumar.suma()
    

if __name__ == '__main__':
    menu = Array(10)
    print(menu)
    menu.__random__(100)
    print(menu)
    print(menu.__sum__())

Este es el código del reto:

class Array:
    def __init__(self, capacity, fill_value=None):
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)

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

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

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

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

    def __setitem__(self, index, new_item):
        self.items[index] = new_item

    def __random_fill__(self):
        import random

        for i in range(len(self.items)):
            self.items[i] = random.randint(i + 1, len(self.items))

    def __secuence_fill__(self):
        for i in range(len(self.items)):
            self.items[i] = i + 1

    def __custom_sum__(self):
        from functools import reduce

        return reduce(lambda a, b: a + b, self.items)

Pues para mi, esta fue una posible soluciòn.

    def __fill__(self, capacity, fill_value = None):
        """ Metodo para rellenar los slots del array con numeros aleatorios"""
        if fill_value is None:
            """ Si no se ingresan datos de entrada, se asume cualquier numero entre 0 y 9"""
            self.items = [random.randint(0,9) for i in range(0,capacity)]
        else:
            """ Si se ingresa un dato, ese mismo numero se multiplica por un numero random de 0 a 9"""
            self.items = [random.randint(0,9)*fill_value for i in range(0,capacity)]
        print(self.items)
    def __sum__(self):
        """ Metodo para sumar todos los valores en el array con una funciòn recursiva"""
        if self.items == None:
            return 0
        else:
            return self.items[0] + sum(self.items[1:])
  1. Cree el mismo array pero un poco diferente
  2. Agrege un metodo para reemplar sus valores
  3. Los sume, no!. Los concantene.
  4. Agrege un next para recorrer el iterador
class Array:
    def __init__(self, capacity, fill_value=None):
        self.items = list()
        for _ in range(capacity):
            self.items.append(fill_value)
            
    def __len__(self):
        return len(self.items)	
    
    def __str__(self):
        return str(self.items)
    
    def __replace__(self, posicion, valor):
        for i in self.items:
            if self.items[posicion - 1] == i:
                self.items[posicion - 1] = valor
                break
                
    def __concatenacion__(self):
        return " ".join(map(str, self.items))
    
    def __iter__(self):
        return iter(self.items)
    
    def __next__(self):
        for i in self.items:
            print(i)
    
    def __getitem__(self, index):
        return self.items[index]
    
    def __setitem__(self, index, new_item):
        self.items[index] = new_item
    
    
menu = Array(5)
menu.__replace__(4, "Hola")
print(menu.__iter__())
menu.__next__()
print(menu.__concatenacion__())

No sé si estará bien la verdad. Acepto cualquier tipo de feedback. Muchas gracias

Mi solucion al reto 🎇

    def __random_slots__(self,mini,maxi):
      for n in range(len(self.items)):
        self.items[n]=random.randint(mini,maxi)
        
    def __sum_list__(self):
      return sum(self.items)

Creo que debo aprender mas POO antes de continuar este curso

Mi aporte al reto:

import random

class Array:

    def __init__(self, capacity):
        
        self.item = list()

        for i in range(capacity):
            self.item.append(random.randint(0, i))
        
    def __str__(self):
        return str(self.item)

    def __iter__(self):
        return iter(self.item)
    
    def __sumitems__(self):
        self.suma = 0

        for i in self.__iter__():
            self.suma += i 
        return self.suma

Solución del reto:

import random
from functools import reduce

class Array: 
    def __init__(self, capacity, fill_value= None):
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)

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

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

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

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

    def __setitem__(self, index, new_item):
        self.items[index] = new_item

    def __random__(self, limite=100):
        capacity = self.__len__()
        for i in range(capacity):
            self.items[i] = (random.randint(0,limite))

    def __sequential__(self, init=0):
        capacity = self.__len__()
        j = 0
        for i in range(init, init+capacity):
            self.items[j] = (i)
            j+= 1

    def __sumatoria__(self):
        return reduce(lambda a,b: a+b, self.items)

Aquí mi aporte:

import random


class Array():

    def __init__(self, capacity, default_value=None):
        self.items = list()
        for i in range(capacity):
            self.items.append(default_value)

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

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

    def __iter__(self):
        return iter(self.items)
    
    def __getitem__(self, index):
        return self.items[index]
    
    def __setitem__(self, index, new_value):
        self.items[index] = new_value

    def __populate__(self):
        for i in range(len(self.items)):
            self.items[i] = random.randint(0, len(self.items))

    def __sum__(self):
        cont = 0
        for n in self.__iter__():
            cont += n
        return cont


if __name__ == '__main__':
    menu = Array(8)
    menu.__populate__()
    print(menu.__str__())
    print(menu.__sum__())

Solución al reto:

"""
Código en el que se crean y manejan arreglos estáticos
a través de métodos definidos por el developer en una clase Array
"""
import random

class Array:
    """
    Se crea todos los métodos de la Clase Array para manipulación de arreglos
    """

    def __init__(self, fill_value=None):
        self.items = list()
        self.capacity = random.randint(0, 20)
        for i in range(self.capacity):
            self.items.append(fill_value)

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

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

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

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

    def setitem(self, index):
        """
        Función que asigna un número aleatorio en un indice dado
        """
        # self.items[index] = new_item
        self.items[index] = random.randint(0, 100)

    def __sum__(self):
        suma = 0
        for i in range(self.capacity):
            suma += self.items[i]
        return suma


if __name__ == '__main__':
    menu = Array()
    for j in range(menu.__len__()):
        menu.setitem(j)

    print(f'Elementos del arreglo: {menu.__str__()}')
    print(f'Suma de elementos del arreglo: {menu.__sum__()}')

Esta es mi solución

from random import randint

class Array():
    def __init__(self, capacity, fill_value=None) -> None:
        self.items = list()
        self.capacity = capacity

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

    def __random__(self):
        for element in range(self.capacity):
            self.items[element] = randint(1,10)

    def __str__(self):
        return self.items

    def __sumitems__(self):
        result = 0
        for i in self.items:
            result += i
        
        return result

Mi solución al reto:

import random

class Array:
    def __init__(self, capacity, fill_value = None):
        self.capacity = capacity
        self.items = list()
        
        for i in range(capacity):
            self.items.append(fill_value)
            # self.items.append(random.randint(0, 100))
            
    def __len__(self):
        return len(self.items)
    
    def __str__(self):
        return str(self.items)
    
    def __iter__(self):
        return iter(self.items)
    
    def __getitem__(self, index):
        return self.items[index]
    
    def __setitem__(self, index, new_item):
        self.items[index] = new_item
        
    def __randreplace__(self):
        self = [self.__setitem__(index, random.randint(0,99)) for index in range(self.capacity)]
    
    def __seqreplace__(self, start_n):
        for index in range(self.capacity):
            self.__setitem__(index, start_n)
            start_n += 1
        
    def __sum__(self):
        return sum(self.items)
    
    def __conc__(self):
        conc = ''
        iterator = self.__iter__()
        for item in iterator:
            conc += item
        return conc

🖥 Mi solución al reto:

.
Primero hice que por default el array se llene con números secuenciales [0,1,2…] para que no esté lleno de puro ‘None’.
.
Luego para el método de sumar sus valores, primero recorro el array en búsqueda de un string, si lo encuentra, suma todos los valores como si fuesen un string cada uno, para así obtener un resultado y no un Type Error xd. Ej. [0,1,2,‘the’,4] = ‘012the4’.
Si se da cuenta que todos los valores del array son números, los suma como tal. Ej. [0,1,2,3,4] = 10.
.
Por último, para llenar el Array de números aleatorios, simplemente lo recorro y voy reemplazando cada valor con un entero aleatorio, usando el método ‘randint’ del módulo ‘random’.
.
Adjunto código:

import random

class Array:

    def __init__(self, capacity, fill_value=0):
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value + i)   
        self.array_sum = 0

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

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

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

    def __sumlist__(self):
        for item in range(len(self.items)):
            if isinstance(self.items[item], str) == True:
                all_numbers = False
                break
            else:
                all_numbers = True
        if all_numbers:
            for item in self.items:
                self.array_sum += item
        else:
            self.array_sum = ""
            for item in self.items:
                self.array_sum += str(item)
        
        return self.array_sum

    def __getitem__(self, index):
        return self.items[index]
    
    def __setitem__(self, index, new_item):
        self.items[index] = new_item

    def __fillrandom__(self):
        for i in range(len(self.items)):
            self.items[i] = random.randint(0, 99)

No cree otra clase, si no que solo añadí dos metodos para el reto.

self.capacity = capacity

def __setall__(self):
    for i in range(self.capacity):
      self.items[i] = randint(1,100)
  
def __totaldata__(self):
    acum = 0
    for i in self.items:
      acum += i
    
    return acum

**Solución al reto:
**

import random

class Array:

    def __init__(self, capacity, value=None):
        self.lista = list()

        for item in range(capacity):
            self.lista.append(value)

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

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

    def __getitem__(self, index):
        return self.lista[index]

    def __setitem__(self, index, new_value):
        self.lista[index] = new_value

    def __changealeatory__(self):
        for index in range(len(self.lista)):
            self.lista[index-1] = random.randint(0, 100)

    def __sumvalues__(self):
        result = 0

        for value in self.lista:
            result = result + value

        return result

Reto:

from functools import reduce

class Array:
    def __init__(self, capacity, fill_value=None):
        self.items = list()
        for _ in range(capacity):
            self.items.append(fill_value)
        
    def __len__(self):
        return len(self.items)
    
    def __str__(self):
        return str(self.items)
    
    def __iter__(self):
        return iter(self.items)
    
    def __getitem__(self, index):
        return self.items[index]
    
    def __setitem__(self, index, new_item):
        self.items[index] = new_item
    
    def __secSlots__(self, n=1):
        self.items = [(i + 1) * n for i in range(len(self.items))]
        
    def __sum__(self):
        return reduce(lambda a, b: a + b, self.items)

if __name__ == '__main__':
    menu = Array(5)
    print(menu)
    menu.__secSlots__(3)
    print(menu)
    print(menu.__sum__())```

He añadido las funciones de ordenar la lista (con posible reversa) y la de contar, he usado algoritmo burbuja para ordenar dado que no quería utilizar alguna función que me facilite mucho.

< def __sortItems__(self, reverse = False):
        n = self.__len__()

        if reverse == False:
            for i in range(n):
                for j in range(n - i - 1):
                    izq = self.__getitem__(j)
                    der = self.__getitem__(j+1)
                    if izq > der:
                        self.__setitem__(j,der)
                        self.__setitem__(j+1,izq)
            
        elif reverse == True:
            for i in range(n):
                for j in range(n - i - 1):
                    izq = self.__getitem__(j)
                    der = self.__getitem__(j+1)
                    if izq < der:
                        self.__setitem__(j,der)
                        self.__setitem__(j+1,izq)

        else:
            raise ValueError("reverse must to be True o False")

        return self.items


    def __count__(self, value):
        count = 0
        for item in self:
            if item == value:
                count +=1
        return count> 

Aquí esta mi solución al reto

import random
from typing import List, Any
from functools import reduce

class Array:
    @property
    def length(self):
        aux = 0
        for _ in self.items:
            aux += 1
        return aux

    def __init__(self, limit: int, fill_values: Any = None) -> None:
        self.items: List = list()
        for i in range(limit):
            self.setitem(i)

    def setitem(self, item: Any, index: int = None) -> None:
        if index is not None:
            self.items[index] = item
        else:
            self.items.append(item)

    def getitem(self, index: int) -> Any:
        return self.items[index]

    def summation(self) -> int:
        return reduce(lambda a, b: a + b, self.items)

    def replace_with_random_values(self) -> List[Any]:
        *alphabet, = map(chr, range(97, 123))
        random_list = [alphabet[random.randint(0, len(alphabet) - 1)] for _ in self.items]
        return random_list
import unittest
import logging
from myarray import Array


class TestArray(unittest.TestCase):
    def setUp(self) -> None:
        self.array = Array(5)

    def test_array_set_item_without_index(self) -> None:
        self.array.setitem(5)
        self.assertEqual(self.array.length, 6)
        self.assertIn(5, self.array.items)

    def test_set_item_with_index(self) -> None:
        self.array.setitem(7, 0)
        self.assertEqual(self.array.getitem(0), 7)
        self.assertIn(7, self.array.items)

    def test_set_item_with_unexists_index(self) -> None:
        try:
            self.assertRaises(IndexError, self.array.setitem("M", 11))
        except IndexError as e:
            logging.warning(str(e))

    def test_array_items_summation(self) -> None:
        expected = 10
        testcase = self.array.summation()
        self.assertEqual(expected, testcase)

    def test_array_replace_with_random_values(self) -> None:
        aux = self.array.items
        testcase = self.array.replace_with_random_values()
        self.assertNotEqual(aux, testcase)
        self.assertEqual(self.array.length, len(testcase))


if __name__ == "__main__":
    unittest.main()

reto de array de 2 dimencion con suma de todas sus dimenciones en una sola array

from functools import reduce
import random
"""
Code used for the 'Crear un array' class.

Array type class
Methods:
    1. Length
    2. String representation
    3. Membership
    4. Index.
    5. Replacement
"""

class Array(object):
    "Represents an array."

    def __init__(self, capacity, fill_value = None):
        """
        Args:
            capacity (int): static size of the array.
            fill_value (any, optional): value at each position. Defaults to None.
        """
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)

    def __len__(self):
        """Returns capacity of the array."""
        return len(self.items)

    def __str__(self):
        """Returns string representation of the array"""
        return str(self.items)

    def __iter__(self):
        """Supports traversal with a for loop."""
        return iter(self.items)

    def __getitem__(self, index):
        """Subscrit operator for access at index."""
        return self.items[index]

    def __setitem__(self, index, new_item):
        """Subscript operator for replacement at index."""
        self.items[index] = new_item

    def __sum__(self):
        return reduce(lambda a, b:
        a + b, self.items)

menu = Array(5)
for i in range(len(menu)):
    menu[i] = [random.randint(0, 100) for i in range(len(menu))]
    #print(menu[i])    

for i in range(len(menu)):
   print(menu[i]+menu[i])

print(menu.__sum__())

Solución al reto usando Numpy:
_

En el reto 2: se indica hacer un metodo para poblar los slot existentes con numeros secuenciales o aleatorios, en los secuenciales no se indica secuenciales en base a que:

  1. sera en base a un numero aleatorio generado por un rango indicado por el usuario?
  2. con un rango generado con los numeros ya existentes tomando los numeros upper y lower de la lista?
  3. promediando los numeros de la lista y tomando ese numero para generar luego una secuencia quee le siga o le anteceda?
  1. Tomando los numeros ya existentes y creando una secuencia sumandole, restandole, multiplicandole o dividiendole por un numero fijo a todos? para quee la secuencia siga?

Resolvi la 4.

Porque no se indica si se pueden usar librerias externas como la de ramdon e igualmente los numeros aleatorios en computacion no existen del todo, esto es uno de los problemas de esta rama, asi que mandaron a hacer algo imposible. 😦

    def __itemaddone__(self):
        a = self.items
        b = []
        for i in a:
            i = int(i)
            i = i + 1
            b.append(i)
        return b

    def __sum__(self):
        a = self.items
        b = 0
        for i in a:
            i = int(i)
            b += i
        return b

RETO:

import random
import functools

class Array:
    def __init__(self, capacity,fill_value=None):
        self.capacity = capacity
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)

    def __len__(self):
        #print("Usando __len__")
        return len(self.items)

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

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

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

    def __setitem__(self, index, new_item):
        self.items[index] = new_item

    def __fillRandom__(self):
        return [self.__setitem__(i, random.randint(0, self.capacity)) for i in range(self.capacity)]

    def __sum__(self):
        return functools.reduce(lambda a ,b: a + b, self.items)

if __name__ == '__main__':

    mi_array = Array(10)
    print(mi_array)
    print("-- ARRAYS ALEATORIO --")
    mi_array.__fillRandom__()
    print(mi_array)
    print("-- SUMA DE ELEMENTOS --")
    print(mi_array.__sum__())

No es nesario usaros dander __ __ ( doble guion abajo) en len para llamar a este metodo, solodebemos usar len() directamente hacer referencia a lo que se haya colocado en la creacion del metodo: def len(), mas conocido como metodos magicos.

class Array:
    def __init__(self, capacity,fill_value=None):
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)

    def __len__(self):
        #print("Usando __len__")
        return len(self.items)

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

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

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

    def __setitem__(self, index, new_item):
        self.items[index] = new_item


if __name__ == '__main__':
    menu = Array(5)
    print(len(menu))

    for i in range(len(menu)):
        menu[i] = i + 1

    for opt in menu:
        print(menu[opt-1])

    print(str(menu))
    print(menu[2])
    menu[2] = 100
    print(menu[2])
    print(menu)

Solucion al RETO

import random


class Array:
    def __init__(self, capacity, fill_value=None):
        self.capacity = capacity
        self.items = list()
        for i in range(capacity):  # None value defaults in range
            self.items.append(fill_value)

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

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

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

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

    def __fillRandom__(self, min=0, max=10):
        self.items = [random.randint(min, max) for i in range(self.capacity)]

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

    def __setitem__(self, index, new_item):
        self.items[index] = new_item

Terminal

╰─ python3
Python 3.8.10 (default, Mar 15 2022, 12:22:08)
[GCC 9.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> from array_ import Array
>>> menu = Array(15,2)
>>> menu.__str__()
'[2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]'
>>> menu.__sumnumeric__()
30
>>> menu.__fillRandom__(1,20)
>>> menu.__str__()
'[12, 15, 3, 17, 2, 18, 15, 8, 13, 4, 10, 18, 6, 1, 10]'
>>> menu.__len__()
15
>>> menu.__sumnumeric__()
152
En esta clase se hace un array de juguete, pero NO TIENE una de las grandes características de estar definido por un bloque de *memoria continuo*. Esto porque en realidad es una lista. Algo realmente más parecido a un Array son los numpy.ndarray https://numpy.org/doc/stable/reference/arrays.ndarray.html#internal-memory-layout-of-an-ndarray No son parte de la librería ml2)x x z pero numpy es muuuuy popular, no tiene la limitante de ser solo para números y characteres, y sí están hechos con bloques de memoria continúa y son super rápidos.

Mi solución al reto:

import random
from functools import reduce

class Array:
	def __init__(self, capacity, fill_value=None):
		self.items = list()

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

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

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

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

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

	def __setitem__(self, index, new_item):
		self.items[index] = new_item

	def reduce(self):
		return reduce(lambda a, b: a + b, self.items)


class SecuentialArray(Array):
	""" 
	Crea un array y lo rellena con los valores secuenciales
	entre start y end.
	"""
	def __init__(self, start, end):
		self.items = list()

		# comprobacion simple
		if (end < start):
			raise ValueError("El valor end tiene que ser mayor o igual a start")

		for i in range(end - start + 1):
			self.items.append(i + start)


class RandomArray(Array):
	""" 
	Crea un array con valores aleatorios entre 0 y 1
	del tamaño especificado
	"""
	def __init__(self, capacity):
		self.items = list()

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

if __name__ == '__main__':
	array = SecuentialArray(1,4)
	print('secuential array: ', array)
	array2 = RandomArray(4)
	print(f'random array: {array2}')
	array3 = Array(4, 'a')
	print('normal array: ', array3)

	print('reduce array 1: ', array.reduce())
	print('reduce array 2: ', array2.reduce())
	print('reduce array 3: ', array3.reduce())


output:

λ python array.py
secuential array:  [1, 2, 3, 4]
random array: [0.718993, 0.668231, 0.948163, 0.411788]
normal array:  ['a', 'a', 'a', 'a']
reduce array 1:  10
reduce array 2:  2.7471769439119327
reduce array 3:  aaaa

Reto Cumplido:

import random
from functools import reduce 


class Array:
   
    def __init__(self, capacity, fill_value=None): 
        self.items = list() #almacenar los items en una lista
        
        for i in range(capacity):
            self.items.append(fill_value)

    # metodo privado que devuelve la longitud del array
    def __len__(self):
        return len(self.items)

    # metodo que devuelve los elementos en su representacion como string
    def __str__(self):
        return str(self.items)

    # metodo iterador: devuelve los elementos del array
    def __iter__(self):
        return iter(self.items)

    # metodo para obtener un elemento especifico del array
    def __getitem__(self, index):
        return self.items[index]

    # metodo para reemplazar un elemento del array por otro
    def __setitem__(self, index, new_item):
        self.items[index] = new_item

    # metodo para poblar sus elementos con numeros aleatorios
    def __alea__(self):
        self.items = [random.randint(0, self.__len__()) for i in range(len(self.items))]

    # metodo para sumar todos los valores del array
    def __sumItems__(self):
        return reduce(lambda a, b: a + b, self.items)
import random
import functools
class Array:
    def __init__(self,capacity, fill_value = None):
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)

    def __len__(self):
        return len(self.items)
    
    def __str__(self) -> str:
        return str(self.items)

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

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

    def __setitem__(self, index, new_item):
        self.items[index] = new_item

    def __fill__(self):
        for i in range(self.__len__()):
            self.__setitem__(i,random.randint(0,self.__len__()))

    def __sum__(self):
        try:
            return functools.reduce(lambda a,b: a + b ,self.items)
        except TypeError:
            return 'All elements must be of the same type '

Para los que deseen tener una vista más amigable en la consola de python, puede intalar el módulo IPython desde pip y pueden iniciar la misma con el comando ipython.

Me complico con las clases y métodos en python pero reto completado

    def setRandItem (self):
        for i in range(len(self.items)):
            self.__setitem__(i, randint(1,10))

    def sumItems (self):
        try:
            print(sum(self.items))
        except TypeError:
            print("Uno o mas datos de este array no son números")           

Estuvo chévere darle una ojeada a los métodos mágicos de python. Hubiese querido implementar la suma con __add__(), pero aunque la programaba para no recibir ningún parámetro, seguía pidiendo uno (que es por defecto).

En este enlace más sobre métodos mágicos

Mi solución al reto:

import random
from functools import reduce

class Array(object):
    
    def __init__(self, capacity, fill_value = None):
        
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)

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

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

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

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

    def __setitem__(self, index, new_item):
        self.items[index] = new_item

    def __newitem__(self, x, y):
        return self.items.insert(x, y)

    def __additems__(self, maxi, mini):
        self.items = [random.randint(maxi, mini)
                      for i in range(len(self.items))]

    def __sumItems__(self):
        return reduce(lambda a, b: a+b, self.items)


if __name__ == "__main__":
    menu = Array(7)
    menu.__additems__(6, 23)
    print(menu)
    print(menu.__getitem__(4))
    print(menu.__newitem__(0, 100))
    print(menu)
    print(menu.__sumItems__())

Mi solución cualquier comentario o sugerencia es bien recibida

Yo lo hice así

import random

class Array():
    def __init__(self, capacity):
        self.items = list()
        for i in range(capacity):
            self.items.append(random.randint(1,100))

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

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

    def __iter__(self): #referencia en memoria
        return iter(self.items)

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

    def __setitem__(self,index, new_item):
        self.items[index] = new_item

    def __suma__(self):
        suma = 0
        for i in range (len(self.items)):
            suma += self.items[i]
            i = i + 1
        print(suma)

array = Array(8)
print(array)

array.__suma__()

Qué gusto practicar OOP desde cero

RETO CONSEGUIDO, ahi nomas jajajajja 😉

def setrandom(self):
for i in range(len(self.items)):
self.items[i] = randint(0,100)

def __setlineal__(self, value=randint(0,100)):
    for i in range(len(self.items)):
        self.items[i] = value + i

def __suma__(self):
    total = 0
    for i in range(len(self.items)):
        int(self.items[i])
        total = total + self.items[i]  
    return total

Mi solución al reto, cualquier comentario es bienvenido:

# 1: un método para que reemplace el valor de sus elementos con números aleatorios
# 2: un método que sume todos los valores del array
from random import random

class Array:
    def __init__(self, capacity, fill_value=None):
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)

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

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

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

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

    def __setItem__(self, index, new_item):
        self.items[index] = new_item

    def __resetValues__(self):
        for i in range(len(self.items)):
            self.items[i] = int(random() * 100)

    def __sumAll__(self):
        addition = 0
        for i in range(len(self.items)):
            addition = self.items[i] + addition
        
        print(f'La suma total es {addition}')

Aca se va el reto:

Nota: le agregué un user input para definir la cantidad de slots de array y se llena con números aleatorios entre 1 y 100.

import random

class Array(object):
    
    def __init__(self, capacity, fill_value = None):
        """
        Args:
            capacity (int): static size of the array.
            fill_value (any, optional): value at each position. Defaults to None.
        """
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)
        
    def __poblate__(self):
        for i in range(len(self)):
            self.items[i] = random.randint(1,100)
        return self.items
    
    def __sum__(self):
        return sum(self.items)
    
    def __len__(self):
        """Returns capacity of the array."""
        return len(self.items)
    
    def __str__(self):
        """ Returns string representation of the array """
        return str(self.items)

    def __iter__(self):
        """Supports traversal with a for loop."""
        return iter(self.items)

    def __getitem__(self, index):
        """Subscrit operator for access at index."""
        return self.items[index]

    def __setitem__(self, index, new_item):
        """Subscript operator for replacement at index."""
        self.items[index] = new_item

def run():

    capacidad = int(input("ingrese la cantidad de slots del array: "))

    print("\ndefinir un array de n elementos\n")
    array1 = Array(capacidad)

    print("array sin poblar",array1) 
    

    print("\naplico el metodo para poblar el array\n")
    array1.__poblate__()

    print("Visualizamos el array poblado con elementos aleatorios\n")
    print(array1)

    print("\nahora sumamos todos los elementos del array\n")
    suma = array1.__sum__()
    print(suma)

if __name__ == "__main__":
    run()
class Array:
    
    def __init__(self, capacity, fill_value=None):
        self.items = list()

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

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

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

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

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

    def __setitem__(self, index, new_item):
        self.items[index] = new_item

    def __populate__(self, min_value, max_value):
        for i in range(self.__len__()):
             self.__setitem__(i, random.randint(min_value, max_value))
        return self.__str__()

    def __sum__(self):
        return reduce(lambda current_item, next_item: current_item+next_item, self.items)
def __fill_array_random__(self, down, hight):
        length_array = self.__len__()

        for i in range(0,length_array):
            item = random.randint(down, hight)
            self.items[i] = item
        
        return self.items

    def __fill_array_secuencial__(self):
        length_array = self.__len__()
        l1 = range(1, length_array+1)

        for  index, item in enumerate(l1):
            self.__setitem__(index, item)
        return self.items
    
    def __sum_values_array__(self):
        total = 0
        for index, item in enumerate(self.items):
            total += item
        
        return total

Solución al reto:


# Agregar un metodo que reemplace los valores por numeros aleatorios
# Agregar un metodo que sume todos esos valores. 

import random


class Array:
    def __init__(self, capacity, fill_value=None):
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)
    
    def __len__(self):
        return len(self.items)
    
    def __str__(self):
        return str(self.items)
    
    def __iter__(self):
        return iter(self.items)
    
    def __getitem__(self, index):
        return self.items[index]
    
    def __settitem__(self, index, new_item):
        self.items[index] = new_item
        
    def __rng__(self):
        for i in range(len(self.items)):
            self.items[i] = random.randint(0,100)
        
        print(f'Nuevos Items: {self.items}')

    def __sum__(self):
        n = 0
        for i in range(len(self.items)):
            n = n + self.items[i]
        
        print(f'La suma total es: {n}')

Resultados de los nuevos metodos:

>>> menu = Array(5)
>>> menu.__rng__()
Nuevos Items: [99, 60, 76, 36, 42]

>>> menu.__sum__()
La suma total es: 313

Saludos.

Aqui mi reto

import random


class Array:
    def __init__(self, capacity, fill_value= None):

        self.items = [random.randint(0, capacity) for x in range(fill_value)]
        
        # comento lo visto en la clase
        # self.items= list()
        # for fill_value in range(capacity):
        #     self.items.append(fill_value)


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

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

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

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

    def __setitem__(self, index, new_items):
        self.items[index] = new_items  

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


10
[20, 16, 17, 14, 9, 18, 19, 10, 5, 18]
<list_iterator object at 0x00000000007AC400>
17
100
229

Solucion al reto de la clase

from functools import reduce
import random


class Array:
    def __init__(self, capacity,  fill_value=None):
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)
    
    def __len__(self):
        return len(self.items)
    
    def __str__(self):
        return str(self.items)

    #iterator
    def __iter__(self):
        return iter(self.items)
    
    def _gititem_(self, index):
         return self.items[index]

    def __setitem__(self, index, new_item):
        self.items[index] = new_item
    
    def __add__(self, lower, upper):
        self.items = [random.randint(lower, upper)
            for i in range(len(self.items))]
    
    def __sum__(self):
        return reduce(lambda a, b:
        a + b, self.items
        )
if __name__ == "__main__":
    menu = Array(5)
    menu2 = Array(5)
    print(menu)
    menu.__add__(1, 5)
    print(menu)
    print(menu.__sum__())

wooo, esto esta genial