'Benlik' kelimesinin amacı nedir?

selfPython'daki kelimenin amacı nedir ? Bu sınıftan oluşturulan belirli bir nesneyi ifade ettiğini anlıyorum, ancak neden açıkça her işleve parametre olarak eklenmesi gerektiğini göremiyorum. Örneklemek gerekirse, Ruby'de bunu yapabilirim:

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

Anladığım kadarıyla, oldukça kolay. Ancak Python dahil etmek gerekir self:

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

Biri benimle bu konuda konuşabilir mi? (Kuşkusuz sınırlı) deneyimime rastladığım bir şey değil.

Eğer kullanımına ihtiyaç nedeni self.Python kullanmaz çünkü @örnek özelliklerine başvurmak için sözdizimi. Python yöntemi edilecek ait olduğu örneğini olacak şekilde yöntemlerini yapmaya karar geçirilen otomatik değil alınan otomatik: yöntemlerinin ilk parametre yöntemi denir örneğidir. Bu, yöntemleri işlevlerle tamamen aynı hale getirir ve gerçek adı size kullanmak için bırakır ( selfkural olmasına rağmen ve insanlar başka bir şey kullandığınızda genellikle size kaşlarını çatacaktır.) Koda selfözel değildir, sadece başka bir nesne .

Python, normal adları özniteliklerden ayırmak için başka bir şey yapabilirdi - Ruby gibi özel sözdizimi veya C ++ ve Java gibi bildirimler veya belki de daha farklı bir şey - ama olmadı. Python, her şeyi açık bir şekilde yapmak, neyin ne olduğunu açıkça ortaya koymak için ve bunu her yerde yapmasa da, örneğin nitelikler için yapıyor. Bu nedenle bir örnek niteliğine atamanın hangi örneğe atanacağını bilmesi gerekir ve bu yüzden buna ihtiyaç duyar self..

Basit bir vektör sınıfı alalım:

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

Uzunluğu hesaplayan bir yöntemimiz olsun istiyoruz. Sınıf içinde tanımlamak istersek nasıl olurdu?

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

Küresel bir yöntem / işlev olarak tanımlayacağımızda neye benzemeli?

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

Böylece tüm yapı aynı kalır. Bunu nasıl kullanabilirim? Bir an lengthiçin Vectorsınıfımız için bir yöntem yazmadığımızı varsayarsak , bunu yapabiliriz:

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

İlk parametresi çünkü bu işler length_globalolarak yeniden kullanılabilir olabilir selfparametre length_new. Açık bir şekilde bu mümkün olmazdı self.

Açık olana olan ihtiyacı anlamanın bir başka yolu da selfPython'un nereye sözdizimsel şeker eklediğini görmektir. Aklınızda bulundurduğunuzda, bu temelde,

v_instance.length()

dahili olarak

Vector.length(v_instance)

Nereye selfuyduğunu görmek kolaydır . Python'da örnek yöntemler yazmazsınız; yazdığınız şey, ilk parametre olarak örneği alması gereken sınıf yöntemleridir. Bu nedenle, example parametresini açıkça bir yere yerleştirmeniz gerekir.

Diyelim ki şu şekilde tanımlanmış ClassAbir yöntem içeren bir sınıfınız var methodA:

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

ve ObjectAbu sınıfın bir örneğidir.

Şimdi ObjectA.methodA(arg1, arg2)çağrıldığında, python dahili olarak sizin için şu şekilde dönüştürür:

ClassA.methodA(ObjectA, arg1, arg2)

selfDeğişken nesnenin kendisine atıfta bulunmaktadır.

Nesneler başlatıldığında, nesnenin kendisi self parametresine geçirilir.

Bu nedenle, nesnenin verileri nesneye bağlıdır. Aşağıda, her bir nesnenin verilerinin nasıl görünebileceğini görselleştirmek isteyebileceğinize bir örnek verilmiştir. 'Kendini' nasıl nesne adıyla değiştirdiğinize dikkat edin. Aşağıdaki bu örnek diyagramın tamamen doğru olduğunu söylemiyorum ama umarım ki kendini kullanmayı görselleştirmede bir amaca hizmet eder.

Nesne self parametresine iletilir, böylece nesne kendi verilerini tutabilir.

Bu tamamen doğru olmasa da, böyle bir nesneyi örnekleme işlemini düşünün: Bir nesne yapıldığında, sınıfı kendi verileri ve yöntemleri için bir şablon olarak kullanır. Kendi adını self parametresine iletmeden, sınıftaki öznitelikler ve yöntemler genel bir şablon olarak kalır ve nesneye atıfta bulunmaz (ona ait değildir). Bu nedenle, nesnenin adını self parametresine iletmek, bir nesneden 100 nesne başlatılırsa, hepsinin kendi verilerini ve yöntemlerini takip edebileceği anlamına gelir.

Aşağıdaki çizime bakın:

Bu örneği beğendim:

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: []

Sınıfları kullanmayan kod ile göstereceğim :

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'

