What is the meaning of single and double underscore before an object name

Question

Can someone please explain the exact meaning of having leading underscores before an object s name in Python  and the difference between both   Also  does that meaning stay the same whether the object in question is a variable  a function  a method  etc

User · Answer

Great answers and all are correct I have provided simple example along with simple definition meaning    Meaning   some variable --  it s public anyone can see this    some variable --  it s public anyone can see this but it s a convention to indicate private   warning no enforcement is done by Python     some varaible  --  Python replaces the variable name with  classname  some varaible  AKA name mangling  and it reduces hides it s visibility and be more like private variable   Just to be honest here According to Python documentation          Private    instance variables that cannot be accessed except from   inside an object don   t exist in Python    The example   class A        here  abc       here   abc        here    abc    aObject A   print aObject here   print aObject  here    now if we try to print   here then it will fail because it s not public variable   print aObject   here

User · Answer

Sometimes you have what appears to be a tuple with a leading underscore as in   def foo bar       return    my     bar    In this case  what s going on is that     is an alias for a localization function that operates on text to put it into the proper language  etc  based on the locale  For example  Sphinx does this  and you ll find among the imports  from sphinx locale import l       and in sphinx locale      is assigned as an alias of some localization function

User · Answer

Single underscore at the beginning   Python doesn t have real private methods  Instead  one underscore at the start of a method or attribute name means you shouldn t access this method  because it s not part of the API   class BaseForm StrAndUnicode        def  get errors self            Returns an ErrorDict for the data provided for the form          if self  errors is None              self full clean           return self  errors      errors   property  get errors     This code snippet was taken from django source code  django forms forms py   In this code  errors is a public property  but the method this property calls   get errors  is  private   so you shouldn t access it   Two underscores at the beginning   This causes a lot of confusion  It should not be used to create a private method  It should be used to avoid your method being overridden by a subclass or accessed accidentally  Let s see an example   class A object       def   test self           print  I m a test method in class A       def test self           self   test    a   A   a test     a   test     This fails with an AttributeError a  A  test     Works  We can access the mangled name directly    Output      python test py I m test method in class A I m test method in class A   Now create a subclass B and do customization for   test method  class B A       def   test self           print  I m test method in class B   b   B   b test     Output will be        python test py I m test method in class A   As we have seen  A test   didn t call B   test   methods  as we might expect  But in fact  this is the correct behavior for     The two methods called   test   are automatically renamed  mangled  to  A  test   and  B  test    so they do not accidentally override   When you create a method starting with    it means that you don t want to anyone to be able to override it  and you only intend to access it from inside its own class   Two underscores at the beginning and at the end   When we see a method like   this    don t call it  This is a method which python is meant to call  not you  Let s take a look    gt  gt  gt  name    test string   gt  gt  gt  name   len     11  gt  gt  gt  len name  11   gt  gt  gt  number   10  gt  gt  gt  number   add   40  50  gt  gt  gt  number   50 60   There is always an operator or native function which calls these magic methods  Sometimes it s just a hook python calls in specific situations  For example   init     is called when the object is created after   new     is called to build the instance     Let s take an example     class FalseCalculator object        def   init   self  number           self number   number      def   add   self  number           return self number - number      def   sub   self  number           return self number   number  number   FalseCalculator 20  print number   10        10 print number - 20        40   For more details  see the PEP-8 guide  For more magic methods  see this PDF

User · Answer

Here is a simple illustrative example on how double underscore properties can affect an inherited class  So with the following setup   class parent object         default    parent      def   init   self  name None           self default   name or self   default       property     def default self           return self   default       default setter     def default self  value           self   default   value   class child parent         default    child    if you then create a child instance in the python REPL  you will see the below  child a   child   child a default               parent  child a  child  default       child  child a  parent  default      parent   child b   child  orphan      this will show  child b default               orphan  child a  child  default       child  child a  parent  default      orphan    This may be obvious to some  but it caught me off guard in a much more complex environment

User · Answer

Single leading underscores is a convention  there is no difference from the interpreter s point of view if whether names starts with a single underscore or not    Double leading and trailing underscores are used for built-in methods  such as   init      bool    etc   Double leading underscores w o trailing counterparts are a convention too  however  the class methods will be mangled by the interpreter  For variables or basic function names no difference exists

User · Answer

In the case of methods  you can use the double underscore to hide away private  methods  with the following pattern    Private methods of MyClass def  MyClass  do something obj  MyClass        print   MyClass  do something   called  type obj        format type obj     class MyClass        def   init   self             do something self   mc   MyClass    Output   MyClass  do something   called  type obj     lt class    main   MyClass  gt   I stumbled across this today when I tried using double underscore for class methods and got the NameError  name    lt class gt  lt method gt   is not defined error

