Calling private function within the same class python

Question

How can I call a private function from some other function within the same class?

class Foo:
  def __bar(arg):
    #do something
  def baz(self, arg):
    #want to call __bar

Right now, when I do this:

__bar(val)

from baz(), I get this:

NameError: global name '_Foo__createCodeBehind' is not defined

Can someone tell me what the reason of the error is? Also, how can I call a private function from another private function?

It does not actually matter here that the function is "private" (this is not real privacy anyway). The problem should have been obvious, anyway: where the code says `def baz(self, arg):`, *why does it not* say `def baz(arg):`? Now, why wouldn't the same logic apply to `__bar`? — Karl Knechtel, Sep 05 '22 at 10:16

Rob Wouters · Accepted Answer · 2012-02-04T23:35:30.470

There is no implicit this-> in Python like you have in C/C++ etc. You have to call it on self.

class Foo:
     def __bar(self, arg):
         #do something
     def baz(self, arg):
         self.__bar(arg)

These methods are not really private though. When you start a method name with two underscores Python does some name mangling to make it "private" and that's all it does, it does not enforce anything like other languages do. If you define __bar on Foo, it is still accesible from outside of the object through Foo._Foo__bar. E.g., one can do this:

f = Foo()
f._Foo__bar('a')

This explains the "odd" identifier in the error message you got as well.

You can find it here in the docs.

senderle · Answer 2 · 2019-06-19T11:30:27.487

__bar is "private" (in the sense that its name has been mangled), but it's still a method of Foo, so you have to reference it via self and pass self to it. Just calling it with a bare __bar() won't work; you have to call it like so: self.__bar(). So...

>>> class Foo(object):
...   def __bar(self, arg):
...     print '__bar called with arg ' + arg
...   def baz(self, arg):
...     self.__bar(arg)
... 
>>> f = Foo()
>>> f.baz('a')
__bar called with arg a

You can access self.__bar anywhere within your Foo definition, but once you're outside the definition, you have to use foo_object._Foo__bar(). This helps avoid namespace collisions in the context of class inheritance.

If that's not why you're using this feature, you might reconsider using it. The convention for creating "private" variables and methods in Python is to prepend an underscore to the name. This has no syntactic significance, but it conveys to users of your code that the variable or method is part of implementation details that may change.

Calling private function within the same class python

2 Answers2

Linked