Sınıflar her zaman bu "durum" şeyinden geçmekten kaçınmanın bir yoludur (ve başlatma, sınıf kompozisyonu, nadiren ihtiyaç duyulan metasınıflar ve operatörleri geçersiz kılmak için özel yöntemleri destekleme gibi diğer güzel şeyler).

Şimdi yukarıdaki kodu, temelde aynı şeyi göstermek için yerleşik python sınıfı makinelerini kullanarak gösterelim.

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 )

[cevabımı yinelenen kapalı sorudan taşıdı]

Aşağıdaki alıntılar benlik hakkındaki Python belgelerinden alınmıştır :

Modula-3'te olduğu gibi, nesnenin üyelerini yöntemlerinden referans almak için [Python'da] herhangi bir kısayol yoktur: method işlevi, nesneyi temsil eden ve çağrı tarafından örtük olarak sağlanan açık bir ilk argümanla bildirilir.

Genellikle, bir yöntemin ilk argümanı benlik olarak adlandırılır. Bu bir konvansiyondan başka bir şey değildir: benlik adının Python için kesinlikle özel bir anlamı yoktur. Bununla birlikte, kurallara uyulmadığında, kodunuzun diğer Python programcıları tarafından daha az okunabilir olabileceğini ve ayrıca bu tür bir kurala dayanan bir sınıf tarayıcı programının yazılabileceğini aklınızda bulundurun.

Daha fazla bilgi için, sınıflarla ilgili Python belgeleri eğitimine bakın .

Daha önce belirtilen diğer tüm nedenlerin yanı sıra, geçersiz kılınan yöntemlere daha kolay erişim sağlar; arayabilirsiniz Class.some_method(inst).

Yararlı olduğu yere bir örnek:

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"

Kullanımı thisJava'da anahtar kelime kullanımına benzer , yani mevcut nesneye bir referans vermek.

Python, Java veya C ++ 'dan farklı olarak Nesne Tabanlı Programlama için oluşturulmuş bir dil değildir.

Python'da statik bir yöntem çağrıldığında, içinde düzenli argümanları olan bir yöntem yazılır.

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

Bununla birlikte, bir hayvan olan bir değişken oluşturmanızı gerektiren bir nesne yöntemi, bu durumda, kendi kendine argümana ihtiyaç duyar

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

Self yöntemi, sınıf içindeki değişken bir alanı belirtmek için de kullanılır.

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


    def getAnimalName(self):
        return self.animalName

Bu durumda, benlik tüm sınıfın animalName değişkenine atıfta bulunur. UNUTMAYIN: Bir yöntem içinde bir değişkeniniz varsa, benlik çalışmaz. Bu değişken yalnızca bu yöntem çalışırken mevcuttur. Alanları tanımlamak için (tüm sınıfın değişkenleri), bunları sınıf yöntemlerinin DIŞINDA tanımlamanız gerekir.

Söylediklerimin tek bir kelimesini anlamıyorsanız, Google "Nesneye Yönelik Programlama". Bunu anladıktan sonra, bu soruyu sormanıza bile gerek kalmayacak :).

Python zen'i “açık, örtük olmaktan daha iyidir” izlemek için orada. Gerçekten de sınıf nesnenize bir referans. Örneğin Java ve PHP'de buna denir this.

Eğer user_type_namemodeliniz bir alandır Eğer bunu erişmek self.user_type_name.

Her şeyden önce, benlik geleneksel bir isimdir, yerine başka bir şey (tutarlı olarak) koyabilirsiniz.

Nesnenin kendisine atıfta bulunur, böylece onu kullanırken, .name ve .age öğesinin oluşturacağınız Student nesnelerinin (notu, Student sınıfının değil) olduğunu beyan edersiniz.

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

Kod burada

selfnesnenin kendisine yapılan bir nesne başvurusudur, bu nedenle aynıdır. Python yöntemleri nesnenin kendisi bağlamında çağrılmaz. selfPython özel nesne modelleri veya başka bir şey ile başa çıkmak için kullanılabilir.

Geleneksel olarak adlandırılan argümanın kullanımını selfanlamak zor değil, neden gerekli? Veya neden açık bir şekilde bahsedelim? Sanırım, bu soruyu arayan çoğu kullanıcı için daha büyük bir soru, ya da değilse, python'u öğrenirken kesinlikle aynı soruya sahip olacaklar. Bu iki blogu okumalarını tavsiye ederim:

1: Kendini açıklayan kullanımı

Anahtar kelime olmadığını unutmayın.

İnit de dahil olmak üzere her sınıf yönteminin ilk argümanı her zaman sınıfın geçerli örneğine bir göndermedir. Kural olarak, bu argüman her zaman benlik olarak adlandırılır. İnit yönteminde, benlik yeni yaratılan nesneyi ifade eder; diğer sınıf yöntemlerinde, yöntemi çağrılan örneği ifade eder. Örneğin, aşağıdaki kod yukarıdaki kodla aynıdır.

