Как увеличить возвращаемые значения функций, не нарушая устаревший код?
Например, допустим, у вас есть функция:
def foo(a):
return a
И есть куча устаревшего кода, который использует эту функцию:
amount = 4 + foo(a)
Что, если мне нужно увеличить возвращаемые значения foo, не нарушая существующий код:
def foo(a)
return a, a + 5
Теперь, когда я это делаю, переменная «amount» не является правильным ответом, потому что a теперь, в словах pylint, «кортеж», поэтому сумма изменится с возврата + 4 на возвращение (a, a + 5) + 4
как мне добавить 'a + 5' к foo, по-прежнему позволяя amount быть одним скалярным значением, а не кортежем?
Почему вы не можете просто деформировать эту функцию в другой функции и вызывать эту оболочку, когда она вам нужна, и это не повлияет на унаследованный код?
Ответы 2
Возможно, что-то вроде этого сработает:
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
Не уверен, почему вас проголосовали против - похоже, это именно тот путь, по которому я бы пошел. Возможно, добавьте пример, показывающий, как foo(a) по-прежнему будет возвращать исходное поведение?
Благодарность! Кажется, это работает и, на мой взгляд, достаточно элегантно. Приму ответ, когда смогу
В общем, это ужасная вещь, но как решение ужасной по своей сути проблемы это неизбежно. Я думаю, что все же намного лучше просто создать отдельную функцию, как предлагает juanpa, но в редких случаях, когда вы не можете этого сделать, это, вероятно, лучшая альтернатива.
вы решили проблему, но создали другую проблему; вы просто взорвали инкапсуляцию (ООП). всякий раз, когда вам нужно внести изменения, вы просто изменяете исходную реализацию !?
Я только что опубликовал то, что считаю более элегантным (хотя и с опозданием на 2 дня). Проверьте это, если не возражаете.
Более элегантное решение - сделать 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
Зависит от реальной ситуации. Можете ли вы использовать код без заполнителя?