ટ્યુપલ્સ વિશે બધું: તેઓ શું છે, તેઓ કેવી રીતે કાર્ય કરે છે અને તેનો ઉપયોગ કેવી રીતે કરવો

જ્યારે આપણે ડેટા સ્ટ્રક્ચર્સ વિશે વાત કરીએ છીએ, ત્યારે ખ્યાલ ટપલ. આ શબ્દ, ગણિત, પ્રોગ્રામિંગ અને ડેટાબેસેસમાં વ્યાપકપણે ઉપયોગમાં લેવાતો, આધુનિક ભાષાઓ માહિતીના જૂથોને કેવી રીતે સંચાલિત કરે છે તે સમજવાની ચાવી છે. આ લેખમાં આપણે ઊંડાણપૂર્વક જાણવા જઈ રહ્યા છીએ કે ટપલ શું છે, તેની વિશેષતાઓ અને તેનો ઉપયોગ વિવિધ પ્રોગ્રામિંગ ભાષાઓ જેમ કે પાયથોન, વિઝ્યુઅલ બેઝિક અને રિલેશનલ ડેટાબેઝમાં પણ કેવી રીતે થાય છે.

ટપલ એટલે, સારમાં, એ મૂલ્યોનો ઓર્ડર કરેલ ક્રમ. જો કે, યાદીઓ જેવા અન્ય પ્રકારના સંગ્રહોથી વિપરીત, તેની એક ખાસિયત છે જે તેને અમુક પરિસ્થિતિઓમાં ખૂબ ઉપયોગી બનાવે છે: પરિવર્તનશીલતા. આનો અર્થ એ છે કે, એકવાર બનાવ્યા પછી, ટ્યુપલ બનાવે છે તે તત્વો બદલી શકાતા નથી. આ સુવિધા ખાસ કરીને અસરકારક છે જ્યારે અમે ખાતરી કરવા માંગીએ છીએ કે ડેટા આકસ્મિક અથવા ઇરાદાપૂર્વક બદલાય નહીં. પરંતુ તેના ઉપયોગો અને લાક્ષણિકતાઓમાં તપાસ કરતા પહેલા, તેના મૂળ અને તેની પરિભાષાનું કારણ સમજવું ઉપયોગી છે.

ટ્યુપલ્સની ઉત્પત્તિ અને સામાન્યીકરણ

આ શબ્દ ટપલ જેમ કે શબ્દોના ગાણિતિક સામાન્યીકરણમાંથી ઉતરી આવે છે જોડ (બે તત્વો), ટ્રિપલ (ત્રણ તત્વો), અને તેથી વધુ. ત્યાંથી, તે સ્થાપિત કરવામાં આવ્યું હતું કે એક ક્રમ n તત્વો (n એ પૂર્ણાંક છે) એ કહેવાય છે n-ટપલ, આકૃતિઓ અથવા ડેટાને જૂથબદ્ધ કરવાની રીત તરીકે. આ નામ પ્રોગ્રામિંગ અને ગણિતમાં તેના ઉપયોગ માટે વિસ્તૃત કરવામાં આવ્યું હતું, કારણ કે ટ્યુપલ્સ મર્યાદિત સંખ્યામાં ઘટકો સાથે કામ કરવાની મંજૂરી આપે છે, તેમની જાળવણી ઓર્ડર અને માળખું.

ગણિતમાં, ધ ટ્યુપલ્સ તેમને ઓર્ડર કરેલ જોડીના વિસ્તરણ તરીકે પણ જોઈ શકાય છે, જ્યાં ઇનપુટ્સનો સમૂહ જૂથના વિવિધ સ્તરો દ્વારા વ્યાખ્યાયિત કરી શકાય છે. આ રીતે, એ n-ટપલ બે કરતાં વધુ તત્વો સાથે તેને તેની પ્રથમ એન્ટ્રીની ઓર્ડર કરેલ જોડી અને બાકીની એન્ટ્રીઓ ધરાવતી સબ-ટપલ તરીકે રજૂ કરી શકાય છે. સંસ્થાના આ વિચારને પ્રોગ્રામિંગની દુનિયામાં સ્થાનાંતરિત કરવામાં આવ્યો છે, જ્યાં ટ્યુપલ્સ તેઓ એક અત્યંત શક્તિશાળી અને લવચીક સાધન છે.

