මොකක්ද වෙනස?
ටුපල් / ලැයිස්තු වල වාසි / අවාසි මොනවාද?
list
. ; ඩී
මොකක්ද වෙනස?
ටුපල් / ලැයිස්තු වල වාසි / අවාසි මොනවාද?
list
. ; ඩී
Answers:
ටුපල් වෙනස් කළ නොහැකි වීමට අමතරව ඒවායේ භාවිතයට මඟ පෙන්විය යුතු අර්ථකථන වෙනසක් ද ඇත. ටුපල්ස් යනු විෂමජාතීය දත්ත ව්යුහයන්ය (එනම් ඒවායේ ඇතුළත් කිරීම්වල විවිධ අර්ථයන් ඇත), ලැයිස්තු සමජාතීය අනුක්රමයකි. ටුපල්ස් ව්යුහයක් ඇත, ලැයිස්තු අනුපිළිවෙලක් ඇත.
මෙම වෙනස භාවිතා කිරීමෙන් කේතය වඩාත් පැහැදිලි සහ තේරුම්ගත හැකිය.
එක් උදාහරණයක් නම් පොතක ස්ථාන යොමු කිරීම සඳහා පිටු සහ පේළි අංක යුගල වේ, උදා:
my_location = (42, 11) # page number, line number
ඔබට ස්ථානවල සටහන් ගබඩා කිරීම සඳහා ශබ්ද කෝෂයක යතුරක් ලෙස මෙය භාවිතා කළ හැකිය. අනෙක් අතට ලැයිස්තුවක් ස්ථාන කිහිපයක් ගබඩා කිරීම සඳහා භාවිතා කළ හැකිය. ස්වාභාවිකවම කෙනෙකුට ලැයිස්තුවෙන් ස්ථාන එකතු කිරීමට හෝ ඉවත් කිරීමට අවශ්ය විය හැකිය, එබැවින් ලැයිස්තු විකෘති බව හැඟේ. අනෙක් අතට, පවතින ස්ථානයකින් අයිතම එකතු කිරීම හෝ ඉවත් කිරීම අර්ථවත් නොවේ - එබැවින් ටුපල් වෙනස් කළ නොහැක.
පවතින ස්ථානයක ඇති අයිතමයක් වෙනස් කිරීමට ඔබට අවශ්ය අවස්ථා තිබිය හැක, උදාහරණයක් ලෙස පිටුවක රේඛා හරහා නැවත යෙදෙන විට. නමුත් සෑම නව අගයක් සඳහාම නව ස්ථානයක් නිර්මාණය කිරීමට ටුපල් නිශ්චලතාව ඔබට බල කරයි. මෙය මුහුණතෙහි අපහසුතාවයක් සේ පෙනේ, නමුත් මේ වගේ වෙනස් කළ නොහැකි දත්ත භාවිතා කිරීම වටිනාකම් වර්ග සහ ක්රියාකාරී ක්රමලේඛන ශිල්පීය ක්රමවල මූලික ගලක් වන අතර එමඟින් සැලකිය යුතු වාසි ලබා ගත හැකිය.
මෙම ගැටලුව පිළිබඳ සිත්ගන්නාසුලු ලිපි කිහිපයක් තිබේ, උදා: "පයිතන් ටුපල්ස් යනු නිරන්තර ලැයිස්තු නොවේ" හෝ "පයිතන්හි ටුපල් එදිරිව ලැයිස්තු තේරුම් ගැනීම" . නිල පයිතන් ලියකියවිලි ද මේ ගැන සඳහන් කරයි
"ටුපල්ස් වෙනස් කළ නොහැකි අතර සාමාන්යයෙන් විෂමජාතීය අනුක්රමයක් අඩංගු වේ ...".
වැනි statically ටයිප් භාෂාවෙන් Haskell වූ tuple දී අගයන් සාමාන්යයෙන් විවිධ වර්ගයේ ඇති අතර tuple දිග ස්ථාවර කළ යුතු ය. ලැයිස්තුවක සියලු අගයන් එකම වර්ගයක් ඇති අතර දිග සවි කර නොමැත. එබැවින් වෙනස ඉතා පැහැදිලිය.
අවසාන වශයෙන් පයිතන්හි නම් කරන ලද ටුපල් ඇත, එය අර්ථවත් වන්නේ ටුපල් එකකට දැනටමත් ව්යුහයක් තිබිය යුතු බැවිනි. පංති හා අවස්ථාවන් සඳහා ටුපල් යනු සැහැල්ලු බර විකල්පයක් යන අදහස මෙයින් අවධාරණය කරයි.
collections.namedtuple
වඩා හොඳ යැයි කියනු ඇතැයි මට හැඟේ collections.record
. පාරිභෝගික වාර්තාවක නම සහ ලිපිනය හුවමාරු කර ගැනීම තේරුමක් නැති දෙයක් වනු ඇත; ඇත්ත වශයෙන්ම, එසේ කිරීම සාමාන්යයෙන් දෝෂයක් වනු ඇත, එමඟින් ටුපල්ගේ වෙනස් කළ නොහැකි බව ඔබව වළක්වයි.
What would you do with such a list?
, ppl මන fant කල්පිත lack නතාවක් තර්කයක් ලෙස භාවිතා කරන විට මම නිතරම වෙවුලමි . මිශ්ර වර්ග ලැයිස්තු භාවිතා කිරීම සමහර ධූරාවලි දත්ත ව්යුහයන් සඳහා විශිෂ්ට ලෙස ක්රියා කරයි, එහිදී සෑම ලැයිස්තුවක්ම ළමා ලැයිස්තු සහ අගය-මූලද්රව්ය වලින් සමන්විත වේ.
ලැයිස්තුව සහ ටුපල් අතර වෙනස
වචනාර්ථය
someTuple = (1,2)
someList = [1,2]
ප්රමාණය
a = tuple(range(1000))
b = list(range(1000))
a.__sizeof__() # 8024
b.__sizeof__() # 9088
ටුපල් මෙහෙයුමක කුඩා ප්රමාණය නිසා, එය ටිකක් වේගවත් වේ, නමුත් ඔබට මූලද්රව්ය විශාල ප්රමාණයක් ලැබෙන තුරු ඒ ගැන සඳහන් කිරීම එතරම් නොවේ.
අවසර ලත් මෙහෙයුම්
b = [1,2]
b[0] = 3 # [3, 2]
a = (1,2)
a[0] = 3 # Error
එයින් කියවෙන්නේ ඔබට මූලද්රව්යයක් මකා දැමීමට හෝ ටියුපල් වර්ග කිරීමට නොහැකි බවයි. කෙසේ වෙතත්, ඔබට ලැයිස්තුවට හා ටුපල් දෙකටම නව අංගයක් එක් කළ හැකිය, එකම වෙනස සමඟ ටුපල් වෙනස් කළ නොහැකි බැවින්, ඔබ සැබවින්ම මූලද්රව්යයක් එකතු නොකරන නමුත් ඔබ නව ටුපල් එකක් නිර්මාණය කරයි, එබැවින් හැඳුනුම්පත වෙනස් වනු ඇත
a = (1,2)
b = [1,2]
id(a) # 140230916716520
id(b) # 748527696
a += (3,) # (1, 2, 3)
b += [3] # [1, 2, 3]
id(a) # 140230916878160
id(b) # 748527696
භාවිතය
ලැයිස්තුවක් විකෘති බැවින්, එය ශබ්දකෝෂයක යතුරක් ලෙස භාවිතා කළ නොහැකි අතර, ටුපල් එකක් භාවිතා කළ හැකිය.
a = (1,2)
b = [1,2]
c = {a: 1} # OK
c = {b: 1} # Error
3. Permitted operation
පෙන්වන්නේ ටුපල් කේස් ය. සාර්ථකත්වය සහ දෝෂය පෙන්වීම සාමාන්ය දෙයක් බව මම දනිමි, නමුත් එය මොහොතකට මගේ හිස අවුල් විය.
one_item_list = [a]
නමුත් one_tuple = (a,)
එය අනුරූප වේ. විචල්ය නාමයෙන් පසුව කොමාව සටහන් කරන්න. නමුත් සටහන් කර ගන්න two_tuple = (a, b)
. මෙය මට කිහිප වතාවක්ම ඉවතට විසි කළේය (තවමත් පයිතන් 3 හි ඇත).
tuple(sorted(the_unsorted_tuple))
ඔබ ඇවිදීමට ගියහොත්, ඕනෑම වේලාවක ඔබේ ඛණ්ඩාංක සටහන් කළ හැකිය (x,y)
.
ඔබේ ගමන පටිගත කිරීමට ඔබට අවශ්ය නම්, සෑම තත්පර කිහිපයකට වරක් ඔබේ ස්ථානය ලැයිස්තුවකට එකතු කළ හැකිය.
නමුත් ඔබට එය වෙනත් ආකාරයකින් කළ නොහැක.
ප්රධාන වෙනස වන්නේ ටුපල් වෙනස් කළ නොහැකි වීමයි. මෙයින් අදහස් කරන්නේ ඔබ එය නිර්මාණය කළ පසු අගයන් වෙනස් කළ නොහැකි බවයි.
එබැවින් ඔබට අගයන් වෙනස් කිරීමට අවශ්ය නම් ලැයිස්තුවක් භාවිතා කරන්න.
ටුපල් සඳහා වාසි:
frozenset
විවිධ තෙවන පාර්ශවීය ශීත කළ ආ ict ාව / ගස / යනාදිය වැනි වෙනස් කළ නොහැකි එකතු කිරීම් වලද මෙය සත්යයක් යැයි ඔබට පැවසිය හැකිය . වර්ග, නමුත් ඒ කිසිවක් ඔබට විකෘති මූලද්රව්ය එකතු කිරීමට ඉඩ නොදේ. (එමෙන්ම ඇත්ත ක tuple පමණක් hashable එහි අංග නම්, සුපුරුදු EAFP ආකාරයෙන් හැන්ඩ්ල්, එසේ කරන වන්නේ d[1, [2]]
මතු කරනු ඇත TypeError: unhashable type: 'list'
.)
ලැයිස්තු විකෘති වේ; tuples එසේ නොවේ.
Docs.python.org/2/tutorial/datastructures.html වෙතින්
ටුපල්ස් වෙනස් කළ නොහැකි අතර සාමාන්යයෙන් ඉවත් කිරීම (මෙම කොටසේ පසුව බලන්න) හෝ සුචිගත කිරීම (හෝ නම් කරන ලද ටුපල් වල ආරෝපණයෙන් පවා) හරහා ප්රවේශ විය හැකි මූලද්රව්යයන්ගේ විෂමජාතීය අනුක්රමයක් අඩංගු වේ. ලැයිස්තු විකෘති වන අතර ඒවායේ මූලද්රව්ය සාමාන්යයෙන් සමජාතීය වන අතර ඒවා ලැයිස්තුව හරහා නැවත යෙදීම මඟින් ප්රවේශ වේ.
එය කරනවා සඳහන් කර ඇති වෙනස බොහෝ දුරට ඍජු බව: ජනතාව tuple සහ ලැයිස්තුව වෙනස් තොරතුරු නියෝජනය කිරීමට බලාපොරොත්තු වෙනවා. නමුත් මෙය මාර්ගෝපදේශයකට වඩා වැඩි ය. සමහර පුස්තකාල ඇත්ත වශයෙන්ම වෙනස් වන්නේ ඒවා සම්මත කළ දේ පදනම් කරගෙන ය. උදාහරණයක් ලෙස NumPy ගන්න ( මම තවත් උදාහරණ ඉල්ලන වෙනත් තනතුරකින් පිටපත් කර ඇත ):
>>> import numpy as np
>>> a = np.arange(9).reshape(3,3)
>>> a
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> idx = (1,1)
>>> a[idx]
4
>>> idx = [1,1]
>>> a[idx]
array([[3, 4, 5],
[3, 4, 5]])
කාරණය නම්, NumPy සම්මත පුස්තකාලයේ කොටසක් නොවිය හැකි අතර, එය ප්රධාන පයිතන් පුස්තකාලයක් වන අතර, NumPy ලැයිස්තු සහ ටුපල් තුළ සම්පූර්ණයෙන්ම වෙනස් දේ ඇත.
type(a_list) != type(a_tuple)
, එබැවින් ඕනෑම පුස්තකාල කේත ශාඛාවක් පදනම් කරගෙන type(x)
වෙනස් ආකාරයකින් හැසිරෙනු ඇත
'%d %d' % [2, 3]
a TypeError
, මන්ද ඔබ ලැයිස්තුවක් පළමුවැන්නා වෙත යැවීමට උත්සාහ කරන %d
අතර ඔබ දෙවන අගයට කිසිදු අගයක් නොදෙන %d
බැවිනි. (කෙසේ වෙතත්, මේ සඳහා ප්රති-උදාහරණ ද ඇත max
…)
ලැයිස්තු ලූප සඳහා වේ, ටුපල් යනු ව්යුහයන් සඳහා ය "%s %s" %tuple
.
ලැයිස්තු සාමාන්යයෙන් සමජාතීය වේ, ටුපල් සාමාන්යයෙන් විෂමජාතීය වේ.
ලැයිස්තු විචල්ය දිග සඳහා වන අතර, ටුපල් ස්ථාවර දිග සඳහා වේ.
මෙය පයිතන් ලැයිස්තු සඳහා උදාහරණයකි:
my_list = [0,1,2,3,4]
top_rock_list = ["Bohemian Rhapsody","Kashmir","Sweet Emotion", "Fortunate Son"]
මෙය පයිතන් ටුපල් සඳහා උදාහරණයකි:
my_tuple = (a,b,c,d,e)
celebrity_tuple = ("John", "Wayne", 90210, "Actor", "Male", "Dead")
පයිතන් ලැයිස්තු සහ ටුපල් සමාන වන අතර ඒ දෙකම සාරධර්ම එකතු කිරීමට ඇණවුම් කර ඇත. "[..., ...]" වරහන් භාවිතා කරමින් ලැයිස්තු නිර්මාණය කර ඇති නොගැඹුරු වෙනස හැරුණු විට සහ වරහන් භාවිතා කරන ටුපල් "(..., ...)" හැරුණු විට, මූලික තාක්ෂණික "පයිතන් සින්ටැක්ස් හි දෘඩ කේත කර ඇති" වෙනස ලැයිස්තු විකෘති වන අතර විශේෂිත ටුපල් එකක මූලද්රව්ය වෙනස් කළ නොහැකි ය (... එබැවින් හූල්ස් පමණක් හැෂ් කළ හැකි අතර ඒවා ශබ්ද කෝෂ / හැෂ් යතුරු ලෙස භාවිතා කළ හැකිය!). මෙය ඔවුන්ට භාවිතා කළ හැකි හෝ භාවිතා කළ නොහැකි ආකාරවල වෙනස්කම් ඇති කරයි (සින්ටැක්ස් මගින් ප්රියෝරියක් බලාත්මක කරයි) සහ මිනිසුන් ඒවා භාවිතා කිරීමට තෝරා ගන්නා ආකාරයෙහි වෙනස්කම් ('හොඳම භාවිතයන්' ලෙස දිරිගන්වනු ලැබේ, පශ්චාත් උපාධියක්, මෙය බුද්ධිමත් ක්රමලේඛකයින් කරන්නේ). මිනිසුන් මූලද්රව්ය අනුපිළිවෙලට ලබා දේ.
ටුපල් සඳහා, 'ඇණවුම' යන්නෙන් අදහස් කරන්නේ තොරතුරු රඳවා තබා ගැනීම සඳහා නිශ්චිත 'ව්යුහයක්' පමණි. එක් එක් ක්ෂේත්රය එකිනෙකට වෙනස් මානයන් හෝ පරිමාණයන් හරහා අගයන් සපයන බැවින් පළමු ක්ෂේත්රය තුළ ඇති අගයන් පහසුවෙන් දෙවන ක්ෂේත්රයට මාරු කළ හැකිය. ඒවා විවිධ වර්ගයේ ප්රශ්නවලට පිළිතුරු සපයන අතර ඒවා සාමාන්යයෙන් ස්වරූපයෙන් යුක්ත වේ: දී ඇති වස්තුවක් / විෂයයක් සඳහා, එහි ලක්ෂණ මොනවාද? වස්තුව / විෂය නියතව පවතී, ගුණාංග වෙනස් වේ.
ලැයිස්තු සඳහා, 'ඇණවුම' යන්නෙන් අනුක්රමයක් හෝ දිශානතියක් අදහස් වේ. දෙවන මූලද්රව්යය පළමු මූලද්රව්යයට පසුව පැමිණිය යුත්තේ එය විශේෂිත හා පොදු පරිමාණයක් හෝ මානයක් මත පදනම්ව 2 වන ස්ථානයේ ස්ථානගත කර ඇති බැවිනි. මූලද්රව්යයන් සමස්තයක් ලෙස ගත් අතර බොහෝ විට පෝරමයේ තනි ප්රශ්නයකට පිළිතුරු සපයයි, දී ඇති ලක්ෂණයක් සඳහා, මෙම වස්තු / විෂයයන් සැසඳෙන්නේ කෙසේද? ගුණාංගය නියතව පවතී, වස්තුව / විෂය වෙනස් වේ.
ජනප්රිය සංස්කෘතියේ සිටින පුද්ගලයින් සහ ක්රමලේඛකයින් මෙම වෙනස්කම් වලට අනුකූල නොවන බවට උදාහරණ ගණනාවක් ඇති අතර ඔවුන්ගේ ප්රධාන පා .මාලාව සඳහා සලාද දෙබලක භාවිතා කළ හැකි ගණන් කළ නොහැකි පුද්ගලයන් සිටිති. දවස අවසානයේදී, එය හොඳයි, දෙදෙනාම සාමාන්යයෙන් කාර්යය ඉටු කළ හැකිය.
සියුම් තොරතුරු කිහිපයක් සාරාංශ කිරීමට
සමානකම්:
සුචිගත කිරීම, තේරීම සහ කැපීම - වරහන් තුළ ඇති පූර්ණ සංඛ්යා අගයන් භාවිතා කරමින් ටුපල් සහ ලැයිස්තු දර්ශකය යන දෙකම. එබැවින්, ලබා දී ඇති ලැයිස්තුවක හෝ ටුපල් එකක පළමු අගයන් 3 ඔබට අවශ්ය නම්, වාක්ය ඛණ්ඩය සමාන වේ:
>>> my_list[0:3]
[0,1,2]
>>> my_tuple[0:3]
[a,b,c]
සංසන්දනය කිරීම හා වර්ග කිරීම - ටුපල් දෙකක් හෝ ලැයිස්තු දෙකක් ඒවායේ පළමු මූලද්රව්යය හා සසඳන අතර ටයි පටියක් තිබේ නම් දෙවන මූලද්රව්යය අනුව යනාදිය. පෙර මූලද්රව්යවල වෙනසක් පෙන්නුම් කිරීමෙන් පසුව පසුකාලීන මූලද්රව්ය කෙරෙහි වැඩි අවධානයක් යොමු නොකෙරේ.
>>> [0,2,0,0,0,0]>[0,0,0,0,0,500]
True
>>> (0,2,0,0,0,0)>(0,0,0,0,0,500)
True
වෙනස්කම්: - නිර්වචනය අනුව ප්රාථමිකයක්
සින්ටැක්ස් - ලැයිස්තු භාවිතය [], ටුපල්ස් භාවිතය ()
විකෘතිතාව - දී ඇති ලැයිස්තුවක ඇති මූලද්රව්ය විකෘති වන අතර, දී ඇති ටුපල් එකක මූලද්රව්ය විකෘති නොවේ.
# Lists are mutable:
>>> top_rock_list
['Bohemian Rhapsody', 'Kashmir', 'Sweet Emotion', 'Fortunate Son']
>>> top_rock_list[1]
'Kashmir'
>>> top_rock_list[1] = "Stairway to Heaven"
>>> top_rock_list
['Bohemian Rhapsody', 'Stairway to Heaven', 'Sweet Emotion', 'Fortunate Son']
# Tuples are NOT mutable:
>>> celebrity_tuple
('John', 'Wayne', 90210, 'Actor', 'Male', 'Dead')
>>> celebrity_tuple[5]
'Dead'
>>> celebrity_tuple[5]="Alive"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
හැෂ්ටේබල් (ශබ්ද කෝෂ) - හැෂ් ටේබල් (ශබ්ද කෝෂ) වලට එහි යතුරු හැෂ් කළ හැකි හා වෙනස් කළ නොහැකි බැවින්, ලැයිස්තු නොව ශබ්ද කෝෂ යතුරු ලෙස ක්රියා කළ හැක්කේ ටුපල් වලට පමණි.
#Lists CAN'T act as keys for hashtables(dictionaries)
>>> my_dict = {[a,b,c]:"some value"}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
#Tuples CAN act as keys for hashtables(dictionaries)
>>> my_dict = {("John","Wayne"): 90210}
>>> my_dict
{('John', 'Wayne'): 90210}
වෙනස්කම් - භාවිතයේ ඇති පශ්චාත් උපාධියක්
හෝමෝ එදිරිව මූලද්රව්යවල විෂමජාතීයතාව - සාමාන්යයෙන් ලැයිස්තුගත වස්තූන් සමජාතීය වන අතර ටුපල් වස්තු විෂමජාතීය වේ. එනම්, ලැයිස්තු එකම වර්ගයේ වස්තූන් / විෂයයන් සඳහා භාවිතා කරනු ලැබේ (සියලුම ජනාධිපති අපේක්ෂකයින්, හෝ සියලුම ගීත, හෝ සියලු ධාවකයන් මෙන්) එය බල නොකෙරුණද), නමුත් විෂමජාතීය වස්තූන් සඳහා ටුපල් වැඩි ය.
ලූපින් එදිරිව ව්යුහයන් - දෙකම ලූප කිරීමට ඉඩ දුන්නද (මගේ_ ලැයිස්තුවේ x සඳහා ...), එය ලැයිස්තුවක් සඳහා එය කිරීම අර්ථවත් කරයි. තොරතුරු ව්යුහගත කිරීම සහ ඉදිරිපත් කිරීම සඳහා ටුපල්ස් වඩාත් යෝග්ය වේ (% s හි වාසය කරන% s% s% s වන අතර වර්තමානයේ% s% ("ජෝන්", "වේන්", 90210, "නළුවා", "මළ"))
ටුපල්ස් සහ ලැයිස්තු දෙකම පයිතන්හි සමාන අනුක්රමික වර්ග වේ.
වචනාර්ථමය වාක්ය ඛණ්ඩය
නව ලැයිස්තුවක් ලබා ගැනීම සඳහා අපි වරහන් ( ) ටුපල් සහ හතරැස් වරහන් තැනීමට භාවිතා කරමු
[ ]
. එසේම, අවශ්ය ව්යුහය ලබා ගැනීම සඳහා අපට සුදුසු වර්ගයේ ඇමතුමක් භාවිතා කළ හැකිය - ටුපල් හෝ ලැයිස්තුව.
someTuple = (4,6)
someList = [2,6]
විකෘතිතාව
ටුපල් වෙනස් කළ නොහැකි අතර ලැයිස්තු විකෘති වේ. මෙම කරුණ පහත දැක්වෙන අය සඳහා පදනම වේ.
මතක භාවිතය
විකෘතිතාව නිසා, ඔබට ලැයිස්තු සඳහා වැඩි මතකයක් සහ ටුපල් සඳහා අඩු මතකයක් අවශ්ය වේ.
දිගු කිරීම
ටුපල්ගේ හැඳුනුම්පත වෙනස් වන එකම වෙනස සමඟ ඔබට ටුපල් සහ ලැයිස්තු දෙකටම නව අංගයක් එක් කළ හැකිය (එනම් අපට නව වස්තුවක් ඇත).
හැෂිං
ටුපල් හැෂ් කළ හැකි අතර ලැයිස්තු එසේ නොවේ. එයින් අදහස් කරන්නේ ඔබට ශබ්දකෝෂයක යතුරක් ලෙස ටුපල් එකක් භාවිතා කළ හැකි බවයි. ලැයිස්තුව ශබ්දකෝෂයක යතුරක් ලෙස භාවිතා කළ නොහැකි අතර, ටුපල් එකක් භාවිතා කළ හැකිය
tup = (1,2)
list_ = [1,2]
c = {tup : 1} # ok
c = {list_ : 1} # error
අර්ථ නිරූපණය
මෙම කරුණ හොඳම පුහුණුව ගැන වැඩි යමක් වේ. ලැයිස්තු සමජාතීය අනුක්රමයන් වන අතර ඔබ විෂම දත්ත ව්යුහයන් ලෙස ටුපල් භාවිතා කළ යුතුය.
ලැයිස්තු සමජාතීය අනුක්රමයන් වීමට අදහස් කරන අතර, ටුපල් විෂමජාතීය දත්ත ව්යුහයන් වේ.
විකෘති වන tuples
අතර lists
වෙනස් කළ නොහැකි බව මිනිසුන් දැනටමත් මෙහි පිළිතුරු දී ඇති නමුත්, අප මතක තබා ගත යුතු ටුපල් භාවිතා කිරීමේ එක් වැදගත් අංගයක් තිබේ
tuple
එහි list
හෝ එහි dictionary
ඇතුළත අඩංගු නම් , ඒවා වෙනස් කළ නොහැකි වුවද ඒවා වෙනස් කළ හැකිය tuple
.
උදාහරණයක් ලෙස, අපි ලැයිස්තුවක් සහ ශබ්ද කෝෂයක් අඩංගු ටුපල් එකක් ඇතැයි සිතමු
my_tuple = (10,20,30,[40,50],{ 'a' : 10})
අපට ලැයිස්තුවේ අන්තර්ගතය වෙනස් කළ හැකිය
my_tuple[3][0] = 400
my_tuple[3][1] = 500
එමඟින් නව ටුපල් පෙනුමක් ඇති කරයි
(10, 20, 30, [400, 500], {'a': 10})
අපට ශබ්ද කෝෂය ඇතුළත ශබ්ද කෝෂය වෙනස් කළ හැකිය
my_tuple[4]['a'] = 500
එමඟින් සමස්ත ටුපල් පෙනුම පෙනේ
(10, 20, 30, [400, 500], {'a': 500})
මේ නිසා සිදු වන list
හා dictionary
අරමුණු සහ මෙම වස්තූන් වෙනස් වේ වේ, නමුත් අන්තර්ගතය එහි පෙන්වා දුන්නාය.
එබැවින් tuple
කිසිදු ව්යතිරේකයකින් තොරව ඉතිරිව පවතී
මෙම පී 484 - වර්ගය ඉඟි මූලික ලක්ෂන වර්ග බවයි tuple
තනි තනිව යතුරු ලියනය කළ හැක; එවිට ඔබට පැවසිය හැකිය Tuple[str, int, float]
; නමුත් a list
, List
යතුරු ලියන පන්තියට ගත හැක්කේ එක් වර්ගයක පරාමිතියක් පමණි List[str]
:, එයින් ඇඟවෙන්නේ 2 හි වෙනස සැබවින්ම කලින් ඇති විෂමජාතීය බව වන අතර දෙවැන්න සහජයෙන්ම සමජාතීය වේ.
එසේම, සම්මත පුස්තකාලය බොහෝ විට භාවිතා කරන්නේ සී නැවත ලබා දෙන එවැනි සම්මත ශ්රිතයන්ගෙන් ප්රතිලාභ අගයක් ලෙස ය struct
.
මිනිසුන් දැනටමත් වෙනස්කම් සඳහන් කර ඇති නිසා මම ලියන්නේ ඇයිද යන්න ගැන.
ටුපල් වලට වැඩි කැමැත්තක් දක්වන්නේ ඇයි?
කුඩා ටුපල් සඳහා ප්රතිපාදන ප්රශස්තිකරණය
මතක ඛණ්ඩනය අඩු කිරීම සහ ප්රතිපාදන වේගවත් කිරීම සඳහා, පයිතන් පැරණි ටුපල් නැවත භාවිතා කරයි. ටුපල් එකක් තවදුරටත් අවශ්ය නොවන්නේ නම් සහ එය ස්ථිරවම මකා දැමීම වෙනුවට අයිතම 20 ට වඩා අඩු නම් පයිතන් එය නිදහස් ලැයිස්තුවකට ගෙන යයි.
නිදහස් ලැයිස්තුවක් කණ්ඩායම් 20 කට බෙදා ඇති අතර, සෑම කණ්ඩායමක්ම 0 සිට 20 දක්වා දිග n ටුපල් ලැයිස්තුවක් නියෝජනය කරයි. සෑම කණ්ඩායමකටම ටුපල් 2 000 ක් දක්වා ගබඩා කළ හැකිය. පළමු (ශුන්ය) කාණ්ඩයේ අඩංගු වන්නේ මූලද්රව්ය 1 ක් පමණක් වන අතර හිස් ටුපල් එකක් නියෝජනය කරයි.
>>> a = (1,2,3)
>>> id(a)
4427578104
>>> del a
>>> b = (1,2,4)
>>> id(b)
4427578104
ඉහත උදාහරණයේ දී අපට පෙනෙන්නේ a සහ b එකම හැඳුනුම්පතක් ඇති බවයි. එයට හේතුව අපි වහාම නිදහස් ලැයිස්තුවේ තිබූ විනාශ වූ ටුපල් එකක් අල්ලා ගැනීමයි.
ලැයිස්තු සඳහා ප්රතිපාදන ප්රශස්තිකරණය
ලැයිස්තු වෙනස් කළ හැකි බැවින්, පයිතන් ටුපල් වල ඇති ප්රශස්තිකරණය භාවිතා නොකරයි. කෙසේ වෙතත්, පයිතන් ලැයිස්තු වලද නොමිලේ ලැයිස්තුවක් ඇත, නමුත් එය භාවිතා කරන්නේ හිස් වස්තු සඳහා පමණි. GC විසින් හිස් ලැයිස්තුවක් මකා දැමුවහොත් හෝ එකතු කරන්නේ නම්, එය පසුව නැවත භාවිතා කළ හැකිය.
>>> a = []
>>> id(a)
4465566792
>>> del a
>>> b = []
>>> id(b)
4465566792
මුලාශ්රය: https://rushter.com/blog/python-lists-and-tuples/
ලැයිස්තු වලට වඩා ටුපල් කාර්යක්ෂම වන්නේ ඇයි? -> https://stackoverflow.com/a/22140115
5.3 හි ප්රලේඛනයෙන් දිශා උපුටා දැක්වීමක් . ටුපල්ස් සහ අනුක්රම :
ටුපල් ලැයිස්තු වලට සමාන බවක් පෙනුනද, ඒවා බොහෝ විට විවිධ අවස්ථාවන්හිදී සහ විවිධ අරමුණු සඳහා භාවිතා කරයි. Tuples වේ අණුවල පැවැත්ම වන අතර, සාමාන්යයෙන් අඩංගු වන විවිධ ගෝති්රකයන්, අනුක්රමය හරහා ප්රවේශ වන බව මූලද්රව්ය විහිදු (පසුව මෙම කොටසේ බලන්න) හෝ ශක (හෝ namedtuples පිළිබඳ පැමිණිල්ලේ දී විශේෂණය විසින්). ලැයිස්තු mutable , ඔවුන්ගේ අංග සාමාන්යයෙන් සමජාතීය විසින් ප්රවේශ එල්ලාවල මහතා ලැයිස්තුව පුරා.
පළමුවෙන්ම, ඒවා දෙකම පයිතන්හි පරිමාණ නොවන වස්තූන් (සංයුක්ත වස්තු ලෙසද හැඳින්වේ) වේ.
+
(අළුත්ම ටුපල් නිර්මාණය වනු ඇත)(3,) # -> (3)
වෙනුවට සිංගල්ටන්(3) # -> 3
[3]
new_array = origin_array[:]
[x**2 for x in range(1,7)]
ඔබට ලබා දෙයි
[1,4,9,16,25,36]
(කියවිය නොහැක)ලැයිස්තුව භාවිතා කිරීමෙන් අන්වර්ථ දෝෂයක් ද ඇති විය හැකිය (එකම වස්තුවකට යොමු වන වෙනස් මාර්ග දෙකක්).
ලැයිස්තු විකෘති වන අතර ටුපල් වෙනස් නොවේ. මෙම උදාහරණය සලකා බලන්න.
a = ["1", "2", "ra", "sa"] #list
b = ("1", "2", "ra", "sa") #tuple
දැන් ලැයිස්තුවේ සහ ටුපල් වල දර්ශක අගයන් වෙනස් කරන්න.
a[2] = 1000
print a #output : ['1', '2', 1000, 'sa']
b[2] = 1000
print b #output : TypeError: 'tuple' object does not support item assignment.
එබැවින් පහත දැක්වෙන කේතය ටුපල් සමඟ වලංගු නොවන බව සනාථ විය, මන්ද අපි ටුපල් යාවත්කාලීන කිරීමට උත්සාහ කළ බැවින් එයට අවසර නැත.
පුදුමාකාරයි. list
එදිරිව tuple
ප්රතිචාර සඳහා ඉක්මන් දිගුවක් :
list
අවශ්ය මතකයට වඩා බිට් බාල්දි වෙන් කරයි. අනාගතයේදී අමතර අයිතම එකතු කළ හොත් මිල අධික නැවත ස්ථානගත කිරීම වැළැක්වීම සඳහා මෙය සිදු කෙරේ.ප්රභවයෙන් එය සිදු කරන්නේ කෙසේදැයි දැන ගැනීමට, 49 වන පේළිය ස්ථානයයි ( cpython / Objects / listobject.c ):
new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6);
tuple
වස්තුවක් ඒවා ගබඩා කිරීම සඳහා අවශ්ය අමතර මතකය වෙන් නොකරයි.ලැයිස්තුව විකෘති වන අතර ටුපල් වෙනස් කළ නොහැක. විකෘති හා වෙනස් කළ නොහැකි අතර ඇති ප්රධාන වෙනස වන්නේ ඔබ අයිතමයක් එකතු කිරීමට උත්සාහ කරන විට මතක භාවිතයයි.
ඔබ විචල්යයක් නිර්මාණය කරන විට, යම් ස්ථාවර මතකයක් විචල්යයට පවරනු ලැබේ. එය ලැයිස්තුවක් නම්, ඇත්ත වශයෙන්ම භාවිතා කිරීමට වඩා වැඩි මතකයක් පවරනු ලැබේ. උදා: වත්මන් මතක පැවරුම බයිට් 100 ක් නම්, ඔබට 101 වන බයිට් එකතු කිරීමට අවශ්ය වූ විට, තවත් බයිට් 100 ක් පැවරෙනු ඇත (මෙම අවස්ථාවේදී මුළු බයිට් 200 කින්).
කෙසේ වෙතත්, ඔබ නිතර නව මූලද්රව්ය එකතු නොකරන බව ඔබ දන්නේ නම්, ඔබ ටුපල් භාවිතා කළ යුතුය. ටුපල්ස් අවශ්ය මතක ප්රමාණය හරියටම නියම කරයි, එබැවින් මතකය ඉතිරි කරයි, විශේෂයෙන් ඔබ විශාල මතක කොටස් භාවිතා කරන විට.