Methods that start and end with a double underscore are called "dunders" or "magic methods". Python looks for these specific names in some situations. When you create a new class object, one of python's syntactic sugars is that it automatically runs __init__ (if it exists). my_dog = Dog() my_dog.__init__() # python will automatically run this and not tell you Python has many little secrets like this, that you will learn over time. These little shortcuts are what make python so user friendly and fast to program.

def __init__(self, items=None):
    if items is None: items = []
    self.l = items

In response to @Eastsun's edit, I propose a different structure to __init__

def __init__(self, items=()):
    ''' Accepts any iterable 
    The appropriate TypeError will be raised if items is not iterable '''
    self.l = list(items)

Note that lowercase l is a bad name, it can be confused with 1

You can circumvent __init__ by calling __new__ directly. Then you can create a object of the given type and call an alternative method for __init__. This is something that pickle would do.

However, first I'd like to stress very much that it is something that you shouldn't do and whatever you're trying to achieve, there are better ways to do it, some of which have been mentioned in the other answers. In particular, it's a bad idea to skip calling __init__.

When objects are created, more or less this happens:

a = A.__new__(A, *args, **kwargs)
a.__init__(*args, **kwargs)

You could skip the second step.

Here's why you shouldn't do this: The purpose of __init__ is to initialize the object, fill in all the fields and ensure that the __init__ methods of the parent classes are also called. With pickle it is an exception because it tries to store all the data associated with the object (including any fields/instance variables that are set for the object), and so anything that was set by __init__ the previous time would be restored by pickle, there's no need to call it again.

If you skip __init__ and use an alternative initializer, you'd have a sort of a code duplication - there would be two places where the instance variables are filled in, and it's easy to miss one of them in one of the initializers or accidentally make the two fill the fields act differently. This gives the possibility of subtle bugs that aren't that trivial to trace (you'd have to know which initializer was called), and the code will be more difficult to maintain. Not to mention that you'd be in an even bigger mess if you're using inheritance - the problems will go up the inheritance chain, because you'd have to use this alternative initializer everywhere up the chain.

Also by doing so you'd be more or less overriding Python's instance creation and making your own. Python already does that for you pretty well, no need to go reinventing it and it will confuse people using your code.

Here's what to best do instead: Use a single __init__ method that is to be called for all possible instantiations of the class that initializes all instance variables properly. For different modes of initialization use either of the two approaches:

1. Support different signatures for __init__ that handle your cases by using optional arguments.
2. Create several class methods that serve as alternative constructors. Make sure they all create instances of the class in the normal way (i.e. calling __init__), as shown by Roman Bodnarchuk, while performing additional work or whatever. It's best if they pass all the data to the class (and __init__ handles it), but if that's impossible or inconvenient, you can set some instance variables after the instance was created and __init__ is done initializing.

If __init__ has an optional step (e.g. like processing that data argument, although you'd have to be more specific), you can either make it an optional argument or make a normal method that does the processing... or both.

Your code is perfectly fine. You don't have to have an __init__ method.

You can still use __init__, even with an ABC. All that the ABC meta tests for is if the names have been defined. Setting images in an __init__ does requires that you define a class attribute, but you can set that to None at first:

class Servers(BaseMenu):

    menu_name = "Servers"
    images = None
    foo = None

    def __init__(self):
        self.images = list_images.get_images()
        self.foo = list_list.get_list()

Now you can set constraints on the ABC requiring that a images abstract property be available; the images = None class attribute will satisfy that constraint.

You are calling the wrong class name in your super() call:

class SimpleHelloWorld(IRCReplyModule):

     def __init__(self):
            #super(IRCReplyModule,self).__init__('hello world')
            super(SimpleHelloWorld,self).__init__('hello world')

Essentially what you are resolving to is the __init__ of the object base class which takes no params.

Its a bit redundant, I know, to have to specify the class that you are already inside of, which is why in python3 you can just do: super().__init__()

Your subclasses's __init__ only takes one parameter (aside from self) so any other parameter will cause an exception. Python won't automatically "pass through" other parameters; you need to do some of this work yourself. The way to fix this is to have your subclass take all the parameters of its superclass as well, and then use super().__init__() to initialize everything else. This would look like class DerivedModifier(Modifier): def __init__(self, value, name, is_positive): super().__init__(value, name) self.is_positive = is_positive

Simply equate the the parameters that you would want to be defaulted to their default value.

For instance, __init__(a,b,c=0) would give 0 as the default value to c which you can override by passing another value when object is created.

Every class has an __init__ method. If it doesn't explicitly define one, then it will inherit one from its parent class. In your 2nd example, the class inherits __init__ and a bunch of other methods (and other non-method attributes) from the base object class. We can see that via the dir function:

class Dog:
    def init_instance(self,name):
        self.name = name
        print('My name is',name)

print(dir(Dog))

output

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'init_instance']

__init__ gets called automatically after the instance is constructed (via the __new__ method), so we might as well use it if we need to initialize our instance. But we can call your init_instance explicitly:

bob = Dog()
bob.init_instance('Bob')
print(bob.name)    

output

My name is Bob
Bob

If you give you class an initializer that isn't named __init__ then it won't get called automatically. How should Python know that that method is an initializer? Although it's customary to make __init__ the first method in the class definition, that's by no means mandatory, and some people like to put __init__ last.

You said: "I have seen code where the init method has not been used, how come?" Well, some classes simply don't need their instances to be initialized: their instance attributes are set via various other methods, or by direct assignment in code outside the class definition, eg bob.color = 'brown'. Or they inherit a perfectly usable __init__ from a parent class.

Use the super class before assigning specfic args

def __init__(self,radius,*args,**kwargs):
     super().__init__(*args,**kwargs)
     self.radius = radius

Edit : I'm assuming you mean class and not a function

Hey @Jorge Grajeda (https://teamtreehouse.com/jorgegrajeda), you’re very close. * there is an extra underscore in __init__ method name. This causes the __init__ method from base class object to be executed since it was not overridden. With the name argument used by the checker in creating an instance, it causes the error since the base method does not accept arguments. * the attribute self.name is not callable. Remove the parens. * assign the parameter name to the attribute self.name * the __init__ method does not use a return statement. The __init__ method modifies the newly created instance in-place so no return is needed. Post back if you need more help. Good luck!!!