No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Crear un array

7/23
Recursos

Aportes 106

Preguntas 16

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 鈥榟ola鈥 y siempre regresa ese valor 7, no importa de qu茅 tama帽o sea el array鈥
Tonses pues ya, eso era lo que quer铆a decir, muchas tardes, buenas gracias.

Solucion al reto:
Clase Array:

Programa principal

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

Resumen:
鈻犫枲鈻犫枲鈻犫枲鈻

Creando un array

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

Clase padre

  • Crearse
  • Longitud
  • Representaci贸n string
  • Pertenencia
  • 铆ndice
  • Reemplazo

Instancia de la clase Array

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

  • Randomizar
  • Sumar

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


Clase Padre

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


        """

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

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

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

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

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


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

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

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

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

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

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




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

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


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

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

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

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


Instancia del padre

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

'''
from arrays_custom import Array
import random as r



class Array_challenge(Array):

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

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

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

        return self.items

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

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

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

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

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



Soluci贸n al reto

import random
from functools import reduce


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

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

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

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

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

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

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

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

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


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

Soluci贸n al reto aplicando tambi茅n lo aprendido en el curso de Python Intermedio:

from random import randint
from functools import reduce


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


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


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


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

Mi soluci贸n al reto:

Agregando m茅todos al Array

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

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

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

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

Por si ustedes tambi茅n se preguntan, porque la implementaci贸n con dunder method.

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

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

  • iter: Nos permite recorrer los elementos, sin 茅l no se permitir铆a la indexaci贸n.

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

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

隆M茅todos M谩gicos!

IMPORTANTE

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

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

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

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

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

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

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

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

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

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

import random

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

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

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

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

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

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

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

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

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

# Aqu铆 hay un ejemplo de c贸mo utilizar la clase MiArray:

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

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

# Imprimir el array
print(mi_array.slots)

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

Soluci贸n al reto de arrays

import random


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

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

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

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

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

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

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

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



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


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

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

Hice correcciones con el c贸digo de Mario Castro.

from random import randint
from functools import reduce

class Array:

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

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

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

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

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

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

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

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

Mi aporte

import random
from functools import reduce


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

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

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


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

Mi aporte:

import random

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

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

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

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

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

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

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

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

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

import random
from functools import reduce

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

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

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

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

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

Este es mi version del reto

class Array:

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

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

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

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

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

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

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

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

y aqui el script donde lo probe

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

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

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

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

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

print(arreglo.__sumItems__())  

Reto

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

Usando el modulo

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

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

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

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

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

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

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

Les dejo mi soluci贸n del c贸digo

Cree la misma funci贸n con un par谩metro que dice si quiere el array vac铆o o aleatorio

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

import random
class Array:
    

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

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

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

Hola!

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

from random import randint

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

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

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

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

if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

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

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


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

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

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

print(menu.__randomenu__())

esta fue la forma en la que resolv铆

import random


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

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

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

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

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

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

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

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

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

len(menu)

Error:

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

Es porque 鈥渕enu鈥 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 鈥渕enu鈥 que instanciamos:

len(menu.items)

Igualmente con 鈥渕enu.items鈥 podemos hacer uso de las dem谩s opciones de array:

print(menu.items)

En una clase hijo 鈥渃hallenge鈥 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 鈥楴one鈥.
.
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,鈥榯he鈥,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 鈥榬andint鈥 del m贸dulo 鈥榬andom鈥.
.
Adjunto c贸digo:

import random

class Array:

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

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

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

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

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

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

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

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

self.capacity = capacity

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

**Soluci贸n al reto:
**

import random

class Array:

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

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

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

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

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

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

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

    def __sumvalues__(self):
        result = 0

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

        return result

Reto:

from functools import reduce

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

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

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

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

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

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

        return self.items


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

Aqu铆 esta mi soluci贸n al reto

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

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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

print(menu.__sum__())

Soluci贸n al reto usando Numpy:
_

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

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

Resolvi la 4.

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

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

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

RETO:

import random
import functools

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

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

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

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

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

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

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

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

if __name__ == '__main__':

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

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

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

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

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

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

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

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


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

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

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

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

Solucion al RETO

import random


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

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

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

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

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

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

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

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

Terminal

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

Mi soluci贸n al reto:

import random
from functools import reduce

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

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

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

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

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

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

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

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


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

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

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


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

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

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

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


output:

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

Reto Cumplido:

import random
from functools import reduce 


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

En este enlace m谩s sobre m茅todos m谩gicos

Mi soluci贸n al reto:

import random
from functools import reduce

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

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

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

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

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

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

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

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

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


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

Mi soluci贸n cualquier comentario o sugerencia es bien recibida

Yo lo hice as铆

import random

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

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

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

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

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

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

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

array = Array(8)
print(array)

array.__suma__()

Qu茅 gusto practicar OOP desde cero

RETO CONSEGUIDO, ahi nomas jajajajja 馃槈

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

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

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

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

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

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

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

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

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

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

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

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

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

Aca se va el reto:

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

import random

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

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

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

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

def run():

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

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

    print("array sin poblar",array1) 
    

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Soluci贸n al reto:


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

import random


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

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

Resultados de los nuevos metodos:

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

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

Saludos.

Aqui mi reto

import random


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

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


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

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

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

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

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

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


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

Solucion al reto de la clase

from functools import reduce
import random


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

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

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

wooo, esto esta genial

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 鈥渟imilar鈥 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 鈥渇unciona鈥, 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__()