alguien podría explicarme como funciona o que fue lo que se hizo con exactitud en este código, por favor no me queda todo muy claro 😦

Claro que sí. Bueno como ya viste primero creamos las clases de los objetos principales de nuestro programa.

1. Clase Borracho. Primero en la clase borracho simplemente tenemos un atributo que es el nombre. 1.1. Clase BorrachoTradicional. Esta es la que vamos a ocupar en nuestro programa, y esta tiene un método muy importante que es el de
   camina(self)
   aquí es básicamente donde sucede toda la magia, ya que aquí se obtienen la coordenada random.
2. Clase Coordenada. Una coordenada recibe dos datos, "x" y "y" para poder ubicarla dentro de un plano cartesiano.
   • Método
     mover(self, delta_x, delta_y)
     . Este es muy importante ya que es donde se modifica la coordenada del borracho.
   • Método
     distancia(self, otra_coordenada)
     . Este nos sirve para obtener la distancia entre dos coordenadas, preferiblemente entre la coordenada inicial y final, para ver dónde quedo el borracho.
3. Clase Campo. Podríamos decir que esta es una representación de nuestro plano cartesiano.
   • Método
     anadir_borracho(self, borracho, coordenada)
     . Sirve para añadir un borracho al campo(ya que podemos tener mas de uno) y a este borracho se le da una coordenada, que sería la de origen.
   • Método
     mover_borracho(self, borracho)
     . Lo que hace es obtener un nuevo movimiento de coordenadas y crea la nueva coordenada del borracho con base a la coordenada actual.
   • Método
     obtener_coordenada(self, borracho)
     . Nos sirve para obtener la coordenada en la que esta el borracho.

Esas son las clases de cada objeto con sus respectivos métodos. Ahora veamos el curso del programa y como se implementa todo esto.

1. Primero, le preguntamos al usuario del programa cuántos pasos(distancias_de_caminata) quiere que de el borracho. La variable
   numero_de_intentos
   sirve para indicar cuántas veces va a correr la simulación, recordemos que entre más una simulación corre más precisa es.
2. Después, a nuestra función
   main(distancias_de_caminata, numero_de_intentos, BorrachoTradicional)
   le pasamos los parámetros correspondientes. Un dato importante es que el BorrachoTradicional lo estamos pasando como la clase que es, no como una instancia.
3. Después en la función
   main()
   haremos un ciclo for por cada paso de nuestro número de pasos. Y creamos la variable distancias que equivale a la función
   simular_caminata(pasos, numero_de_intentos, tipo_de_borracho)
   , ya que al final queremos hacer operaciones con las distancias.
4. Una vez llamada la función
   simular_caminata(pasos, numero_de_intentos, tipo_de_borracho)
   hacemos lo siguiente. 4.1. Creamos una instancia de la clase BorrachoTradicional, ahora hacemos referencia a BorrachoTradicional con
   tipo_de_borracho
   , ya que llevamos pasando esta clase como parámetro desde hace dos funciones. 4.2. Después creamos una instancia de Coordenada llamada origen, que es básicamente la coordenada donde inicia a caminar nuestro borracho. 4.3. Después creamos una lista llamada distancias() que es donde vamos a estar guardando las distancias. 4.4. Después recorremos con un ciclo for la veces de nuestro
   numero_de_intentos
   . 4.5. Una vez dentro del ciclo for creamos una instancia de nuestro clase
   Campo()
   y en este campo añadimos a nuestro borracho haciendo uso del método
   anadir_borracho()
   de nuestra clase Campo, el método recibe dos parámetros, el borracho y la coordenada, por lo tanto pasamos la instancia de borracho y la coordenada de nombre origen que creamos. 4.6. Después de esto creamos una variable llamada
   simulacion_caminata
   que es igual a la función
   caminata(campo, borracho, pasos)
   , y le pasamos cada uno de los parámetros que requiere.
