Camino de Borrachos

Me agradan mucho este tipo de algoritmos, solo que cuando el profesor empieza a programar lo hace muy rápido y sin explicar la solución que propone (esto también hizo en el curso de CRUD con python), me parece que la forma de ayudar al estudiante es explicar el problema y diagramar una solución, por ejemplo un diagrama de clases UML, para saber que clases se van a crear y como van a estar relacionadas

Hola, vengo del futuro ( dos clases mas adelante) y les vengo a recomendar que vayan comentando su código ( se usa # )
Este modulo integra varias funciones y tener a la vista que hace cada una ayuda bastante al momento de leer.

vuelvo al futuro, adiós

https://github.com/karlbehrensg/programacion-dinamica-y-estocastica
Camino de Borrachos

Este es un ejercicio donde empezando desde un punto 0 aleatoriamente podemos decidir que dirección tomar, dependiendo de las opciones establecidas.

Para realizar un ejemplo de aleatoriedad vamos a crear un programa que representara el problema del “Camino de Borrachos”. Para esto crearemos 3 clases: uno que represente al agente que camina, una que genere una abstracción de las coordenadas y una que represente el plano en el cual nos estamos moviendo, y vamos a graficar la distancia en la que termina nuestro agente a medida que definimos una mayor cantidad de pasos que puede dar.

Primero crearemos un ambiente virtual, para ello vamos a la terminar.

mkdir camino_de_borramos    # Creamos una carpeta para nuestro proyecto.
cd camino_de_borrachos      # Ingresamos a la carpeta.
python3 -m venv env         # Creamos nuestro ambiente virtual.
source env/bin/activate     # Activamos nuestro ambiente.
pip install bokeh           # Instalamos el paquete de bokeh para generar nuestra gráfica.

Luego de haber creado nuestro entorno de trabajo creamos los siguientes archivos en nuestra carpeta.

# Creamos un archivo borracho.py
import random

# Creamos nuestra Clase borracho.
class Borracho:

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


# Creamos la clase BorrachoTradicional que extiende de Borracho.
class BorrachoTradicional(Borracho):

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

    # Y tendrá un método caminar que devolverá la dirección a la que ira.
    def camina(self):
        # Con random.choice elegimos un elemento aleatoriamente de la lista.
        return random.choice([(0, 1), (0, -1), (1, 0), (-1, 0)])

# Creamos un archivo coordenada.py

# La clase Coordenada guardara las coordenadas de nuestro agente
class Coordenada:

    # Definimos unas posiciones iniciales.
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # Y cuando se mueve simplemente a las coordenadas actuales se les
    # suma las coordenadas X e Y que ingresan como parámetros.
    def mover(self, delta_x, delta_y):
        return Coordenada(self.x + delta_x, self.y + delta_y)


    # Y si queremos saber la distancia del agente con respecto a
    # unas coordenadas, simplemente lo calculamos con el
    # teorema de Pitágoras.
    def distancia(self, otra_coordenada):
        delta_x = self.x - otra_coordenada.x 
        delta_y = self.y - otra_coordenada.y 

        return (delta_x**2 + delta_y**2)**0.5

# Creamos un archivo campo.py
class Campo:

    # Nuestra clase tendrá como atributo un diccionario.
    def __init__(self):
        self.coordenadas_de_borrachos = {}


    # Añadimos un agente a nuestro diccionario, nuestra llave sera
    # nuestro parámetro "borracho" y tendrá el valor asignado "coordenada"
    # que es una clase Coordenada creado en coordenada.py.
    def anadir_borracho(self, borracho, coordenada):
        self.coordenadas_de_borrachos[borracho] = coordenada


    def mover_borracho(self, borracho):
        # Al mover a nuestro agente ejecutamos el método camina de
        # nuestra clase BorrachoTradicional creado en el archivo borracho.py,
        # devolviendo la dirección hacia donde se movió.
        delta_x, delta_y = borracho.camina()

        # Obtenemos el objeto de Coordenada.
        coordenada_actual = self.coordenadas_de_borrachos[borracho]

        # Del objeto Coordenada ejecutamos el método mover con los parámetros
        # que el objeto borracho genero. El resultado lo guardamos en
        # nueva_coordenada.
        nueva_coordenada = coordenada_actual.mover(delta_x, delta_y)

        # El objeto guardado en nueva_coordenada ahora estará asociado
        # a la llave de borracho.
        self.coordenadas_de_borrachos[borracho] = nueva_coordenada


    def obtener_coordenada(self, borracho):
        return self.coordenadas_de_borrachos[borracho]

# Creamos el archivo camino_aleatorio.py

# Importamos las clases que creamos anteriormente.
from borracho import BorrachoTradicional
from campo import Campo
from coordenada import Coordenada

# Importamos bokeh para generar un gráfico con nuestros resultados.
from bokeh.plotting import figure, show


def caminata(campo, borracho, pasos):
    # De la instancia Campo obtenemos las coordenadas actuales de la llave "borracho".
    inicio = campo.obtener_coordenada(borracho)

    # Repetiremos la misma cantidad de pasos definidos.
    for _ in range(pasos):

        # De la instancia campo ejecutaremos mover_borracho.
        campo.mover_borracho(borracho)

    # Y devolveremos la distancia entre las coordenadas de la instancia
    # inicio y campo.
    return inicio.distancia(campo.obtener_coordenada(borracho))


def simular_caminata(pasos, numero_de_intentos, tipo_de_borracho):

    # Definimos los parámetros para crear una instancia de Campo.
    borracho = tipo_de_borracho(nombre='Karl')
    origen = Coordenada(0, 0)

    # Creamos una lista que guardara las distancias en cada simulación.
    distancias = []

    # Por cada numero de intento.
    for _ in range(numero_de_intentos):

        # Creamos una instancia de Campo.
        campo = Campo()

        # A nuestra instancia de Campo le damos la llave borracho y sus coordenadas de origen.
        campo.anadir_borracho(borracho, origen)

        # Obtenemos la distancia final de la simulación.
        simulacion_caminata = caminata(campo, borracho, pasos)

        # El resultado lo guardamos en la lista de distancias.
        distancias.append(round(simulacion_caminata, 1))
    
    # Retornamos la lista de distancias.
    return distancias


def graficar(x, y):
    # Creamos una instancia de figure, con su titulo y las etiquetas de los ejes.
    grafica = figure(title='Camino aleatorio', x_axis_label='pasos', y_axis_label='distancia')

    # Ingresamos los datos de X e Y.
    grafica.line(x, y, legend='distancia media')

    # Generamos una gráfica en HTML.
    show(grafica)


def main(distancias_de_caminata, numero_de_intentos, tipo_de_borracho):

    # Creamos una lista que guardara el promedio de cada caminata.
    distancias_media_por_caminata = []

    # Por cada ítem en nuestras series de caminata.
    for pasos in distancias_de_caminata:

        # Guardamos las distancias que generan todas las simulaciones definido en numero_de_intentos.
        distancias = simular_caminata(pasos, numero_de_intentos, tipo_de_borracho)

        # De la lista de distancias obtenemos la distancia promedio.
        distancia_media = round(sum(distancias) / len(distancias), 4)

        # De la lista de distancias obtenemos el máximo valor.
        distancia_maxima = max(distancias)

        # De la lista de distancias obtenemos el menor valor.
        distancia_minima = min(distancias)

        # Guardamos el promedio de la caminata en la lista distancias_media_por_caminata.
        distancias_media_por_caminata.append(distancia_media)

        # Imprimimos los datos de la caminata actual.
        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}')

    # Generamos un gráfico con la información de las distancias finales según la cantidad de pasos.
    graficar(distancias_de_caminata, distancias_media_por_caminata)

