Un array bidimensionale può essere rappresentato da un elenco utilizzando il tipo di elenco integrato in Python.
Ecco alcuni modi per scambiare righe e colonne di questo elenco bidimensionale.
- Converti in numpy.ndarray e trasponi con T
- Converti in panda.DataFrame e trasponi con T
- Trasponi con la funzione integrata zip()
È più facile usare NumPy e panda, ma se non vuoi importare NumPy o panda solo per la trasposizione, puoi usare la funzione zip().
L’elenco bidimensionale originale è definito come segue:
import numpy as np
import pandas as pd
l_2d = [[0, 1, 2], [3, 4, 5]]
Converti in numpy.ndarray e trasponi con T
Crea un array NumPy ndarray dall’elenco 2D originale e ottieni l’oggetto trasposto con l’attributo T.
Se vuoi un oggetto di tipo elenco, convertilo in un elenco con il metodo 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'>
Oltre all’attributo T, puoi anche usare il metodo transpose() di ndarray e la funzione numpy.transpose(). Fare riferimento al seguente articolo per dettagli come l’elaborazione per matrici multidimensionali più di tre dimensioni.
Converti in panda.DataFrame e trasponi con T
Crea pandas.DataFrame dall’elenco 2D originale e ottieni l’oggetto trasposto con l’attributo T.
Se vuoi un oggetto di tipo list, ottieni numpy.ndarray con l’attributo values e convertilo in list con il metodo 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'>
Trasponi con la funzione integrata zip()
Puoi trasporre un elenco bidimensionale usando la funzione incorporata zip().
zip() è una funzione che richiede un iteratore che riassume i molteplici iterabili (elenco, tupla, ecc.).
Inoltre, usa * che ti permette di decomprimere l’elenco e passare i suoi elementi alla funzione.
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'>
Gli elementi sono tuple. Se vuoi fare list, usa list() e list comprehensions.
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'>
Il dettaglio è il seguente.
Gli elementi dell’elenco vengono espansi con *, gli elementi espansi vengono combinati con la funzione zip() e la tupla viene convertita nell’elenco nella comprensione dell’elenco.
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]]