`goto` en Python

Je sais ce que tout le monde pense:

Cependant, il pourrait y avoir quelques didactique cas où vous avez réellement besoin d'un goto.

Ce python recette fournit la goto de commande en fonction de décorateur.

Le goto décorateur (Python recette par Carl Cerecke)

C'est la recette pour vous si vous êtes malade de la vitesse lente de la
existant goto module http://entrian.com/goto/. Le goto dans ce
la recette est sur 60x, plus rapide et aussi plus propre (abuser sys.settrace
semble guère pythonic). Parce que c'est un décorateur, il avertit l'
lecteur de fonctions utilisation goto. Il ne permet pas de mettre en œuvre les comefrom
commande, bien qu'il n'est pas difficile de l'étendre pour le faire (exercice
pour le lecteur). Aussi, calculée gotos ne sont pas pris en charge; ils ne sont pas
pythonic.

• Utilisation dis.dis(fn) pour afficher le pseudo-code de démontage d'une fonction.
• Le bytecode d'une fonction sont accessibles par fn.func_code.co_code.
  C'est en lecture seule, donc:
• Décoré de la fonction est créé exactement le même que l'ancien,
  mais avec le pseudo-code mis à jour pour obéir à la goto commandes.
• C'est 2.x seulement; le nouveau module n'est pas en python 3.x (un autre
  exercice pour le lecteur!)

Utilisation

@goto
def test1(n):
    s = 0

    label .myLoop

    if n <= 0:
        return s
    s += n
    n -= 1

    goto .myLoop

>>> test1(10)
55

---

Mise à jour

Voici deux autres implémentations compatible avec Python 3:

• https://github.com/cdjc/goto
• https://github.com/snoack/python-goto

J'ai mis à jour mon python goto décorateur pour Python 3. Vous pouvez l'obtenir à https://github.com/cdjc/goto. Utilisation de goto au lieu de fonctions peut faire une machine de l'etat de près de 5 fois plus rapide.

La version pour python 2 est toujours disponible à http://code.activestate.com/recipes/576944-the-goto-decorator/ mais il a un certain nombre de bugs qui sont résolus dans le python version 3.

Ce n'est pas exactement ce que vous cherchez, mais écoutez-moi.

Il y a plusieurs années, mon fils et j'ai écrit une "Aventure" du jeu de BASE. Chaque emplacement dans le métro de jeu a été un numéro de ligne. Lorsque vous avez quitté un endroit à travers le tunnel en direction du nord, par exemple, vous êtes arrivé à un autre emplacement.

Le codage a été quelque chose comme if response == 'N' GOTO 2400. Alors les joueurs ont fini par aller tout en utilisant GOTOs.

Je me demandais comment cela pourrait être fait en Python et est venu avec cette.

Peut-être que cette technique pourrait être utilisée pour d'autres applications où quelque chose comme un GOTO est nécessaire. Si vous fractionnez votre programme en morceaux qui sont des fonctions, la suite de "un peu bête" codage ferait l'affaire.

""" Simple, short and unfinished 'Adventure' game to show how a program such
as this with 'locations' (where each location is handled by a function) can
simulate 'GOTO's through use of the eval() function. Each time the player
chooses an exit from his current location, where he goes to will depend on the
exit chosen and achieved using eval() on the last line.
This saves having to code a series of 'if's at each location which call the
correct function the player goes to. Also, because the code always comes back
to the eval line at the botton each time, one location's function doesn't call
the next location's function, with possible risk of stack overflow if the
program is radically extended.
The program uses randint() to determine if characters are there and what they
are doing. This is just a taster. Dramatic improvements could be made if the
player could collect and use artefacts found during his travels. For instance
if there was a key somewhere and it was collected, it could be used to unlock
the door, but the key can't be picked up unless the troll isn't there etc.
The program needs to be able to parse (understand) simple natural language
(English) commands such as 'take key' or 'unlock door' or 'give food to troll'
There will also need to be some global variables so each function can behave
and do stuff dependent on these variables.
The program needs to be able to respond to players' commands, such as after a
player has indicated which direction he wants to go, the program responds,
'You can't go that way. the Ork is blocking your path'. You get the picture.
The program also needs to be able to save variables in a dictionary (which is
then pickled into a file) so players can close the game and save it and pick up
where they left off next time.
People new to this sort of game should realise by the way, that just because
a tunnel (or other route) leaves one location northwards, that doesn't mean
that it arrives at the next location from the south. The tunnels twist and
turn all over the place."""
def l0():
#print('L0')
print("You're south of a forbidding-looking cave")
go = input('n or q > ')
if go == 'n': return('1')
if go == 'q': return('q')
else: return 'q'
def l1():
#print('L1')
print("You're in a large, dark cave. Bats are hanging from the ceiling.")
print("Tunnels lead north, east and west. The entrance is south of you.")
go = input('n s e w > ')
if go == 'n': return('3') # Leaving L1 northwards takes you to L3
if go == 's': return('0') # Leaving L1 southwards takes you to L0
if go == 'e': return('3') # Leaving L1 eastwards also takes you to L3
if go == 'w': return('2') # Leaving L1 westwards takes you to L2
else: return 'q'
def l2():
#print('L2')
print("You've come to a bridge running east across a chasm")
print("On the other side the only way to go is through a tunnel")
print("This side of the chasm, a tunnel leads north and a path leads south")
go = input('n e s > ')
if go == 'n': return('1') # As per L! but applicable to L2 etc.
if go == 'e': return('4')
if go == 's': return('3')
else: return 'q'
def l3():
#print('L3')
print("You've come to a hot and humid cavern")
print("Tunnels run north, east and west. A path leads south.")
print("There's a dragon here.")
dstate = randint(1,5)
if dstate == 1: print("The dragon seems to be asleep")
if dstate == 2: print("The dragon looks sleepy")
if dstate == 3: print("The dragon is awake")
if dstate == 4: print("The dragon looks angry")
if dstate == 5: print("The dragon is breathing fire and very angry!")
go = input('n s e w > ')
if go == 'n': return('1')
if go == 's': return('2')
if go == 'e': return('4')
if go == 'w': return('1')
else: return 'q'
def l4():
#print('L4')
print("You've arrived at a grotto. There are jewels here!")
tstate = randint(1,4)
if tstate > 1: print("There's a troll here wielding a cudgel")
print("Tunnels lead east, west and south from here")
go = input('s e w > ')
if go == 's': return('5')
if go == 'e': return('2')
if go == 'w': return('3')
else: return 'q'
def l5():
#print('L5')
print("The tunnel ends at a door leading to a small room")
print("Through a grille in the door, you can see there is no way out")
print("The only way is back, south along the tunnel")
print("But there's gold in the room!")
print("The door is locked.")
go = input('s > ')
if go == 's': return('4')
else: return 'q'
### ********************* Main Program Start ***************************
import random
from random import randint
go = l0()   # That's call L zero (location zero), not ten!
while go != 'q':
print()
go = eval("l"+go+"()")  # Program always returns here to sort out where to
# go next. Player doesn't of course!