ટ્યુપલ્સની મુખ્ય લાક્ષણિકતાઓ

આ ટ્યુપલ્સ તેઓ લાક્ષણિકતાઓની શ્રેણી દ્વારા વ્યાખ્યાયિત કરવામાં આવે છે જે તેમને અન્ય ડેટા સ્ટ્રક્ચર્સની તુલનામાં અનન્ય બનાવે છે:

• અપરિવર્તનક્ષમતા: એકવાર બનાવ્યા પછી, ટ્યુપલના ઘટકોને સંશોધિત કરવું શક્ય નથી. આનો અર્થ એ છે કે અમે ટ્યુપલની અંદર ચોક્કસ સ્થાન માટે મૂલ્ય ફરીથી સોંપી શકતા નથી. ઉદાહરણ તરીકે, જો ટપલ તેના પ્રથમ ઘટકમાં મૂલ્ય 3 ધરાવે છે, તો તે તેના જીવનકાળ દરમિયાન તે મૂલ્યને જાળવી રાખશે.
• ઓર્ડર: ટપલમાંના તત્વો ચોક્કસ ક્રમમાં સંગ્રહિત થાય છે. અન્ય ઘણા સંગ્રહોથી વિપરીત, જેમ કે સેટ, જે ક્રમમાં તત્વો દાખલ કરવામાં આવે છે તે રેન્ડમ નથી. ઓર્ડર મહત્વપૂર્ણ છે અને જ્યારે પણ અમે ટપલ સાથે સંપર્ક કરીશું ત્યારે તેનું સન્માન કરવામાં આવશે.
• વિવિધ પ્રકારો: અન્ય ડેટા પ્રકારો જેમ કે એરેથી વિપરીત, ટ્યૂપલ્સમાં વિવિધ પ્રકારના તત્વો હોઈ શકે છે. ટ્યુપલ માટે પૂર્ણાંકો, શબ્દમાળાઓ અને બુલિયન બંનેનો સમાવેશ કરવો તે સંપૂર્ણપણે સ્વીકાર્ય છે.
• અનુક્રમણિકાઓ દ્વારા ઍક્સેસ કરો: સૂચિઓની જેમ, ટ્યુપલ્સ અનુક્રમણિકાઓ દ્વારા તેમના વ્યક્તિગત ઘટકોને ઍક્સેસ કરવાની મંજૂરી આપે છે. આ સૂચકાંકો સામાન્ય રીતે નંબર 0 થી શરૂ થાય છે. વધુમાં, કારણ કે ટ્યુપલ્સ છે તુલનાત્મક, તેમના તત્વોના મૂલ્યના આધારે તેમની વચ્ચેના સંબંધોને ચકાસવાનું શક્ય છે.

આ લાક્ષણિકતાઓ બનાવે છે ટ્યુપલ્સ તે એવી પરિસ્થિતિઓ માટે આદર્શ છે કે જ્યાં અમારે વિજાતીય ડેટાને જૂથબદ્ધ કરવાની જરૂર છે અને ખાતરી કરો કે તે પ્રોગ્રામના અમલ દરમિયાન આકસ્મિક રીતે બદલાય નહીં. ઉદાહરણ તરીકે, પ્લેનમાં કોઓર્ડિનેટ્સ (x, y) સંગ્રહિત કરવા માટે ટપલ એ યોગ્ય પસંદગી હશે, કારણ કે તે મૂલ્યો વ્યાખ્યાયિત કર્યા પછી બદલાવું જોઈએ નહીં.

પ્રોગ્રામિંગ ભાષાઓમાં ટ્યુપલનો ઉપયોગ

Python માં Tuples

પાયથોનમાં, ધ ટ્યુપલ્સ તેઓ ખૂબ જ સર્વતોમુખી અને વ્યાપકપણે ઉપયોગમાં લેવાતું ડેટા માળખું છે. તેઓ કૌંસનો ઉપયોગ કરીને વ્યાખ્યાયિત કરવામાં આવે છે () અને તત્વોને અલ્પવિરામથી અલગ કરી રહ્યા છીએ. પાયથોનમાં ટ્યુપલ્સની એક ખાસિયત એ છે કે, તેમની અપરિવર્તનક્ષમતા ઉપરાંત, તેમાં વિવિધ પ્રકારના તત્વો હોઈ શકે છે:

