'ස්වයං' යන වචනයේ අරමුණ කුමක්ද?

selfපයිතන්හි වචනයේ අරමුණ කුමක්ද? එය පන්තියෙන් නිර්මාණය කරන ලද නිශ්චිත වස්තුවක් බව මට වැටහී ඇත, නමුත් එය පරාමිතියක් ලෙස සෑම ශ්‍රිතයක් සඳහාම පැහැදිලිවම එකතු කළ යුත්තේ මන්දැයි මට නොපෙනේ. නිදර්ශනය කිරීම සඳහා, රූබි භාෂාවෙන් මට මෙය කළ හැකිය:

class myClass
    def myFunc(name)
        @name = name
    end
end

මට තේරෙන, ඉතා පහසුවෙන්. කෙසේ වෙතත් පයිතන්හි මා ඇතුළත් කළ යුත්තේ self:

class myClass:
    def myFunc(self, name):
        self.name = name

මේ හරහා කිසිවෙකුට මා සමඟ කතා කළ හැකිද? එය මගේ (පිළිගත් සීමිත) අත්දැකීම් තුලින් මා හමු වූ දෙයක් නොවේ.

ඔබ භාවිතා කිරීමට self.හේතුව පයිතන් @නිදර්ශන ගුණාංග වෙත යොමු කිරීම සඳහා වාක්‍ය ඛණ්ඩය භාවිතා නොකිරීමයි . Python මීට උදාහරණ ක්රමය අයත් වන කළ කාරණයේ ඇති කරවන ආකාරයෙන් ක්රම කරන්න තීරණය කළා සම්මත ස්වයංක්රීයව, නමුත් ලැබී ක්රම පළමු පරාමිතිය ක්රමය මත හැඳින්වේ වන අවස්ථාව වේ: ස්වයංක්රීයව. එමඟින් ක්‍රමයන් මුළුමනින්ම ක්‍රියාකාරීත්වයට සමාන වන අතර සැබෑ නම ඔබට භාවිතා කිරීමට ඉඩ දෙයි ( selfසම්මුතිය වුවද , ඔබ වෙනත් දෙයක් භාවිතා කරන විට මිනිසුන් සාමාන්‍යයෙන් ඔබ කෙරෙහි කෝප වනු ඇත.) selfකේතයට විශේෂ නොවේ, එය තවත් වස්තුවකි .

සාමාන්‍ය නම් වලින් ගුණාංග වෙන්කර හඳුනා ගැනීම සඳහා පයිතන්ට වෙනත් දෙයක් කළ හැකිය - රූබි වැනි විශේෂ වාක්‍ය ඛණ්ඩයක් හෝ සී ++ සහ ජාවා ඩෝ වැනි ප්‍රකාශ අවශ්‍ය වේ, හෝ ඊට වඩා වෙනස් දෙයක් - නමුත් එය එසේ නොවීය. පයිතන් සියල්ලම පැහැදිලිව ප්‍රකාශ කිරීම, කුමක් දැයි පැහැදිලි කිරීම සහ එය සම්පූර්ණයෙන්ම සෑම තැනකම සිදු නොකලද එය නිදසුනක් ලෙස එය කරයි. නිදර්ශන ගුණාංගයකට පැවරීම සඳහා කුමන අවස්ථාව පැවරිය යුතු දැයි දැන ගැනීමට අවශ්‍ය වන්නේ එබැවිනි self..

ඔබට පන්තියක් ClassAඇති බව කියමු methodA.

def methodA(self, arg1, arg2):
    # do something

හා ObjectAමෙම පන්තියේ උදාහරණයක් වේ.

දැන් ObjectA.methodA(arg1, arg2)හැඳින්වූ විට , පයිතන් අභ්‍යන්තරව එය ඔබ වෙනුවෙන් පරිවර්තනය කරයි:

ClassA.methodA(ObjectA, arg1, arg2)

මෙම selfවිචල්ය වස්තුව ම සඳහන් කරයි.

අපි සරල දෛශික පන්තියක් ගනිමු:

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

දිග ගණනය කරන ක්‍රමයක් අපට අවශ්‍යය. පංතිය තුළ අපට එය අර්ථ දැක්වීමට අවශ්‍ය නම් එය කෙබඳු වනු ඇත්ද?

    def length(self):
        return math.sqrt(self.x ** 2 + self.y ** 2)