if __name__ == '__main__':
    # Definamos cuantos pasos queremos que camine en cada serie.
    distancias_de_caminata = [10, 100, 1000, 10000]
    
    # Determinamos la cantidad de simulaciones que generara en cada serie.
    numero_de_intentos = 100

    # Ejecutamos el método main con los parámetros definidos anteriormente
    # y además pasamos la clase BorrachoTradicional
    main(distancias_de_caminata, numero_de_intentos, BorrachoTradicional)

Dentro el pensamiento estocástico debemos realizar varias simulaciones, por ese motivo en el ejemplo anterior realizamos varios intentos. Lo importante de esta aleatoriedad es que podemos distribuirla a lo largo de varios intentos, con esto podemos obtener certeza de que el comportamiento de nuestro programa se comporte en que esperamos estadísticamente.

Para ejecutar nuestro programa iremos nuevamente a la consola.

python3 camino_aleatorio.py     # Ejecutamos nuestro programa

# Y veremos nuestros resultados:

BorrachoTradicional caminata aleatoria de 10 pasos
Media = 2.639
Max = 6.3
Min = 0.0
BorrachoTradicional caminata aleatoria de 100 pasos
Media = 8.914
Max = 23.5
Min = 1.4
BorrachoTradicional caminata aleatoria de 1000 pasos
Media = 28.58
Max = 73.8
Min = 2.0
BorrachoTradicional caminata aleatoria de 10000 pasos
Media = 86.012
Max = 241.3
Min = 22.4

