Wat doen __init__ en ikzelf in Python?

Ik ben de programmeertaal Python aan het leren en ik ben iets tegengekomen dat ik niet helemaal begrijp.

In een methode als:

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

Wat doet self? Wat is de bedoeling? Is het verplicht?

Wat doet de methode __init__? Waarom is het nodig? (enz.)

Ik denk dat het misschien OOP-constructies zijn, maar ik weet niet veel.

Antwoord 1, autoriteit 100%

In deze code:

class A(object):
    def __init__(self):
        self.x = 'Hello'
    def method_a(self, foo):
        print self.x + ' ' + foo

… de variabele selfvertegenwoordigt de instantie van het object zelf. De meeste objectgeoriënteerde talen geven dit als een verborgen parameter door aan de methoden die op een object zijn gedefinieerd; Python niet. U moet dit expliciet aangeven. Wanneer u een instantie van de klasse amaakt en zijn methoden aanroept, wordt deze automatisch doorgegeven, zoals in …

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

De __init__methode is ongeveer wat een constructor in Python voorstelt. Als je A()aanroept, maakt Python een object voor je aan en geeft het als eerste parameter door aan de methode __init__. Alle aanvullende parameters (bijv. A(24, 'Hello')) worden ook doorgegeven als argumenten – in dit geval wordt er een uitzondering gegenereerd, omdat de constructor ze niet verwacht.

Antwoord 2, autoriteit 43%

Ja, je hebt gelijk, dit zijn oop-constructies.

__init__is de constructor voor een klasse. De parameter selfverwijst naar de instantie van het object (zoals thisin C++).

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

De methode __init__wordt aangeroepen nadat geheugen voor het object is toegewezen:

x = Point(1,2)

Het is belangrijk om de parameter selfin de methode van een object te gebruiken als u de waarde bij het object wilt behouden. Als u bijvoorbeeld de __init__methode als volgt implementeert:

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

Uw parameters xen yworden opgeslagen in variabelen op de stapel en worden weggegooid wanneer de init-methode buiten het bereik valt. Door die variabelen in te stellen als self._xen self._yworden die variabelen ingesteld als leden van het Point-object (toegankelijk voor de levensduur van het object) .

NB Enige verduidelijking van het gebruik van het woord ‘constructor’ in dit antwoord. Technisch gezien zijn de verantwoordelijkheden van een “constructor” verdeeld over twee methoden in Python. Die methoden zijn __new__(verantwoordelijk voor het toewijzen van geheugen) en __init__(zoals hier besproken, verantwoordelijk voor het initialiseren van de nieuw gemaakte instantie).

Antwoord 3, autoriteit 39%

Een kort illustratief voorbeeld

In de hoop dat het een beetje kan helpen, is hier een eenvoudig voorbeeld dat ik gebruikte om het verschil te begrijpen tussen een variabele gedeclareerd in een klasse en een variabele gedeclareerd in een functie __init__:

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

Uitvoer:

345
123

Antwoord 4, autoriteit 8%

Kortom:

1. selfzoals het suggereert, verwijst naar zichzelf– het object dat de methode heeft aangeroepen. Dat wil zeggen, als je N objecten hebt die de methode aanroepen, dan zal self.averwijzen naar een aparte instantie van de variabele voor elk van de N objecten. Stel je voor N exemplaren van de variabele avoor elk object
2. __init__is wat een constructor wordt genoemd in andere OOP-talen zoals C++/Java. Het basisidee is dat het een specialemethode is die automatisch wordt aangeroepen wanneer een object van die klasse wordt gemaakt

Antwoord 5, autoriteit 5%

Klasse-objectenondersteunen twee soorten bewerkingen: kenmerkverwijzingen en instantiatie

Kenmerkverwijzingengebruiken de standaardsyntaxis die wordt gebruikt voor alle kenmerkverwijzingen in Python: obj.name. Geldige attribuutnamen zijn alle namen die zich in de naamruimte van de klasse bevonden toen het klasseobject werd gemaakt. Dus als de klassedefinitie er zo uitzag:

class MyClass:
    """A simple example class"""
    i = 12345
    def f(self):
        return 'hello world'

dan zijn MyClass.ien MyClass.fgeldige attribuutreferenties, die respectievelijk een geheel getal en een functieobject retourneren. Er kunnen ook klasseattributen aan worden toegewezen, dus u kunt de waarde van MyClass.iper toewijzing wijzigen. __doc__is ook een geldig attribuut en geeft de docstring terug die bij de klasse hoort: “Een eenvoudige voorbeeldklasse”.

Klasse-instantiatiemaakt gebruik van functienotatie. Doe gewoon alsof het klasseobject een parameterloze functie is die een nieuwe instantie van de klasse retourneert. Bijvoorbeeld:

x = MyClass()

De instantiatiebewerking (“aanroepen” van een klasseobject) creëert een leeg object. Veel klassen maken graag objecten met instanties die zijn aangepast aan een specifieke beginstatus. Daarom kan een klasse een speciale methode definiëren met de naam __init__(), zoals deze:

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

Als een klasse een methode __init__()definieert, roept klasse-instantiatie automatisch __init__()aan voor de nieuw gemaakte klasse-instantie. Dus in dit voorbeeld kan een nieuwe, geïnitialiseerde instantie worden verkregen door:

x = MyClass()

Natuurlijk kan de methode __init__()argumenten hebben voor meer flexibiliteit. In dat geval worden de argumenten die aan de klasse-instantiatie-operator worden gegeven, doorgegeven aan __init__(). Bijvoorbeeld,

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
x.r, x.i

Genomen uit officiële documentatiedie me uiteindelijk het meest heeft geholpen.

Hier is mijn voorbeeld

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 :)")

Als u een instantie van klasse Bill maakt:

purchase = Bill(5,6,7)

Je krijgt:

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

Antwoord 6, autoriteit 5%

__init__gedraagt zich als een constructor. Je moet “self” doorgeven aan alle klassenfuncties als het eerste argument als je wilt dat ze zich gedragen als niet-statische methoden. “self” zijn instantievariabelen voor je klas.

Antwoord 7, autoriteit 4%

Probeer deze code uit. Ik hoop dat het veel C-programmeurs zoals ik helpt om Py te leren.

#! /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__

Uitvoer:

Jay

Sum = 5

Doc - Inside Class

Doc - __init__ Constructor

Doc - Inside Show

Destructor Deleting object - Jay

Antwoord 8, autoriteit 4%

Ik had er zelf moeite mee om dit te begrijpen. Zelfs na het lezen van de antwoorden hier.

Om de __init__methode goed te begrijpen, moet je jezelf begrijpen.

De zelfparameter

De argumenten die worden geaccepteerd door de __init__methode zijn:

def __init__(self, arg1, arg2):

Maar we geven het eigenlijk maar twee argumenten door:

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

Waar komt het extra argument vandaan?

Als we toegang krijgen tot attributen van een object, doen we dat bij naam (of bij referentie). Hier is bijvoorbeeld een verwijzing naar ons nieuwe object. We openen de printargs-methode van het instance-object met instance.printargs.

Om toegang te krijgen tot objectkenmerken vanuit de __init__methode hebben we een verwijzing naar het object nodig.

Telkens wanneer een methode wordt aangeroepen, wordt een verwijzing naar het hoofdobject als eerste argument doorgegeven.Volgens afspraak noem je dit eerste argument altijd naar je methoden zelf.

Dit betekent dat we in de __init__methode kunnen doen:

self.arg1 = arg1
self.arg2 = arg2

Hier stellen we attributen voor het object in.U kunt dit als volgt verifiëren:

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

Dergelijke

waarden staan bekend als objectattributen. Hier stelt de __init__methode de arg1 en arg2 attributen van de instantie in.

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

Antwoord 9, autoriteit 3%

merk op dat selfeigenlijk elke geldige python-ID kan zijn. We zouden bijvoorbeeld net zo gemakkelijk kunnen schrijven, naar het voorbeeld van Chris B:

class A(object):
    def __init__(foo):
        foo.x = 'Hello'
    def method_a(bar, foo):
        print bar.x + ' ' + foo

en het zou precies hetzelfde werken. Het wordt echter aanbevolen om zelf te gebruiken omdat andere pythoners het gemakkelijker zullen herkennen.

Antwoord 10, autoriteit 3%

Wat doet zelf? Wat is het bedoeld? Is het verplicht?

Het eerste argument van elke klassemethode, inclusief init, is altijd een verwijzing naar de huidige instantie van de klasse. Volgens afspraak wordt dit argument altijd selfgenoemd. In de init-methode verwijst selfnaar het nieuw gemaakte object; in andere klassenmethoden verwijst het naar de instantie waarvan de methode werd aangeroepen.

Python dwingt je niet om“zelf” te gebruiken. Je kunt het elke gewenste naam geven. Maar onthoud het eerste argument in een methodedefinitie is een verwijzing naar het object. Python voegt het argument selfvoor je toe aan de lijst; u hoeft het niet op te nemen wanneer u de methoden aanroept.
als je jezelf niet hebt opgegeven in de init-methode, krijg je een foutmelding

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

Wat doet de init-methode? Waarom is het nodig? (enz.)

initis een afkorting voor initialisatie. Het is een constructor die wordt aangeroepen wanneer je een instantie van de klasse maakt en het is niet nodig. Maar meestal is het onze gewoonte om de init-methode te schrijven voor het instellen van de standaardstatus van het object. Als u in eerste instantie geen enkele status van het object wilt instellen, hoeft u deze methode niet te schrijven.

Antwoord 11, autoriteit 3%

1. __init__is in feite een functie die de eigenschappen van de klasse “initialiseert”/“activeert”voor een specifiek object, eenmaal gemaakt en gekoppeld aan de corresponderende klasse..
2. selfvertegenwoordigt dat object dat deze eigenschappen zal erven.

Antwoord 12, autoriteit 2%

Kortom, u moet het trefwoord ‘self’ gebruiken wanneer u een variabele in meerdere functies binnen dezelfde klasse gebruikt. Wat betreft init, het wordt gebruikt om standaardwaarden in te stellen voor het geval er geen andere functies binnen die klasse worden aangeroepen.

Antwoord 13, autoriteit 2%

Gewoon een demo voor de vraag.

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

Antwoord 14, autoriteit 2%

Het ‘zelf’ is een verwijzing naar de klasse-instantie

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

Nu kunnen we een instantie van foo maken en de methode erop aanroepen, in dit geval wordt de parameter self door Python toegevoegd:

f = foo()
f.bar()

Maar het kan ook worden doorgegeven als de methodeaanroep niet in de context van een instantie van de klasse is, de onderstaande code doet hetzelfde

f = foo()
foo.bar(f)

Interessant is dat de variabelenaam ‘zelf’ slechts een conventie is. De onderstaande definitie zal precies hetzelfde werken.. Dat gezegd hebbende, het is zeer sterke conventiedie altijdmoet worden gevolgd, maar het zegt wel iets over de flexibele aard van de taal

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

Antwoord 15, Autoriteit 2%

In deze code:

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

Hier __init__Handelt als een constructeur voor de klas en wanneer een object inleiding is, wordt deze functie genoemd. selfVertegenwoordigt het Instantiating-object.

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

Het resultaat van de bovenstaande uitspraken is als volgt:

I am a cat and I am called Kitty

Antwoord 16

# 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()

Antwoord 17

Hier heeft de man vrij goed en eenvoudig geschreven: https://www.jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming/

Lees bovenstaande link als een verwijzing naar dit:

self? Dus wat is er met die zelfparameter voor alle klanten?
methoden? Wat is het? Wel, het is natuurlijk de instantie! Zet een andere
manier, een methode als terugtrekken definieert de instructies voor terugtrekken
geld van de rekening van een abstracte klant. Roeping
jeff.withdraw(100.0) zet die instructies op de jeff
instantie.

