Início / coding / Perguntas / 79353015
Accepted
herohaha
Asked: 2025-01-14 01:36:33 +0800 CST

Uma função para modificar outras funções já definidas

  • 772

Existe uma maneira de escrever uma função que receba algum parâmetro para modificar várias funções existentes?

Por exemplo, se eu tiver:

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

def minus(a, b):
    return a - b

def offset_b(func, n):
    (??) func(a, b - n)

então quero executar abaixo:

offset_b(add(1, 2), 0.5)
offset_b(minus(1, 2), 0.5)

Eu sei que uma maneira de fazer isso é:

def new_b(b):
    return b-0.5

add(1, new_b(b))
minus(1, new_b(b))

Existe uma maneira de usar um wrapper ou algo assim para pegar a função ( add/ minus) e n, para que toda vez que eu inserir alguma, add(1, 2)ela realmente faça isso add(1, 2 - 0.5)em vez da versão original?

python

2 respostas

  1. Best Answer

    Defina uma função que aceita uma função existente com parâmetros conhecidos e retorna uma nova função que a encapsula:

    import functools  # To borrow wrapped function's docs nicely

def offset_b(func, n):
    @functools.wraps(func)
    def wrapped(a, b):
        return func(a, b-n)
    return wrapped

    Você pode então definir novas versões de adde minusque aplicam o deslocamento:

    add_with_offset_1 = offset_b(add, 1)
minus_with_offset_1 = offset_b(minus, 1)

    Ou se você quiser criar um decorador adequado para aplicar essa mutação a uma nova função que só deve ser chamada com um deslocamento aplicado, você pode aumentar o aninhamento para produzir um decorador com parâmetros , de modo que a primeira chamada pegue o deslocamento e retorne uma função que, quando chamada com outra função, produza a função encapsulada:

    def offset_b(n):
    def do_wrap(func):
        @functools.wraps(func)
        def wrapped(a, b):
            return func(a, b-n)
        return wrapped
    return do_wrap

    o que permite que você o use como antes, mas em uma ordem diferente:

    offset_by_1 = offset_b(1)
add_with_offset_1 = offset_by_one(add)  # Or as one-liner: add_with_offset_1 = offset_b(1)(add)
minus_with_offset_1 = offset_by_one(minus)

    ou usá-lo como um decorador para modificar a função encapsulada imediatamente:

    @offset_b(0.5)
def add(a, b):
    return a + b

@offset_b(0.5)
def minus(a, b):
    return a - b

    então adde minusexistem imediatamente com o deslocamento de 0.5aplicado a todas as chamadas (confuso neste caso, mas útil em outros).

    • 4

  2. Com a ajuda de @shadowRanger, descobri que há duas maneiras de escrever o wrapper.

    Primeira maneira:

    def offset_b(n, func):
    def inner_wrapper(*args):
        new_arg = (args[0], args[1]-n)
        return func(*new_arg)
    return inner_wrapper

print(offset_b(1, add)(1,2))

    Porque eu NÃO TENHO que usar @offset_b(0.5)a definição da função before, o offset_b(n, func)na verdade pode levar func. Pode economizar uma camada de wrap.

    Em termos da função de impressão, offset_b(0.5, add)fornece a função add modificada, então podemos passar(1,2)

    2ª via (a mesma que ShadowRanger compartilhou):

    def offset_b(n)
    def outer_wrapper(func):
        def inner_wrapper(*args)
            return func(*args)
        return inner_wrapper
    return outer_wrapper

    se chamarmos offset_b(0.5), o que obtemos é na verdade uma função wrapper. Como usamos wrapper, func = wrapper(func) o que precisamos fazer é obter a nova função, offset_b(0.5)(add) então damos (1,2)a essa função, o que nos dáoffset_b(0.5)(add)(1,2)

    • 0

relate perguntas