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

Варіант: Використання кортежу

Розглянемо цей тривіальний приклад:

def f(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return (y0, y1, y2)

Однак це швидко стає проблематичним, оскільки кількість повернених значень збільшується. Що робити, якщо ви хочете повернути чотири-п’ять значень? Звичайно, ви могли б продовжувати їх обробляти, але легко забути, яке значення є де. Також досить некрасиво розпакувати їх там, де ви хочете їх отримати.

Варіант: Використання словника

Наступним логічним кроком, здається, є введення якогось "позначення запису". У Python очевидний спосіб зробити це за допомогою a dict.

Розглянемо наступне:

def g(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return {'y0': y0, 'y1': y1 ,'y2': y2}

(Щоб було зрозуміло, y0, y1 та y2 позначаються лише як абстрактні ідентифікатори. Як зазначалося, на практиці ви використовуєте значущі ідентифікатори.)

Тепер у нас є механізм, за допомогою якого ми можемо проектувати певного члена повернутого об'єкта. Наприклад,

result['y0']

Варіант: Використання класу

Однак є й інший варіант. Натомість ми могли б повернути спеціалізовану структуру. Я поставив це в контексті Python, але впевнений, що це стосується і інших мов. Дійсно, якби ви працювали в C, це, можливо, буде вашим єдиним варіантом. Ось:

class ReturnValue:
  def __init__(self, y0, y1, y2):
     self.y0 = y0
     self.y1 = y1
     self.y2 = y2

def g(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return ReturnValue(y0, y1, y2)

У Python попередні два, можливо, дуже схожі з точки зору сантехніки - адже вони в { y0, y1, y2 }кінцевому підсумку є записами у внутрішній __dict__частині ReturnValue.

Є ще одна додаткова функція, що надається Python, хоча для крихітних об'єктів - __slots__атрибут. Клас можна виразити так:

class ReturnValue(object):
  __slots__ = ["y0", "y1", "y2"]
  def __init__(self, y0, y1, y2):
     self.y0 = y0
     self.y1 = y1
     self.y2 = y2

З посібника з Python :

__slots__Декларація приймає послідовність змінних екземпляра і резервів тільки досить місця в кожному окремому випадку для зберігання значення для кожної змінної. Простір економиться, оскільки __dict__не створюється для кожного примірника.

Варіант: Використання класу даних (Python 3.7+)

Використовуючи нові класи даних Python 3.7, повертайте клас із автоматично доданими спеціальними методами, набором тексту та іншими корисними інструментами:

@dataclass
class Returnvalue:
    y0: int
    y1: float
    y3: int

def total_cost(x):
    y0 = x + 1
    y1 = x * 3
    y2 = y0 ** y3
    return ReturnValue(y0, y1, y2)

Варіант: Використання списку

Ще одна пропозиція, яку я не помітив, походить від Білла Ящера:

def h(x):
  result = [x + 1]
  result.append(x * 3)
  result.append(y0 ** y3)
  return result

Але це мій найулюбленіший метод. Я вважаю, що я зіпсований експозицією до Haskell, але думка про списки змішаного типу завжди відчувала мені незручність. У цьому конкретному прикладі список - не змішаний тип, але він, можливо, може бути.

Список, використаний таким чином, насправді не отримує нічого стосовно кортежу, наскільки я можу сказати. Єдина реальна різниця між списками та кортежами в Python полягає в тому, що списки є змінними , тоді як кортежі - ні.

Я особисто схильний переносити конвенції з функціонального програмування: використовувати списки для будь-якої кількості елементів одного типу і кортежі для фіксованої кількості елементів заздалегідь визначених типів.

Питання

Після тривалої преамбули постає неминуче питання. Який метод (на вашу думку) найкращий?

Названі кортежі були додані для цього в 2.6. Також див. Os.stat для подібного вбудованого прикладу.

>>> import collections
>>> Point = collections.namedtuple('Point', ['x', 'y'])
>>> p = Point(1, y=2)
>>> p.x, p.y
1 2
>>> p[0], p[1]
1 2

В останніх версіях Python 3 (думаю, 3.6+) нова typingбібліотека отримала NamedTupleклас, щоб зробити іменовані кортежі простішими для створення та більш потужними. Успадкування від typing.NamedTupleдозволяє використовувати документи, значення за замовчуванням та вводити примітки.

Приклад (із документів):

class Employee(NamedTuple):  # inherit from typing.NamedTuple
    name: str
    id: int = 3  # default value

employee = Employee('Guido')
assert employee.id == 3

Для невеликих проектів мені найпростіше працювати з кортежами. Коли це стає занадто важким для управління (і не раніше), я починаю групувати речі в логічні структури, проте вважаю, що запропоноване вами використання словників та ReturnValueоб'єктів є неправильним (або занадто спрощеним).

Повернувшись словником з ключами "y0", "y1", "y2"і т.д. не дають ніяких переваг перед кортежами. Повернення ReturnValueпримірника з властивостями .y0, .y1, .y2і т.д. не дає ніяких переваг по порівнянні кортежів або. Потрібно почати називати речі, якщо ви хочете дістатися куди завгодно, і все одно це можна зробити, використовуючи кортежі:

def get_image_data(filename):
    [snip]
    return size, (format, version, compression), (width,height)

size, type, dimensions = get_image_data(x)

ІМХО, єдина хороша техніка поза кортежами - це повернення реальних об'єктів правильними методами та властивостями, як ви отримали від re.match()або open(file).

Багато відповідей свідчать про те, що вам потрібно повернути якусь колекцію, як-от словник чи список. Ви можете залишити зайвий синтаксис і просто виписати зворотні значення, розділені комами. Примітка. Це технічно повертає кортеж.

def f():
    return True, False
x, y = f()
print(x)
print(y)

дає:

True
False

Я голосую за словник.

Я знаходжу, що якщо я буду функцію, яка повертає щось більше, ніж 2-3 змінні, я складу їх у словник. Інакше я схильний забувати порядок і зміст того, що повертаюсь.

Крім того, введення «спеціальної» структури ускладнює ваш код. (Хтось інший повинен буде шукати код, щоб дізнатися, що це таке)

Якщо ви стурбовані пошуком типу, використовуйте описові словники, наприклад, "список значень x".

def g(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return {'y0':y0, 'y1':y1 ,'y2':y2 }

Іншим варіантом буде використання генераторів:

>>> def f(x):
        y0 = x + 1
        yield y0
        yield x * 3
        yield y0 ** 4


>>> a, b, c = f(5)
>>> a
6
>>> b
15
>>> c
1296

Хоча кортежі IMHO, як правило, найкращі, за винятком випадків, коли значення, що повертаються, є кандидатами на інкапсуляцію в класі.

Я вважаю за краще використовувати кортежі, коли кортеж відчуває себе "природним"; координати - типовий приклад, коли окремі об'єкти можуть стояти самостійно, наприклад, в одноосі лише розрахунки масштабування, і порядок важливий. Примітка: якщо я можу сортувати або переміщувати елементи без шкідливого впливу на значення групи, я, мабуть, не повинен використовувати кортеж.

Я використовую словники як повернене значення лише тоді, коли згруповані об'єкти не завжди однакові. Придумайте необов’язкові заголовки електронної пошти.

Для решти випадків, коли згруповані об'єкти мають властиве значення всередині групи або потрібен повноцінний об’єкт із власними методами, я використовую клас.

Я віддаю перевагу:

def g(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return {'y0':y0, 'y1':y1 ,'y2':y2 }

Здається, все інше - це лише додатковий код, щоб зробити те саме.

>>> def func():
...    return [1,2,3]
...
>>> a,b,c = func()
>>> a
1
>>> b
2
>>> c
3

Взагалі, "спеціалізована структура" насправді являє собою чутливий поточний стан об'єкта, з його власними методами.

class Some3SpaceThing(object):
  def __init__(self,x):
    self.g(x)
  def g(self,x):
    self.y0 = x + 1
    self.y1 = x * 3
    self.y2 = y0 ** y3

r = Some3SpaceThing( x )
r.y0
r.y1
r.y2

Мені подобається знайти імена для анонімних структур, де це можливо. Значущі назви роблять речі більш зрозумілими.

Кортежі, дикти та об'єкти Python пропонують програмісту плавний компроміс між формальністю та зручністю для невеликих структур даних ("речі"). Для мене вибір того, як зобразити річ, продиктований головним чином тим, як я буду використовувати структуру. У C ++ загальна умова використовувати structдля елементів, що classмістять дані, і для об'єктів методами, навіть якщо ви можете юридично розміщувати методи на struct; моя звичка схожа на Python, з dictі tupleна місці struct.

Для наборів координат я буду використовувати tupleскоріше крапку classчи точку dict(і зауважте, що ви можете використовувати tupleяк ключ словника, тому dicts створюйте великі розріджені багатовимірні масиви).

Якщо я збираюся повторювати список речей, я віддаю перевагу розпаковуванню tuples на ітерації:

for score,id,name in scoreAllTheThings():
    if score > goodScoreThreshold:
        print "%6.3f #%6d %s"%(score,id,name)

... оскільки версія об'єкта більш захаращена для читання:

for entry in scoreAllTheThings():
    if entry.score > goodScoreThreshold:
        print "%6.3f #%6d %s"%(entry.score,entry.id,entry.name)

... НЕ кажучи вже про dict.

for entry in scoreAllTheThings():
    if entry['score'] > goodScoreThreshold:
        print "%6.3f #%6d %s"%(entry['score'],entry['id'],entry['name'])

Якщо річ широко використовується, і ви виявите, що виконайте подібні нетривіальні операції над нею в декількох місцях коду, тоді зазвичай варто зробити її об’єктом класу відповідними методами.

Нарешті, якщо я збираюсь обмінюватися даними з компонентами, які не належать до Python, я найчастіше триматиму їх у dictтому, що це найкраще підходить для серіалізації JSON.

+1 за пропозицією С.Лотта щодо названого класу контейнерів.

Для Python 2.6 і вище названий кортеж забезпечує корисний спосіб легко створювати ці класи контейнерів, а результати "легкі і не потребують більше пам'яті, ніж звичайні кортежі".

У таких мовах, як Python, я зазвичай використовую словник, оскільки він передбачає менше накладних витрат, ніж створення нового класу.

Однак, якщо я можу постійно повертати один і той же набір змінних, то це, ймовірно, передбачає новий клас, який я буду визначати.

Я б використовував dict для передачі та повернення значень функції:

Використовуйте змінну форму, як визначено у формі .

form = {
    'level': 0,
    'points': 0,
    'game': {
        'name': ''
    }
}


def test(form):
    form['game']['name'] = 'My game!'
    form['level'] = 2

    return form

>>> print(test(form))
{u'game': {u'name': u'My game!'}, u'points': 0, u'level': 2}

Це найефективніший спосіб для мене та для технологічного блоку.

Ви повинні пропустити лише один вказівник і повернути лише один вказівник назовні.

Вам не доведеться змінювати аргументи функцій (їх тисячі), коли ви вносите зміни в свій код.

"Найкраще" - частково суб'єктивне рішення. Використовуйте кортежі для невеликих наборів повернення в загальному випадку, коли незмінний прийнятний. Кортеж завжди кращий до списку, коли змінність не є необхідною умовою.

Для більш складних повернутих значень або для випадку, коли формальність є цінною (тобто код високого значення), краще названий кортеж. Для найскладнішого випадку об'єкт, як правило, найкращий. Однак насправді важлива ситуація. Якщо є сенс повернути об'єкт, оскільки це, природно, ви маєте в кінці функції (наприклад, заводський зразок), тоді поверніть об'єкт.

Як сказав мудрець:

Передчасна оптимізація - корінь усього зла (або, принаймні, більшості) в програмуванні.