Crear un array

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)

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

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

class Array:
def init(self, long):
self.long=long
self.items=[None for _ in range(self.long)]

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, pos, item):
    self.items[pos]=item
    
def __fillrand__(self,minimo,maximo):
    import random as rnd
    self.items=[rnd.randint(minimo,maximo) for _ in range(self.long)]
    
def __suma__(self):
    iterador=self.__iter__()
    suma=0
    for i in range(self.long):
        suma=suma+next(iterador)
    return suma

Les comparto mi solución al reto:

class Array:
    def __init__(self,capacity,fill_value=None):
        self.items = [fill_value for _ in range(capacity)]
        self.capacity = 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 __set_elements__(self,start=None,random=False,stop=None):
        if random:
            self.items = [randint(start,stop) for _ in range(self.capacity)]
        else:
            self.items = [(start+i) for i in range(self.capacity)]
    def __sum__(self):
        return sum(self.items)

import random
from functools import reduce

class Array:

    def __init__(self, capacity, value = None):
        self.items = list()
        self.__capacity = capacity
        for i in range(capacity):
            self.items.append(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, value):
        self.items[index] = value

    def __populate__(self, random_ini, random_end):
        #Realizando pruebas verifico que este puede tirar número duplicados
        #self.items = random.choices(range(random_ini, random_end), k=self.__capacity)
        
        #No duplicamos los números
        self.items = random.sample(range(random_ini, random_end), self.__capacity)

    def __sum__(self):
        #Solo sirve para sumas
        #sum(self.items)
        return reduce(lambda a, b: a+b, self.items)

Solución al reto:

#importamos libreria para randomizar
from random import randrange

#definimos la clase e inicializamos valores en None
class Array:
    def __init__(self, capacity, fill_value=None):
        self.items = list()
        for i in range (capacity):
            self.items.append(fill_value)

    #retorna el largo
    def __len__(self):
        return len(self.items)

    #retorna la lista como string
    def __str__(self):
        return str(self.items)

    #retorna el iterador
    def __iter__(self):
        return iter(self.items)

    #trae un numero del array
    def __getitem__(self, index):
        return self.items[index]

    #da valor a una posicion especifica
    def __setitem__(self, index, new_item):
        self.items[index] = new_item

    #llenar datos iniciales
    def __setvalues__(self):
        for i in range (len(self.items)):
            self.items.__setitem__(i,randrange(10))

    #retorna la sumarotia
    def __summation__(self):
        summation = 0
        for i in range (len(self.items)):
            summation += self.items[i]
        return summation

Consola:

Reto

    def __rand__(self, metodo_x):
        l = self.items.__len__()
        if metodo_x == 0:
            for i in range(0,l):
                number = r.randrange(l*l)
                self.items.__setitem__(i, number)
        elif metodo_x == 1:
            for i in range(0,l):
                self.items.__setitem__(i, i)
            return self.items
        else:
            return "Error" 
        
    def __sum__(self):
        return reduce(lambda start, finish: start+finish, self.items)

El reto!

import random

class Array:
    def __init__(self, capacity: int, fill_value: int =None):
        self.items = list()
        for i in range(capacity):
            self.items.append(fill_value)
    
    def __len__(self):
        return len(self.items)
    
    def __str__(self):  #Arreglar
        return str(self.items)
    
    def __iter__(self):
        return iter(self.items)
    
    def __getitem__(self, index: int):
        return self.items[index]

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

    def __sumitems__(self):
        sum = 0
        for i in range(self.items.__len__()):
            sum = sum + self.__getitem__(i)
        return sum
        
    def __randomitems__(self, min, max):
        for index in range(self.items.__len__()):
            self.__setitem__(random.randint(min,max),index)

Mi solución al reto:

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 __fill_array__(self):
    for i in range(len(self.items)):
      random_number = random.randrange(0, 100)
      self.items[i] = random_number


  def __sum_values__(self):
    sum = 0
    for i in range(len(self.items)):
      if type(self.items[i]) == int:
        sum += self.items[i]
    return sum

