Buy Me a Coffee☕

*My post explains private attributes about variables, functions and classes and the variables, functions and classes in a function.

  • Single leading underscore(_abc) can make the unforced private attributes(variables, methods and classes) in a class which are basically used in the class so they're still acceptable from the outside of the class.
  • Double leading underscore(__abc) can make the forced private attributes in a class which are only used in the class so it's unacceptable from the outside of the class.

These below are the experiments using single, double and triple leading and trailing underscores. *It's about the variables, methods and classes in a class:

*Memos:

  • Double leading and trailing underscore(__abc__) can make the special public attributes which are used in and out the class, e.g. __init__, __class__, __name__, etc.
  • Single trailing underscore(abc_) is used when you want to use the identifiers which are already used as identifiers and special keywords, e.g. len_, list_, int_, True_, def_, class_, etc.
  • S is single as the 1st character.
  • D is double as the 1st character.
  • T is triple as the 1st character.
  • L is leading as the 2nd character.
  • T is trailing as the 2nd character.
  • U is underscore or underscores as the 3rd character.

The variables in a class: 

class Cls:
    _var = "_var"           # SLU       (Acceptable)
    __var = "__var"         # DLU       (Unacceptable)
    ___var = "___var"       # TLU       (Unacceptable)
    var_ = "var_"           # STU       (Acceptable)
    var__ = "var__"         # DTU       (Acceptable)
    var___ = "var___"       # TTU       (Acceptable)
    _var_ = "_var_"         # SLU & STU (Acceptable)
    __var_ = "__var_"       # DLU & STU (Unacceptable)
    ___var_ = "___var_"     # TLU & STU (Unacceptable)
    _var__ = "_var__"       # SLU & DTU (Acceptable)
    __var__ = "__var__"     # DLU & DTU (Acceptable)
    ___var__ = "___var__"   # TLU & DTU (Acceptable)
    _var___ = "_var___"     # SLU & TTU (Acceptable)
    __var___ = "__var___"   # DLU & TTU (Acceptable)
    ___var___ = "___var___" # TLU & TTU (Acceptable)

cls = Cls()

print(cls._var)      # _var
print(cls.__var)     # Error
print(cls.___var)    # Error
print(cls.var_)      # var_
print(cls.var__)     # var__
print(cls.var___)    # var___
print(cls._var_)     # _var_
print(cls.__var_)    # Error
print(cls.___var_)   # Error
print(cls._var__)    # _var__
print(cls.__var__)   # __var__
print(cls.___var__)  # ___var__
print(cls._var___)   # _var___
print(cls.__var___)  # __var___
print(cls.___var___) # ___var___

The methods in a class: 

class Cls:
    def _func(self): pass      # SLU       (Acceptable)
    def __func(self): pass     # DLU       (Unacceptable)
    def ___func(self): pass    # TLU       (Unacceptable)
    def func_(self): pass      # STU       (Acceptable)
    def func__(self): pass     # DTU       (Acceptable)
    def func___(self): pass    # TTU       (Acceptable)
    def _func_(self): pass     # SLU & STU (Acceptable)
    def __func_(self): pass    # DLU & STU (Unacceptable)
    def ___func_(self): pass   # TLU & STU (Unacceptable)
    def _func__(self): pass    # SLU & DTU (Acceptable)
    def __func__(self): pass   # DLU & DTU (Acceptable)
    def ___func__(self): pass  # TLU & DTU (Acceptable)
    def _func___(self): pass   # SLU & TTU (Acceptable)
    def __func___(self): pass  # DLU & TTU (Acceptable)
    def ___func___(self): pass # TLU & TTU (Acceptable)

cls = Cls()

print(cls._func.__name__)      # _func
print(cls.__func.__name__)     # Error
print(cls.___func.__name__)    # Error
print(cls.func_.__name__)      # func_
print(cls.func__.__name__)     # func__
print(cls.func___.__name__)    # func___
print(cls._func_.__name__)     # _func_
print(cls.__func_.__name__)    # Error
print(cls.___func_.__name__)   # Error
print(cls._func__.__name__)    # _func__
print(cls.__func__.__name__)   # __func__
print(cls.___func__.__name__)  # ___func__
print(cls._func___.__name__)   # _func___
print(cls.__func___.__name__)  # __func___
print(cls.___func___.__name__) # ___func___

The classes in a class: 

class Cls:
    class _Cls: pass      # SLU       (Acceptable)
    class __Cls: pass     # DLU       (Unacceptable)
    class ___Cls: pass    # TLU       (Unacceptable)
    class Cls_: pass      # STU       (Acceptable)
    class Cls__: pass     # DTU       (Acceptable)
    class Cls___: pass    # TTU       (Acceptable)
    class _Cls_: pass     # SLU & STU (Acceptable)
    class __Cls_: pass    # DLU & STU (Unacceptable)
    class ___Cls_: pass   # TLU & STU (Unacceptable)
    class _Cls__: pass    # SLU & DTU (Acceptable)
    class __Cls__: pass   # DLU & DTU (Acceptable)
    class ___Cls__: pass  # TLU & DTU (Acceptable)
    class _Cls___: pass   # SLU & TTU (Acceptable)
    class __Cls___: pass  # DLU & TTU (Acceptable)
    class ___Cls___: pass # TLU & TTU (Acceptable)

cls = Cls()

print(cls._Cls().__class__.__name__)      # _Cls
print(cls.__Cls().__class__.__name__)     # Error
print(cls.___Cls().__class__.__name__)    # Error
print(cls.Cls_().__class__.__name__)      # Cls_
print(cls.Cls__().__class__.__name__)     # Cls__
print(cls.Cls___().__class__.__name__)    # Cls___
print(cls._Cls_().__class__.__name__)     # _Cls_
print(cls.__Cls_().__class__.__name__)    # Error
print(cls.___Cls_().__class__.__name__)   # Error
print(cls._Cls__().__class__.__name__)    # _Cls__
print(cls.__Cls__().__class__.__name__)   # __Cls__
print(cls.___Cls__().__class__.__name__)  # ___Cls__
print(cls._Cls___().__class__.__name__)   # _Cls___
print(cls.__Cls___().__class__.__name__)  # __Cls___
print(cls.___Cls___().__class__.__name__) # ___Cls___