Simulación de Caminata Aleatoria con Python

Curso de Estadística Computacional con Python

Contenido del curso

Introducción

1
Programación Dinámica y Estocástica: Optimización y Modelado de Datos
01:56 min

Programación Dinámica

Caminos Aleatorios

Programas Estocásticos

Simulaciones de Montecarlo

Muestreo e Intervalos de Confianza

Datos Experimentales

Conclusiones

24
Optimización de Programas con Programación Dinámica y Simulaciones
02:54 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0014:18

Simulación de Caminata Aleatoria con Python

Curso de Estadística Computacional con Python

Clase 7 de 24

Clase 7 / 24

Recursos

¿Cómo se configura el entorno para simular una caminata de borrachos?

Primero, es esencial importar las clases que hemos creado para simular nuestra caminata. Estas son BorachoTradicional, Campo, y Coordenada. Reiterar la distinción entre "Campo" (el módulo) y "Campo" (la clase) es fundamental.

El siguiente paso es establecer un entorno para ejecutar el programa mediante if __name__ == "__main__": asegurando que nuestro código se ejecute cuando sea llamado desde la terminal. Luego definimos las distancias de las caminatas y la cantidad de intentos de simulación, que serán 10, 100, 1000, y 10000 pasos en 100 intentos cada una. Estos múltiplos permiten medir más precisamente la media de los resultados logrados.

¿Cómo definimos la función main?

La función main es vital ya que coordina la simulación. Recibe tres parámetros:

distancias_de_caminata: lista de enteros indicando la cantidad de pasos por simulación.
num_intentos: número de veces que cada simulación se debe ejecutar para obtener una media precisa.
tipo_de_borracho: la clase del borracho que se utilizará, como BorachoTradicional.

Código de ejemplo para la función main

def main(distancias_de_caminata, num_intentos, tipo_de_borracho):
    for dist in distancias_de_caminata:
        # Simula la caminata para cada distancia y número de intentos
        distancias = simular_caminata(dist, num_intentos, tipo_de_borracho)
        # Genera estadísticas de las simulaciones
        distancia_media = round(sum(distancias) / len(distancias), 3)
        distancia_maxima = max(distancias)
        distancia_minima = min(distancias)
        # Imprime resultados
        print(f'{tipo_de_borracho.__name__} tuvo una caminata aleatoria de {dist} pasos')
        print(f'Distancia media: {distancia_media}')
        print(f'Distancia máxima: {distancia_maxima}')
        print(f'Distancia mínima: {distancia_minima}\n')

¿Cómo implementamos la simulación de la caminata?

La función simular_caminata organiza cómo un borracho se desplazará paso a paso desde una coordenada inicial (0, 0).

Inicialización: Crea una instancia del tipo de borracho y establece el punto de inicio en (0, 0).
Iteración: Por cada intento, se crea un nuevo campo y se añade el borracho en la coordenada inicial.
Movimiento: Utiliza la función caminata para mover el borracho según el número de pasos definidos y calcula la distancia.

Ejemplo de Código para simular_caminata

def simular_caminata(pasos, num_intentos, tipo_de_borracho):
    distancias = []
    for _ in range(num_intentos):
        campo = Campo()
        borracho = tipo_de_borracho()
        origen = Coordenada(0, 0)
        campo.anadir_borracho(borracho, origen)
        simulacion_distancia = caminata(campo, borracho, pasos)
        distancias.append(round(simulacion_distancia, 1))
    return distancias

¿Cómo implementamos el movimiento del borracho?

La función caminata simula el movimiento paso a paso:

Inicio: La coordenada inicial es (0, 0).
Iteración: Por cada paso, se llama a la función mover_borracho del campo, que mueve al borracho y actualiza su posición.
Resultado: Calcula la distancia final entre la posición inicial y la alcanzada tras todos los pasos.

Código de Ejemplo para caminata

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

¿Qué se debe tener en cuenta al ejecutar la simulación?

Finalmente, la ejecución del programa debe hacerse asegurando que la función main incluya las llamadas adecuadas para cada tipo de simulación. Además, es fundamental asegurarse de que las estadísticas calculadas sean precisas y se almacenen y muestren de manera significativa a los usuarios.

Este método robusto y sistemático garantiza que la simulación del borracho sea exhaustiva, cubriendo una variedad de distancias y obteniendo estadísticas de importancia crítica para la comprensión de estas simulaciones aleatorias.

Si tienes dudas o comentarios sobre este código, no dudes en usar el sistema de comentarios, donde recibirás apoyo de la comunidad. ¡Sigue adelante y mantén la curiosidad!

Mauricio Obe

Hace 6 años

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.

Mauricio Obe

Hace 6 años

