ਪਾਈਥਨ ਵਿੱਚ ਦੋ ਸੂਚੀਆਂ ਨੂੰ ਜੋੜਨਾ: ਢੰਗ ਅਤੇ ਉਦਾਹਰਨਾਂ

ਪਾਈਥਨ ਵਿੱਚ ਸੂਚੀ ਜੋੜਨ ਨੂੰ ਸਮਝਣਾ

ਪਾਈਥਨ ਵਿੱਚ ਸੂਚੀਆਂ ਨੂੰ ਜੋੜਨਾ ਇੱਕ ਆਮ ਕੰਮ ਹੈ ਜਿਸ ਵਿੱਚ ਦੋ ਜਾਂ ਵੱਧ ਸੂਚੀਆਂ ਨੂੰ ਇੱਕ ਸਿੰਗਲ, ਯੂਨੀਫਾਈਡ ਸੂਚੀ ਵਿੱਚ ਮਿਲਾਉਣਾ ਸ਼ਾਮਲ ਹੈ। ਇਹ ਓਪਰੇਸ਼ਨ ਵੱਖ-ਵੱਖ ਸਥਿਤੀਆਂ ਵਿੱਚ ਲਾਭਦਾਇਕ ਹੈ, ਜਿਵੇਂ ਕਿ ਡੇਟਾ ਏਗਰੀਗੇਸ਼ਨ, ਹੇਰਾਫੇਰੀ, ਅਤੇ ਜਦੋਂ ਤੁਹਾਨੂੰ ਤੱਤਾਂ ਦੇ ਕ੍ਰਮ ਨੂੰ ਕਾਇਮ ਰੱਖਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਪਾਈਥਨ, ਇੱਕ ਬਹੁਮੁਖੀ ਭਾਸ਼ਾ ਹੋਣ ਕਰਕੇ, ਇਸ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਕਈ ਤਰੀਕੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਪਾਈਥਨ ਵਿੱਚ ਸੂਚੀਆਂ ਨੂੰ ਜੋੜਨ ਲਈ ਵੱਖ-ਵੱਖ ਤਕਨੀਕਾਂ ਦੀ ਪੜਚੋਲ ਕਰਾਂਗੇ, ਜਿਸ ਵਿੱਚ + ਆਪਰੇਟਰ, ਐਕਸਟੈਂਡ() ਵਿਧੀ, ਅਤੇ ਸੂਚੀ ਸਮਝਣਾ ਸ਼ਾਮਲ ਹੈ। ਇਹਨਾਂ ਤਰੀਕਿਆਂ ਨੂੰ ਸਮਝ ਕੇ, ਤੁਸੀਂ ਇੱਕ ਚੁਣ ਸਕਦੇ ਹੋ ਜੋ ਤੁਹਾਡੀਆਂ ਲੋੜਾਂ ਅਤੇ ਕੋਡਿੰਗ ਸ਼ੈਲੀ ਦੇ ਅਨੁਕੂਲ ਹੋਵੇ। ਆਓ ਉਦਾਹਰਣਾਂ ਅਤੇ ਵਿਆਖਿਆਵਾਂ ਦੇ ਨਾਲ ਵੇਰਵਿਆਂ ਵਿੱਚ ਡੂੰਘਾਈ ਕਰੀਏ।

ਸੂਚੀ ਜੋੜਨ ਦੀਆਂ ਤਕਨੀਕਾਂ ਨੂੰ ਸਮਝਣਾ

