Why are Python s private methods not actually private

Question

Python gives us the ability to create  private  methods and variables within a class by prepending double underscores to the name  like this    myPrivateMethod    How  then  can one explain this      class MyClass          def myPublicMethod self                   print  public method          def   myPrivateMethod self                   print  this is private             obj   MyClass       obj myPublicMethod   public method     obj   myPrivateMethod   Traceback  most recent call last     File     line 1  in  AttributeError  MyClass instance has no attribute    myPrivateMethod      dir obj     MyClass  myPrivateMethod      doc        module      myPublicMethod       obj  MyClass  myPrivateMethod   this is private     What s the deal    I ll explain this a little for those who didn t quite get that       class MyClass          def myPublicMethod self                   print  public method          def   myPrivateMethod self                   print  this is private             obj   MyClass     What I did there is create a class with a public method and a private method and instantiate it   Next  I call its public method       obj myPublicMethod   public method   Next  I try and call its private method       obj   myPrivateMethod   Traceback  most recent call last     File     line 1  in  AttributeError  MyClass instance has no attribute    myPrivateMethod    Everything looks good here  we re unable to call it  It is  in fact   private   Well  actually it isn t  Running dir   on the object reveals a new magical method that python creates magically for all of your  private  methods       dir obj     MyClass  myPrivateMethod      doc        module      myPublicMethod     This new method s name is always an underscore  followed by the class name  followed by the method name       obj  MyClass  myPrivateMethod   this is private     So much for encapsulation  eh   In any case  I d always heard Python doesn t support encapsulation  so why even try  What gives

User · Answer

The phrase commonly used is  we re all consenting adults here    By prepending a single underscore  don t expose  or double underscore  hide   you re telling the user of your class that you intend the member to be  private  in some way   However  you re trusting everyone else to behave responsibly and respect that  unless they have a compelling reason not to  e g  debuggers  code completion    If you truly must have something that is private  then you can implement it in an extension  e g  in C for CPython    In most cases  however  you simply learn the Pythonic way of doing things

User · Answer

Example of private function  import re import inspect  class MyClass        def   init   self            pass      def private function   self             try               function call   inspect stack   1  4  0  strip                  See if the function call has  self   in the begining             matched   re match    self     function call               if not matched                   print  This is Private Function  Go Away                  return         except               print  This is Private Function  Go Away              return            This is the real Function  only accessible inside class           print  Hey  Welcome in to function       def public function   self               i can call private function from inside the class         self private function        End

User · Answer

Important update  Python 3 4   Any identifier of the form   name  at least two leading underscores  at most one trailing underscore  is publicly replaced with  classname  name  where classname is the current class name with leading underscore s  stripped  Therefore    name is private  while  classname  name is public  https   docs python org 3 tutorial classes html tut-private Example class Cat      def   init   self  name  unnamed            self name   name     def   print my name self           print self name                    tom   Cat   tom   print my name    Error tom  Cat  print my name    Prints name

User · Answer

It s just one of those language design choices  On some level they are justified  They make it so you need to go pretty far out of your way to try and call the method  and if you really need it that badly  you must have a pretty good reason   Debugging hooks and testing come to mind as possible applications  used responsibly of course

User · Answer

It s not like you absolutly can t get around privateness of members in any language  pointer arithmetics in C    Reflections in  NET Java    The point is that you get an error if you try to call the private method by accident  But if you want to shoot yourself in the foot  go ahead and do it   Edit  You don t try to secure your stuff by OO-encapsulation  do you

User · Answer

From http   www faqs org docs diveintopython fileinfo private html     Strictly speaking  private methods are   accessible outside their class  just   not easily accessible  Nothing in   Python is truly private  internally    the names of private methods and   attributes are mangled and unmangled   on the fly to make them seem   inaccessible by their given names  You   can access the   parse method of the   MP3FileInfo class by the name    MP3FileInfo  parse  Acknowledge that this is interesting  then promise to   never  ever do it in real code    Private methods are private for a   reason  but like many other things in   Python  their privateness is   ultimately a matter of convention  not   force

User · Answer

The class   stuff naming convention lets the programmer know he isn t meant to access   stuff from outside  The name mangling makes it unlikely anyone will do it by accident   True  you still can work around this  it s even easier than in other languages  which BTW also let you do this   but no Python programmer would do this if he cares about encapsulation

User · Answer

From http   www faqs org docs diveintopython fileinfo private html     Strictly speaking  private methods are   accessible outside their class  just   not easily accessible  Nothing in   Python is truly private  internally    the names of private methods and   attributes are mangled and unmangled   on the fly to make them seem   inaccessible by their given names  You   can access the   parse method of the   MP3FileInfo class by the name    MP3FileInfo  parse  Acknowledge that this is interesting  then promise to   never  ever do it in real code    Private methods are private for a   reason  but like many other things in   Python  their privateness is   ultimately a matter of convention  not   force

