「自己」という言葉の目的は何ですか？

selfPython の単語の目的は何ですか？そのクラスから作成された特定のオブジェクトを参照していることは理解していますが、すべての関数にパラメーターとして明示的に追加する必要がある理由がわかりません。説明のために、Rubyでこれを行うことができます。

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

私にはわかります。ただし、Pythonでは以下を含める必要がありますself。

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

誰もがこれを通して私を話すことができますか？それは私の（確かに限られた）経験で遭遇したものではありません。

使用する必要がある理由self.は、Pythonが@インスタンス属性を参照する構文を使用しないためです。Pythonは、メソッドが属するインスタンスが自動的に渡されるが、自動的に受け取られないようにメソッドを実行することを決定しました。メソッドの最初のパラメーターは、メソッドが呼び出されるインスタンスです。これにより、メソッドは関数と完全に同じになり、実際の名前は自由に使用できるようになります（self慣例ですが、一般に、他のものを使用すると人々はあなたを怒ります）selfはコードに特別なものではなく、単なる別のオブジェクトです。 。

Pythonは、通常の名前を属性から区別するために別のことを行った可能性があります-Rubyのような特別な構文、C ++やJavaのような宣言を要求すること、あるいはおそらくさらに異なる何か-しかし、実際はそうではありませんでした。Pythonは、物事を明確にし、何が何であるかを明確にするためのものであり、すべての場所で完全に実行されるわけではありませんが、インスタンス属性に対して実行されます。そのため、インスタンス属性に割り当てるには、どのインスタンスに割り当てるかを知る必要があり、それが必要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です。

明示的な必要性を理解するもう1つの方法はself、Pythonが構文上の砂糖を追加する場所を確認することです。あなたが心に留めておくと、それは基本的に、

v_instance.length()

内部的に変換されます

Vector.length(v_instance)

どこにself収まるかは簡単に確認できます。実際には、Pythonでインスタンスメソッドを作成するわけではありません。あなたが書くのは、最初のパラメータとしてインスタンスをとらなければならないクラスメソッドです。したがって、インスタンスパラメータを明示的にどこかに配置する必要があります。

次のように定義されClassAたメソッドを含むクラスがあるとしますmethodA。

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

そしてObjectA、このクラスのインスタンスです。

今ときObjectA.methodA(arg1, arg2)に呼び出され、Pythonは内部的にあなたのためにそれを変換します。

ClassA.methodA(ObjectA, arg1, arg2)

self変数は、オブジェクト自体を指します。

オブジェクトがインスタンス化されると、オブジェクト自体がselfパラメータに渡されます。

このため、オブジェクトのデータはオブジェクトにバインドされます。以下は、各オブジェクトのデータがどのように見えるかを視覚化する方法の例です。「self」がオブジェクト名に置き換えられていることに注意してください。以下のこの図の例が完全に正確であるとは言っていませんが、うまくいけば、自己の使用を視覚化することを目的としています。

オブジェクトが自身のデータを保持できるように、オブジェクトはselfパラメータに渡されます。

これは完全に正確ではないかもしれませんが、次のようにオブジェクトをインスタンス化するプロセスを考えてください。オブジェクトが作成されると、オブジェクトは独自のデータとメソッドのテンプレートとしてクラスを使用します。自身の名前をselfパラメータに渡さないと、クラスの属性とメソッドは一般的なテンプレートとして残り、オブジェクトに（所属する）参照されません。したがって、オブジェクトの名前をselfパラメータに渡すことは、1つのクラスから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'

クラスは、この「状態」を常に渡すことを回避するための方法にすぎません（および初期化、クラス構成、まれに必要になるメタクラス、および演算子をオーバーライドするカスタムメソッドのサポートなどのその他の優れた点）。

次に、組み込みのPythonクラスの機構を使用して上記のコードを示し、基本的に同じことを示します。

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 )

[重複した閉じた質問から私の回答を移行しました]

次の抜粋は、selfに関するPythonのドキュメントからの抜粋です。

Modula-3のように、メソッドからオブジェクトのメンバーを参照するための省略形はありません（メソッドの関数はオブジェクトを表す明示的な最初の引数で宣言され、呼び出しによって暗黙的に提供されます）。

メソッドの最初の引数はしばしば自分自身と呼ばれます。これは単なる慣例に過ぎません。名前selfはPythonにとってまったく特別な意味を持ちません。ただし、この規則に従わないと、コードが他のPythonプログラマにとって読みにくくなる可能性があります。また、そのような規則に依存するクラスブラウザプログラムが作成されることも考えられます。

詳細については、Pythonドキュメントのクラスに関するチュートリアルをご覧ください。

既に述べた他のすべての理由と同様に、オーバーライドされたメソッドに簡単にアクセスできます。あなたが呼び出すことができます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、Java でのキーワードの使用法に似ています。つまり、現在のオブジェクトへの参照を提供します。

