'자기'라는 단어의 목적은 무엇입니까?

self파이썬 에서 단어 의 목적은 무엇입니까 ? 나는 그것이 그 클래스에서 생성 된 특정 객체를 참조한다는 것을 이해하지만, 왜 그것이 모든 함수에 매개 변수로 명시 적으로 추가되어야하는지 알 수 없습니다. 예를 들어, Ruby에서는 다음과 같이 할 수 있습니다.

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

아주 쉽게 이해할 수 있습니다. 그러나 파이썬에서는 self다음 을 포함해야합니다 .

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

누구든지 이것을 통해 나에게 이야기 할 수 있습니까? 내가 경험 한 바에 따르면 내가 경험 한 것은 아니다.

self.파이썬이 @구문을 사용하여 인스턴스 속성을 참조 하지 않기 때문에 사용해야하는 이유 입니다. 파이썬은 메소드가 속한 인스턴스가 자동으로 전달 되지만 자동으로 수신 되지 않는 방식으로 메소드를 수행하기로 결정했습니다. 메소드 의 첫 번째 매개 변수는 메소드가 호출되는 인스턴스입니다. 그것은 메소드를 함수와 완전히 동일하게 만들고 실제 이름을 당신이 사용할 수 있도록 남겨 둡니다 ( self관습은 있지만 사람들이 일반적으로 다른 것을 사용할 때 당신을 찌푸리게 할 것입니다). self코드에 특별하지는 않습니다 . .

파이썬은 일반 이름과 속성 (Ruby와 같은 특수 구문, C ++ 및 Java와 같은 선언이 필요하거나 더 다른 것)을 구별하기 위해 다른 것을 할 수 있었지만 그렇지 않았습니다. 파이썬은 모든 것을 명시 적으로 만들고, 무엇이 무엇인지를 분명하게하며, 모든 곳에서 그것을하지는 않지만 인스턴스 속성을 위해 수행합니다. 그렇기 때문에 인스턴스 속성에 할당 할 인스턴스를 할당해야하는 이유가 필요합니다 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맞는지 쉽게 알 수 있습니다 . 실제로 파이썬에서 인스턴스 메소드를 작성하지는 않습니다. 작성하는 것은 첫 번째 매개 변수로 인스턴스를 가져와야하는 클래스 메서드입니다. 따라서 인스턴스 매개 변수를 명시 적 어딘가에 배치해야합니다.

다음 과 같이 정의 된 ClassA메소드를 포함하는 클래스가 있다고 가정하십시오 methodA.

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

그리고 ObjectA이 클래스의 인스턴스입니다.

이제 ObjectA.methodA(arg1, arg2)호출되면 파이썬은 내부적으로 다음과 같이 변환합니다.

ClassA.methodA(ObjectA, arg1, arg2)

self변수 객체 자체를 의미한다.

객체가 인스턴스화되면 객체 자체가 자체 매개 변수로 전달됩니다.

이로 인해 객체의 데이터가 객체에 바인딩됩니다. 아래는 각 객체의 데이터가 어떻게 보이는지 시각화하는 방법의 예입니다. 'self'가 어떻게 객체 이름으로 대체되는지 확인하십시오. 아래 예제 다이어그램이 완전히 정확하다고 말하지는 않지만 자아 사용을 시각화하는 목적으로 사용되기를 바랍니다.

오브젝트는 자체 매개 변수로 전달되므로 오브젝트가 자체 데이터를 보유 할 수 있습니다.

이것이 완전히 정확하지는 않지만 다음과 같이 객체를 인스턴스화하는 프로세스를 생각해보십시오. 객체가 만들어 질 때 클래스는 자체 데이터 및 메소드의 템플리트로 클래스를 사용합니다. 자체 매개 변수에 자체 이름을 전달하지 않으면 클래스의 속성과 메서드는 일반 템플릿으로 유지되며 객체와 관련하여 참조되지 않습니다. 따라서 객체 이름을 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 )

[중복 된 질문에서 답변을 마이그레이션했습니다]

다음 발췌는 self에 대한 Python 문서 에서 발췌 한 것입니다 .

Modula-3에서와 같이, 메소드에서 객체의 멤버를 참조하기위한 [Python에서는] 속기가 없습니다. 메소드 함수는 객체를 나타내는 명시적인 첫 번째 인수로 선언되며, 이는 호출에 의해 암시 적으로 제공됩니다.

종종 메소드의 첫 번째 인수를 self라고합니다. 이것은 규칙에 지나지 않습니다. self라는 이름은 파이썬에 특별한 의미가 없습니다. 그러나 규칙을 따르지 않으면 코드를 다른 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"

그 사용은 thisJava에서 키워드를 사용하는 것과 유사합니다. 즉, 현재 객체에 대한 참조를 제공합니다.

파이썬은 자바 나 C ++과 달리 객체 지향 프로그래밍을 위해 만들어진 언어가 아닙니다.

파이썬에서 정적 메소드를 호출 할 때, 내부에 규칙적인 인수를 가진 메소드를 작성합니다.

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"

self 메소드는 클래스 내 변수 필드를 참조하는 데에도 사용됩니다.

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


    def getAnimalName(self):
        return self.animalName