User · Answer

Similar behavior exists when module attribute names begin with a single underscore  e g   foo    Module attributes named as such will not be copied into an importing module when using the from  method  e g    from bar import     However  this is a convention and not a language constraint  These are not private attributes  they can be referenced and manipulated by any importer  Some argue that because of this  Python can not implement true encapsulation

User · Answer

When I first came from Java to Python I hated this  It scared me to death   Today it might just be the one thing I love most about Python   I love being on a platform  where people trust each other and don t feel like they need to build impenetrable walls around their code  In strongly encapsulated languages  if an API has a bug  and you have figured out what goes wrong  you may still be unable to work around it because the needed method is private  In Python the attitude is   sure   If you think you understand the situation  perhaps you have even read it  then all we can say is  good luck     Remember  encapsulation is not even weakly related to  security   or keeping the kids off the lawn  It is just another pattern that should be used to make a code base easier to understand

User · Answer

The phrase commonly used is  we re all consenting adults here    By prepending a single underscore  don t expose  or double underscore  hide   you re telling the user of your class that you intend the member to be  private  in some way   However  you re trusting everyone else to behave responsibly and respect that  unless they have a compelling reason not to  e g  debuggers  code completion    If you truly must have something that is private  then you can implement it in an extension  e g  in C for CPython    In most cases  however  you simply learn the Pythonic way of doing things

User · Answer

Similar behavior exists when module attribute names begin with a single underscore  e g   foo    Module attributes named as such will not be copied into an importing module when using the from  method  e g    from bar import     However  this is a convention and not a language constraint  These are not private attributes  they can be referenced and manipulated by any importer  Some argue that because of this  Python can not implement true encapsulation

User · Answer

It s not like you absolutly can t get around privateness of members in any language  pointer arithmetics in C    Reflections in  NET Java    The point is that you get an error if you try to call the private method by accident  But if you want to shoot yourself in the foot  go ahead and do it   Edit  You don t try to secure your stuff by OO-encapsulation  do you

User · Answer

It s just one of those language design choices  On some level they are justified  They make it so you need to go pretty far out of your way to try and call the method  and if you really need it that badly  you must have a pretty good reason   Debugging hooks and testing come to mind as possible applications  used responsibly of course

User · Answer

It s not like you absolutly can t get around privateness of members in any language  pointer arithmetics in C    Reflections in  NET Java    The point is that you get an error if you try to call the private method by accident  But if you want to shoot yourself in the foot  go ahead and do it   Edit  You don t try to secure your stuff by OO-encapsulation  do you

User · Answer

The class   stuff naming convention lets the programmer know he isn t meant to access   stuff from outside  The name mangling makes it unlikely anyone will do it by accident   True  you still can work around this  it s even easier than in other languages  which BTW also let you do this   but no Python programmer would do this if he cares about encapsulation

User · Answer

The name scrambling is used to ensure that subclasses don t accidentally override the private methods and attributes of their superclasses  It s not designed to prevent deliberate access from outside   For example    gt  gt  gt  class Foo object           def   init   self               self   baz   42         def foo self               print self   baz           gt  gt  gt  class Bar Foo           def   init   self               super Bar  self    init                 self   baz   21         def bar self               print self   baz      gt  gt  gt  x   Bar    gt  gt  gt  x foo   42  gt  gt  gt  x bar   21  gt  gt  gt  print x   dict      Bar  baz   21    Foo  baz   42    Of course  it breaks down if two different classes have the same name

User · Answer

The name scrambling is used to ensure that subclasses don t accidentally override the private methods and attributes of their superclasses  It s not designed to prevent deliberate access from outside   For example    gt  gt  gt  class Foo object           def   init   self               self   baz   42         def foo self               print self   baz           gt  gt  gt  class Bar Foo           def   init   self               super Bar  self    init                 self   baz   21         def bar self               print self   baz      gt  gt  gt  x   Bar    gt  gt  gt  x foo   42  gt  gt  gt  x bar   21  gt  gt  gt  print x   dict      Bar  baz   21    Foo  baz   42    Of course  it breaks down if two different classes have the same name

User · Answer

Why are Python s  private  methods not actually private    As I understand it  they can t be private  How could privacy be enforced   The obvious answer is  private members can only be accessed through self   but that wouldn t work - self is not special in Python  it is nothing more than a commonly-used name for the first parameter of a function

User · Answer

The name scrambling is used to ensure that subclasses don t accidentally override the private methods and attributes of their superclasses  It s not designed to prevent deliberate access from outside   For example    gt  gt  gt  class Foo object           def   init   self               self   baz   42         def foo self               print self   baz           gt  gt  gt  class Bar Foo           def   init   self               super Bar  self    init                 self   baz   21         def bar self               print self   baz      gt  gt  gt  x   Bar    gt  gt  gt  x foo   42  gt  gt  gt  x bar   21  gt  gt  gt  print x   dict      Bar  baz   21    Foo  baz   42    Of course  it breaks down if two different classes have the same name

