when you code in many languages, you usually need to dig a bit to find answers to questions that are not immediately obvious in a specific language. Mine was whether closures can simulate real private variables in python (i.e that really can’t be accessed as opposed to the __ mangling method).
I decided to test if this would work with closures, as shown below
def outer(a,b):
class this:
pass
#--------------------------
# real private variables and methods go here
this.a = a
this.b = b
def sum_():
return this.a + this.b
def product_():
return this.a * this.b
def set_nums_(a, b):
this.a, this.b = a, b
#--------------------------
# public variables and methods go here
class inner:
def get_nums(self):
return this.a, this.b
def set_nums(self, a, b):
set_nums_(a,b)
def sum(self):
return sum_()
def product(self):
return product_()
return inner()
and the result:
>>> x = outer(5,3)
>>> x.get_nums()
(5, 3)
>>> x.set_nums(5,4)
>>> x.get_nums()
(5, 4)
>>> x.product()
20
>>> x
<__main__.outer..inner object at 0x0000023C581E21C0>
>>>
Yay! seems like it works.
Of course, a bit of further digging showed that every python object has the __closure__ property through which you can access the closure for that object, and changing the values of the “private” variables above (bypassing the set_nums method) just becomes a matter of:
>>> loophole = x.sum.__closure__[0].cell_contents.__closure__[0].cell_contents
>>> loophole
<class '__main__.outer.<locals>.this'>
>>> loophole.a = 8
>>> loophole.b = 9
>>> x.get_nums()
(8, 9)
>>>