අප එය ගෝලීය ක්‍රමයක් / ශ්‍රිතයක් ලෙස අර්ථ දැක්වීමේදී එය කෙබඳු විය යුතුද?

def length_global(vector):
    return math.sqrt(vector.x ** 2 + vector.y ** 2)

එබැවින් සමස්ත ව්‍යුහයම එලෙසම පවතී. මට මෙය භාවිතා කළ හැක්කේ කෙසේද? lengthඅපගේ Vectorපංතිය සඳහා ක්‍රමවේදයක් ලියා නොමැති බව අපි මොහොතකට උපකල්පනය කළහොත් අපට මෙය කළ හැකිය:

Vector.length_new = length_global
v = Vector(3, 4)
print(v.length_new()) # 5.0

නිසා පළමු පරාමිතිය මෙම ක්රියා length_global, ලෙස නැවත භාවිතා කළ හැකි selfතුළ පරාමිතිය length_new. පැහැදිලි කිරීමකින් තොරව මෙය කළ නොහැකි වනු ඇත self.

පැහැදිළි කිරීමේ අවශ්‍යතාවය අවබෝධ කර ගත හැකි තවත් ක්‍රමයක් selfනම් පයිතන් සින්ටැක්ටිකල් සීනි එකතු කරන්නේ කොතැනට දැයි බැලීමයි. ඔබ මතකයේ තබා ගත් විට, එය මූලික වශයෙන්, ඇමතුමක් වැනි ය

v_instance.length()

අභ්‍යන්තරව පරිවර්තනය වේ

Vector.length(v_instance)

selfගැළපෙන්නේ කොතැනට දැයි බැලීම පහසුය . ඔබ ඇත්ත වශයෙන්ම පයිතන්හි උදාහරණ ක්‍රම ලියන්නේ නැත; ඔබ ලියන්නේ පන්ති ක්‍රම වන අතර එය පළමු පරාමිතිය ලෙස ගත යුතුය. එමනිසා, ඔබට උදාහරණ පරාමිතිය කොතැනක හෝ පැහැදිලිව තැබිය යුතුය.

වස්තූන් ක්ෂණිකව සිදු කළ විට, වස්තුව ස්වයං පරාමිතිය තුළට යවනු ලැබේ.

මේ නිසා, වස්තුවේ දත්ත වස්තුවට බැඳී ඇත. පහත දැක්වෙන්නේ එක් එක් වස්තුවේ දත්ත කුමක් දැයි දෘශ්‍යමාන කිරීමට ඔබ කැමති ආකාරය පිළිබඳ උදාහරණයකි. 'ස්වයං' වස්තු නාමයෙන් ප්‍රතිස්ථාපනය කරන්නේ කෙසේදැයි බලන්න. පහත දැක්වෙන උදාහරණ රූප සටහන මුළුමනින්ම නිවැරදි යැයි මම නොකියමි, නමුත් එය ස්වයං භාවිතය දෘශ්‍යමාන කිරීමේ අරමුණක් ඉටු කරයි.

වස්තුව ස්වයං පරාමිතිය තුළට සම්ප්‍රේෂණය වන අතර එමඟින් වස්තුවට තමන්ගේ දත්ත රඳවා තබා ගත හැකිය.

මෙය සම්පුර්ණයෙන්ම නිවැරදි නොවිය හැකි වුවද, මෙවැනි වස්තුවක් ක්ෂණිකව ක්‍රියාත්මක කිරීමේ ක්‍රියාවලිය ගැන සිතන්න: වස්තුවක් සෑදූ විට එය පන්තිය තමන්ගේම දත්ත සහ ක්‍රම සඳහා අච්චුවක් ලෙස භාවිතා කරයි. ස්වයං පරාමිතිය තුළට තමන්ගේම නමක් නොතබා, පන්තියේ ගුණාංග සහ ක්‍රම සාමාන්‍ය අච්චුවක් ලෙස පවතිනු ඇති අතර එය වස්තුවට (අයත්) යොමු නොකෙරේ. එබැවින් වස්තුවේ නම ස්වයං පරාමිතිය තුළට යැවීමෙන් අදහස් වන්නේ එක් පන්තියකින් වස්තු 100 ක් ක්ෂණිකව ලබා ගත හොත්, ඒ සියල්ලටම ඔවුන්ගේ දත්ත සහ ක්‍රමවේදයන් පිළිබඳව සොයා බැලිය හැකි බවයි.

