Convertir un tuple en liste et inversement

Question

Je travaille actuellement sur un éditeur de cartes pour un jeu en pygame, utilisant des cartes de tuiles. Le niveau est construit à partir de blocs dans la structure suivante (bien que beaucoup plus grande) :

level1 = (
         (1,1,1,1,1,1)
         (1,0,0,0,0,1)
         (1,0,0,0,0,1)
         (1,0,0,0,0,1)
         (1,0,0,0,0,1)
         (1,1,1,1,1,1))

où "1" est un bloc qui est un mur et "0" est un bloc qui est de l'air vide.

Le code suivant est essentiellement celui qui gère le changement de type de bloc :

clicked = pygame.mouse.get_pressed()
if clicked[0] == 1:
    currLevel[((mousey+cameraY)/60)][((mousex+cameraX)/60)] = 1

Mais comme le niveau est stocké dans un tuple, je ne peux pas modifier les valeurs des différents blocs. Comment puis-je modifier facilement les différentes valeurs du niveau ?

Answer 1

Pourquoi ne pas essayer de convertir son type de tuple en liste et vice versa.

level1 = (
     (1,1,1,1,1,1)
     (1,0,0,0,0,1)
     (1,0,0,0,0,1)
     (1,0,0,0,0,1)
     (1,0,0,0,0,1)
     (1,1,1,1,1,1))

print(level1)

level1 = list(level1)

print(level1)

level1 = tuple(level1)

print(level1)

Answer 2

Les deux réponses sont bonnes, mais un petit conseil :

Les tuples sont immuables, ce qui signifie qu'ils ne peuvent pas être modifiés. Par conséquent, si vous devez manipuler des données, il est préférable de les stocker dans une liste, ce qui réduira les frais généraux inutiles.

Dans votre cas, extrayez les données dans une liste, comme indiqué par eumiro, et après modification, créez un tuple similaire de structure similaire à la réponse donnée par Schoolboy.

De plus, comme suggéré, l'utilisation d'un tableau numpy est une meilleure option.

Answer 3

Le passage d'une liste à un tuple et inversement peut se faire comme suit

import ast, sys
input_str = sys.stdin.read()
input_tuple = ast.literal_eval(input_str)

l = list(input_tuple)
l.append('Python')
#print(l)
tuple_2 = tuple(l)

# Make sure to name the final tuple 'tuple_2'
print(tuple_2)

Answer 4

Vous pourriez accélérer considérablement votre travail si vous utilisiez une seule liste au lieu d'une liste de listes. Bien entendu, cela n'est possible que si toutes les listes internes sont de la même taille (ce qui est le cas dans votre exemple, donc je suppose que c'est le cas).

WIDTH = 6
level1 = [ 1,1,1,1,1,1,
           1,0,0,0,0,1,
           1,0,0,0,0,1,
           1,0,0,0,0,1,
           1,0,0,0,0,1,
           1,1,1,1,1,1 ]
print level1[x + y*WIDTH]  # print value at (x,y)

Et vous pourriez être encore plus rapide si vous utilisiez un champ de bits au lieu d'une liste :

WIDTH = 8  # better align your width to bytes, eases things later
level1 = 0xFC84848484FC  # bit field representation of the level
print "1" if level1 & mask(x, y) else "0"  # print bit at (x, y)
level1 |= mask(x, y)  # set bit at (x, y)
level1 &= ~mask(x, y)  # clear bit at (x, y)

avec

def mask(x, y):
  return 1 << (WIDTH-x + y*WIDTH)

Mais cela ne fonctionne que si vos champs ne contiennent que 0 ou 1 bien sûr. Si vous avez besoin de plus de valeurs, vous devrez combiner plusieurs bits, ce qui rendra le problème beaucoup plus complexe.

Answer 5

L'utilisation de la liste des commandes n'a pas fonctionné pour moi.

si vous avez un tuple, il suffit d'itérer jusqu'à ce que vous ayez les éléments nécessaires, puis de les ajouter à une liste. Et si vous allez au niveau de l'élément, vous pouvez le modifier facilement.

l'entrée :

level1 = (
         (1,1,1,1,1,1),
         (1,0,0,0,0,1),
         (1,0,0,0,0,1),
         (1,0,0,0,0,1),
         (1,0,0,0,0,1),
         (1,1,1,1,1,1))

level1_as_list=[]
for i in level1:
    inside_list=[]
    for j in i:
        inside_list.append(j)
    level1_as_list.append(inside_list)

print(level1_as_list)enter code here

de la production :

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