පයිතන් හි වෙනස් කළ නොහැකි (වෙනස් කළ නොහැකි) අනුක්‍රමික වස්තූන් වන Tuples.
තනි මූලද්‍රව්‍යයක් හෝ හිස් ටියුපල් සහිත ටියුපල් උත්පාදනය කිරීමේදී සැලකිලිමත් විය යුතුය.
පහත විස්තර මෙහි විස්තර කර ඇත.
- මූලද්‍රව්‍ය 1ක් සහිත ටුපල්
- Tuple round brackets අත්හැරිය හැක.
- හිස් ටුපල්
- ක්‍රියාකාරී තර්කවල ටියුපල්
මූලද්‍රව්‍ය 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)
Tuple round brackets අත්හැරිය හැක.
එක් මූලද්‍රව්‍යයක් සහිත ටියුපල් එකකට කොමාවක් අවශ්‍ය වීමට හේතුව ටූපල් යනු වටකුරු වරහන් () වලින් කොටු කර ඇති අගයක් නොව කොමාවකින් වෙන් කරන ලද අගයකි.
වටකුරු වරහන් නොව ටුපල් නිර්මාණය කරන්නේ කොමාවයි.
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'>
tuple එක තරු ලකුණකින් සලකුණු කර ඇත්නම් *, tuple හි මූලද්‍රව්‍ය පුළුල් කර තර්ක ලෙස සම්මත කළ හැකිය.
example(*(0, 1))
# 0 <class 'int'>
# 1 <class 'int'>
වැඩි විස්තර සඳහා, පහත ලිපිය බලන්න.