જ્યારે તમે Python માં સૂચિઓ (એરે) અને ટ્યુપલ્સને એકબીજામાં કન્વર્ટ કરવા માંગતા હો, ત્યારે list() અને tuple() નો ઉપયોગ કરો.
જો પુનરાવર્તિત ઑબ્જેક્ટ્સ જેમ કે સેટ પ્રકારો તેમજ સૂચિઓ અને ટ્યુપલ્સ દલીલો તરીકે આપવામાં આવે છે, તો પ્રકારોની સૂચિ અને ટ્યુપલના નવા ઑબ્જેક્ટ્સ પરત કરવામાં આવે છે.
- class list([iterable]) — Built-in Functions — Python 3.10.2 Documentation
- class tuple([iterable]) — Built-in Functions — Python 3.10.2 Documentation
નીચેની સૂચિ, ટ્યુપલ અને શ્રેણી પ્રકારના ચલો ઉદાહરણો છે.
l = [0, 1, 2]
print(l)
print(type(l))
# [0, 1, 2]
# <class 'list'>
t = ('one', 'two', 'three')
print(t)
print(type(t))
# ('one', 'two', 'three')
# <class 'tuple'>
r = range(10)
print(r)
print(type(r))
# range(0, 10)
# <class 'range'>
શ્રેણી() પાયથોન 3 થી પ્રકાર શ્રેણીના ઑબ્જેક્ટ પરત કરે છે.
નોંધ કરો કે જો કે “રૂપાંતર” શબ્દનો ઉપયોગ સગવડતા માટે કરવામાં આવે છે, પરંતુ વાસ્તવમાં નવો ઑબ્જેક્ટ બનાવવામાં આવે છે, અને મૂળ ઑબ્જેક્ટ અકબંધ રહે છે.
યાદી બનાવો:list()
જ્યારે પુનરાવર્તિત ઑબ્જેક્ટ જેમ કે ટ્યુપલને સૂચિ() માટે દલીલ તરીકે ઉલ્લેખિત કરવામાં આવે છે, ત્યારે તે તત્વ સાથેની સૂચિ જનરેટ થાય છે.
tl = list(t)
print(tl)
print(type(tl))
# ['one', 'two', 'three']
# <class 'list'>
rl = list(r)
print(rl)
print(type(rl))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# <class 'list'>
ટ્યુપલ્સ બનાવો:tuple()
જ્યારે પુનરાવર્તિત ઑબ્જેક્ટ જેમ કે સૂચિને ટ્યુપલ() માટે દલીલ તરીકે ઉલ્લેખિત કરવામાં આવે છે, ત્યારે તે તત્વ સાથેનું ટ્યુપલ જનરેટ થાય છે.
lt = tuple(l)
print(lt)
print(type(lt))
# (0, 1, 2)
# <class 'tuple'>
rt = tuple(r)
print(rt)
print(type(rt))
# (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
# <class 'tuple'>
ટ્યૂપલ્સના ઘટકો ઉમેરો અથવા બદલો
ટ્યૂપલ્સ અપરિવર્તનશીલ છે (અપડેટ કરી શકાય તેવું નથી), તેથી તત્વો બદલી અથવા કાઢી શકાતા નથી. જો કે, બદલાયેલ અથવા કાઢી નાખેલ તત્વો સાથેનું ટ્યુપલ યાદી બનાવવા માટે list() નો ઉપયોગ કરીને, તત્વોને બદલીને અથવા કાઢી નાખીને અને પછી ફરીથી tuple() નો ઉપયોગ કરીને મેળવી શકાય છે.
