Quelle est la différence entre la classe et les variables d'instance?

Lorsque vous écrivez une classe de bloc, vous créez attributs de classe (ou de variables de classe). Tous les noms que vous affectez dans la classe du bloc, y compris les méthodes, vous définissez avec def deviennent des attributs de classe.

Après une instance de classe est créée, quoi que ce soit avec une référence à l'instance peut créer une instance attributs sur elle. À l'intérieur des méthodes, le "courant" de l'instance est presque toujours lié à un nom de self, qui est pourquoi vous êtes la pensée de ces comme "variables". Généralement dans la conception orientée objet, le code associé à une classe qui est censé avoir le contrôle sur les attributs des instances de cette classe, donc presque tous instance d'affectation d'attribut est fait à l'intérieur des méthodes, à l'aide de la référence de l'instance a reçu dans le self paramètre de la méthode.

Attributs de classe sont souvent comparés à des statique variables (ou les méthodes), comme l'a constaté dans des langages comme Java, C# ou C++. Toutefois, si vous voulez viser pour une meilleure compréhension, je voudrais éviter de penser à des attributs de classe comme "la même" que les variables statiques. Alors qu'ils sont souvent utilisés pour les mêmes fins, le concept sous-jacent est tout à fait différent. Plus à ce sujet dans la section "avancé" en dessous de la ligne.

Un exemple!

class SomeClass:
    def __init__(self):
        self.foo = 'I am an instance attribute called foo'
        self.foo_list = []

    bar = 'I am a class attribute called bar'
    bar_list = []

Après l'exécution de ce bloc, il y a une classe SomeClass, avec 3 attributs de classe: __init__, bar, et bar_list.

Ensuite, nous allons créer une instance:

instance = SomeClass()

Lorsque cela se produit, SomeClass's __init__ méthode est exécutée, la réception de la nouvelle instance dans son self paramètre. Cette méthode crée deux attributs d'instance: foo et foo_list. Ensuite, cette instance est attribué dans le instance variable, il est donc lié à une chose avec ces deux attributs d'instance: foo et foo_list.

Mais:

print instance.bar

donne:

I am a class attribute called bar

Comment est-ce arrivé? Quand nous essayons de récupérer un attribut par le biais de la syntaxe à point, et l'attribut n'existe pas, Python va à travers un tas de mesures pour tenter de répondre à votre demande de toute façon. La prochaine chose qu'il va faire est d'essayer de regarder la attributs de classe de la classe de votre instance. Dans ce cas, il a trouvé un attribut bar dans SomeClass, de sorte qu'il ne revienne.

Qui est aussi la façon dont les appels de méthode de travail par la voie. Lorsque vous appelez mylist.append(5), par exemple, mylist ne pas avoir un attribut nommé append. Mais le classe de mylist fait, et il est lié à une méthode de l'objet. Cette méthode de l'objet renvoyé par le mylist.append peu, et puis le (5) bits appelle la méthode avec l'argument 5.

La façon dont cela est utile, c'est que tous instances de SomeClass auront accès à la même bar attribut. On pourrait créer un million de cas, mais nous avons seulement besoin de stocker une chaîne de caractères en mémoire, car ils peuvent tous trouver.

Mais vous devez être un peu prudent. Jetez un oeil à l'une des opérations suivantes:

sc1 = SomeClass()
sc1.foo_list.append(1)
sc1.bar_list.append(2)

sc2 = SomeClass()
sc2.foo_list.append(10)
sc2.bar_list.append(20)

print sc1.foo_list
print sc1.bar_list

print sc2.foo_list
print sc2.bar_list

Que pensez-vous de cette affiche?

[1]
[2, 20]
[10]
[2, 20]

C'est parce que chaque instance possède sa propre copie de foo_list, de sorte qu'ils ont été ajoutés séparément. Mais tous instances de partager l'accès à la même bar_list. Alors, quand nous avons fait sc1.bar_list.append(2) il a touché sc2, même si sc2 n'existent pas encore! Et de même sc2.bar_list.append(20) affecté la bar_list récupérés par le biais d' sc1. Ce n'est souvent pas ce que vous voulez.

---

Avancée de l'étude qui suit. 🙂

Vraiment grok Python, venant de la traditionnelle statiquement typé OO-langages comme Java et C#, vous devez apprendre à repenser les classes un peu.

