J'écris une fonction qui fait naviguer une carte d'un coin à l'autre, cette carte se présente sous la forme d'une liste de listes, 0 étant des espaces et 1 étant des murs. comme ça:

[
[0, 0, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 0],
[0, 0, 0, 0, 0, 0],
[0, 1, 1, 1, 1, 1],
[0, 1, 1, 1, 1, 1],
[0, 0, 0, 0, 0, 0]
]

Mon code marque les espaces dans lesquels il se trouve avec un 2 afin qu'il ne retourne pas sur lui-même. le code parcourt la carte plusieurs fois pour essayer de trouver des itinéraires plus courts, cela signifie cependant qu'à chaque fois qu'il passe, il doit réinitialiser la carte. Il semble cependant que la variable à laquelle la carte est transmise change à chaque fois que chaque autre variable avec la carte change, donc je ne peux pas garder une copie originale. Cela ne semble se produire que lorsqu'il est passé à la fonction plutôt que défini dans la fonction. J'ai essayé plusieurs approches différentes, comme définir plusieurs autres variables, passer chaque liste en ajoutant la variable dans une boucle for, effacer l'une des variables, mais je n'arrive pas à trouver le problème, je n'ai jamais eu cela genre de problème avant et je suis confus. Des idées?

0
Alarm-1202 13 avril 2020 à 15:46

2 réponses

Meilleure réponse

Il semble que vous passiez votre carte (qui est une liste de listes) à une fonction et que vous trouviez surprenant que la fonction modifie la carte d'origine que vous lui passez. Cependant, ce comportement est attendu dans de nombreuses opérations de liste.

Le problème sous-jacent est que Les listes Python sont modifiables. Cela signifie que des opérations comme a[i] = b modifieront la liste sur place.

Prenons l'exemple suivant:

a_list = [1, 2, 3]

def foo(l):
    l[0] += 1
    return l

b_list = foo(a_list)

Ici, on trouve que

>>> b_list
[2, 2, 3]

>>> a_list
[2, 2, 3]

>>> a_list is b_list
True

Si vous souhaitez éviter cela, vous devrez créer une copie de la liste avant de la modifier:

import copy

def foo_2(l):
    # this creates a copy of the list and all sublists
    l = copy.deepcopy(l)
    l[0] += 1
    return l

b_list = foo_2(a_list)

Maintenant, nous trouvons ce qui suit:

>>> b_list
[2, 2, 3]

>>> a_list
[1, 2, 3]

>>> a_list is b_list
False

Vous pouvez faire de même avec votre carte avant de la transmettre, ou être plus prudent pour éviter les opérations sur place sur vos données.

0
Dion 13 avril 2020 à 12:53

Pouvez-vous publier du code?

Au lieu de passer directement votre carte d'origine à la fonction qui navigue dans la carte. Copiez simplement la carte et stockez-la dans une autre variable. Passez cette nouvelle variable à la fonction qui navigue dans la carte.

0
Sri 13 avril 2020 à 12:49