User · Answer

Similar behavior exists when module attribute names begin with a single underscore  e g   foo    Module attributes named as such will not be copied into an importing module when using the from  method  e g    from bar import     However  this is a convention and not a language constraint  These are not private attributes  they can be referenced and manipulated by any importer  Some argue that because of this  Python can not implement true encapsulation

User · Answer

Why are Python s  private  methods not actually private    As I understand it  they can t be private  How could privacy be enforced   The obvious answer is  private members can only be accessed through self   but that wouldn t work - self is not special in Python  it is nothing more than a commonly-used name for the first parameter of a function

User · Answer

With Python 3 4 this is the behaviour    gt  gt  gt  class Foo          def   init   self                   pass         def   privateMethod self                   return 3         def invoke self                   return self   privateMethod      gt  gt  gt  help Foo  Help on class Foo in module   main     class Foo builtins object      Methods defined here           init   self         invoke self         ----------------------------------------------------------------------     Data descriptors defined here           dict           dictionary for instance variables  if defined           weakref           list of weak references to the object  if defined     gt  gt  gt  f   Foo     gt  gt  gt  f invoke    3   gt  gt  gt  f   privateMethod    Traceback  most recent call last      File   lt pyshell 47 gt    line 1  in  lt module gt       f   privateMethod    AttributeError   Foo  object has no attribute    privateMethod    https   docs python org 3 tutorial classes html tut-private     Note that the mangling rules are designed mostly to avoid accidents  it still is possible to access or modify a variable that is considered private  This can even be useful in special circumstances  such as in the debugger    Even if the question is old I hope my snippet could be helpful

User · Answer

From http   www faqs org docs diveintopython fileinfo private html     Strictly speaking  private methods are   accessible outside their class  just   not easily accessible  Nothing in   Python is truly private  internally    the names of private methods and   attributes are mangled and unmangled   on the fly to make them seem   inaccessible by their given names  You   can access the   parse method of the   MP3FileInfo class by the name    MP3FileInfo  parse  Acknowledge that this is interesting  then promise to   never  ever do it in real code    Private methods are private for a   reason  but like many other things in   Python  their privateness is   ultimately a matter of convention  not   force

User · Answer

The class   stuff naming convention lets the programmer know he isn t meant to access   stuff from outside  The name mangling makes it unlikely anyone will do it by accident   True  you still can work around this  it s even easier than in other languages  which BTW also let you do this   but no Python programmer would do this if he cares about encapsulation

User · Answer

The most important concern about private methods and attributes is to tell developers not to call it outside the class and this is encapsulation  one may misunderstand security from encapsulation  when one deliberately uses syntax like that bellow  you mentioned  you do not want encapsulation   obj  MyClass  myPrivateMethod     I have migrated from C  and at first it was weird for me too but after a while I came to the idea that only the way that Python code designers think about OOP is different

User · Answer

Example of private function  import re import inspect  class MyClass        def   init   self            pass      def private function   self             try               function call   inspect stack   1  4  0  strip                  See if the function call has  self   in the begining             matched   re match    self     function call               if not matched                   print  This is Private Function  Go Away                  return         except               print  This is Private Function  Go Away              return            This is the real Function  only accessible inside class           print  Hey  Welcome in to function       def public function   self               i can call private function from inside the class         self private function        End

User · Answer

The phrase commonly used is  we re all consenting adults here    By prepending a single underscore  don t expose  or double underscore  hide   you re telling the user of your class that you intend the member to be  private  in some way   However  you re trusting everyone else to behave responsibly and respect that  unless they have a compelling reason not to  e g  debuggers  code completion    If you truly must have something that is private  then you can implement it in an extension  e g  in C for CPython    In most cases  however  you simply learn the Pythonic way of doing things

User · Answer

Similar behavior exists when module attribute names begin with a single underscore  e g   foo    Module attributes named as such will not be copied into an importing module when using the from  method  e g    from bar import     However  this is a convention and not a language constraint  These are not private attributes  they can be referenced and manipulated by any importer  Some argue that because of this  Python can not implement true encapsulation

User · Answer

The most important concern about private methods and attributes is to tell developers not to call it outside the class and this is encapsulation  one may misunderstand security from encapsulation  when one deliberately uses syntax like that bellow  you mentioned  you do not want encapsulation   obj  MyClass  myPrivateMethod     I have migrated from C  and at first it was weird for me too but after a while I came to the idea that only the way that Python code designers think about OOP is different

User · Answer

