В чем разница между императивным и функциональным программированием?

Разница между императивным и функциональным программированием

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

Определения

Императивное программирование (Imperative):

• Фокус на КАК это сделать
• Описываешь пошаговые инструкции
• Изменяешь состояние переменных
• Используешь циклы и условия
• Пример языков: Python, Java, C, JavaScript

Функциональное программирование (Functional):

• Фокус на ЧТО нужно получить
• Функции - как математические отображения
• Избегаешь изменения состояния (immutability)
• Используешь функции высшего порядка
• Пример языков: Lisp, Haskell, Scala, Clojure

Практический пример

Задача: увеличить все числа в списке на 1

Императивный подход:

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

for number in numbers:
    result.append(number + 1)

print(result)  # [2, 3, 4, 5, 6]

Здесь описываешь КАК: создать пустой список, пройти по каждому элементу, добавить +1, добавить в новый список.

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

numbers = [1, 2, 3, 4, 5]
result = list(map(lambda x: x + 1, numbers))

print(result)  # [2, 3, 4, 5, 6]

Здесь описываешь ЧТО: применить функцию +1 ко всем элементам списка.

Сравнительная таблица

Ключевые концепции функционального программирования

1. Pure functions (чистые функции)

# Плохо - неопределенное поведение
result = 0
def add(x):  # побочный эффект - изменение result
    global result
    result += x

# Хорошо - чистая функция
def add(x, y):
    return x + y

Чистая функция:

• Не имеет побочных эффектов
• Всегда возвращает один результат для одного входа
• Легко тестировать

2. Immutability (неизменяемость)

# Императивное - изменяем исходный список
data = [1, 2, 3]
data[0] = 10

# Функциональное - создаем новый список
data = [1, 2, 3]
new_data = [10] + data[1:]  # оригинальный data не изменился

3. Higher-order functions (функции высшего порядка)

# Функция принимает другую функцию как аргумент
def apply_operation(x, y, operation):
    return operation(x, y)

result = apply_operation(5, 3, lambda a, b: a + b)
print(result)  # 8

4. Recursion вместо loops

# Императивное
def factorial_imperative(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

# Функциональное
def factorial_functional(n):
    if n <= 1:
        return 1
    return n * factorial_functional(n - 1)

map, filter, reduce

# map - применить функцию ко всем элементам
numbers = [1, 2, 3, 4, 5]
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 - свернуть список в одно значение
from functools import reduce
sum_all = reduce(lambda x, y: x + y, numbers)
print(sum_all)  # 15

List comprehension - гибрид подходов

Python позволяет писать функциональный стиль с читаемостью императивного:

# Функциональный стиль
squared = list(map(lambda x: x ** 2, numbers))

# List comprehension - более читаемый способ
squared = [x ** 2 for x in numbers]

# С условием
even_squared = [x ** 2 for x in numbers if x % 2 == 0]

Когда использовать какой подход

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

• Сложная логика с много условиями
• Важна производительность
• Нужно манипулировать состоянием
• Работаешь с mutable структурами (списки, дикты)

# Хороший пример императивного
def process_data(data):
    for item in data:
        if item['status'] == 'pending':
            item['status'] = 'processed'
            item['timestamp'] = datetime.now()

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

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

# Хороший пример функционального
def get_active_users(users):
    return list(filter(lambda u: u['is_active'], users))

def get_user_names(users):
    return list(map(lambda u: u['name'], users))

active_names = get_user_names(get_active_users(users))

Python - гибридный язык

Python поддерживает оба парадигма:

# Функции первого класса
operations = {
    '+': lambda x, y: x + y,
    '-': lambda x, y: x - y,
}

# Замыкания
def make_multiplier(n):
    def multiplier(x):
        return x * n
    return multiplier

multiply_by_3 = make_multiplier(3)
print(multiply_by_3(10))  # 30

# Декораторы (функции высшего порядка)
def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f'Calling {func.__name__}')
        return func(*args, **kwargs)
    return wrapper

@log_decorator
def add(a, b):
    return a + b

Заключение

Императивное - это КАК, пошагово описываешь алгоритм. Функциональное - это ЧТО, описываешь желаемый результат.

Python позволяет использовать оба подхода. Лучший код часто - это гибрид обоих парадигм, где ты выбираешь инструмент, подходящий для конкретной задачи.

Для интервью важно понимать КОГДА использовать какой подход и уметь писать код обоими способами.