__init__와 self는 파이썬에서 무엇을합니까?

__init__와 self는 파이썬에서 무엇을합니까?

---

저는 파이썬 프로그래밍 언어를 배우고 있는데 제가 완전히 이해하지 못하는 것을 발견했습니다.

다음과 같은 방법으로 :

def method(self, blah):
    def __init__(?):
        ....
    ....

무엇을 self합니까? 그것은 무엇을 의미합니까? 필수인가요?

뭐라고를 않는 __init__방법은 무엇입니까? 왜 필요한가요? (기타.)

나는 그들이 OOP 구조일지도 모른다고 생각하지만, 나는 잘 모른다.

---

이 코드에서 :

class A(object):
    def __init__(self):
        self.x = 'Hello'

    def method_a(self, foo):
        print self.x + ' ' + foo

... self변수는 객체 자체의 인스턴스를 나타냅니다. 대부분의 객체 지향 언어는 이것을 객체에 정의 된 메소드에 숨겨진 매개 변수로 전달합니다. 파이썬은 그렇지 않습니다. 명시 적으로 선언해야합니다. A클래스 의 인스턴스를 만들고 메서드를 호출하면 ...에서와 같이 자동으로 전달됩니다.

a = A()               # We do not pass any argument to the __init__ method
a.method_a('Sailor!') # We only pass a single argument

이 __init__메서드는 대략 Python에서 생성자를 나타내는 것입니다. A()Python 을 호출 하면 객체가 생성되고 첫 번째 매개 변수로 __init__메서드에 전달됩니다. 추가 매개 변수 (예 A(24, 'Hello'):)도 인수로 전달됩니다.이 경우 생성자가 예상하지 않기 때문에 예외가 발생합니다.

---

네, 맞습니다. 이것들은 oop 구조입니다.

__init__클래스의 생성자입니다. self파라미터 (같은 오브젝트의 인스턴스를 참조 this++ C에서).

class Point:
    def __init__(self, x, y):
        self._x = x
        self._y = y

__init__객체에 대한 메모리가 할당 될 때 불려갑니다 :

x = Point(1,2)

self객체에 값을 유지하려면 객체의 메서드 내 에서 매개 변수 를 사용하는 것이 중요 합니다. 예를 들어 다음 __init__과 같은 메서드 를 구현하면 :

class Point:
    def __init__(self, x, y):
        _x = x
        _y = y

내 x및 y매개 변수는 스택 변수에 저장 될 것이고, init 메소드가 범위를 벗어나면 폐기 될 것이다. 로 그 변수를 설정 self._x하고 self._y의 구성원으로 그 변수를 설정 Point오브젝트 (객체의 수명에 대한 접근).

---

간단한 설명 예

조금 도움이 될 수 있기를 바라며, 여기에 클래스 내부에서 선언 된 변수와 __init__함수 내부에서 선언 된 변수의 차이점을 이해하는 데 사용한 간단한 예제가 있습니다.

class MyClass(object):
    i = 123
    def __init__(self):
        self.i = 345

a = MyClass()
print(a.i)
print(MyClass.i)

산출:

345
123

---

요컨대 :

1. self그것이 암시 하듯이, 메서드를 호출 한 객체 인 자신을 참조합니다 . 즉, 메서드를 호출 self.a하는 N 개의 개체가있는 경우 N 개 개체 각각에 대해 별도의 변수 인스턴스를 참조합니다. a각 개체에 대해 N 개의 변수 복사본을 상상해보십시오.
2. __init__C ++ / Java와 같은 다른 OOP 언어에서 생성자로 호출됩니다. 기본 개념은 해당 Class의 객체가 생성 될 때 자동으로 호출되는 특수 메서드라는 것입니다.

---

__init__생성자처럼 작동합니다. 비 정적 메서드로 동작하게하려면 첫 번째 인수로 모든 클래스 함수에 "self"를 전달해야합니다. "self"는 클래스의 인스턴스 변수입니다.

---

이 코드를 사용해보십시오. 나와 같은 많은 C 프로그래머가 Py를 배우는 데 도움이되기를 바랍니다.