2: Neden bu şekilde sahibiz ve neden Java gibi bir argüman olarak ortadan kaldıramıyoruz ve bunun yerine bir anahtar kelimemiz var

Eklemek istediğim başka bir şey de, isteğe bağlı bir selfargüman yazmadan bir sınıf içindeki statik yöntemleri bildirmeme izin veriyor self.

Kod örnekleri:

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"

Not : Bu sadece Python 3.x sürümünde çalışır.

Önceki sürümlerde, açıkça @staticmethoddekoratör eklemeniz gerekir , aksi takdirde selfargüman zorunludur.

Kimsenin Lua'yı yetiştirmediğine şaşırdım. Lua 'öz' değişkenini de kullanır, ancak atlanabilir ancak yine de kullanılabilir. C ++ 'this' ile aynı şeyi yapar. Her işlevde 'kendini' bildirmek için herhangi bir neden göremiyorum, ancak yine de lua ve C ++ ile yapabildiğiniz gibi kullanabilmelisiniz. Kısa olmakla övünen bir dil için, kendi değişkenini bildirmeniz gariptir.

Aşağıdaki örneğe bir göz atın; 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 örnekleri arasında ayrım yapmak için kullanılır / gereklidir.

Kaynak: Python'da kendi değişkeni açıklandı - Pythontips

Çünkü python tasarlanırken alternatifler pek işe yaramazdı. Python, yöntemlerin veya işlevlerin, örtük this(a-la Java / C ++) veya açık @(a-la ruby) işlevlerinin çalışmadığı bir bağlamda tanımlanmasına izin verecek şekilde tasarlanmıştır . Python sözleşmeleriyle açık yaklaşıma bir örnek verelim:

def fubar(x):
    self.x = x

class C:
    frob = fubar

Şimdi fubarişlev işe yaramaz çünkü selfküresel bir değişken (ve frobaynı zamanda) olduğunu varsayar . Alternatif, yöntemlerin yerine global bir kapsam ( selfnesnenin nerede olduğu) uygulamaktır.

Örtük yaklaşım,

def fubar(x)
    myX = x

class C:
    frob = fubar

Bu, myXyerel bir değişken olarak fubar(ve içinde frob) yorumlanacağı anlamına gelir . Buradaki alternatif, çağrılar arasında tutulan, ancak yöntem yerel değişkenlerinin olasılığını kaldıracak, değiştirilmiş bir yerel kapsamla yöntemler yürütmek olacaktır.

Ancak mevcut durum iyi sonuç verir:

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

 class C:
     frob = fubar

Bir yöntem olarak burada aradığında frobo yoluyla deniyor nesneyi alacak selfparametre ve fubarhala parametre olarak bir nesne ile çağrılabilir ve (aynı işe olduğu aynı C.frobsanırım).

İn __init__yöntemi, kendini yeni oluşturulan nesne anlamına gelir; diğer sınıf yöntemlerinde, yöntemi çağrılan örneği ifade eder.

bir isim olarak benlik sadece bir kongre , istediğiniz gibi çağırın! : o kullanırken örnek nesneyi silmek için değil, aynı adı kullanmak zorunda __del__(var), varkullanılan__init__(var,[...])

Daha büyük resmecls sahip olmak için de bir göz atmalısınız . Bu yayın yardımcı olabilir.

self, mevcut nesne adı veya sınıf örneği gibi davranıyor.

# 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 kaçınılmazdır.

Sadece örtük veya açık olması gereken bir soru vardıself . Guido van RossumBu soru çözüldü diyerek selfkalmalı .

Peki nerede selfyaşıyor?

İşlevsel programlamaya sadık kalırsak ihtiyacımız olmazdı self. Biz girdikten sonra Python OOP bulduğumuzself orada .

İşte class Cyöntem ile tipik kullanım durumum1

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

Bu programın çıktıları:

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

Böylece selfsınıf örneğinin bellek adresini tutar. Amacı , örneğin yöntemlerself için referansı tutmak ve bizim için bu referansa açık erişime sahip olmaktır.

_{Üç farklı sınıf yöntemi türü olduğuna dikkat edin:}

• _{statik yöntemler (okuma: fonksiyonlar),}
• _{sınıf yöntemleri,}
• _{örnek yöntemler (bahsedilen).}

dan docs ,

yöntemlerle ilgili özel şey, örnek nesnenin işlevin ilk argümanı olarak iletilmesidir. Örneğimizde, çağrı x.f()tam olarak eşdeğerdir MyClass.f(x). Genel olarak, n argüman listesiyle bir yöntemin çağrılması, karşılık gelen işlevin, yöntemin örnek nesnesini ilk argümandan önce ekleyerek oluşturulan bir argüman listesiyle çağrılmasına eşdeğerdir.

bundan önce ilgili pasaj,

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

    def f(self):
        return 'hello world'

x = MyClass()

sınıf örneği nesnesine açık bir başvurudır.