ਪਾਈਥਨ ਵਿੱਚ ਦੋ ਸੂਚੀਆਂ ਨੂੰ ਜੋੜਨ ਲਈ ਦਿੱਤੀਆਂ ਗਈਆਂ ਸਕ੍ਰਿਪਟਾਂ ਭਾਸ਼ਾ ਦੀ ਬਹੁਪੱਖੀਤਾ ਅਤੇ ਸਰਲਤਾ ਨੂੰ ਦਰਸਾਉਂਦੀਆਂ ਵੱਖ-ਵੱਖ ਵਿਧੀਆਂ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦੀਆਂ ਹਨ। ਪਹਿਲਾ ਤਰੀਕਾ ਵਰਤਦਾ ਹੈ + ਆਪਰੇਟਰ, ਜੋ ਕਿ ਸਿੱਧਾ ਅਤੇ ਵਰਤਣ ਵਿੱਚ ਆਸਾਨ ਹੈ। ਇਹ ਇੱਕ ਨਵੀਂ ਸੂਚੀ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਦੋਵਾਂ ਸੂਚੀਆਂ ਦੇ ਤੱਤਾਂ ਨੂੰ ਜੋੜਦਾ ਹੈ। ਇਹ ਵਿਧੀ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਲਈ ਆਦਰਸ਼ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਅਸਲ ਸੂਚੀਆਂ ਨੂੰ ਬਦਲਿਆ ਨਹੀਂ ਰੱਖਣਾ ਚਾਹੁੰਦੇ ਹੋ। ਦੂਜਾ ਤਰੀਕਾ ਵਰਤਦਾ ਹੈ extend() ਵਿਧੀ, ਜੋ ਨਿਰਧਾਰਤ ਦੁਹਰਾਉਣਯੋਗ (ਇਸ ਕੇਸ ਵਿੱਚ ਇੱਕ ਹੋਰ ਸੂਚੀ) ਤੋਂ ਸਾਰੀਆਂ ਆਈਟਮਾਂ ਨੂੰ ਸੂਚੀ ਦੇ ਅੰਤ ਵਿੱਚ ਜੋੜਦੀ ਹੈ ਜਿਸ 'ਤੇ ਇਸਨੂੰ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਵਿਧੀ ਮੂਲ ਸੂਚੀ ਨੂੰ ਸੰਸ਼ੋਧਿਤ ਕਰਦੀ ਹੈ, ਇਸ ਨੂੰ ਲਾਭਦਾਇਕ ਬਣਾਉਂਦੀ ਹੈ ਜਦੋਂ ਤੁਹਾਨੂੰ ਵਾਧੂ ਤੱਤਾਂ ਨਾਲ ਮੌਜੂਦਾ ਸੂਚੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਤੀਜੀ ਵਿਧੀ ਸੂਚੀ ਦੀ ਸਮਝ ਨੂੰ ਨਿਯੁਕਤ ਕਰਦੀ ਹੈ, ਤੱਤ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਅਤੇ ਇੱਕ ਨਵੀਂ ਸੂਚੀ ਵਾਪਸ ਕਰਨ ਦਾ ਇੱਕ ਸੰਖੇਪ ਅਤੇ ਕੁਸ਼ਲ ਤਰੀਕਾ। ਇਹ ਪਹੁੰਚ ਬਹੁਤ ਜ਼ਿਆਦਾ ਅਨੁਕੂਲਿਤ ਹੈ, ਕੋਡ ਦੀ ਇੱਕ ਲਾਈਨ ਦੇ ਅੰਦਰ ਗੁੰਝਲਦਾਰ ਕਾਰਵਾਈਆਂ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਚੌਥਾ ਤਰੀਕਾ ਸ਼ਾਮਲ ਹੈ itertools.chain() itertools ਮੋਡੀਊਲ ਤੋਂ, ਜੋ ਕਿ ਕੁਸ਼ਲ ਦੁਹਰਾਅ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਹ ਮਲਟੀਪਲ ਦੁਹਰਾਓ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇੱਕ ਸਿੰਗਲ ਇਟਰੇਟਰ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਕ੍ਰਮ ਵਿੱਚ ਹਰੇਕ ਦੁਹਰਾਉਣਯੋਗ ਤੋਂ ਤੱਤ ਪੈਦਾ ਕਰਦਾ ਹੈ। ਇਹ ਵਿਧੀ ਖਾਸ ਤੌਰ 'ਤੇ ਵੱਡੇ ਡੇਟਾਸੇਟਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਉਪਯੋਗੀ ਹੈ। ਅੰਤਮ ਢੰਗ ਵਰਤਦਾ ਹੈ numpy.concatenate() NumPy ਲਾਇਬ੍ਰੇਰੀ ਤੋਂ, ਸੰਖਿਆਤਮਕ ਕਾਰਵਾਈਆਂ ਲਈ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਟੂਲ। ਇਹ ਇੱਕ ਮੌਜੂਦਾ ਧੁਰੀ ਦੇ ਨਾਲ ਐਰੇ ਦੇ ਇੱਕ ਕ੍ਰਮ ਨੂੰ ਜੋੜਦਾ ਹੈ, ਅਤੇ tolist() ਵਿਧੀ ਨਤੀਜੇ ਵਾਲੀ ਐਰੇ ਨੂੰ ਪਾਈਥਨ ਸੂਚੀ ਵਿੱਚ ਬਦਲਦੀ ਹੈ। ਇਹ ਵਿਧੀ ਸੰਖਿਆਤਮਕ ਡੇਟਾ ਅਤੇ NumPy ਦੇ ਪ੍ਰਦਰਸ਼ਨ ਲਾਭਾਂ ਦੀ ਲੋੜ ਵਾਲੇ ਦ੍ਰਿਸ਼ਾਂ ਲਈ ਅਨੁਕੂਲ ਹੈ।

