Facundo Nicolás García Martoni
ProfesorArnulfo Rojas Jimenez
Que diferente se ven, este sería uno de los recorridos para el borracho en 100,000 pasos.
johan Stever Rodriguez Molina
Subo la apuesta hasta el 1000.000 de pasos jeje.
(
¿Cómo ejecutar el código y corregir errores comunes?
Es frecuente encontrarse con errores al ejecutar código, pero cada uno es una oportunidad para aprender. Para ejecutar un script de Python, abre una terminal, navega a la carpeta del proyecto y usa el comando python script.py. Si aparece un error, no te preocupes. En este caso, los errores encontrados fueron:
Nombre no definido: En el código se intentó utilizar la función rango, cuando debería ser range(). Corrige el nombre y vuelve a intentarlo.
Número incorrecto de argumentos: Al definir métodos dentro de una clase en Python, siempre se debe incluir self como primer parámetro. Corrige esto para evitar errores de argumentos.
Estos pasos básicos te ayudarán a ejecutar tu código correctamente y aprender qué mejorar cuando se presenten fallos.
¿Cómo interpretar los resultados de la simulación de caminos aleatorios?
Al ejecutar la simulación de caminos aleatorios, obtienes resultados como la media, distancia máxima y mínima de pasos. En este ejemplo:
Estos resultados muestran cómo, aun con eventos aleatorios incorporados, la simulación se comporta de manera consistente con lo esperado estadísticamente. Cada ejecución te dará resultados ligeramente diferentes debido a su naturaleza estocástica.
¿Cómo graficar los datos con la librería Bokeh?
Visualizar los datos puede brindarte una mejor comprensión de los resultados. Para esto, usamos la librería Bokeh, recomendada por su facilidad de uso:
Configura un entorno virtual para no instalar la librería de manera global:
python -m venv venv source venv/bin/activate # Linux/MacOS .\venv\Scripts\activate # Windows
Instala Bokeh:
pip install bokeh
Importa y utiliza Bokeh en el código:
from bokeh.plotting import figure, show def graficar(x, y): plot = figure(title="Camino aleatorio", x_axis_label='Pasos', y_axis_label='Distancia') plot.line(x, y, legend_label="Distancia Media") show(plot)
Ejecuta tu código para ver la gráfica después de haber añadido los pasos para los ejes.
¿Qué reto puedes intentar para continuar el aprendizaje?
Como ejercicio práctico, te animamos a modificar la clase del borracho o crear una nueva implementación. Varía el comportamiento, como el incremento en los pasos hacia cualquier dirección, y observa cómo afectas la simulación.
Así, entenderás cómo los ajustes en tu código pueden alterar los resultados, y compartir tus ajustes con la comunidad enriquecerá tu comprensión. Si tienes dudas o comentarios, usa los foros para obtener ayuda. ¡Continúa explorando y aprendiendo!
Facundo Nicolás García Martoni
ProfesorArnulfo Rojas Jimenez
Que diferente se ven, este sería uno de los recorridos para el borracho en 100,000 pasos.
johan Stever Rodriguez Molina
Subo la apuesta hasta el 1000.000 de pasos jeje.
(
Angel Armando Martínez Blanco
Iván Ricardo Bohórquez Basto
Muchas gracias por tu aporte, finalmente con parte de tu código logré pasar a graficar los caminos de borracho. Me demoré porque tomé como referentes otro par de aportes de otros compañeros. Sin embargo el tuyo fue el definitivo.
Gracias de verdad :D
Jesús Joel Sarabia Félix
Gracias!
Juan David Vergara Torres
María José Medina
Hola! que buen aporte. Estuve haciendo algo parecido a lo que hiciste y te tengo una pequeña sugerencia, en la función graficar en vez de hacer que acepte el parámetro pasos para graficar el último elemento de la lista, puedes sustituir pasos-1 por simplemente -1 debido a una propiedad del slicing .
De esa manera se veria mucho mejor el código:
[0:-1:pasos-1] --> [0:-1:-1]
Referencias: Stack OverFlow
Juan David Vergara Torres
Jaime Eduardo González Meléndez
Creo que a esta parte del curso le hace falta una implementación antes de Caminos Aleatorios, algo más simple como simular una partida de dados o algún juego de mesa sencillo. Por mucho que David vaya guiando, no es una buena práctica dar brincos sensibles de complejidad. Me refiero a que para explicar este problema necesitaron 3 lecciones (de más de 10 minutos) cuando sus ejemplos previos son explicados, casi sin excepción, en 1 lección. Un problema explicado en 2 lecciones hubiera sido un salto más prudente, o explicar el mismo problema en diferentes capas de complejidad (por ejemplo, comenzar explicándolo de manera iterativa y después añadir POO), así los alumnos con bases sólidas previas podrían brincar a las lectures con POO y los que lo necesiten, podrían comenzar con el caso más sencillo.
En este tutorial el profesor explica todo pero haciendo una introducción partiendo de una solución sencilla que se entiende con facilidad, después en vídeos posteriores propone soluciones más sofisticadas. La solución está en javascript, pero el punto es la manera en que propone su approach: Coding Challenge #52: Random Walker
Esa es mi opinión, con base en mi experiencia (también soy profesor).
Esta es mi solución a la variación solicitada en la lecture:
Enrique Villamizar
Totalmente de acuero:
William Chamorro
De acuerdo.
Juan Manuel Roa Mejia
Haciéndole unos pequeños cambios a la implementación se pueden ver los caminos que harían n borrachos con k cantidad de pasos xD.
Para hacer la implementación decidí partir del objetivo central y hacerlo desde cero. Creo que así se puede entender mejor el propósito y la funcionalidad del algoritmo presentado en la clase.
Juan Manuel Roa Mejia
Los rombos rojos, son los puntos donde finaliza la caminata de cada borracho. .
Carlos Daniel Pimentel Díaz
Hola dot_roa, ¡están geniales los resultados! Sería interesante que nos compartieras el código que usaste para realizar la implementación. Gracias.
Iván Ricardo Bohórquez Basto
¡Por fin! Han sido valiosos los apuntes y aportes de varios compañeros, especialmente compartiendo la manera en que generaron la gráfica del camino aleatorio del borracho. Confieso que hubo un momento en que me desanimé un poco. Sin embargo dejé pasar algunos días, vi videos de otros cursos y retomé el ejercicio. Finalmente tengo estas 2 gráficas del camino aleatorio, para los mismos parámetros, se ven 2 comportamientos aleatorios muy distintos.
Daniel Andrés Giraldo Benites
muchos aportes son de bastante ayuda.... le dan un valor añadido a Platzi
Angelica Landazabal
Mi propuesta se llama BorrachoDoblado al cual tiene más probabilidad de moverse hacía arriba o hacía la derecha sumando una unidad a su coordenada actual. Sin embargo, cae en la opción de moverse hacía abajo o a la izquierda, se modificará en 2 unidades su coordenada actual.
class BorrachoDoblado(Borracho): def __init__(self, nombre): super().__init__(nombre) def camina(self): return random.choice([(0,1),(0,1),(0,-2),(1,0),(1,0),(-2,0)])
La gráfica resultante con distancias_de_caminata = 10000 y numero_de_intentos = 1000 es la siguiente:
Daniel Andrés Giraldo Benites
excelente aporte ... me encanta ver todas las variantes que pueden crearse con un solo ejercicio
En mi caso agregué 2 tipos de borrachos mas, uno muy mareado, que de repente no avanza es decir, una delta de (0,0) y otro que nunca va a la izquierda:
Me llamó la atención que al quitarle una dirección la curva se vuelve lineal.
De paso grafiqué los caminos:
Si alguien le sirve aquí mi código: https://github.com/raag/caminos_aleatorios
Ricardo Moreno
Este es mi resultado:
codigo -> https://colab.research.google.com/drive/1ZgW6XIAWV91Ktx89PUzvjshJCF1JHOCI
Yeison Tapasco
Bro Muchas gracias no entendia como graficar los mapas!!!
Yeison Tapasco
Bro muchas gracias no entendia como graficar los mapas!!!!
Enrique Villamizar
Borracho aguardientero.
Luis Fernando Pedroza Taborda
Wow Enrique, le quedo excelente, por casualidad que tipo de grafico es?
Enrique Villamizar
Ashly Loren Aguilar Gutiérrez
consulta, como puedo publicar una imagen en aportes ? no puedo
Edgar Ramón González Contreras
Tu imagen tiene que estar descargada y en el botón que dice Imagen desde ahí agregas la imagen.
Si intentas compartir una imagen de internet, usas esto ![]() en los paréntesis ahí agregas el link de la imagen que vayas a compartir (esta se usa si es una imagen de internet).
CRISTIAN BARBERO PÉREZ
Para mí lo más fácil es arrastrarla desde tu carpeta de archivos hacia el cuadrito del comentario
Jose Colmenares
Bueno, en mi caso: Pausa y a revisar todo lo que he aprendido de Python hasta ahora.
Pedro Alejandro Rodríguez García
Este fue el camino de 2 borrachos con 1,000:
con 10,000:
con 1,000,000 de pasos:
Pedro Alejandro Rodríguez García
Daniel Andrés Giraldo Benites
jajajjaa.. si le seguimos aumentando pasos el que va a terminar borracho es tu procesador
Esteban Pablo Hernández Ramírez
2 noches para pasar de este video...
Guillermo Sánchez Martinez
yo quebrandome la cabeza con tres borrachos simples y veo que hay quien saco gráficas que parecen mapas >.<
Daniel Alejandro Moreno Astorga
porque comparten esos mapas con manchas si la cosa es una linea no mas. pasos vs distancia
Pedro Alvarado Garcia
Porque el profesor aroesti solo grafico la distancia media, y los compañeros en la sección de aportes modificaron su código para que en vez de la distancia media, grafique todo el camino.
Kevin Eduardo Villanueva Menichetti
Con 100000 pasos
Rafa Romero
esta clase casi no le entendi!! :(
Kevin Morales
Puedes verla las veces que sea necesario hasta que puedas entender o preguntar qué es lo que no entiendes :)
Angel Solis
¿Qué no entendiste? igual puedo ayudar
Natalia Gonzalez Palacios
Miguel Torres
Hola, @nataliagonzalezpalacios. :D
¿No los muestra completamente o donde debería ir el valor aparece vacío?
Natalia Gonzalez Palacios
Hola Miguel no me sale nada ejecuta el codigo pero en la terminal no me sale ningùn error ni nada simplemente ejecuta el codigo y termina sin hacer nada no me muestra los print
Les presento al Drogado, la variante que pensé para resolver el reto de esta clase 😂 hace caminos aleatorios con floats en lugar de ints. Aquí el código y una gráfica de cada trayecto, dependiendo si hizo 10, 100, 1000 o 10000 pasos:
class Drogado(Borracho): def __init__(self, nombre): super().__init__(nombre) def camina(self): return ( random.choice([ (random.random(), random.random() * -1), (random.random() * -1, random.random()), (random.random() * -1, random.random() * -1), (random.random(), random.random()), ]) )
Para los que se están preguntando como hacer los caminitos aquí les dejo un código corto usando las mismas clases implementadas BorrachoTradicional Campo y Coordenada
from borracho import BorrachoTradicional from coordenada import Coordenada from campo import Campo from bokeh.plotting import figure, show def main(distancia, inicio, borracho): campo = Campo() campo.anadir_borracho(borracho, inicio) #poner un borracho en origen ejecutar_caminata(campo, borracho, distancia) def ejecutar_caminata(campo, borracho, distancia): x_arreglo = [] y_arreglo = [] x_arreglo.append(campo.obtener_coordenada(borracho).x) y_arreglo.append(campo.obtener_coordenada(borracho).y) for _ in range(distancia): campo.mover_borracho(borracho) #se actualiza las coordenadas del borracho x_arreglo.append(campo.obtener_coordenada(borracho).x) y_arreglo.append(campo.obtener_coordenada(borracho).y) graficar(x_arreglo, y_arreglo) def graficar(x, y): figura = figure() figura.line(x, y) show(figura) if __name__ == '__main__': distancia = 1000000 inicio = Coordenada(0,0) borracho = BorrachoTradicional('Angel') main(distancia, inicio, borracho)
solo tendrán que modificar distancia para hacer sus gráficas más grandes ;)
Esta es la gráfica con un millón de pasos
Esta caminata fue de 5000 pasos. Inicio punto negro, final punto rojo; abajo está el ajuste del código para este tipo de gráfica. Me tome 6 horas entre entender el código y hacer la modificación, pero valió la pena el proceso.
from borracho import BorrachoTradicional from campo import Campo from coordenada import Coordenada from bokeh.plotting import figure, show def caminata(campo, pasos, tipo_de_borracho): borracho = tipo_de_borracho(nombre='David') origen = Coordenada(0, 0) campo.anadir_borracho(borracho, origen) coordenadas_x=[] coordenadas_y=[] coordenadas_x.append(origen.x) coordenadas_y.append(origen.y) for _ in range(pasos): campo.mover_borracho(borracho) coordenadas_x.append(campo.obtener_coordenada(borracho).x) coordenadas_y.append(campo.obtener_coordenada(borracho).y) return (coordenadas_x, coordenadas_y) def graficar(x, y,pasos): grafica = figure(title='Random Walks',x_axis_label='x axis', y_axis_label='y axis') grafica.line(x, y, legend_label='walk', color='yellowgreen',name='juan') #recorrido # gráfica la línea inicial de movimiento porque no se puede graficar un punto grafica.line(x[0:2],y[0:2],color='black',line_width=10) grafica.line(x[-3:-1],y[-3:-1],color='red',line_width=10) #punto final y final-1 grafica.line(x[0:-1:pasos-1],y[0:-1:pasos-1]) #linea de punto inicial a punto final show(grafica) def main(pasos, tipo_de_borracho): campo=Campo() coordenadas_x, coordenadas_y = caminata(campo, pasos, tipo_de_borracho) graficar(coordenadas_x, coordenadas_y,pasos) if __name__ == '__main__': pasos = 5000 main(pasos, BorrachoTradicional)
Hola, las dos expresiones no son equivalentes, porque para pintar la linea tengo que pasar la coordenada inicial y la coordenada final, sólo son dos puntos y la expresión que mencionas no hace eso, la he probado y arroja una lista vacia.
Ahora he cambiado por esta que es mejor para mi:
grafica.line(x[0:pasos:pasos-1],y[0:pasos:pasos-1])
Cuentame si lo pudiste hacer cómo lo mencionas y a lo mejor lo estoy aplicando mal.
Hola Luis. Solo saque las coordenadas y las guarde en dos listas, una para x y otra para y. y cree otra función para graficarlas, así como en el primer ejercicios grafico.
def caminata(campo, borracho, pasos): inicio= campo.obtener_coordenada(borracho) x_vals=[] y_vals=[] x_vals.append(inicio.x) y_vals.append(inicio.y) for i in range(pasos): x_act=x_vals[i] y_act=y_vals[i] campo.mover_borracho(borracho) p=campo.obtener_coordenada(borracho) x_vals.append(p.x) y_vals.append(p.y) graficarpasos(x_vals,y_vals) return inicio.distancia(campo.obtener_coordenada(borracho)) def graficarpasos(x_vals,y_vals): fig=figure() #genera la figura fig.line(x_vals,y_vals,line_width=2) show(fig)
campo.py
class Campo: def __init__(self): self.coordenadas_borrachos={} def add_borracho(self, borracho, coordenada): self.coordenadas_borrachos[borracho]=coordenada def mover_borracho(self, borracho): #cuando el borracho camina, devuelve una tupla #por esto... dx,dy=borracho.camina() coord_actual = self.coordenadas_borrachos[borracho] coord_actual.mover(dx,dy) def get_coord(self, borracho): return self.coordenadas_borrachos[borracho]
coordenada.py
class Coordenada: def __init__(self, x,y): self.x = x self.y = y def distancia(self, NxtCoord): d_x= self.x - NxtCoord.x d_y= self.y - NxtCoord.y return (d_x**2 + d_y**2)**0.5 def mover(self, d_x, d_y): self.x = self.x + d_x self.y = self.y + d_y
camino_aleatorio.py
from borracho import BorrachoTradicional from campo import Campo from coordenada import Coordenada from bokeh.plotting import figure, output_file, show if __name__ == "__main__": dis_de_caminata = int(input('Cuál es el número de pasos que dará el borracho?: ')) Filomeno = BorrachoTradicional('Filomeno') obj_coord_1 = Coordenada(0,0) recorrido1_en_x=[] recorrido1_en_y=[] Pancracio = BorrachoTradicional('Pancrácio') obj_coord_2 = Coordenada(0,0) recorrido2_en_x=[] recorrido2_en_y=[] campo = Campo() campo.add_borracho(Filomeno,obj_coord_1) campo.add_borracho(Pancracio,obj_coord_2) i=0 while i<=dis_de_caminata: posicion = campo.get_coord(Filomeno) recorrido1_en_x.append(posicion.x) recorrido1_en_y.append(posicion.y) campo.mover_borracho(Filomeno) i+=1 i=0 while i<=dis_de_caminata: posicion = campo.get_coord(Pancracio) recorrido2_en_x.append(posicion.x) recorrido2_en_y.append(posicion.y) campo.mover_borracho(Pancracio) i+=1 output_file('Camino de borrachos.html') mapa=figure() mapa.multi_line([recorrido1_en_x,recorrido2_en_x], [recorrido1_en_y,recorrido2_en_y], color=['green','navy'], alpha=[1,1], line_width=2) show(mapa)
La clase borracho se queda igual
Cuando ejecuto el programa no me sale ningùn error al paracer ejecuta bien pero no muestra los print de la media max y min
from borracho import BorrachoTradicional from campo import Campo from coordenada import Coordenada def caminata(campo, borracho, pasos): inicio = campo.obtener_coordenada(borracho) for _ in range (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} pasos') print(f'Media = {distancia_media}') print(f'Maxima = {distancia_maxima}') print(f'Minimo = {distancia_minima}') if __name__ == 'main': distancias_de_caminata =[10,100,1000,10000] numero_de_intentos = 100 main(distancias_de_caminata, numero_de_intentos, BorrachoTradicional)