Underscore in Python (1)

Buy Me a Coffee☕

*Memo:

• My post explains the single, double and triple leading and trailing underscore with variables, functions and classes.
• My post explains the single, double and triple leading and trailing underscore with the variables, functions and classes in a function.
• My post explains naming convention.

A single, double and triple leading and trailing underscore can be used with the variables, methods and classes in a class:

*Memo:

• A single leading underscore(_abc) can make the unforced private attributes(variables, methods and classes) in a class which are basically used in a class so they're still acceptable from the outside of the class.
• A 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.
• A double leading and trailing underscore(__abc__) can make the special public attributes which are used in and out a class, e.g. __init__, __class__, __name__, etc.
• A single trailing underscore(abc_) is used to prevent identifier conflicts when using the identifiers (including reserved keywords) which already exist, e.g. var_, func_, 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___