I hardly see the difference, given the capabilities of operator overloading in Python,

    class MyNum(int):
        def __add__ (self, other):
            return super().__add__(other) * 10
        
        
    n = MyNum(12)
    a = 45
    print(n + a) # oops

This type confusion would have been identical with a plain function, __add__ is only syntactic sugar:

    class MyNum(int):
        def ten_times_sum (self, other):
            return (self+other)* 10

    n = MyNum(12)
    a = 45
    print(n.ten_times_sum(a)) 

Compare with, for example, fouling the state of output streams from operator>> in C++.

Hardly any different, trying to pretend Python is somehow better.

Operator overload is indeed syntactic sugar for function calls, regardless of the language.

By the way, you can overload >> in Python via rshift(), or __rshift__() methods.

Of course I can overload >> in Python, but I cannot foul up output stream state because it doesn't exist. Formally there is little difference between C++ and Python operator overloading and both languages have good syntax for it, but C++ has many rough edges in the standard library and intrinsic complications that can make operator overloading much more interesting in practice. For instance, overload resolution is rarely trivial.

It is only one pip install away, if anyone bothers to make on such set of overloads.

People don't though. That's the big difference. There's a certain taste in the Python community.

I love how among a certain set the word "taste" has become an all-purpose substitute for having an argument or making a case. It basically means "I have more social media follows than you do, so I'm right"

I believe the C++ community as a whole are quite convinced that overloading >> for stdout was a mistake.