Strutture dati personalizzate in Python

Question

Sono abbastanza nuovo in Python e devo dichiarare la mia struttura dati, sono un po 'confuso su come farlo. Al momento ho:

class Particle: 

    def __init__(self, mass, position, velocity, force): 

     self.mass = mass 
     self.position, self.velocity, self.force = position, velocity, force 

    def __getitem__(self, mass): 
     return self.mass 

    def __getitem__(self, position): 
     return self.position 

    def __getitem__(self, velocity): 
     return self.velocity 

    def __getitem__(self, force): 
     return self.force 

Questo non funziona, tuttavia, quando cerco di definire un'istanza della classe con:

p1 = Particle(mass, position, velocity, force) 

Ogni valore finisce proprio come una (0.0, 0.0) (che è il valore di velocità e forza).

Qualcuno potrebbe spiegare dove sto andando male, tutto ciò di cui ho bisogno dalla struttura dati è di essere in grado di estrarre i dati da esso, nient'altro. (Edit: in realtà, mi dispiace, dovrò cambiare loro un po 'più tardi)

Grazie

Answer 1

Prima di tutto, è necessario comprendere che lo __getitem__ è zucchero sintattico. È bello avere, ma se non ne hai bisogno, non usarlo. __getitem__ e __setitem__ sono fondamentalmente, se si vuole essere in grado di accedere agli elementi del tuo oggetto utilizzando la notazione staffa come:

p= Particle(foo) 
bar = p[0] 

se non c'è bisogno di questo, non ti preoccupare.

Ora, su tutto il resto. Sembra che tu abbia le caratteristiche principali che vuoi che il tuo oggetto abbia a portata di mano nella tua definizione __init__, che va bene. Ora è necessario legare in realtà questi valori sul vostro oggetto utilizzando self:

class Particle: 
    def __init__(self, mass, position, velocity, force): 
     self.mass = mass 
     self.position = position 
     self.velocity = velocity 
     self.force = force 

Questo è davvero. È ora possibile accedere a questi valori usando la notazione punto, in questo modo:

mass,pos,vel,f = 0,0,0,0 # just for readability 
p = Particle(mass,pos,vel,f) 
print p.mass, p.position, p.velocity, p.force 

Una delle cose belle che abbiamo uscire da questo è che se chiediamo pitone cosa p è, vi dirà che si tratta di un caso di il tipo Particle, in questo modo:

in [1]: p 
out[1]: <__main__.Particle instance at 0x03E1fE68> 

In teoria, quando si lavora con gli oggetti come questo si vuole che ci sia un "livello di astrazione" tra l'utente ei dati tali che non accedono o manipolare i dati direttamente. Per fare questo, puoi creare funzioni (come hai provato a fare con __getitem__) per mediare le interazioni tra l'utente e i dati attraverso i metodi di classe. Questo è bello, ma spesso non è necessario.

Nel tuo caso più semplice, per aggiornare i valori di questi attributi, si può solo farlo direttamente allo stesso modo in cui li si accede, con la notazione dot:

in [2]: p.mass 
out[2]: 0 

in [3]: p.mass = 2 
in [4]: p.mass 
out[4]: 2 

Potreste aver capito questo già, ma non c'è nulla di magico nella funzione __init__, o anche nella definizione class (in cui dovresti/dovresti generalmente definire la maggior parte degli attributi e dei metodi della tua classe). Alcuni tipi di oggetti sono piuttosto permissivi e ti permettono di aggiungere attributi quando e dove vuoi. Questo può essere conveniente, ma in genere è molto hacky e non è una buona pratica. Non sto suggerendo di farlo, solo dimostrandoti che è possibile.

in [5]: p.newattr ='foobar!' 
in [6]: p.newattr 
out[6]: 'foobar!' 

Strano, vero? Se questo ti fa accapponare la pelle ... beh, forse dovrebbe. Ma è possibile, e chi sono io per dire ciò che puoi o non puoi fare. Quindi questo è un assaggio di come funzionano le classi.

Answer 2

si può semplicemente mettere questa definizione di classe in anticipo prima di usarla. Se si vuole dichiarare, controllare questo sito: http://www.diveintopython.net/getting_to_know_python/declaring_functions.html

Tra l'altro, il problema è simile a questo post: Is it possible to forward-declare a function in Python? e anche questo post: Is it possible to use functions before declaring their body in python?

Answer 3

class Particle: 
    def __init__(self, mass, position, velocity, force): 
     self.mass = mass 
     self.position = position 
     self.velocity = velocity 
     self.force = force 

particle = Particle(1, 2, 3, 4) 
print(particle.mass) # 1 

Se si vuole far finta vostra classe ha proprietà, è possibile utilizzare il @property decoratore:

class Particle: 
    def __init__(self, mass, position, velocity, force): 
     self.mass = mass 
     self.position = position 
     self.velocity = velocity 
     self.force = force 

    @property 
    def acceleration(self): 
     return self.force/self.mass 

particle = Particle(2, 3, 3, 8) 
print(particle.acceleration) # 4.0 

Answer 4

Sembra come collections.namedtuple è quello che stai dopo:

from collections import namedtuple 

Particle = namedtuple('Particle', 'mass position velocity force') 
p = Particle(1, 2, 3, 4) 
print p.velocity 

Answer 5

Se solo bisogno di memorizzare alcuni valori degli attributi (simile ad un linguaggio C struct), si può solo fare:

class myContainer(object): 
    pass # Do nothing 

myContainerObj = myContainer() 
myContainerObj.storedAttrib = 5 
print myContainerObj.storedAttrib