User · Answer

Your question is good  it is not only about methods  Functions and objects in modules are commonly prefixed with one underscore as well  and can be prefixed by two   But   double underscore names are not name-mangled in modules  for example  What happens is that names beginning with one  or more  underscores are not imported if you import all from a module  from module import     nor are the names shown in help module

User · Answer

Private    instance variables that cannot be accessed except from inside an object don   t exist in Python  However  there is a convention that is followed by most Python code  a name prefixed with an underscore  e g   spam  should be treated as a non-public part of the API  whether it is a function  a method or a data member   It should be considered an implementation detail and subject to change without notice   reference https   docs python org 2 tutorial classes html private-variables-and-class-local-references

User · Answer

Accroding to https   dbader org blog meaning-of-underscores-in-python   Single Leading Underscore  var   Naming convention indicating a name is meant for internal use  Generally not enforced by the Python interpreter  except in wildcard imports  and meant as a hint to the programmer only  Single Trailing Underscore var    Used by convention to avoid naming conflicts with Python keywords  Double Leading Underscore   var   Triggers name mangling when used in a class context  Enforced by the Python interpreter  Double Leading and Trailing Underscore   var     Indicates special methods defined by the Python language  Avoid this naming scheme for your own attributes  Single Underscore     Sometimes used as a name for temporary or insignificant variables     don   t care      Also  The result of the last expression in a Python REPL

User · Answer

variable is semiprivate and meant just for convention     variable is often incorrectly considered superprivate  while it s actual meaning is just to namemangle to prevent accidental access 1      variable   is typically reserved for builtin methods or variables  You can still access    mangled variables if you desperately want to  The double underscores just namemangles  or renames  the variable to something like instance  className  mangled  Example   class Test object       def   init   self           self   a    a          self  b    b    gt  gt  gt  t   Test    gt  gt  gt  t  b  b    t  b is accessible because it is only hidden by convention   gt  gt  gt  t   a Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  AttributeError   Test  object has no attribute    a    t   a isn t found because it no longer exists due to namemangling   gt  gt  gt  t  Test  a  a    By accessing instance  className  variable instead of just the double underscore name  you can access the hidden value

User · Answer

foo    this is just a convention  a way for the Python system to use names that won t conflict with user names    foo  this is just a convention  a way for the programmer to indicate that the variable is private  whatever that means in Python      foo  this has real meaning  the interpreter replaces this name with  classname  foo as a way to ensure that the name will not overlap with a similar name in another class   No other form of underscores have meaning in the Python world   There s no difference between class  variable  global  etc in these conventions

User · Answer

Excellent answers so far but some tidbits are missing  A single leading underscore isn t exactly just a convention  if you use from foobar import    and module foobar does not define an   all   list  the names imported from the module do not include those with a leading underscore  Let s say it s mostly a convention  since this case is a pretty obscure corner -    The leading-underscore convention is widely used not just for private names  but also for what C   would call protected ones -- for example  names of methods that are fully intended to be overridden by subclasses  even ones that have to be overridden since in the base class they raise NotImplementedError -  are often single-leading-underscore names to indicate to code using instances of that class  or subclasses  that said methods are not meant to be called directly   For example  to make a thread-safe queue with a different queueing discipline than FIFO  one imports Queue  subclasses Queue Queue  and overrides such methods as  get and  put   client code  never calls those   hook   methods  but rather the   organizing   public methods such as put and get  this is known as the Template Method design pattern -- see e g  here for an interesting presentation based on a video of a talk of mine on the subject  with the addition of synopses of the transcript    Edit  The video links in the description of the talks are now broken  You can find the first two videos here and here

User · Answer

var  variables with a leading single underscore in python are classic variables  intended to inform others using your code that this variable should be reserved for internal use  They differ on one point from classic variables  they are not imported when doing a wildcard import of an object module where they are defined  exceptions when defining the   all   variable   Eg    foo py  var    quot var quot   var    quot  var quot     bar py  from foo import    print dir       list of defined objects  contains  var  but not   var  print var       var print  var      NameError  name   var  is not defined       the single underscore is a special case of the leading single underscore variables  It is used by convention as a trash variable  to store a value that is not intended to be later accessed  It is also not imported by wildcard imports  Eg  this for loop prints  quot I must not talk in class quot  10 times  and never needs to access the   variable  for   in range 10       print  quot I must not talk in class quot       var  double leading underscore variables  at least two leading underscores  at most one trailing underscore   When used as class attributes  variables and methods   these variables are subject to name mangling  outside of the class  python will rename the attribute to   lt Class name gt    lt attribute name gt   Example  class MyClass        an attribute    quot attribute value quot   my class   MyClass   print my class  MyClass  an attribute      quot attribute value quot  print my class   an attribute     AttributeError   MyClass  object has no attribute    an attribute   When used as variables outside a class  they behave like single leading underscore variables     var    double leading and trailing underscore variables  at least two leading and trailing underscores   Also called dunders  This naming convention is used by python to define variables internally  Avoid using this convention to prevent name conflicts that could arise with python updates  Dunder variables behave like single leading underscore variables  they are not subject to name mangling when used inside classes  but are not imported in wildcard imports