Díganme por favor que no soy el único que de alguna forma mira los continentes en esta imagen del minuto 03:09 jajajaja

Por aca les dejo los archivos con algunos comentarios y un repo de GitHub REPO

borracho.py

"""Modulo borrachos."""
import random


class 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)])

coordenada.py

"""Modulo de coordenadas."""


class Coordenada:
    """Clase para las coordenadas."""

    def __init__(self, x, y):
        """Inicializa las coordendas."""
        self.x = x
        self.y = y

    def mover(self, delta_x, delta_y):
        """Retorna una nueva Coordenada con la nueva posicion."""
        return Coordenada(self.x + delta_x, self.y + delta_y)

    def distancia(self, otra_coordenada):
        """Calcula la distancia entre las coordenada."""
        delta_x = self.x - otra_coordenada.x
        delta_y = self.y - otra_coordenada.y
        return (delta_x**2 + delta_y**2)**0.5

campo.py

"""Modulo del Campo."""


class Campo:
    """Clase para el campo donde se mueve le borracho."""

    def __init__(self):
        """Inicializa el campo."""
        self.coordenadas_de_borrachos = {}

    def anadir_borracho(self, borracho, coordenada):
        """Agrega un borracho al diccionario."""
        self.coordenadas_de_borrachos[borracho] = coordenada

    def mover_borracho(self, borracho):
        """Mueve al borracho de coordenda."""
        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

    def obtener_coordenada(self, borracho):
        """Retorna la coordenda del borracho."""
        return self.coordenadas_de_borrachos[borracho]

Para poder entender mejor la funcionalidad de las clases hice el diagrama UML, tomando como referencia un artículo de un curso de POO.
Así quedo:

Referencia: https://platzi.com/clases/1474-oop/17219-uml/

Nota: NO soy experta en esto, y realice el diagrama conforme al artículo. Si alguien encuentra algún error o tiene sugerencias de como mejorarlos, bienvenido sea 😃

Cada vez que escribe estos códigos “largos” me hace dudar de mi inteligencia. ¿Uno debe hacer así en la vida real? o sea, parece que no tuviera la necesidad de pensarlo solo tiene claro que va en cada sitio y ya. Yo en su lugar tendría que pensar detenidamente cada paso (que se yo en un cuaderno) y ahí si podría empezar a escribir las clases y mientras escribo me daría cuenta que me faltó algo por definir.

Estuvo genial la clase. Cuando hago mi código, repito lo más aproximadamente posible las palabras del profesor, así voy interiorizando más ese método para programar.
Siento que, como todo, en la medida en que se practica, luego queda en la memoria, es decir que nuestro cerebro ya no debe crear un valor nuevo, sino que recursivamente va a esas experiencias para que podamos llegar a un nivel cada vez mejor como programadores, solo después de practicar, y practicar y seguir practicando.

The winter is coming ¿Una referencia a GOT?

Quedé borracho de la clase xd

AAAAAAAAAAAAAA TODO ESTO VA MUY RAPIDOOOOOOOOOOOOOOOOOOOOOOO

Winter is coming! XD ajajajajaj

lo que hago para entender mejor el codigo es poner comentarios explicando que hace cada linea de codigo:

class Campo:

    def __init__(self):
        self.coordenadas_de_borrachos = {} #creamos un diccionario

    def anadir_borracho(self, borracho, coordenada):
        self.coordenadas_de_borrachos[borracho] = coordenada 
        #le damos una llave(borracho) y un valor(coordenada)

    def mover_borracho(self, borracho):
        coordenada_actual = self.coordenadas_de_borrachos 
        #creamos la varible coordenada_actual y le asignamos las coordenadas del borracho  
        dif_x, dif_y = borracho.camina() 
        #lo que hacemos es: generar el movimiento aleatorio con "borracho.camina()"
        #y guardar el movimiento en las variables dif_X , dif_Y
        nueva_coordenada = coordenada_actual.mover(dif_x, dif_y) 
        #creamos una nueva_coordenada y le asignamos "coordenada_actual.mover(dif_x, dif_y)"
        #lo que hace "coordenada_actual.mover(dif_x, dif_y)":
        # es aplicar el movimiento aleatorio generado anteriormente por "borracho.camina()"
        self.coordenadas_de_borrachos[borracho] = nueva_coordneenada
        #reasignamos las coordenadas_de_borrachos con la nueva_coordenada 

    def obtener_coordenada(self, borracho):
        return self.coordenadas_de_borrachos[borracho] 
        #retornamos las coordenadas_de_borrachos```

Tiempo de tomar!! … para comprender al borracho!

Aquí les dejo un video acerca del teoréma de pitágoras. Saludos.

https://www.youtube.com/watch?v=w6nh99v3r4A

Camino de Borrachos
Generamos un ‘borracho’ que elije aleatoriamente entre moverse entre cualquier dirección (aunque puede cambiarse las probabilidades de elección por ejemplo podemos hacer que sea el doble de probable que se mueva hacia el este).
Nuestra hipótesis es que mientras más se mueve el borracho más se aleja del punto de inicio. Para ello usamos el teorema de Pitágoras para calcular la distancia al punto inicial

Nota:
random.choice(<lista>) → elije aleatoriamente entre los valores de la lista

El profesor se explica solo , creo que deberia pausar y explicar y no leer el codigo de la maquina q tiene al frente

Que malos han sido estos últimos 3 cursos.

Que interesante clase, he de confesar que en campo.py me atoré pero gracias a las explicaciones me ayudaron mucho…

TIP: mientras estuvo explicando lo que íbamos a hacer pensé en lo que se necesitaría, lo escribí, así fue más fácil comprender, es como por ej. pensar en la receta para hacer un postre, piensa en los ingredientes y como los combinarías

Dejo mi código con anotaciones

-Clase Borracho

#Clase para inicializar un borracho
import random
class Borracho:
    def __init__(self, nombre):
        self.nombre = nombre
#Es la extensión que hace que un borracho se desplace entr cuatro coordenadas
class BorrachoTradicional(Borracho):
    def __init__(self, nombre):
        super().__init__(nombre)
    
    def camina(self):
        #random.choice() escoge aleatoriamente entre una estructura 
        #iterable en este caso un arreglo con cuatro coordenadas
        return random.choice([(1,0),(0,1),(-1,0),(0,-1)])

-Clase coordenada

#Clase para modificar las coordenadas de un borracho
class Coordenada:
    #Inicializa las coordenadas de partida o en las que se encuentra
    #un borracho
    def __init__(self, x, y):
        self.x = x
        self.y = y
    #Esta función suma una distancia nueva delta a las coordenadas  
    #iniciales x e y que se definieron en el constructor
    def mover(self, delta_x, delta_y):
        #Retorna la coordenada actualizada. (Usa el constructor para ello)
        return Coordenada(self.x +  delta_x, self.y + delta_y)
    #Mide la distancia entre la posicion actual y la distancia objetivo
    #Donde queremos llegar o a donde vamos
    def distancia(self, otra_coordenada):
        delta_x = self.x - otra_coordenada.x 
        delta_y = self.y - otra_coordenada.y
        #Retornamos la medida de la distancia entre donde estoy y a donde 
        #quiero ir. Usando pitagoras
        return (delta_x**2 + delta_y**2)**0.5 

-Clase campo