listone = [1, 2, 3]
listtwo = [4, 5, 6]
joinedlist = listone + listtwo
print(joinedlist)

listone = [1, 2, 3]
listtwo = [4, 5, 6]
listone.extend(listtwo)
print(listone)

listone = [1, 2, 3]
listtwo = [4, 5, 6]
joinedlist = [item for sublist in [listone, listtwo] for item in sublist]
print(joinedlist)

import itertools
listone = [1, 2, 3]
listtwo = [4, 5, 6]
joinedlist = list(itertools.chain(listone, listtwo))
print(joinedlist)

import numpy as np
listone = [1, 2, 3]
listtwo = [4, 5, 6]
joinedlist = np.concatenate((listone, listtwo)).tolist()
print(joinedlist)

ਸੂਚੀ ਜੋੜਨ ਲਈ ਉੱਨਤ ਤਕਨੀਕਾਂ

ਪਾਈਥਨ ਵਿੱਚ ਸੂਚੀਆਂ ਨੂੰ ਜੋੜਨ ਦੇ ਬੁਨਿਆਦੀ ਤਰੀਕਿਆਂ ਤੋਂ ਇਲਾਵਾ, ਇੱਥੇ ਉੱਨਤ ਤਕਨੀਕਾਂ ਹਨ ਜੋ ਵਧੇਰੇ ਲਚਕਤਾ ਅਤੇ ਕੁਸ਼ਲਤਾ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ। ਇੱਕ ਅਜਿਹਾ ਤਰੀਕਾ ਵਰਤ ਰਿਹਾ ਹੈ zip() ਸੂਚੀ ਦੀ ਸਮਝ ਦੇ ਨਾਲ ਸੁਮੇਲ ਵਿੱਚ ਫੰਕਸ਼ਨ. ਦ zip() ਫੰਕਸ਼ਨ ਦੋ ਜਾਂ ਦੋ ਤੋਂ ਵੱਧ ਦੁਹਰਾਓ (ਜਿਵੇਂ ਕਿ ਸੂਚੀਆਂ) ਤੋਂ ਤੱਤ ਜੋੜਦਾ ਹੈ ਅਤੇ ਟੂਪਲਾਂ ਦਾ ਇੱਕ ਦੁਹਰਾਓ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇੱਕ ਸੂਚੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਤੁਸੀਂ ਇਹਨਾਂ ਟੂਪਲਾਂ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਸੂਚੀ ਵਿੱਚ ਸਮਤਲ ਕਰ ਸਕਦੇ ਹੋ, ਇੱਕ ਕਸਟਮ ਤਰੀਕੇ ਨਾਲ ਸੂਚੀਆਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਮਿਲਾ ਸਕਦੇ ਹੋ। ਇਹ ਤਕਨੀਕ ਖਾਸ ਤੌਰ 'ਤੇ ਲਾਭਦਾਇਕ ਹੁੰਦੀ ਹੈ ਜਦੋਂ ਤੁਹਾਨੂੰ ਸੂਚੀਆਂ ਤੋਂ ਐਲੀਮੈਂਟਸ ਨੂੰ ਇੱਕ ਦੂਜੇ ਨਾਲ ਜੋੜਨ ਦੀ ਬਜਾਏ ਇੰਟਰਲੀਵ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਇੱਕ ਹੋਰ ਉੱਨਤ ਢੰਗ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸ਼ਾਮਲ ਹੈ map() ਦੇ ਨਾਲ ਫੰਕਸ਼ਨ lambda ਫੰਕਸ਼ਨ। ਦ map() ਫੰਕਸ਼ਨ ਇੱਕ ਦਿੱਤੇ ਫੰਕਸ਼ਨ ਨੂੰ ਇੱਕ ਇਨਪੁਟ ਸੂਚੀ ਵਿੱਚ ਸਾਰੀਆਂ ਆਈਟਮਾਂ 'ਤੇ ਲਾਗੂ ਕਰਦਾ ਹੈ, ਅਤੇ lambda ਫੰਕਸ਼ਨ ਇਸ ਕਾਰਵਾਈ ਨੂੰ ਇਨਲਾਈਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਸਕਦਾ ਹੈ। ਇਹ ਪਹੁੰਚ ਸੂਚੀਆਂ ਦੇ ਤੱਤਾਂ ਦੇ ਹਰੇਕ ਜੋੜੇ ਵਿੱਚ ਗੁੰਝਲਦਾਰ ਪਰਿਵਰਤਨ ਲਾਗੂ ਕਰਨ ਲਈ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਵੱਡੇ ਪੈਮਾਨੇ ਦੇ ਡੇਟਾ ਹੇਰਾਫੇਰੀ ਲਈ, ਲਾਇਬ੍ਰੇਰੀਆਂ ਜਿਵੇਂ ਕਿ pandas ਲਾਭਦਾਇਕ ਹੋ ਸਕਦਾ ਹੈ। ਦ pandas.concat() ਫੰਕਸ਼ਨ ਇੱਕ ਖਾਸ ਧੁਰੀ ਦੇ ਨਾਲ ਸੂਚੀਆਂ (ਜਾਂ ਸੀਰੀਜ਼ ਅਤੇ ਡੇਟਾਫ੍ਰੇਮ) ਨੂੰ ਜੋੜਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ, ਉੱਚ ਪੱਧਰੀ ਨਿਯੰਤਰਣ ਅਤੇ ਕੁਸ਼ਲਤਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਟੇਬਲਯੂਲਰ ਡੇਟਾ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ।

