No tienes acceso a esta clase

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

Desarrollando la simulaci贸n

7/24
Recursos

Aportes 135

Preguntas 31

Ordenar por:

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

o inicia sesi贸n.

El problema es que el profesor Aroesti IMPLEMENTA directo sus algoritmos, sin explicar el proceso mental o l贸gico que lo llevo a saber que ese algoritmo es el mejor. Eso provoca que nosotros solo veamos como escribe c贸digo sin saber EXACTAMENTE cu谩l es el prop贸sito de lo que el profesor programa. Por favor Aroesti, si ves este mensaje trata de incluir en estos videos una peque帽a secci贸n al inicio que nos explique de manera GR脕FICA qu茅 es lo que intentas lograr con cada clase de tu c贸digo y C脫MO SE RELACIONAN ENTRE S脥.

Estuvo muy pesada la clase, creo que muchos estamos solo copiando el c贸digo para que quiz谩s m谩s adelante podamos entender. Faltan muchas explicaciones.

Realice este c贸digo no pensando en la soluci贸n planteada por el tutor, sino estableciendo una logica l贸gica para solucionar este ejercicio. Por lo que mi c贸digo es muy diferente a lo anteriormente planteado bas谩ndome en la ejecuci贸n de 3 pasos:

  1. Decidir sobre que eje me voy a desplazar
  2. Realizar desplazamiento calculando la posici贸n final
  3. Actualizar las listas para obtener el tracking del camino recorrido

M贸dulo Principal
La l贸gica de este m贸dulo parte del entendimiento que al momento de graficar el plot final, deben estar almacenados en dos listas los movimientos realizados por el 鈥渂orracho鈥 (pasos_x, pasos_y), como esta probabilidad de decisi贸n es del 25% (arriba, abajo, izquierda, derecha) en cada paso, es importante entender que si la decisi贸n de desplazarse fue sobre el eje horizontal (pasos_x) no debe afectar los valores correspondientes al eje vertical (pasos_y) y viceversa; por tal motivo en el m贸dulo principal 煤nicamente se toma la decisi贸n de realizar el movimiento de manera vertical u horizontal.
M贸dulo de movimiento
Una vez decidido el eje sobre el cual se va a realizar el movimiento se determina hacia d贸nde va a ser realizado el siguiente paso (positivo o negativo) de manera aleatoria, como este afecta de forma iterativa la 煤ltima posici贸n del sujeto 鈥渂orracho鈥 debe obtenerse la 煤ltima posici贸n y aplicarle el respectivo movimiento.
Como ejemplo podr铆a tomarse el caso de que durante la simulaci贸n el borracho decidi贸 caminar un paso hacia la derecha X 飪1 y el siguiente paso es hacia la izquierda 1 飪 X por lo que la posici贸n final ser谩 el mismo lugar de partida (por esa raz贸n el sujeto esta 鈥渂orracho鈥 xD), en t茅rminos de programaci贸n el n煤mero de pasos realizados fueron 2 aumentando el tama帽o de la lista, pero el ultimo valor es cero, reflejando la acci贸n de dar un paso y luego devolverse.
La lista deber铆a tener estos valores:
pasos_x =
[0 --> origen / paso 0 /
1 --> derecha / paso 1
0] --> izquierda / paso 2 / vuelvo al origen
Como todos los pasos fueron en el eje horizontal el vertical debe permanecer vac铆o
[0 --> paso 0
0 --> paso 1
0] --> paso 2
M贸dulo de igualaci贸n de listas
Este modulo 煤nicamente iguala el tama帽o de las listas repitiendo el ultimo valor en la lista sobre la que no se efect煤a ning煤n desplazamiento.
Ya con las listas actualizadas y todos los pasos realizados solo me queda graficar las dos variables para ver el 鈥渃amino del borracho鈥

import os
import random as random
from bokeh.plotting import figure, output_file, show
os.system('cls')

# Inicializa las listas 

pasos_x = [0]
pasos_y = [0]

# M贸dulo de movimiento

def mover(pasos):
    #print(f'iteracion: {i}')
    move = random.choice([-1, 1])
    #print(f'choice: ({move})')
    last = len(pasos)
    delta = pasos[last-1] + move
    pasos.append(delta)
    #print(pasos)
    return pasos

# M贸dulo de igualaci贸n de listas

def equal_array(pasos):
    last = len(pasos)
    pasos.append(pasos[last-1])
    return pasos

# M贸dulo Principal

def random_direction(pasos_x, pasos_y, num):
    for i in range(num):
        direc = random.choice([-1,1])
        if direc == -1:
            #print(f'Horizontal')
            pasos_x = mover(pasos_x)
            pasos_y = equal_array(pasos_y)
        else:
            #print(f'Vertical')
            pasos_y = mover(pasos_y)
            pasos_x = equal_array(pasos_x)
    #print(pasos_x,pasos_y)
    return pasos_x, pasos_y

# Inicio del programa con ingreso de cantidad de pasos mediante consola

num = int(input('Numero de pasos aleatorios: '))
random_direction(pasos_x, pasos_y, num)

# Modulo de plotting

output_file("line.html")
plot = figure(plot_width=600, plot_height=600)
plot.line(pasos_x, pasos_y, line_width=2)
show(plot)

Me gustan los temas que quieren abordar con esta serie de cursos de python, pero un problema como este deberia tener una explicaci贸n (whiteboarding) previa, para entender lo que vamos a hacer, pues creo que al final del dia solo estamos viendo como David escribe codigo y tendremos que entender todo por nuestra cuenta.

Yo soy nueva programando y me costo casi que todo el d铆a para poder entender esto, pero luego de rayar bastante en el cuaderno, repasar, buscar m谩s informaci贸n y hacer unas pruebas en la terminal creo que pude entenderlo. Aqui van mis recomendaciones:

Hagan un diagrama UML de las clases. Yo lo hice en la clase pasada y aunque no es perfecto me ayudo a entender las dependencias entre clases. Sabiendo esto se hace m谩s facil entender lo que viene. Dejo el UML que hice por aqu铆:

Analicen el orden del c贸digo y vayan arm谩ndolo funci贸n por funci贸n. Por ejemplo, la 鈥減rimera鈥 funci贸n que se ejecuta es main(), que a su vez, tiene en s铆 misma la funcion simular_caminata(), que tiene al mismo tiempo la funcion caminata(). Si lo hacen en papel les va a quedar algo as铆:

Si escriben el c贸digo linea por linea y funcion por funcion se dar谩n cuenta que le programa en esencia lo que hace es:

  1. Mover el borracho x pasos y en cada paso registrar su nueva coordenada.
  2. A帽adir esa nueva coordenada a una lista de distancias recorridas
  3. Hacer operaciones con la lista de distancias recorridas.