5. Ahora estamos en función
   caminata()
   . 5.1. Declaramos una variable
   inicio
   que hace referencia al método
   obtener_coordenada(borracho)
   de nuestra clase campo. La cual nos devuelve la coordenada en la que esta el borracho que le acabamos de pasar por parámetro. Si vemos nuestro método
   obtener_coordenada()
   de la clase campo, lo que devuelve es
   self.coordenadas_de_borrachos[borracho]
   , que hace referencia a un diccionario en nuestro método
   __init__
   de esa misma clase Campo. Y el diccionario tiene el valor del borracho, porque cuando añadimos al borracho, dentro del método
   anadir_borracho()
   lo que hace es que en ese diccionario creamos un nuevo elemento con llave borracho(la llave es nuestro borracho, la instancia de la clase borracho), y a esa llave le asignamos el valor de la coordenada, que recordemos que fue la variable origen 5.2. Después recorremos un ciclo for por cada paso. 5.3. Dentro del ciclo for ejecutamos el método
   mover_borracho(borracho)
   , que es un método de la clase Campo.
6. Ahora estamos en el método
   mover_borracho(borracho)
   en la clase Campo. Lo que hace este método es lo siguiente. 6.1. Obtenemos una coordenada(no nos referimos a una instancia de la clase Coordenada, sino a una tupla de dos valores, x y) random con nuestro método
   borracho.camina()
   . Si miras nuestro método camina() es la clase Borracho() verás que ahí es donde obtenemos la coordenada random. Esa función devuelve a la tuplas, que para separarla hacemos
   delta_x y delta_y
   . Delta en física y matemáticas significa cambio, así que estas dos variables hacen referencia al cambio que va a haber en "x" y "y". 6.2. Ahora creamos una variable llamada
   coordenada_actual
   que hace reference al atributo que esta en nuestro método
   __init__
   que a su vez hace referencia a la coordenada en la que esta el borracho actualmente. 6.3. Después creamos una variable llamada
   nueva_coordenada()
   que equivale a
   coordenada_actual.mover(delta_x, delta_y)
   .
   coordenada_actual
   es una instancia de la clase coordenada, la cual tiene el método mover que recibe delta_x y delta_y como parámetros. Si vemos en nuestra función
   mover()
   de la clase Coordenada() lo que hace es que retorna una nueva coordenada, y ahora x y y equivalen a lo que había antes más sus respectivos deltas. 6.4. De regreso en la función
   mover_borracho()
   de nuestra clase Campo, lo que sucede es que nuestra coordenada del borracho es igual a la nueva coordenada, y esto se hace mediante:
   self.coordenadas_de_borrachos[borracho] = nueva_coordenada
7. Una vez hecho esto, volvemos a nuestra función
   caminata()
   , que es donde esta corriendo todo nuestro programa. Una vez terminando todo el ciclo
   for
   nuestro borracho habrá terminado de caminar. Y lo que hacemos es retornar la distancia haciendo referencia al método
   distancia
   de nuestra clase
   Coordenada()
   .
8. Ahora ya terminamos en la función
   caminata()
   , y volvemos a la función
   simular_caminata()
   , y estamos en la variable
   simulacion_caminata
   que es básicamente la distancia, por que es igual a lo que devolvía la función
   caminata()
   , ahora esta variable se la agregamos a nuestro lista
   distancias
   redondeando a un decimal. Y posteriormente, fuera del ciclo for retornamos nuestra distancia.
9. Si recordamos, ahora estamos en nuestra función
   main()
   y la variable
   distancias
   ya tiene las distancias. Ahora proseguimos a hacer operaciones con estas distancias, como la distancia media, la distancia maxima, la distancia, minima, y en una lista llamada
   distancias_media_por_caminata
   agregamos las distancias medias.
10. Después imprimimos esos valores y graficamos los datos. 10.1. NOTA: El profesor Aroesti lo que grafico fueron las distancias_media_por_caminata.

Como ya lo mencioné anteriormente, el profesor Aroesti graficado la relación entre la distancia_de_caminata, que son los pasos, y las distancias_media_por_caminata. Algunos compañeros y compañeras graficaron cada paso que dio el borracho, por eso en la sección de aportes puedes ver las graficas con demasiados puntos. Si deseas hacer esto puedes basarte en el mío, aquí esta el código: https://github.com/pegadro/drunk-walk. La lógica es la misma, solo que en esta versión por cada paso agregas el paso en una lista tanto para x como para y.

Y básicamente ese es la lógica de todo el programa, al inicio es muy complejo, pero cuando lo entiendes verás que la lógica es simple y tiene mucho sentido. Espero que esto te haya ayudado.

UFFF 1000 GRACIAS! Ya me quedo todo muy claro. Gracias por la explicación, muy buena!!