When I first came from Java to Python I hated this  It scared me to death   Today it might just be the one thing I love most about Python   I love being on a platform  where people trust each other and don t feel like they need to build impenetrable walls around their code  In strongly encapsulated languages  if an API has a bug  and you have figured out what goes wrong  you may still be unable to work around it because the needed method is private  In Python the attitude is   sure   If you think you understand the situation  perhaps you have even read it  then all we can say is  good luck     Remember  encapsulation is not even weakly related to  security   or keeping the kids off the lawn  It is just another pattern that should be used to make a code base easier to understand

User · Answer

With Python 3 4 this is the behaviour    gt  gt  gt  class Foo          def   init   self                   pass         def   privateMethod self                   return 3         def invoke self                   return self   privateMethod      gt  gt  gt  help Foo  Help on class Foo in module   main     class Foo builtins object      Methods defined here           init   self         invoke self         ----------------------------------------------------------------------     Data descriptors defined here           dict           dictionary for instance variables  if defined           weakref           list of weak references to the object  if defined     gt  gt  gt  f   Foo     gt  gt  gt  f invoke    3   gt  gt  gt  f   privateMethod    Traceback  most recent call last      File   lt pyshell 47 gt    line 1  in  lt module gt       f   privateMethod    AttributeError   Foo  object has no attribute    privateMethod    https   docs python org 3 tutorial classes html tut-private     Note that the mangling rules are designed mostly to avoid accidents  it still is possible to access or modify a variable that is considered private  This can even be useful in special circumstances  such as in the debugger    Even if the question is old I hope my snippet could be helpful

User · Answer

It s not like you absolutly can t get around privateness of members in any language  pointer arithmetics in C    Reflections in  NET Java    The point is that you get an error if you try to call the private method by accident  But if you want to shoot yourself in the foot  go ahead and do it   Edit  You don t try to secure your stuff by OO-encapsulation  do you

User · Answer

Important update  Python 3 4   Any identifier of the form   name  at least two leading underscores  at most one trailing underscore  is publicly replaced with  classname  name  where classname is the current class name with leading underscore s  stripped  Therefore    name is private  while  classname  name is public  https   docs python org 3 tutorial classes html tut-private Example class Cat      def   init   self  name  unnamed            self name   name     def   print my name self           print self name                    tom   Cat   tom   print my name    Error tom  Cat  print my name    Prints name

User · Answer

The name scrambling is used to ensure that subclasses don t accidentally override the private methods and attributes of their superclasses  It s not designed to prevent deliberate access from outside   For example    gt  gt  gt  class Foo object           def   init   self               self   baz   42         def foo self               print self   baz           gt  gt  gt  class Bar Foo           def   init   self               super Bar  self    init                 self   baz   21         def bar self               print self   baz      gt  gt  gt  x   Bar    gt  gt  gt  x foo   42  gt  gt  gt  x bar   21  gt  gt  gt  print x   dict      Bar  baz   21    Foo  baz   42    Of course  it breaks down if two different classes have the same name

User · Answer

From http   www faqs org docs diveintopython fileinfo private html     Strictly speaking  private methods are   accessible outside their class  just   not easily accessible  Nothing in   Python is truly private  internally    the names of private methods and   attributes are mangled and unmangled   on the fly to make them seem   inaccessible by their given names  You   can access the   parse method of the   MP3FileInfo class by the name    MP3FileInfo  parse  Acknowledge that this is interesting  then promise to   never  ever do it in real code    Private methods are private for a   reason  but like many other things in   Python  their privateness is   ultimately a matter of convention  not   force

User · Answer

It s just one of those language design choices  On some level they are justified  They make it so you need to go pretty far out of your way to try and call the method  and if you really need it that badly  you must have a pretty good reason   Debugging hooks and testing come to mind as possible applications  used responsibly of course

User · Answer

The class   stuff naming convention lets the programmer know he isn t meant to access   stuff from outside  The name mangling makes it unlikely anyone will do it by accident   True  you still can work around this  it s even easier than in other languages  which BTW also let you do this   but no Python programmer would do this if he cares about encapsulation

User · Answer

It s just one of those language design choices  On some level they are justified  They make it so you need to go pretty far out of your way to try and call the method  and if you really need it that badly  you must have a pretty good reason   Debugging hooks and testing come to mind as possible applications  used responsibly of course

User · Answer

The phrase commonly used is  we re all consenting adults here    By prepending a single underscore  don t expose  or double underscore  hide   you re telling the user of your class that you intend the member to be  private  in some way   However  you re trusting everyone else to behave responsibly and respect that  unless they have a compelling reason not to  e g  debuggers  code completion    If you truly must have something that is private  then you can implement it in an extension  e g  in C for CPython    In most cases  however  you simply learn the Pythonic way of doing things

[python] Why are Python's 'private' methods not actually private?

Examples related to python

Examples related to python-2.7

Examples related to encapsulation

Examples related to information-hiding