పైథాన్‌లో, టుపుల్ లేదా జాబితా యొక్క మూలకాలు విస్తరించబడతాయి మరియు బహుళ వేరియబుల్స్‌కు కేటాయించబడతాయి. దీనిని సీక్వెన్స్ అన్‌ప్యాకింగ్ లేదా అన్‌ప్యాక్డ్ అసైన్‌మెంట్ అంటారు.
కింది వివరాలు ఇక్కడ వివరించబడ్డాయి.
- టుపుల్స్ మరియు లిస్ట్‌ల బేసిక్స్ అన్‌ప్యాక్ చేయడం
- నెస్టెడ్ టుపుల్స్, అన్‌ప్యాక్డ్ లిస్టింగ్‌లు
- అండర్‌స్కోర్‌లతో అన్‌ప్యాక్ చేయడం:
_ - ఆస్టరిస్క్‌లతో అన్‌ప్యాక్ చేస్తోంది:
*
టుపుల్స్, లిస్ట్‌లు మరియు డిక్షనరీలను ఫంక్షన్ ఆర్గ్యుమెంట్‌లుగా విస్తరించడానికి మరియు పాస్ చేయడానికి ఆస్టరిస్క్‌లను ఉపయోగించడం గురించి సమాచారం కోసం క్రింది కథనాన్ని చూడండి.
టుపుల్స్ మరియు లిస్ట్‌ల బేసిక్స్ అన్‌ప్యాక్ చేయడం
వేరియబుల్స్ ఎడమ వైపున వ్రాయబడినప్పుడు, కామాలతో వేరు చేయబడినప్పుడు, ప్రతి వేరియబుల్ కుడి వైపున టుపుల్ లేదా జాబితా యొక్క మూలకం కేటాయించబడుతుంది. ఇది టుపుల్స్ మరియు లిస్ట్‌లు రెండింటికీ ఒకే విధంగా ఉంటుంది (క్రింది ఉదాహరణలు టుపుల్ రూపంలో వ్రాయబడ్డాయి).
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
ఆస్టరిస్క్‌లతో అన్‌ప్యాక్ చేస్తోంది
మూలకాల సంఖ్య కంటే వేరియబుల్స్ సంఖ్య తక్కువగా ఉంటే, వేరియబుల్ పేరులోని నక్షత్రం మూలకాలను కలిపి జాబితాగా కేటాయించడానికి కారణమవుతుంది.
ఈ సింటాక్స్ పైథాన్ 3 నుండి అమలు చేయబడింది మరియు పైథాన్ 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
ఉదాహరణకు, మీరు ఒక వేరియబుల్‌కు tuple లేదా జాబితా యొక్క మొదటి రెండు మూలకాలను మాత్రమే కేటాయించాలనుకుంటే, మీరు అవసరం లేని భాగాల కోసం ఎగువ అండర్‌స్కోర్‌ని ఉపయోగించవచ్చు.
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
# []