පහත උපමාව බලන්න:

මම මෙම උදාහරණයට කැමතියි:

class A: 
    foo = []
a, b = A(), A()
a.foo.append(5)
b.foo
ans: [5]

class A: 
    def __init__(self): 
        self.foo = []
a, b = A(), A()
a.foo.append(5)
b.foo
ans: []

පංති භාවිතා නොකරන කේත සමඟ මම නිරූපණය කරමි :

def state_init(state):
    state['field'] = 'init'

def state_add(state, x):
    state['field'] += x

def state_mult(state, x):
    state['field'] *= x

def state_getField(state):
    return state['field']

myself = {}
state_init(myself)
state_add(myself, 'added')
state_mult(myself, 2)

print( state_getField(myself) )
#--> 'initaddedinitadded'

පංති යනු සෑම විටම මෙම "තත්වයට" නොපැමිණීමේ මාර්ගයකි (සහ ආරම්භ කිරීම, පන්ති සංයුතිය, කලාතුරකින් අවශ්‍ය වන මෙටාක්ලාස්, සහ ක්‍රියාකරුවන් අභිබවා යාමට අභිරුචි ක්‍රමවලට සහාය දීම වැනි වෙනත් හොඳ දේවල්).

දැන් ඉහත කේතය බිල්ට් පයිතන් පන්තියේ යන්ත්‍රෝපකරණ භාවිතයෙන් නිරූපණය කරමු, එය මූලික වශයෙන් එකම දේ බව පෙන්වීමට.

class State(object):
    def __init__(self):
        self.field = 'init'
    def add(self, x):
        self.field += x
    def mult(self, x):
        self.field *= x

s = State()
s.add('added')    # self is implicitly passed in
s.mult(2)         # self is implicitly passed in
print( s.field )

[මගේ පිළිතුර අනුපිටපත් සංවෘත ප්‍රශ්නයෙන් සංක්‍රමණය විය]

පහත දැක්වෙන උපුටා ගැනීම් ස්වයං පිළිබඳ පයිතන් ප්‍රලේඛනයෙන් වේ :

මොඩියුලා -3 හි මෙන්, වස්තුවේ සාමාජිකයන් එහි ක්‍රම වලින් යොමු කිරීම සඳහා [පයිතන්හි] කෙටිමං නොමැත: ක්‍රමයේ ක්‍රියාකාරිත්වය ප්‍රකාශයට පත් කරනු ලබන්නේ වස්තුව නියෝජනය කරන පැහැදිලි පළමු තර්කයෙනි, එය ඇමතුමෙන් ව්‍යංගයෙන් සපයනු ලැබේ.

බොහෝ විට, ක්‍රමයක පළමු තර්කය ස්වයං ලෙස හැඳින්වේ. මෙය සම්මුතියකට වඩා වැඩි දෙයක් නොවේ: ස්වයං යන නමට පයිතන්ට විශේෂ අර්ථයක් නැත. කෙසේ වෙතත්, සම්මුතිය අනුගමනය නොකිරීමෙන් ඔබේ කේතය වෙනත් පයිතන් ක්‍රමලේඛකයන්ට කියවිය නොහැකි බව සලකන්න. එවැනි සම්මුතියක් මත රඳා පවතින පන්ති බ්‍රව්සර් වැඩසටහනක් ලිවිය හැකි යැයි සිතිය හැකිය.

වැඩි විස්තර සඳහා, පන්ති පිළිබඳ පයිතන් ප්‍රලේඛන නිබන්ධනය බලන්න .

දැනටමත් සඳහන් කර ඇති අනෙකුත් සියලුම හේතු මෙන්ම, අභිබවා ගිය ක්‍රම වෙත පහසුවෙන් ප්‍රවේශ වීමට එය ඉඩ දෙයි; ඔබට ඇමතිය හැකිය Class.some_method(inst).

එය ප්‍රයෝජනවත් තැනකට උදාහරණයක්:

class C1(object):
    def __init__(self):
         print "C1 init"

class C2(C1):
    def __init__(self): #overrides C1.__init__
        print "C2 init"
        C1.__init__(self) #but we still want C1 to init the class too

