పైథాన్ ఫంక్షన్‌లో బహుళ రిటర్న్ విలువలను ఎలా తిరిగి ఇవ్వాలి

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'>