Caminos aleatorios

Para ejemplificar este caso, lo que se hace es similar el comportamiento de la caminata de un borracho dentro de un campo.
En ese sentido, necesitaremos un ‘Borracho’

import random

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


class BorrachoTradicional(Borracho):
  def __init__(self, nombre):
    super().__init__(nombre)
    
  def camina(self):
    return random.choice( [(0,1), (0,-1), (1,0), (-1,0) ])

OJO: En este ejemplo se utiliza una clase ‘Tradicional’ que hereda de la clase principal. En ese sentido, podemos generar nuestro propio comportamiento de Borracho que deseemos.

Además, definimos las Coordenadas y el Campo.

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

class Campo:
  def __init__(self):
    self.coordenadas_de_borracho = {}
    
  def anadir_borracho(self, borracho, coordenada):
    self.coordenadas_de_borracho[borracho] = coordenada
    
  def mover_borracho(self, borracho):
    delta_x, delta_y = borracho.camina()
    coordenada_actual = self.coordenadas_de_borracho[borracho]
    nueva_coordenada = coordenada_actual.mover(delta_x, delta_y)
    
    self.coordenadas_de_borracho[borracho] = nueva_coordenada
  
  def obtener_coordenada(self, borracho):
    return self.coordenadas_de_borracho[borracho]

Para realizar la simulación también se hará uso de la librería Bokeh para realizar las gráficas.

from borracho import BorrachoTradicional
from campo import Campo
from coordenada import Coordenada

from bokeh.plotting import figure, show

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 = 'Nidia')
  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 graficar(x,y):
  grafica = figure(title='Camino aleatorio', x_axis_label='Pasos', y_axis_label='Distancia')
  grafica.line(x,y, legend='Distancia media')
  
  show(grafica)


def main(distancia_de_caminata, numero_de_intentos, tipo_de_borracho):
  
  distancia_media_por_caminata = []
  
  for  pasos in distancia_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)
    
    distancia_media_por_caminata.append(distancia_media)
    
    print(f'{tipo_de_borracho.__name__} caminata aleatoria de {pasos}')
    print('Media {}'. format(distancia_media))
    print('Máxima {}'. format(distancia_maxima))
    print('Minimo {}'. format(distancia_minima))
  
  graficar(distancia_de_caminata, distancia_media_por_caminata)

if __name__ == '__main__':
  distancia_de_caminata = [10, 100, 1000, 10000]
  numero_de_intentos = 100
  
  main(distancia_de_caminata, numero_de_intentos, BorrachoTradicional)

NOTA:
Antes te ejecutar el programa, primero se deberá inicializar el entorno virtual de Python y luego instalar Bokeh:

python3 -m venv env 

source env/bin/activate  

pip3 install bokeh