ਮਿਆਰੀ ਪਾਈਥਨ ਸੂਚੀ ਕਿਸਮ ਸੂਚੀਆਂ ਦੀ ਇੱਕ ਸੂਚੀ ਦੁਆਰਾ ਇੱਕ ਦੋ-ਅਯਾਮੀ ਐਰੇ ਨੂੰ ਦਰਸਾ ਸਕਦੀ ਹੈ।
ਇਹ ਭਾਗ ਦੱਸਦਾ ਹੈ ਕਿ ਇਸ ਦੋ-ਅਯਾਮੀ ਐਰੇ ਦੀਆਂ ਕਤਾਰਾਂ ਅਤੇ ਕਾਲਮਾਂ ਨੂੰ ਕਿਵੇਂ ਬਦਲਣਾ ਹੈ।
- NumPy ਐਰੇ ਵਿੱਚ ਬਦਲੋ
.Tਇਸ ਨਾਲ ਟ੍ਰਾਂਸਪੋਜ਼ ਕਰੋ.
pandas.DataFrameਇਸ ਵਿੱਚ ਤਬਦੀਲ ਕਰੋ.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 ਗੁਣ ਨਾਲ ਟ੍ਰਾਂਸਪੋਜ਼ਡ ਆਬਜੈਕਟ ਪ੍ਰਾਪਤ ਕਰੋ।
ਜੇਕਰ ਤੁਸੀਂ ਅੰਤ ਵਿੱਚ ਇੱਕ ਪਾਈਥਨ ਸੂਚੀ-ਕਿਸਮ ਦਾ ਆਬਜੈਕਟ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇਸਨੂੰ ਟੋਲਿਸਟ() ਵਿਧੀ ਨਾਲ ਸੂਚੀ ਵਿੱਚ ਬਦਲੋ।
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 ਨਾਲ ਟ੍ਰਾਂਸਪੋਜ਼ ਕੀਤਾ ਗਿਆ
ਮੂਲ ਦੋ-ਅਯਾਮੀ ਐਰੇ ਤੋਂ ਇੱਕ ਪਾਂਡਾ. ਡੇਟਾਫ੍ਰੇਮ ਬਣਾਓ ਅਤੇ .T ਗੁਣ ਨਾਲ ਟ੍ਰਾਂਸਪੋਜ਼ਡ ਆਬਜੈਕਟ ਪ੍ਰਾਪਤ ਕਰੋ।
ਜੇਕਰ ਤੁਸੀਂ ਅੰਤ ਵਿੱਚ ਪਾਈਥਨ ਸੂਚੀ-ਕਿਸਮ ਦਾ ਆਬਜੈਕਟ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਮੁੱਲ ਵਿਸ਼ੇਸ਼ਤਾ ਦੇ ਨਾਲ numpy.ndarray ਪ੍ਰਾਪਤ ਕਰੋ, ਅਤੇ ਫਿਰ ਇਸਨੂੰ ਟੋਲਿਸਟ() ਵਿਧੀ ਨਾਲ ਸੂਚੀ ਵਿੱਚ ਬਦਲੋ।
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() ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜੋ ਇੱਕ ਟੂਪਲ ਨੂੰ ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਵਿੱਚ ਇੱਕ ਸੂਚੀ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।
- ਸੰਬੰਧਿਤ:ਪਾਈਥਨ ਸੂਚੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ
- ਸੰਬੰਧਿਤ:ਪਾਈਥਨ ਵਿੱਚ ਸੂਚੀਆਂ ਅਤੇ ਟੂਪਲਾਂ ਨੂੰ ਇੱਕ ਦੂਜੇ ਵਿੱਚ ਬਦਲਣਾ: ਸੂਚੀ(), ਟੂਪਲ()
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]]
