**Abstract Class** is a class that can't have instances but can have subclasses.

To create the **abstract class**, you need to import the `ABC` (Abstract Base Class) from the `abc` built-in library:
```python
from abc import ABC
```

Also, you need to inherit from class `ABC`:
```python
class SomeClass(ABC):
    pass
```

Now, we have the abstract class `SomeClass`, but we can create instances:

from abc import ABC

class SomeClass(ABC):
    pass

instance = SomeClass()
instance.something = "Something"
print(instance.something)

In the example above, we created an instance of `SomeClass` because `SomeClass` does not have any abstract methods.

To create an abstract class, it should follow the following structure:
1. The abstract class should inherit from the `ABC` class.
2. The abstract class should define one or more abstract methods.

> Note
>
> A class is not considered abstract unless it has at least one abstract method and inherits from the `ABC` (Abstract Base Class) class.

We will describe **abstract methods** in the next chapter.

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.