No tienes acceso a esta clase

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

Crear un array

7/23
Recursos

Aportes 64

Preguntas 9

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

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

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

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

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

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

Mi solución al reto:

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

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)

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

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

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!!!

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!

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__()```
# Reto Platzi - Curso Estructuras de Datos Lineales - Clase 8

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

def __setrandom__(self, lower_number, upper_number):
	self.items = [randint(lower_number, upper_number) for number in range(self.items.__len__())]

def __setserial__(self, start_number = 1):
	self.items = [number for number in range(start_number, start_number + self.items.__len__())]
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__()
from functools import reduce
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 __getitem__(self,index):
        return self.items[index]

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

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

    def sequence_numbers(self):
        return [self.__setitem__(i,i+1) for i in range(self.capacity)]

    def add(self):
        return reduce(lambda x,y: x+y,self.items)
    



if __name__ == '__main__':
    array = Array(5)

    array.sequence_numbers()

    array.random_numbers()

    print(array)

    print(array.add())
 

Implementación array

Les comparto mi implementación de la clase array.

"""
Clase 7: crear un array
"""
from random import randint
from functools import reduce

class Array:
    """Representasión de un array."""
    def __init__(self, size : int, fill=None):
        self._items = list()
        self._size = size

        for i in range(size):
            self._items.append(fill)
    
    def __len__(self):
        return self._size

    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 __repr__(self):
        return str(self)

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

    def index(self, value, start_index: int = 0):
        """Busca un elemento a partir de un índice y retorna su índice si es encontrado,
        si no existe retorna -1.

        Args:
            value: Objetivo
            start_index: Valor a partir del cual se comenzará la búsqueda.

        Returns:
            int: índice del elemento.
        """

        assert start_index >= 0 and len(self._items) > start_index, 'Índice fuera de rango.'

        _index = -1
        for idx, _value in enumerate(self._items[start_index:]):
            if value == _value:
                _index = idx + start_index
                break

        return _index

    def randomize_values(self):
        """Popula el array con números aleatoreos"""

        for i in range(self._size):
            self._items[i] = randint(0, self._size * i)

        return self

Hola, compañeros. Aquí les dejo mi solución al reto:
Nota: Cuando hay un tipo de dato distinto al numerico lo que hace el programa es tratar todo como cadena y concatenar.

Probablemente si añaden un complejo no funcione, pero bueno creo que pueden añadir ese caso sin problemas.

from random import randint


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, min=0, max=100):
        for i in range(self.__len__()):
            self.items[i]=randint(min, max)

    def __notjustnumbers__(self):
        nojustnumbers=False
        for elemento in self.items:
            if type(elemento)!=int and type(elemento)!=float:
                nojustnumbers=True
                return nojustnumbers
        return nojustnumbers

    def __sumate__(self):
        centinela=self.__notjustnumbers__()
        if centinela:
            suma=''
            for elemento in self.items:
                suma += str(elemento)
        else:
            suma=0
            for elemento in self.items:
                suma += elemento
        return suma 


if __name__=='__main__':
    menu=Array(7)
    print(menu.items)
    print('Chequemos que se rellenan los numeros aleatorios')
    menu.__random_fill__(10,200)
    print(menu.__str__())
    print(menu.items)
    print('Ahora chequemos la suma')
    print(menu.__sumate__())
    print('Verifiquemos que identifica que hay elementos no numericos')
    menu.__setitem__(0,'gegege')
    print(menu.items)
    menu.__setitem__(1,[1,2,3])
    print(menu.__notjustnumbers__())
    print('Ahora chequemos la suma')
    print(menu.__sumate__())

Escribí algo de código para los retos:

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, value):
    self.items[index] = value
  def fill(self, fill_random = False):
    for idx, i in enumerate(self.items):
      if fill_random:
        self.items[idx] = random.randint(0,len(self.items) * 10)
      else:
        self.items[idx] = idx
  def fill_str(self, fill_random= False):
    for idx, i in enumerate(self.items):
      if fill_random:
        self.items[idx] = chr(random.randint(65,91))
      else:
        self.items[idx] = chr(65 + idx)
  def sum_values(self):
    result = self.items[0]
    for i in self.items[1:]:
      result += i
    return result


arr = Array(10)
arr.fill() #Si agregamos True como argumento nos llena nuestro array con valores aleatorios
print(arr.sum_values()) #imprime la suma de valores

arr.fill_str(True)#Al aplicar True nos llena nuestro array con caracteres aleatorios
print(arr.sum_values())#imprime la suma de los valores

Agregue la propiedad de datatype a mi array, para poder generar numeros aleatorios y hacer la suma dependiendo si es int(), float() o str()

Código de la clase con los métodos:

import random
from string import ascii_lowercase

class Array:
    def __init__(self, capacity, datatype=int(), fill_value=None):
        self.items = list()
        self.datatype = datatype
        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 __random_fill__(self, min, max):
        if isinstance(self.datatype,int):
            for i in range(self.__len__()):
                self.__setitem__(i, random.randint(min, max))
        if isinstance(self.datatype,float):
            for i in range(self.__len__()):
                self.__setitem__(i, random.random()*(max-min)+min)
        if isinstance(self.datatype,str):
            for i in range(self.__len__()):
                self.__setitem__(i, random.choice(
                    ascii_lowercase[ascii_lowercase.find(min):ascii_lowercase.find(max)+1]))

    def __sum__(self):
        iterator = self.__iter__()
        total = self.datatype
        for _ in range(self.__len__()):
            total += next(iterator)
        return total


Creando arrays y probando los métodos

int_array = Array(5,int())
int_array.__random_fill__(0,100)
print(f'int_array = {int_array}')
print(f'suma = {int_array.__sum__()}')
print()

float_array = Array(5,float())
float_array.__random_fill__(0,100)
print(f'float_array = {float_array}')
print(f'suma = {float_array.__sum__()}')
print()

string_array = Array(5,str())
string_array.__random_fill__("a","n")
print(f'string_array = {string_array}')
print(f'suma = {string_array.__sum__()}')
print()

Salida

int_array = [71, 23, 43, 93, 13]
suma = 243

float_array = [88.35510926609096, 17.037455577701298, 47.9979968848974, 26.35872451326293, 69.35082847341802]
suma = 249.10011471537058

string_array = ['j', 'c', 'f', 'j', 'f']
suma = jcfjf

SOLUCIÓN DEL RETO

from random import randint

class ArrayReto:
    def__init__(self, capacity, fill_value = None):
        self.items = list()
        self.capacity = capacity
        for i in range(capacity):
            self.items.append(fill_value)
	
    def__GenerateItems__(self, method):
            self.items = [randint(0, 20) for i in self.items] if method == 'random' else [i for i in range(self.capacity)]

    def __SumItems__(self):
        cont = 0
        for i in self.items:
            cont = (cont + i) if type(i) is int else (cont + 0)

        return cont

if __name__ == '__main__':
    array = ArrayReto(5)
    array.__PopulateItems__('random')
    print(f'ARRAY ITEMS ==> {array.items}')
    print(f' ITEMS SUM ==> {array.__SumItems__()}')
    
    print('\n\n')

    array = ArrayReto(3)
    array.__PopulateItems__('secuential')
    print(f'ARRAY ITEMS ==> {array.items}')
    print(f' ITEMS SUM ==> {array.__SumItems__()}')

OUTPUT

ARRAY ITEMS ==> [2, 4, 7, 8, 3]
ITEMS SUM ==> 24

ARRAY ITEMS ==> [0, 1, 2]
ITEMS SUM ==> 3