User · Answer

Since so many people are referring to Raymond s talk  I ll just make it a little easier by writing down what he said      The intention of the double underscores was not about privacy  The intention was to use it exactly like this  class Circle object        def   init   self  radius           self radius   radius      def area self           p   self   perimeter           r   p   math pi   2 0         return math pi   r    2 0      def perimeter self           return 2 0   math pi   self radius        perimeter   perimeter    local reference   class Tire Circle        def perimeter self           return Circle perimeter self    1 25       It s actually the opposite of privacy  it s all about freedom  It makes your subclasses free to override any one method without breaking the others    Say you don t keep a local reference of perimeter in Circle  Now  a derived class Tire overrides the implementation of perimeter  without touching area  When you call Tire 5  area    in theory it should still be using Circle perimeter for computation  but in reality it s using Tire perimeter  which is not the intended behavior  That s why we need a local reference in Circle   But why   perimeter instead of  perimeter  Because  perimeter still gives derived class the chance to override   class Tire Circle        def perimeter self           return Circle perimeter self    1 25       perimeter   perimeter   Double underscores has name mangling  so there s a very little chance that the local reference in parent class get override in derived class  thus  makes your subclasses free to override any one method without breaking the others    If your class won t be inherited  or method overriding does not break anything  then you simply don t need   double leading underscore

User · Answer

If one really wants to make a variable read-only  IMHO the best way would be to use property   with only getter passed to it  With property   we can have complete control over the data   class PrivateVarC object        def get x self           pass      def set x self  val           pass      rwvar   property get p  set p         ronly   property get p     I understand that OP asked a little different question but since I found another question asking for  how to set private variables  marked duplicate with this one  I thought of adding this additional info here

User · Answer

Getting the facts of   and    is pretty easy  the other answers express them pretty well  The usage is much harder to determine    This is how I see it       Should be used to indicate that a function is not for public use as for example an API  This and the import restriction make it behave much like internal in c         Should be used to avoid name collision in the inheritace hirarchy and to avoid latebinding  Much like private in c          If you want to indicate that something is not for public use  but it should act like protected use    If you want to indicate that something is not for public use  but it should act like private use      This is also a quote that I like very much      The problem is that the author of a class may legitimately think  this   attribute method name should be private  only accessible from within   this class definition  and use the   private convention  But later on    a user of that class may make a subclass that legitimately needs   access to that name  So either the superclass has to be modified    which may be difficult or impossible   or the subclass code has to   use manually mangled names  which is ugly and fragile at best     But the problem with that is in my opinion that if there s no IDE that warns you when you override methods  finding the error might take you a while if you have accidentially overriden a method from a base-class

User · Answer

Single Underscore  Names  in a class  with a leading underscore are simply to indicate to other programmers that the attribute or method is intended to be private   However  nothing special is done with the name itself   To quote PEP-8       single leading underscore  weak  internal use  indicator  E g  from M import   does not import objects whose name starts with an underscore    Double Underscore  Name Mangling   From the Python docs      Any identifier of the form   spam  at least two leading underscores  at most one trailing underscore  is textually replaced with  classname  spam  where classname is the current class name with leading underscore s  stripped  This mangling is done without regard to the syntactic position of the identifier  so it can be used to define class-private instance and class variables  methods  variables stored in globals  and even variables stored in instances  private to this class on instances of other classes     And a warning from the same page      Name mangling is intended to give classes an easy way to define    private    instance variables and methods  without having to worry about instance variables defined by derived classes  or mucking with instance variables by code outside the class  Note that the mangling rules are designed mostly to avoid accidents  it still is possible for a determined soul to access or modify a variable that is considered private    Example   gt  gt  gt  class MyClass            def   init   self                   self   superprivate    Hello                  self  semiprivate      world        gt  gt  gt  mc   MyClass    gt  gt  gt  print mc   superprivate Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  AttributeError  myClass instance has no attribute    superprivate   gt  gt  gt  print mc  semiprivate   world   gt  gt  gt  print mc   dict      MyClass  superprivate    Hello     semiprivate      world

[python] What is the meaning of single and double underscore before an object name?

Examples related to python

Examples related to oop

Examples related to naming-conventions

Examples related to identifier