Есть ли переменные в функциональном программировании?

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

В чистом функциональном программировании нет переменных в классическом понимании. Вместо этого используются неизменяемые (immutable) значения и привязки имён.

Отличие от императивного кода

# Императивное программирование — есть переменные
x = 5
x = x + 1  # Изменяем переменную
print(x)   # 6

# Функциональное программирование — нет переменных
# Вместо этого используем привязки (bindings)
result = add(5, 1)  # 6

Ключевые различия

Переменная в классическом смысле:

• Имеет адрес в памяти
• Может менять значение (mutable)
• Разное состояние в разное время

x = 5
x = 10  # Значение переменной изменилось

Привязка в функциональном программировании:

• Имя привязано к значению
• Значение не меняется (immutable)
• Всегда одно и то же значение

# FP подход
x = 5
y = 10  # Новое имя, новое значение
# x всегда остаётся 5

Примеры в Python

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

# Переменная изменяется
sum_value = 0
for i in range(1, 6):
    sum_value += i  # Переменная меняется каждую итерацию
print(sum_value)  # 15

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

from functools import reduce

# Нет изменения состояния, только функции
result = reduce(lambda acc, i: acc + i, range(1, 6), 0)
print(result)  # 15

# Или через list comprehension
result = sum([i for i in range(1, 6)])
print(result)  # 15

Рекурсия вместо циклов

# Императивный — используются переменные
def factorial_imperative(n):
    result = 1
    for i in range(2, n + 1):
        result *= i  # Переменная меняется
    return result

# Функциональный — рекурсия без переменных
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5))  # 120

Неизменяемые структуры данных

# Вместо изменения списка
my_list = [1, 2, 3]
my_list.append(4)  # Изменяем исходный список

# В FP создаём новый список
from functools import reduce

my_list = [1, 2, 3]
new_list = my_list + [4]  # Новый список
print(my_list)     # [1, 2, 3] — не изменился
print(new_list)    # [1, 2, 3, 4]

# Или используем tuple (неизменяемый)
my_tuple = (1, 2, 3)
new_tuple = my_tuple + (4,)  # Новый tuple

Map, Filter, Reduce

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

# Map — преобразование каждого элемента
squares = list(map(lambda x: x ** 2, numbers))
print(squares)  # [1, 4, 9, 16, 25]

# Filter — отбор элементов
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)    # [2, 4]

# Reduce — свёртка
from functools import reduce
total = reduce(lambda acc, x: acc + x, numbers)
print(total)    # 15

Чистые функции (Pure Functions)

В FP функции не должны менять состояние:

# Нечистая функция — меняет внешнее состояние
global_list = []

def impure_add(x):
    global_list.append(x)  # Побочный эффект!

impure_add(1)
print(global_list)  # [1]

# Чистая функция — нет побочных эффектов
def pure_add(lst, x):
    return lst + [x]  # Возвращает новый список

my_list = [1, 2]
new_list = pure_add(my_list, 3)
print(my_list)  # [1, 2] — не изменился
print(new_list) # [1, 2, 3]

Параметры как привязки

# Параметры функции — это привязки, не переменные
def add(x, y):
    # x и y привязаны к значениям
    # они не меняются внутри функции
    return x + y

result = add(5, 3)  # 8

# Нельзя написать:
def bad_function(x, y):
    x = x + 1  # Это не меняет внешний x
    y = y + 1  # Это не меняет внешний y
    return x + y

a = 5
b = 3
result = bad_function(a, b)  # 10
print(a, b)  # 5, 3 — не изменились

FP в Python

Python не чистый функциональный язык, но поддерживает FP концепции:

from functools import reduce
from operator import add

# Функциональный стиль
numbers = [1, 2, 3, 4, 5]

# Pipeline: filter → map → reduce
result = reduce(
    add,
    map(
        lambda x: x ** 2,
        filter(lambda x: x > 2, numbers)
    )
)

print(result)  # 9 + 16 + 25 = 50

# Или с list comprehension
result = sum([x ** 2 for x in numbers if x > 2])
print(result)  # 50

Языки с чистым FP

В языках как Haskell переменные действительно не меняются:

-- Haskell
factorial :: Integer -> Integer
factorial n
  | n <= 1 = 1
  | otherwise = n * factorial (n - 1)

-- Нельзя написать: x = 5; x = 10
-- Это синтаксическая ошибка

Практический вывод

# В Python можно комбинировать стили:

# Объявляем, что переменная не меняется (соглашение)
CONSTANT = 42  # Капс — не трогаем

# Используем неизменяемые типы
tuples_of_data = (1, 2, 3)
frozen_set = frozenset([1, 2, 3])

# Пишем чистые функции
def calculate(data):
    return sum(data)

# Используем FP функции
result = list(map(lambda x: x * 2, [1, 2, 3]))

Вывод: В функциональном программировании нет "переменных" как таких — только привязки имён к неизменяемым значениям. Это предотвращает ошибки, связанные с изменением состояния, и делает код более предсказуемым и тестируемым.