पायथन सूची प्रकार के द्वि-आयामी सरणी की पंक्तियों और स्तंभों को स्वैप करें

मानक पायथन सूची प्रकार सूचियों की सूची द्वारा द्वि-आयामी सरणी का प्रतिनिधित्व कर सकता है।

यह खंड बताता है कि इस द्वि-आयामी सरणी की पंक्तियों और स्तंभों को कैसे स्वैप किया जाए।

• 1. NumPy सरणी में कनवर्ट करें
  2. .Tइसके साथ ट्रांजेक्शन करें।
• 1. pandas.DataFrameइसमें कनवर्ट करें
  2. .Tइसके साथ ट्रांजेक्शन करें।
• अंतर्निर्मित फ़ंक्शन ज़िप के साथ स्थानान्तरण ()

NumPy या पांडा का उपयोग करना आसान है, लेकिन यदि आप केवल ट्रांसपोज़िशन के लिए NumPy या पांडा को आयात नहीं करना चाहते हैं, तो आप ट्रांसपोज़ करने के लिए 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() का भी उपयोग किया जा सकता है।

पांडा में कनवर्ट किया गया। डेटाफ़्रेम और .T . के साथ ट्रांसपोज़ किया गया

एक पांडा उत्पन्न करें। मूल द्वि-आयामी सरणी से डेटाफ़्रेम और .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'>

निम्नलिखित प्रक्रिया का चरण-दर-चरण विश्लेषण है।

सूची के तत्वों को तारक के साथ विस्तारित किया जाता है, विस्तारित तत्वों को ज़िप () फ़ंक्शन के साथ समूहीकृत किया जाता है, और फिर टपल को सूची समझ नोटेशन के साथ एक सूची में परिवर्तित किया जाता है।

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