>>> t = (1, 'dos', 3)

આ ઉદાહરણમાં, અમારી પાસે એ ટપલ ત્રણ ઘટકો સાથે: પૂર્ણાંક, ટેક્સ્ટ સ્ટ્રિંગ અને અન્ય પૂર્ણાંક. જો આપણે તેના ઘટકોમાંથી એકને સંશોધિત કરવાનો પ્રયાસ કરીએ, જેમ કે પ્રથમ નંબરની કિંમત ફરીથી સોંપવી, તો પાયથોન એક ભૂલ આપશે:

>>> t[0] = 'uno'Traceback (most recent call last): File "<stdin>", line 1, in <module>TypeError: 'tuple' object does not support item assignment

જ્યારે આપણે આકસ્મિક ફેરફારો સામે અમારા ડેટાને સુરક્ષિત કરવા માંગીએ છીએ ત્યારે ટ્યુપલ્સને સંશોધિત કરવાની અશક્યતા તેમને ખૂબ જ ઉપયોગી તત્વો બનાવે છે.

Python માં tuples સાથે કામગીરી

અમે પાયથોનમાં ટ્યૂપલ્સ સાથે કરી શકીએ છીએ તે કેટલાક ઑપરેશન અમે સૂચિઓ સાથે કરી શકીએ છીએ તે સમાન છે:

• અનુક્રમણિકાઓ દ્વારા ઍક્સેસ કરો: આપણે તેના અનુરૂપ અનુક્રમણિકાનો ઉપયોગ કરીને ટ્યુપલના ઘટકોને ઍક્સેસ કરી શકીએ છીએ. પહેલેથી જ ઉલ્લેખ કર્યો છે તેમ, ધ સૂચકાંકો પાયથોનમાં તેઓ 0 થી શરૂ થાય છે.
• સ્લાઇસિંગ અથવા સ્લાઇસિંગ: પદ્ધતિનો ઉપયોગ કરીને ટ્યુપલના ભાગોને કાઢવાનું શક્ય છે સ્લાઇસ. ઉદાહરણ તરીકે, અમે અગાઉ બનાવેલ ટ્યૂપલના પોઝિશન 1 અને 2 માં તત્વો સાથે સબ-ટપલ મેળવી શકીએ છીએ:

>>> t[1:3]

પરિણામ એ તત્વો સાથેનું નવું ટ્યુપલ હશે:

('બે', 3)

ટપલ મેનીપ્યુલેશન: જો કે ટ્યૂપલ્સ અપરિવર્તનશીલ હોય છે અને અમે તેમના તત્વોને સીધું બદલી શકતા નથી, ટ્યૂપલને નવા વેરીએબલને ફરીથી સોંપવું અથવા નવું બનાવવા માટે ઘણા ટ્યૂપલ્સને ભેગા કરવાનું શક્ય છે. ઉદાહરણ તરીકે, આપણે ઓપરેટરનો ઉપયોગ કરીને બે ટ્યુપલ ઉમેરી શકીએ છીએ +:

>>> t = (1, 2) + (3, 4)>>> t(1, 2, 3, 4)

રિલેશનલ ડેટાબેઝમાં ટ્યુપલ્સ

ડેટાબેઝના ક્ષેત્રમાં, એ ટપલ રિલેશનલ ડેટાબેઝ કોષ્ટકમાં એક પંક્તિ છે. કોષ્ટકની દરેક કૉલમમાં ટ્યૂપલને લગતું મૂલ્ય છે.

ઉદાહરણ તરીકે, વિડિયો ગેમ પ્લેયર ટેબલમાં, દરેક પંક્તિ નીચેની રચના સાથે ટપલનું પ્રતિનિધિત્વ કરી શકે છે:

(Jugador: 'Luis', Puntuación: 25)

અહીં, ટપલમાં બે મૂલ્યો છે: ખેલાડીનું નામ અને તેનો સ્કોર. આ સંદર્ભમાં, ટ્યુપલ્સ ખૂબ જ ઉપયોગી છે કારણ કે તે વિવિધ પ્રકારના ડેટા (જેમ કે સ્ટ્રીંગ્સ અને ઈન્ટિજર, જેમ કે આપણે જોયું તેમ) સુસંગત રીતે સાંકળવાની મંજૂરી આપે છે.

