Python의 self 매개변수는 무엇입니까?

이미 알고 있는 것부터 시작해 보겠습니다. self - 메서드의 첫 번째 매개 변수 - 클래스 인스턴스를 참조합니다.

class MyClass:
┌─────────────────┐
▼ │
def do_stuff(self, some_arg): │
print(some_arg)▲│
 ││
 ││
 ││
 ││
instance = MyClass() ││
instance.do_stuff("whatever") │
│ │
└───────────────────────────────┘

또한 이 인수는 실제로 self라고 불릴 필요는 없습니다. 계약. 예를 들어, 다른 언어에서 일반적으로 사용되는 것처럼 사용할 수 있습니다.

위 코드는 이미 사용해봤기 때문에 자연스럽고 당연할 수 있지만 .do_stuff()에 하나의 매개변수(some_arg)만 주었는데 메소드에서 두 개(self 및, some_arg)를 선언했는데 역시 '하지 않는다'라고 말하는 것 같습니다. 말이 안 돼요. 코드 조각의 화살표는 self가 인스턴스로 변환된다는 것을 보여 주지만 실제로는 어떻게 전달됩니까?

instance = MyClass()
MyClass.do_stuff(instance, "whatever")

Python이 내부적으로 수행하는 작업은 instance.do_stuff("whatever")를 MyClass.do_stuff(instance, "whatever")로 변환하는 것입니다. 여기서는 이를 "파이썬의 마법"이라고 부를 수 있지만, 뒤에서 무슨 일이 일어나고 있는지 실제로 이해하려면 파이썬 메서드가 무엇인지, 함수와 어떻게 관련되는지 이해해야 합니다.

클래스 속성/메서드

Python에는 "메서드" 객체라는 것이 없습니다. 사실 메쏘드는 그냥 일반 함수입니다. 함수와 메서드의 차이점은 메서드는 클래스의 네임스페이스에 정의되어 해당 클래스의 속성이 된다는 점입니다.

이러한 속성은 클래스 사전 __dict__에 저장되어 있으며 직접 액세스하거나 vars 내장 함수를 사용하여 액세스할 수 있습니다.

MyClass.__dict__["do_stuff"]
# <function MyClass.do_stuff at 0x7f132b73d550>
vars(MyClass)["do_stuff"]
# <function MyClass.do_stuff at 0x7f132b73d550>

이러한 속성에 액세스하는 가장 일반적인 방법은 "클래스 메서드" 방식입니다.

print(MyClass.do_stuff)
# <function MyClass.do_stuff at 0x7f132b73d550>

여기서 클래스 속성을 사용하여 함수에 액세스하면 do_stuff가 MyClass의 함수라는 예상대로 인쇄됩니다. 그러나 인스턴스 속성을 사용하여 액세스할 수도 있습니다.

print(instance.do_stuff)
# <bound method MyClass.do_stuff of <__main__.MyClass object at 0x7ff80c78de50>

하지만 이 경우 원래 함수 대신 "바운드 메서드"를 얻습니다. 여기서 Python이 하는 일은 클래스 속성을 인스턴스에 바인딩하여 "바인딩 메서드"라는 것을 생성하는 것입니다. 이 "바운드 메서드"는 이미 인스턴스를 첫 번째 인수(self)로 삽입하는 기본 함수를 둘러싼 래퍼입니다.

따라서 메소드는 다른 매개변수에 클래스 인스턴스(self)가 추가된 일반 함수입니다.

이러한 상황이 어떻게 발생하는지 이해하려면 설명자 프로토콜을 살펴봐야 합니다.

설명자 프로토콜

설명자는 메서드 뒤에 있는 메커니즘으로, __get__(), __set__() 또는 __delete__() 메서드를 정의하는 객체(클래스)입니다. self가 어떻게 작동하는지 이해하기 위해 서명이 있는 __get__()을 고려해 보겠습니다.

descr.__get__(self, instance, type=None) -> value

그러나 __get__() 메서드는 실제로 무엇을 합니까? 이를 통해 클래스의 속성 조회를 사용자 정의할 수 있습니다. 즉, 점 표기법을 사용하여 클래스 속성에 액세스할 때 발생하는 일을 사용자 정의할 수 있습니다. 이는 메소드가 실제로는 클래스의 속성일 뿐이라는 점을 고려하면 매우 유용합니다. 이는 __get__ 메서드를 사용하여 클래스의 "바운드 메서드"를 생성할 수 있음을 의미합니다.

이해를 더 쉽게 하기 위해 설명자를 사용하여 "메서드"를 구현하여 이를 보여드리겠습니다. 먼저 함수 객체의 순수 Python 구현을 만듭니다.

import types
class Function:
def __get__(self, instance, objtype=None):
if instance is None:
return self
return types.MethodType(self, instance)
def __call__(self):
return