#Clase para mover y ubicar los borrachos en el campo
class Campo:
    def __init__(self):
        #Este diccionario me sirve para definir las coordenadas donde se 
        #ubican los borrachos en el campo
        self.coordenadasDeBorrachos = {}

    #Agrega un nuevo borracho al campo
    def anadir_borracho(self, borracho, coordenada):
        #Cada borracho nuevo tendra sus coordenadas
        #Key = borracho value = coordenada
        self.coordenadasDeBorrachos[borracho] = coordenada

    #Movemos el borracho en el campo
    def mover_borracho(self, borracho):
        #Cuando hacemos que el borracho camine regresa las coordenadas
        #hacia donde se movera. Por eso sera el delta de nueva coordenada
        delta_x, delta_y = borracho.camina()
        #Ahora obtenemos la coordenada actual del borracho
        coordenadaActual = self.coordenadasDeBorrachos[borracho]
        #Ahora hacemos que se actualice la posicion del borracho en 
        #el campo
        nuevaCoordenada = coordenadaActual.mover(delta_x, delta_y)
        #Finalmente guardamos esta posicion en el diccionario para
        #actualizar nuesta base de datos (el diccionario)
        self.coordenadasDeBorrachos[borracho] = nuevaCoordenada
    #Este metodo nos ayuda a consultar cual es la posicion de un borracho
    #en particular, sera util para calcular la distancia al objetivo
    def obtenerCoordenada(self, borracho):
        return self.coordenadasDeBorrachos[borracho]

Camino de borrachos:
Un problema donde comenzamos en el origen(0, 0) de plano de coordenadas y podemos movernos con igual probabilidad hacia arriba(y+1), abajo(y-1), derecha(x+1) o izquierda(x-1) en cada paso.
Esto se puede generalizar a mas dimensiones y/o con probabilidades desiguales para las direcciones.

Me gusta mucho la actitud de David, no me cansaré de decirlo.
Pero tengo que admitir que si no tuviera ya bases en programación se me complicaría mucho aprender o entender lo que dice, a veces creo que para estos temas que son un poco introductorios debería “masticar” mejor los temas.
Pero como tal es muy bueno como explica el algoritmo =3

Camino de borrachos utilizando Turtle 🐢

import turtle as t
from turtle import Screen
from random import randint, choice

def main():
    total_steps = int(input(f"How many steps the drunken will make? Type a number: "))


    borracho = t.Turtle()
    borracho.width(4)
    borracho.speed(0)
    t.colormode(255)
    step_size = 15

    for _ in range(total_steps):
        towards = choice([0, 270, 180, 90])
        r = randint(0, 255)
        g = randint(0, 255)
        b = randint(0, 255)
        borracho.setheading(towards)
        borracho.pencolor((r, g, b))
        borracho.fd(step_size)

    screen = Screen()
    screen.screensize(600)
    screen.exitonclick()


if __name__ == '__main__':
    main()

Hice una forma alternativa del camino del borracho, por si les interesa.

from bokeh.plotting import figure, output_file, show
import random

if __name__ =="__main__":

    output_file("prueba_aleatorio.html")

    fig = figure()

    pasos = 10000

    # Declaramos 2 listas con coordenada inicial en 0

    x_values = [0]
    y_values = [0]

    for i in range(pasos):


        coor_x_y = random.choice([(0, 1), (1, 0), (-1, 0), (0, -1)])         #Selecionarmos aleatoriamente una dupla con el movimiento
      
        x_values.append("")       # Agregamos a la lista x_values un campo vacio 
        x_values[i + 1] = coor_x_y[0] # Reemplazamos el valor obtenido aleatoriamente en la coordenada x, por el campo vacio creado en la lista
        y_values.append("")       # Agregamos a la lista y_values un campo vacio 
        y_values[i + 1] = coor_x_y[1]       # Reemplazamos el valor obtenido aleatoriamente en la coordenada y, por el campo vacio creado en la lista

        x_values[i + 1] = x_values[i + 1] + x_values[i]     # le sumamos el valor del campo nuevo creado al valor anterior
        y_values[i + 1] = y_values[i + 1] + y_values[i]     # le sumamos el valor del campo nuevo creado al valor anterior

    fig.line(x_values, y_values, line_width = 2 )

    show(fig)```

En el minuto 10, cuando David nombra las deltas, la palabra es un termino matematico que hace referencia a la distancia comprendida entre dos puntos a ---- b,o en este caso entre x_inicial_ y x_final_

borracho.py

import random

class Borracho:

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

class BorrachoTradicional(Borracho):

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

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

coordenada.py

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 distancia(self, otra_coordenada):
		delta_x = self.x - otra_coordenada.x
		delta_y = self.y - otra_coordenada.y

		return (delta_x**2 + delta_y**2)**0.5
		```

campo.py