Espero que ayude, he visto muchos comentarios en donde se quejan sobre la falta explicaci贸n del c贸digo, pero creo que esa es justamente la parte que nos toca a nosotros: desarrollar herramientas para entender por nosotros mismos el c贸digo. No siempre va a haber alguien que nos las haga f谩cil.

Estos cursos son muy buenos, pero podrian ser mucho mejor si se explicaran los algoritmos en vez de solo implementarlos, tienen ejemplos claros en los cursos de Freddy, el explica graficamente y luego implementa. No me gusta comparar pero con esa metodologia estos cursos estarian a un nivel muy alto. Ojala en proximos cursos de David podamos ver eso ya que el es sin duda uno de los mejores profesores.

Hola, si a alguno le cost贸 algo de trabajo entender el c贸digo tal vez este colab (Jupyter Notebook de Google) les sirva, tiene el c贸digo en un s贸lo documento junto con la documentaci贸n para ir siguiendolo. Saludos.

https://colab.research.google.com/drive/1wQD3jQcXzsYnTr6s98W0QtCOhgU3-x-F?usp=sharing

Creo que la forma correcta seria que primero explicara de manera grafica que debemos hacer para nosotros tambi茅n tener alg煤n precedente y no solo copiar el c贸digo conforme el profesor lo escribe

No se porque, pero los 煤ltimos cursos que he visto de David, he sentido que su forma de explicar ha desmejorado鈥 pareciera mas una demostraci贸n de lo que el sabe hacer y no una clase donde se ense帽e a hacer algo鈥 puede ser que sea yo, pero la verdad siento que para aprender basicamente me toca tomar el titulo del tema e ir a investigar a otra parte, porque aqui solo veo lo que el Profe hace pero no explica el porque de las cosas鈥

Ser铆a bueno que el profesor comentara el c贸digo a medida que lo va escribiendo para mejorar el entendimiento de los algoritmos

camino_aleatorio.py


from borracho import BorrachoTradicional
from campo import Campo
from coordenada import Coordenada

def caminata(campo, borracho, pasos):
	inicio = campo.obtener_coordenada(borracho)

	for _ in rango(pasos):
		campo.mover_borracho(borracho)

	return inicio.distancia(campo.obtener_coordenada(borracho))


def simular_caminata(pasos, numero_de_intentos, tipo_de_borracho):
	borracho = tipo_de_borracho(nombre = 'David')
	origen = Coordenada(0,0)
	distancias = []

	for _ in range(numero_de_intentos):
		campo = Campo()
		campo.anadir_borracho(borracho, origen)
		simulacion_caminata = caminata(campo, borracho, pasos)
		distancias.append(round(simulacion_caminata, 1))

	return distancias

def main(distancias_de_caminata, numero_de_intentos, tipo_de_borracho):
	
	for pasos in distancias_de_caminata:
		distancias = simular_caminata(pasos, numero_de_intentos, tipo_de_borracho)
		distancia_media = round(sum(distancias) / len(distancias), 4)
		distancia_maxima = max(distancias)
		distancia_minima = min(distancias)
		print(f'{tipo_de_borracho.__name__} caminata aleatoria de {pasos}')
		print(f'Media = {distancia_media}')
		print(f'Max = {distancia_maxima}')
		print(f'Min = {distancia_minimas}')

if __name__ == '__main__':
	distancias_de_caminata = [10,100,1000,10000]
	numero_de_intentos = 100

	main(distancias_de_caminata, numero_de_intentos,BorrachoTradicional)

Estuvo muy buena esta serie de el camino de borrachos, aplicamos al mismo tiempo varios conocimientos adquiridos en cursos y clases pasadas

Aunque creo que David podr铆a asignar nombres un poquito mejores para algunas variables y as铆 lograr un mejor entendimiento del c贸digo鈥 Por ejemplo: La lista declarada como 鈥渄istancias_de_caminata鈥 no tiene mucho que ver con su significado y funcionamiento en el c贸digo鈥 ya que en realidad esa lista no guarda las distancias de las caminatas de los borrachos鈥 mas bien guarda las 4 cantidades diferentes de pasos (10, 100, 1000 & 10000 pasos) que va a dar un borracho en la simulaci贸n.

Saludos y que Viva M茅xico!! 鉂わ笍

esta es la parte cuando te sientas con los codos sobre las rodillas y aumentas tu concentraci贸n al maximo en pleno juego de play station.


from borracho import BorrachoTradicional
from campo import Campo
from coordenada import Coordenada

#Obtiene la distancia entre la 1ra coord y la ultima
def caminata(campo, borracho, pasos):
	inicio = campo.obtener_coordenada(borracho) #Obtenemos la coordenada (0,0) ,el origen
	#inicio es el objeto coordenada de la clase Coordenada, aca esta el truco

	for _ in range(pasos): #Pasos = 10, aca se va a mover 10 veces, luego 100 y asi
		campo.mover_borracho(borracho) 
	
	"""def mover_borracho(self, borracho): 
        delta_x, delta_y = borracho.camina()
        coordenada_actual = self.coordenadas_de_borrachos[borracho]
        nueva_coordenada = coordenada_actual.mover(delta_x, delta_y)
        self.coordenadas_de_borrachos[borracho] = nueva_coordenada"""


	return inicio.distancia(campo.obtener_coordenada(borracho))
	#Sacamos la distancia entre la primera coordernada (0,0) y la ultima despues de los 10 pasos

#Numero de intentos siempre es 100
#Pasos : 10, 100, 10000, 100000
def simular_caminata(pasos, numero_de_intentos, tipo_de_borracho):
	borracho = tipo_de_borracho(name = 'David') #obj de la clase Borracho
	#Crea un objeto de la clase Coordenada
	origen = Coordenada(0,0)
	distancias = []

	for _ in range(numero_de_intentos): #100 veces 
		#Objeto de la clase campo
		campo = Campo()
		campo.anadir_borracho(borracho, origen) #campo tiene borracho(Borracho) y origen(Coordenada)
		simulacion_caminata = caminata(campo, borracho, pasos) #Obtenemos una distancia
		distancias.append(round(simulacion_caminata, 1))

	return distancias
	#Obtenemos 100 distancias y la anexamos a la lista

def main(distancias_de_caminata, numero_de_intentos, tipo_de_borracho):
	
	for pasos in distancias_de_caminata: 
		#Obtenemos 100 distancias por cada paso
		distancias = simular_caminata(pasos, numero_de_intentos, tipo_de_borracho)
		#Aca sacan la media y todo eso
		
		