#! /usr/bin/python2

class Person:

    '''Doc - Inside Class '''

    def __init__(self, name):
        '''Doc - __init__ Constructor'''
        self.n_name = name        

    def show(self, n1, n2):
        '''Doc - Inside Show'''
        print self.n_name
        print 'Sum = ', (n1 + n2)

    def __del__(self):
        print 'Destructor Deleting object - ', self.n_name

p=Person('Jay')
p.show(2, 3)
print p.__doc__
print p.__init__.__doc__
print p.show.__doc__

산출:

Jay

Sum = 5

Doc - Inside Class

Doc - __init__ Constructor

Doc - Inside Show

Destructor Deleting object - Jay

---

이것을 스스로 이해하는 데 어려움을 겪었습니다. 여기에서 답변을 읽은 후에도.

__init__방법 을 제대로 이해하려면 자신을 이해해야합니다.

자체 매개 변수

__init__메서드에서 허용하는 인수 는 다음과 같습니다.

def __init__(self, arg1, arg2):

하지만 실제로는 두 가지 인수 만 전달합니다.

instance = OurClass('arg1', 'arg2')

추가 논쟁은 어디에서 왔습니까?

객체의 속성에 액세스 할 때 이름 (또는 참조)으로 수행합니다. 여기 인스턴스는 새로운 객체에 대한 참조입니다. instance.printargs를 사용하여 인스턴스 객체의 printargs 메서드에 액세스합니다.

__init__메서드 내에서 개체 속성에 액세스하려면 개체에 대한 참조가 필요합니다.

메서드가 호출 될 때마다 기본 개체에 대한 참조가 첫 번째 인수로 전달됩니다. 관례 적으로 당신은 항상이 첫 번째 인자를 당신의 메소드 self에 호출합니다.

이것은 __init__우리가 할 수 있는 방법 에서 의미합니다 :

self.arg1 = arg1
self.arg2 = arg2

여기에서는 객체에 대한 속성을 설정합니다. 다음을 수행하여이를 확인할 수 있습니다.

instance = OurClass('arg1', 'arg2')
print instance.arg1
arg1

이와 같은 값을 개체 속성이라고합니다. 여기서 __init__메서드는 인스턴스의 arg1 및 arg2 속성을 설정합니다.

출처 : http://www.voidspace.org.uk/python/articles/OOP.shtml#the-init-method

---

클래스 객체 는 속성 참조와 인스턴스화 의 두 가지 작업을 지원합니다.

속성 참조 obj.name : 파이썬의 모든 속성 참조에 사용되는 표준 구문을 사용합니다. 유효한 속성 이름은 클래스 개체를 만들 때 클래스의 네임 스페이스에 있던 모든 이름입니다. 따라서 클래스 정의가 다음과 같은 경우 :

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

    def f(self):
        return 'hello world'

다음 MyClass.i과 MyClass.f각각 정수 및 함수 객체를 반환 유효한 속성 참조이다. 클래스 속성도 할당 할 수 있으므로 MyClass.i할당별로 값을 변경할 수 있습니다 . __doc__"A simple example class"클래스에 속하는 독 스트링을 반환하는 유효한 속성이기도합니다.

클래스 인스턴스화 는 함수 표기법을 사용합니다. 클래스 개체가 클래스의 새 인스턴스를 반환하는 매개 변수가없는 함수라고 가정하십시오. 예를 들면 :

x = MyClass()

인스턴스화 (클래스 객체 "호출") 작업은 빈 객체를 생성합니다. 많은 클래스는 특정 초기 상태에 맞게 사용자 정의 된 인스턴스로 객체를 생성하는 것을 좋아합니다. 따라서 클래스는 다음 __init__()과 같이 라는 특수 메서드를 정의 할 수 있습니다 .

def __init__(self):
    self.data = []

클래스가 __init__()메서드를 정의하면 클래스 인스턴스화 __init__()가 새로 생성 된 클래스 인스턴스에 대해 자동으로 호출됩니다 . 따라서이 예제에서 초기화 된 새 인스턴스는 다음을 통해 얻을 수 있습니다.

