పైథాన్ జాబితా రకం యొక్క ద్విమితీయ శ్రేణి యొక్క అడ్డు వరుసలు మరియు నిలువు వరుసలను మార్చండి

ప్రామాణిక పైథాన్ జాబితా రకం జాబితాల జాబితా ద్వారా రెండు డైమెన్షనల్ శ్రేణిని సూచిస్తుంది.

ఈ ద్విమితీయ శ్రేణి యొక్క అడ్డు వరుసలు మరియు నిలువు వరుసలను ఎలా మార్చుకోవాలో ఈ విభాగం వివరిస్తుంది.

• 1. NumPy శ్రేణికి మార్చండి
  2. .Tదీనితో బదిలీ చేయండి.
• 1. pandas.DataFrameదీనికి మార్చండి
  2. .Tదీనితో బదిలీ చేయండి.
• అంతర్నిర్మిత ఫంక్షన్ జిప్()తో బదిలీ

NumPy లేదా పాండాలను ఉపయోగించడం సులభం, కానీ మీరు కేవలం ట్రాన్స్‌పోజిషన్ కోసం NumPy లేదా పాండాలను దిగుమతి చేయకూడదనుకుంటే, మీరు బదిలీ చేయడానికి జిప్() ఫంక్షన్‌ని ఉపయోగించవచ్చు.

అసలు ద్విమితీయ శ్రేణి క్రింది విధంగా నిర్వచించబడింది

import numpy as np
import pandas as pd

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

NumPy array ndarrayకి మార్చబడింది మరియు .Tతో మార్చబడింది

అసలు ద్విమితీయ శ్రేణి నుండి NumPy శ్రేణి ndarrayని రూపొందించండి మరియు .T లక్షణంతో బదిలీ చేయబడిన వస్తువును పొందండి.

మీరు చివరికి పైథాన్ జాబితా-రకం ఆబ్జెక్ట్ కావాలనుకుంటే, దానిని 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'>

.T అట్రిబ్యూట్‌తో పాటు, ndarray పద్ధతి transpose() మరియు numpy.transpose() ఫంక్షన్ కూడా ఉపయోగించవచ్చు.

పాండాలుగా మార్చబడింది.డేటాఫ్రేమ్ మరియు .Tతో మార్చబడింది

అసలు ద్విమితీయ శ్రేణి నుండి పాండాలు.DataFrameని రూపొందించండి మరియు .T లక్షణంతో బదిలీ చేయబడిన వస్తువును పొందండి.

మీరు చివరికి పైథాన్ జాబితా-రకం ఆబ్జెక్ట్ కావాలనుకుంటే, విలువల లక్షణంతో numpy.ndarrayని పొందండి, ఆపై దాన్ని 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'>

అంతర్నిర్మిత ఫంక్షన్ జిప్()తో బదిలీ

అంతర్నిర్మిత ఫంక్షన్ జిప్()ని ఉపయోగించి ద్విమితీయ శ్రేణిని బదిలీ చేస్తుంది.

zip() అనేది మల్టిపుల్ ఇటరబుల్స్ (లిస్ట్‌లు, టుపుల్స్, మొదలైనవి) యొక్క ఎలిమెంట్‌లను సంగ్రహించే ఇటరేటర్‌ని తిరిగి ఇచ్చే ఫంక్షన్. లూప్‌లో బహుళ జాబితాలను అమలు చేస్తున్నప్పుడు ఇది ఉపయోగించబడుతుంది, ఉదాహరణకు.

• సంబంధిత:పైథాన్‌లో జిప్ ఫంక్షన్‌ని ఉపయోగించడం: బహుళ జాబితాల ఎలిమెంట్స్‌ని కలిసి పొందడం

అదనంగా, ఫంక్షన్ ఒక మెకానిజంను ఉపయోగిస్తుంది, దీని ద్వారా ఫంక్షన్ ఆర్గ్యుమెంట్‌ను నక్షత్రం గుర్తుతో గుర్తించినట్లయితే జాబితాను విస్తరించవచ్చు మరియు పాస్ చేయవచ్చు.

• సంబంధిత:పైథాన్‌లో ఫంక్షన్ ఆర్గ్యుమెంట్‌లుగా జాబితాలు, టుపుల్స్ మరియు డిక్షనరీలను విస్తరించడం మరియు పాస్ చేయడం

బదిలీలు క్రింది విధంగా చేయవచ్చు.

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

అది ఉన్నట్లుగా, లోపల మూలకాలు టుపుల్స్. కాబట్టి, మీరు దీన్ని జాబితాగా చేయాలనుకుంటే, జాబితా()ని ఉపయోగించండి, ఇది టుపుల్‌ను జాబితా కాంప్రహెన్షన్ నొటేషన్‌లో జాబితాగా మారుస్తుంది.

• సంబంధిత:పైథాన్ జాబితా గ్రహణాలను ఎలా ఉపయోగించాలి
• సంబంధిత:పైథాన్‌లో జాబితాలు మరియు టుపుల్‌లను ఒకదానికొకటి మార్చడం: జాబితా(), టుపుల్()

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

క్రింది ప్రక్రియ యొక్క దశల వారీ విచ్ఛిన్నం.

జాబితా యొక్క మూలకాలు నక్షత్రం గుర్తుతో విస్తరించబడ్డాయి, విస్తరించిన మూలకాలు జిప్() ఫంక్షన్‌తో కలిసి సమూహం చేయబడతాయి, ఆపై tuple జాబితా గ్రహణ సంజ్ఞామానంతో జాబితాగా మార్చబడుతుంది.

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