if __name__ == '__main__':
	distancias_de_caminata = [10,100,1000,10000]
	numero_de_intentos = 100

	main(distancias_de_caminata, numero_de_intentos,BorrachoTradicional)```

Realmente no es dificil el algoritmo, de hecho es bastante sencillo.
Si escriben el c贸digo de forma procedimental veran la sencillez.

Siento que se volvi贸 complejo porque el profe lo escribi贸 con programaci贸n orientado a objetos desde el inicio. Lo que es bueno, porque modulariz贸 ya los distintos componentes, y la pr贸xima vez que escriba otro tipo de borracho solo ser谩 agregando el borracho a una clase.

cuando empece la ruta le entend铆a muy claro a David, incluso me anticipaba, siento que va muy rapido, y que no esta siendo claro, en este punto me han sido de gran ayuda los comentarios del curso por que ya han realizado el curso personas, con las mismas dudas y su explicaci贸n es m谩s breve

subi贸 bastante de nivel la clase, costo trabajo seguirla

No es dificil el codigo pero la explicacion de David es como si solo estuviera leyendo el codigo y es dificil de seguir

No es dificil el codigo, pero bastaaaaaante enredadito el borracho, por el nombre de las variables.

creo que esta clase y la pasada pod铆an haberse dividido para hacerlas 4 clases. A veces no se entiende bien el proceso o el por qu茅 del c贸digo, lo cual puede solucionarse con clases mas al detalle de cada parte, primero explicando de forma abstracta y luego ejecutando el c贸digo.

Deben invertir m谩s en sus testers, este curso es un ejemplo de que nos usan como testers a los mismos alumnos que estamos pagando por productos de calidad.
Se pierde mucho tiempo, energ铆a y motivaci贸n tratando de deducir lo que el profesor hace, o sea, parece m谩s una demostraci贸n verbalizada de como el profesor soluciona algunas problem谩ticas pero no hay una explicaci贸n de la l贸gica detr谩s (algo muy similar pasa con los cursos de Ardila)
Podr铆an a incentivar a alumnos que apenas cumplen o que tienen ligeras carencias t茅cnicas para aproximarse a sus cursos y evaluar a partir de ellos si el curso es accesible para todo aquel que est茅 en cierto margen de aprovechar la informaci贸n
Y es tal vez donde se ve el impacto de una buena formaci贸n y la importancia de la Universidad en nuestra vida, hay una MUY MARCADA diferencia entre la calidad que ofrece un profesional de la talla Natalia Usme con bases bien s贸lidas y el como aborda la vida un simple t茅cnico medianamente calificado.

A mi parecer, escribir tres clases para este problema es complicar demasiado las cosas. Tanto Coordenada como Campo se podr铆an incorporar f谩cilmente a Borracho. Por ejemplo:

import random
from bokeh.plotting import figure, show


class Borracho:

    def __init__(self, nombre, x=0, y=0):
        self.nombre = nombre
        self.x = x
        self.y = y

    def posicion(self):
        return (self.x, self.y)

    def distancia_origen(self):
        return (self.x**2 + self.y**2)**0.5  # Pit谩goras


class Borracho_Tradicional(Borracho):

    def __init__(self, nombre):
        super().__init__(nombre)

    def camina(self):
        # Se mueve arriba, abajo, a la derecha o a la izquierda
        # devuelve uno de los cuatro vectores
        dx, dy = random.choice([(0, 1), (0, -1), (1, 0), (-1, 0)])
        self.x += dx
        self.y += dy
        return [dx, dy]


def caminata(borracho, pasos):
    inicio = [borracho.posicion()]
    x_graph = []
    y_graph = []
    for _ in range(pasos):
        borracho.camina()
        x, y = borracho.posicion()
        x_graph.append(x)
        y_graph.append(y)
    graficar_pasos(x_graph, y_graph)
    return borracho.distancia_origen()


def simular_caminata(pasos, numero_de_intentos, tipo_de_borracho):
    # Se recibe una clase como par谩metro
    borracho = []
    distancias = []
    for i in range(numero_de_intentos):
        borracho.append(tipo_de_borracho(nombre=f'Daniel {i}'))
        simular_caminata = caminata(borracho[i], pasos)
        distancias.append(round(simular_caminata, 1))
    return distancias


def graficar_pasos(x_graph, y_graph):
    grafica = figure(title="Pasos aleatorios",
                     x_axis_label="Eje X", y_axis_label="Eje Y")
    grafica.line(x_graph, y_graph, legend_label="Coordenadas")
    show(grafica)


def main(distancias_de_caminata, numero_de_intentos, tipo_de_borracho):
    # distancias_media_por_caminata = []

    for pasos in distancias_de_caminata:
        # Del origen al punto final
        distancias = simular_caminata(
            pasos, numero_de_intentos, tipo_de_borracho)
        distancia_media = round(sum(distancias) / len(distancias), 4)
        distancia_maxima = max(distancias)
        distancia_minima = min(distancias)
        print(f'{tipo_de_borracho.__name__} caminata aleatoria de {pasos} pasos')
        print(f'Media = {distancia_media}')
        print(f'Max = {distancia_maxima}')
        print(f'Min = {distancia_minima}')


if __name__ == "__main__":
    distancias_de_caminata = [1000]
    numero_de_intentos = 1

    main(distancias_de_caminata, numero_de_intentos, Borracho_Tradicional)

Algo me dice que voy a ver la clase 10, 100, 1000 y 10聽000 veces

Muy enredado jaja. La parte que si causa mucho conflicto es la instancia borracho en la llamada de las funciones.

A pesar de que a煤n debo revisar y leer el c贸digo varias veces m谩s para comprenderlo desde la raz贸n, mi m茅todo de aprendizaje es m谩s el de 鈥減ongo manos a la obra鈥 y luego voy entendiendo.
Ha estado genial el inicio de este curso. Ya estoy enganchado, me pas茅 del n煤mero de clases a estudiar hoy.

me parece que van muy rapido, escriben codigo y ni si quiera lo entendemos

Considero que al instructor le hace falta mas orden en su manera de desarrollo, no esta bien ya que confunde bastante

Est谩 un poco pesado el c贸digo pero aqu铆 les dejo el c贸digo comentado para que lo puedan entender mejor:
Recomendaci贸n: L茅anlo de abajo para arriba.

from borracho import BorrachoTradicional
from borracho import BorrachoPitagorico
from campo import Campo
from coordenada import Coordenada

def caminata(campo, borracho,pasos):
    # obtenemos la coordenada y la guardamos en inicio
    inicio = campo.obtener_coordenada(borracho)

    # por cada paso que damos moveremos al borracho una vez.
    for _ in range(pasos):
        campo.mover_borracho(borracho)

    # distancia es un par谩metro en la clase campo que nos regresa "distancia" :v
    return inicio.distancia(campo.obtener_coordenada(borracho))




def simular_caminata(pasos, numero_de_intentos,tipo_de_borracho):
    # invocamos al borracho, ponemos el nombre porque la clase lo pide
    borracho = tipo_de_borracho(nombre='David')

    # Iniciamos coordenada con 0,0 porque nos pide en la clase
    origen= Coordenada(0,0)
    distancia =[] #guardaremos las distancias obtenidas por la simulacion

    for _ in range(numero_de_intentos):
        #ponemos al borracho en el campo, no agregamos nada porque no pide la clase
        campo = Campo()

        # iniciamos un par谩metro de la funcion
        # boracho, que recive BorrachoTracicional y origen (0,0)
        campo.a帽adir_borracho(borracho,origen)

        # a帽adimos una funcion que vamos a crear(arriba), la que nos devolver谩 la distancia
        simulacion_caminata = caminata(campo, borracho, pasos)
        distancia.append(round(simulacion_caminata,1))
    return distancia

def main (distancias_de_caminata, numero_de_intentos, tipo_de_borracho):
    # vamos a simular varias caminatas
    for pasos in distancias_de_caminata:
        # tomar谩 distancia de caminata 10, 100,.. y har谩 correr la simulacion (se implementa arriba)
        distancias = simular_caminata(pasos, numero_de_intentos, tipo_de_borracho)

        # estos son datos adicionales de estad铆sticas
        # (OJO con la diferencia entre distancia y distancias)
        distancia_media = round(sum(distancias)/len(distancias))
        distancia_maxima = max(distancias)
        distancia_minima = min(distancias)
        print(f'El borracho {tipo_de_borracho.__name__} con {pasos} pasos, tiene:')
        print(f'Distancia Maxima = {distancia_maxima}')
        print(f'Distancia Minima = {distancia_minima}')
        print(f'Distancia Media = {distancia_media} \n')


if __name__ == '__main__':
    # Vamos a hacer caminar la cantidad de pasos indicados en la lista
    # Ademas se har谩 la simulicon un determinado n煤mero de veces
    distancias_de_caminata=[10,100,1000,10000]
    numero_de_intentos = 100

    main(distancias_de_caminata, numero_de_intentos, BorrachoTradicional)

Este v铆deo tiene la PEOR pedagog铆a que he visto, muy malo explicando el desarrollo del c贸digo

No me hubiera importado que la clase durara 45 minutos mientras explicara bien paso por paso, dado que aun no dominamos bien todo lo que es POO y esta forma de escribir el codigo.

from prueba_prog_din import borracho_tra
from Campo_borracho import Campo
from Coord_borracho import Coordenada

def caminata(campo,borracho,pasos):
    inicio = campo.obtener_coordenada(borracho)

    for i in range(pasos):
        campo.mover_borracho(borracho)

    return inicio.distancia(campo.obtener_coordenada(borracho))


def simular_caminata(pasos, numero_intentos,tipo_borracho):
    borracho= tipo_borracho(nombre='Fernando')
    origen= Coordenada(0,0)
    distancias= []

    for _ in range(numero_intentos):
        campo= Campo()
        campo.anadir_borracho(borracho,origen)
        simulacion_caminata= caminata(campo,borracho,pasos)
        distancias.append(round(simulacion_caminata,1))

    return distancias


def main(distancias_caminata,numero_intentos,tipo_borracho):

    for pasos in distancias_caminata:
        distancias = simular_caminata(pasos,numero_intentos,tipo_borracho)
        distancia_media= round(sum(distancias)/ len(distancias), 4)
        distancia_maxima= max(distancias)
        distancia_minima= min(distancias)
        print(f'{tipo_borracho.__name__} caminata aleatoria de {pasos}')
        print(f'Media={distancia_media}')
        print(f'Maxima= {distancia_maxima}')
        print(f'Minima= {distancia_minima}')


if __name__ == '__main__':
    distancias_caminata=[10,100,1000,10000]
    numero_intentos= 100

    main(distancias_caminata,numero_intentos,borracho_tra)


Al profesor aqu铆 se le olvid贸 retornar en el m茅todo simular_caminata.
Para entender este tipo de c贸digos les recomiendo ir haciendo comentarios en su propio c贸digo describiendo cada acci贸n, as铆 tendr谩n una mayor idea de lo que se desea lograr. Aqu铆 les dejo mi c贸digo comentado.

from drunk import TraditionalDrunk
from field import Field
from coordinates import Coordinate


def walk(field, drunk, steps):
    # Wich is te starting position of the drunk
    startingPoint = field.getCoordinate(drunk)

    # For each step we move the drunk
    for _ in range(steps):
        field.moveDrunk(drunk)
    # Finally we get the distance between the starting position of the drunk and the final position after walk n steps
    return startingPoint.getDistance(field.getCoordinate(drunk))


def simulateWalk(steps, iterations, DrunkType):
    drunk = DrunkType(name='Henry')
    startingPoint = Coordinate(0, 0)
    distancesTraveled = []

    # We will execute the simulation n times
    for _ in range(iterations):
        field = Field()
        field.addDrunk(drunk, startingPoint)
        distanceWalked = walk(field, drunk, steps)
        distancesTraveled.append(round(distanceWalked, 1))

    return distancesTraveled


def main(stepsList, iterations, DrunkType):

    # For each step we create a simulation
    for steps in stepsList:
        distancesTraveled = simulateWalk(steps, iterations, DrunkType)

        # Formula media => SUM(elementos) / LEN(elementos)
        # round(MEDIA, 4) => 4 = 3 decimales
        midDistance = round(sum(distancesTraveled) / len(distancesTraveled), 4)
        maxDistance = max(distancesTraveled)
        minDistance = min(distancesTraveled)
        print(f'{DrunkType.__name__} random walk of {steps} steps')
        print(f'Mid distance: {midDistance}')
        print(f'Max distance: {maxDistance}')
        print(f'Min distance: {minDistance}')


if __name__ == '__main__':

    # setepList represent the number of steps that the drunk will make
    stepsList = [10, 100, 1000, 100000]

    # how many times we will execute the simulation
    iterations = 100

    main(stepsList, iterations, TraditionalDrunk)

Apoyo la moci贸n de que David es un excelente profesor, pero ser铆a bueno que se expliquen los algoritmos en gr谩ficas antes de su despliegue en c贸digo, los conceptos se explican muy bien, pero si no hay una visualizaci贸n, es dificil que se queden en la memoria a largo plazo.

esta clase de una me mando a revisar anteriores

creo que estoy solo copiando codigo porque la verdad, estoy un poco perdido en esto, y no es lo que yo esperaba de este curso la verdad.

Demasiado velocidad, no explica nada, solo escribe c贸digo. Confunde mucho con los m茅todos

Dudas: Muchas, Razon, Nose, Perdido? Si鈥

Esta muyinteresante, pero todo el codigo de golpe fue muy repentino

ENTENDIBLES LAS MOLESTIAS: pero hay distintos m茅todos para aprender por INDUCCION, como es el caso de la plataforma de Platzi.

  • primera soluci贸n: comentar el programa que proporciona el docente, o el que tu vayas desarrollando.

  • segunda soluci贸n: hacer tu propio diagrama de flujo, a partir del programa que implementa el docente.

  • tercera soluci贸n: traducir a pseudocodigo lo que vas leyendo

  • es decir, razonamiento inductivo.

  • NOTA: estos nos son cursos introductorios, mas bien son cursos complementarios para personas que tienen una base de a帽os de pr谩ctica construyendo algoritmos.

  • es entendible la molestia, pero 鈥 es la forma en que se ense帽a en este nivel.

  • talvez Platzi puede darles un curso muy basico, para los que tienen dificultad en traducir algoritmos

No puedo ni programar una borrachera con mis amigos y creen que yo podr铆a programar de la nada algo as铆? ToT
.
Ya fuera de chiste, les comparto mi c贸digo con comentarios que me ayud贸 a medio entenderlo un poco mejor.
.

from borracho import BorrachoTradicional
from coordenada import Coordenada
from campo import Campo

def caminata(campo, borracho, pasos):
    inicio = campo.obtener_coordenadas[borracho] # M茅todo creado en Campo

    for _ in range(pasos):
        campo.mover_borracho(borracho) # M茅todo creado en campo para cambiar la posici贸n y guardar las coordenadas

        return inicio.distancia(campo.obtener_coordenadas(borracho)) # M茅todo creado en Coordenada para calcular la distancia entre coordenadas


def simular_caminata(pasos, numero_de_intentos, tipo_de_borracho):
    # Me trae cualquier tipo de borracho sin importar su tipo 
    borracho = tipo_de_borracho(nombre = 'Sumatra')
    # La clase Coordenada recibe como par谩metros (x, y)
    origen = Coordenada(0, 0)
    # Diccionario que va guardando las distancias
    distancias = []

    # Por cada intento en un numero_de_intentos
    # _ quiere decir que no usamos la variable
    for _ in range(numero_de_intentos):
        campo = Campo() # Genero el campo con la clase, la cual no recibe par谩metros
        campo.agregar_borracho(borracho, origen) # M茅todo creado en campo

        simulacion_caminata = caminata(campo, borracho, pasos) # Es para ver el resultado de la simulaci贸n y usa una f(x) auxiliar
        
        distancias.append(round(simulacion_caminata, 1)) # Agregamos las distancias de la simulaci贸n de la caminata sin decimal

        return distancias


def main(distancias_de_caminata, numero_de_intentos, tipo_de_borracho):
    for pasos in distancias_de_caminata:
        distancias = simular_caminata(pasos, numero_de_intentos, tipo_de_borracho)
        
        # Suma de las distancias dividido el n煤mero de distancias, redondeado a 3 decimales. 4 = 3 en "round()"
        distancia_media = round(sum(distancias) / len(distancias), 4)

        distancia_max = max(distancias)
        distancia_min = min(distancias)

        # Imprimimos estad铆sticas descriptivas de lo que sucede
        print(f'{tipo_de_borracho.__name__} caminata aleatoria de {pasos}')
        print(f'Media = {distancia_media}')
        print(f'Max = {distancia_max}')
        print(f'Min = {distancia_min}')


if __name__ == "__main__":
    distancias_de_caminata = [10, 100, 1000, 10000]
    numero_de_intentos = 100

    main(distancias_de_caminata, numero_de_intentos, BorrachoTradicional)

veo que muchos comentarios se basan en a falta de explicacion grafica, veo que ya se corrigio, sin embargo, algo que me sucedio es que el codigo al inicio no corria, ello me abstrajo por varias horas, llevandome incluso a pensar en el codigo hasta cuando almorzaba, despues de revisar todo nuevamente por 鈥榥鈥 vez, encontre la solucion. Moraleja, sigamos intentando, repasemos los pasos hasta que calen en nuestro pensamiento, ningun curso es perfecto, nuestro esfuerzo lo hace!

A veces, de verdad caen en lo negligente. Se supone que nos est谩n capacitando en temas que sus capacitadores deber铆an estar capacitados.

Opte por ir a ver otros tutoriales en youtube y cursos de pago, ya que tengo la misma impresi贸n de los compa帽eros, no se explica la l贸gica de por que hacer las cosas de una manera clara, se supone nos estamos formando. He visto y aprobado los primeros 4 cursos de la ruta de Data Sciene pero con este curso me siento muy desanimado.

Saludos amigos. He le铆do comentarios sobre lo dif铆cil que han sentido esta clase en particular, y los entiendo. Como dijo David en un video previo, 茅l no suele usar diagramas, va dise帽ando la soluci贸n conforme programa, y cada uno puede usar una metodolog铆a diferente. A mi me funciona desarrollar el c贸digo en un Jupyter Notebook que me permita ir interactuando con el c贸digo conforme voy avanzando. Se los sugiero si quiere poder probar bloques de c贸digo especifico en lugar de ejecutar todo el bloque cada vez que quieran probar como funciona.

Les comparto mi implementaci贸n con documentaci贸n en cada funci贸n, parar que vayan viendo como documento cada funci贸n y s茅 en todo momento que hace la funci贸n que voy llamando:

import random

class Borracho:

    def __init__(self, nombre):
        self.nombre = nombre

class BorrachoTradicional(Borracho):
    
    def __init__(self, nombre):
        super().__init__(nombre)

    def caminar(self):
        return random.choice([(0,1), (1,0), (0,-1), (-1,0)])

class Coordenada:

    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def mover(self, delta_x, delta_y):
        return Coordenada(self.x + delta_x, self.y + delta_y)
    
    def calcular_distancia(self, otra_coordenada):
        delta_x = self.x - otra_coordenada.x
        delta_y = self.y - otra_coordenada.y

        distancia = ((delta_x ** 2) + (delta_y ** 2)) ** 0.5

        return distancia

class Campo:

    def __init__(self):
        self.coordenadas = {}
    
    def agregar_borracho(self, borracho, coordenada):
        self.coordenadas[borracho] = coordenada
    
    def mover_borracho(self, borracho):
        delta_x, delta_y = borracho.caminar()
        coordenada_actual = self.coordenadas[borracho]
        nueva_coordenada = coordenada_actual.mover(delta_x, delta_y)

        self.coordenadas[borracho] = nueva_coordenada
    
    def obtener_coordenada(self, borracho):

        return self.coordenadas[borracho]

def caminata(campo, borracho, pasos):
    """Este m茅todo ejecuta la caminata del borracho, deplazandolo 
     sobre campo la cantidad de pasos definidos en los argumentos

    Arguments : 
        campo : Instancia de la clase Campo
        borracho : instancia de la clase BorrachoTradicional
        pasos : cantidad de pasos que el borracho caminara sobre
            el campo
    
    Returns : 
        desplazamiento : Distancia que se ha movido el borracho
    """
    inicio = campo.obtener_coordenada(borracho)

    for _ in range(pasos):
        campo.mover_borracho(borracho)
    
    desplazamiento = inicio.calcular_distancia(campo.obtener_coordenada(borracho))
    
    return desplazamiento

def simular_caminata(pasos, intentos, borracho):
    """Este m茅todo simula la caminata del borracho ejecutando 
    el m茅todo caminata.

    Ejecuta una caminata por cada intento especificado, y agrega
    el resultado de la caminata a la lista distancias. 

    Arguments : 
        pasos : La cantidad de pasos que el borracho caminar谩 en 
            cada intento
        intentos : La cantidad de veces que se simulara la caminata
        borracho : instancia de la clase BorrachoTradicional
    
    Returns :
        distancias : Lista de las distancias recorridas en cada 
            simulaci贸n
    """
    origen = Coordenada(0, 0)
    distancias = []

    for _ in range(intentos):
        campo = Campo()
        campo.agregar_borracho(borracho = borracho, coordenada = origen)
        caminata_borracho = caminata(campo, borracho, pasos)
        distancias.append(round(caminata_borracho, 1))
    
    return distancias

def main(distancias_de_caminata, intentos, borracho):
    """Este m茅todo ejecuta la simulaci贸n de la caminata e imprime 
    la m谩xima distancia recorrida, la distancia media y la distancia minima 
    en los diferentes intentos. 

    Arguments : 
        distancias_de_caminata : lista con la cantidad de pasos que queremos que
            el borracho camine en cada simulaci贸n
        intentos : cuantas veces se va a simular cada caminata
        borracho : instancia de la clase BorrachoTradicional
    """
    for pasos in distancias_de_caminata:
        distancias = simular_caminata(pasos, intentos, borracho)
        distancia_media = round((max(distancias) / len(distancias)), 4)
        distancia_maxima = max(distancias)
        distancia_minima = min(distancias)
        print(f'La distancia media que el borracho {borracho.nombre} se movio es {distancia_media}')
        print(f'Lo m谩ximo que el borracho se movio es {distancia_maxima}')
        print(f'Lo m铆nimo que el borracho se movio es {distancia_minima}')

if __name__ == '__main__':
    distancias_de_caminata = [10, 100, 1000, 10000]
    intentos = 100
    nombre_borracho = input('Define el nombre del borrachito que va a caminar: ')
    main(distancias_de_caminata, intentos, BorrachoTradicional(nombre_borracho))

Es una clase un poco complicada de entender ya que se detienen muy poco a explicar el c贸digo.
Comparto mis apuntes donde en una secci贸n trato de explicar el c贸digo, espero que sean de ayuda. 鉂わ笍

https://github.com/abdielgv162/Estadistica_Computacional/tree/master#explicacion-de-simulaci贸n

Hola, a mi me cost贸 trabajo hacerlo y lo hice desde cero, lo logr茅 con una l贸gica diferente pero aplicando todos los conceptos, dem谩s de que exporta los resultados del camino de borrachos a un archivo CSV

<
import random
import csv

class persona():
    def __init__(self, nombre):
        self.nombre = nombre
        self.posicion = (0,0)
 
    def saluda(self):
        print(f'Hola mi nombre es {self.nombre} y estoy en {self.posicion}')
   
class borracho(persona):
    def __init__(self, nombre, pasos, intentos):
        super().__init__(nombre)
        self.pasos = pasos
        self.intentos = intentos

    def caminar_borracho(self):
        self.direccion_paso = random.choice([(1,0),(0,1),(-1,0),(0,-1)])
        self.recorrido_x = []
        self.recorrido_y = []
        self.contador_pasos = []
        self.contador_intentos = []
        self.nombre_borracho = []
        self.tipo_de_paso = []


        for i in range (self.intentos):
            self.nueva_x = self.posicion[0]
            self.nueva_y = self.posicion[1]
            self.nombre_borracho.append(self.nombre)
            self.recorrido_x.append(self.posicion[0])
            self.recorrido_y.append(self.posicion[1])
            self.contador_intentos.append(0)
            self.contador_pasos.append(0)
            self.tipo_de_paso.append('INICIO_DEL_RECORRIDO')

            for j in range (self.pasos):
                if j+1 == self.pasos:
                    self.tipo_de_paso.append('FIN_DEL_RECORRIDO')
                else:
                    self.tipo_de_paso.append(f'PASO_{j+1}')
                self.nombre_borracho.append(self.nombre)
                self.contador_intentos.append(i+1)
                self.contador_pasos.append(j+1)
                self.direccion_paso = random.choice([(1,0),(0,1),(-1,0),(0,-1)])
                self.recorrido_x.append(self.nueva_x + self.direccion_paso[0])
                self.recorrido_y.append(self.nueva_y + self.direccion_paso[1])
                self.nueva_x = self.nueva_x + self.direccion_paso[0]
                self.nueva_y = self.nueva_y + self.direccion_paso[1]   


    def saluda(self):
        super().saluda()
        print('Creo que estoy borracho')

class observador_del_borracho(borracho,persona):
    def __init__(self, nombre, pasos, intentos):
        super().__init__(nombre, pasos, intentos)
        pass

    def exportar_csv_rows(self):
        self.data_base_1 = [self.nombre_borracho, self.tipo_de_paso ,self.contador_intentos, self.contador_pasos, self.recorrido_x, self.recorrido_y ]
        print(self.data_base_1)
        # with open('file4.csv','w') as f:
        #     for raw in self.data_base_1:
        #         for x in raw:
        #             f.write (str(x) + ',')
        #         f.write('\n')
        with open('camino_de_borrachos.csv','w') as f:
            fieldnames = ['NOMBRE_BORRACHO', 'TIPO_DE_PASO' ,  'INTENTOS', 'PASOS', 'COORDENADA_X', 'COORDENADA_Y']
            writer = csv.DictWriter(f, fieldnames=fieldnames)
            writer.writeheader()
            for i in range( len(self.recorrido_x) ):
                writer.writerow({'NOMBRE_BORRACHO': self.nombre_borracho[i], 'TIPO_DE_PASO': self.tipo_de_paso[i] , 'INTENTOS':self.contador_intentos[i], 'PASOS':self.contador_pasos[i], 'COORDENADA_X':self.recorrido_x[i], 'COORDENADA_Y':self.recorrido_y[i]})
                pass


def run():
    persona_1 = observador_del_borracho('Fernando', 10 , 2)
    persona_1.saluda()
    persona_1.caminar_borracho()
    persona_1.exportar_csv_rows()


if __name__ == "__main__":
    run()

Dejo la misma imagen que en el video anterior, quiza ayuda a entender mejor el codigo

(

Si tienen alguna duda de por qu茅 no les funciona el c贸digo como deber铆a o les manda error, adjunten una captura del problema en su pregunta. Esto es para poder ayudarlos m谩s r谩pido.

Revisi贸n de lo que hace el programa.

alguien me pasa el programa que no se donde esta mi error ???

Les digo la verdad? La 煤nica forma de aprender esto es haciendo ejercicios. Uno puede entender el concepto y todo, pero de ah铆 a saber hacerlo, falta bastante practica.

Un poco confuso, pero vamos a dedicarle un tiempo a enteder todo el codigo.

Todos se quejan de la explicaci贸n, a esas personas les digo solo es un ejemplo m谩s bien busquen un reto y resu茅lvanlo o implementen su propia versi贸n ya vieron como funciona, les ser谩 f谩cil hacer su versi贸n

Que bueno que era un ejercicio sencillo si no imaginate XD

Es un algoritmo algo complejo y mas en un lenguaje que apenas se esta aprendiendo, gracias a varios compa帽eros que han publicado sus analisis se ha logrado entender mejor.

Esta clase estuvo poco explicativa, es cierto que muchas delas cosas se han explicado en m贸dulos anteriores pero considero que la diferencia de 鈥溾渘ivel鈥濃 entre el video anterior y este es DEMASIADO ALTA jajjajaj, aun asi intent茅 entender y creo que algo al menos me entr贸. fue interesante como agrega las cosas antes de crearlas xd

La verdad siento que si estas tomando este curso es porque ya sabes leer c贸digo, no se me hace complicado entender el como funciona, o para que tal cosa, solo escribelo y genera comentarios de lo que entiendes, as铆 ser谩 mucho mejor t煤 aprendizaje.

el codigo del profe necesita ser refactorizado para hacerlo mas simple, igual esta bueno como implementa composici贸n pero deberia tipar los datos para que se entienda mejor鈥

si no tipas los datos de python, esto se vuelve un caos al volver a ver tu codigo o tratar de entenderlo

Soy muy principiante en POO, pero no se si es el paradigma en si
comparado con la programaci贸n funcional, pero me da que son
demasiadas funciones, muchas de las cuales puede que no se
usen para, mover un abjeto. ademas de la complejidad de entender en profundidad la POO, tal vez deberia ir en la ruta un
curso mas profundo de POO, que lo que se ve en el curso anterior antes de poner un aplicacion tan compleja, aunque
es intuitivo lo que el profe hace es dificil de poner el reto de hacerlo uno mismo antes de ver la demostracion.

[Diagrama de flujo]

Inicio
Importar m贸dulos
Definir funci贸n "caminata"
Definir funci贸n "simular_caminata"
Definir funci贸n "graficar"
Definir funci贸n "main"
Inicializar lista "distancias_media_por_caminata"
Bucle 鈥渇or鈥 a trav茅s de distancias de caminata
Simular varias caminatas de borracho
Calcular distancias media, m谩xima y m铆nima
Agregar distancia media a "distancias_media_por_caminata"
Graficar resultados
Mostrar gr谩fica
Fin

La comprensi贸n de esta clase se facilita si se tiene experiencia previa con la programaci贸n orientada a objetos en alg煤n lenguaje como Java, dado que el profesor David estructura su programa muy af铆n a las reglas que all铆 se siguen (recomendar铆a como ejercicio replicar el c贸digo en Java y ver谩n c贸mo todo es much铆simo m谩s claro y solucionar谩 dudas sobre el uso de clases y abstracciones en funciones).

Dir铆a que en Python es incluso m谩s r谩pido y sencillo hacer una implementaci贸n como un script (sin usar paradigma POO) para este problema pero siento que lo que nos quiere ense帽ar el profesor sin ir a mucho detalle es que en las simulaciones y tambi茅n en la inteligencia artificial debemos delimitar (para una mayor comprensi贸n) qui茅n es nuestro agente, cu谩l es el entorno del agente y cu谩l es su comportamiento; adem谩s de implementar algunas funcionalidades de evaluaci贸n.

El proceso de abstracci贸n es muy importante a la hora de realizar el c贸digo, incluso la clase que se incluy贸 despu茅s no es lo suficientemente clara, porque explica la idea pero no explica la implementaci贸n.
Todos los cursos con Aroesti son iguales, realmente ser profesor no es lo suyo.

Es dificil enternder viendo c贸digo y escuchando al profesor, hace falta flujogramas.

Pague la suscripci贸n a Platzi para que el aprendizaje sea m谩s sencillo y me ayuden con la documentaci贸n y mejor explicaci贸n de lo que voy aprendiendo, y no recurrir a fuentes externas pues para eso no me hace falta gastar dinero ya que en internet hay informaci贸n gratis pudiendo aprender por mi cuenta

Facundo explica con mayor claridad.

De acuerdo con un par de comentarios que le铆. A esta clase le falta la explicaci贸n de la arquitectura del programa. Creo que se entiende que David la construye sobre la marcha, per ser铆a muy bueno que hubiera esa estructura vista de una forma m谩s gr谩fica ANTES de empezar a programar.
En su momento as铆 aprend铆 a programar por primera vez y (al menos para quien sea como yo) es mucho m谩s f谩cil entender de esa forma.

estuvo como pesada la clases, y los nombres de las variables confunden mucho鈥ero a seguirle

Utilizar el under score en un ciclo, es para indicar que no vamos a utilizar esa variable.

Podemos hacer, que los objetos que inicializamos, puedan variar, solo con la referencia de un par谩metro.

Tambi茅n puedes poner _ como nombre xd

Hay que generar mucho, para estudiar una base de resultados.

La idea de las simulaciones, es correrlas muchas veces.

AYUDA, esto no es un meme!

Un algoritmo mas interesante puede hacerse con

import numpy as np
import numpy.random as rd
# random orientation converted from degrees to radians
direction = rd.uniform(low=0, high=360) * np.pi / 180
x = np.cos(direction)
y = np.sin(direction)

esto dar铆a un aspecto circular al movimiento.

Les recomiendo este video donde explican la misma idea de Caminos borrachos pero m谩s sencillo y de varias formas para luego comprender mejor el algoritmo que uso el profesor en esta clase.
https://www.youtube.com/watch?v=BfS2H1y6tzQ

Pienso que se deber铆a tomar un poco m谩s de tiempo para explicar los c贸digos , el objetivo no es entregar un algoritmo, el objetivo es que todos los que estamos realizando este curso podamos acceder a su entendimiento

David es excelente profesor y es brillante al momento de explicar los conceptos y concatenar ideas. Codea como excelente ingeniero y usa las palabras como excelente abogado. Sin embargo, muchos estudiantes somos visuales y es ah铆 cuando los modelos, diagramas o esquemas nos ayudan a entender sist茅micamente (holisticamente, como un todo) aquellos conceptos y luego el c贸digo que lo operativiza.

like fredie vega

comenta david aroesti

A煤n falta mucho para llegar al deep learning asi que sin miedo compa帽eros鈥stamos en las puertas de hadeesss!!

Es horrible ver c贸mo alguien programa sin explicar bien鈥 me quedo con la teor铆a 馃槙

Hola.
Leyendo los comentarios, las principales quejas van sobre que no se presentan ayudas visuales y diagramas. Considero que con lo que hemos aprendido hasta aqu铆 (siguiendo la ruta de aprendizaje), es suficiente para abordar una clase como esta. Si no se entiende el algoritmo a la primero, podemos escribir los comentarios de profe David en el c贸digo; con l谩piz y papel correr el c贸digo con los primeros valores y ah铆 mismo trazar nuestros diagramas, entre otros m茅todos.
Creo que es de mucho m谩s provecho el que nosotros mismos dise帽emos nuestros propios m茅todos de comprensi贸n de ejercicios a que se nos explique de manera ultra detallada cada parte del c贸digo.
Soy nuevo programando, y el entender esto es perfectamente alcanzable. 脕nimo!!!

Buenas, cuando ejectuo el codigo, tal como esta en el video me resulta
鈥橳ypeError: camina() takes 0 positional arguments but 1 was given鈥

Me cost贸 un poco entender 茅ste algoritmo, tuve que ver las clases varias veces para poder implementarlo correctamente. Pero lo logr茅! 馃榿 Vamooooooossss!

a probar 馃槈

Pffff de verdad que desde un curso de Ardila que no me encabronaba tanto. Es increible como a temas que fundamentales les es imposible aterrizarlos en su complejidad. Con este tipo de manifestaciones catedr谩ticas hacen quedar en rid铆culo su postura contra la universidad a la par que hacen ver el promedio de lo que forman es empleados copiac贸digo

wow鈥 es lo mas complejo que he hecho

Al momento de crear el objeto tipo_de_borracho(nombre==鈥楧avid鈥), deberia ser 鈥榥ame鈥 en lugar de nombre ya que el argumento de la clase BorrachoTradicional es name y al hacer la herencia de Borracho (la clase padre) convierte ese 鈥榥ame鈥 en self.nombre:

lass Borracho:
    """Clase para los borrachos."""

    def __init__(self, nombre):
        """Inicializa el borracho."""
        self.nombre = nombre


class BorrachoTradicional(Borracho):
    """Clase para el borracho tradicional."""

    def __init__(self, name):
        """Inicializa el borracho tradicional."""
        super().__init__(name)  <-------------------

    def camina():
        """Retorna una tupla.

        Calcula el valor aleatorio con la direccion
        a donde se mueve el borracho.
        """
        return random.choice([(0, 1), (0, -1), (1, 0), (-1, 0)])```