이 경우 self는 전체 클래스의 animalName 변수를 참조합니다. 기억하십시오 : 메소드 내에 변수가 있으면 self가 작동하지 않습니다. 해당 변수는 해당 메소드가 실행되는 동안에 만 존재합니다. 필드 (전체 클래스의 변수)를 정의하려면 클래스 메소드 외부에서 필드를 정의해야합니다.

내가 말하고있는 한 마디를 이해하지 못하면 Google "객체 지향 프로그래밍" 일단 이것을 이해하면 그 질문을 할 필요조차 없습니다 :).

파이썬 선을 따르는 것은 "명시적인 것이 암시적인 것보다 낫습니다". 실제로 클래스 객체에 대한 참조입니다. 예를 들어 Java와 PHP에서는이라고 this합니다.

user_type_name모델의 필드 인 경우 으로 액세스합니다 self.user_type_name.

우선, self는 관습적인 이름이므로, 다른 것 (일관성있는)을 대신 사용할 수 있습니다.

객체 자체를 참조하므로 사용하는 경우 .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는 객체 자체에 대한 객체 참조이므로 동일합니다. 파이썬 메서드는 객체 자체의 컨텍스트에서 호출되지 않습니다. self파이썬에서는 커스텀 객체 모델이나 무언가를 처리하는 데 사용될 수 있습니다.

일반적으로 불린 논증의 사용 self 이 은 왜 그렇게 필요한지 이해하기 어렵지 않습니까? 또는 왜 명시 적으로 언급합니까? 그것은이 질문을 찾는 대부분의 사용자에게 더 큰 질문이라고 생각합니다. 그렇지 않은 경우 파이썬 학습을 진행할 때 반드시 같은 질문이있을 것입니다. 다음 두 블로그를 읽는 것이 좋습니다.

1 : 자기 설명의 사용

키워드가 아닙니다.

init를 포함한 모든 클래스 메소드의 첫 번째 인수는 항상 클래스의 현재 인스턴스에 대한 참조입니다. 일반적으로이 인수는 항상 self로 명명됩니다. init 메소드에서 self는 새로 작성된 오브젝트를 나타냅니다. 다른 클래스 메서드에서는 메서드가 호출 된 인스턴스를 나타냅니다. 예를 들어 아래 코드는 위 코드와 동일합니다.

2 : 왜 우리는 이런 식으로 그것을 가지고 있고 왜 우리는 그것을 Java와 같은 인수로 제거 할 수없고 대신 키워드를 가질 수 없습니다

내가 추가하고 싶은 또 다른 것은 선택적 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"

추신 : 이것은 Python 3.x에서만 작동합니다.

이전 버전에서는 @staticmethod데코레이터 를 명시 적으로 추가해야합니다 self. 그렇지 않으면 인수가 필수입니다.

루아를 키운 사람이 아무도 없습니다. 루아는 또한 '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 인스턴스를 구별하는 데 사용 / 필요합니다.

출처 : 파이썬의 자체 변수 설명-Pythontips

파이썬이 설계된 방식으로 대안이 거의 작동하지 않기 때문입니다. Python은 암시 적 this(a-la Java / C ++) 또는 명시 적 @(a-la ruby)이 작동하지 않는 컨텍스트에서 메소드 또는 함수를 정의 할 수 있도록 설계되었습니다 . 파이썬 규칙을 사용한 명시 적 접근 방식을 예로 들어 보겠습니다.

def fubar(x):
    self.x = x

class C:
    frob = fubar

이제는 전역 변수 fubar라고 가정하기 때문에 함수가 작동하지 않습니다 . 대안은 전역 범위를 대체하여 메소드를 실행하는 것입니다 (여기서selffrobself 객체가있는 ) 입니다.

암시 적 접근 방식은

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__ 방법에서 self는 새로 작성된 오브젝트를 나타냅니다. 다른 클래스 메서드에서는 메서드가 호출 된 인스턴스를 나타냅니다.

이름으로 self 는 컨벤션 일뿐입니다. 원하는대로 부르십시오! 그러나 객체를 삭제하는 등의 경우에는 동일한 이름을 사용해야합니다 __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입니다. 우리가 입력되면 파이썬 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에 대한 참조 유지하는 것입니다 인스턴스 메소드를 우리가 가지고과 명시 적으로 해당 참조에 액세스 할 수 있습니다.

_{세 가지 유형의 클래스 메소드가 있습니다.}

• _{정적 메소드 (읽기 : 함수)}
• _{수업 방법,}
• _{인스턴스 메소드 (언급).}

로부터 문서 ,

메소드에 대한 특별한 점은 인스턴스 오브젝트가 함수의 첫 번째 인수로 전달된다는 것입니다. 이 예에서 호출 x.f()은와 정확히 동일합니다 MyClass.f(x). 일반적으로 n 개의 인수 목록으로 메소드를 호출하는 것은 첫 번째 인수 앞에 메소드의 인스턴스 오브젝트를 삽입하여 작성된 인수 목록으로 해당 함수를 호출하는 것과 같습니다.

이에 앞서 관련 스 니펫,

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

    def f(self):
        return 'hello world'

x = MyClass()

클래스 인스턴스 객체에 대한 명시 적 참조입니다.