Python является функциональным или объектно-ориентированным

Python: функциональный или объектно-ориентированный?

Правильный ответ: оба! Python — это мультипарадигмный язык, который поддерживает и функциональное, и объектно-ориентированное программирование, а также процедурное.

Поддержка ООП в Python

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

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

class Dog(Animal):
    def make_sound(self):
        return "Woof!"

class Cat(Animal):
    def make_sound(self):
        return "Meow!"

# ООП в действии
dog = Dog("Rex")
cat = Cat("Whiskers")

print(dog.make_sound())  # Woof!
print(cat.make_sound())  # Meow!

Поддержка функционального программирования

Python предоставляет мощные инструменты для функционального программирования:

1. Первоклассные функции

# Функции — это объекты первого класса
def greet(name):
    return f"Hello, {name}"

# Можно присваивать переменным
func = greet
print(func("Alice"))  # Hello, Alice

# Можно передавать как аргументы
def call_twice(func, arg):
    func(arg)
    func(arg)

call_twice(greet, "Bob")  # Hello, Bob Hello, Bob

2. Лямбда-функции

# Анонимные функции
square = lambda x: x ** 2
print(square(5))  # 25

# Используются с map, filter, sorted
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

3. Функции высшего порядка

def apply_operation(a, b, operation):
    return operation(a, b)

add = lambda x, y: x + y
multiply = lambda x, y: x * y

print(apply_operation(5, 3, add))      # 8
print(apply_operation(5, 3, multiply)) # 15

4. Map, Filter, Reduce

from functools import reduce

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

# map — применить функцию к каждому элементу
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

# filter — отфильтровать элементы
even = list(filter(lambda x: x % 2 == 0, numbers))
print(even)  # [2, 4]

# reduce — свернуть список в одно значение
product = reduce(lambda x, y: x * y, numbers)
print(product)  # 120

5. Замыкания и декораторы

# Замыкание — функция, которая "помнит" переменные окружения
def create_multiplier(factor):
    def multiply(x):
        return x * factor
    return multiply

multiply_by_2 = create_multiplier(2)
multiply_by_3 = create_multiplier(3)

print(multiply_by_2(5))  # 10
print(multiply_by_3(5))  # 15

# Декоратор — функция, которая модифицирует другую функцию
def timer(func):
    def wrapper(*args, **kwargs):
        import time
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f"Выполнено за {elapsed:.2f}с")
        return result
    return wrapper

@timer
def slow_function():
    import time
    time.sleep(1)

slow_function()  # Выполнено за 1.00с

6. List comprehensions (функциональный стиль)

# Функциональный подход к преобразованию данных
numbers = [1, 2, 3, 4, 5]

# List comprehension
squared = [x ** 2 for x in numbers if x % 2 == 0]
print(squared)  # [4, 16]

# Словари
square_dict = {x: x ** 2 for x in numbers}
print(square_dict)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

7. Генераторы (лениво вычисляемые последовательности)

# Функциональный подход к производству данных
def fibonacci(limit):
    a, b = 0, 1
    while a < limit:
        yield a
        a, b = b, a + b

# Ленивое вычисление — значения генерируются по требованию
for num in fibonacci(20):
    print(num, end=" ")  # 0 1 1 2 3 5 8 13

Сравнение подходов

Объектно-ориентированный подход

class Calculator:
    def __init__(self, initial_value=0):
        self.value = initial_value
    
    def add(self, x):
        self.value += x
        return self
    
    def multiply(self, x):
        self.value *= x
        return self
    
    def result(self):
        return self.value

calc = Calculator(10)
result = calc.add(5).multiply(2).result()
print(result)  # 30

Функциональный подход

from functools import reduce

def compose(*functions):
    def composed(value):
        return reduce(lambda v, f: f(v), functions, value)
    return composed

add_5 = lambda x: x + 5
multiply_by_2 = lambda x: x * 2

calculate = compose(add_5, multiply_by_2)
result = calculate(10)
print(result)  # 30

Когда использовать что?

Используй ООП когда:

• Нужно моделировать сущности (User, Product, Order)
• Требуется наследование и полиморфизм
• Работаешь с состоянием объектов
• Нужна инкапсуляция

class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email
    
    def send_email(self, subject, message):
        # Логика отправки
        pass

Используй функциональное программирование когда:

• Обрабатываешь данные (трансформации, фильтрация)
• Нужны чистые функции без побочных эффектов
• Работаешь с потоками данных
• Нужна композиция функций

from operator import itemgetter
from functools import reduce

# Функциональный конвейер обработки данных
users = [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]

result = sorted(
    filter(lambda u: u["age"] > 20, users),
    key=itemgetter("age")
)

Правильный подход

Лучшая практика в Python — использовать оба подхода вместе, выбирая парадигму в зависимости от задачи:

class DataProcessor:
    """ООП для структурирования"""
    
    def __init__(self, data):
        self.data = data
    
    def filter_by_age(self, min_age):
        # Функциональный подход для обработки
        return list(filter(lambda x: x["age"] >= min_age, self.data))
    
    def map_names(self):
        return list(map(lambda x: x["name"], self.data))
    
    def sort_by_name(self):
        return sorted(self.data, key=lambda x: x["name"])

Заключение

Python НЕ является чисто функциональным или чисто объектно-ориентированным. Это мультипарадигмный язык, который дает разработчику свободу выбирать подходящую парадигму для каждой задачи. Лучшие Python-разработчики умеют использовать оба подхода гибко, в зависимости от контекста и требований проекта.