Un Algoritmo algo complejo, toca la verdad sentarse y enteder cada clase que lo hace. La verdad estoy aprendiendo mucho

Entendido y vamos por el borrado de David

Wow鈥oca ver esto m谩s de una vez e interiorizarlo.

porque usa el init a principio de las funciones

Waooo! 鈥 mucho que procesar

Una pregunta, al importar las clases de los dem谩s archivos es necesario que estos est茅n en la misma carpeta, que est谩n abiertos en simultaneo en el editor de c贸digo o cu谩l es esa condici贸n para que ese archivo al que traemos las clases reconozca ese 鈥渋mport鈥?

Yo la verdad estoy aprendiendo a manejar python, me cuesta mucho entenderle David Aroesti, no entiendo muchas funciones y la l贸gica detr谩s del c贸digo - no entiendo tampoco porque no se explica un poco del proceso mental para llegar a la soluci贸n del c贸digo y porque se tomar铆a ese camino y no otro. Siento que es muy bueno en lo que hace pero quiz谩s falta bajarle un cambio e ir un poco m谩s despacio, quiz谩s lo que se hace sea intuitivo para alguien que tenga algo de conocimiento, pero para mi seguirle el paso y entender realmente lo que estoy haciendo a sido muy dif铆cil.

Notas:

  • Importar modulo desde un programa exterior:
from <nombre_programa> import <modulo>
  • _ 鈫 no vamos a utilizar la variable
  • Generamos la simulaci贸n varias veces para obtener una media (tendencia)

Picante borracho

me perd铆 馃槮

Por que se accede al atributo nombre usando el name?

Es una buena pr谩ctica, se hizo pesado sobre todo porque lleg贸 un punto en que copiaba el c贸digo sin saber qu茅 hac铆a, pero despu茅s de un rato de estarlo analizarlo, lo comprend铆. El contenido me gust贸

Para la gente que tengais Python 3.8.X y tengais problemas al ejecutar el codigo os recomiendo que los imports los hagais de la siguiente manera:

from .person import Person, BasicPerson
from .coordinate import Coordinate
from .canvas import Canvas

Finalmente en el terminal que navegueis en la carpeta padre de donde tengais el proyecto y ejecuteis (el $ es la representaci贸n de que lo ejecuto en el terminal):

$ [python_path] -m [directorio_del_proyecto].[archivo_principal]

En mi caso queda de la siguiente manera:

$ py -m random_paths.__init__