பைத்தானில் உள்ள மாறாத (மாற்ற முடியாத) வரிசைப் பொருள்களான டூபிள்ஸ்.
ஒற்றை உறுப்பு அல்லது வெற்று டூப்பிள்களை கொண்டு டூப்பிள்களை உருவாக்கும் போது கவனமாக இருக்க வேண்டும்.
பின்வரும் விவரங்கள் இங்கே விவரிக்கப்பட்டுள்ளன.
- 1 உறுப்புடன் டூப்பிள்
- டூபிள் சுற்று அடைப்புக்குறிகள் தவிர்க்கப்படலாம்.
- வெற்று டூப்பிள்
- செயல்பாட்டு வாதங்களில் டூப்பிள்ஸ்
1 உறுப்புடன் டூப்பிள்
நீங்கள் ஒரு உறுப்புடன் ஒரு ட்யூபிளை உருவாக்க முயற்சித்தால், வட்ட அடைப்புக்குறிக்குள் () ஒரே ஒரு பொருளை மட்டும் எழுதினால், சுற்று அடைப்புக்குறிகள் () புறக்கணிக்கப்பட்டு செயலாக்கப்படும் மற்றும் டூப்பிள் என்று கருதப்படாது.
single_tuple_error = (0)
print(single_tuple_error)
print(type(single_tuple_error))
# 0
# <class 'int'>
ஒரு உறுப்புடன் ஒரு ட்யூபிளை உருவாக்க, ஒரு டிரெயிலிங் கமா தேவை.
single_tuple = (0, )
print(single_tuple)
print(type(single_tuple))
# (0,)
# <class 'tuple'>
எடுத்துக்காட்டாக, பல டூப்பிள்களை இணைக்க + ஆபரேட்டரைப் பயன்படுத்தும் போது, நீங்கள் ஒரு உறுப்பைச் சேர்த்து, கமாவை மறந்துவிட்டால், பிழை ஏற்படும் என்பதை நினைவில் கொள்ளவும்.
# print((0, 1, 2) + (3))
# TypeError: can only concatenate tuple (not "int") to tuple
print((0, 1, 2) + (3, ))
# (0, 1, 2, 3)
டூபிள் சுற்று அடைப்புக்குறிகள் தவிர்க்கப்படலாம்.
ஒரு உறுப்பைக் கொண்ட ட்யூபிளுக்கு கமா தேவைப்படுவதற்குக் காரணம், டூப்பிள் என்பது சுற்று அடைப்புக்குறிக்குள் () இணைக்கப்பட்ட மதிப்பு அல்ல, ஆனால் கமாவால் பிரிக்கப்பட்ட மதிப்பு.
காற்புள்ளியே டூப்பிளை உருவாக்குகிறது, வட்ட அடைப்புக்குறிகளை அல்ல.
Tuples — Built-in Types — Python 3.10.4 Documentation
சுற்று அடைப்புக்குறிகள் () தவிர்க்கப்பட்டாலும், அது ஒரு டூபிளாக செயலாக்கப்படும்.
t = 0, 1, 2
print(t)
print(type(t))
# (0, 1, 2)
# <class 'tuple'>
ஒரு பொருளுக்குப் பிறகு ஒரு தேவையற்ற கமா ஒரு டூப்பிள் என்று கருதப்படுகிறது.
t_ = 0,
print(t_)
print(type(t_))
# (0,)
# <class 'tuple'>
வெற்று டூப்பிள்
மேலே குறிப்பிட்டுள்ளபடி, டூப்பிளைக் குறிக்கும் போது வட்ட அடைப்புக்குறிகள் () தவிர்க்கப்படலாம், ஆனால் ஒரு வெற்று ட்யூபிளை உருவாக்கும் போது தேவைப்படும்.
ஒரு இடைவெளி அல்லது காற்புள்ளி மட்டுமே தொடரியல் பிழையை ஏற்படுத்தும்.
empty_tuple = ()
print(empty_tuple)
print(type(empty_tuple))
# ()
# <class 'tuple'>
# empty_tuple_error =
# SyntaxError: invalid syntax
# empty_tuple_error = ,
# SyntaxError: invalid syntax
# empty_tuple_error = (,)
# SyntaxError: invalid syntax
வாதங்கள் இல்லாமல் tuple() மூலம் வெற்று டூப்பிள்களையும் உருவாக்கலாம்.
empty_tuple = tuple()
print(empty_tuple)
print(type(empty_tuple))
# ()
# <class 'tuple'>
செயல்பாட்டு வாதங்களில் டூப்பிள்ஸ்
தொடரியல் தெளிவின்மை இருக்கும்போது கூட Tuple round brackets () தேவை.
செயல்பாட்டு வாதங்கள் காற்புள்ளிகளால் பிரிக்கப்படுகின்றன, ஆனால் இந்த விஷயத்தில், சுற்று அடைப்புக்குறிகளின் இருப்பு அல்லது இல்லாமை மூலம் செயல்பாடு ஒரு டூபிளாக உள்ளதா இல்லையா என்பதை வெளிப்படையாகக் குறிப்பிடுவது அவசியம் ().
அடைப்புக்குறிகள் இல்லாமல் (), ஒவ்வொரு மதிப்பும் ஒவ்வொரு வாதத்திற்கும் அனுப்பப்படுகிறது; அடைப்புக்குறிக்குள் (), ஒவ்வொரு மதிப்பும் ஒரு வாதத்திற்கு ஒரு டுபிளாக அனுப்பப்படுகிறது.
def example(a, b):
print(a, type(a))
print(b, type(b))
example(0, 1)
# 0 <class 'int'>
# 1 <class 'int'>
# example((0, 1))
# TypeError: example() missing 1 required positional argument: 'b'
example((0, 1), 2)
# (0, 1) <class 'tuple'>
# 2 <class 'int'>
ட்யூப்பிள் ஒரு நட்சத்திரக் குறியீடு * மூலம் குறிக்கப்பட்டால், ட்யூபிளின் உறுப்புகள் விரிவாக்கப்பட்டு வாதங்களாக அனுப்பப்படும்.
example(*(0, 1))
# 0 <class 'int'>
# 1 <class 'int'>
மேலும் தகவலுக்கு, பின்வரும் கட்டுரையைப் பார்க்கவும்.