bien, después de dos días de arduo trabajo, les dejo unos consejos y el código funcional. Lo primero es reforzar sus conocimientos previos, y si en caso no entienden vean videos de youtube e investiguen, en mi caso yo me descargue un libro de introduccion a python que habla de los mismos temas que ya pasamos pero con mayor detalle, practiquen y practiquen lo basico en la terminal y cuando no entiendan, pruebenlo en la terminal. y repito nuevamente, practique lo basico, hasta entender y dominar.

aqui el codigo del primer archivo: camino_de_borracho.py el nombre de los archivos es muy importante porque lo utilizaremos mas adelante.

import random

class Borracho: 
    
    def __init__(self, nombre): 
        self.nombre = nombre
    
class BorrachoTradicional(Borracho):  # clase base, genera un contructor con init
    
    def __init__(self, nombre):
        super().__init__(nombre)

    def camina(self): # camina aleatoriamente entre 4 opciones
        return random.choice([(0, 1), (0, -1), (1, 0), (-1, 0)]) #choice permite generar varias opciones que tienen la misma probabilidad

segundo archivo: coordenada.py

class Coordenada:

    def __init__(self, x, y): #contructor
        self.x = x
        self.y = y
    
    def mover(self, delta_x, delta_y): 
        # deltas definen cuanto se mueven a cada direccion. regresa una nueva coordenada con la suma de la coordenada actual + los cambios en delta x
        #cada que generamos un cambio creamos una nueva coordenada, es inmutable, 
        return Coordenada(self.x + delta_x, self.y + delta_y) 
        
    
    def distancia(self, otra_coordenada): # estamos en una coordenada actual y necesitamos otra coordenada, para calcular la distancia usamos pitagoras
        delta_x = self.x - otra_coordenada.x #diferencia, se calcula la distancia entre dos coordenadas.
        delta_y = self.y - otra_coordenada.y 

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

tercer archivo: campo.py

class Campo:

    def __init__(self): #contructor
        self.coordenadas_de_borrachos = {} #crea un diccionario de las coordenadas de los borrachos.

    def añadir_borracho(self, borracho, coordenada): #que borracho queremos recibir y donde estara
        self.coordenadas_de_borrachos[borracho] = coordenada #se guarda dentro del diccionario, y se designa esta operacion a coordenada

    def mover_borracho(self, borracho): #que borracho vamos a mover
        delta_x, delta_y = borracho.camina() #cuando camina el borracho regresa una tupla, aleatorio.
        coordenada_actual = self.coordenadas_de_borrachos[borracho] #la coordenada actual guardada en el diccionario
        nueva_coordenada = coordenada_actual.mover(delta_x, delta_y) #con la coordenada actual le decimos que se mueva con el delta x, y el delta y.

        self.coordenadas_de_borrachos[borracho] = nueva_coordenada #guardamos nuevamente la coordenada del borracho en el diccionario.

    def obtener_coordenada(self, borracho):  #consulta de donde anda un borracho al final del programa.
        return self.coordenadas_de_borrachos[borracho] #devuelve el valor actual en el diccionario.

aquí importaremos los tres archivos con from indicando las clases que vamos a usar:

from camino_de_borrachos import BorrachoTradicional #importacion de clases.
from campo import Campo #campo es el modulo y Campo es la clase.
from coordenada import Coordenada 

def caminata(campo, borracho, pasos):
    inicio = campo.obtener_coordenada(borracho) #cual es el inicion, nos  debe dar al inicio (0, 0)
    
    for _ in range(pasos): #para el rango de los pasos, tantos pasos se diga
        #de campo con la funcion mover borracho, se le entrega como parametro un borracho.
        campo.mover_borracho(borracho) 
        #le decimos a la coordenada de inicio 
    return inicio.distancia(campo.obtener_coordenada(borracho))

def simular_caminata(pasos, numero_de_intentos, tipo_de_borracho):
    #llamada a tipo de borracho, a diferencia de llamarlo directamente como borracho tradicional, se lo recibe como parametro de la funcion
    # lo que se hace es inicializar una instancia de borracho tradicional o de cualquier tipo de borracho que se le mande. "agnostica" recibe un borracho, cualquie tipo.
    borracho = tipo_de_borracho(nombre="David") 
    origen = Coordenada(0, 0)
    distancias = []  #variable que guarda las distancias en cada una de las simulaciones.

    """por cada intento, el _ indica que no utilizaremos variable """
    for _ in range(numero_de_intentos):
        campo = Campo() #simulacion 
        campo.añadir_borracho(borracho, origen) #se añade un borracho y un origen de coordenada. 
        simulacion_caminata = caminata(campo, borracho, pasos) #resultado de la funcion caminata, (todavia no esta implementada)
        distancias.append(round(simulacion_caminata, 1)) #añadir a las distancias la simulacion de la caminata, round permite que no tenga ningun decimal.
     
    return distancias

