doubler.py challenge task 2

Hey Jake Williams, your code is not far off.

Breaking it down, the class definition is correct.

class Double(int):

The first method line needs two corrections:

    def __new__(self):

• the first parameter of a method automatically receives the class reference. In a class instance, this is a reference to the instance itself. The actual parameter name can be almost anything, but to help improve code readability, it is customary to use self. For a class method, such as those decorated with @classmethod or the dunder method __new__, the first parameter represents the defined class. Again, this parameter can be named almost anything, but differentiate from a class instance method, it is customary to use cls for class methods and __new__.
• Since, you don't know what other arguments and keyword arguments are going to be passed in, it is customary to include a catchall tuple for the positional arguments and a catchall dict for the keyword arguments. Again, these can be named almost anything, but it is customary to use *args and **kwargs
• this makes the corrected line look like def __new__(cls, *args, **kwargs):

The second method line creates the new instance of the class, This needs to be broken down further:

        self = int.__new__:

• Using self as the new instance name is perfect! Since using self is a customary reference for class instances
• The proper way to call the __new__ method is to reference the inherent class, or super class. This is done using super() instead of explicitly naming the class. This has the desired benefit of only have to change the inherited class name in one place (the class definition line).
• the arguments to __new__ should be the current class, which is captured by cls in the first method line. followed the any arguments also captured in the catch-all parameters *args and **wkargs.
• putting this all together yields: self = super().__new__(cls, *args, **kwargs)

Finally, the third method line returns the result.

        return int(self)

• Since the instance has be properly created in the second line , it can be simply returned: return self

While there are many solutions that happen to pass the challenge, they may incorrect in various way. Common errors include:

• Explicitly name the inherited class, instead of using super()
• forgetting to include a class placeholder cls. This accidentally works because the class reference gets absorbed into the *args. This is bad form.

A well written __new__ method would allow simply changing the inherited class to get a new result:

# defining Double as subclass of int
# class Double(int):

>> Double("123")
246

# redefining Double as subclass of str
# class Double(str):

>>> Double("abcde")
'abcdeabcde'

Post back if you have more questions. Good luck!!