class Campo(object):
	def __init__(self):
		self.coordenadas_de_borrachos = {}

	def anadir_borracho(self, borracho, coordenada):
		self.coordenadas_de_borrachos[borracho] = coordenada

	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

	def obtener_coordenada(self, borracho):
		return self.coordenadas_de_borrachos[borracho]
		```

Un algoritmo sencillo decía […] x.x""

Desarrolle este ejercicio antes de inciar la clase en aras de ver si lo podia crear! seguro no es la mejor manera!, jaja

import random
from bokeh.io import output_file, show
from bokeh.plotting import figure

def camino_del_borracho(x,y):
coordenada = random.randint(1,2)

if coordenada == 1:
    
    x1 = random.randint(1,2)
    #print(f'{coordenada} - la Coordenada a afectar es la X {x1}')
    if x1 == 1:
        x = x + 1
    elif x1  == 2:
        x = x - 1
    print(f'la X = {x} y la Y = {y}')
    return (x,y)
elif coordenada == 2:
    y1 = random.randint(1,2)
    if y1 == 1:
        y = y + 1
    elif y1 == 2:
        y = y - 1
    print(f'la X = {x} y la Y = {y}')
    return (x,y)

if name == ‘main’:
output_file(‘graficando_simple.html’)
fig = figure()

total_vals = int(input('Cuantos valores quieres graficar ? '))
x_vals = []
y_vals = []
x= y=0
for i  in range(total_vals):
    x_vals.append(x)
    y_vals.append(y)
    x, y = camino_del_borracho(x,y)
   

fig.line(x_vals, y_vals, line_width=2)

show(fig)

Algún libro de Python que recomienden leer para reforzar estos conocimientos?
Gracias

Clase muy flash

Para aquellos que les cueste un poco la matemática les comento que delta x y delta y hacen referencia a la diferencia entre un punto A y un punto B, osea:

x(B) - x(A) = delta x

Es un algoritmo y una implemenatación muy padre, pero creo que se entendería mejor si hiciera uso de algún diagrama donde pudiera estructurar toda la explicación.

POR QUE TENGO ESTE ERROR ?

Esto funciona mucho para el movimiento de moléculas de un gas en un espacio en cerrado, y luego las cosas pueden cambiar si los exponemos a un solido que absorbe gas, excelentes principios para la simulación molecular.

Repo:
click Acá

import random
import seaborn as sns
import matplotlib.pyplot as plt


class Borracho:

    def __init__(self):
        self.posicion = [0, 0]

    def camino_borrachos(self, pasos: int):

        plt.scatter(x=self.posicion[0], y=self.posicion[1])

        direccion = random.choice(["derecha", "izquierda", "arriba", "abajo"])
        axis_x = [self.posicion[0]]
        axis_y = [self.posicion[1]]

        for i in range(pasos):

            direccion = random.choice(
                ["derecha", "izquierda", "arriba", "abajo"])
            if direccion == "izquierda":
                self.posicion[0] -= 1
            elif direccion == "derecha":
                self.posicion[0] += 1
            elif direccion == "arriba":
                self.posicion[1] += 1
            elif direccion == "abajo":
                self.posicion[1] -= 1
            else:
                return None

            axis_x.append(self.posicion[0])
            axis_y.append(self.posicion[1])

        plt.scatter(x=axis_x, y=axis_y, c="r",
                    alpha=0.3, s=5*len(axis_x), marker='.')
        plt.plot(axis_x, axis_y, c="b", alpha=0.5,
                 linewidth=1, linestyle="--")

        plt.show()

        return self.posicion


if __name__ == "__main__":
    borrachin = Borracho()
    direccion_final = borrachin.camino_borrachos(pasos=100)
    print(direccion_final)
    distancia_final = (direccion_final[0]**2+direccion_final[1]**2)**0.5
    print("La distancia final es: ", distancia_final)

ERROR EN LA INVOCACION A BOKEH:

• usando python 3.9

• hay una invocación al modificador “legend”

• da un error, no existe este modificador en Bokeh

• eliminé la referencia y me mostró la gráfica en el navegador por defecto

Solo a mi me parece que David va muy rapido??

vamos a utilizar el método de pitágoras para poder calcular las distancias.

Con el video explicativo anterior, quedo bastante entendible el algoritmo de borracho.

Las probabilidades, pueden depender de qué queramos simulas y las podemos manipular, a favor de simular algunas derivaciones de nuestro objeto.

Hay un método dentro de la libería random, que es choice, para elegir entre un set de datos.

Con una clase base, podemos hacer implementaciones de muchos tipos de la misma cosa, que queremos simular.

Dentro el pensamiento estocástico debemos realizar varias simulaciones.

Podemos movernos con diferentes probabilidades, por lo que tenemos que entrar probar muchas posibilidades.

Nuestras preguntas, deben abarcar las posibilidades. ¿Qué pasa si...?

Como tenemos 4 opciones, osea, avanzar arriba, abajo, derecha o izquierda, tenemos 25% de probabilidad para cada una.

Subo esto por si alguien se perdió un poco con lo del teorema de Pitágoras:

Alguien mas escucho ‘la coordenada’ y se le vino SNK a la mente? o.O! …

para mi, ayudaria mucho que cuando se complete cada modulo haya 2 o 3 ejercicios , con sus respuestas para practicar lo aprendido.

Se me hace curioso que cuando hace 200k de pasos, parece el mapa mundial haha

En la clase Campo, para calcular la distancia se indica que es:

delta_x = self.x - coordenada_final.x
delta_y = self.y - coordenada_final.y

Pero esto es incorrecto dado que self.x y self.y siempre es CERO. No hay necesidad de esa resta para sacar la distancia del origen a un punto.

El objetivo del experimento es probar la hipótesis de que a mayor número de pasos, mayor distancia del punto inicial.

interesante como se implementan las clases, solo falta hacer probar

![](

Dejo este aporte, quiza a alguno le sirva para ubicarse mejor, si no, me avisan y paso mis apuntes que es mucho mas especifico

Ta bueno el ejercicio del borracho

me recuerda a un ejercicio que se hizo en el curso de como prepararse profesionalmente para el futuro

Explicación algoritmo "Camino de Borrachos".

Que buen ejercicio profe

Jon Snow 😄

Estuvo difícil seguirle el paso a el código, pero conceptualmente es simple!

Vamos a ver como funcionan estas instancias de clases de objetos juntas…

import random

class Borracho:

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

class Borracho_Tradicional(Borracho):

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

    def camina():
        return random.choice([(0, 1), (0, -1), (1, 0), (-1, 0)])    ```

