టూపుల్స్, ఇవి పైథాన్‌లో మార్పులేని (మార్చలేని) క్రమం వస్తువులు.
ఒకే మూలకం లేదా ఖాళీ టుపుల్స్‌తో టుపుల్స్‌ను ఉత్పత్తి చేసేటప్పుడు జాగ్రత్త తీసుకోవాలి.
కింది వివరాలు ఇక్కడ వివరించబడ్డాయి.
- 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
ఆర్గ్యుమెంట్‌లు లేకుండా టుపుల్() ద్వారా ఖాళీ టుపుల్‌లను కూడా రూపొందించవచ్చు.
empty_tuple = tuple()
print(empty_tuple)
print(type(empty_tuple))
# ()
# <class 'tuple'>
ఫంక్షన్ ఆర్గ్యుమెంట్‌లలో టుపుల్స్
వాక్యనిర్మాణ సందిగ్ధత ఉన్నప్పుడు కూడా టుపుల్ రౌండ్ బ్రాకెట్‌లు () అవసరం.
ఫంక్షన్ ఆర్గ్యుమెంట్‌లు కామాలతో వేరు చేయబడతాయి, అయితే ఈ సందర్భంలో, రౌండ్ బ్రాకెట్‌ల () ఉనికి లేదా లేకపోవడం ద్వారా ఫంక్షన్ టుపుల్ కాదా అని స్పష్టంగా సూచించడం అవసరం.
కుండలీకరణాలు లేకుండా (), ప్రతి విలువ ప్రతి వాదనకు పంపబడుతుంది; కుండలీకరణాలతో (), ప్రతి విలువ ఒక ఆర్గ్యుమెంట్‌కు టుపుల్‌గా పంపబడుతుంది.
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'>
మరింత సమాచారం కోసం, క్రింది కథనాన్ని చూడండి.
