Python ලැයිස්තු ආකාරයේ ද්විමාන අරාවක පේළි සහ තීරු මාරු කරන්න

සම්මත Python ලැයිස්තු වර්ගයට ලැයිස්තු ලැයිස්තුවක් මගින් ද්විමාන අරාවක් නියෝජනය කළ හැක.

මෙම ද්විමාන අරාවේ පේළි සහ තීරු මාරු කරන්නේ කෙසේදැයි මෙම කොටස විස්තර කරයි.

• 1. NumPy අරාවට පරිවර්තනය කරන්න
  2. .Tමෙය සමඟ මාරු කරන්න.
• 1. pandas.DataFrameමෙයට පරිවර්තනය කරන්න
  2. .Tමෙය සමඟ මාරු කරන්න.
• බිල්ට් ක්‍රියාකාරී zip() සමඟ ප්‍රතිවර්තනය

NumPy හෝ pandas භාවිතා කිරීම පහසු වේ, නමුත් ඔබට NumPy හෝ pandas ආයාත කිරීමට අවශ්‍ය නොවන්නේ නම්, ඔබට transpose කිරීමට zip() ශ්‍රිතය භාවිතා කළ හැක.

මුල් ද්විමාන අරාව පහත පරිදි අර්ථ දක්වා ඇත

import numpy as np
import pandas as pd

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

NumPy array ndarray වෙත පරිවර්තනය කර .T සමඟින් මාරු කරන ලදී

මුල් ද්විමාන අරාවෙන් NumPy array 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 ගුණාංගය සමඟින් මාරු කළ වස්තුව ලබා ගන්න.

ඔබට අවසානයේ Python list-type object එකක් අවශ්‍ය නම්, අගයන් ගුණාංගය සමඟ 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() යනු බහු පුනරාවර්තක (ලැයිස්තු, ටියුපල්, ආදිය) මූලද්‍රව්‍ය සාරාංශ කරන පුනරාවර්තකයක් ආපසු ලබා දෙන ශ්‍රිතයකි. උදාහරණයක් ලෙස for loop එකක බහු ලැයිස්තු ධාවනය කරන විට එය භාවිතා වේ.

• සම්බන්ධිත:Python හි 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 list comprehensions භාවිතා කරන්නේ කෙසේද
• සම්බන්ධිත: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]]