>>> C2()
"C2 init"
"C1 init"

එහි භාවිතය thisජාවා හි යතුරු පද භාවිතා කිරීමට සමාන වේ , එනම් වත්මන් වස්තුවට යොමු දැක්වීමක්.

පයිතන් යනු ජාවා හෝ සී ++ මෙන් නොව වස්තු දිශානත වැඩසටහන්කරණය සඳහා සාදන ලද භාෂාවක් නොවේ.

පයිතන්හි ස්ථිතික ක්‍රමයක් අමතන විට යමෙක් එය තුළ සාමාන්‍ය තර්ක සහිත ක්‍රමයක් ලියයි.

class Animal():
    def staticMethod():
        print "This is a static method"

කෙසේ වෙතත්, වස්තුවක් වන ඔබට විචල්‍යයක් කිරීමට අවශ්‍ය වන සතෙකු වන මෙම අවස්ථාවේදී ස්වයං තර්කය අවශ්‍ය වේ

class Animal():
    def objectMethod(self):
        print "This is an object method which needs an instance of a class"

පංතිය තුළ විචල්ය ක්ෂේත්රයක් යොමු කිරීම සඳහා ස්වයං ක්රමය භාවිතා කරයි.

class Animal():
    #animalName made in constructor
    def Animal(self):
        self.animalName = "";


    def getAnimalName(self):
        return self.animalName

මෙම අවස්ථාවේ දී, ස්වයං යන්නෙන් අදහස් කරන්නේ සමස්ත පන්තියේ සත්ව නාම විචල්‍යයයි. මතක තබා ගන්න: ඔබට ක්‍රමයක් තුළ විචල්‍යයක් තිබේ නම්, ස්වයං ක්‍රියා නොකරනු ඇත. එම විචල්‍යය පවතින්නේ එම ක්‍රමය ක්‍රියාත්මක වන අතරතුර පමණි. ක්ෂේත්ර නිර්වචනය කිරීම සඳහා (සමස්ත පන්තියේ විචල්යයන්), ඔබ ඒවා පන්ති ක්රම වලින් පිටත අර්ථ දැක්විය යුතුය.

මා පවසන දෙයින් එක වචනයක්වත් ඔබට තේරෙන්නේ නැත්නම්, ගූගල් "Object Oriented Programming". ඔබ මෙය තේරුම් ගත් පසු, ඔබට එම ප්‍රශ්නය ඇසීමට පවා අවශ්‍ය නොවනු ඇත :).

පයිතන් සෙන් අනුගමනය කිරීම එහි ඇත “පැහැදිලිව ඇඟවීමට වඩා හොඳය”. එය ඇත්ත වශයෙන්ම ඔබේ පන්ති වස්තුවට යොමු කිරීමකි. ජාවා සහ පීඑච්පී වල, උදාහරණයක් ලෙස, එය හැඳින්වේ this.

user_type_nameඔබේ ආකෘතියේ ක්ෂේත්‍රයක් නම් ඔබ එයට පිවිසිය හැකිය self.user_type_name.

පළමුවෙන්ම, ස්වයං යනු සම්ප්‍රදායික නමකි, ඔබට වෙනත් ඕනෑම දෙයක් (සුහදව) ඒ වෙනුවට තැබිය හැකිය.

එය වස්තුවටම යොමු දක්වයි, එබැවින් ඔබ එය භාවිතා කරන විට .name සහ .age යනු ඔබ නිර්මාණය කිරීමට යන ශිෂ්‍ය වස්තූන්ගේ ගුණාංග බව සලකන්න (සටහන, ශිෂ්‍ය පන්තියේ නොවේ).

class Student:
    #called each time you create a new Student instance
    def __init__(self,name,age): #special method to initialize
        self.name=name
        self.age=age

    def __str__(self): #special method called for example when you use print
        return "Student %s is %s years old" %(self.name,self.age)

    def call(self, msg): #silly example for custom method
        return ("Hey, %s! "+msg) %self.name

#initializing two instances of the student class
bob=Student("Bob",20)
alice=Student("Alice",19)

#using them
print bob.name
print bob.age
print alice #this one only works if you define the __str__ method
print alice.call("Come here!") #notice you don't put a value for self

#you can modify attributes, like when alice ages
alice.age=20
print alice

