Операторы в Python: Глубокое погружение в магию '+' и '*'

>> Если сложение между этими типами невозможно напрямую, Python пытается использовать __radd__ у второго объекта.

И чем radd сильнее add, и почему только у второго обьекта?

Попробуйте дополнить статью объяснением логики интерпретатора при вызовах __add__ и __radd__, как это сделали в комментариях выше

Можно ещё добавить пример того, как это можно использовать для объединения объектов

Уважаемый, "глубокое" погружение - это когда вы детально расписываете, как именно происходит низкоуровневая оптимизация сложения на Си. А то, что вы написали, знает любой грамотный джун-питонист.

Тут недавно статья была про программирование за "гранью", где взяли рандомные куски кода на js и python, про которые даже стажер знать должен.
Теперь глубокое погружение в + и * , когда про умножение и складывание строк рассказывают при первом изучении этих операторов, а про магические методы складывания и умножения узнают сразу, когда начинают изучать магические методы.

Глубокое погружение возможно было бы при рассказе про переполнения на python, а точнее его отсутствия в привычном виде и почему это так, или почему оно все же возможно при работе с pandas или numpy или при работе с float к примеру.

Глубокое погружение возможно было бы при рассказе о том как на самом деле складываются строки и какая алокация при этом происходит и почему складывание большого количества строк по средствам цикла не очень хорошая идея.

Ну или на крайний случай хотя бы пример какой-нибудь реализации магических методов. К примеру класс вектора реализующий метод складывания векторов. Уже было бы значительно полезнее. А так мы имеем, что новичок который прочитает статью вспомнит разве что про складывание строк, про которое он уже скорее всего знал, а про магические методы так ничего и не поймет. Тому же, кто знает про магические методы ваша статья тем более ничего не даст.

Погружение было бы еще глубже, если бы была упомянута роль NotImplemented в этих функциях.

>Глубокое погружение

>2 мин

У вас там всё в порядке?

Чтобы на этой странице было побольше полезно, то приведу два примера как быстро считать числа Фибоначчи при помощи матриц 2×2 и чисел вида a+b√5.
Мы реализуем класс матриц с операцией умножения и возведения в степень.
И класс чисел вида a+b√5 с основной арифметикой.

По формуле Бине $$F_n = \dfrac{ \frac{1+\sqrt5}{2}^n - \frac{1-\sqrt5}{2}^n }{\sqrt{5}}$$
А с матрицами Фибоначчи лезет при возведении матрицы (1 1) (1 0) в степень. А в степень можно возводить быстро.

class Mat2x2:
    __slots__ = ['a', 'b', 'c', 'd']

    def __init__(self, a, b, c, d):
        self.a = a
        self.b = b
        self.c = c
        self.d = d

    def __matmul__(x, y):
        ans = x.copy()
        ans @= y
        return ans

    def __imatmul__(x, y):
        x.a, x.b, x.c, x.d = x.a * y.a + x.b * y.c, x.a * y.b + x.b * y.d, x.c * y.a + x.d * y.c, x.c * y.b + x.d * y.d
        return x

    def __pow__(self, exp):
        cur = Mat2x2(1, 0, 0, 1)
        base = self.copy()
        while exp:
            if exp & 1:
                exp -= 1
                cur @= base
            else:
                exp >>= 1
                base @= base
        return cur

    def copy(self):
        return Mat2x2(self.a, self.b, self.c, self.d)

    def __repr__(self):
        return f'{self.__class__.__name__}({self.a}, {self.b}, {self.c}, {self.d})'


class R5:
    def __init__(self, a=0, b=0):
        self.a = a
        self.b = b

    def __repr__(self):
        return f'R5({self.a}, {self.b})'

    def __str__(self):
        if self.a and self.b:
            return f'({self.a}{self.b:+}√5)'
        elif self.b:
            return f'{self.b}√5'
        else:
            return f'{self.a}'

    def __add__(x, y):
        return R5(x.a + y.a, x.b + y.b)

    def __sub__(x, y):
        return R5(x.a - y.a, x.b - y.b)

    def __mul__(x, y):
        return R5(x.a * y.a + x.b * y.b * 5, x.a * y.b + x.b * y.a)

    def __pow__(x, power):
        if power == 0:
            return R5(1, 0)
        elif power % 2 == 1:
            return x * (x ** (power - 1))
        else:
            sq = x ** (power // 2)
            return sq * sq

    def __floordiv__(x, n):
        return R5(x.a // n, x.b // n)


def fib_stupid(n):
    c, p = 0, 1
    for _ in range(n):
        c, p = c + p, c
    return c


def fib_bine(n):
    return (R5(1, 1) ** n - R5(1, -1) ** n).b // 2 ** n


def fib_matrix(n, *, fib_mat=Mat2x2(0, 1, 1, 1)):
    if n == 0:
        return 0
    fib_pow = fib_mat ** (n - 1)
    return fib_pow.d


# Проверка корректности
for i in range(0, 100):
    assert fib_bine(i) == fib_stupid(i) == fib_matrix(i)

print(fib_matrix(100))

Если "глубокое" погружение то и про __iadd__ пару слов бы сказали. И как такое может работать с неизменяемыми объектами.