In computer science, reference counting is a programming technique of storing the number of references, pointers, or handles to a resource, such as an object, a block of memory, disk space, and others. In garbage collection algorithms, reference counts may be used to deallocate objects that are no longer needed.
Reference counting deallocates objects sooner than garbage collection. But as reference counting can't handle reference cycles between unreachable objects, Python uses a garbage collector (really just a cycle collector) to collect those cycles when they exist.
getrefcount(number) basically means that number is used in your current code but isn't used anywhere else in Python. So based on our experiments above, it looks like the integer 24601 isn't used anywhere by default in Python.
According to the Python documentation, the sys
module contains a function:
import sys
sys.getrefcount(object) #-- Returns the reference count of the object.
Generally 1 higher than you might expect, because of object arg temp reference.
Using the gc
module, the interface to the garbage collector guts, you can call gc.get_referrers(foo)
to get a list of everything referring to foo
.
Hence, len(gc.get_referrers(foo))
will give you the length of that list: the number of referrers, which is what you're after.
See also the gc
module documentation.
There is gc.get_referrers()
and sys.getrefcount()
. But, It is kind of hard to see how sys.getrefcount(X)
could serve the purpose of traditional reference counting. Consider:
import sys
def function(X):
sub_function(X)
def sub_function(X):
sub_sub_function(X)
def sub_sub_function(X):
print sys.getrefcount(X)
Then function(SomeObject)
delivers '7', sub_function(SomeObject)
delivers '5', sub_sub_function(SomeObject)
delivers '3', and sys.getrefcount(SomeObject)
delivers '2'.
In other words: If you use sys.getrefcount()
you must be aware of the function call depth. For gc.get_referrers()
one might have to filter the list of referrers.
I would propose to do manual reference counting for purposes such as “isolation on change”, i.e. “clone if referenced elsewhere”.
import ctypes
my_var = 'hello python'
my_var_address = id(my_var)
ctypes.c_long.from_address(my_var_address).value
ctypes
takes address of the variable as an argument.
The advantage of using ctypes
over sys.getRefCount
is that you need not subtract 1 from the result.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With