මෙම පිළිතුර මගින් උදාහරණ සමඟ මික්සින් පැහැදිලි කිරීම අරමුණු කරයි :
ස්වයං අන්තර්ගත : කෙටි, උදාහරණය තේරුම් ගැනීමට කිසිදු පුස්තකාලයක් දැන ගැනීමට අවශ්ය නැත.
පයිතන් භාෂාවෙන් මිස වෙනත් භාෂාවලින් නොවේ.
එම භාෂාවල මෙම යෙදුම වඩාත් සුලභ බැවින් රූබි වැනි වෙනත් භාෂාවලින් උදාහරණ ඇති බව තේරුම් ගත හැකි නමුත් මෙය පයිතන් නූලකි.
එය මතභේදාත්මක ප්‍රශ්නය ද සලකා බලනු ඇත:
බහුවිධ උරුමයක් අවශ්‍යද නැත්නම් මික්සින් චරිතයක් නොවේද?
අර්ථ දැක්වීම්
පයිතන්හි මිශ්‍රණයක් යනු කුමක්දැයි පැහැදිලිව පවසන “බලයලත්” ප්‍රභවයකින් උපුටා දැක්වීමක් මා තවම දැක නැත.
මික්සින් සඳහා විය හැකි නිර්වචන 2 ක් මම දැක ඇත්තෙමි (ඒවා වියුක්ත පාදක පන්ති වැනි වෙනත් සමාන සංකල්පවලට වඩා වෙනස් ලෙස සැලකිය යුතු නම්), සහ කුමන ඒවා නිවැරදිද යන්න ජනතාව සම්පූර්ණයෙන්ම එකඟ නොවේ.
සම්මුතිය විවිධ භාෂා අතර වෙනස් විය හැකිය.
අර්ථ දැක්වීම 1: බහු උරුමයක් නොමැත
මික්සින් යනු පංතියක් වන අතර පන්තියේ සමහර ක්‍රමයක් පන්තියේ අර්ථ දක්වා නැති ක්‍රමයක් භාවිතා කරයි.
එබැවින් පංතිය ක්ෂණිකව දැක්වීමට නොව මූලික පංතියක් ලෙස සේවය කරයි. එසේ නොවුවහොත්, ව්‍යතිරේකයක් මතු නොකර ඇමතිය නොහැකි ක්රම තිබේ.
සමහර ප්‍රභවයන් එකතු කරන බාධකයක් නම් පන්තියේ දත්ත අඩංගු නොවිය හැකි බවයි, ක්රම පමණි, නමුත් මෙය අවශ්ය වන්නේ මන්දැයි මම නොදනිමි. කෙසේ වෙතත්, ප්‍රායෝගිකව, බොහෝ ප්‍රයෝජනවත් මික්සින් වලට දත්ත නොමැත, සහ දත්ත නොමැතිව මූලික පන්ති භාවිතා කිරීම පහසුය.
සම්භාව්‍ය නිදසුනක් නම්, සියලු සංසන්දනාත්මක ක්‍රියාකරුවන් පමණක් ක්රියාත්මක කිරීම <=සහ ==:
class ComparableMixin(object):
"""This class has methods which use `<=` and `==`,
but this class does NOT implement those methods."""
def __ne__(self, other):
return not (self == other)
def __lt__(self, other):
return self <= other and (self != other)
def __gt__(self, other):
return not self <= other
def __ge__(self, other):
return self == other or self > other
class Integer(ComparableMixin):
def __init__(self, i):
self.i = i
def __le__(self, other):
return self.i <= other.i
def __eq__(self, other):
return self.i == other.i
assert Integer(0) < Integer(1)
assert Integer(0) != Integer(1)
assert Integer(1) > Integer(0)
assert Integer(1) >= Integer(1)
# It is possible to instantiate a mixin:
o = ComparableMixin()
# but one of its methods raise an exception:
#o != o
මෙම සුවිශේෂී උදාහරණය functools.total_ordering()සැරසිලි කරුවා හරහා ලබා ගත හැකි නමුත් මෙහි ක්‍රීඩාව වූයේ රෝදය ප්‍රතිනිර්මාණය කිරීමයි:
import functools
@functools.total_ordering
class Integer(object):
def __init__(self, i):
self.i = i
def __le__(self, other):
return self.i <= other.i
def __eq__(self, other):
return self.i == other.i
assert Integer(0) < Integer(1)
assert Integer(0) != Integer(1)
assert Integer(1) > Integer(0)
assert Integer(1) >= Integer(1)
අර්ථ දැක්වීම 2: බහු උරුමය
මික්සින් යනු මූලික පන්තියක යම් ක්‍රමයක් එය නිර්වචනය නොකරන ක්‍රමයක් භාවිතා කරන මෝස්තර රටාවක් වන අතර, එම ක්රමය ක්රියාත්මක කිරීමට අදහස් කරන්නේ අර්ථ දැක්වීම 1 හි ව්යුත්පන්න කර ඇති ආකාරයට නොව වෙනත් පාදක පන්තියක් විසිනි.
පදය mixin පන්ති මෝස්තර රටාව තුළ භාවිතා කිරීමට බලාපොරොත්තු වන අතර මූලික පන්ති අදහස් (කිවමනා ක්රමය භාවිතා කරන ඒවා, හෝ එය ක්රියාත්මක කල යුතු බව එම?)
දී ඇති පංතියක් මික්සින් ද නැද්ද යන්න තීරණය කිරීම පහසු නැත: මෙම ක්රමය ව්යුත්පන්න පංතිය මත පමණක් ක්රියාත්මක කළ හැකි අතර, එම අවස්ථාවේ දී අපි නැවත අර්ථ දැක්වීම 1 වෙත යමු. ඔබ කතුවරයාගේ අභිප්‍රායන් සලකා බැලිය යුතුය.
මෙම රටාව සිත්ගන්නාසුළු වන්නේ මූලික පන්තිවල විවිධ තේරීම් සමඟ ක්‍රියාකාරීත්වය නැවත ඒකාබද්ධ කළ හැකි බැවිනි:
class HasMethod1(object):
def method(self):
return 1
class HasMethod2(object):
def method(self):
return 2
class UsesMethod10(object):
def usesMethod(self):
return self.method() + 10
class UsesMethod20(object):
def usesMethod(self):
return self.method() + 20
class C1_10(HasMethod1, UsesMethod10): pass
class C1_20(HasMethod1, UsesMethod20): pass
class C2_10(HasMethod2, UsesMethod10): pass
class C2_20(HasMethod2, UsesMethod20): pass
assert C1_10().usesMethod() == 11
assert C1_20().usesMethod() == 21
assert C2_10().usesMethod() == 12
assert C2_20().usesMethod() == 22
# Nothing prevents implementing the method
# on the base class like in Definition 1:
class C3_10(UsesMethod10):
def method(self):
return 3
assert C3_10().usesMethod() == 13
අධිකාරී පයිතන් සිදුවීම්
දී collections.abc සඳහා නිල documentatiton ලේඛගතකිරීම සුවිශේෂව යන වචනය භාවිතා කරමින් Mixin ක්රම .
පංතියක් නම්:
- ක්රියාත්මක කරයි
__next__
- තනි පන්තියකින් උරුම වේ
Iterator
එවිට පන්තියට නොමිලේ __iter__ මික්සින් ක්‍රමයක් ලැබේ.
එබැවින් අවම වශයෙන් ප්‍රලේඛනයේ මෙම අවස්ථාවෙහිදී, මික්සින්ට බහු උරුමයක් අවශ්ය නොවන අතර එය අර්ථ දැක්වීම 1 සමඟ සමපාත වේ.
ප්‍රලේඛනය විවිධ ස්ථානවල පරස්පර විරෝධී විය හැකි අතර අනෙකුත් වැදගත් පයිතන් පුස්තකාල ඔවුන්ගේ ප්‍රලේඛනයේ අනෙක් අර්ථ දැක්වීම භාවිතා කරයි.
මෙම පිටුව ද මෙම පදය භාවිතා කරයි Set mixin, එය පැහැදිලිවම යෝජනා කරන්නේ පන්ති වලට කැමති Setහා Iteratorමික්සින් පන්ති ලෙස හැඳින්විය හැකි බවයි.
වෙනත් භාෂාවලින්
රූබි: ක්‍රමලේඛන රූබි සහ රූබි ක්‍රමලේඛන භාෂාව වැනි ප්‍රධාන යොමු පොත් වල සඳහන් කර ඇති පරිදි මික්සින් සඳහා බහු උරුමයක් අවශ්ය නොවන බව පැහැදිලිය.
C ++: virtualසකසා =0ඇති ක්‍රමයක් පිරිසිදු අථත්ය ක්‍රමයකි.
අර්ථ දැක්වීම 1 වියුක්ත පංතියක නිර්වචනය සමඟ සමපාත වේ (පිරිසිදු අථත්ය ක්‍රමයක් ඇති පන්තියක්). එම පන්තිය ක්ෂණිකව කළ නොහැක.
අථත්ය උරුමය සමඟ අර්ථ දැක්වීම 2 හැකි ය: ව්යුත්පන්න පන්ති දෙකකින් බහු උරුමය