ટ્યુપલ્સ, જે પાયથોનમાં અપરિવર્તનશીલ (અપરિવર્તનશીલ) સિક્વન્સ ઑબ્જેક્ટ છે.
એક જ તત્વ અથવા ખાલી ટ્યુપલ્સ સાથે ટ્યૂપલ્સ જનરેટ કરતી વખતે કાળજી લેવી આવશ્યક છે.
નીચેની વિગતો અહીં વર્ણવેલ છે.
- 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'>
વધુ માહિતી માટે, નીચેનો લેખ જુઓ.