Dus als we zeggen def intrekken (zelf, bedrag):, dan zeggen we, “hier is hoe”
u geld opneemt van een klantobject (dat we zelf zullen noemen) en
een dollarcijfer (wat we bedrag noemen). zelf is de instantie van de
Klant die zich terugtrekt wordt opgeroepen. Dat ben ik niet aan het maken
analogieën, ofwel. jeff.withdraw (100.0) is gewoon een afkorting voor
Customer.withdraw (jeff, 100.0), wat volkomen geldig is (zo niet vaak)
gezien) code.

initself is misschien logisch voor andere methoden, maar hoe zit het met init? Als we initnoemen, zijn we bezig met het maken van een object, dus hoe kan er al een zelf zijn? Python stelt ons in staat om uit te breiden
het zelfpatroon tot wanneer objecten ook worden geconstrueerd, hoewel
het past niet precies. Stel je voor dat jeff = Klant(‘Jeff
Knupp’, 1000.0) is hetzelfde als jeff = Customer(jeff, ‘Jeff .) aanroepen
Knup’, 1000.0); de jeff die is doorgegeven wordt ook het resultaat.

Dit is de reden waarom wanneer we initaanroepen, we objecten initialiseren door te zeggen
dingen als zelf.naam = naam. Onthoud, aangezien het zelf de instantie is,
dit komt overeen met het zeggen van jeff.name = naam, wat hetzelfde is als
jeff.name = ‘Jeff Knupp. Evenzo is zelfbalans = balans hetzelfde
als jeff.balance = 1000,0. Na deze twee regels beschouwen we de
Klantobject “geïnitialiseerd” en klaar voor gebruik.

Wees voorzichtig met wat je __init__

Nadat initis afgelopen, kan de beller er terecht van uitgaan dat de
object is klaar voor gebruik. Dat wil zeggen, na jeff = Klant(‘Jeff Knupp’,
1000.0), kunnen we beginnen met het storten en opnemen van oproepen op Jeff; jeff is een volledig geïnitialiseerd object.

Antwoord 18

Python __init__en selfwat doen ze?

Wat doet self? Wat is de bedoeling? Is het verplicht?

Wat doet de methode __init__? Waarom is het nodig? (enz.)

Het gegeven voorbeeld is niet correct, dus laat me er een correct voorbeeld van maken:

class SomeObject(object):
    def __init__(self, blah):
        self.blah = blah
    def method(self):
        return self.blah 

Als we een instantie van het object maken, wordt de __init__aangeroepen om het object aan te passen nadat het is gemaakt. Dat wil zeggen, wanneer we SomeObjectaanroepen met 'blah'hieronder (wat van alles kan zijn), wordt het doorgegeven aan de functie __init__als argument , blah:

an_object = SomeObject('blah')

Het argument selfis de instantie van SomeObjectdie wordt toegewezen aan an_object.

Later willen we misschien een methode voor dit object aanroepen:

an_object.method()

Door de dotted lookup uit te voeren, dat wil zeggen an_object.method, wordt de instantie aan een instantie van de functie gebonden, en de methode (zoals hierboven genoemd) is nu een “gebonden” methode – wat betekent we hoeven de instantie niet expliciet door te geven aan de methodeaanroep.

De methode-aanroep krijgt de instantie omdat deze gebonden was aan de gestippelde lookup, en wanneer deze wordt aangeroepen, voert het de code uit waarvoor het is geprogrammeerd.

Het impliciet doorgegeven argument selfwordt volgens afspraak selfgenoemd. We zouden elke andere legale Python-naam kunnen gebruiken, maar je zult waarschijnlijk geteerd en gevederd worden door andere Python-programmeurs als je het in iets anders verandert.

__init__is een speciale methode, gedocumenteerd in de Python-datamodeldocumentatie. Het wordt onmiddellijk aangeroepen nadat de instantie is gemaakt (meestal via __new__– hoewel __new__niet vereist is, tenzij u een onveranderlijk gegevenstype subclasseert).