પાયથોનમાં ટ્યુપલ્સ અને લિસ્ટને અનપૅક કરો (બહુવિધ ચલોને વિસ્તૃત કરો અને સોંપો).

બિઝનેસ

પાયથોનમાં, ટ્યુપલ અથવા સૂચિના ઘટકોને વિસ્તૃત કરી શકાય છે અને બહુવિધ ચલોને સોંપી શકાય છે. આને સિક્વન્સ અનપેકિંગ અથવા અનપેક્ડ અસાઇનમેન્ટ કહેવામાં આવે છે.

નીચેની વિગતો અહીં વર્ણવેલ છે.

  • ટ્યુપલ્સ અને સૂચિની મૂળભૂત બાબતોને અનપૅક કરવી
  • નેસ્ટેડ ટ્યુપલ્સ, અનપેક્ડ સૂચિઓ
  • અંડરસ્કોર્સ સાથે અનપૅકિંગ:_
  • ફૂદડી સાથે અનપેકિંગ:*

ફંક્શન દલીલો તરીકે ટ્યુપલ્સ, સૂચિઓ અને શબ્દકોશોને વિસ્તૃત કરવા અને પસાર કરવા માટે ફૂદડીનો ઉપયોગ કરવા વિશેની માહિતી માટે નીચેનો લેખ જુઓ.

ટ્યુપલ્સ અને સૂચિની મૂળભૂત બાબતોને અનપૅક કરવી

જ્યારે ચલો ડાબી બાજુએ લખવામાં આવે છે, અલ્પવિરામ દ્વારા અલગ કરીને, દરેક ચલને જમણી બાજુએ ટ્યુપલ અથવા સૂચિનું એક ઘટક સોંપવામાં આવે છે. તે ટ્યુપલ્સ અને સૂચિ બંને માટે સમાન છે (નીચેના ઉદાહરણો ટ્યુપલ સ્વરૂપમાં લખાયેલા છે).

t = (0, 1, 2)

a, b, c = t

print(a)
print(b)
print(c)
# 0
# 1
# 2

l = [0, 1, 2]

a, b, c = l

print(a)
print(b)
print(c)
# 0
# 1
# 2

નોંધ કરો કે ટ્યુપલ્સ ગોળાકાર કૌંસને છોડી શકે છે, તેથી તેનો ઉપયોગ નીચે પ્રમાણે એક લીટી પર બહુવિધ ચલોને બહુવિધ મૂલ્યો સોંપવા માટે થઈ શકે છે.

a, b = 0, 1

print(a)
print(b)
# 0
# 1

જો ચલોની સંખ્યા તત્વોની સંખ્યા સાથે મેળ ખાતી નથી, તો એક ભૂલ થાય છે.

# a, b = t
# ValueError: too many values to unpack (expected 2)

# a, b, c, d = t
# ValueError: not enough values to unpack (expected 4, got 3)

જો ચલોની સંખ્યા તત્વોની સંખ્યા કરતા ઓછી હોય, તો બાકીના ઘટકોને ચલના નામમાં ફૂદડી ઉમેરીને સૂચિ તરીકે અસાઇન કરી શકાય છે (નીચે જુઓ).

નેસ્ટેડ ટ્યુપલ્સ, અનપેક્ડ સૂચિઓ

નેસ્ટેડ ટ્યુપલ્સ અને સૂચિઓ પણ અનપેક કરી શકાય છે. જો તમે સામગ્રીને પણ અનપૅક કરવા માંગતા હો, તો નીચેનામાંથી એકમાં વેરીએબલને બંધ કરો

  • ()
  • []
t = (0, 1, (2, 3, 4))

a, b, c = t

print(a)
print(b)
print(c)
# 0
# 1
# (2, 3, 4)

print(type(c))
# <class 'tuple'>

a, b, (c, d, e) = t

print(a)
print(b)
print(c)
print(d)
print(e)
# 0
# 1
# 2
# 3
# 4

_અંડરસ્કોર_ સાથે અનપેક્ડ.

પાયથોનમાં, માત્ર અનપેક્ડ જ નહીં, જરૂરી ન હોય તેવા મૂલ્યોને પરંપરાગત રીતે અન્ડરસ્કોર (અંડરસ્કોર) _ ને સોંપવામાં આવે છે. ત્યાં કોઈ ખાસ વ્યાકરણીય અર્થ નથી; તેઓ ફક્ત _ નામના ચલને સોંપેલ છે.

t = (0, 1, 2)

a, b, _ = t

print(a)
print(b)
print(_)
# 0
# 1
# 2

ફૂદડી સાથે અનપેકિંગ

જો ચલોની સંખ્યા તત્વોની સંખ્યા કરતા ઓછી હોય, તો વેરીએબલના નામમાં ફૂદડીના કારણે તત્વોને સૂચિ તરીકે એકસાથે સોંપવામાં આવશે.

આ વાક્યરચના Python 3 થી લાગુ કરવામાં આવી છે અને Python 2 માં ઉપલબ્ધ નથી.

ફૂદડી વગરના ચલોને એલિમેન્ટ્સ શરૂઆતથી અને અંતથી અસાઇન કરવામાં આવે છે અને બાકીના એલિમેન્ટ્સ ફૂદડી સાથેના ચલોને સૂચિ તરીકે અસાઇન કરવામાં આવે છે.

t = (0, 1, 2, 3, 4)

a, b, *c = t

print(a)
print(b)
print(c)
# 0
# 1
# [2, 3, 4]

print(type(c))
# <class 'list'>

a, *b, c = t

print(a)
print(b)
print(c)
# 0
# [1, 2, 3]
# 4

*a, b, c = t

print(a)
print(b)
print(c)
# [0, 1, 2]
# 3
# 4

ઉદાહરણ તરીકે, જો તમે વેરીએબલને ટ્યુપલ અથવા સૂચિના ફક્ત પ્રથમ બે ઘટકો સોંપવા માંગતા હો, તો તમે જરૂરી ન હોય તેવા ભાગો માટે ઉપરોક્ત અન્ડરસ્કોરનો ઉપયોગ કરી શકો છો.

a, b, *_ = t

print(a)
print(b)
print(_)
# 0
# 1
# [2, 3, 4]

તે જ નીચે મુજબ પણ લખી શકાય છે

a, b = t[0], t[1]

print(a)
print(b)
# 0
# 1

માત્ર એક ફૂદડી જોડી શકાય છે. જો ત્યાં ફૂદડી સાથે ચિહ્નિત બહુવિધ વેરિયેબલ્સ હોય, તો સિન્ટેક્સ એરર ભૂલ પરિણમશે કારણ કે તે નક્કી કરવું શક્ય નથી કે દરેક વેરીએબલને કેટલા તત્વો અસાઇન કરવામાં આવ્યા છે.

# *a, b, *c = t
# SyntaxError: two starred expressions in assignment

નોંધ કરો કે ફૂદડી સાથે ચિહ્નિત થયેલ ચલને અસાઇન કરેલ એક પણ તત્વ સૂચિ તરીકે અસાઇન કરેલ છે.

t = (0, 1, 2)

a, b, *c = t

print(a)
print(b)
print(c)
# 0
# 1
# [2]

print(type(c))
# <class 'list'>

જો ત્યાં કોઈ વધારાના ઘટકો ન હોય, તો ખાલી સૂચિ સોંપવામાં આવે છે.

a, b, c, *d = t

print(a)
print(b)
print(c)
print(d)
# 0
# 1
# 2
# []