ਸੂਚੀ ਜੋੜਨ 'ਤੇ ਅੰਤਿਮ ਵਿਚਾਰ

ਸਿੱਟੇ ਵਜੋਂ, ਪਾਈਥਨ ਵਿੱਚ ਸੂਚੀਆਂ ਨੂੰ ਜੋੜਨਾ ਇੱਕ ਬੁਨਿਆਦੀ ਹੁਨਰ ਹੈ ਜੋ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਨਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਸਧਾਰਨ ਤੱਕ + ਆਪਰੇਟਰ ਅਤੇ extend() ਹੋਰ ਤਕਨੀਕੀ ਤਕਨੀਕਾਂ ਜਿਵੇਂ ਕਿ ਵਿਧੀ itertools.chain() ਅਤੇ numpy.concatenate(), ਹਰੇਕ ਪਹੁੰਚ ਦੇ ਆਪਣੇ ਵਿਲੱਖਣ ਫਾਇਦੇ ਹਨ। ਇਹਨਾਂ ਤਰੀਕਿਆਂ ਨੂੰ ਸਮਝਣਾ ਤੁਹਾਨੂੰ ਤੁਹਾਡੀਆਂ ਖਾਸ ਲੋੜਾਂ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਟੂਲ ਚੁਣਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਭਾਵੇਂ ਤੁਸੀਂ ਛੋਟੀਆਂ ਸੂਚੀਆਂ ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਹੋ ਜਾਂ ਵੱਡੇ ਡੇਟਾਸੈਟਾਂ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਸੰਭਾਲ ਰਹੇ ਹੋ।