API Python C, conteggio di riferimento elevato per nuovo oggetto

Question

Sto solo cercando di capire come gestire i conteggi di riferimento quando si utilizza l'API Python C.

voglio chiamare una funzione Python in C++, in questo modo:

PyObject* script; 
PyObject* scriptRun; 
PyObject* scriptResult; 

// import module 
script = PyImport_ImportModule("pythonScript"); 
// get function objects 
scriptRun = PyObject_GetAttrString(script, "run"); 
// call function without/empty arguments 
scriptResult = PyObject_CallFunctionObjArgs(scriptRun, NULL); 

if (scriptResult == NULL) 
    cout << "scriptResult = null" << endl; 
else 
    cout << "scriptResult != null" << endl; 

cout << "print reference count: " << scriptResult->ob_refcnt << endl; 

codice

Il Python in pythonScript.py è molto semplice:

def run(): 
    return 1 

La documentazione di "PyObject_CallFunctionObjArgs" afferma che ottieni un nuovo riferimento come valore di ritorno. Quindi mi aspetterei "scriptResult" per avere un conteggio di riferimento del 1. Tuttavia l'output è:

scriptResult != null 
print reference count: 72 

Inoltre mi si aspetterebbe una perdita di memoria se vorrei farlo in un ciclo senza diminuire il conteggio dei riferimenti. Tuttavia questo sembra non accadere.

Qualcuno potrebbe aiutarmi a capire?

Cordiali saluti!

Answer 1

ecatmur è corretto, i numeri e le stringhe sono internati in Python, quindi invece puoi provare con un semplice oggetto object().

Un semplice demo con gc:

import gc 


def run(): 
    return 1 

s = run() 
print len(gc.get_referrers(s)) # prints a rather big number, 41 in my case 

obj = object() 
print len(gc.get_referrers(obj)) # prints 1 

lst = [obj] 
print len(gc.get_referrers(obj)) # prints 2 

lst = [] 
print len(gc.get_referrers(obj)) # prints 1 again 

---

Un po 'di più: quando CPython crea un nuovo oggetto, che definisce un C macro _Py_NewReference per inizializzare il conteggio dei riferimenti a 1. Poi usa Py_INCREF(op) e Py_DECREF(op) per aumentare e diminuire il conteggio dei riferimenti.

Answer 2

La confusione è che piccoli interi (anche True, False, None, stringhe singolo carattere, etc.) sono internati ("is" operator behaves unexpectedly with integers), il che significa che ovunque siano utilizzati o ottenuti in un programma runtime proverà di utilizzare la stessa istanza oggetto:

>>> 1 is 1 
True 
>>> 1 + 1 is 2 
True 
>>> 1000 + 1 is 1001 
False 

Ciò significa che quando si scrive return 1, stai tornando un'istanza int oggetto già esistente con (come avete visto) un considerevole numero di riferimento. Poiché la stessa istanza viene utilizzata altrove, non riuscendo a dereferenziare non si verificherà una perdita di memoria.

Se si modifica lo script in return 1001 o return object(), verrà visualizzato un conteggio iniziale di 1 e una perdita di memoria.