클래스 메서드의 'self' 파라미터는 무엇입니까?
self 왜 이 명시적으로 포함되어야 요?self★★★★★★★★★★★★★★★★★?
class MyClass:
def func(self, name):
self.name = name
는 대로 converse no no 가 없다.self:
class MyClass
def func(name)
@name = name
end
end
「 」를 해야 self.은 Python Python을 하지 않기 입니다.@instance Atribute를 참조하는 구문.Python은 메서드가 속한 인스턴스가 자동으로 전달되지만 자동으로 수신되지 않는 방식으로 메서드를 수행하기로 결정했습니다. 메서드의 첫 번째 매개 변수는 메서드가 호출되는 인스턴스입니다.이것에 의해, 메서드는 함수와 완전하게 같게 되어, 실제의 이름은 유저에게 맡겨집니다(단,self))))))))))))))))))))))))))))))))))))))))))))))))))))self코드에 특별한 게 아니라 다른 물건일 뿐이에요
Python은 Ruby가 가지고 있는 것과 같은 특별한 구문이나, C++나 Java와 같은 선언을 요구하거나, 혹은 좀 더 다른 것을 요구하거나, 하지만 그렇지 않았다.Python은 모든 것을 명확하게 하고, 무엇이 무엇인지 명확하게 하기 위한 것입니다.또, 모든 장소에서 그렇게 하는 것은 아니지만, 예를 들면 속성에 대해서 그렇게 합니다.해야 하는지 합니다 Atribute에 할당해야 합니다.그것이 바로 인스턴스 속성에 할당해야 하는 이유입니다.self..
가정해 보겠습니다.ClassA에는 방법이 되어 있습니다.methodA다음과 같이 합니다.
def methodA(self, arg1, arg2):
# do something
★★★★★★★★★★★★★★★★★」ObjectA는 이 클래스의 인스턴스입니다.
, 이제 제, 제ObjectA.methodA(arg1, arg2)는 Python이 과 같이변환합니다.
ClassA.methodA(ObjectA, arg1, arg2)
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 할 수 : 업업, 리리:: ::: :: class, 리:::::
Vector.length_new = length_global
v = Vector(3, 4)
print(v.length_new()) # 5.0
동작은 첫 가 ""이기 합니다.length_global 을, 을, 을, 을, 을, 을, 을 다시 사용할 수.self의 파라미터length_new은 명시적인 an an . . 、 . 、 . 、 . 、 . 、 . 、 . 。self.
의 또 selfPython이 어디에 구문설탕을 첨가하는지 보는 것입니다.두면 '콜'과 같은 입니다.
v_instance.length()
내부적으로는 로 변환되다
Vector.length(v_instance)
알 수 .self 를 첫 삼아야 하는 입니다.인스턴스 메서드를 실제로 Python으로 쓰는 것이 아니라 인스턴스를 첫 번째 파라미터로 삼아야 하는 클래스 메서드입니다.따라서 인스턴스 파라미터를 명시적으로 배치해야 합니다.
오브젝트가 인스턴스화되면 오브젝트 자체가 self 파라미터로 전달됩니다.
이 때문에 객체의 데이터는 객체에 바인딩됩니다.다음은 각 개체의 데이터를 시각화하는 방법의 예입니다.'self'가 개체 이름으로 대체되는 방법에 주목하십시오.아래 예시도가 완전히 정확하다고 말하는 것은 아니지만, 희망적으로 자기 사용을 시각화하는 데 도움이 될 것입니다.
오브젝트가 자신의 데이터를 유지할 수 있도록 오브젝트는 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'
클래스는 항상 이 "상태"를 통과하지 않기 위한 수단일 뿐입니다(또한 초기화, 클래스 구성, 거의 필요하지 않은 메타클래스, 연산자를 재정의하는 커스텀 메서드 지원 등 기타 장점도 있습니다).
이제 내장된 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 )
[마지막 질문 중복]
다음은 Python의 self에 관한 문서에서 발췌한 것입니다.
Modula-3에서와 같이 메서드에서 오브젝트의 멤버를 참조하기 위한 [Python]에는 생략이 없습니다.메서드 함수는 콜에 의해 암묵적으로 제공되는 오브젝트를 나타내는 명시적인 첫 번째 인수로 선언됩니다.
종종 방법의 첫 번째 인수는 자기라고 불립니다.이것은 관례에 지나지 않습니다. Python에게 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"
는 '아까부터'의.this키워드를 Java로 지정합니다.즉, 현재 오브젝트에 대한 참조를 제공합니다.
Python은 Java나 C++와 달리 객체 지향 프로그래밍을 위해 만들어진 언어가 아닙니다.
Python에서 static 메서드를 호출할 때는 규칙적인 인수가 포함된 메서드를 작성하기만 하면 됩니다.
class Animal():
def staticMethod():
print "This is a static method"
그러나 개체 메서드는 변수를 만들어야 하는데, 이 경우 동물입니다. self 인수가 필요합니다.
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 변수를 참조합니다.기억: 메서드 내에 변수가 있는 경우, 자아는 동작하지 않습니다.이 변수는 단순히 메서드가 실행 중일 때만 존재합니다.필드(클래스 전체의 변수)를 정의하려면 클래스 메서드 외부에서 필드를 정의해야 합니다.
제가 하는 말을 한마디도 이해하지 못한다면 구글의 "객체 지향 프로그래밍"입니다.이것을 이해하면, 그 질문을 할 필요도 없습니다. : )
우선, 자아는 관습적인 이름이기 때문에 그 대신에 다른 어떤 것도 넣을 수 있다.
오브젝트 자체를 참조하기 때문에 이 오브젝트를 사용할 때는 .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에서는 커스텀 오브젝트 모델 같은 것을 취급할 수 있습니다.
Python의 "명시적인 것이 암묵적인 것보다 낫다"는 선에 따르기 위해서다.이치노PHP에서는 또는 PHP라고 .this.
ifuser_type_name입니다.self.user_type_name.
아무도 루아 얘기를 꺼내지 않았다니 놀랍네요.Lua는 또한 'self' 변수를 사용하지만 생략할 수 있지만 여전히 사용됩니다.C++는 'this'와 같은 동작을 합니다.각 기능에서 'self'라고 선언할 필요는 없지만, lua나 C++와 마찬가지로 사용할 수 있어야 합니다.간결하다고 자부하는 언어에서는 자기변수를 선언해야 하는 것이 이상하다.
으로 「」라고 불리는.self왜 필요한 만큼이나 이해하기 어렵지 않나요?아니면 왜 그것을 명시적으로 언급하는가?이 질문을 찾는 대부분의 사용자에게는 더 큰 질문일 것입니다.그렇지 않다면 파이썬을 배우면서 같은 질문을 하게 될 것입니다.하다
키워드는 아닙니다.
init을 포함한 모든 클래스 메서드의 첫 번째 인수는 항상 클래스의 현재 인스턴스를 참조합니다.관례상, 이 주장은 항상 자기라고 불린다.init 메서드에서는 self는 새로 생성된 오브젝트를 참조합니다.다른 클래스 메서드에서는 메서드가 호출된 인스턴스를 참조합니다.예를 들어 아래 코드는 위 코드와 동일합니다.
2: 왜 이렇게 하고 자바와 같은 논쟁으로 없애고 대신 키워드를 가질 수 없는가?
하나 은 선택 self에서는 static static method를 쓰지 않고 내에서 할 수 .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인수는 필수입니다.
예시를 , '먹다'의 하게 알 수 .이 예에서는, 다음의 목적에 대해 명확하게 설명합니다.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의 self variable 설명 - Pythontips
왜냐하면 파이썬이 디자인된 방식으로는 다른 방법이 거의 효과가 없을 것이기 때문입니다.은 양쪽 암묵적인 Python을 할 수 .this Java 명시적(a-la Java/C++)@ ruby하지 않습니다 (a-la ruby)파이썬 규약을 사용한 명시적 접근 방법의 예를 들어보겠습니다.
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★★★★★★★★★★★★★★★★」대안은 여기서 호출 간의 기억하는가 교체된 지역 범위가 메서드를 실행하기 위하지만, 그 방식 지역 변수 posibility을 제거하는 것이다.
하지만 현재 상황은 잘:운동합니다.
def fubar(self, x)
self.x = x
class C:
frob = fubar
서 frob을 수신합니다.self 및 "" " " " "fubar여전히 변수로 개체와 같은(그것은 같은 일을 호출할 수 있습니다.C.frob)생생생생다
서서 __init__법, 자신이 새로 만든 개체에 다른 클래스 메서드에, 그 메서드가 호출 인스턴스에 대해 언급하고 말한다.
이름으로서 셀프는 그냥 규칙, 당신은 당신이 원하는 것으로 나타나! 하지만을 사용하여, 예를 들어 개체를 삭제하기 위해 같은 이름을 사용한다:.__del__(var)서, snowledge.var was was was was __init__(var,[...])
도 한번 보세요.cls너무, 더 큰 사진.이 포스트 도움이 될 것이다.
셀프 클래스의 현재 개체 이름 또는 인스턴스와 같은 행동하고 있다.
# 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" 키워드는 클래스의 참조를 보관하고 있으며 사용 여부는 사용자에게 달려 있습니다.그러나 python에서 새로운 메서드를 작성할 때마다 python은 자동으로 self 키워드를 작성합니다.R&D를 실시하면, 클래스내에서 2개의 메서드를 작성하고, 다른 메서드를 호출하려고 하면, self(클래스의 참조)를 추가하지 않는 한 메서드를 인식하지 않는 것을 알 수 있습니다.
class testA:
def __init__(self):
print('ads')
def m1(self):
print('method 1')
self.m2()
def m2(self):
print('method 2')
아래 코드는 해결할 수 없는 참조 오류를 발생시킵니다.
class testA:
def __init__(self):
print('ads')
def m1(self):
print('method 1')
m2() #throws unresolvable reference error as class does not know if m2 exist in class scope
def m2(self):
print('method 2')
이제 다음 예를 보겠습니다.
class testA:
def __init__(self):
print('ads')
def m1(self):
print('method 1')
def m2():
print('method 2')
이제 클래스 testA 개체를 만들 때 메서드 m1()에 self 키워드가 포함되어 있기 때문에 이와 같은 클래스 개체를 사용하여 메서드 m1()을 호출할 수 있습니다.
obj = testA()
obj.m1()
그러나 메서드 m2()를 호출하는 경우 is는 자기 참조가 없으므로 다음과 같이 클래스 이름을 사용하여 m2()를 직접 호출할 수 있습니다.
testA.m2()
그러나 self 키워드를 사용하는 것은 글로벌 변수 생성과 같은 다른 이점도 있기 때문에 계속 연습해야 합니다.
self피할 수 없습니다.
그냥 질문이 하나 있는데self암시적 또는 명시적.Guido van Rossum '남아야 한다'는 이 문제를 해결했다.
에요?self 라이브?
프로그래밍을 할 .selfPython OOP에 들어가면,selfcontract.discontracts.
사례는 .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가지 유형이 있습니다.
- 정적 메서드(읽기: 함수),
- 클래스 메서드,
- 인스턴스 메서드(상기)
'self'라는 단어는 클래스의 예를 말한다.
class foo:
def __init__(self, num1, num2):
self.n1 = num1 #now in this it will make the perimeter num1 and num2 access across the whole class
self.n2 = num2
def add(self):
return self.n1 + self.n2 # if we had not written self then if would throw an error that n1 and n2 is not defined and we have to include self in the function's perimeter to access it's variables
클래스 인스턴스 객체에 대한 명시적 참조입니다.
메서드의 특별한 점은 인스턴스 객체가 함수의 첫 번째 인수로 전달된다는 것입니다.예에서는, 콜 「」이 되고 있습니다.
x.f()일치하다MyClass.f(x)일반적으로 n개의 인수 목록을 사용하여 메서드를 호출하는 것은 첫 번째 인수 앞에 메서드의 인스턴스 개체를 삽입하여 작성된 인수 목록을 사용하여 대응하는 함수를 호출하는 것과 같습니다.
이 관련 토막 전에
class MyClass:
"""A simple example class"""
i = 12345
def f(self):
return 'hello world'
x = MyClass()
적어도 Python의 경우 self 파라미터는 플레이스 홀더로 생각할 수 있습니다.이것 좀 보세요.
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
p1 = Person("John", 36)
print(p1.name)
print(p1.age)
이 경우 Self와 다른 많은 것들이 이름 값을 저장하기 위한 방법으로 사용되었습니다.그러나 그 이후에는 p1을 사용하여 사용 중인 클래스에 할당합니다.그리고 인쇄 시 동일한 p1 키워드를 사용합니다.
이것이 Python에게 도움이 되길 바랍니다!
내 작은 2센트
이 클래스에서는 self와 함께 init 메서드를 정의했습니다.여기서 주목해야 할 것은 self 변수 p와 instance 변수 p의 메모리 위치가 동일하다는 것입니다.<__main__.Person object at 0x106a78fd0>
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def say_hi(self):
print("the self is at:", self)
print((f"hey there, my name is {self.name} and I am {self.age} years old"))
def say_bye(self):
print("the self is at:", self)
print(f"good to see you {self.name}")
p = Person("john", 78)
print("the p is at",p)
p.say_hi()
p.say_bye()
따라서 위에서 설명한 바와 같이 self 변수와 instance 변수는 모두 동일한 객체입니다.
언급URL : https://stackoverflow.com/questions/2709821/what-is-the-self-parameter-in-class-methods
'sourcecode' 카테고리의 다른 글
| Node.js에서 MySQL(ORM 없음)을 어떻게 조롱합니까? (0) | 2022.09.05 |
|---|---|
| MySQL: 저장 프로시저에서 여러 필드를 여러 변수로 선택 (0) | 2022.09.05 |
| TypeError: Vuex 4 및 Vue 3에서 사용할 때 정의되지 않은 속성 'getters'를 읽을 수 없습니다. (0) | 2022.09.05 |
| Cenum으로 인쇄하다. 값 대신 텍스트. (0) | 2022.09.05 |
| 정적 메서드 내에서 비 정적 내부 클래스를 인스턴스화하려면 어떻게 해야 합니까? (0) | 2022.09.05 |