x = MyClass()

물론이 __init__()방법에는 더 큰 유연성에 대한 논쟁이있을 수 있습니다. 이 경우 클래스 인스턴스화 연산자에 제공된 인수가에 전달됩니다 __init__(). 예를 들면

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart

x = Complex(3.0, -4.5)
x.r, x.i

결국 가장 도움이 된 공식 문서 에서 가져 왔습니다 .

---

여기 내 예가 있습니다.

class Bill():
    def __init__(self,apples,figs,dates):
        self.apples = apples
        self.figs = figs
        self.dates = dates
        self.bill = apples + figs + dates
        print ("Buy",self.apples,"apples", self.figs,"figs 
                and",self.dates,"dates. 
                Total fruitty bill is",self.bill," pieces of fruit :)")

Bill 클래스의 인스턴스를 생성하는 경우 :

purchase = Bill(5,6,7)

당신은 얻을 :

> Buy 5 apples 6 figs and 7 dates. Total fruitty bill is 18  pieces of
> fruit :)

---

참고 self실제로 유효한 파이썬 식별자 일 수있다. 예를 들어, Chris B의 예 에서처럼 쉽게 작성할 수 있습니다.

class A(object):
    def __init__(foo):
        foo.x = 'Hello'

    def method_a(bar, foo):
        print bar.x + ' ' + foo

정확히 똑같이 작동합니다. 그러나 self를 사용하는 것이 좋습니다. 다른 파이썬 사용자가 더 쉽게 인식 할 수 있기 때문입니다.

---

Basically, you need to use the 'self' keyword when using a variable in multiple functions within the same class. As for init, it's used to setup default values incase no other functions from within that class are called.

---

1. __init__ is basically a function which will "initialize"/"activate" the properties of the class for a specific object, once created and matched to the corresponding class..
2. self represents that object which will inherit those properties.

---

The 'self' is a reference to the class instance

class foo:
    def bar(self):
            print "hi"

Now we can create an instance of foo and call the method on it, the self parameter is added by Python in this case:

f = foo()
f.bar()

But it can be passed in as well if the method call isn't in the context of an instance of the class, the code below does the same thing

f = foo()
foo.bar(f)

Interestingly the variable name 'self' is just a convention. The below definition will work exactly the same.. Having said that it is very strong convention which should be followed always, but it does say something about flexible nature of the language

class foo:
    def bar(s):
            print "hi"

---

Just a demo for the question.

class MyClass:

    def __init__(self):
        print('__init__ is the constructor for a class')

    def __del__(self):
        print('__del__ is the destructor for a class')

    def __enter__(self):
        print('__enter__ is for context manager')
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print('__exit__ is for context manager')

    def greeting(self):
        print('hello python')


if __name__ == '__main__':
    with MyClass() as mycls:
        mycls.greeting()

---

$ python3 class.objects_instantiation.py
__init__ is the constructor for a class
__enter__ is for context manager
hello python
__exit__ is for context manager
__del__ is the destructor for a class

---

# Source: Class and Instance Variables
# https://docs.python.org/2/tutorial/classes.html#class-and-instance-variables

class MyClass(object):
    # class variable
    my_CLS_var = 10

    # sets "init'ial" state to objects/instances, use self argument
    def __init__(self):
        # self usage => instance variable (per object)
        self.my_OBJ_var = 15

        # also possible, class name is used => init class variable
        MyClass.my_CLS_var = 20


def run_example_func():
    # PRINTS    10    (class variable)
    print MyClass.my_CLS_var

    # executes __init__ for obj1 instance
    # NOTE: __init__ changes class variable above
    obj1 = MyClass()

    # PRINTS    15    (instance variable)
    print obj1.my_OBJ_var

    # PRINTS    20    (class variable, changed value)
    print MyClass.my_CLS_var


run_example_func()

---

In this code:

class Cat:
    def __init__(self, name):
        self.name = name
    def info(self):
        print 'I am a cat and I am called', self.name