위의 Function 클래스는 설명자로 만드는 __get__ 을 구현합니다. 이 특수 메소드는 인스턴스 매개변수에서 클래스 인스턴스를 받습니다. 이 매개변수가 None이면 __get__ 메소드가 클래스(예: MyClass.do_stuff)에서 직접 호출되었음을 알기 때문에 그냥 self를 반환합니다. 그러나 인스턴스.do_stuff와 같은 클래스 인스턴스에서 호출되면 "바인딩된 메서드"를 수동으로 생성하는 방법인 type.MethodType을 반환합니다.

이 외에도 __call__ 특수 메서드도 제공합니다. __init__은 인스턴스를 초기화하기 위해 클래스가 호출될 때(예: 인스턴스 = MyClass()) 호출되는 반면, __call__은 인스턴스가 호출될 때(예: 인스턴스()) 호출됩니다. type.MethodType(self, 인스턴스)의 self가 호출 가능해야 하기 때문에 이를 사용해야 합니다.

이제 자체 함수 구현이 있으므로 이를 사용하여 메서드를 클래스에 바인딩할 수 있습니다.

class MyClass:
do_stuff = Function()
print(MyClass.__dict__["do_stuff"])# __get__ not invoked
# <__main__.Function object at 0x7f229b046e50>
print(MyClass.do_stuff)# __get__ invoked, but "instance" is None, "self" is returned
print(MyClass.do_stuff.__get__(None, MyClass))
# <__main__.Function object at 0x7f229b046e50>
instance = MyClass()
print(instance.do_stuff)#__get__ invoked and "instance" is not None, "MethodType" is returned
print(instance.do_stuff.__get__(instance, MyClass))
# <bound method ? of <__main__.MyClass object at 0x7fd526a33d30>

MyClass에 Function 유형의 do_stuff 속성을 제공하여 클래스 things의 네임스페이스에서 Python의 메서드 정의를 대략적으로 시뮬레이션합니다. 당시에 했습니다.

요약하면, instance.do_stuff 등의 속성에 접근하면 인스턴스의 속성 사전(__dict__)에서 do_stuff를 검색하게 됩니다. do_stuff가 __get__ 메소드를 정의하면 do_stuff.__get__이 호출되어 궁극적으로 다음을 호출합니다.

# For class invocation:
print(MyClass.__dict__['do_stuff'].__get__(None, MyClass))
# <__main__.Function object at 0x7f229b046e50>
# For instance invocation:
print(MyClass.__dict__['do_stuff'].__get__(instance, MyClass))
# Alternatively:
print(type(instance).__dict__['do_stuff'].__get__(instance, type(instance)))
# <bound method ? of <__main__.MyClass object at 0x7fd526a33d30>

우리가 지금 알고 있듯이 - 바인딩된 메소드가 반환됩니다. 즉, 인수 self가 앞에 오는 원래 함수 주변의 호출 가능한 래퍼입니다!

더 자세히 살펴보고 싶다면 정적 메서드와 클래스 메서드를 비슷하게 구현할 수 있습니다(https://docs.python.org/3.7/howto/descriptor.html#static-methods-and-class-methods)

이유 메소드 정의에서 자체?

이제 어떻게 작동하는지 알지만 더 철학적인 질문이 있습니다. "왜 메소드 정의에 있어야 할까요?"

명시적인 self 메소드 매개변수는 논란의 여지가 있는 디자인 선택이지만 A 선택입니다. 그것은 단순성을 선호합니다.

Python은 "나쁠수록 좋다"라는 디자인 철학을 자체적으로 구현합니다. 여기에 설명되어 있습니다. 이 디자인 철학의 우선 순위는 다음과 같이 정의되는 "단순성"입니다.

디자인은 구현 및 인터페이스를 포함하여 단순해야 합니다. 인터페이스보다 구현이 단순하다는 것이 더 중요합니다...

이것이 바로 self의 경우입니다. 즉, 메소드 서명이 호출과 일치하지 않는 인터페이스를 희생하여 간단한 구현을 하는 것입니다.

물론 self를 명시적으로 작성해야 하는 이유나 보존해야 하는 이유가 더 많이 있습니다. 그 중 일부는 Guido van Rossum의 블로그 게시물(http://neopythonic.blogspot.com/2008/10/)에 설명되어 있습니다. Why-explicit-self-has-to-stay.html), 기사가 삭제 요청에 응답했습니다.

Python은 많은 복잡성을 추상화하지만 제 생각에는 낮은 수준의 세부 사항과 복잡성을 파헤치는 것은 언어 작동 방식을 더 잘 이해하고 문제가 발생할 때 고급 문제 해결/디버깅을 수행하는 데 매우 유용하지 않습니다.

또한 설명자를 이해하는 것은 몇 가지 사용 사례가 있기 때문에 실제로 매우 실용적일 수 있습니다. 대부분의 경우 실제로는 @property 설명자만 필요하지만 SLQAlchemy 또는 사용자 정의 유효성 검사기와 같은 사용자 정의 설명자가 적합한 경우도 있습니다.

위 내용은 Python의 self 매개변수는 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!