Расчет значения выражения в Python для чисел, переменных и коллекций

Расширенные примеры вычисления выражений в Python

Ниже собраны примеры для разных типов выражений: от безопасного AST-калькулятора до векторных расчетов NumPy и точной арифметики Decimal.

Безопасный калькулятор с функциями math через ast

import ast
import math
import operator

allowed_bin = {
    ast.Add: operator.add,
    ast.Sub: operator.sub,
    ast.Mult: operator.mul,
    ast.Div: operator.truediv,
    ast.Pow: operator.pow,
    ast.Mod: operator.mod,
}
allowed_unary = {ast.UAdd: operator.pos, ast.USub: operator.neg}
allowed_funcs = {
    'sqrt': math.sqrt,
    'sin': math.sin,
    'cos': math.cos,
    'abs': abs,
}

def safe_eval(node, variables):
    if isinstance(node, ast.Expression):
        return safe_eval(node.body, variables)
    if isinstance(node, ast.Constant) and isinstance(node.value, (int, float)):
        return node.value
    if isinstance(node, ast.Name):
        return variables[node.id]
    if isinstance(node, ast.BinOp):
        op = allowed_bin[type(node.op)]
        return op(safe_eval(node.left, variables), safe_eval(node.right, variables))
    if isinstance(node, ast.UnaryOp):
        op = allowed_unary[type(node.op)]
        return op(safe_eval(node.operand, variables))
    if isinstance(node, ast.Call):
        if isinstance(node.func, ast.Name) and node.func.id in allowed_funcs:
            args = [safe_eval(arg, variables) for arg in node.args]
            return allowed_funcs[node.func.id](*args)
    raise ValueError('Недопустимый узел выражения')

expr = 'sqrt(x**2 + y**2) + abs(-3)'
tree = ast.parse(expr, mode='eval')
print(safe_eval(tree, {'x': 3, 'y': 4}))

8.0

Пояснение: выражение sqrt(3**2 + 4**2) даёт 5.0, функция abs(-3) даёт 3, итог равен 8.0. Такой калькулятор не выполняет произвольные вызовы и подходит для формул из внешнего интерфейса.

Компиляция выражения для многократного расчета

code = compile('base * rate + bonus', '', 'eval')
records = [
    {'base': 100, 'rate': 0.2, 'bonus': 10},
    {'base': 200, 'rate': 0.1, 'bonus': 30},
]
for record in records:
    print(eval(code, {'__builtins__': {}}, record))

30.0
50.0

Пояснение: compile создаёт объект кода один раз. Далее eval использует его с разными словарями переменных. Это удобно для пакетной обработки строк с одинаковой структурой формулы.

Вычисление выражения в pandas с внешней переменной

import pandas as pd

df = pd.DataFrame({
    'qty': [2, 3, 5],
    'price': [10, 20, 8],
})
discount = 0.1
df['final'] = df.eval('qty * price * (1 - @discount)')
print(df)

   qty  price  final
0    2     10   18.0
1    3     20   54.0
2    5      8   36.0

Пояснение: символ @ показывает pandas, что discount является внешней переменной Python, а не колонкой DataFrame.

Векторное выражение с NumPy

import numpy as np

x = np.array([1, 2, 3])
y = np.array([10, 20, 30])
expr = 'x ** 2 + y / 2'
result = eval(expr, {'__builtins__': {}}, {'x': x, 'y': y})
print(result)

[ 6. 14. 24.]

Пояснение: x ** 2 даёт массив [1, 4, 9], y / 2 даёт [5, 10, 15]. Сложение выполняется поэлементно, результат имеет тип float.

Символьное выражение, производная и численный расчет

from sympy import symbols, diff, lambdify

x = symbols('x')
expr = x**3 - 3*x + 2
derivative = diff(expr, x)
f = lambdify(x, expr, 'math')
g = lambdify(x, derivative, 'math')
print(f(2), g(2))

4 9

Пояснение: исходная функция при x = 2 равна 4, производная 3*x**2 - 3 при x = 2 равна 9. SymPy сохраняет точную формулу, а lambdify создаёт быструю функцию для чисел.

Точная арифметика Decimal с переменными

from decimal import Decimal, getcontext, ROUND_HALF_UP

getcontext().prec = 10
price = Decimal('19.99')
qty = Decimal('3')
tax = Decimal('0.075')
expr = 'price * qty * (1 + tax)'
result = eval(expr, {'__builtins__': {}}, {'price': price, 'qty': qty, 'tax': tax})
print(result.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))

64.47

Пояснение: 19.99 * 3 * 1.075 даёт 64.46775. Метод quantize округляет до копейки с правилом ROUND_HALF_UP.

literal_eval для конфигурационных значений

from ast import literal_eval

text = "{'width': 10, 'height': 20, 'ratio': 0.5}"
config = literal_eval(text)
print(config['width'] * config['height'] * (1 + config['ratio']))

300.0

Пояснение: literal_eval безопасно разбирает строки, числа, кортежи, списки и словари. Он не вычисляет арифметические операции вроде 2 + 3, поэтому для формул нужен другой механизм.

eval с перегрузкой операторов пользовательского класса

class Money:
    def __init__(self, amount):
        self.amount = amount
    def __add__(self, other):
        return Money(self.amount + other.amount)
    def __mul__(self, k):
        return Money(self.amount * k)
    def __repr__(self):
        return f'Money({self.amount})'

a = Money(100)
b = Money(50)
result = eval('a + b * 2', {'__builtins__': {}}, {'a': a, 'b': b})
print(result)

Money(200)

Пояснение: eval использует те же правила операторов Python. Если объекты поддерживают __add__ и __mul__, выражение работает с ними как с числами.

Ограничение literal_eval на арифметике

from ast import literal_eval

try:
    print(literal_eval('2 + 3'))
except ValueError as err:
    print('ValueError:', err)

ValueError: malformed node or string

Пояснение: literal_eval принимает только литералы. Для арифметики с числами и переменными подходит безопасный AST-обход или eval с ограничениями.