Что делает Python ООП языком?

Что делает Python объектно-ориентированным языком

Python — это полнофункциональный объектно-ориентированный язык программирования. Его делают ООП языком несколько ключевых особенностей архитектуры и дизайна.

1. Всё в Python — объект

Фундаментальная особенность Python: буквально всё является объектом. Числа, строки, функции, классы, модули — всё это объекты.

number = 42
print(type(number))  # <class 'int'>

string = "hello"
print(type(string))  # <class 'str'>

def my_func():
    pass
print(type(my_func))  # <class 'function'>

2. Классы и наследование

Python поддерживает определение классов и наследование, что позволяет создавать иерархии объектов.

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        raise NotImplementedError

class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

animals = [Dog("Rex"), Cat("Whiskers")]
for animal in animals:
    print(animal.speak())

Это демонстрирует три столпа ООП: инкапсуляцию, наследование и полиморфизм.

3. Инкапсуляция и доступ к атрибутам

Инкапсуляция — скрытие внутреннего состояния объекта и предоставление контролируемого доступа.

class BankAccount:
    def __init__(self, balance):
        self._balance = balance  # Protected по конвенции
    
    def withdraw(self, amount):
        if amount > self._balance:
            raise ValueError("Insufficient funds")
        self._balance -= amount
    
    def get_balance(self):
        return self._balance

account = BankAccount(1000)
account.withdraw(100)
print(account.get_balance())  # 900

4. Методы и атрибуты экземпляра

Объекты Python содержат как данные (атрибуты), так и поведение (методы).

class Person:
    species = "Homo sapiens"  # Атрибут класса
    
    def __init__(self, name, age):
        self.name = name  # Атрибут экземпляра
        self.age = age
    
    def birthday(self):  # Метод экземпляра
        self.age += 1
        return f"{self.name} is now {self.age}"
    
    @classmethod
    def from_birth_year(cls, name, birth_year):
        age = 2024 - birth_year
        return cls(name, age)
    
    @staticmethod
    def is_adult(age):
        return age >= 18

person = Person("Alice", 30)
print(person.birthday())  # Alice is now 31
print(Person.is_adult(30))  # True

5. Полиморфизм через duck typing

Python использует duck typing — если объект ведёт себя как утка, это утка. Не требуется явное наследование.

class Dog:
    def speak(self):
        return "Woof"

class Robot:
    def speak(self):
        return "Beep boop"

def make_speak(entity):
    return entity.speak()

print(make_speak(Dog()))    # Woof
print(make_speak(Robot()))  # Beep boop

6. Специальные методы (magic methods)

Python поддерживает специальные методы (dunder methods), которые позволяют объектам взаимодействовать с встроенными операциями.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    def __str__(self):
        return f"Vector({self.x}, {self.y})"
    
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

v1 = Vector(1, 2)
v2 = Vector(3, 4)
v3 = v1 + v2  # Вызывает __add__
print(v3)     # Вызывает __str__
print(v1 == v2)  # Вызывает __eq__

7. Множественное наследование

Python поддерживает множественное наследование, хотя это требует осторожности.

class Flyer:
    def fly(self):
        return "Flying"

class Swimmer:
    def swim(self):
        return "Swimming"

class Duck(Flyer, Swimmer):
    pass

duck = Duck()
print(duck.fly())   # Flying
print(duck.swim())  # Swimming

8. Свойства (properties)

Python позволяет создавать свойства — методы, которые выглядят как атрибуты.

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius
    
    @property
    def celsius(self):
        return self._celsius
    
    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32
    
    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Below absolute zero")
        self._celsius = value

temp = Temperature(0)
print(temp.celsius)     # 0
print(temp.fahrenheit)  # 32.0

Почему Python считается ООП, но не требует ООП

Python имеет все инструменты ООП, но не заставляет вас их использовать. Вы можете писать функциональный код или процедурный код, если хотите.

numbers = [1, 2, 3, 4, 5]

# Функциональный подход
squares = list(map(lambda x: x**2, numbers))

# Процедурный подход
squares = []
for num in numbers:
    squares.append(num**2)

# ООП подход
class NumberProcessor:
    def process(self, numbers):
        return [x**2 for x in numbers]

Выводы

Python — полноценный ООП язык благодаря:

• Объектной модели — всё является объектом
• Классам и наследованию — создание иерархий
• Инкапсуляции — скрытие и контроль доступа
• Полиморфизму — duck typing и наследование
• Мощным возможностям — magic methods, properties, декораторы
• Гибкости — ООП опционально, можно смешивать парадигмы

Это делает Python идеальным для больших систем, фреймворков и библиотек, где требуется архитектурная чистота.