पायथन सूची प्रकाराच्या द्विमितीय अॅरेच्या पंक्ती आणि स्तंभ स्वॅप करा

मानक Python सूची प्रकार सूचीच्या सूचीद्वारे द्विमितीय अॅरे दर्शवू शकतो.

या द्विमितीय अॅरेच्या पंक्ती आणि स्तंभांची अदलाबदल कशी करायची हे या विभागात स्पष्ट केले आहे.

• 1. NumPy अॅरेमध्ये रूपांतरित करा
  2. .Tयासह ट्रान्स्पोज करा.
• 1. pandas.DataFrameयामध्ये रूपांतरित करा
  2. .Tयासह ट्रान्स्पोज करा.
• बिल्ट-इन फंक्शन zip() सह ट्रान्सपोझिशन

NumPy किंवा pandas वापरणे सोपे आहे, परंतु जर तुम्हाला NumPy किंवा pandas फक्त ट्रान्सपोझिशनसाठी इंपोर्ट करायचे नसतील, तर तुम्ही ट्रान्सपोज करण्यासाठी zip() फंक्शन वापरू शकता.

मूळ द्विमितीय अॅरे खालीलप्रमाणे परिभाषित केले आहे

import numpy as np
import pandas as pd

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

NumPy अॅरे 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() फंक्शन देखील वापरले जाऊ शकते.

pandas.DataFrame मध्ये रूपांतरित केले आणि .T सह ट्रान्सपोज केले

मूळ द्विमितीय अ‍ॅरेमधून एक pandas.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() सह ट्रान्सपोझिशन

बिल्ट-इन फंक्शन zip() वापरून द्विमितीय अॅरे ट्रान्सपोज करते.

zip() हे एक फंक्शन आहे जे एक पुनरावृत्ति देते जे एकाधिक पुनरावृत्ती (यादी, ट्यूपल्स इ.) च्या घटकांचा सारांश देते. उदाहरणार्थ, फॉर लूपमध्ये एकाधिक सूची चालवताना याचा वापर केला जातो.

• संबंधित:पायथनमध्ये झिप फंक्शन वापरणे: अनेक सूचीचे घटक एकत्र मिळवणे

याव्यतिरिक्त, फंक्शन एक यंत्रणा वापरते ज्याद्वारे फंक्शन वितर्क तारकाने चिन्हांकित असल्यास सूची विस्तृत आणि पास केली जाऊ शकते.

• संबंधित:Python मध्ये फंक्शन आर्ग्युमेंट म्हणून याद्या, ट्यूपल्स आणि डिक्शनरी विस्तृत करणे आणि पास करणे

खालीलप्रमाणे बदल केले जाऊ शकतात.

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

जसे आहे, आतील घटक ट्यूपल्स आहेत. म्हणून, जर तुम्हाला ती सूची बनवायची असेल, तर list() वापरा, जे ट्यूपलला सूची आकलन नोटेशनमध्ये सूचीमध्ये रूपांतरित करते.

• संबंधित:पायथन सूची आकलन कसे वापरावे
• संबंधित:Python मध्ये सूची आणि tuples एकमेकांमध्ये रूपांतरित करणे: 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'>

खालील प्रक्रियेचे चरण-दर-चरण ब्रेकडाउन आहे.

यादीतील घटक तारकासह विस्तारित केले जातात, विस्तारित घटक zip() फंक्शनसह एकत्रित केले जातात आणि नंतर ट्यूपल सूची आकलन नोटेशनसह सूचीमध्ये रूपांतरित केले जाते.

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