[python] Waarschijnlijk simpel probleemp met classes

[Xqlusive]

Op school zijn we nu bezig met python, ik heb al wel wat ervaring met andere talen, maar heb eigenlijk nog nooit gebruik gemaakt van classes. Nu heb ik dus een klein stukje code wat nog niet helemaal doet wat ik wil.

code:

from Tkinter import *

class Atom:
    def __init__(self, AtomName='no name', AtomWeight='no weight'):
        self.atom_name=AtomName
        self.atom_weight=AtomWeight

class Molecule:
    def __init__(self, AtomList=[]):
        self.atom_list=AtomList
    def Add_New_Atom(self, AtomName, AtomWeight):
        Name=Atom(AtomName,AtomWeight)
        self.atom_list.append(Name)
    def Add_library_Atom(self, Atom):
        self.atom_list.append(Atom)
        
        
        
root=Tk()
root.title("Atoms")
hydrogen=Atom("hydrogen", "1")
list1=[hydrogen]
water=Molecule(list1)

water.Add_New_Atom("oxygen","16")
water.Add_library_Atom(hydrogen)

Ik heb dus 2 classes aangemaakt, een class Atom, en een class Molecule. Nu werkt het aanmaken van een nieuw Atom en een nieuw Molecule prima. Het toevoegen van een Atom aan een Molecule uit de bestaande Atoms werkt ook goed. Ook het teovoegen van een Nieuw Atom aan een Molecule met de Add_new_Atom methode werkt goed. Het enige wat ik nog graag zou willen is dat een Atom die is aangemaakt met deze methode ook word opgeslagen als een Atom ipv alleen in de atom_list van een Molecule.

Nou heeft dat dus met deze regel code te maken:

code:

Name=Atom(AtomName,AtomWeight)

Nou wil ik dus dat "Name" bijvoorbeeld oxygen wordt en dat hij dus later terug te vinden is onder het commando

code:

oxygen.atom_name

dus een object van de class Atom.
Echter werkt het niet als ik er bijvoorbeeld dit van maak:

code:

AtomName=Atom(AtomName,AtomWeight)

Dit werkt niet omdat deze bewerking niet mag worden uitgevoerd op een str object.
Hoe kan ik dit wel doen?

[muksie]

Als ik je goed begrijp, is je Molecule in principe een verzameling Atom objecten, welke je m.b.v. een string wilt kunnen aanspreken, ofwel een dictionary. Je zou dus kunnen overwegen om je Molecule te laten overerven van dict of je kunt wat speciale methoden implementeren om het gewenste effect te bereiken.

[ValHallASW]

Je wilt dat als je een functie in een object uitvoert, dat dan een *global* wordt aangemaakt met een bepaalde naam?

Verder:

Python:

from x import *

is ranzig (from Tkinter import Tk ofzo)

code:

AtomName=Atom(AtomName,AtomWeight)

Dit werkt niet omdat deze bewerking niet mag worden uitgevoerd op een str object.

Dat werkt prima. Het doet misschien niet wat je wilt, maar het is legale code. Het heeft er niets mee te maken 'dat een bewerking niet mag worden uitgevoerd op een str object' maar dat je blijkbaar geen ene clue hebt waar je mee bezig bent. Je wijst hier een nieuwe Atom toe aan de variabele 'AtomName'. Geen wonder dat dat niet werkt

Globals bestaan in python. Het gebruik wordt - terecht - sterk afgeraden. Als je het echt wilt, ga een basiscursus programmeren volgen. Als dan blijkt dat het écht niet anders kan, ga dan een uitgebreide cursus programmeren volgen. Mocht je dan toch nog denken dat het nodig is, dan kan je met globals() en de dict die daar uit komt rollen vast wel het een en ander bereiken

[Xqlusive]

Je hebt gelijk dat het wel werkt, ik was in de war met een andere manier die ik probeerde.

Maar ik had er helemaal niet aan gedacht dat het misschien wel eens een lokale variabele kon zijn waardoor ik er dus niet bij kon.

btw. Je hoeft me ook niet direct zo af te kraken op mijn python/programmeer kennis, ik zeg toch al in de topicstart dat ik net met deze taal begin en nog nooit met classes heb gewerkt. Dat ik dan misschien wat vreemde constructies bouw en niet goed weet waar ik mee bezig ben weet ik zelf ook wel. ik ben ook niet voor niks er mee aan het oefenen.

code:

class Atom:
    def __init__(self, AtomName='no name', AtomWeight='no weight'):
        self.atom_name=AtomName
        self.atom_weight=AtomWeight

class Molecule:
    def __init__(self, AtomList=[]):
        self.atom_list=AtomList
    def Add_Atom(self, AtomName,AtomWeight): 
        self.atom_list.append(Atom(AtomName,AtomWeight))

water=Molecule()
water.Add_Atom("oxygen","16")
water.Add_Atom("hydrogen","1")

Het gaat ook eigenlijk niet zozeer om het programma werkend te krijgen, maar meer om het concept class beter te begrijpen. In het bovenstaande stukje voeg ik dus telkens een Atom object toe aan de lijst van een Molecule.

Ik vroeg me dus eigenlijk af of ik naast dat ik een Atom object aan de lijst had toegevoegd, ook een los Atom object had gemaakt welke ik weer kon gebruiken.

[ Voor 42% gewijzigd door Xqlusive op 10-01-2009 14:45 ]

[wjv]

Ja elk Atom object dat aan de lijst wordt toe gevoegd kan je er ook weer uithalen :

code:

een_atom = water.atom_list[0]

Dat haalt het eerste Atom object uit de lijst.

Als je trouwens met named variabelen werkt in een functie definite kan je die ook beter gebruiken bij het aanroepen daarvan, dus :

code:

water.Add_Atom(AtomName="oxygen",AtomWeight="16")

[ValHallASW]

Kijk, het punt is dat het zinvoller is als je gewoon even ergens een OOP-tutorial volg dan als je wat probeert en met dit soort dingen hier uitkomt. Daar staat het namelijk veel algemener uitgelegd.

Ik vroeg me dus eigenlijk af of ik naast dat ik een Atom object aan de lijst had toegevoegd, ook een los Atom object had gemaakt welke ik weer kon gebruiken.

Nee, je hebt één object gemaakt. Dat object kan je ook buiten die molecuul-lijst weer gebruiken. Je zou bij je add_atom functie bijvoorbeeld ook je atom kunnen retourneren:

code:

    def Add_New_Atom(self, AtomName, AtomWeight):
        atoom=Atom(AtomName,AtomWeight)
        self.atom_list.append(atoom)
        return atoom

Je krijgt hierbij hetzelfde atoom terug, dus alle wijzigingen die je daarom uitvoert wordt zijn óók zichtbaar in je molecuul.

Voor zover moleculen te definieren zijn als een lijst met atomen natuurlijk

[djc]

Overigens misschien ook wel nuttig als je PEP 8 even doorleest, dan kan je Python schrijven zoals Python bedoeld is.