Robot Motion en Python

Question

Estoy intentando programar un robot para moverlo. El robot se mueve según dónde se encuentra actualmente. Hay cuatro lugares donde puede ser:

LOCATION1 Motion Plan is like so, 
5 6 
3 4 
1 2 
Initial positon is (x1,y1) 
This gets coded as (x1,y1)->(x1+dx,y1)->(x1,y1+dy)->(x1+dx,y1+dy) ... and so on 

LOCATION2 Motion Plan is like so, 
5 3 1 
6 4 2 
The initial position is (x1,y1) 
This gets coded as (x1,y1)->(x1,y1-dy)->(x1-dx,y1)->(x1-dx,y1-dy) ... and so on 

LOCATION3 Motion Plan is like so, 
6 5 
4 3 
2 1 
Initial positon is (x1,y1) 
This gets coded as (x1,y1)->(x1-dx,y1)->(x1,y1+dy)->(x1-dx,y1+dy) ... and so on 

LOCATION4 Motion Plan is like so, 
6 4 2 
5 3 1 
The initial position is (x1,y1) 
This gets coded as (x1,y1)->(x1,y1+dy)->(x1-dx,y1)->(x1-dx,y1+dy) ... and so on 

estoy luchando para encontrar una buena manera de codificar Pythonic esto. Estoy pensando en las líneas de definición de 4 diferentes reglas próximo movimiento y luego tener un montón de si las declaraciones que eligen las reglas correctas

alguien ha hecho algo similar ... ¿Hay una mejor manera

Answer 1

Sé que esto podría hacerse más elegante (y los nombres de mis métodos son horribles), pero tal vez algo como esto?

>>> import itertools 
>>> def alternator(*values): 
...  return itertools.cycle(values) 
... 
>>> def increasor(value_1, dvalue_1, steps=2): 
...  counter = itertools.count(value_1, dvalue_1) 
...  while True: 
...    repeater = itertools.repeat(counter.next(), steps) 
...    for item in repeater: 
...     yield item 
... 
>>> def motion_plan(x_plan, y_plan, steps=6): 
...  while steps > 0: 
...   yield (x_plan.next(), y_plan.next()) 
...   steps -= 1 
... 
>>> for pos in motion_plan(alternator('x1', 'x1+dx'), increaser('y1', '+dy'): #Location 1 motion plan 
...  print pos 
... 
('x1', 'y1') 
('x1+dx', 'y1') 
('x1', 'y1+dy') 
('x1+dx', 'y1+dy') 
('x1', 'y1+dy+dy') 
('x1+dx', 'y1+dy+dy') 

no estaba seguro de cuánta flexibilidad que necesitaba con esto, se podía reducir la complejidad aún más si se desea eliminar una cierta flexibilidad. Además, es casi seguro que no estarías usando cadenas para esto, solo pensé que era la forma más fácil de demostrar la idea. Si utiliza los números, entonces algo como esto:

>>> count = 0 
>>> for pos in motion_plan(increaser(0, -1), alternator(0, 1)): #location 4 motion plan 
...  print "%d %r" % (count, pos) 
...  count += 1 
1 (0, 0) 
2 (0, 1) 
3 (-1, 0) 
4 (-1, 1) 
5 (-2, 0) 
6 (-2, 1) 

debe corresponder con bastante claridad a esto:

LOCATION4 Motion Plan is like so, 
6 4 2 
5 3 1 

Creo que los planes de movimiento serían los siguientes:

Location1 = motion_plan(alternator(0, 1), increasor(0, 1)) 
Location2 = motion_plan(increasor(0, -1), alternator(0, -1)) 
Location3 = motion_plan(alternator(0, -1), increasor(0, 1)) 
Location4 = motion_plan(increasor(0, -1), alternator(0, 1)) 

Answer 2

que podría hacer eso, lo que harías es.

def motion_loc1(x1,y1,dx,dy): 
    # your operation 


def motion_loc2(x1,y1,dx,dy): 
    # your operation 

Y luego en el programa principal, dependiendo de x1, y1 llame a los diversos métodos de movimiento.

Answer 3

más el camino pythonic es StateMachine