Как вернуть несколько значений, не использующих стандартные структуры данных (списки, кортежи, словари)?

Вопрос о возврате нескольких значений из функции в Python, не используя стандартные структуры данных (списки, кортежи, словари), проверяет понимание разработчиком различных механизмов передачи данных и гибкости языка. Хотя списки и кортежи - наиболее распространенные и часто рекомендуемые способы, существуют альтернативы, подходящие для определенных сценариев.

Вот несколько способов, как это можно сделать:

1. Использование объектов (классов):

   Самый явный и часто предпочтительный способ - это создать пользовательский класс, представляющий собой структуру для хранения нескольких значений.

   
   class Result:
       def __init__(self, value1, value2, value3):
           self.value1 = value1
           self.value2 = value2
           self.value3 = value3
   
   def my_function():
       # Вычисления...
       return Result(10, "hello", True)
   
   result = my_function()
   print(result.value1)
   print(result.value2)
   print(result.value3)
         

   Этот подход хорош, когда набор возвращаемых значений логически связан и имеет определенный смысл. Класс позволяет явно определить имена для каждого значения.

2. Использование `namedtuple` (из модуля `collections`):

   `namedtuple` – это упрощенный класс, представляющий собой кортеж с именованными полями. Он обеспечивает удобный доступ к элементам по имени, что делает код более читабельным, чем использование обычного кортежа.

   
   from collections import namedtuple
   
   def my_function():
       Result = namedtuple("Result", ["value1", "value2", "value3"])
       # Вычисления...
       return Result(value1=10, value2="hello", value3=True)
   
   result = my_function()
   print(result.value1)
   print(result.value2)
   print(result.value3)
         

   `namedtuple` является иммутабельным, что может быть преимуществом в некоторых ситуациях.

3. Передача изменяемых объектов по ссылке (out parameters):

   Python позволяет изменять объекты, переданные в функцию. Хотя это и не является возвратом в прямом смысле, это позволяет передать данные "наружу". Этот метод менее желателен, поскольку он делает код менее читабельным и сложнее для отладки, но полезно знать о его существовании.

   
   def my_function(value1, value2):
       value1[0] = 10
       value2['message'] = "hello"
   
   value1 = [0]
   value2 = {'message': ''}
   my_function(value1, value2)
   
   print(value1[0])  # Выведет 10
   print(value2['message'])  # Выведет "hello"
         

   В этом примере `value1` (список) и `value2` (словарь) изменяются внутри `my_function`, и эти изменения видны за пределами функции.

   Предостережение: Чрезмерное использование изменяемых аргументов по умолчанию может привести к неожиданному поведению. В основном избегайте их, особенно если явно не хотите мутировать входящий объект.

4. Использование глобальных переменных (крайне не рекомендуется):

   Можно использовать глобальные переменные для сохранения результатов, но это крайне не рекомендуется из-за проблем с читаемостью, отладкой и потенциальных конфликтов.

   
   global_value1 = None
   global_value2 = None
   
   def my_function():
       global global_value1, global_value2
       global_value1 = 10
       global_value2 = "hello"
   
   my_function()
   print(global_value1)
   print(global_value2)
         

   Никогда не используйте этот подход в реальном коде, если нет абсолютной необходимости, и вы четко понимаете последствия.

5. Использование замыкания (в редких специфических случаях):

   Замыкание (closure) может сохранить состояние для последующего доступа. Этот метод полезен в узкоспециализированных случаях, например, когда функция возвращает другую функцию, которая использует эти значения.

   
   def create_function():
       value1 = 10
       value2 = "hello"
   
       def inner_function():
           print(value1)
           print(value2)
   
       return inner_function
   
   my_func = create_function()
   my_func() # Выведет 10 и hello
           

   Замыкание создает функцию, которая помнит переменные из области видимости внешней функции, даже после того, как внешняя функция завершила свою работу.

Важно помнить: Выбор метода зависит от конкретной задачи, требований к читабельности кода и необходимости передачи данных. Объекты и `namedtuple` обычно являются наиболее предпочтительными вариантами, так как они обеспечивают хороший баланс между читабельностью и структурированностью. Изменение аргументов по ссылке и использование глобальных переменных следует избегать, если нет веских причин для их использования.