파이썬에서 명시적인 '자아'를 피하는 법?

나는 파이 게임 튜토리얼을 따라 파이썬을 배웠다.

거기에서 나는 키워드 self의 광범위한 사용을 발견했고, 주로 자바 배경에서 왔고, 나는 자기를 타이핑하는 것을 잊고있다. 예를 들어 self.rect.centerx 대신 rect.centerx를 입력합니다. 왜냐하면 나에게 rect는 이미 클래스의 멤버 변수이기 때문입니다.

이 상황을 생각할 수있는 Java 병렬은 멤버 변수에 대한 모든 참조 앞에 이걸 붙여야합니다.

모든 멤버 변수에 접두어를 붙여야합니까? 아니면 그렇게하지 않아도되도록 선언 할 수있는 방법이 있습니까?

비록 내가 제안하고있는 것이 pythonic이 아니더라도, 나는 그것이 가능한지 아직도 알고 싶다.

나는 이와 관련된 SO 질문을 살펴 봤지만, 나는 그들이 내가 한 것에 대해 대답하지 않는다 :

해결법

==============================
1.파이썬은 self를 지정해야합니다. 결과적으로 전체 클래스 정의가 보이지 않더라도 회원이 무엇이고 그렇지 않은 것은 혼동하지 않습니다. 이것은 예를 들어 회원이 아닌 멤버를 우연히 추가하여 코드를 중단시키는 등의 유용한 속성을 유도합니다.

파이썬은 self를 지정해야합니다. 결과적으로 전체 클래스 정의가 보이지 않더라도 회원이 무엇이고 그렇지 않은 것은 혼동하지 않습니다. 이것은 예를 들어 회원이 아닌 멤버를 우연히 추가하여 코드를 중단시키는 등의 유용한 속성을 유도합니다.

하나의 극단적 인 예 : 어떤 기본 클래스가 있는지에 대한 지식이 없어도 클래스를 작성할 수 있으며 멤버에 액세스하는지 여부를 항상 알 수 있습니다.
```
class A(some_function()):
  def f(self):
    self.member = 42
    self.method()
```
그것은 완전한 코드입니다! (some_function은 기본으로 사용 된 유형을 반환합니다.)

클래스의 메소드가 동적으로 구성되는 또 다른 메소드는 다음과 같습니다.
```
class B(object):
  pass

print B()
# <__main__.B object at 0xb7e4082c>

def B_init(self):
  self.answer = 42
def B_str(self):
  return "<The answer is %s.>" % self.answer
# notice these functions require no knowledge of the actual class
# how hard are they to read and realize that "members" are used?

B.__init__ = B_init
B.__str__ = B_str

print B()
# <The answer is 42.>
```
이 두 예는 모두 극단적이므로 매일 보지 않을 것이며, 이와 같은 코드를 자주 써야한다고 제안하지는 않지만 명시 적으로 요구되는 자아 측면을 분명히 보여줍니다.
==============================
2.실제로 self는 키워드가 아니며, Python의 인스턴스 메소드의 첫 번째 매개 변수에 일반적으로 제공되는 이름입니다. 그리고 첫 번째 매개 변수는 건너 뛸 수 없습니다. 메서드가 호출되는 클래스의 인스턴스를 알 수있는 유일한 메커니즘이기 때문입니다.

