wake-up-neo.com

Konvertiere Tuple in Liste und zurück

Ich arbeite gerade an einem Karteneditor für ein Spiel in Pygame mit Tile-Maps .. Die Ebene ist aus Blöcken in der folgenden Struktur aufgebaut (obwohl viel größer):

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

dabei ist "1" ein Block, der eine Wand ist, und "0" ist ein Block, der leere Luft ist.

Der folgende Code behandelt im Wesentlichen die Änderung des Blocktyps:

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

Da der Pegel jedoch in einem Tuple gespeichert ist, kann ich die Werte der verschiedenen Blöcke nicht ändern. Wie kann ich die verschiedenen Werte in der Ebene auf einfache Weise ändern?

141
user2133308

Tuple in Liste umwandeln:

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

Liste in Tuple umwandeln:

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

Sie haben einen Tupel Tupel.
So konvertieren Sie jeden Tuple in eine Liste:

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

--- OR ---

map(list, level)

Und nachdem Sie mit der Bearbeitung fertig sind, konvertieren Sie sie einfach zurück:

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

--- OR --- (Danke @jamylak)

Tuple(itertools.imap(Tuple, edited))

Sie können auch ein numpy-Array verwenden:

>>> 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]])

Zur Manipulation:

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

Sie können eine Liste mit Listen erstellen. Konvertieren Sie Ihren Tupel Tupel in eine Liste der Listen mit:

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

oder

level1 = map(list, level1)

und modifizieren sie entsprechend.

Aber ein numpy-Array ist kühler.

20
eumiro

Um Tupel in Liste umzuwandeln 

(In der gegebenen Frage fehlten Kommas zwischen den Tupeln. Sie wurden hinzugefügt, um eine Fehlermeldung zu vermeiden.)

Methode 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)

Methode 2:

level1 = map(list,level1)

print(list(level1))

Methode 1 dauerte --- 0,0019991397857666016 Sekunden ---

Methode 2 dauerte --- 0,0010001659393310547 Sekunden ---

16

Warum versuchen Sie nicht, den Typ von einem Tuple in eine Liste zu konvertieren und umgekehrt.

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

Beide Antworten sind gut, aber ein kleiner Ratschlag:

Tupel sind unveränderlich, was bedeutet, dass sie nicht geändert werden können. Wenn Sie also Daten bearbeiten müssen, ist es besser, Daten in einer Liste zu speichern. Dadurch wird unnötiger Aufwand reduziert.

In Ihrem Fall extrahieren Sie die Daten in eine Liste, wie von eumiro gezeigt, und erstellen Sie nach dem Ändern einen ähnlichen Tupel mit einer ähnlichen Struktur wie die Antwort, die Sie von Schoolboy erhalten haben.

Auch ist die Verwendung eines numpy-Arrays eine bessere Option

5
tanzil

Sie könnten Ihr Material drastisch beschleunigen, wenn Sie statt einer Listenliste nur eine Liste verwenden. Dies ist natürlich nur möglich, wenn alle Ihre inneren Listen dieselbe Größe haben (was in Ihrem Beispiel zutrifft, ich gehe also davon aus).

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)

Und Sie könnten noch schneller sein, wenn Sie anstelle einer Liste ein Bitfield verwenden:

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)

mit

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

Das funktioniert aber nur, wenn Ihre Felder natürlich nur 0 oder 1 enthalten. Wenn Sie mehr Werte benötigen, müssen Sie mehrere Bits kombinieren, wodurch das Problem erheblich komplizierter wird.

2
Alfe

Liste zu Tuple und zurück kann wie unten beschrieben durchgeführt werden

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