Schimbă rândurile și coloanele unei matrice bidimensionale de tip listă Python

Tipul standard de listă Python poate reprezenta o matrice bidimensională printr-o listă de liste.

Această secțiune explică modul în care se schimbă rândurile și coloanele din această matrice bidimensională.

• 1. Conversia în matrice NumPy
  2. .TTranspuneți cu aceasta.
• 1. pandas.DataFrameConversia în
  2. .TTranspuneți cu aceasta.
• Transpunere cu funcția încorporată zip()

Este mai ușor să folosiți NumPy sau pandas, dar dacă nu doriți să importați NumPy sau pandas doar pentru transpunere, puteți folosi funcția zip() pentru transpunere.

Matricea bidimensională originală este definită după cum urmează

import numpy as np
import pandas as pd

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

Convertit în matrice NumPy ndarray și transpus cu .T

Generați o matrice NumPy ndarray din matricea bidimensională originală și obțineți obiectul transpus cu atributul .T.

Dacă doriți să obțineți la final un obiect de tip listă Python, convertiți-l în continuare într-o listă cu ajutorul metodei 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'>

În plus față de atributul .T, pot fi utilizate, de asemenea, metoda ndarray transpose() și funcția numpy.transpose().

Convertit în pandas.DataFrame și transpus cu .T

Generați un pandas.DataFrame din matricea bidimensională originală și obțineți obiectul transpus cu atributul .T.

Dacă doriți un obiect Python de tip listă la final, obțineți numpy.ndarray cu atributul values și apoi convertiți-l într-o listă cu ajutorul metodei 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'>

Transpunere cu funcția încorporată zip()

Transpune o matrice bidimensională utilizând funcția încorporată zip().

zip() este o funcție care returnează un iterator care rezumă elementele mai multor iterabile (liste, tuple etc.). Se utilizează atunci când se execută mai multe liste într-o buclă for, de exemplu.

• RELAȚIE:Utilizarea funcției zip în Python: Reunirea elementelor din liste multiple

În plus, funcția utilizează un mecanism prin care lista poate fi extinsă și transmisă în cazul în care argumentul funcției este marcat cu un asterisc.

• RELAȚIE:Extinderea și trecerea listelor, tulelor și dicționarelor ca argumente ale funcțiilor în Python

Transpunerile pot fi făcute după cum urmează.

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

Așa cum este, elementele din interior sunt tupluri. Prin urmare, dacă doriți să o transformați într-o listă, utilizați list(), care convertește un tuple într-o listă în notația de înțelegere a listei.

• RELAȚIE:Cum se utilizează înțelegerile de liste Python
• RELAȚIE:Conversia listelor și a tuplurilor între ele în 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'>

În cele ce urmează este prezentată o defalcare pas cu pas a procesului.

Elementele listei sunt extinse cu un asterisc, elementele extinse sunt grupate cu ajutorul funcției zip(), iar apoi tupla este convertită într-o listă cu ajutorul notației de înțelegere a listei.

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