பைத்தானில், ஒரு டூப்பிள் அல்லது பட்டியலின் கூறுகள் விரிவாக்கப்பட்டு பல மாறிகளுக்கு ஒதுக்கப்படும். இது சீக்வென்ஸ் அன்பேக்கிங் அல்லது பேக் செய்யப்பட்ட அசைன்மென்ட் எனப்படும்.
பின்வரும் விவரங்கள் இங்கே விவரிக்கப்பட்டுள்ளன.
- டூப்பிள்ஸ் மற்றும் லிஸ்ட்களின் அடிப்படைகளைத் திறக்கிறது
- உள்ளமைக்கப்பட்ட டூப்பிள்கள், தொகுக்கப்படாத பட்டியல்கள்
- அடிக்கோடிட்டுத் திறக்கிறது:
_ - நட்சத்திரக் குறியீடுகளுடன் பேக்கிங்:
*
டூப்பிள்கள், பட்டியல்கள் மற்றும் அகராதிகளை செயல்பாட்டு வாதங்களாக விரிவுபடுத்தவும் அனுப்பவும் நட்சத்திரக் குறியீடுகளைப் பயன்படுத்துவது பற்றிய தகவலுக்கு பின்வரும் கட்டுரையைப் பார்க்கவும்.
- தொடர்புடையது:பைத்தானில் செயல்பாட்டு வாதங்களாக பட்டியல்கள், டூப்பிள்கள் மற்றும் அகராதிகளை விரிவுபடுத்துதல் மற்றும் அனுப்புதல்
டூப்பிள்ஸ் மற்றும் லிஸ்ட்களின் அடிப்படைகளைத் திறக்கிறது
மாறிகள் இடது புறத்தில் எழுதப்பட்டால், காற்புள்ளிகளால் பிரிக்கப்பட்டால், ஒவ்வொரு மாறிக்கும் வலது புறத்தில் டூப்பிள் அல்லது பட்டியலின் ஒரு உறுப்பு ஒதுக்கப்படும். டூப்பிள்கள் மற்றும் பட்டியல்கள் இரண்டிற்கும் இது ஒன்றுதான் (பின்வரும் எடுத்துக்காட்டுகள் டூப்பிள் வடிவத்தில் எழுதப்பட்டுள்ளன).
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
_underscore_ உடன் தொகுக்கப்பட்டது.
பைத்தானில், தொகுக்கப்படாதது மட்டுமல்ல, தேவையில்லாத மதிப்புகள் வழக்கமாக அடிக்கோடிட்டு (அண்டர்ஸ்கோர்) _க்கு ஒதுக்கப்படும். சிறப்பு இலக்கண பொருள் இல்லை; அவை வெறுமனே _ என்ற பெயரிடப்பட்ட மாறிக்கு ஒதுக்கப்படுகின்றன.
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
# []
