Quelle est la Pythonic façon d'initialiser, de définir et d'obtenir mon personnalisée attributs de l'objet, par son nom?

Je suis assez nouveau à Python et j'ai besoin de faire déclarer ma propre structure de données, je suis un peu confus sur la façon de faire cela. J'ai actuellement:

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

Ce qui ne fonctionne pas, cependant, lorsque j'essaie de définir une instance de la classe:

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

Chaque valeur se termine juste en haut comme un (0.0, 0.0) (qui est la valeur pour la vitesse et la force).

Quelqu'un pourrait-il expliquer d'où je vais mal, je n'ai besoin de la structure de données est de pouvoir extraire les données en dehors de ça, rien d'autre. (edit: en fait, désolé, je vais devoir modifier un peu plus tard)

Grâce

cela fonctionne pour moi comme.
Tous vos __getitem__ définitions sont de la même méthode. Vous devez vérifier ce qui est fait en cours de récupération.
Il ne devrait pas.
Aparté: sur les dimensions de la cohérence des motifs, j'avais store accélération plutôt que la force.
Comment essayer d'accès? La façon dont vous l'a défini, p1[<anything>] retourne self.force. Je suis curieux de savoir comment vous imaginez pour accéder aux différents attributs...

OriginalL'auteur djcmm476 | 2013-03-07

  1. 20

    Tout d'abord, vous devez comprendre que __getitem__ est sucre syntaxique. C'est agréable d'avoir, mais si vous n'en avez pas besoin, ne l'utilisez pas. __getitem__ et __setitem__ sont, fondamentalement, si vous voulez être en mesure d'accéder à des éléments de votre objet à l'aide de support de la notation comme:

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

    si vous n'avez pas besoin de cela, ne vous inquiétez pas à ce sujet.

    Maintenant, sur tout le reste. On dirait que vous avez les principales caractéristiques que vous voulez que votre objet à transporter dans votre __init__ définition, ce qui est bien. Maintenant, vous avez besoin de se lier ces valeurs à votre objet à l'aide de self:

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

    C'est vraiment elle. Vous pouvez désormais accéder à ces valeurs à l'aide de la notation point, comme suit:

    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

    Une des choses intéressantes à nous sortir de cette situation est que si nous demandons python, ce qui p est, il vous dira que c'est un exemple de la Particle type, comme suit:

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

    En théorie, lorsque vous travaillez avec des objets, comme ce que vous voulez qu'il y ait une "couche d'abstraction" entre l'utilisateur et les données telles qu'ils n'ont pas accès ou de manipuler directement les données. Pour ce faire, vous créez des fonctions (comme vous avez essayé de faire avec __getitem__) à la médiation des interactions entre l'utilisateur et les données à travers les méthodes de la classe. C'est sympa, mais pas souvent nécessaire.

    Dans votre cas plus simple, pour mettre à jour les valeurs de ces attributs, vous pouvez le faire directement de la même manière que nous avons consulté, avec la notation point:

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

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

    Vous pourriez avoir compris cela déjà, mais il n'y a rien de magique à propos de la __init__ fonction, ou même la class définition (où vous pourrait/devrait être généralement la définition de la plupart de votre classe, les attributs et méthodes). Certains types d'objets sont assez permissif sur vous permettant d'ajouter des attributs quand et où vous voulez. Cela peut être pratique, mais c'est généralement très hacky et pas une bonne pratique. Je ne suggère pas que vous faites cela, juste vous montrer que c'est possible.

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

    Bizarre droite? Si cela rend votre peau ramper... eh bien, peut-être qu'il devrait. Mais il est possible, et qui suis-je pour dire ce que vous pouvez et ne pouvez pas faire. Donc, c'est un avant-goût de classes.

    C'est génial, merci! Rapide suivi de la question cependant, comment puis-je modifier les valeurs après la création d'une instance de la Particule?
    Affectation, comme avec les variables (il y a quelques différences subtiles, mais la plupart des gens s'entendent pour mois sans les comprendre, de sorte que vous devrait être bon ^^): p.mass = new value
    Cool, merci beaucoup.
    Mis à jour le poste de démo de cession et de vous montrer un peu de la magie noire

    OriginalL'auteur David Marx

  2. 8
    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

    Si vous voulez faire semblant de votre classe possède des propriétés, vous pouvez utiliser le @property décorateur:

    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
    C'est super, merci. Je suis assez nouveau à Python, et j'ai eu du mal à trouver quelque chose de décent pour décrire cela. Comme d'habitude avec Python, la réponse est plus simple que je ne le pensais.
    D'intérêt, pourquoi semblant pour avoir des propriétés, alors qu'en réalité, ayant des propriétés est si facile?
    Supposons qu'une propriété est définie par une formule en s'appuyant sur deux autres propriétés. Si vous modifiez l'un d'entre eux (comme la masse) il faudrait aussi mettre à jour l'accélération. Que signifie probablement le buggy ou le code désordre.
    Je suis un Python vétéran. Quand je dis "bien", je veux dire la property builtin, de préférence utilisé en tant que décorateur. Qui, comme vous le savez ou pas, de faire exactement cela-juste à un meilleur et plus joli.
    Comment aurais-je aller sur le faire, par exemple, l'accélération de la propriété à l'aide de la méthode dont vous parlez?

    OriginalL'auteur Waleed Khan

  3. 4

    Semble collections.namedtuple est ce que vous êtes après:

    from collections import namedtuple

Particle = namedtuple('Particle', 'mass position velocity force')
p = Particle(1, 2, 3, 4)
print p.velocity
    Seulement si les attributs de ne pas avoir à changer au cours de la vie de l'objet, et que vous êtes bien avec elle étant une séquence. La propreté de namedtuples souffre aussi d'un coup lorsque vous avez besoin d'ajouter des méthodes, ou quelque chose de constructeur-like (ils sont toujours utiles, mais nécessitent plus d'attention à la manipulation et laid code pour le faire fonctionner).
    Vrai, mais je vais par les OP de la déclaration de all I need from the data structure is to be able to pull the data out of it, nothing else.
    Ouais, et votre réponse est correcte. C'est juste que je n'ai presque jamais voir ces limitations, même par allusion, même lorsqu'important, j'ai donc pris l'habitude de les mentionner.
    Ah, merde, je vais changer cela. J'ai besoin de modifier un peu par la suite (mon mauvais!).

    OriginalL'auteur Jon Clements

  4. 1

    vous pouvez simplement mettre la définition de cette classe à l'avance avant de l'utiliser. Si vous voulez déclarer, consulter ce site: http://www.diveintopython.net/getting_to_know_python/declaring_functions.html

    Par ailleurs, votre question est similaire à ce post: Est-il possible de déclarer une fonction en Python? et aussi ce post: Est-il possible d'utiliser les fonctions avant de déclarer leurs corps en python?

    OriginalL'auteur tqjustc

  5. 0

    Si vous juste besoin de stocker les valeurs de certains attributs (similaire au langage C struct), il vous suffit de faire:

    class myContainer(object):
    pass  # Do nothing

myContainerObj = myContainer()
myContainerObj.storedAttrib = 5
print myContainerObj.storedAttrib
    Nah, c'est juste une horrible façon de rédiger un dictionnaire. Je suis opposé à l'utilisation de la possibilité d'ajouter et de supprimer des attributs aux objets sans de très bonnes raisons. Il fait des erreurs plus difficile à repérer (parfois cette chose a un attribut, parfois, il n'a pas, en fonction du flux de contrôle).
    Je suis d'accord en général, mais pour quelqu'un de nouveau pour Python, c'est une solution simple et ne nécessite pas la compréhension des dictionnaires, le hachage et la get() méthode. (Il est aussi dans le tutoriel Python docs: docs.python.org/3/tutorial/classes.html#odds-and-ends)
    edit: (insert: "get() méthode pour spécifier une valeur si l'attribut n'existe pas, ou une autre méthode à la sonde, si elle a été définie"). Personnellement, je préfère voir une classe complète avec __init__ et approprié des méthodes get/set pour toutes les propriétés, mais dans mon (peut-être inexacte) avis, il a rencontré l'OP besoins.)

    OriginalL'auteur neilr8133