class Campo:

    def __init__ (self):
        self.coordenadas_de_borrachos = {}

    def anadir_borracho (self, borracho, coordenada):
        self.coordenadas_de_borrachos[borracho] = coordenada

    def mover_borracho (self, borracho):
        dif_x, dif_y = borracho.camina()
        coordenada_actual = self.coordenadas_de_borrachos
        nueva_coordenada = coordenada_actual.mover(dif_x, dif_y) 

        self.coordenadas_de_borrachos[borracho] = nueva_coordenada    

    def obtener_coordenada(self, borracho):
        return self.coordenadas_de_borrachos[borracho]  ```

class Coordenada:

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

    def mover (self, dif_x, dif_y):
        return Coordenada(self.x + dif_x, self.y + dif_y)    

    def distancia (self, otra_coordenada):
        dif_x = (self.x - otra_coordenada.x)
        dif_y = (self.y - otra_coordenada.y)

        return (dif_x**2 + dif_y**2)**0.5      ```

Que buen nombre para el algoritmo, sería genial cambiar el % de probabilidad de arriba, abajo, derecha, izquierda según el tipo de alcohol que ingiera xD

“winter is coming” el invierno se acerca, una referencia de la serie juego de tronos que indica que los que viven en el norte deben ir mas hacia al sur o esperar su destino.

En el minuto 11:38
En el método de añadir borrachos.
-Añade un borracho por cada intento de la simulación?

-O cada vez que el borracho avanza un paso, técnicamente se convierte en un nuevo borracho y por lo tanto es cuando se añade?

No se a que se refiere exactamente ese método

No entiendo porque podríamos calcular la distancia con el método de pitagoras, ósea estamos asumiendo, que el tipo nunca se devuelve - si fuera asi no seria todo totalmente aleatorio hay un porcentaje deterministico, existe la

Interesante implementacion de este algoritmo, da entender muchos conceptos estudiados en los anteriores cursos.

un "random walk’, pero con las siguientes condiciones.

