Movimiento de un robot en un plano

#!/usr/bin/python
# -*- coding: latin-1 -*-
import math

def posicion_objeto(mapa,w,h,objeto='O'):
    """ busca O por defecto pero puede buscar otras cosas"""
    for y in range(h):
        for x in range(w):
            if mapa[y][x]==objeto:
                return (y,x)

def que_hay(mapa,w,h,yy,xx):
    """ mira que hay en este posible movimiento True no hay obstaculos"""
    for y in range(h):
        for x in range(w):
            """ que hay en esta posicion """
            if x==xx and y==yy:
                if mapa[y][x]=='.' or mapa[y][x]=='O':
                    return True #puede avanzar . 0

                return False #hay un obstaculo #

def robot (mapa,w,h,n):
    """ movimiento del robot dentro del mapa"""

    #Los movimientos pueden ser repetitidos una secuencia
    repeticion=[]
    #cuanto dura una secuencia , un periodo de repeticion?
    secuencia=0

    #Recupera la posicion inicial del robot 0
    pos=posicion_objeto(mapa,w,h) #pos (y,x)

    #movimiento inicial hacia arriba Up
    move='U'

    #el robot se mueve mientra existan n
    while (n):

        #Mueve hacia arriba U
        if move=='U' :

            #Sube no hay obstaculos
            if que_hay(mapa,w,h,pos[0]-1,pos[1]):
                pos=pos[0]-1,pos[1]

            # ha encontrado un obstaculo gira a la derecha 1 posicion
            else:
                pos=pos[0],pos[1]+1
                move='R' # GIRA HACIA LA DERECHA Right

        #Mueve hacia derecha R
        elif move=='R' :

            #Continua hacia la derecha Right no hay obstaculos
            if que_hay(mapa,w,h,pos[0],pos[1]+1):
                pos=pos[0],pos[1]+1

            # ha encontrado un obstaculo gira a la derecha 1 posicion
            else:
                pos=pos[0]+1,pos[1]
                move='D'# GIRA HACIA ABAJO Down

        #Mueve hacia abajo D
        elif move=='D' :

            #Continua hacia abajo D no hay obstaculos
            if que_hay(mapa,w,h,pos[0]+1,pos[1]):
                pos=pos[0]+1,pos[1]

            # ha encontrado un obstaculo gira a la iquierda 1 posicion
            else:
                pos=pos[0],pos[1]-1
                move='L' # GIRA HACIA LA IZQUIERDA Left

        #Mueve hacia izquierda L
        elif move=='L' :

            #Continua izquiera Left no hay obstaculos
            if que_hay(mapa,w,h,pos[0],pos[1]-1):
                pos=pos[0],pos[1]-1

            # ha encontrado un obstaculo gira a la derecha 1 posicion
            else:
                pos=pos[0]-1,pos[1]
                move='U' # GIRA HACIA ARRIBA Up

        #La secuencia se repite ?
        if ((move,pos[1],pos[0]) in repeticion):
            #Si es una secuencia repetitiva puedo simplificarla
            if n>secuencia:
                n= (n-((n//secuencia)*secuencia))
                repeticion.clear()
        else:
            repeticion.append( (move,pos[1],pos[0]) )#guarda direccion y coordenadas
            secuencia+=1

        n-=1 #decrementa un movimiento

    #ha llegado al final de n donde esta ?
    print (str(pos[1])+' '+str(pos[0]))


"""  w h ancho y alto del mapa"""
w, h = [int(i) for i in input().split()]

""" numero de operaciones del robot"""
n = int(input())

""" mapa donde se mueve el robot """
mapa=[]

""" El mapa donde se mueve el robot. representando
espacio libre. # obstáculo  O la posición inicial"""

#anade lineas Y al mapa , cada linea mide X=W
for i in range(h):
    line = input()
    mapa.append(line)

#Analisis movimientos del robot
robot (mapa,w,h,n)


"""
Objectif
Desde hace varios años, en las escuelas primarias,
hemos visto la aparición de un nuevo modelo educativo, la programación lúdica.
Los estudiantes deben programar un pequeño robot usando bloques de ensamblaje.
Esto les permite familiarizarse con la programación desde una edad temprana mientras ejercen su lógica y percepción del espacio.

Eres un estudiante en una de esas escuelas.
El propósito del ejercicio es simple: su maestro ha creado un circuito para su robot,
le dijo cuántos movimientos puede hacer el robot y debe averiguar la posición final del robot al final de la ejecución.

Para hacer esto, necesita conocer algunos principios del funcionamiento del robot.
- Cuando el robot encuentra un obstáculo (representado por #)
gira a la derecha (en la misma operación).
 De lo contrario, en un área vacía (representada por.) Se mueve hacia adelante.

- El robot inicialmente se mueve hacia arriba.
- El robot se detiene después de n movimientos.
- La esquina superior izquierda representa las coordenadas (0,0)
- El entorno del robot se representa de la siguiente manera, donde O es la posición inicial del robot:
"""