Here __init__ acts as a constructor for the class and when an object is instantiated, this function is called. self represents the instantiating object.

c = Cat('Kitty')
c.info()

The result of the above statements will be as follows:

I am a cat and I am called Kitty

---

What does self do? What is it meant to be? Is it mandatory?

The first argument of every class method, including init, is always a reference to the current instance of the class. By convention, this argument is always named self. In the init method, self refers to the newly created object; in other class methods, it refers to the instance whose method was called.

Python doesn't force you on using "self". You can give it any name you want. But remember the first argument in a method definition is a reference to the object. Python adds the self argument to the list for you; you do not need to include it when you call the methods. if you didn't provide self in init method then you will get an error

TypeError: __init___() takes no arguments (1 given)

What does the init method do? Why is it necessary? (etc.)

init is short for initialization. It is a constructor which gets called when you make an instance of the class and it is not necessary. But usually it our practice to write init method for setting default state of the object. If you are not willing to set any state of the object initially then you don't need to write this method.

---

Python __init__ and self what do they do?

What does self do? What is it meant to be? Is it mandatory?

What does the __init__ method do? Why is it necessary? (etc.)

The example given is not correct, so let me create a correct example based on it:

class SomeObject(object):

    def __init__(self, blah):
        self.blah = blah

    def method(self):
        return self.blah 

When we create an instance of the object, the __init__ is called to customize the object after it has been created. That is, when we call SomeObject with 'blah' below (which could be anything), it gets passed to the __init__ function as the argument, blah:

an_object = SomeObject('blah')

The self argument is the instance of SomeObject that will be assigned to an_object.

Later, we might want to call a method on this object:

an_object.method()

Doing the dotted lookup, that is, an_object.method, binds the instance to an instance of the function, and the method (as called above) is now a "bound" method - which means we do not need to explicitly pass the instance to the method call.

The method call gets the instance because it was bound on the dotted lookup, and when called, then executes whatever code it was programmed to perform.

The implicitly passed self argument is called self by convention. We could use any other legal Python name, but you will likely get tarred and feathered by other Python programmers if you change it to something else.

__init__ is a special method, documented in the Python datamodel documentation. It is called immediately after the instance is created (usually via __new__ - although __new__ is not required unless you are subclassing an immutable datatype).

---

Here, the guy has written pretty well and simple: https://www.jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming/

Read above link as a reference to this:

self? So what's with that self parameter to all of the Customer methods? What is it? Why, it's the instance, of course! Put another way, a method like withdraw defines the instructions for withdrawing money from some abstract customer's account. Calling jeff.withdraw(100.0) puts those instructions to use on the jeff instance.

So when we say def withdraw(self, amount):, we're saying, "here's how you withdraw money from a Customer object (which we'll call self) and a dollar figure (which we'll call amount). self is the instance of the Customer that withdraw is being called on. That's not me making analogies, either. jeff.withdraw(100.0) is just shorthand for Customer.withdraw(jeff, 100.0), which is perfectly valid (if not often seen) code.

init self may make sense for other methods, but what about init? When we call init, we're in the process of creating an object, so how can there already be a self? Python allows us to extend the self pattern to when objects are constructed as well, even though it doesn't exactly fit. Just imagine that jeff = Customer('Jeff Knupp', 1000.0) is the same as calling jeff = Customer(jeff, 'Jeff Knupp', 1000.0); the jeff that's passed in is also made the result.

This is why when we call init, we initialize objects by saying things like self.name = name. Remember, since self is the instance, this is equivalent to saying jeff.name = name, which is the same as jeff.name = 'Jeff Knupp. Similarly, self.balance = balance is the same as jeff.balance = 1000.0. After these two lines, we consider the Customer object "initialized" and ready for use.

Be careful what you __init__

After init has finished, the caller can rightly assume that the object is ready to use. That is, after jeff = Customer('Jeff Knupp', 1000.0), we can start making deposit and withdraw calls on jeff; jeff is a fully-initialized object.

참고URL : https://stackoverflow.com/questions/625083/what-init-and-self-do-on-python