[Python] OOP vragen

[Verwijderd]

Hallo

Ik begin nu een beetje OOP te scripten in Python. Nu heb ik gewoon een paar vraagjes. Ik heb al hulp gevraagd op wat Engelse forums maar omdat ik 14 ben kon ik het niet helemaal volgen. Hopelijk lukt dat hier beter .

Python:

#!/usr/bin/env python
class Student:
    def __init__( self, name, adres, age, klas ):
        self.name = name
        self.adres = adres
        self.age = age
        self.klas = klas

    def alleinfo( self ):
        print "Naam: %s" % ( self.name )
    
pyn = Student( "Pynthon", "Street 12", 14, "b2e" )
pyn.alleinfo()

Dit scriptje werkt prima alleen toch nog wat vragen:
1. __init__ is er toch voor om waarde mee te geven aan een Python class zodat je dat niet allemaal via functions moet doen?
2. Waarom dat self? Ik snapte dat een beetje maar een wat betere uitleg zo mooi zijn.
3. Je hebt ook nog een __del__ wat doet dat?
4. Waarom werkt het niet als ik bijvoorbeeld in de functie alleinfo() een variabele maak genaamd "name = name" en dan de:

Python:

print "Naam: %s" % ( self.name )

Vervang door

Python:

print "Naam: %s" % ( name )

Sorry voor al de vragen, hopelijk kan iemand me toch helpen _0_.

Alvast super bedankt!
Pynthon

[user109731]

Heb je deze tutorial gezien (vanaf 9.3)? Nederlandstalig en volgens mij niet al te moeilijk.
diveintopython.org heeft ook een hoofdstuk over classes, is wel engelstalig.

Daar vind je het antwoord op vraag 1 en 2.

3. __del__ is een speciale methode die word aangeroepen voordat het object word verwijderd (door de garbage collector, als er geen referenties meer naar zijn). Het is de destructor, eigenlijk het tegenovergestelde van __init__ (de constructor).

4. Je kunt wel dit doen:

Python:

name = self.name
print "Naam: %s" % ( name )

self.name is een instance-variabele, die moet je altijd benaderen via een instantie van je class, in dit geval 'self'.
name zonder self is een lokale variabele die enkel in de functie 'alleinfo' bekend is.

[Verwijderd]

Ik zou je aanraden om eerst wat meer over OOP in te lezen. Dingen als 'self' , 'init en 'del' zijn heel basic OOP. Zoek maar eens op 'constructor' en 'destructor'.

Toch even heel kort:

1. __init__ wordt uitgevoerd zodra een instantie van de klasse wordt gemaakt. Je hoeft hem dus niet zelf aan te roepen. Het wordt inderdaad vaak gebruikt om een instantie te initialiseren, maar in principe kun je het ook gebruiken om "poep" naar het scherm te schrijven.
2. Self is een variabele waarmee je variabelen in de klasse zelf aanroept. Heeft te maken met scopes van variabelen.
3. __del__ is het omgekeerde van __init en wordt uitgevoerd bij het verwijderen van de instantie. Hiermee geef je bijvoorbeeld geheugen weer vrij.
4. Name = name is een zinloze declaratie. Je zou denk ik name = self.name moeten doen.

Nogmaals, ik raad je aan om gewoon een goed boek over OOP/Python te kopen en eens lekker aan de bak te gaan. Daar leer je meer van dan van online tutorials en online fora.

[Sir Isaac]

Verwijderd schreef op dinsdag 14 april 2009 @ 19:54:
Ik begin nu een beetje OOP te scripten in Python. Nu heb ik gewoon een paar vraagjes. Ik heb al hulp gevraagd op wat Engelse forums maar omdat ik 14 ben kon ik het niet helemaal volgen. Hopelijk lukt dat hier beter .

Python:

#!/usr/bin/env python
class Student:
    def __init__( self, name, adres, age, klas ):
        self.name = name
        self.adres = adres
        self.age = age
        self.klas = klas

    def alleinfo( self ):
        print "Naam: %s" % ( self.name )
    
pyn = Student( "Pynthon", "Street 12", 14, "b2e" )
pyn.alleinfo()

Dit scriptje werkt prima alleen toch nog wat vragen:
1. __init__ is er toch voor om waarde mee te geven aan een Python class zodat je dat niet allemaal via functions moet doen?
3. Je hebt ook nog een __del__ wat doet dat?

__init_() wordt aangeroepen op het moment een object wordt gemaakt, __del__() vlak voordat het vernietigd wordt. Je kunt in deze functies een boel administratieve taken voor het object zelf instoppen die dan automatisch worden uitgevoerd. Stel je object tijdens zijn levensduur verschillende keren iets naar een file. In de __init__() method open je dan de file, en in de __del__() sluit je hem weer. Dan hoef je dat vanuit je hoofdprogramma inderdaad niet handmatig met andere lidfuncties te doen.

2. Waarom dat self? Ik snapte dat een beetje maar een wat betere uitleg zo mooi zijn.

Als je een object A1, A2 en A3 van class Aclass hebt, dan betekent A1.alleinfo() in feite Aclass.alleinfo(A1). De naam van heb object is dus het eerste argument van alle lidfuncties. In python is ervoor gekozen om dit expliciet zo op te schrijven. Een voordeel hiervan is dat een lokale variabele in een functie dezelfde naam kan hebben als een lid van de class. Je kunt ook een andere naam gebruiken dan self:

Python:

class A:
    def __init__(Zelf, X):
        Zelf.x=X

4. Waarom werkt het niet als ik bijvoorbeeld in de functie alleinfo() een variabele maak genaamd "name = name" en dan de:

Python:

print "Naam: %s" % ( self.name )

Vervang door

Python:

print "Naam: %s" % ( name )

Dat moet nu duidelijk zijn. Je definieert nu een nieuwe variabele "name" en die maak je gelijk aan "name", maar die bestaat nog niet. Dan gaat python over zijn nek. Wat je wilt is:

Python:

def alleinfo(self):
    name = self.name
    print "Naam: %s" % (name )

Tip: gebruik de __str__() lid functie:

Python:

class Student:
    def __str__(self):
        print "Naam: %s" % (self.name)
pyn = Student( "Pynthon", "Street 12", 14, "b2e" )
print pyn

Sorry voor al de vragen, hopelijk kan iemand me toch helpen _0_.

Een 14 jarige die python leert, is zo goed bezig dat ie verdient om een handje geholpen te worden. Ga zo door.

[Remus]

JanDM schreef op dinsdag 14 april 2009 @ 20:30:
3. __del__ is een speciale methode die word aangeroepen voordat het object word verwijderd (door de garbage collector, als er geen referenties meer naar zijn). Het is de destructor, eigenlijk het tegenovergestelde van __init__ (de constructor).

Wel even belangrijk om te realiseren is dat je __del__ over het algemeen niet hoeft te implementeren, tenzij je echt belangrijk opruim werk te doen hebt dat niet door Python's garbage collector gedaan kan worden.

[dev10]

Remus schreef op woensdag 15 april 2009 @ 09:33:
[...]


Wel even belangrijk om te realiseren is dat je __del__ over het algemeen niet hoeft te implementeren, tenzij je echt belangrijk opruim werk te doen hebt dat niet door Python's garbage collector gedaan kan worden.

Ik heb niet veel ervaring met garbage collectors en dergelijke, maar wat voor soort dingen zouden dat dan kunnen zijn?

[Wolfboy]

dev10 schreef op woensdag 15 april 2009 @ 10:03:
[...]


Ik heb niet veel ervaring met garbage collectors en dergelijke, maar wat voor soort dingen zouden dat dan kunnen zijn?

Dit object wordt nooit verwijderd:

Python:

class Spam(object):
    def __init__(self):
        self.self = self

    def __del__(self):
        print 'deleting Spam object'

a = Spam()
del a

Dat is ook het gevaarlijke aan __del__, je kan er niet vanuit gaan dat die aangeroepen wordt. Die wordt pas aangeroepen als de reference counter op 0 staat. 'deleting Spam object' zal je dus niet zien tenzij je 'del a.self, a' doet.

[Remus]

dev10 schreef op woensdag 15 april 2009 @ 10:03:
[...]
Ik heb niet veel ervaring met garbage collectors en dergelijke, maar wat voor soort dingen zouden dat dan kunnen zijn?

In het geval van Python wordt bij de garbage collection van een file-object de OS-filehandle gesloten indien de gebruiker van het object het bestand niet expliciet gesloten heeft.

Daarnaast heb ik het zelf eigenlijk alleen gebruikt om wat problemen te doorgronden door aan objecten (tijdelijk) een __del__ toe te voegen die eigenlijk alleen logging uitvoerde.

[Soultaker]

In het algemeen moet je ook geen __del__ methoden implementeren; de meeste low-level objecten (zoals files, sockets, e.d.) die expliciet gesloten moeten worden, implementeren dat zelf wel, dus als je een object maakt wat b.v. een file opent, dan wordt die file vanzelf wel gesloten als je object gecollect wordt. Zoals Wolfboy aangeeft kunnen ze zelfs problemen geven omdat objecten die in een cykel met een object met een __del__ methode zitten, niet door de garbage collector opgeruimd worden.

Ik heb al heel wat regels Python code geschreven en volgens mij nergens de __del__ methode geïmplementeerd, dus als je in zo'n beginnersfase zit dat je nog niet begrijpt waar self goed voor is, hoef je echt nog niet van het bestaan van __del__ methodes te weten laat staan dat je ze zou hoeven implementeren.

[Wolfboy]

Soultaker schreef op woensdag 15 april 2009 @ 14:26:
Ik heb al heel wat regels Python code geschreven en volgens mij nergens de __del__ methode geïmplementeerd, dus als je in zo'n beginnersfase zit dat je nog niet begrijpt waar self goed voor is, hoef je echt nog niet van het bestaan van __del__ methodes te weten laat staan dat je ze zou hoeven implementeren.

Wat dit betreft, ik heb in ieder geval een keer een goede use case gehad. Een module geschreven in c die echt een de-initialize vereiste voor het verwijderen van het object. Deed je dit niet dan had je een geheugen lek.

Maargoed, voorlopig kan je er vanuit gaan dat je de __del__ nooit nodig hebt en dat je het voorlopig alleen bij de __init__ hoeft te houden.

[djc]

Wolfboy schreef op donderdag 16 april 2009 @ 00:26:
Wat dit betreft, ik heb in ieder geval een keer een goede use case gehad. Een module geschreven in c die echt een de-initialize vereiste voor het verwijderen van het object. Deed je dit niet dan had je een geheugen lek.

Ja, als je modules in C gaat schrijven is het natuurlijk nogal een ander verhaal.