He luchado recientemente contra un error en Python. Fue uno de esos errores tontos para novatos, pero me hizo pensar en los mecanismos de Python (soy un programador de C ++ desde hace mucho tiempo, nuevo en Python). Diseñaré el código con errores y explicaré lo que hice para solucionarlo, y luego tengo un par de preguntas ...

El escenario: tengo una clase llamada A, que tiene un miembro de datos de diccionario, el siguiente es su código (esto es simplificación, por supuesto):

class A:
    dict1={}

    def add_stuff_to_1(self, k, v):
        self.dict1[k]=v

    def print_stuff(self):
        print(self.dict1)

La clase que usa este código es la clase B:

class B:

    def do_something_with_a1(self):
        a_instance = A()
        a_instance.print_stuff()        
        a_instance.add_stuff_to_1('a', 1)
        a_instance.add_stuff_to_1('b', 2)    
        a_instance.print_stuff()

    def do_something_with_a2(self):
        a_instance = A()    
        a_instance.print_stuff()            
        a_instance.add_stuff_to_1('c', 1)
        a_instance.add_stuff_to_1('d', 2)    
        a_instance.print_stuff()

    def do_something_with_a3(self):
        a_instance = A()    
        a_instance.print_stuff()            
        a_instance.add_stuff_to_1('e', 1)
        a_instance.add_stuff_to_1('f', 2)    
        a_instance.print_stuff()

    def __init__(self):
        self.do_something_with_a1()
        print("---")
        self.do_something_with_a2()
        print("---")
        self.do_something_with_a3()

bserve que cada llamada ado_something_with_aX() inicializa una nueva instancia "limpia" de clase A e imprime el diccionario antes y después de la adición.

El error (en caso de que aún no lo haya resuelto):

>>> b_instance = B()
{}
{'a': 1, 'b': 2}
---
{'a': 1, 'b': 2}
{'a': 1, 'c': 1, 'b': 2, 'd': 2}
---
{'a': 1, 'c': 1, 'b': 2, 'd': 2}
{'a': 1, 'c': 1, 'b': 2, 'e': 1, 'd': 2, 'f': 2}

En la segunda inicialización de la clase A, los diccionarios no están vacíos, sino que comienzan con el contenido de la última inicialización, y así sucesivamente. Esperaba que comenzaran "frescas".

Lo que resuelve este "error" obviamente está agregando:

self.dict1 = {}

En el__init__ constructor de clase A. Sin embargo, eso me hizo preguntarme:

¿Cuál es el significado de la inicialización "dict1 = {}" en el punto de la declaración de dict1 (primera línea en la clase A)? ¿No tiene sentido? ¿Cuál es el mecanismo de instanciación que hace que se copie la referencia de la última inicialización?Si agrego "self.dict1 = {}" en el constructor (o cualquier otro miembro de datos), ¿cómo no afecta al miembro del diccionario de instancias inicializadas previamente?

EDIT: Siguiendo las respuestas ahora entiendo que al declarar un miembro de datos y no hacer referencia a él en el__init__ o en otro lugar como self.dict1, prácticamente estoy definiendo lo que se llama en C ++ / Java un miembro de datos estáticos. Al llamarlo self.dict1 lo estoy haciendo "vinculado a la instancia".