是否可以在python中使用多重分配来转置多维列表？

Question

In order to avoid creating a new list of equal dimension, I'm wondering if multiple assignment could allow for an easy transpose function that modifies an exiting array. This function is meant to act as a method for a class with a state property that is a multidimensional list. Something like this:

def transpose(self):
    for i in range(dim):
        for j in range(dim):
            self.state[i][j], self.state[j][i] = self.state[j][i], self.state[i][j]
    return self

Though running this seems to give me back the same list. I'm also interested in why something like this should/shouldn't work theoretically. I've already looked into other efficient means of transposing lists ( zip , etc.), this is more of a task specific question. Thanks for your help.

Answer 1

You are traverseing every element which means you will swap twice.

In example at (i=0, j=1) you will swap (i=0, j=1) <-> (i=1, j=0) and at (i=1, j=0) you will swap (i=1, j=0) <-> (i=0, j=1) again .

Change the second loop to for j in range(i + 1, dim) to traverse only the upper right half (triangle).

Answer 2

This does work, the object referenced to by self.state just won't change. If you use an intermediate object for the list, self.state may be reassigned to point at it:

def transpose(self):
    result = [[None for column in row] for row in self.state]
    for i in range(len(self.state)):
        for j in range(len(self.state[i])):
            result[j][i], result[i][j] = self.state[i][j], self.state[j][i]
    self.state = result

Answer 3

Disclaimer : I have not tested any of the code above, so I apologize if there is a mistake. Additionally, I made the assumption that we're talking about Python 3 here, but I think that this code should still work fine in Python 2.

---

Not without an extra function call.

For example, let's say you have a Matrix class as follows:

from copy import copy

class Matrix:
    def __init__(self, rows):
        self._rows = rows

    @property
    def rows(self):
        return list(map(copy, self._rows))

    @rows.setter
    def rows(self, rows):
        self._rows = list(map(copy, rows))

    def cols(self):
        return list(map(list, zip(*self._rows)))

    @cols.setter
    def cols(self, cols):
        self._rows = list(map(list, zip(cols)))

    def transpose(self):
        self.cols = self._rows

The transpose function wouldn't even need to use list unpacking. But this still uses zip , which you mentioned you're considering doing away with.

If you want to use list unpacking, you have to know how many values will be unpacked. Therefore, if you are supporting variable dimensions, then it's a no-go. Otherwise, you have to hardcode the changes.

But there's another issue at hand. Since transposing would change the dimensions of a non-square matrix, you can't do element-wise swapping. An IndexError would occur in such a situation. You'd have to do row- or column-wise swapping. To do that, you'd have to make a copy of the columns or rows at some point (as shown in the code above—note that the getter copies aren't necessary).

There is one technique that you could use though. You could store your multidimensional list as a one-dimensional list and just use math to determine where a row (or column) begins. For example, you could do the following:

class Matrix:
    def __init__(self, values, number_of_columns, number_of_rows):
        self._values = values
        self._number_of_columns = number_of_columns
        self._number_of_rows = number_of_rows

    @property
    def rows(self):
        return [self._values[i * self._number_of_rows:(i + 1) * self._number_of_rows] for i in range(self._number_of_rows)]

    @property
    def cols(self):
        return [self._values[i::self._number_of_columns] for i in range(self._number_of_columns)]

    def transpose(self):
        for i in range(self._number_of_rows):
            self._values[i * self._number_of_rows:(i + 1) * self._number_of_rows], self._values[i::self._number_of_rows] = self._values[i::self._number_of_columns], self._values[i * self._number_of_columns:(i + 1) * self._number_of_columns]
        self._number_of_columns, self._number_of_rows = self._number_of_rows, number_of_columns

Though the first iteration swaps values to their proper places, in a non-square matrix, some values are lost. For example, consider a matrix constructed like Matrix(list(range(6)), 3, 2) .

Each pass as follows:

1. self._values == [0, 3, 1, 3, 2, 5]
2. self._values == [0, 3, 3, 2, 2, 5]

Notice that it puts the values in the correct places on the first pass. But it overwrites values that have yet to be moved. The only way to avoid this is to make a copy. So you could change the transpose method to work as follows:

    def transpose(self):
        new_values = []
        for i in range(self._number_of_rows):
            new_values.extend(self._values[i::self._number_of_columns])
        self._values = new_values
        self._number_of_columns, self._number_of_rows = self._number_of_rows, number_of_columns

But that's extremely convoluted and difficult to debug. So the moral of the story is to just use self.state = list(zip(*self.state)) —it's fairly easy to read and hard to mess up—or what you already have in your transpose method.

---

At a second glance, it appears that your transpose method does a double transposition. And of course the transposition of a transposition of a matrix M is identical to M. You need to make the ceiling the inner loop smaller:

def transpose(self):
    for i in range(dim):
        for j in range(i):
            self.state[i][j], self.state[j][i] = self.state[j][i], self.state[i][j]
    return self