""" definicion de main """
def main(distancias_de_caminata, numero_de_intentos, tipo_de_borracho):
    for pasos in distancias_de_caminata: #recuerde que son 10, 100, 1000, 10000
        distancias = simular_caminata(pasos, numero_de_intentos, tipo_de_borracho)     #esto es lo que va a estar haciendo la simulacion.          
        distancia_media = round(sum(distancias) / len(distancias), 4) #4 son 3 decimales, es la media de los datos.
        distancia_maxima = max(distancias) #el dato maximo de la distancia
        distancia_minima = min(distancias)
        #__name__ nos da el nombre de la clase, 
        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__": #End point
    distancias_de_caminata = [10, 100, 1000, 10000] #simulacion de 10 pasos, 100 pasos, ... , 
    numero_de_intentos = 100           #las simulaciones se corren varias veces para obtener su media.

    """ recibir classe de borracho, en vez inizializar la clase la vamos a ponerlo como referencia """
    main(distancias_de_caminata, numero_de_intentos, BorrachoTradicional)

el resultado aleatorio: no tiene que ser lo mismo porque es aleatorio.

BorrachoTradicional caminata aleatoria de 10 pasos
Media = 2.91
Max = 6.0
Min = 0.0
BorrachoTradicional caminata aleatoria de 100 pasos
Media = 8.642
Max = 22.4
Min = 1.4
BorrachoTradicional caminata aleatoria de 1000 pasos
Media = 28.488
Max = 58.9
Min = 2.0
BorrachoTradicional caminata aleatoria de 10000 pasos
Media = 83.948
Max = 210.0
Min = 10.3

en mi caso tuve errores que me costo encontrar pero que son errores casi invisibles a la vista, pero al final después de buscar si funciona. no te rindas!!

Luis Fernando Pedroza Taborda

Hace 6 años

Jesse muchas gracias por realizar el analisis de este algoritmo, logre entenderlo mejor.

Comentarios (166)166 comentarios

JESUS AXEL DOMÍNGUEZ ROCHA

Hace 7 años

Sebastián Ignacio Barría Collante

Arturo Escobar Fernandez

Juan Pablo Gomez Hernandez

Joan Federico Marin Ruiz

Carlos Arturo Rueda Calier

Carlos Esquivel

Jose Colmenares

Dante Castillo

Emma Juliana Gachancipa Castelblanco

Mateo Echavarria

Carli Code

Profesor

María José Medina

Juan David Suarez

Oscar Hernan Pomi Piazza

JONATAN CADAVID TORRES

Miguel Torres

Daniel Andrés Giraldo Benites

Luis Fernando Cruz Carrillo

Juan Pablo Lozano

Manuel Alejandro Hermoso

Diego Figueroa Rosales

Royer Guerrero Pinilla

Jorge Andres Muñoz Becerra

Héctor Daniel Vega Quiñones

David Felipe Carvajal Certuche

Angelica Landazabal

Juan Alonso Alcala

Gustavo Alejandro Espinioza Palomares

Gonzalo Gramaglia

Joaquín Rafael Montes

Valenttina Cardozo

Rodrigo Urquizo Yepez

Ariadna B

Kevin Franco

Edmundo Toledo

Guillermo Vara De Gante

Anthony Pernia

Introducción

Programación Dinámica y Estocástica: Optimización y Modelado de Datos

Programación Dinámica

Programación Dinámica: Optimización de Problemas con Memorización

Optimización de Algoritmos con Programación Dinámica en Python

Caminos Aleatorios

Simulaciones con Caminos Aleatorios en Programación

Camino Aleatorio en Programación Orientada a Objetos

Algoritmo de Caminata Aleatoria en Python: Clase Borracho

Simulación de Caminata Aleatoria con Python

Visualización de Caminatas Aleatorias con Python y Bokeh

Programas Estocásticos

Programación Estocástica: Aplicaciones y Ejemplos Prácticos

Cálculo de Probabilidades y Simulación de Montecarlo

Simulaciones de Probabilidades con Dados en Python

Inferencia Estadística: Conceptos y Aplicaciones Prácticas

Cálculo de la Media Aritmética en Python paso a paso

Media, Varianza y Desviación Estándar en Estadística

Distribución Normal: Propiedades y Aplicaciones Estadísticas

Simulaciones de Montecarlo

Simulaciones de Montecarlo: Historia y Aplicaciones Prácticas

Simulación de Montecarlo para Probabilidades en Juegos de Cartas

Simulaciones de Montecarlo para Aproximar Pi

Estimación de Pi mediante Monte Carlo y Simulación Estadística

Muestreo e Intervalos de Confianza

Muestreo Estadístico: Aleatorio y Estratificado

Teorema del Límite Central: Transformación de Distribuciones

Datos Experimentales

Validación de teorías científicas con datos experimentales

Regresión Lineal con NumPy y Matplotlib en Google Colab

Conclusiones

Optimización de Programas con Programación Dinámica y Simulaciones

Simulación de Caminata Aleatoria con Python