self.__class__ is a reference to the type of the current instance.

For instances of abstract1, that'd be the abstract1 class itself, which is what you don't want with an abstract class. Abstract classes are only meant to be subclassed, not to create instances directly:

>>> abstract1()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in __init__
NotImplementedError: Interfaces can't be instantiated

For an instance of a subclass of abstract1, self.__class__ would be a reference to the specific subclass:

>>> class Foo(abstract1): pass
... 
>>> f = Foo()
>>> f.__class__
<class '__main__.Foo'>
>>> f.__class__ is Foo
True

Throwing an exception here is like using an assert statement elsewhere in your code, it protects you from making silly mistakes.

Note that the pythonic way to test for the type of an instance is to use the type() function instead, together with an identity test with the is operator:

class abstract1(object):
    def __init__(self):
        if type(self) is abstract1: 
            raise NotImplementedError("Interfaces can't be instantiated")

type() should be preferred over self.__class__ because the latter can be shadowed by a class attribute.

There is little point in using an equality test here as for custom classes, __eq__ is basically implemented as an identity test anyway.

Python also includes a standard library to define abstract base classes, called abc. It lets you mark methods and properties as abstract and will refuse to create instances of any subclass that has not yet re-defined those names.

Here's an English explanation, basically with functions "def" you can't share variables with other functions. So if you put them a class and put self in front of variable in a function, other functions in that class can call that variable and manipulate it.

No, singletons are rarely a good idea in general, and this approach to enforcing the Singleton contract (not that this kind of "enforcement" is really Pythonic) is totally broken anyway. I can't say I've ever seen it recommended anywhere; it really looks like something that somebody made up while not really having a good grasp on the concept.

It becomes necessary to pass self argument to the functions of your class. however, your code has several problems like the initialization of var variable. You need a constructor __init__ to create the variable, after that, you will be able to modify it:

class ThisIsClass:
  def __init__(self, value=0):
    self.var = value

  def Func(self):
      self.var+=1

c = ThisIsClass()
c.Func()
print(c.var)

In the above code, the class is instantiated as an object and stored in the variable c. You can assign an initial value to var by passing an argument to the object creation, like: c = ThisIsClass(89)
Output:

1

Good question! In self.__class__.__name__: * "self" is represents the instance of the class: kenneth * The attribute __class__ is set to the type of the instance. In this case it is set to point to the Thief class obj: kenneth.__class__ returns * When the class instance is initiated, the __name__ attribute of the __class__ is assigned to the name "Thief": kenneth.__class__.__name__ returns "Thief" Answering @anthony pizarro (https://teamtreehouse.com/anthonypizarro): What does **__ do? Can anything be __x__?** The double underscores __ beginning and ending a method name is a naming convention signifying this method is one of the special methods predefined within the Python language. They are also nicknamed “dunder” method for double underscore. See Python data model (https://docs.python.org/3/reference/datamodel.html) for complete list. It is not recommended to create your own new dunder method. What is the “.” for? The dot (“.”) syntax is used to mean “an attribute of”. So the code Python self.__class__"."__name__ would mean, the __name__ attribute of the __class__ attribute, of self which is the current instance of the class What if i had two files one for Thief and another for Pirate? In both cases, the __class__.__name__ would be set to the name of the defined class. So Thief and Pirate would get the correct name. As always, post back if you have more questions. Good Luck!!

The reason you need to use self is because Python does not use special syntax to refer to instance attributes. Python decided to do methods in a way that makes the instance to which the method belongs be passed automatically but not received automatically, the first parameter of methods is the instance the method is called on. That makes methods entirely the same as functions and leaves the actual name to use up to you (although self is the convention, and people will generally frown at you when you use something else.) self is not special to the code, it's just another object.

Python could have done something else to distinguish normal names from attributes -- special syntax like Ruby has, or requiring declarations like C++ and Java do, or perhaps something yet more different -- but it didn't. Python's all for making things explicit, making it obvious what's what, and although it doesn't do it entirely everywhere, it does do it for instance attributes. That's why assigning to an instance attribute needs to know what instance to assign to, and that's why it needs self.

employee, __init__, and add_employee are just attributes of the class Workers.

employee is an attribute being a list, and __init__ is another attribute, being a method.

Also from the def documentation:

A function definition is an executable statement. Its execution binds the function name in the current local namespace to a function object (a wrapper around the executable code for the function).

so employees and __init__ and all other methods are really the same: names in a namespaces.

See also https://docs.python.org/3/tutorial/classes.html#class-objects

Update

In Python 3.11 the module is named typing instead of typing_extensions

from typing import Self


class Node:
    """Binary tree node."""

    def __init__(self, left: Self, right: Self):
        self.left = left
        self.right = right

---

This might be helpful:

from typing_extensions import Self


class Node:
    """Binary tree node."""

    def __init__(self, left: Self, right: Self):
        self.left = left
        self.right = right

typing_extensions offers a Self class to reference class itself which I think is most elegent way to self-reference(PEP 673).

---

As others have mentioned, you can also use string literals. But it comes to problem when you have multiple type hints.

# python 3.10
var: str | int

And then you write something like

class Node:
    def __init__(self, var: 'Node' | SomeClass):
        self.var = var

It will raise a TypeError: unsupported operand type(s) for |: 'str' and 'type'.

It's to allow chaining.

For example:

var Car = function () {
    return {
        gas : 0,
        miles : 0,
        drive : function (d) {
            this.miles += d;
            this.gas -= d;
            return this;
        },
        fill : function (g) {
            this.gas += g;
            return this;
        },
    };
}

Now you can say:

var c = Car();
c.fill(100).drive(50);
c.miles => 50;
c.gas => 50;