Byta rader och kolumner i en tvådimensionell matris av Python-listtyp

Pythons standardtyp list kan representera en tvådimensionell matris med en lista av listor.

Det här avsnittet förklarar hur du byter rader och kolumner i denna tvådimensionella matris.

• 1. Konvertera till NumPy-array
  2. .TTransponera med detta.
• 1. pandas.DataFrameKonvertera till detta
  2. .TTransponera med detta.
• Överföring med den inbyggda funktionen zip()

Det är lättare att använda NumPy eller pandas, men om du inte vill importera NumPy eller pandas bara för att transponera kan du använda funktionen zip() för att transponera.

Den ursprungliga tvådimensionella matrisen definieras på följande sätt

import numpy as np
import pandas as pd

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

Konverterad till NumPy array ndarray och transponerad med .T

Generera en NumPy-array ndarray från den ursprungliga tvådimensionella arrayen och hämta det transponerade objektet med attributet .T.

Om du vill ha ett Python-objekt av listtyp i slutet, omvandlar du det till en lista med metoden 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'>

Förutom .T-attributet kan ndarray-metoden transpose() och funktionen numpy.transpose() också användas.

Konverterad till pandas.DataFrame och transponerad med .T

Generera ett pandas.DataFrame från den ursprungliga tvådimensionella matrisen och hämta det transponerade objektet med attributet .T.

Om du vill ha ett Python-objekt av listtyp i slutet hämtar du numpy.ndarray med attributet values och omvandlar det sedan till en lista med metoden 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'>

Överföring med den inbyggda funktionen zip()

Transponerar en tvådimensionell matris med hjälp av den inbyggda funktionen zip().

zip() är en funktion som returnerar en iterator som sammanfattar elementen i flera iterabler (listor, tupler osv.). Den används till exempel när man kör flera listor i en for-slinga.

• RELATERAT:Använda zip-funktionen i Python: Att samla ihop element från flera listor

Dessutom använder funktionen en mekanism som gör det möjligt att expandera listan och skicka den vidare om funktionsargumentet är markerat med en asterisk.

• RELATERAT:Expandera och skicka listor, tupler och ordlistor som funktionsargument i Python

Transpositioner kan göras på följande sätt.

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

Som det är nu är elementen inuti tupler. Om du vill göra det till en lista använder du därför list(), som omvandlar en tupel till en lista i list comprehension notation.

• RELATERAT:Hur man använder Pythons listförståelser
• RELATERAT:Konvertering av listor och tupler till varandra i 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'>

Nedan följer en stegvis beskrivning av processen.

Elementen i listan expanderas med en asterisk, de expanderade elementen grupperas tillsammans med funktionen zip() och sedan omvandlas tupeln till en lista med list comprehension notation.

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