પાયથોન ફંક્શનમાં બહુવિધ વળતર મૂલ્યો કેવી રીતે પરત કરવી

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