ਪਾਈਥਨ ਫੰਕਸ਼ਨ ਵਿੱਚ ਮਲਟੀਪਲ ਰਿਟਰਨ ਵੈਲਯੂਜ਼ ਨੂੰ ਕਿਵੇਂ ਵਾਪਸ ਕਰਨਾ ਹੈ

C ਵਿੱਚ, ਇੱਕ ਫੰਕਸ਼ਨ ਤੋਂ ਮਲਟੀਪਲ ਰਿਟਰਨ ਵੈਲਯੂਜ਼ ਨੂੰ ਵਾਪਸ ਕਰਨਾ ਕਾਫ਼ੀ ਮੁਸ਼ਕਲ ਹੈ, ਪਰ ਪਾਈਥਨ ਵਿੱਚ, ਇਹ ਕਰਨਾ ਬਹੁਤ ਆਸਾਨ ਹੈ।

ਕਾਮਿਆਂ ਨਾਲ ਵੱਖ ਕਰਕੇ ਵਾਪਸੀ

ਪਾਈਥਨ ਵਿੱਚ, ਤੁਸੀਂ ਸਤਰ ਜਾਂ ਸੰਖਿਆਵਾਂ ਦੀ ਕਾਮੇ ਨਾਲ ਵੱਖ ਕੀਤੀ ਸੂਚੀ ਵਾਪਸ ਕਰ ਸਕਦੇ ਹੋ।

ਇੱਕ ਉਦਾਹਰਨ ਦੇ ਤੌਰ ‘ਤੇ, ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਹੇਠਾਂ ਦਰਸਾਏ ਅਨੁਸਾਰ ਸਿਰਫ ਇੱਕ ਸਤਰ ਅਤੇ ਇੱਕ ਨੰਬਰ ਦਿੰਦਾ ਹੈ, ਹਰੇਕ ਨੂੰ ਵਾਪਸੀ ਤੋਂ ਬਾਅਦ ਕਾਮੇ ਨਾਲ ਵੱਖ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

def test():
    return 'abc', 100

ਪਾਈਥਨ ਵਿੱਚ, ਕਾਮੇ ਨਾਲ ਵੱਖ ਕੀਤੇ ਮੁੱਲਾਂ ਨੂੰ ਬਰੈਕਟਾਂ ਤੋਂ ਬਿਨਾਂ ਟੂਪਲ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ, ਸਿਵਾਏ ਜਿੱਥੇ ਸਿੰਟੈਕਟਿਕ ਤੌਰ ‘ਤੇ ਜ਼ਰੂਰੀ ਹੁੰਦਾ ਹੈ। ਇਸ ਲਈ, ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਵਿੱਚ ਫੰਕਸ਼ਨ ਇੱਕ ਤੱਤ ਦੇ ਰੂਪ ਵਿੱਚ ਹਰੇਕ ਮੁੱਲ ਦੇ ਨਾਲ ਇੱਕ ਟੂਪਲ ਵਾਪਸ ਕਰੇਗਾ।

ਇਹ ਕੌਮਾ ਹੈ ਜੋ ਟੂਪਲ ਬਣਾਉਂਦਾ ਹੈ, ਨਾ ਕਿ ਗੋਲ ਬਰੈਕਟਾਂ। ਗੋਲ ਬਰੈਕਟਾਂ ਨੂੰ ਛੱਡਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਸਿਵਾਏ ਖਾਲੀ ਟੂਪਲਾਂ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਜਾਂ ਜਦੋਂ ਸੰਟੈਕਟਿਕ ਅਸਪਸ਼ਟਤਾ ਤੋਂ ਬਚਣ ਲਈ ਜ਼ਰੂਰੀ ਹੋਵੇ।
Built-in Types — Python 3.10.0 Documentation

ਵਾਪਸੀ ਮੁੱਲ ਦੀ ਕਿਸਮ ਇੱਕ ਟੂਪਲ ਹੈ।

result = test()

print(result)
print(type(result))
# ('abc', 100)
# <class 'tuple'>

ਹਰ ਤੱਤ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਕਿਸਮ ਦਾ ਹੋਵੇਗਾ।

print(result[0])
print(type(result[0]))
# abc
# <class 'str'>

print(result[1])
print(type(result[1]))
# 100
# <class 'int'>

ਗਲਤੀ ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਇੰਡੈਕਸ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹੋ ਜੋ ਤੁਹਾਡੇ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਵਾਪਸੀ ਮੁੱਲਾਂ ਦੀ ਸੰਖਿਆ ਤੋਂ ਵੱਧ ਹੈ।

# print(result[2])
# IndexError: tuple index out of range

ਇਹ ਅਨਪੈਕ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਵੱਖ-ਵੱਖ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਕਈ ਵਾਪਸੀ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ।

a, b = test()

print(a)
# abc

print(b)
# 100

ਇਹੀ ਲਾਗੂ ਹੁੰਦਾ ਹੈ ਜੇਕਰ ਤੁਸੀਂ ਸਿਰਫ਼ ਦੋ ਦੀ ਬਜਾਏ ਤਿੰਨ ਜਾਂ ਵਧੇਰੇ ਵਾਪਸੀ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ।

def test2():
    return 'abc', 100, [0, 1, 2]

a, b, c = test2()

print(a)
# abc

print(b)
# 100

print(c)
# [0, 1, 2]

ਇੱਕ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ।

[]ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਨੂੰ ਇਸ ਨਾਲ ਨੱਥੀ ਕਰਦੇ ਹੋ, ਤਾਂ ਵਾਪਸੀ ਦਾ ਮੁੱਲ ਟੂਪਲ ਦੀ ਬਜਾਏ ਇੱਕ ਸੂਚੀ ਹੋਵੇਗਾ।

def test_list():
    return ['abc', 100]

result = test_list()

print(result)
print(type(result))
# ['abc', 100]
# <class 'list'>