이를 지원하는 언어로 여러 값을 반환하는 표준 방법은 종종 튜플 링 입니다.

옵션 : 튜플 사용

이 사소한 예를 고려하십시오.

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

그러나 반환되는 값의 수가 증가함에 따라 이는 빠르게 문제가됩니다. 4 개 또는 5 개의 값을 반환하려면 어떻게합니까? 물론, 계속 튜플 링 할 수는 있지만 어느 값이 어디에 있는지 잊어 버릴 수 있습니다. 또한 원하는 곳 어디에서나 포장을 풀면 추악합니다.

옵션 : 사전 사용

다음 논리적 단계는 일종의 ‘레코드 표기법’을 도입하는 것 같습니다. 파이썬에서이를 수행하는 확실한 방법은을 사용하는 것입니다 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']

옵션 : 수업 사용

그러나 다른 옵션이 있습니다. 대신 특수 구조를 반환 할 수 있습니다. 파이썬의 맥락 에서이 프레임을 만들었지 만 다른 언어에도 적용된다고 확신합니다. 실제로 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)

파이썬에서 앞의 두 아마도 배관의 측면에서 매우 유사하다 – 결국 { y0, y1, y2 }단지 내부의 항목 끝나게 __dict__의 ReturnValue.

작은 객체, __slots__속성에 대해 Python이 제공하는 추가 기능이 하나 있습니다 . 수업은 다음과 같이 표현 될 수 있습니다.

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

로부터 파이썬 참조 설명서 :

__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)

옵션 : 목록 사용

내가 간과 한 또 다른 제안은 Bill the Lizard에서 온 것입니다.

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

이것은 내가 가장 좋아하는 방법입니다. 나는 Haskell에 노출되어 오염되었다고 생각하지만 혼합 유형 목록의 아이디어는 항상 나에게 불편하다고 느꼈습니다. 이 특정 예제에서 목록은 혼합 유형이 아니지만 가능할 수 있습니다.

이 방법으로 사용 된 목록은 실제로 내가 알 수있는 한 튜플과 관련하여 아무것도 얻지 못합니다. 파이썬에서 목록과 튜플의 유일한 차이점은 목록은 변경 가능 하지만 튜플은 변경 불가능 하다는 것 입니다.

필자는 개인적으로 함수형 프로그래밍에서 관례를 따르는 경향이 있습니다. 동일한 유형의 여러 요소에 대해 목록을 사용하고 미리 결정된 유형의 고정 된 요소에 대해 튜플을 사용하십시오.

질문

긴 서문 후에 피할 수없는 질문이 온다. 가장 좋은 방법은 무엇입니까?

답변

>>> 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

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

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

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

size, type, dimensions = get_image_data(x)

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

True
False

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

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