3

❄️ Versión alterna sencilla de la simulación de caminos aleatorios

En vista de que ha habido varios comentarios con respecto a la dificultad de entender la implementación de la simulación de caminos aleatorios, propongo una forma alterna de hacer la misma simulación de forma más sencilla, utilizando únicamente 1 clase, y 3 métodos, esperando que pueda ser de utilidad para alguien.
.
En mi caso, para la implementación, solamente utilicé 2 módulos (Archivos de Python):
.
1. Generador: Archivo que se ejecutará, y que generará los caminos aleatorios.
2. Patrones: En donde se encuentra la clase que genera el tipo de “persona”.
.
NOTA: En lugar de caminantes borrachos, yo lo hice como piezas de ajedrez que se mueven. Da lo mismo, porque el funcionamiento es igual.
.
En el archivo de Patrones, se declara la clase principal, que tendrá sólo 2 parámetros, que definirán su posición (x, y) y un método.
.
code_01.png
.
El método llamado dibujar, toma como parámetros x, y, nueva_x, nueva_y. Este método lo único que hace, es acceder a su atributo llamado x (self.x), y asignarle el valor del parámetro nueva_x. Lo mismo con la y. Es decir, toma los atributos que definen la posición del objeto, y los modifica por el nuevo valor de x y de y, que se tenga. Si queremos mover el objeto (Dibujar), hará falta únicamente usar el método, y pasarle la posición x y y en la que está el objeto, y las posiciones x y y a las que queremos moverlo.
.
Teniendo la clase, ahora hace falta crear los objetos de esa clase (Los caminantes), por ejemplo:
.
code_02.png
.
Ahí se está creando un “Caminante”, llamado Bishop_Pattern, o Patrón de Alfil en español, que es hija de la clase que creamos al principio. Tiene un método llamado movimiento_xy, que crea una lista llamada avance_xy, en la que guardará 2 valores aleatorios, (Uno para x y una para y).
.
NOTA: El alfil, en el ajedrez, se mueve en diagonal, es decir, avanza tanto en x, como en y, por eso este elige entre 1 y -1 en x y y en x. Si queremos crear otro tipo de caminante, creamos otra clase igual a esta, y en el método movimiento_xy, elegirá cualquier otra cantidad.
.
Finalmente, el método regresa la lista, que tiene ambos valores aleatorios.
.
.
.
.
Teniendo esto, ya está listo nuestro primer patrón, ahora sólo debemos hacer el programa que ejecute estos métodos.
.
En el otro archivo, llamado Generador, crearemos el método que genere el patrón (La caminata): Este método toma de parámtero, Chess_Piece y movimientos, el primero, es para identificar qué tipo de pieza va a crear y a mover, el segundo, es la cantidad de movimientos (Pasos), que se va a mover el objeto. Después:
.
code_04.png
.

  • pieza = Chess_Piece(0,0): Lo que hace es que crea un objeto llamado pieza, y toma el parámetro Chess_Piece. Es decir, está creando una instancia de la clase de Pieza de Ajedrez, y la está llamando pieza.
    .
    NOTA: Recordemos que la clase “Chess_Piece”, que creamos anteriormente, recibe como parámetros, dos números. Estos los que determinan su posición (x, y). Es por ello que al crear pieza, le damos los valores (0,0), porque la estamos creando en las coordenadas (0, 0)
    .
    Después, creamos una lista llamada positions, que sencillamente guardará cada para de coordenadas del objeto mientras lo movemos.
    .
    Ahora, declaramos una variable llamada pasos, que nos servirá para manejar el ciclo while, que se repetirá hasta que pasos sea igual a movimientos.
    .
    code_05.png
    .
    Dentro del ciclo se ejecuta lo siguiente:
    .
  • Se le asigna a las variables x y y, el valor del atributo del objeto pieza. Para acceder al atributo de un objeto, basta con poner nombre_del_objeto.atributo.
    .
  • Se crea una variable con el nombre avance_xy, y se le da un valor, ejecutando el método que creamos anteriormente, llamado movimiento_xy, que si recordamos, regresa un par de números, que representan una coordenada.
    .
  • Se crea un par de variables llamadas nueva_x y nueva_y, y a cada una de ellas, se le asigna el valor de x (Posición actual del objeto), y se le suma el avance que se generó en el paso anterior.
    .
  • Después, se pregunta si el avance en x y en y es igual a 0 (O sea, que la pieza no va a moverse). Si es así, no hace nada, pero si sí va a haber un avance, entonces continúa.
    .
    NOTA: El alfil siempre se va a mover, porque elige entre avanzar 1 o retroceder 1 (1, -1), pero si creamos algún caminante que pueda generar coordenadas con ceros, entonces es posible que al generar el avance, den 0 ambas coordenadas. Es por eso que se pregunta.
    .
  • Finalmente, se ejecuta el método dibujar, en el objeto pieza, que recibe de parámetros, la posición actual del objeto, y la nueva posición que se generará.
    .
  • Además, a la lista que creamos, llamada positions, le pasaremos la nueva posición en que está la pieza. Además de que, a un par de listas llamadas eje_x y eje_y, que próximamente declararemos y que nos servirán para graficar el movimiento de nuestra pieza, le agregamos las nuevas coordenadas.
    .
    Al final, se le suma uno a pasos, pues ya hemos dado un paso. Y terminando el ciclo, la función regresa la lista de posiciones.
    .
    .
    .
    .
    Ahora, creamos la llamada a ejecición de main
    .
    code_07.png
    .
    Preguntaremos la cantidad de pasos que quiere el usuario para crear el patrón aleatorio. Y crearemos 3 figures, para hacer nuestras gráficas de Bokeh.
    .
    NOTA: Hice 2 patrones más, además del patrón de alfil, uno como el movimiento de una torre, y uno de una reina.
    .
    Para terminar, creamos las listas del eje x y y, para graficarlas y ejecutamos nuestra función de generar patrones, y le pasamos de parátmetros, la clase Bishop_Pattern y la cantidad de movimientos. Además, creamos la gráfica bokeh y la mostramos.
    .
    code_08.png
    .
    De este modo, creando patrones con diferentes tipos de movimiento, obtendríamos como resultados, ejecuciones como esta…
    .
    .
    .
    .
    .
    .
    01 Patrón de Alfil 01.png
    01 Patrón de Alfil 02.png
    01 Patrón de Torre 01.png
    01 Patrón de Torre 02.png
    01 Patrón de Reina 01.png
    01 Patrón de Reina 02.png
    .
    SI QUIERES EL CÓDIGO DE ESTE PROGRAMA PARA REVISARLO, HAZ CLIC AQUÍ…
Escribe tu comentario
+ 2
3
55796Puntos

Genial, Muchas gracias por el aporte, creo que ayuda a complementar el curso que me está gustando bastante. Ver las salidas del código en una imagen me vuela la cabeza. Es una excelente transición a solamente ver la pantalla negra con las letras jajaja. Saludos

2
10462Puntos
2 años

Muchas gracias 😊

2
4521Puntos

Hola el tutorial me ha servido mucho para entender el curso. Pero tengo una pregunta, en la línea de código en la que pone:
Nueva_x = x + avance_xy[0]

Alli avance_xy[0] es el elemento en el índice 0 de la lista avance_xy???
Gracias de antemano

2
10462Puntos
un año

Así es:

  • avance_xy contiene la coordenadas de x y luego la de y, por lo que:

La casilla 0 contiene a x, y la casilla 1 contiene a y.

1
10462Puntos
un año

Disculpa la tardanza al responder 🙌

0
4521Puntos
un año

genial muchas gracias