කේතය මෙහි ඇත

selfවස්තුවකටම වස්තු යොමු කිරීමකි, එබැවින් ඒවා සමාන වේ. පයිතන් ක්‍රම හැඳින්වෙන්නේ වස්තුවේ සන්දර්භය තුළ නොවේ. selfඅභිරුචි වස්තු ආකෘති හෝ වෙනත් දෙයක් සමඟ කටයුතු කිරීමට පයිතන් භාවිතා කළ හැකිය.

සාම්ප්‍රදායිකව හැඳින්වෙන තර්කය භාවිතා කිරීම selfතේරුම් ගැනීමට අපහසු නැත, එය අවශ්‍ය වන්නේ ඇයි? නැතහොත් එය පැහැදිලිව සඳහන් කරන්නේ ඇයි? මෙම ප්‍රශ්නය දෙස බලන බොහෝ පරිශීලකයින්ට එය විශාල ප්‍රශ්නයක් යැයි මම සිතමි, නැතහොත් එය එසේ නොවේ නම්, ඔවුන් ඉගෙනීමේ පයිතන් ඉදිරියට යන විට ඔවුන්ට නිසැකවම එකම ප්‍රශ්නය ඇත. මෙම බ්ලොග් කිහිපයක් කියවීමට මම ඔවුන්ට නිර්දේශ කරමි:

1: ස්වයං භාවිතය පැහැදිලි කිරීම

එය මූල පදයක් නොවන බව සලකන්න.

Init ඇතුළුව සෑම පන්ති ක්‍රමයකම පළමු තර්කය සෑම විටම පන්තියේ වර්තමාන අවස්ථාව වෙත යොමු කිරීමකි. සම්මුතිය අනුව, මෙම තර්කය සැමවිටම ස්වයං ලෙස නම් කර ඇත. ආරම්භක ක්‍රමයේදී ස්වයං යන්නෙන් අදහස් කරන්නේ අලුතින් සාදන ලද වස්තුවයි; වෙනත් පංති ක්‍රම වලදී, එය යොමු කරනුයේ ක්‍රමවේදය හැඳින්වූ අවස්ථාවයි. උදාහරණයක් ලෙස පහත කේතය ඉහත කේතයට සමාන වේ.

2: අපට එය මේ ආකාරයෙන් ඇත්තේ ඇයි සහ අපට එය ජාවා වැනි තර්කයක් ලෙස තුරන් කළ නොහැක්කේ ඇයි?

මම එකතු කිරීමට කැමති තවත් දෙයක් නම්, විකල්ප selfතර්කයක් මඟින් ලිවීමකින් තොරව පන්තියක් තුළ ස්ථිතික ක්‍රම ප්‍රකාශ කිරීමට මට ඉඩ ලබා දේ self.

කේත උදාහරණ:

class MyClass():
    def staticMethod():
        print "This is a static method"

    def objectMethod(self):
        print "This is an object method which needs an instance of a class, and that is what self refers to"

PS : මෙය ක්‍රියාත්මක වන්නේ පයිතන් 3.x හි පමණි.

පෙර සංස්කරණ වලදී, ඔබ පැහැදිලිවම @staticmethodසැරසිලි කරුවෙකු එකතු කළ යුතුය , එසේ නොමැතිනම් selfතර්කය අනිවාර්ය වේ.

මට පුදුමයි කවුරුත් ලුවා හදා වඩා ගත්තේ නැහැ. ලුආ ද 'ස්වයං' විචල්‍යය භාවිතා කරයි, කෙසේ වෙතත් එය මඟ හැරිය හැකි නමුත් තවමත් භාවිතා වේ. C ++ 'මෙය' සමඟ ද එසේමය. සෑම කාර්යයකදීම 'ස්වයං' ප්‍රකාශ කිරීමට කිසිදු හේතුවක් මා දකින්නේ නැත, නමුත් ඔබට තවමත් ලුවා සහ සී ++ සමඟ එය භාවිතා කළ හැකිය. කෙටියෙන් කියා ආඩම්බර වන භාෂාවක් සඳහා ස්වයං විචල්‍යය ප්‍රකාශ කිරීම අවශ්‍ය වේ.

පහත දැක්වෙන උදාහරණය දෙස බලන්න, එහි අරමුණ පැහැදිලිව පැහැදිලි කරයි self

