web-dev-qa-db-fra.com

Convertir Tuple en liste et retour

Je travaille actuellement sur un éditeur de carte pour un jeu en pygame, en 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 vide.

Le code suivant est fondamentalement 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 changer les valeurs des différents blocs. Comment puis-je modifier facilement les différentes valeurs du niveau?

pythonlisttuples
141
user2133308

Convertir le tuple en liste:

>>> t = ('my', 'name', 'is', 'mr', 'Tuple')
>>> t
('my', 'name', 'is', 'mr', 'Tuple')
>>> list(t)
['my', 'name', 'is', 'mr', 'Tuple']

Convertir la liste en tuple:

>>> l = ['my', 'name', 'is', 'mr', 'list']
>>> l
['my', 'name', 'is', 'mr', 'list']
>>> Tuple(l)
('my', 'name', 'is', 'mr', 'list')
205
Khonix

Vous avez un tuple de tuples.
Pour convertir chaque tuple en liste:

[list(i) for i in level] # list of lists

--- OR ---

map(list, level)

Et après avoir terminé l'édition, reconvertissez-les simplement:

Tuple(tuple(i) for i in edited) # Tuple of tuples

--- OR --- (Merci @jamylak)

Tuple(itertools.imap(Tuple, edited))

Vous pouvez également utiliser un tableau numpy:

>>> a = numpy.array(level1)
>>> a
array([[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]])

Pour manipuler:

if clicked[0] == 1:
    x = (mousey + cameraY) // 60 # For readability
    y = (mousex + cameraX) // 60 # For readability
    a[x][y] = 1
62
pradyunsg

Vous pouvez avoir une liste de listes. Convertissez votre tuple de tuples en une liste de listes en utilisant:

level1 = [list(row) for row in level1]

ou

level1 = map(list, level1)

et les modifier en conséquence.

Mais un tableau numpy est plus cool.

20
eumiro

Pour convertir des tuples en liste 

(Des virgules manquaient entre les tuples de la question donnée, elle a été ajoutée pour éviter le message d'erreur)

Méthode 1: 

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 = [list(row) for row in level1]

print(level1)

Méthode 2:

level1 = map(list,level1)

print(list(level1))

Méthode 1 a pris --- 0.0019991397857666016 secondes ---

Méthode 2 a pris --- 0,00100016593933335471 secondes ---

16
Aravind Krishnakumar

Pourquoi n'essayez-vous pas de convertir son type d'un tuple en une liste et inversement.

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)
12
TheRedstoneLemon

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

Les tuples sont immuables, ce qui implique qu'ils ne peuvent pas être changés. Donc, si vous devez manipuler des données, il est préférable de les stocker dans une liste, cela réduira les coûts 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 à celle donnée par Schoolboy.

Aussi, comme suggéré, utiliser numpy array est une meilleure option

5
tanzil

Vous pourriez accélérer considérablement votre travail si vous utilisiez une seule liste au lieu d’une liste de listes. Ceci n’est bien sûr possible que si toutes vos listes internes ont la même taille (ce qui est vrai dans votre exemple, je suppose donc que cela 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 compliquerait beaucoup le problème.

2
Alfe

La liste à tuple et au dos peut être faite comme ci-dessous

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)
0
Vijay Rangarajan