将元组转换为列表并返回

问题描述：

我目前正在为 pygame 中的一款游戏开发地图编辑器，使用图块地图。该级别由以下结构中的块构成（尽管要大得多）：

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

其中“1”表示墙体块，“0”表示空气块。

以下代码基本上是处理块类型变化的代码：

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

但是由于关卡存储在元组中，我无法更改不同块的值。如何以简单的方式更改关卡中的不同值？

解决方案 1：

将元组转换为列表：

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

将列表转换为元组：

>>> l = ['my', 'name', 'is', 'mr', 'list']
>>> l
['my', 'name', 'is', 'mr', 'list']
>>> tuple(l)
('my', 'name', 'is', 'mr', 'list')

解决方案 2：

您有一个元组的元组。

要将每个元组转换为列表：

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

• • 或者 - -

map(list, level)

编辑完成后，只需将它们转换回来即可：

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

--- 或 --- （感谢@jamylak）

tuple(itertools.imap(tuple, edited))

您还可以使用 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]])

对于操纵：

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

解决方案 3：

从 Python 3.5（PEP 448--附加解包概括）开始，可以使用以下文字语法将元组转换为列表：

>>> t = (1,2,3)
>>> lst = [*t]
>>> lst
[1, 2, 3]
>>> *lst,  # back to tuple
(1, 2, 3)

列表推导可用于将元组的元组转换为列表的列表：

>>> 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]
>>> level1_list
[[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]]
>>> *((*row,) for row in level1_list),
((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
True

解决方案 4：

你可以拥有一个列表的列表。使用以下命令将元组的元组转换为列表的列表：

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

或者

level1 = map(list, level1)

并进行相应的修改。

但是numpy 数组更酷。

解决方案 5：

将元组转换为列表

（给定问题的元组之间缺少逗号，添加逗号是为了防止出现错误消息）

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

方法 2：

level1 = map(list,level1)

print(list(level1))

方法 1 耗时 --- 0.0019991397857666016 秒 ---

方法 2 耗时 --- 0.0010001659393310547 秒 ---

解决方案 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)

level1 = list(level1)

print(level1)

level1 = tuple(level1)

print(level1)

解决方案 7：

列表到元组再返回可以按如下方式完成

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)

解决方案 8：

两个答案都很好，但有一点建议：

元组是不可变的，这意味着它们不能被改变。因此，如果你需要操作数据，最好将数据存储在列表中，这将减少不必要的开销。

在您的情况下，将数据提取到一个列表中，如 eumiro 所示，并在修改后创建与 Schoolboy 给出的答案具有类似结构的元组。

还建议使用 numpy 数组是一个更好的选择

解决方案 9：

如果您只使用一个列表而不是一个列表列表，则可以大大加快您的工作速度。当然，只有当您的所有内部列表大小相同时才有可能（这在您的示例中是正确的，所以我只是假设这一点）。

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)

如果你使用位域而不是列表，速度可能会更快：

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)

和

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

但这只在字段只包含 0 或 1 时才有效。如果您需要更多值，则必须组合多个位，这会使问题变得更加复杂。

解决方案 10：

仅使用命令列表对我来说不起作用。

如果你有一个元组，只需迭代直到获得所需的元素，然后将其附加到列表中。如果你进入元素级别，你可以轻松更改它。

输入：

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

输出：

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

解决方案 11：

就我而言，我想合并行/ lists：

a = ['Tom', 'Dick', 'Harry']
b = ['20', '32', '14']
c = ['foo', 'bar', 'blah']

lines = [list(row) for row in zip(a, b, c)]

lines = [['Tom', '20', 'foo'], ...]