The **methods** of the class are functions for instances. You can define a function inside the class and use it from instances:

class Plane:
    name = "Unknown"

    def fly(self, distance):
        print(f"The plane {self.name} flew {distance} km")

bon = Plane()
bon.name = "Bon"
bon.fly(56)

> Note
>
> You can access the instance attributes via the `self` argument inside methods.

The `bon.fly(56)` is equal to:
```python
Plane.fly(bon, 56)
```
Where `self` is the `bon` instance and `distance` is `56`.

Let's implement the `ThreeNumbers` class with a method named `total` that returns the sum of three numbers.

class ThreeNumbers:
    def __init__(self, number1, number2, number3):
        self.num1 = number1
        self.num2 = number2
        self.num3 = number3

    def total(self):
        total = self.num1 + self.num2 + self.num3
        return total

nums = ThreeNumbers(25, 12, 44)
print(nums.num1, nums.num2, nums.num3)

total_sum = nums.total()
print("Total:", total_sum)

So, the `self` argument allows access to the values `num1`, `num2`, and `num3` through the instance.

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.