Informazioni sul conteggio dei riferimenti della variabile di classe

Question

Questo è un tentativo di comprendere meglio come funziona il conteggio dei riferimenti in Python.

Creiamo un corso e lo istanziamo. conteggio di riferimento del grado sarebbe 1 (getrefcount display 2 perché è proprie strutture interne riferimento che un'istanza di classe aumentare conteggio di riferimento da 1):

>>> from sys import getrefcount as grc 
>>> class A(): 
    def __init__(self): 
     self.x = 100000 


>>> a = A() 
>>> grc(a) 
2 

s' a variabili interne x dispone 2 riferimenti:

>>> grc(a.x) 
3 

Mi aspettavo che fosse referenziato dal a e dal metodo __init__A. Quindi ho deciso di controllare.

Così ho creato una variabile temporanea b nello spazio dei nomi __main__ solo per poter accedere alla variabile x. E 'aumentato il ref-numero per 1 per farlo diventare 3 (come previsto):

>>> b = a.x 
>>> grc(a.x) 
4 

Poi ho cancellato l'istanza della classe e il conteggio ref diminuito del 1:

>>> del a 
>>> grc(b) 
3 

Così ora ci sono 2 riferimenti: uno è di b e uno è di A (come mi aspettavo).

Eliminando lo spazio dei nomi A da __main__, il conteggio diminuirà di 1.

>>> del A 
>>> grc(b) 
3 

Ma non succede. Non esiste una classe A o le sue istanze che possono fare riferimento a 100000, ma è comunque referenziata da qualcosa di diverso da b nello spazio dei nomi __main__.

Quindi, la mia domanda è, che cos'è 100000 a cui si fa riferimento a parte da b?

---

BrenBarn ha suggerito che dovrei usare object() invece di un numero che può essere memorizzato da qualche parte internamente.

>>> class A(): 
    def __init__(self): 
     self.x = object() 


>>> a = A() 
>>> b = a.x 
>>> grc(a.x) 
3 
>>> del a 
>>> grc(b) 
2 

Dopo aver eliminato l'istanza a c'erano solo riferimento da b che è molto logico.

L'unica cosa che rimane da capire è il motivo per cui non è così con il numero 100000.

Answer 1

a.x è l'intero 10000. Questa costante fa riferimento all'oggetto codice corrispondente al metodo __init__() di A. oggetti di codice sono sempre comprensivi di riferimenti a tutte le costanti letterali nel codice:

>>> def f(): return 10000 
>>> f.__code__.co_consts 
(None, 10000) 

La linea

del A 

elimina solo il nome A e diminuisce il conteggio dei riferimenti di A. In Python 3.x (ma non in 2.x), le classi spesso includono alcuni riferimenti ciclici e quindi sono solo garbage collection quando si esegue esplicitamente il garbage collector. E in effetti, usando

import gc 
gc.collect() 

dopo del A consentono di giungere alla riduzione del numero di riferimento di b.

Answer 2

È probabile che si tratti di un artefatto in cui si utilizza un numero intero come valore di test. Python a volte memorizza oggetti interi per riutilizzarli in seguito, perché sono immutabili. Quando eseguo il tuo codice utilizzando invece self.x = object() (che creerà sempre un oggetto nuovo di zecca per x), ricevo grc(b)==2 alla fine.