Как увеличить возвращаемые значения функций без нарушения устаревшего кода?

Например, допустим, у вас есть функция:

def foo(a): 
    return a

И есть куча устаревшего кода, который использует эту функцию:

amount = 4 + foo(a)

Что, если мне нужно увеличить возвращаемые значения foo, не нарушая существующий код:

def foo(a)
   return a, a + 5

Теперь, когда я это делаю, переменная «количество» не является правильным ответом, потому что теперь a, по словам pylint, «кортеж», поэтому сумма изменится с возврата + 4 на возврат (a, a + 5) + 4

как мне добавить «a + 5» к foo, при этом позволяя количеству быть одним скалярным значением, а не кортежем?


python-3.x python function legacy maintenance
person Tristan Berry    schedule 04.08.2018    source источник
comment
Зависит от реальной ситуации. Можно ли использовать код без заполнителей?   -  person Ry-♦    schedule 04.08.2018
comment
Почему вы не можете просто преобразовать эту функцию в другую функцию и вызвать эту оболочку, когда вам это нужно, и это не повлияет на устаревший код?   -  person juanpa.arrivillaga    schedule 04.08.2018

Ответы (2)


arrow_upward
3
arrow_downward

Возможно, что-то вроде этого сработает:

def foo(a, new_usage=False):
    if not new_usage:
        return a

    return a + 5

Затем вызывайте свою функцию следующим образом для всех новых ситуаций использования:

foo(a, True)

Например, ваш старый код все еще будет работать:

In [40]: amount = 4 + foo(4)

In [41]: amount
Out[41]: 8

И для нового использования вы можете сделать это:

In [42]: amount = 4 + foo(4, True)

In [43]: amount
Out[43]: 13
person Ashish Acharya    schedule 04.08.2018
comment
Не уверен, почему за вас проголосовали - кажется, это именно тот путь, по которому я бы пошел. Возможно, добавьте пример, показывающий, как foo(a) по-прежнему будет возвращать исходное поведение? - person tonysdg; 04.08.2018
comment
Благодарность! Кажется, это работает, и я думаю, что это достаточно элегантно. Приму ответ, когда смогу - person Tristan Berry; 04.08.2018
comment
В общем, это ужасная вещь, но как решение изначально ужасной проблемы это неизбежно. Я думаю, что все же гораздо лучше просто создать отдельную функцию, как предложил juanpa, но в тех редких случаях, когда вы не можете этого сделать, это, вероятно, лучшая альтернатива. - person abarnert; 04.08.2018
comment
вы решили проблему, но создали другую проблему; вы только что взорвали инкапсуляцию (ООП). всякий раз, когда вам нужно внести изменения, вы просто изменяете исходную реализацию!? - person Afshin Amiri; 04.08.2018
comment
Я только что опубликовал то, что считаю более элегантным решением (хотя и с опозданием на 2 дня). Посмотрите, если не возражаете. - person blhsing; 06.08.2018

arrow_upward
0
arrow_downward

Более элегантное решение состоит в том, чтобы сделать foo классом, который расширяет int (или float, в зависимости от вывода вашего прежнего foo()), при этом реализуя метод __iter__, позволяющий распаковывать его как последовательность при использовании в контексте последовательности:

class foo(int):
    def __iter__(self):
        return iter((self, self + 5))

Чтобы:

amount = 4 + foo(1) # used as an int
print(amount)
a, b = foo(1) # used in a sequence context so foo.__iter__ is called
print(a, b)

выведет:

5
1 6

Но, конечно, приведенный выше код работает только потому, что в вашем вопросе foo(a) просто возвращает a, и это просто поведение конструктора int, поэтому, расширяя int, foo(a) также удобно возвращает a.

Однако, если ваш foo(a) на самом деле возвращает что-то отличное от a в устаревшем производственном коде, вам нужно будет переопределить метод __new__, чтобы он возвращал новый экземпляр int с другим значением.

Ниже показан пример, если ваш прежний foo(a) возвращает a + 1:

class foo(int):
    @classmethod
    def __new__(cls, type, a):
        return super(foo, cls).__new__(type, a + 1)
    def __iter__(self):
        return iter((self, self + 5))

Чтобы:

amount = 4 + foo(1)
print(amount)
a, b = foo(1)
print(a, b)

Будет вывод:

6
2 7
person blhsing    schedule 06.08.2018