En general, muy bien la explicación pero hay algo que no entiendo. ¿Para qué usar los métodos que por defecto py trae si las que se deberían usar son las que se crearon? a veces se pierde el rumbo.

Solución al reto:

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 __repr__(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 __sum__(self):
        return sum(self.items)

    def fill(self, method, inf_lim=0, sup_lim=100):
        if method == "random":
            for i in range(len(self.items)):
                self.items[i] = random.randint(inf_lim, sup_lim)
        elif method == "linear":
            for i in range(len(self.items)):
                self.items[i] = i+1

La función repr es “similar” a la función str y, además, usé la función built-in sum para devolver la suma de las items del array.

You can define the method __sum__ son you can use th bultin function sum. Example: sum(my_array)

My solution to the challenge:

    def __sum__(self) -> None:
        for ele in self.items:
            assert (
                type(ele) == int or type(ele) == float
            ), "You can only get the sum of `int` and `float` values"

        return sum(self.items)

    def fill(self, min: int, max: int, random: bool = False) -> None:
        assert min <= max, "The property `min` needs to be lower or equal to `max`"

        if random:
            for i in range(len(self.items)):
                self.items[i] = randint(min, max)
        else:
            assert max - min == len(self.items)

            i = 0
            for num in range(min, max):
                self.items[i] = num
                i += 1

Incluyendo los métodos a la clase Array:

  def __aleatoryfill__(self):
    for i in range(self.capacity):
      self.items[i]=(random.randint(0,100))
  
  def __sequentialfill__(self):
    for i in range(self.capacity):
      self.items[i]= i + 1
  
  def __sumall__(self):
    return sum(self.items)

SOLUCION AL RETO!!!

Los dos métodos del reto

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

    def __cumsum__(self):
        sum = 0
        iterator = self.__iter__()
        try:
            while True:
                sum += iterator.__next__()
        except:
            print(sum)

Acá esta mi array y solución al reto. Quise hacer algunos métodos distinto a los que hizo el profesor, ademas de agregarle un par de métodos mas ademas de los del reto.

class Array(object):
    """
    Create a own Array
    """

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

    def __len__(self) -> int:
        """
        Method to Know the array's lenght
        """
        count = 0
        for i in self.items:
            count += 1
        return count

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

    def __iter__(self):
        """
        Method to iter the array
        """
        current = 0
        while current < len(self.items):
            yield current
            current += 1

    def __getitem__(self, index: any) -> any:
        """
        retunr a specific index
        """
        return self.items[index]

    def __setitem__(self, index, new_item):
        """
        set item in a specific index
        """
        self.items[index] = new_item
        return self.items

    def __fillslots__(self):
        """
        return a sequence of numbers according to the array's length
        """
        slots = self.items
        for i in range(len(slots)):
            slots[i] = i + 1
        return slots

    def __sumlements__(self) -> list or None:
        """
        return the sum of all array's elements if and only if the elements are integers
        """
        arr = self.items
        try:
            for i in range(len(arr)):
                if type(arr[i]) != int:
                    raise TypeError('Solo se pueden sumar enteros')
            return sum(arr)
        except TypeError as e:
            print(e)

    def __add__(self, index, item):
        """
        returns the array with de new element
        """
        return arr[:index] + [item] + arr[index:]

    def __append__(self, item):
        """
        returns the array with de new element at the end
        """
        arr = self.items
        return arr[:] + [item]

OJO: Los métodos add y append no son in place (Como debería de ser en un array), le eche cabeza durante horas y no los pude hacer in place, pero así como lo hice “funciona”, solo que crea un nuevo array, si alguien sabe de que manera podría hacer esos métodos sin crear un nuevo array, les agradecería que me lo hicieran saber

En esta clase creamos una clase Array, definimos sus métodos y sus comportamientos:

Por defecto, cada uno de esos elementos tiene un valor igual a None, que no es lo mismo que la ausencia de ese elemento o que el elemento sea igual a cero. Son cosas diferentes.

Después, con un ciclo for, y por fuera de la clase Array, les dimos valores diferentes. En este caso fueron números del 1 al 5.

Hola, les comparto mi reto.

from typing import Any


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 __randReplace__(self):
        return [self.__setitem__(i, Any.rand(0, self.capacity)) for i in range(self.capacity)]

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

Acepto sugerencias de cómo mejorarlo.

Muchas gracias

Esta fue mi solución al reto, usando funciones ya integradas en python.

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

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

Esta es mi solución al reto propuesto en clase :

import random
"""
Creando mi clase Array en python
"""

class Array:
    def __init__(self, capacidad, valor):
        self.capacidad = capacidad
        self.items = []
        for item in range(capacidad):
            self.items.append(valor)
    """
    definimos los metodos de la lista/array
    """
    @property
    def get_array(self):
        """
        obtiene la lista morsh
        """
        return self.items
    
    def __replace_item__(self, *args):
        if len(args) > self.capacidad:
            raise IndexError(
            "La cantidad de indices a setear no pueden ser\n \t\t\tmayor a la capacidad ya asignada al Array")
        for i in range(len(args)):
            if args[i][0] > self.capacidad:
                raise Exception    
            self.items[args[i][0]-1] = args[i][1]
        return self.items

    def fill_random_value(self, minimo, maximo):
	    return [random.randint(minimo, maximo) for _ in range(self.capacidad)]    
    
    def __getitem__(self, index):
        """
        retorna el valor del arreglo dado un indice
        """
        return self.items[index]
    
    def sum_array(self, type_data):
        sum = '' if type(type_data) == str else 0
        for number in range(len(self.items)):
            sum += self.items[number]
        return sum
    
    def __str__(self):
        return str(self.items)
    
    def __len__(self):
        len_counter = 0
        for item in self.items:
            len_counter += 1
        return len_counter
    
    def __iter__(self):
        return iter(self.items)

instancia = Array(5, 0)
print(instancia.__replace_item__((3, 90), (1, 0),
 (2, 0), (5, 34), (4, 35)))
print(instancia.fill_random_value(5, 100))
print(instancia.sum_array(0))

La salida:

[0, 0, 90, 35, 34]
[70, 91, 56, 22, 64]
159

Hola a todos, esta fue mi forma de resolver el reto, estoy abierto a la retroalimentación, nunca paren de aprender! 😄

Código controlador:

import random as rd
if __name__== "__main__":

    menu = Array(10)
    rdIndex = [rd.randint(0,9) for _ in range(3)]
    # loop to add items with 3 randoms NoneTypes elements
    for i in range(len(menu)):
        if i == rdIndex[0] or i == rdIndex[1] or i == rdIndex[2]:
            continue
        menu[i] = i + 1
    # Printing results
    print(f'''
            with empty spaces:
            {menu.__str__()}
            
            fill the empty spaces:
            {menu.__fillempty__()}
            
            sum of elements:
            {menu.__sumitems__()}
            ''')

Código de la clase:

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 __sumitems__(self):
        """" add all elements in the array"""
        values, ans = self.__iter__(), 0
        for _ in self.items:
            ans += values.__next__()
        return ans
    def __fillempty__(self):
        """Detect all elements with Nonetype and fill with a default value"""
        values, i, defaultVal = self.__iter__(), 0, 0
        for _ in self.items:
            if values.__next__() == None:
                self.__setitem__(i,defaultVal)
            i+=1
        return self.__str__()```

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 __remitem__(self, name_array):
        for i in range(len(name_array)):
            self.items[i] = random.randint(0, 100)
    
    def __sumitem__(self):
        try:    
            return print(sum(self.items))
        except TypeError:
            print('Se produjo en error, al parecer hay un string en la lista')

if __name__ == '__main__':
    menu = Array(5)
    
    menu.__remitem__(menu)
    print(menu)
    menu.__sumitem__()