Similarly to the mathematical magic methods, here we take `self` and `other` as arguments and compare their desired attributes. These magic methods should always return `True` or `False`.

| **Magic Method** | **Operation** |
| :--- | :--- |
| `__eq__(self, other)` | `==` |
| `__gt__(self, other)` | `>` |
| `__ge__(self, other)` | `>=` |
| `__lt__(self, other)` | `<` |
| `__le__(self, other)` | `<=` |
| `__ne__(self, other)` | `!=` |

> Note
> 
> To understand the naming of these methods, look at some examples:
>
> - `eq` is `eq`ual.
> - `gt` is `g`reater `t`han.
> - `le` is `l`ess or `e`qual.
> - `ne` is `n`ot `e`qual.

a = 12.3
b = 5.7

print("a >= b is", a >= b)
print("a.__ge__(b) is", a.__ge__(b))

class Road:
    def __init__(self, length):
        self.length = length

    def __eq__(self, other):
        if isinstance(other, Road):
            return self.length == other.length  # compare with road
        return self.length == other  # compare with number

road_1 = Road(20)
road_2 = Road(30)
road_3 = Road(20)

print(road_1 == road_2)
print(road_1 == road_3)
print(road_1 == 20)
print(road_1 == 20.0)
print(road_1 == 1412)

> Note
>
> To optimize the code, you can utilize existing comparison methods. For example, if you have implemented the `__lt__()` method (`<`), by implementing the `__ge__()` method (`>=`), you can use `return not (instance1 < instance2)` which will return the opposite result of the already implemented `<` operator.

This course covers Object-Oriented Programming (OOP) in Python, starting with the basics and progressing to advanced concepts. You will implement a User model to gain practical experience and understanding of OOP features. By the end of the course, you will have a strong foundation in OOP and a deeper knowledge of Python's inner workings.

Let's start! The Object-Oriented Programming basic concepts are waiting for you here! In this section, you will get acquainted with the most important concepts for understanding Object-Oriented Programming.

Inheritance - the first of the OOP principles. The entities can be inherited from other ones. You learn how it works in code here.

Inheritance - the second of the OOP principles. The attributes and methods can be closed inside the class and used by the class only. Here you learn how to code with different access modifiers.

Polymorphism and abstraction are the third and fourth of the OOP principles. These principles are not easy to understand. Here you will get to know them in the simplest ways.

The magic methods make sandbox from Python. It's a unique Python tool you can't see in other languages. Here you learn how to use these methods and about the flexibility that they bring to Python.

Magic Method	Operation
`__eq__(self, other)`	`==`
`__gt__(self, other)`	`>`
`__ge__(self, other)`	`>=`
`__lt__(self, other)`	`<`
`__le__(self, other)`	`<=`
`__ne__(self, other)`	`!=`

In-Depth Python OOP

Comparison Magic Methods