1. solo puede ir adelante o hacia atras.

from random import choice
import matplotlib.pyplot as plt

step_option = [-1,1]
step_choice = choice (step_option) # aleatorio ente -1 y 1

walk = []
walk.append (step_choice)

for step in range (1, 1000):
    next_step = walk[step-1] + choice(step_option)
    walk.append(next_step)
 
print (walk)
plt.figure (figsize=(12,5))
plt.plot(walk)
plt.show()

Camino de Borrachos
Clase Borracho

Clase Coordenada

Clase Campo

“Va mas hacia el sur pq winter is coming” XD

Una pregunta y disculpen si es algo tonta, en la clase Coordenada en el delta_x y el delta_y de la función distancia están relacionadas con el delta_x y el delta_y de la función mover? o son variables completamente diferentes? Muchas gracias

Una clase espectacular.

Entendido, vamos por el borracho

Es idea mia o ese camino de 200k pasos basicamente hizo un mapa mundi?

Winter is coming!!! jajjajaja

Muero de ganas por ver el resultado

Se me hizo muy difícil entender todo lo que explicó en esta clase. Creo que hace falta una guía visual o algo así, algo que muestre gráficamente lo que está programando en el código.

Aunque el metodo caminar no necesite la variable self, igualmente deberiamos darsela por ser un metodo de clase?

Si las clases fueran personas.
Clase Borracho:
-Pana yo solo se el NOMBRE y que PASO va a dar.
Clase coordenada:
-A listo, necesito que me digas el PASO para meterlo en una COORDENADA.
Al final me toca medir.
Clase Campo;
Bancan! Yo voy a coger el NOMBRE y COORDENADA para moverlo al panita a la vez voy a archivar sus coordenadas.
Después te mando la COORDENADA final para que nos midas la distancia.
El borracho:
Ah Caray! Soy yo!

Aquí mi implementación con typing:

from __future__ import annotations

from random import choice
from typing import Tuple, Dict, NoReturn


class Borracho:
    def __init__(self, name: str):
        self.name = name

    def camina(self) -> Tuple[int, int]:
        pass


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

    def camina(self) -> Tuple[int, int]:
        return choice([(0, 1), (0, -1), (1, 0), (-1, 0)])


class Coordenada:
    def __init__(self, x: int, y: int):
        self.x = x
        self.y = y

    def mover(self, delta_x: int, delta_y: int) -> Coordenada:
        return Coordenada(self.x + delta_x, self.y + delta_y)

    def distancia(self, otra_coordenada: Coordenada) -> int:
        delta_x = self.x - otra_coordenada.x
        delta_y = self.y - otra_coordenada.y

        return (delta_x ** 2 + delta_y ** 2) ** 0.5


class Campo:
    def __init__(self):
        self.coordenadas_de_borrachos: Dict[Borracho, Coordenada] = {}

    def anadir_borracho(self, borracho: Borracho, coordenada: Coordenada) -> NoReturn:
        self.coordenadas_de_borrachos[borracho] = coordenada

    def mover_borracho(self, borracho: Borracho) -> NoReturn:
        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

    def obtener_coordenada(self, borracho: Borracho) -> Coordenada:
        return self.coordenadas_de_borrachos[borracho]

siento que el mover y la distancia deberian ser del borracho y no de la coordenada… pero bueno será

Me gusta cuando nos metemos más de lleno en la alteratoriedad de los números.

Estos algoritmos al inicio explotan la mente, pero al analizar y ver el vídeo se logra entender paso a paso y tener una visión de lo que se quiere lograr construir 😄

¿Tienen que crearse dos archivos?, ¿no pueden estar las clases en un solo archivo? A mí me gusta hacerlo en Jupyter y creo que eso es problema.

<from random import randint

coordenadax = 0
coordenaday = 0

n = int(input('inserte un la cantidad de pasos  '))
c = 0
while n > 0:
    c +=1
    coordenadax += randint(-1,1)
    coordenaday += randint(-1,1)
    distnaciadelorigen = (coordenadax**2+coordenaday**2)**(1/2)
    print('En el paso n° '+str(c)+ ' está ubicado en la posición ('+str(coordenadax)+','+str(coordenaday)+') \n A una distancia del origen de '+str(round(distnaciadelorigen,2))+'')
    n-=1>