class Restaurant(object):  
    bankrupt = False

    def open_branch(self):
        if not self.bankrupt:
           print("branch opened")

#create instance1
>>> x = Restaurant()
>>> x.bankrupt
False

#create instance2
>>> y = Restaurant()
>>> y.bankrupt = True   
>>> y.bankrupt
True

>>> x.bankrupt
False  

self අවස්ථා අතර වෙනස හඳුනා ගැනීමට භාවිතා කරයි / අවශ්‍ය වේ.

මූලාශ්‍රය: පයිතන් හි ස්වයං විචල්‍යය පැහැදිලි කර ඇත - පයිතොන්ටිප්ස්

එයට හේතුව පයිතන් නිර්මාණය කර ඇති විට විකල්පයන් කිසිසේත්ම ක්‍රියා නොකරනු ඇත. පයිතන් නිර්මාණය කර ඇත්තේ ව්‍යංග this(a-la Java / C ++) හෝ පැහැදිලි @(a-la ruby) යන දෙකම ක්‍රියා නොකරන සන්දර්භයක් තුළ ක්‍රම හෝ කාර්යයන් අර්ථ දැක්වීමට ඉඩ සලසමිනි. පයිතන් සම්මුතීන් සමඟ පැහැදිලි ප්‍රවේශය සමඟ උදාහරණයක් ගනිමු:

def fubar(x):
    self.x = x

class C:
    frob = fubar

එය ගෝලීය විචල්‍යයක් fubarයැයි උපකල්පනය කරන බැවින් දැන් ශ්‍රිතය ක්‍රියා නොකරනු ඇත self( frobඑසේම). විකල්පය වනුයේ ප්‍රතිස්ථාපිත ගෝලීය විෂය පථයකින් ( selfවස්තුව කොහේද ) ක්‍රමවේදය ක්‍රියාත්මක කිරීමයි.

ව්‍යංග ප්‍රවේශය වනු ඇත

def fubar(x)
    myX = x

class C:
    frob = fubar

මෙයින් අදහස් වන්නේ myXඑය දේශීය විචල්‍යයක් ලෙස fubar(සහ frobමෙන්ම) අර්ථ දැක්විය හැකි බවයි. මෙහි ඇති විකල්පය වනුයේ ඇමතුම් අතර රඳවා තබා ඇති ප්‍රතිස්ථාපිත දේශීය විෂය පථයක් සහිත ක්‍රමවේදයන් ක්‍රියාත්මක කිරීමයි, නමුත් එමඟින් දේශීය විචල්‍යයන්ගේ ක්‍රමවේදය ඉවත් කරයි.

කෙසේ වෙතත් වර්තමාන තත්වය හොඳින් ක්‍රියාත්මක වේ:

 def fubar(self, x)
     self.x = x

 class C:
     frob = fubar

මෙහි ක්රමයක් ලෙස ඉල්ලා සිටි විට frobමත එය හරහා අමතන්නේ වස්තුව ලැබෙනු ඇත selfපරාමිතිය, සහ fubarඑම තවමත් පරාමිතිය හා වැඩ කටයුතු ලෙස වස්තුවක් එක්ක යනුවෙන් නම් කළ හැකිය (එය වේ සමාන C.frobමම හිතන්නේ).

තුළ __init__ක්රමය, ස්වයං අලුතින් නිර්මාණය වස්තුව හඳුන්වන්නේ; වෙනත් පංති ක්‍රම වලදී, එය යොමු කරනුයේ ක්‍රමවේදය හැඳින්වූ අවස්ථාවයි.

ස්වයං, නමක් ලෙස, සම්මුතියක් පමණි , ඔබට අවශ්‍ය පරිදි එය අමතන්න! නමුත් එය භාවිතා කරන විට, උදාහරණයක් ලෙස වස්තුව මකා දැමීමට, ඔබ එකම නමක් භාවිතා කළ යුතුය : __del__(var), varභාවිතා කළ ස්ථානය__init__(var,[...])

ඔබ දෙස ගත යුතු clsඇති, ඉතා විශාල ඡන්ද චිත්රයක් . මෙම ලිපිය ප්‍රයෝජනවත් විය හැකිය.

ස්වයං ක්‍රියා කරන්නේ වත්මන් වස්තු නම හෝ පන්තියේ උදාහරණය ලෙස ය.

