ਪਾਈਥਨ ਦਾ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ zip() ਮਲਟੀਪਲ ਦੁਹਰਾਉਣਯੋਗ ਆਬਜੈਕਟ (ਸੂਚੀਆਂ, ਟੂਪਲਜ਼, ਆਦਿ) ਦੇ ਤੱਤਾਂ ਨੂੰ ਜੋੜਦਾ ਹੈ ਅਤੇ ਲੂਪ ਲਈ ਕਈ ਸੂਚੀਆਂ ਦੇ ਤੱਤਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
ਇਹ ਭਾਗ zip() ਫੰਕਸ਼ਨ ਦੀ ਨਿਮਨਲਿਖਤ ਵਰਤੋਂ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ।
- ਇੱਕ ਲਈ ਲੂਪ ਵਿੱਚ ਕਈ ਸੂਚੀਆਂ ਦੇ ਤੱਤ ਪ੍ਰਾਪਤ ਕਰੋ।
- ਵੱਖ-ਵੱਖ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਨਾਲ ਨਜਿੱਠਣਾ
zip():ਫੰਕਸ਼ਨ ਉਹਨਾਂ ਤੱਤਾਂ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰੇਗਾ ਜੋ ਬਹੁਤ ਜ਼ਿਆਦਾ ਹਨ।itertools.zip_longest():ਇਹ ਫੰਕਸ਼ਨ ਗੁੰਮ ਹੋਏ ਤੱਤਾਂ ਨੂੰ ਭਰ ਦੇਵੇਗਾ।
- ਮਲਟੀਪਲ ਦੁਹਰਾਓ ਦੇ ਤੱਤਾਂ ਦੇ ਟੁਪਲਾਂ ਦੀ ਸੂਚੀ ਪ੍ਰਾਪਤ ਕਰੋ।
ਇੱਕ ਲਈ ਲੂਪ ਵਿੱਚ ਕਈ ਸੂਚੀਆਂ ਦੇ ਤੱਤ ਪ੍ਰਾਪਤ ਕਰੋ।
ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਲਈ ਲੂਪ ਵਿੱਚ ਇੱਕੋ ਸਮੇਂ ਇੱਕ ਤੋਂ ਵੱਧ ਦੁਹਰਾਉਣਯੋਗ ਵਸਤੂਆਂ (ਸੂਚੀਆਂ, ਟੂਪਲਾਂ, ਆਦਿ) ਦੇ ਤੱਤਾਂ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨਾ ਅਤੇ ਵਰਤਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਉਹਨਾਂ ਨੂੰ zip() ਫੰਕਸ਼ਨ ਲਈ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਦਿਓ।
names = ['Alice', 'Bob', 'Charlie'] ages = [24, 50, 18] for name, age in zip(names, ages): print(name, age) # Alice 24 # Bob 50 # Charlie 18
ਸਿਰਫ਼ ਦੋ ਨਹੀਂ, ਸਗੋਂ ਤਿੰਨ ਜਾਂ ਵੱਧ ਵੀ।
points = [100, 85, 90] for name, age, point in zip(names, ages, points): print(name, age, point) # Alice 24 100 # Bob 50 85 # Charlie 18 90
ਵੱਖ-ਵੱਖ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਨਾਲ ਨਜਿੱਠਣਾ
zip() ਫੰਕਸ਼ਨ ਬਹੁਤ ਸਾਰੇ ਤੱਤਾਂ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਦਾ ਹੈ।
zip() ਫੰਕਸ਼ਨ ਵਿੱਚ, ਜੇਕਰ ਹਰੇਕ ਸੂਚੀ ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਸੰਖਿਆ ਵੱਖਰੀ ਹੈ, ਤਾਂ ਤੱਤਾਂ ਦੀ ਘੱਟ (ਛੋਟੀ) ਸੰਖਿਆ ਤੱਕ ਵਾਪਸ ਕੀਤੀ ਜਾਵੇਗੀ, ਅਤੇ ਵੱਡੀ ਸੰਖਿਆ ਨੂੰ ਅਣਡਿੱਠ ਕੀਤਾ ਜਾਵੇਗਾ।
names = ['Alice', 'Bob', 'Charlie', 'Dave'] ages = [24, 50, 18] for name, age in zip(names, ages): print(name, age) # Alice 24 # Bob 50 # Charlie 18
itertools.zip_longest() ਫੰਕਸ਼ਨ ਗੁੰਮ ਹੋਏ ਤੱਤਾਂ ਨੂੰ ਭਰ ਦੇਵੇਗਾ।
ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ ਆਈਟਰਟੂਲਸ ਮੋਡੀਊਲ ਵਿੱਚ zip_longest() ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਹਰ ਸੂਚੀ ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਸੰਖਿਆ ਵੱਖਰੀ ਹੋਣ ‘ਤੇ ਆਰਬਿਟਰਰੀ ਮੁੱਲਾਂ ਨਾਲ ਗੁੰਮ ਹੋਏ ਤੱਤਾਂ ਨੂੰ ਭਰਨਾ ਸੰਭਵ ਹੈ।
ਮੂਲ ਰੂਪ ਵਿੱਚ, ਇਹ None ਨਾਲ ਭਰਿਆ ਹੋਇਆ ਹੈ।
from itertools import zip_longest names = ['Alice', 'Bob', 'Charlie', 'Dave'] ages = [24, 50, 18] for name, age in zip_longest(names, ages): print(name, age) # Alice 24 # Bob 50 # Charlie 18 # Dave None
ਜੇਕਰ ਫਿਲਵੈਲੂ ਆਰਗੂਮੈਂਟ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਇਹ ਉਸ ਮੁੱਲ ਨਾਲ ਭਰਿਆ ਜਾਵੇਗਾ।
for name, age in zip_longest(names, ages, fillvalue=20): print(name, age) # Alice 24 # Bob 50 # Charlie 18 # Dave 20
ਭਾਵੇਂ ਗੁੰਮ ਤੱਤਾਂ ਵਾਲੀਆਂ ਕਈ ਸੂਚੀਆਂ ਹੋਣ, ਭਰਿਆ ਜਾਣ ਵਾਲਾ ਮੁੱਲ ਇਕਸਾਰ ਹੈ। ਵੱਖ-ਵੱਖ ਮੁੱਲਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨਾ ਸੰਭਵ ਨਹੀਂ ਹੈ।
points = [100, 85] for name, age, point in zip_longest(names, ages, points, fillvalue=20): print(name, age, point) # Alice 24 100 # Bob 50 85 # Charlie 18 20 # Dave 20 20
zip_longest() ਦੇ ਅੰਦਰ zip_longest() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਵੱਖਰਾ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਨਾ ਸੰਭਵ ਹੈ, ਪਰ ਇਹ ਵਿਹਾਰਕ ਨਹੀਂ ਹੈ ਕਿਉਂਕਿ ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਤੋਂ ਇਹ ਜਾਣਨ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ ਕਿ ਸੂਚੀ ਦੇ ਕਿਹੜੇ ਤੱਤ ਗੁੰਮ ਹਨ।
ਜੇਕਰ ਤੁਸੀਂ ਕਈ ਸੂਚੀਆਂ ਨੂੰ ਅਣਜਾਣ ਤੱਤਾਂ ਦੇ ਨਾਲ ਭਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਹਰੇਕ ਦਾ ਇੱਕ ਵੱਖਰਾ ਮੁੱਲ ਹੈ, ਤਾਂ ਹੇਠਾਂ ਦਿੱਤੀ ਪ੍ਰਕਿਰਿਆ ‘ਤੇ ਵਿਚਾਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
- ਸਾਰੀਆਂ ਸੂਚੀਆਂ ਨੂੰ ਭਰਨ ਲਈ ਮੁੱਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।
- ਤੱਤਾਂ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਗਿਣਤੀ ਪ੍ਰਾਪਤ ਕਰੋ
- ਸਾਰੀਆਂ ਸੂਚੀਆਂ ਨੂੰ ਤੱਤਾਂ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਗਿਣਤੀ ਵਿੱਚ ਭਰੋ
- zip() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨਾ
fill_name = 'XXX' fill_age = 20 fill_point = 50 len_names = len(names) len_ages = len(ages) len_points = len(points) max_len = max(len_names, len_ages, len_points) names = names + [fill_name] * (max_len - len_names) ages = ages + [fill_age] * (max_len - len_ages) points = points + [fill_point] * (max_len - len_points) print(names) print(ages) print(points) # ['Alice', 'Bob', 'Charlie', 'Dave'] # [24, 50, 18, 20] # [100, 85, 50, 50] for name, age, point in zip(names, ages, points): print(name, age, point) # Alice 24 100 # Bob 50 85 # Charlie 18 50 # Dave 20 50
ਤੱਤਾਂ ਦੀ ਸਭ ਤੋਂ ਵੱਡੀ ਗਿਣਤੀ ਨੂੰ ਭਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ, ਅਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਕੰਮ ਕਰਦੇ ਹਾਂ।
- ਕਿਸੇ ਮਨਮਾਨੇ ਮੁੱਲ ਅਤੇ ਤੱਤਾਂ ਦੀ ਸੰਖਿਆ ਨਾਲ ਇੱਕ ਸੂਚੀ ਸ਼ੁਰੂ ਕਰਨਾ
- + ਸੂਚੀਆਂ ਨੂੰ ਇਕੱਠੇ ਜੋੜਨ ਲਈ ਆਪਰੇਟਰ
ਜੇਕਰ ਅਸੀਂ ਇਸਨੂੰ ਫੰਕਸ਼ਨ ਵਿੱਚ ਬਦਲਦੇ ਹਾਂ, ਤਾਂ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ। ਅਸਲ ਸੂਚੀ ਅਤੇ ਸੂਚੀ ਨੂੰ ਭਰਨ ਵਾਲੇ ਮੁੱਲਾਂ ਨੂੰ ਕ੍ਰਮਵਾਰ ਦੁਹਰਾਉਣਯੋਗ (ਸੂਚੀ ਜਾਂ ਟੂਪਲ) ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਦਰਸਾਏ ਗਏ ਹਨ।
def my_zip_longest(iterables, fillvalues): max_len = max(len(i) for i in iterables) return zip(*[list(i) + [v] * (max_len - len(i)) for i, v in zip(iterables, fillvalues)]) for name, age, point in my_zip_longest((names, ages, points), ('XXX', 20, 50)): print(name, age, point) # Alice 24 100 # Bob 50 85 # Charlie 18 50 # Dave 20 50
ਇਹ ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਅਤੇ * ਦੁਆਰਾ ਸੂਚੀ ਵਿਸਥਾਰ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।
- ਸੰਬੰਧਿਤ ਲੇਖ:ਪਾਈਥਨ ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਦੀ ਵਰਤੋਂ ਕਰਨਾ
ਮਲਟੀਪਲ ਦੁਹਰਾਓ ਦੇ ਤੱਤਾਂ ਦੇ ਟੁਪਲਾਂ ਦੀ ਸੂਚੀ ਪ੍ਰਾਪਤ ਕਰੋ।
zip() ਫੰਕਸ਼ਨ ਇੱਕ ਇਟਰੇਟਰ (ਜ਼ਿਪ ਆਬਜੈਕਟ) ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ ਕਿ ਕਈ ਦੁਹਰਾਉਣ ਯੋਗ ਵਸਤੂਆਂ ਦੇ ਤੱਤਾਂ ਦਾ ਇੱਕ ਟੁਪਲ ਹੈ।
ਇਹ ਲੂਪ ਲਈ ਦੇ ਬਾਹਰ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ ਟੀਚਾ ਸੂਚੀਆਂ ਤੱਕ ਸੀਮਿਤ ਨਹੀਂ ਹੈ।
names = ['Alice', 'Bob', 'Charlie'] ages = (24, 50, 18) z = zip(names, ages) print(z) print(type(z)) # <zip object at 0x10b57b888> # <class 'zip'>
ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਟੂਪਲ ਦੇ ਤੌਰ ‘ਤੇ ਕਈ ਦੁਹਰਾਉਣ ਯੋਗ ਵਸਤੂਆਂ ਦੇ ਤੱਤਾਂ ਦੀ ਸੂਚੀ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਸੂਚੀ ਬਣਾਉਣ ਲਈ list() ਦੀ ਵਰਤੋਂ ਕਰੋ।
l = list(zip(names, ages)) print(l) print(type(l)) print(type(l[0])) # [('Alice', 24), ('Bob', 50), ('Charlie', 18)] # <class 'list'> # <class 'tuple'>