અદ્યતન Tuple ઉદાહરણો

કેટલીક પ્રોગ્રામિંગ ભાષાઓમાં, જેમ કે વિઝ્યુઅલ બેઝિક, ટ્યુપલ્સ કૌંસ અને અલ્પવિરામથી વિભાજિત મૂલ્યોના સમૂહનો ઉપયોગ કરીને સરળતાથી બનાવી શકાય છે. વધુમાં, વિઝ્યુઅલ બેઝિકનો ઉપયોગ કરવાની મંજૂરી આપે છે નામના ટ્યુપલ્સ, જે અમને ટ્યુપલની અંદર દરેક ઘટકને નામો સોંપવાની સુગમતા આપે છે.

ઉદાહરણ તરીકે, એ બે તત્વ ટપલ બુલિયન મૂલ્ય અને ટેક્સ્ટ સ્ટ્રિંગ હોઈ શકે છે:

Dim holiday = (#07/04/2017#, "Independence Day", True)

આ કિસ્સામાં, ત્રણ-તત્વોનું ટ્યુપલ બનાવવામાં આવ્યું છે જ્યાં પ્રથમ તારીખ છે, બીજી સ્ટ્રિંગ છે અને ત્રીજી બુલિયન મૂલ્ય છે.

ટ્યુપલ્સ અને તેમની કાર્યક્ષમતા

ધ્યાનમાં રાખવાનું બીજું પાસું એ છે કે ટ્યુપલ્સ, અપરિવર્તનશીલ હોવાને કારણે, સૂચિ કરતાં સમય અને મેમરીની દ્રષ્ટિએ પ્રમાણમાં વધુ કાર્યક્ષમ છે. આનું કારણ એ છે કે, અપરિવર્તિત હોવાને કારણે, પ્રોગ્રામિંગ લેંગ્વેજને તેની આંતરિક રચનાને તે જ રીતે સંચાલિત કરવાની જરૂર નથી જેવી રીતે તે પરિવર્તનશીલ સૂચિ સાથે કરે છે. તેથી જ જ્યારે વધુ કાર્યક્ષમતા જરૂરી હોય અથવા જ્યારે ડેટામાં ફેરફાર કરવામાં ન આવે ત્યારે ટ્યુપલ્સ વધુ પ્રાધાન્યક્ષમ હોય છે.

સૂચિઓ અને ટ્યુપલ્સ વચ્ચે રૂપાંતર

છેવટે, ઘણી પ્રોગ્રામિંગ ભાષાઓમાં સૂચિને a માં કન્વર્ટ કરવું શક્ય છે ટપલ અને ઊલટું. પાયથોનમાં, પૂર્વવ્યાખ્યાયિત કાર્યોનો ઉપયોગ કરીને આ સરળતાથી કરી શકાય છે ટપલ() y યાદી().

>>> l = [1, 2, 3]>>> t = tuple(l)>>> t(1, 2, 3)

એ જ રીતે, આપણે ટ્યુપલને સૂચિમાં કન્વર્ટ કરી શકીએ છીએ:

>>> t = (1, 2, 3)>>> l = list(t)>>> l[1, 2, 3]

આ લવચીકતા અમને પ્રોગ્રામની જરૂરિયાતો અનુસાર દરેક કિસ્સામાં સૌથી યોગ્ય ડેટા સ્ટ્રક્ચરનો ઉપયોગ કરવાની મંજૂરી આપે છે.

ટૂંક માં, ટ્યુપલ્સ તેઓ જટિલ ડેટાને પ્રોગ્રામિંગ અને હેન્ડલિંગમાં આવશ્યક સાધન છે. તેમની અપરિવર્તનક્ષમતા અને વિજાતીય ડેટાને જૂથબદ્ધ કરવાની ક્ષમતા માટે આભાર, તેઓ વિવિધ સંદર્ભોમાં અત્યંત ઉપયોગી માળખું છે, અલ્ગોરિધમ ઑપ્ટિમાઇઝેશનથી લઈને રિલેશનલ ડેટાબેઝમાં ડેટા રજૂઆત સુધી. જો તમને તમારા પ્રોગ્રામના અમલ દરમિયાન અપરિવર્તિત રહે તેવા ડેટા પ્રકારની જરૂર હોય, તો ટ્યુપલ એક ઉત્તમ પસંદગી છે.