# Self explanation.


 class classname(object):

    def __init__(self,name):

        self.name=name
        # Self is acting as a replacement of object name.
        #self.name=object1.name

   def display(self):
      print("Name of the person is :",self.name)
      print("object name:",object1.name)


 object1=classname("Bucky")
 object2=classname("ford")

 object1.display()
 object2.display()

###### Output 
Name of the person is : Bucky
object name: Bucky
Name of the person is : ford
object name: Bucky

self නොවැළැක්විය හැකිය.

යන්තම් ඇති විය ප්රශ්නය යුතු selfගම්ය හෝ පැහැදිලි විය. රැඳී සිටිය යුතුGuido van Rossum යැයි කියමින් මෙම ප්‍රශ්නය selfවිසඳීය .

ඉතින් කොහෙද selfජීවත් වෙන්නේ?

අපි ක්‍රියාකාරී වැඩසටහන් වලට ඇලී සිටියහොත් අපට අවශ්‍ය නොවනු selfඇත. අපි පයිතන් ඕඕපීයට ඇතුළු වූ පසු selfඑහි අපට හමු වේ.

මෙන්න class Cක්‍රමය සමඟ සාමාන්‍ය භාවිත අවස්ථාවm1

class C:
    def m1(self, arg):
        print(self, ' inside')
        pass

ci =C()
print(ci, ' outside')
ci.m1(None)
print(hex(id(ci))) # hex memory address

මෙම වැඩසටහන ප්‍රතිදානය කරයි:

<__main__.C object at 0x000002B9D79C6CC0>  outside
<__main__.C object at 0x000002B9D79C6CC0>  inside
0x2b9d79c6cc0

එබැවින් selfපන්තියේ උදාහරණයේ මතක ලිපිනය රඳවා තබා ගනී. මෙහි අරමුණ වනුයේ නිදර්ශන ක්‍රමself සඳහා යොමු කිරීම සහ එම සඳහනට අපට පැහැදිලි ප්‍රවේශයක් තිබීමයි.

_{පන්ති ක්‍රම විවිධ ආකාර තුනක් ඇති බව සලකන්න:}

• _{ස්ථිතික ක්‍රම (කියවන්න: කාර්යයන්),}
• _{පන්ති ක්‍රම,}
• _{නිදර්ශන ක්‍රම (සඳහන් කර ඇත).}

සිට ලේඛන ,

ක්‍රම පිළිබඳ විශේෂත්වය නම් නිදර්ශන වස්තුව ශ්‍රිතයේ පළමු තර්කය ලෙස සම්මත කිරීමයි. අපගේ උදාහරණයේ දී, ඇමතුම x.f()හරියටම සමාන වේ MyClass.f(x). පොදුවේ ගත් කල, n තර්ක ලැයිස්තුවක් සහිත ක්‍රමයක් ඇමතීම, පළමු තර්කයට පෙර ක්‍රමයේ නිදර්ශන වස්තුව ඇතුළත් කිරීමෙන් නිර්මාණය කරන ලද තර්ක ලැයිස්තුවක් සමඟ අනුරූප ශ්‍රිතය ඇමතීමට සමාන වේ.

මෙයට පෙර අදාළ ස්නිපටය,

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

x = MyClass()

මම අවම වශයෙන් පයිතන් සඳහා කියමි, ස්වයං පරාමිතිය ස්ථානගත කරන්නෙකු ලෙස සිතිය හැකිය. මෙය දෙස බලන්න:

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

p1 = Person("John", 36)

print(p1.name)
print(p1.age)

මෙම නඩුවේදී ස්වයං සහ තවත් බොහෝ අය නම අගය ගබඩා කිරීම සඳහා ක්‍රමයක් ලෙස භාවිතා කරන ලදී. කෙසේ වෙතත්, ඊට පසු, අපි භාවිතා කරන පන්තියට එය පැවරීමට p1 භාවිතා කරමු. ඉන්පසු අපි එය මුද්‍රණය කරන විට එකම p1 යතුර භාවිතා කරමු.

මෙය පයිතන්ට උපකාරී වේ යැයි සිතමු!

එය පන්ති නිදර්ශන වස්තුව පිළිබඳ පැහැදිලි සඳහනකි.