સ્ટાન્ડર્ડ પાયથોન સૂચિનો પ્રકાર સૂચિઓની સૂચિ દ્વારા દ્વિ-પરિમાણીય એરેને રજૂ કરી શકે છે.
આ વિભાગ સમજાવે છે કે આ દ્વિ-પરિમાણીય એરેની પંક્તિઓ અને કૉલમ કેવી રીતે સ્વેપ કરવી.
- NumPy એરેમાં કન્વર્ટ કરો
.Tઆ સાથે ટ્રાન્સપોઝ કરો.
pandas.DataFrameઆમાં કન્વર્ટ કરો.Tઆ સાથે ટ્રાન્સપોઝ કરો.
- બિલ્ટ-ઇન ફંક્શન ઝિપ() સાથે ટ્રાન્સપોઝિશન
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 વિશેષતા સાથે ટ્રાન્સપોઝ કરેલ ઑબ્જેક્ટ મેળવો.
જો તમને અંતે પાયથોન લિસ્ટ-ટાઈપ ઑબ્જેક્ટ જોઈતું હોય, તો તેને ટોલિસ્ટ() મેથડ વડે લિસ્ટમાં કન્વર્ટ કરો.
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 પદ્ધતિ ટ્રાન્સપોઝ() અને ફંક્શન 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() એ એક કાર્ય છે જે પુનરાવર્તક પરત કરે છે જે બહુવિધ પુનરાવર્તિત શબ્દો (સૂચિઓ, ટ્યુપલ્સ, વગેરે) ના ઘટકોનો સારાંશ આપે છે. ઉદાહરણ તરીકે, લૂપ માટે બહુવિધ સૂચિઓ ચલાવતી વખતે તેનો ઉપયોગ થાય છે.
વધુમાં, ફંક્શન એવી મિકેનિઝમનો ઉપયોગ કરે છે કે જેના દ્વારા જો ફંક્શન આર્ગ્યુમેન્ટને ફૂદડી સાથે ચિહ્નિત કરવામાં આવે તો સૂચિને વિસ્તૃત અને પસાર કરી શકાય છે.
ટ્રાન્સપોઝિશન નીચે પ્રમાણે કરી શકાય છે.
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 માં સૂચિઓ અને ટ્યુપલ્સને એકબીજામાં રૂપાંતરિત કરવું: 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]]