실제로 self는 키워드가 아니며, Python의 인스턴스 메소드의 첫 번째 매개 변수에 일반적으로 제공되는 이름입니다. 그리고 첫 번째 매개 변수는 건너 뛸 수 없습니다. 메서드가 호출되는 클래스의 인스턴스를 알 수있는 유일한 메커니즘이기 때문입니다.
==============================
3.원하는 이름을 사용할 수 있습니다 (예 :

원하는 이름을 사용할 수 있습니다 (예 :
```
class test(object):
    def function(this, variable):
        this.variable = variable
```
또는
```
class test(object):
    def function(s, variable):
        s.variable = variable
```
그러나 당신은 범위에 대한 이름을 사용하는 것으로 붙어 있습니다.

경험있는 pythonistas에게는 외계인이 될 수 있기 때문에 설득력있는 이유가없는 한 스스로 다른 것을 사용하는 것은 좋지 않습니다.
==============================
4.명시 적으로 암시 적보다 낫기 때문에 그렇습니다. 항상 파이썬 철학에 따르면 자아를 지정해야합니다.

명시 적으로 암시 적보다 낫기 때문에 그렇습니다. 항상 파이썬 철학에 따르면 자아를 지정해야합니다.

또한 파이썬에서 프로그래밍하는 방식이 자바에서 프로그래밍하는 방식과 매우 다르다는 것을 알 수 있습니다. 따라서 객체 내부의 모든 것을 투영하지 않으므로 자체 사용이 줄어들 기 쉽습니다. 오히려 더 잘 테스트 할 수있는 모듈 수준의 함수를 많이 사용합니다.

그건 그렇고. 나는 처음에는 그것을 싫어했다, 지금 나는 그 반대가 싫다. 들여 쓰기 구동 흐름 제어에도 동일합니다.
==============================
5.self는 객체의 멤버에 액세스하는 파이썬 구문의 일부입니다. 그래서 여러분은 그것에 매몰되어 있습니다.

self는 객체의 멤버에 액세스하는 파이썬 구문의 일부입니다. 그래서 여러분은 그것에 매몰되어 있습니다.
==============================
6."self"는 클래스의 현재 객체 인스턴스의 일반적인 자리 표시 자입니다. 이 클래스는 "자체"를 참조하는 것처럼 클래스의 객체 속성이나 필드 또는 메서드를 참조하려는 경우에 사용됩니다. 그러나 파이썬 프로그래밍 영역에서 누군가를 더 짧게 만들려면 "자기"를 사용하기 시작하고 다른 영역에서는 "this"를 사용하지만 대체 할 수없는 키워드로 만듭니다. 나는 코드 가독성을 높이기 위해 "its"를 사용했다. Python의 좋은 점 중 하나 인 "self"이외의 객체 인스턴스에 대한 자신 만의 자리 표시자를 자유롭게 선택할 수 있습니다. 자체에 대한 예 :

"self"는 클래스의 현재 객체 인스턴스의 일반적인 자리 표시 자입니다. 이 클래스는 "자체"를 참조하는 것처럼 클래스의 객체 속성이나 필드 또는 메서드를 참조하려는 경우에 사용됩니다. 그러나 파이썬 프로그래밍 영역에서 누군가를 더 짧게 만들려면 "자기"를 사용하기 시작하고 다른 영역에서는 "this"를 사용하지만 대체 할 수없는 키워드로 만듭니다. 나는 코드 가독성을 높이기 위해 "its"를 사용했다. Python의 좋은 점 중 하나 인 "self"이외의 객체 인스턴스에 대한 자신 만의 자리 표시자를 자유롭게 선택할 수 있습니다. 자체에 대한 예 :
```
class UserAccount():    
    def __init__(self, user_type, username, password):
        self.user_type = user_type
        self.username = username            
        self.password = encrypt(password)        

    def get_password(self):
        return decrypt(self.password)

    def set_password(self, password):
        self.password = encrypt(password)
```
이제 우리는 '자아'를 '그'로 대체합니다.
```
class UserAccount():    
    def __init__(its, user_type, username, password):
        its.user_type = user_type
        its.username = username            
        its.password = encrypt(password)        

    def get_password(its):
        return decrypt(its.password)

    def set_password(its, password):
        its.password = encrypt(password)
```
어느 쪽이 더 읽기 쉬울까요?
==============================
7.이전 답변은 기본적으로 "할 수 없다"또는 "하지 말아야한다"의 변형입니다. 후자의 정서에 동의하는 동안, 문제는 기술적으로 아직 답을 얻지 못했습니다.

이전 답변은 기본적으로 "할 수 없다"또는 "하지 말아야한다"의 변형입니다. 후자의 정서에 동의하는 동안, 문제는 기술적으로 아직 답을 얻지 못했습니다.

게다가 누군가가 실제 질문에서 요구하는 바를 따라 뭔가를하고 싶어하는 정당한 이유가 있습니다. 내가 가끔 실행하는 한 가지는 긴 이름을 사용하여 방정식을 인식 할 수 없도록 만드는 긴 수학 방정식입니다. 다음은 통조림으로 만든 예제에서이 작업을 수행 할 수있는 몇 가지 방법입니다.
```
import numpy as np
class MyFunkyGaussian() :
    def __init__(self, A, x0, w, s, y0) :
        self.A = float(A)
        self.x0 = x0
        self.w = w
        self.y0 = y0
        self.s = s

    # The correct way, but subjectively less readable to some (like me) 
    def calc1(self, x) :
        return (self.A/(self.w*np.sqrt(np.pi))/(1+self.s*self.w**2/2)
                * np.exp( -(x-self.x0)**2/self.w**2)
                * (1+self.s*(x-self.x0)**2) + self.y0 )

    # The correct way if you really don't want to use 'self' in the calculations
    def calc2(self, x) :
        # Explicity copy variables
        A, x0, w, y0, s = self.A, self.x0, self.w, self.y0, self.s
        sqrt, exp, pi = np.sqrt, np.exp, np.pi
        return ( A/( w*sqrt(pi) )/(1+s*w**2/2)
                * exp( -(x-x0)**2/w**2 )
                * (1+s*(x-x0)**2) + y0 )

    # Probably a bad idea...
    def calc3(self, x) :
        # Automatically copy every class vairable
        for k in self.__dict__ : exec(k+'= self.'+k)
        sqrt, exp, pi = np.sqrt, np.exp, np.pi
        return ( A/( w*sqrt(pi) )/(1+s*w**2/2)
                * exp( -(x-x0)**2/w**2 )
                * (1+s*(x-x0)**2) + y0 )

g = MyFunkyGaussian(2.0, 1.5, 3.0, 5.0, 0.0)
print(g.calc1(0.5))
print(g.calc2(0.5))
print(g.calc3(0.5))
```
세 번째 예제 - 즉, self .__ dict__ : k (k + '= self.'+ k)의 k는 기본적으로 질문이 실제로 요구하는 것입니다. 그러나 그것이 일반적으로 좋은 것이라고 생각하지 않는다는 것을 분명히합니다. 생각.

더 많은 정보와 클래스 변수 나 함수를 반복하는 방법은이 질문에 대한 답변과 토론을 참조하십시오. 동적으로 변수 이름을 지정하는 다른 방법에 대한 설명과 왜 이것이 일반적으로 좋은 아이디어인지는이 블로그 게시물을 참조하십시오.
==============================
8.그래, 자기 지겨운거야. 그러나, 그것은 더 좋은가?

그래, 자기 지겨운거야. 그러나, 그것은 더 좋은가?
```
class Test:

    def __init__(_):
        _.test = 'test'

    def run(_):
        print _.test
```
==============================
9.사실 Armin Ronacher 프리젠 테이션 "5 년의 나쁜 아이디어"(Google에서)를 통해 조리법 "암시 적 자기"를 사용할 수 있습니다.

사실 Armin Ronacher 프리젠 테이션 "5 년의 나쁜 아이디어"(Google에서)를 통해 조리법 "암시 적 자기"를 사용할 수 있습니다.

Armin Ronacher의 거의 모든 것처럼 매우 똑똑한 요리법이지만이 아이디어는 매우 매력적이라고 생각하지 않습니다. 나는 C # / Java에서 명시 적으로 이것을 선호한다고 생각한다.

최신 정보. "나쁜 아이디어 제조법"링크 : https://speakerdeck.com/mitsuhiko/5-years-of-bad-ideas?slide=58
==============================
10.From : Self Hell - 더 많은 상태 저장 기능.

From : Self Hell - 더 많은 상태 저장 기능.

from https://stackoverflow.com/questions/1984104/how-to-avoid-explicit-self-in-python by cc-by-sa and MIT license

'PYTHON' 카테고리의 다른 글

[PYTHON] Selenium Python API 바인딩을 사용하여 Chrome에서 console.log 출력 얻기 (0)	2018.10.12
[PYTHON] UnicodeDecodeError : 'utf8'코덱은 0 위치의 바이트 0xa5을 디코딩 할 수 없습니다 : 잘못된 시작 바이트 (0)	2018.10.12
[PYTHON] Paramiko에서 대화식 명령 실행하기 (0)	2018.10.12
[PYTHON] keypress를 읽는 파이썬 방법? (0)	2018.10.12
[PYTHON] matplotlib에서 여러 개의 서브 플로트를 얻으려면 어떻게해야합니까? (0)	2018.10.12

복붙노트

[PYTHON] 파이썬에서 명시적인 '자아'를 피하는 법?

파이썬에서 명시적인 '자아'를 피하는 법?

해결법

3.원하는 이름을 사용할 수 있습니다 (예 :

4.명시 적으로 암시 적보다 낫기 때문에 그렇습니다. 항상 파이썬 철학에 따르면 자아를 지정해야합니다.

5.self는 객체의 멤버에 액세스하는 파이썬 구문의 일부입니다. 그래서 여러분은 그것에 매몰되어 있습니다.

7.이전 답변은 기본적으로 "할 수 없다"또는 "하지 말아야한다"의 변형입니다. 후자의 정서에 동의하는 동안, 문제는 기술적으로 아직 답을 얻지 못했습니다.

8.그래, 자기 지겨운거야. 그러나, 그것은 더 좋은가?

9.사실 Armin Ronacher 프리젠 테이션 "5 년의 나쁜 아이디어"(Google에서)를 통해 조리법 "암시 적 자기"를 사용할 수 있습니다.

10.From : Self Hell - 더 많은 상태 저장 기능.

'PYTHON' 카테고리의 다른 글

티스토리툴바