Scambia righe e colonne di un array bidimensionale di tipo lista Python

Il tipo di lista standard di Python può rappresentare un array bidimensionale con una lista di liste.

Questa sezione spiega come scambiare le righe e le colonne di questa matrice bidimensionale.

• 1. Convertire in array NumPy
  2. .TTrasponi con questo.
• 1. pandas.DataFrameConvertire in questo
  2. .TTrasponi con questo.
• Trasposizione con la funzione integrata zip()

È più facile usare NumPy o pandas, ma se non volete importare NumPy o pandas solo per la trasposizione, potete usare la funzione zip() per trasporre.

La matrice bidimensionale originale è definita come segue

import numpy as np
import pandas as pd

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

Convertito in array NumPy ndarray e trasposto con .T

Genera un array NumPy ndarray dall'array bidimensionale originale e ottiene l'oggetto trasposto con l'attributo .T.

Se volete un oggetto Python di tipo lista alla fine, convertitelo ulteriormente in una lista 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, possono essere utilizzati anche il metodo ndarray transpose() e la funzione numpy.transpose().

Convertito in pandas.DataFrame e trasposto con .T

Genera un pandas.DataFrame dall'array bidimensionale originale e ottiene l'oggetto trasposto con l'attributo .T.

Se volete un oggetto Python di tipo lista alla fine, ottenete numpy.ndarray con l'attributo values, e poi convertitelo in una lista 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'>

Trasposizione con la funzione integrata zip()

Traspone una matrice bidimensionale usando la funzione integrata zip().

zip() è una funzione che restituisce un iteratore che riassume gli elementi di più iterabili (liste, tuple, ecc.). Si usa quando si eseguono più liste in un ciclo for, per esempio.

• COLLEGATO:Usare la funzione zip in Python: Ottenere elementi di più liste insieme

Inoltre, la funzione utilizza un meccanismo per cui la lista può essere espansa e passata se l'argomento della funzione è contrassegnato da un asterisco.

• COLLEGATO:Espandere e passare liste, tuple e dizionari come argomenti di funzioni in Python

Le trasposizioni possono essere fatte come segue.

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'>

Così com'è, gli elementi all'interno sono tuple. Quindi, se volete renderlo una lista, usate list(), che converte una tupla in una lista nella notazione di comprensione della lista.

• COLLEGATO:Come usare la comprensione delle liste in Python
• COLLEGATO:Convertire liste e tuple tra loro in Python: lista(), tupla()

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'>

Quello che segue è una ripartizione passo dopo passo del processo.

Gli elementi della lista vengono espansi con un asterisco, gli elementi espansi vengono raggruppati con la funzione zip(), e poi la tupla viene convertita in una lista con la notazione list comprehension.

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]]