Why do I have to use self = str.__new__(*args, **kwargs)? I tried not using it and it worked.

It makes total sense to me. Thanks so much for helping! I've learned a lot from you!

Hey, Chris! Could you answer this follow up question for me please?

I was playing around with this ReversedStr class. When I typed def __new__(, PyCharm autocompleted including a cls parameter. So far so good.

So I tried to run the same code, only including the cls parameter like this:

class ReversedStr(str):
    def __new__(cls, *args, **kwargs):   # cls included in the function parameter. Kenneth's code doesn't include cls in this case.
        self = str.__new__(*args, **kwargs)  
        return self

So when I went to the console and ran the following code, resulting in a TypeError:

>>>test = ReversedStr("Hello")
# output: TypeError: str.__new__(X): X is not a type object (str)

I kept wondering why was this happening. Then, to try to fix it, I included a cls parameter into the str.__new__

class ReversedStr(str):
    def __new__(cls, *args, **kwargs):
        self = str.__new__(cls, *args, **kwargs)  #cls included here too
        self = self[::-1]
        return self

# Console:
# test = ReversedStr("Hello")
# >>>test
# output: "olleH"

Now, the code ran perfectly.

So if I include the cls parameter inside def __new__, I also have to include inside str.__new__. The same logic goes if I DON'T include the cls parameter inside the def __new__: in this case, I have to NOT include cls inside str.__new__

Can you tell me the reason why this happens? I understood the logic of using cls in other cases, but I can't figure out on this one!

Thank you in advance!

[MOD: added ` escapes around dunder names -cf]

Great follow-up question!: So if I include the cls parameter inside def __new__ , I also have to include inside str.__new__ . The same logic goes if I DON'T include the cls parameter inside the def __new__: in this case, I have to NOT include cls inside str.__new__? Yes, but not for the reasons you may be thinking. The short answer is cls should never be included in the __new__ method definition because __new__ is a static method not a class method! That is, the parameter lists should be *args, **kwargs, or myarg, *args, **kwargs if your __new__ method needs to use a parameter that will not be passed along in the super() call.

The reason using *args, **kwargs in both places or cls, *args, **kwargs in both places works, is that they are virtually the same. Since __new__ is a static method it does not consume the first parameter to refer to the class (cls) or a class instance (self). Since no class object exists yet (nothing new as been created to refer to), there is no meaning to this parameter as there are no other methods or attributes to be referenced. What is really happening is more obvious if I rewrite cls, *args, **kwargs as args[0], *args[1:], **kwargs. Here you can see that cls is really what would otherwise have been the first of the args list.

Update: Video Correction: In the video subclassing builtins, Kenneth says: "The __new__ method does not use "self" because it is a class method."

This is inaccurate. classmethods typically use cls as the first parameter. Since __new__ does not use cls (or self) it is a static method.

Refresher:

• instance method uses self to refer to the class instance and it's methods. May be referenced by instance.method() or Class().method() (note use of first set of parens).
• class method uses cls to refer to the defined class. May be referenced by Class.method() (note only method as parens). The class method should be decorated with @classmethod
• static method (similar to regular function), does not use self or cls and does not consume first parameter to reference the instance or the class. May be referred to using instance.method() or Class.method(). Excluding __new__, the static method should be decorated with @staticmethod

Again, post back if you have more questions! Good Luck!!

I forgot to address the error you’re seeing :

TypeError: str.__new__(X): X is not a type object (str)

Looking at the code below:

class ReversedStr(str):
    def __new__(cls, *args, **kwargs): 
        self = str.__new__([], *args, **kwargs) 
        return self

In the case where cls is included in the method parameter list but not included in the super() call, the TypeError is caused by the “empty” *args be equivalent to an empty list. The error you get can be seen if an empty list is passed to `super:

# Python Console:
name = ReversedStr("Ewerton")
# returns:
Traceback (most recent call last):
  File “<string>”, line 7, in <module>
  File “<string>”, line 3, in __new__
TypeError: str.__new__(X): X is not a type object (list)

If an empty *args were equivalent to None, the error would have been:

TypeError: str.__new__(X): X is not a type object (NoneType)

I’ve added a comment to my previous answer to address the TypeError as seen in your first example. Your second example and explanation is correct.

Of course, none of the examples will actually reverse the string without the slice reversal statement, left out for brevity. 🙂