Pythonは、JavaやC ++とは異なり、オブジェクト指向プログラミング用に構築された言語ではありません。

Pythonで静的メソッドを呼び出すときは、内部に通常の引数を持つメソッドを記述するだけです。

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

ただし、この場合、Animalである変数を作成する必要があるオブジェクトメソッドには、自己引数が必要です。

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

selfメソッドは、クラス内の変数フィールドを参照するためにも使用されます。

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


    def getAnimalName(self):
        return self.animalName

この場合、selfはクラス全体のanimalName変数を参照しています。注意：メソッド内に変数がある場合、selfは機能しません。その変数は、そのメソッドの実行中にのみ存在します。フィールド（クラス全体の変数）を定義するには、クラスメソッドの外でフィールドを定義する必要があります。

私が言っていることの1つの単語を理解していない場合は、Googleの「オブジェクト指向プログラミング」です。これを理解すれば、その質問をする必要さえありません:)。

Python zenの「明示的なものは暗黙的なものよりも優れている」に続くものです。それは確かにあなたのクラスオブジェクトへの参照です。たとえば、JavaとPHPではと呼ばれthisます。

user_type_nameがモデルのフィールドである場合は、によってアクセスしますself.user_type_name。

まず第一に、自己は慣習的な名前です。代わりに（一貫性のある）他のものを置くことができます。

これはオブジェクト自体を参照しているので、それを使用するときは、.nameと.ageが、作成するStudentオブジェクト（Studentクラスではない）のプロパティであることを宣言しています。

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オブジェクト自体へのオブジェクト参照であるため、同じです。Pythonメソッドは、オブジェクト自体のコンテキストでは呼び出されません。 selfPythonでは、カスタムオブジェクトモデルなどを処理するために使用できます。

慣習的に呼ばれている議論の使用 selfなぜそれが必要であるのと同様に、理解するのが難しくありませんか？またはなぜそれを明示的に言及するのか？それは、この質問を検索するほとんどのユーザーにとってより大きな質問だと思います。そうでない場合は、Pythonの学習を進めるにつれて、同じ質問をすることになります。これらのブログをいくつか読むことをお勧めします。

1：自己説明の使用

これはキーワードではないことに注意してください。

initを含むすべてのクラスメソッドの最初の引数は、常にクラスの現在のインスタンスへの参照です。慣例により、この引数は常にselfという名前になります。initメソッドでは、selfは新しく作成されたオブジェクトを参照します。他のクラスメソッドでは、メソッドが呼び出されたインスタンスを参照します。たとえば、以下のコードは上記のコードと同じです。

2：なぜこのようにして、なぜJavaのようにそれを引数として排除できず、代わりにキーワードを持つことができるのですか？

追加したいもう1つのことは、オプションの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：これはPython 3.xでのみ機能します。

以前のバージョンでは、明示的に@staticmethodデコレータを追加する必要がありますself。そうでない場合、引数は必須です。

誰もLuaを育てていないことに驚いています。Luaは 'self'変数も使用しますが、省略可能ですが引き続き使用されます。C ++は 'this'と同じことを行います。各関数で 'self'を宣言する必要がある理由はわかりませんが、luaや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 インスタンスを区別するために使用/必要です。

ソース：Pythonの自己変数の説明-Pythontips

なぜなら、Pythonが設計されているため、代替手段はほとんど機能しないからです。Pythonは、暗黙的this（a-la Java / C ++）または明示的@（a-la ruby​​）の両方が機能しないコンテキストでメソッドまたは関数を定義できるように設計されています。Pythonの規則を使用した明示的なアプローチの例を見てみましょう。

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は、現在のオブジェクト名またはクラスのインスタンスのように機能しています。

# 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。私たちが入るとPythonのOOPを我々は見つけます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のための参照を保持することですインスタンスメソッドを私たちは持っていると明示的なその参照へのアクセスを。

_{クラスメソッドには3つの異なるタイプがあることに注意してください。}

• _{静的メソッド（読み取り：関数）、}
• _{クラスメソッド、}
• _{インスタンスメソッド（言及）。}

ドキュメントから、

メソッドの特別な点は、インスタンスオブジェクトが関数の最初の引数として渡されることです。この例では、呼び出しx.f()はとまったく同じMyClass.f(x)です。一般に、n個の引数のリストを使用してメソッドを呼び出すことは、最初の引数の前にメソッドのインスタンスオブジェクトを挿入することによって作成された引数リストを使用して、対応する関数を呼び出すことと同じです。

これに先行する関連スニペット、

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

    def f(self):
        return 'hello world'

x = MyClass()

これは、クラスインスタンスオブジェクトへの明示的な参照です。