En Java, une classe n'est pas vraiment un chose dans son propre droit. Lorsque vous écrivez une classe que vous avez plus de déclarer un tas de choses que toutes les instances de cette classe ont en commun. Au moment de l'exécution, il n'y a qu'cas (et statique méthodes/variables, mais ceux qui sont vraiment juste des variables globales et des fonctions dans un espace de noms associé à une classe, rien à voir avec OO vraiment). Les Classes sont la façon dont vous écrivez dans votre code source que le cas sera, comme au moment de l'exécution; ils "existent" dans votre code source, non pas dans le programme en cours d'exécution.

En Python, une classe est rien de spécial. C'est un objet tout comme toute autre chose. Ainsi, "les attributs de classe" sont en fait exactement la même chose qu'une "instance attributs"; en réalité, il est juste "attributs". La seule raison de faire une distinction, c'est que nous avons tendance à utilisation objets qui sont des classes différemment à partir d'objets qui ne sont pas des classes. Le sous-jacentes de la machinerie est tout de même. C'est pourquoi je dis qu'il serait une erreur de penser d'attributs de classe en tant que variables statiques à partir d'autres langues.

Mais ce qui le rend vraiment classes Python différent de Java-classes de style, c'est que comme tout autre objet chaque classe est une instance de la classe!

En Python, la plupart des classes sont des instances d'un builtin classe appelée type. C'est cette classe qui contrôle le comportement commun de classes, et fait tous les trucs OO la façon dont il le fait. La valeur par défaut OO façon d'avoir des instances de classes qui ont leurs propres attributs, et ont en commun les mêmes méthodes/attributs définis par leur classe, c'est juste un protocole en Python. Vous pouvez modifier la plupart des aspects de celui-ci si vous le souhaitez. Si vous avez jamais entendu parler de l'aide d'un métaclasse, tout ce qui est est la définition d'une classe qui est une instance d'une classe différente de celle type.

Le seul vraiment "spécial" chose à propos de classes (en dehors de toutes les builtin machines pour les faire travailler de la façon dont ils le font par défaut), c'est la classe bloc de syntaxe, pour le rendre plus facile pour vous de créer des instances de type. Ce:

class Foo(BaseFoo):
    def __init__(self, foo):
        self.foo = foo

    z = 28

est à peu près équivalente à la suivante:

def __init__(self, foo):
    self.foo = foo

classdict = {'__init__': __init__, 'z': 28 }

Foo = type('Foo', (BaseFoo,) classdict)

Et il se chargera de tout le contenu de classdict à devenir des attributs de l'objet qui est créé.

Alors il devient presque banal de voir que vous pouvez accéder à un attribut de classe par Class.attribute aussi facilement que i = Class(); i.attribute. Les deux i et Class sont des objets, et les objets ont des attributs. Cela le rend aussi facile à comprendre comment vous pouvez modifier une classe après qu'il a été créé; il suffit de céder ses attributs de la même manière que vous le feriez avec tout autre objet!

En fait, des cas ont aucune relation spéciale avec la classe utilisée pour les créer. La façon Python sait ce qui la classe à la recherche pour les attributs qui ne sont pas trouvés dans l'instance est par hidden __class__ attribut. Que vous pouvez lire pour savoir ce que cette classe est une instance de l', tout comme avec n'importe quel autre attribut: c = some_instance.__class__. Vous avez maintenant une variable c lié à une classe, même si elle n'a sans doute pas le même nom que la classe. Vous pouvez l'utiliser pour accéder à des attributs de classe, ou même de l'appeler à créer plusieurs instances de celui-ci (même si vous ne savez pas dans quelle classe il est!).

Et vous pouvez même attribuer à i.__class__ de changement dans quelle classe il est une instance de! Si vous faites cela, rien de particulier ne se produit immédiatement. Ce n'est pas fracassant. Tout ce que cela signifie est que lorsque vous regardez les attributs qui n'existent pas dans l'instance, Python allez voir le nouveau contenu de __class__. Depuis que comprend la plupart des méthodes, et des méthodes s'attendent généralement à ce que l'instance ils fonctionnent à être dans certains états, il en résulte généralement dans les erreurs, si vous le faites au hasard, et il est très déroutant, mais il peut être fait. Si vous êtes très prudent, la chose que vous stockez dans __class__ n'ont même pas à être un objet de classe; tous les Python va faire, c'est de rechercher des attributs dans certaines circonstances, de sorte que tous vous avez besoin est un objet qui a le bon type d'attributs (certaines mises en garde de côté où Python est pointilleux sur les choses des classes ou des instances d'une classe particulière).

C'est probablement assez pour l'instant. Si tout va bien (si vous avez même lu jusqu'ici) je n'ai pas confondu vous trop. Python est soigné lorsque vous apprendre comment il fonctionne. 🙂