Trocar linhas e colunas de uma matriz bidimensional do tipo de lista Python

O tipo de lista Python padrão pode representar uma matriz bidimensional através de uma lista de listas.

Esta secção explica como trocar as filas e colunas desta matriz bidimensional.

• 1. Converter para a matriz NumPy
  2. .TTranspor com isto.
• 1. pandas.DataFrameConvertam-se a isto
  2. .TTranspor com isto.
• Transposição com função zip() integrada

É mais fácil usar NumPy ou pandas, mas se não quiser importar NumPy ou pandas apenas para transposição, pode usar a função zip() para transpor.

A matriz bidimensional original é definida da seguinte forma

import numpy as np
import pandas as pd

l_2d = [[0, 1, 2], [3, 4, 5]]

Convertido para NumPy array ndarray e transposto com .T

Gerar uma matriz NumPy ndarray a partir da matriz bidimensional original e obter o objecto transposto com o atributo .T

Se quiser um objecto tipo lista Python no final, converta-o ainda mais para uma lista com o método tolist().

arr_t = np.array(l_2d).T

print(arr_t)
print(type(arr_t))
# [[0 3]
#  [1 4]
#  [2 5]]
# <class 'numpy.ndarray'>

l_2d_t = np.array(l_2d).T.tolist()

print(l_2d_t)
print(type(l_2d_t))
# [[0, 3], [1, 4], [2, 5]]
# <class 'list'>

Para além do atributo .T, o método ndarray transpose() e a função numpy.transpose() também podem ser utilizados.

Convertido para pandas.DataFrame e transposto com .T

Gerar um pandas.DataFrame a partir da matriz bidimensional original e obter o objecto transposto com o atributo .T

Se quiser um objecto do tipo lista Python no final, obtenha o numpy.ndarray com o atributo valores, e depois converta-o para uma lista com o método tolist().

df_t = pd.DataFrame(l_2d).T

print(df_t)
print(type(df_t))
#    0  1
# 0  0  3
# 1  1  4
# 2  2  5
# <class 'pandas.core.frame.DataFrame'>

l_2d_t = pd.DataFrame(l_2d).T.values.tolist()

print(l_2d_t)
print(type(l_2d_t))
# [[0, 3], [1, 4], [2, 5]]
# <class 'list'>

Transposição com função zip() integrada

Transpõe uma matriz bidimensional usando a função zip() incorporada.

zip() é uma função que devolve um iterador que resume os elementos de múltiplos iterables (listas, tuplos, etc.). É utilizada, por exemplo, na execução de múltiplas listas em loop, por exemplo.

• RELACIONADO:Usando a função zip em Python: Obtenção de Elementos de Listas Múltiplas

Além disso, a função utiliza um mecanismo pelo qual a lista pode ser expandida e aprovada se o argumento da função for marcado com um asterisco.

• RELACIONADO:Expandindo e passando listas, tuplos e dicionários como argumentos de função em Python

As transposições podem ser feitas da seguinte forma.

l_2d_t_tuple = list(zip(*l_2d))

print(l_2d_t_tuple)
print(type(l_2d_t_tuple))
# [(0, 3), (1, 4), (2, 5)]
# <class 'list'>

print(l_2d_t_tuple[0])
print(type(l_2d_t_tuple[0]))
# (0, 3)
# <class 'tuple'>

Tal como está, os elementos interiores são tuplos. Portanto, se quiser fazer uma lista, use list(), que converte um tuple para uma lista em notação de compreensão de lista.

• RELACIONADO:Como utilizar as compreensões da lista Python
• RELACIONADO:Conversão de listas e tupples em Python: lista(), tuple()

l_2d_t = [list(x) for x in zip(*l_2d)]

print(l_2d_t)
print(type(l_2d_t))
# [[0, 3], [1, 4], [2, 5]]
# <class 'list'>

print(l_2d_t[0])
print(type(l_2d_t[0]))
# [0, 3]
# <class 'list'>

O que se segue é uma decomposição passo-a-passo do processo.

Os elementos da lista são expandidos com um asterisco, os elementos expandidos são agrupados juntamente com a função zip(), e depois o tuple é convertido numa lista com notação de compreensão de lista.

print(*l_2d)
# [0, 1, 2] [3, 4, 5]

print(list(zip([0, 1, 2], [3, 4, 5])))
# [(0, 3), (1, 4), (2, 5)]

print([list(x) for x in [(0, 3), (1, 4), (2, 5)]])
# [[0, 3], [1, 4], [2, 5]]