Egy Python lista típusú kétdimenziós tömb sorainak és oszlopainak felcserélése

A Python szabványos listatípusa egy kétdimenziós tömböt listák listájával ábrázolhat.

Ez a szakasz elmagyarázza, hogyan cseréljük fel a kétdimenziós tömb sorait és oszlopait.

• 1. Átalakítás NumPy tömbre
  2. .TTegyük át ezzel.
• 1. pandas.DataFrameKonvertáld át erre
  2. .TTegyük át ezzel.
• Áthelyezés a beépített zip() függvénnyel

Egyszerűbb a NumPy vagy a pandas használata, de ha nem akarod a NumPy-t vagy a pandas-t csak az átvitelhez importálni, akkor használhatod a zip() függvényt az átvitelhez.

Az eredeti kétdimenziós tömb a következőképpen definiált

import numpy as np
import pandas as pd

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

Átkonvertálva NumPy tömb ndarray és transzponálva .T-vel

Az eredeti kétdimenziós tömbből egy NumPy ndarray tömb generálása és a transzponált objektum kinyerése a .T attribútummal.

Ha a végén egy Python-lista típusú objektumot szeretnénk, alakítsuk át listává a tolist() metódussal.

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

A .T attribútum mellett az ndarray transpose() metódus és a numpy.transpose() függvény is használható.

Átkonvertálva pandas.DataFrame-be és transzponálva .T-vel

Generáljon egy pandas.DataFrame-et az eredeti kétdimenziós tömbből, és kapja meg a transzponált objektumot a .T attribútummal.

Ha a végén egy Python-lista típusú objektumot akarsz, szerezd meg a numpy.ndarray-t a values attribútummal, majd alakítsd át listává a tolist() metódussal.

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

Áthelyezés a beépített zip() függvénnyel

Egy kétdimenziós tömb transzponálása a beépített zip() függvény segítségével.

A zip() egy olyan függvény, amely egy olyan iterátort ad vissza, amely több iterábilis (lista, tuple stb.) elemeit foglalja össze. Ezt például akkor használjuk, amikor több listát futtatunk egy for ciklusban.

• KAPCSOLÓDÓ:A zip függvény használata Pythonban: Több lista elemeinek összevonása

Ezenkívül a függvény egy olyan mechanizmust használ, amellyel a lista kibővíthető és átadható, ha a függvény argumentuma csillaggal van jelölve.

• KAPCSOLÓDÓ:Listák, tuplik és szótárak bővítése és átadása függvényargumentumként Pythonban

Az átváltásokat a következőképpen lehet elvégezni.

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

Így is, a benne lévő elemek tuple-ok. Ezért, ha listává akarjuk alakítani, használjuk a list() funkciót, amely a listát listává alakítja a listát értő jelölés szerint.

• KAPCSOLÓDÓ:Hogyan használjuk a Python listakövetelményeket
• KAPCSOLÓDÓ:Listák és tuple-ok egymásba konvertálása Pythonban: 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'>

Az alábbiakban lépésről lépésre ismertetjük a folyamatot.

A lista elemeit csillaggal bővítjük, a bővített elemeket a zip() függvénnyel csoportosítjuk, majd a tuple-t listává alakítjuk a lista megértésének jelölésével.

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