El tipo de lista estándar de Python puede representar una matriz bidimensional mediante una lista de listas.
Esta sección explica cómo intercambiar las filas y columnas de esta matriz bidimensional.
- Convertir en matriz NumPy
.TTranspórtate con esto.
pandas.DataFrameConvertir en esto.TTranspórtate con esto.
- Transposición con la función incorporada zip()
Es más fácil usar NumPy o pandas, pero si no quieres importar NumPy o pandas sólo para la transposición, puedes usar la función zip() para transponer.
La matriz bidimensional original se define como sigue
import numpy as np
import pandas as pd
l_2d = [[0, 1, 2], [3, 4, 5]]
Convertido a matriz NumPy ndarray y transpuesto con .T
Genera un array NumPy ndarray a partir del array bidimensional original y obtiene el objeto transpuesto con el atributo .T.
Si quieres un objeto tipo lista de Python al final, conviértelo además en una lista con el 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'>
Además del atributo .T, también se puede utilizar el método ndarray transpose() y la función numpy.transpose().
Convertido a pandas.DataFrame y transpuesto con .T
Genera un pandas.DataFrame a partir del array bidimensional original y obtiene el objeto transpuesto con el atributo .T.
Si quieres un objeto tipo lista de Python al final, obtén numpy.ndarray con el atributo values, y luego conviértelo en una lista con el 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 la función incorporada zip()
Transpone una matriz bidimensional utilizando la función incorporada zip().
zip() es una función que devuelve un iterador que resume los elementos de múltiples iterables (listas, tuplas, etc.). Se utiliza cuando se ejecutan múltiples listas en un bucle for, por ejemplo.
Además, la función utiliza un mecanismo por el que la lista puede ampliarse y pasarse si el argumento de la función está marcado con un asterisco.
Las transposiciones pueden hacerse de la siguiente manera.
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 y como está, los elementos de su interior son tuplas. Por lo tanto, si quieres que sea una lista, utiliza list(), que convierte una tupla en una lista en notación de comprensión de listas.
- RELACIONADO:Cómo utilizar las comprensiones de listas de Python
- RELACIONADO:Conversión de listas y tuplas 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'>
A continuación se desglosa el proceso paso a paso.
Los elementos de la lista se expanden con un asterisco, los elementos expandidos se agrupan con la función zip() y luego la tupla se convierte en una lista con la 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]]
