Intercambiar filas e columnas dunha matriz bidimensional de tipo lista Python

O tipo de lista Python estándar pode representar unha matriz bidimensional mediante unha lista de listas.

Esta sección explica como intercambiar as filas e as columnas desta matriz bidimensional.

• 1. Converter a matriz NumPy
  2. .TTranspón con isto.
• 1. pandas.DataFrameConverte a isto
  2. .TTranspón con isto.
• Transposición con función incorporada zip()

É máis fácil usar NumPy ou pandas, pero se non queres importar NumPy ou pandas só para a transposición, podes usar a función zip() para transpoñer.

A matriz bidimensional orixinal defínese do seguinte xeito

import numpy as np
import pandas as pd

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

Convertido a NumPy matriz ndarray e transposto con .T

Xera unha matriz NumPy ndarray a partir da matriz bidimensional orixinal e obtén o obxecto transposto co atributo .T.

Se queres un obxecto de tipo lista Python ao final, convérteo nunha lista co 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'>

Ademais do atributo .T, tamén se poden usar o método ndarray transpose() e a función numpy.transpose().

Convertido en pandas.DataFrame e transposto con .T

Xera un pandas.DataFrame a partir da matriz bidimensional orixinal e obtén o obxecto transposto co atributo .T.

Se queres un obxecto de tipo lista Python ao final, obtén numpy.ndarray co atributo values ​​e, a continuación, convérteo nunha lista co 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'>

Transposición con función incorporada zip()

Transpón unha matriz bidimensional usando a función incorporada zip().

zip() é unha función que devolve un iterador que resume os elementos de múltiples iterables (listas, tuplas, etc.). Utilízase cando se executan varias listas nun bucle for, por exemplo.

• RELACIONADO:Usando a función zip en Python: xuntando elementos de varias listas

Ademais, a función usa un mecanismo polo cal a lista se pode expandir e pasar se o argumento da función está marcado cun asterisco.

• RELACIONADO:Expandir e pasar listas, tuplas e dicionarios como argumentos de función en Python

As transposicións pódense facer do seguinte xeito.

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 no interior son tuplas. Polo tanto, se quere facelo unha lista, use list(), que converte unha tupla nunha lista en notación de comprensión de lista.

• RELACIONADO:Como usar as listas de comprensión de Python
• RELACIONADO:Convertendo listas e tuplas entre si en Python: list(), 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 seguinte é un desglose paso a paso do proceso.

Os elementos da lista amplíanse cun asterisco, os elementos expandidos agrúpanse coa función zip() e despois a tupla convértese nunha lista con notación de comprensión 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]]