Pregunta Python __init__ y yo ¿qué hacen?


Estoy aprendiendo el lenguaje de programación de Python y he encontrado algo que no entiendo completamente.

En un método como:

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

Que hace self ¿hacer? ¿Qué significa ser? ¿Es obligatorio?

Lo que hace el __init__ método do? ¿Por qué es necesario? (etc.)

Creo que podrían ser construcciones OOP, pero no sé mucho.


571
2018-03-09 05:09


origen


Respuestas:


En este código:

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

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

... el self variable representa la instancia del objeto en sí. La mayoría de los lenguajes orientados a objetos pasan esto como un parámetro oculto a los métodos definidos en un objeto; Python no. Tienes que declararlo explícitamente. Cuando creas una instancia de A clase y llame a sus métodos, se pasará automáticamente, como en ...

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

los __init__ método es más o menos lo que representa un constructor en Python. Cuando usted llama A() Python crea un objeto para ti y lo pasa como el primer parámetro al __init__ método. Cualquier parámetro adicional (p. A(24, 'Hello')) también pasarán como argumentos, en este caso causando que se levante una excepción, ya que el constructor no los está esperando.


461
2018-03-09 05:18



Sí, tienes razón, estos son constructos oop.

__init__ es el constructor de una clase. los self parámetro se refiere a la instancia del objeto (como this en C ++).

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

los __init__ se llama al método cuando se asigna la memoria para el objeto:

x = Point(1,2)

Es importante usar el self parámetro dentro del método de un objeto si desea persistir el valor con el objeto. Si, por ejemplo, implementa el __init__ método como este:

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

Tu x y y los parámetros se almacenarían en variables en la pila y se descartarían cuando el método init salga del alcance. Establecer esas variables como self._x y self._y establece esas variables como miembros de la Point objeto (accesible durante la vida del objeto).


184
2018-03-09 05:18



Un breve ejemplo ilustrativo

Con la esperanza de que pueda ayudar un poco, aquí hay un ejemplo simple que solía entender la diferencia entre una variable declarada dentro de una clase y una variable declarada dentro de una clase. __init__ función:

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

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

137
2018-06-23 12:15



En breve:

  1. self como sugiere, se refiere a sí mismo- el objeto que ha llamado el método. Es decir, si tiene N objetos llamando al método, entonces self.a se referirá a una instancia separada de la variable para cada uno de los N objetos. Imagine N copias de la variable a para cada objeto
  2. __init__ es lo que se llama como un constructor en otros lenguajes OOP como C ++ / Java. La idea básica es que es un especial método que se llama automáticamente cuando se crea un objeto de esa clase

36
2018-03-09 05:41



__init__ actúa como un constructor. Tendrá que pasar "self" a cualquier función de clase como primer argumento si desea que se comporten como métodos no estáticos. "self" son variables de instancia para tu clase.


24
2018-03-09 05:18



Pruebe este código. Espero que ayude a muchos programadores de C como yo a aprender 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__

Salida:

Jay

Sum = 5

Doc - Inside Class

Doc - __init__ Constructor

Doc - Inside Show

Destructor Deleting object - Jay


20
2018-05-10 03:03



Tuve problemas para comprender esto yo mismo. Incluso después de leer las respuestas aquí.

Para entender apropiadamente el __init__ método que necesita para comprenderse a sí mismo.

El auto parámetro

Los argumentos aceptados por el __init__ método son:

def __init__(self, arg1, arg2):

Pero en realidad solo le pasamos dos argumentos:

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

¿De dónde viene el argumento extra?

Cuando accedemos a los atributos de un objeto lo hacemos por nombre (o por referencia). Aquí instancia es una referencia a nuestro nuevo objeto. Accedemos al método printargs del objeto de instancia utilizando instance.printargs.

Para acceder a los atributos del objeto desde dentro del __init__ método necesitamos una referencia al objeto.

Cada vez que se llama a un método, se pasa una referencia al objeto principal como primer argumento. Por convención, siempre llamas a este primer argumento a tus métodos.

Esto significa en el __init__ método que podemos hacer:

self.arg1 = arg1
self.arg2 = arg2

Aquí estamos estableciendo atributos en el objeto. Puede verificar esto haciendo lo siguiente:

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

valores como este se conocen como atributos de objeto. Aquí el __init__ método establece los atributos arg1 y arg2 de la instancia.

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


19
2018-01-09 22:39



tenga en cuenta que self podría ser cualquier identificador python válido. Por ejemplo, podríamos escribir con la misma facilidad, del ejemplo de Chris B:

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

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

y funcionaría exactamente igual. Sin embargo, se recomienda utilizarlo porque otros pythoners lo reconocerán más fácilmente.


16
2018-03-09 12:50



Básicamente, necesita usar la palabra clave 'self' cuando usa una variable en múltiples funciones dentro de la misma clase. Como para en eso, se usa para configurar valores predeterminados en caso de que no se invoquen otras funciones dentro de esa clase.


14
2017-09-23 12:02



  1. __init__ es básicamente una función que "inicializar"/"activar" las propiedades de la clase para un objeto específico, una vez creado y emparejado con la clase correspondiente ...
  2. self representa ese objeto que heredará esas propiedades.

14
2017-09-03 22:19



Estarás en lo cierto, son construcciones orientadas a objetos. Básicamente self es una referencia (algo así como un puntero, pero self es una referencia especial a la que no puedes asignar) a un objeto, y __init__ es una función que se llama para inicializar el objeto, es decir, establecer los valores de las variables, etc., justo después de asignarle la memoria.


13
2018-03-09 05:17