Cách chính tắc để trả về nhiều giá trị trong các ngôn ngữ hỗ trợ nó thường là tupling .

Tùy chọn: Sử dụng bộ dữ liệu

Hãy xem xét ví dụ tầm thường này:

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

Tuy nhiên, điều này nhanh chóng gặp vấn đề khi số lượng giá trị được trả về tăng lên. Điều gì nếu bạn muốn trả về bốn hoặc năm giá trị? Chắc chắn, bạn có thể tiếp tục sử dụng chúng, nhưng thật dễ dàng để quên giá trị đó ở đâu. Nó cũng khá xấu xí để giải nén chúng bất cứ nơi nào bạn muốn nhận chúng.

Tùy chọn: Sử dụng từ điển

Bước hợp lý tiếp theo dường như là giới thiệu một số loại 'ký hiệu hồ sơ'. Trong Python, cách rõ ràng để làm điều này là bằng cách a dict.

Hãy xem xét những điều sau đây:

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

(Nói rõ hơn, y0, y1 và y2 chỉ có nghĩa là các định danh trừu tượng. Như đã chỉ ra, trong thực tế, bạn sử dụng các định danh có ý nghĩa.)

Bây giờ, chúng ta có một cơ chế theo đó chúng ta có thể chiếu ra một thành viên cụ thể của đối tượng được trả về. Ví dụ,

result['y0']

Tùy chọn: Sử dụng một lớp

Tuy nhiên, có một lựa chọn khác. Thay vào đó chúng ta có thể trả về một cấu trúc chuyên biệt. Tôi đã đóng khung cái này trong ngữ cảnh của Python, nhưng tôi chắc chắn nó cũng áp dụng cho các ngôn ngữ khác. Thật vậy, nếu bạn đang làm việc trong C thì đây rất có thể là lựa chọn duy nhất của bạn. Đây là:

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)

Trong Python, hai cái trước có lẽ rất giống nhau về hệ thống ống nước - sau khi tất cả { y0, y1, y2 }cuối cùng chỉ là mục trong nội bộ __dict__của ReturnValue.

Có một tính năng bổ sung được cung cấp bởi Python mặc dù đối với các đối tượng nhỏ, __slots__thuộc tính. Các lớp có thể được thể hiện như sau:

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

Từ tài liệu tham khảo Python :

Các __slots__tuyên bố mất một chuỗi các biến dụ và dự trữ chỉ đủ không gian trong mỗi trường hợp để giữ giá trị cho mỗi biến. Không gian được lưu vì __dict__không được tạo cho mỗi phiên bản.

Tùy chọn: Sử dụng một dataclass (Python 3.7+)

Sử dụng các bảng dữ liệu mới của Python 3.7, trả về một lớp với các phương thức đặc biệt được thêm tự động, gõ và các công cụ hữu ích khác:

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

Tùy chọn: Sử dụng danh sách

Một đề nghị khác mà tôi đã bỏ qua đến từ Bill the Lizard:

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

Đây là phương pháp ít yêu thích nhất của tôi mặc dù. Tôi cho rằng tôi đã bị vấy bẩn khi tiếp xúc với Haskell, nhưng ý tưởng về danh sách hỗn hợp luôn khiến tôi cảm thấy khó chịu. Trong ví dụ cụ thể này, danh sách là loại hỗn hợp, nhưng có thể hiểu được.

Một danh sách được sử dụng theo cách này thực sự không đạt được bất cứ điều gì liên quan đến bộ dữ liệu như tôi có thể nói. Sự khác biệt thực sự duy nhất giữa danh sách và bộ dữ liệu trong Python là danh sách có thể thay đổi , trong khi bộ dữ liệu thì không.

Cá nhân tôi có xu hướng thực hiện các quy ước từ lập trình chức năng: sử dụng danh sách cho bất kỳ số lượng phần tử nào cùng loại và bộ dữ liệu cho một số phần tử cố định của các loại được xác định trước.

Câu hỏi

Sau lời mở đầu dài, đến câu hỏi không thể tránh khỏi. Phương pháp nào (bạn nghĩ) là tốt nhất?

Các bộ dữ liệu được đặt tên đã được thêm vào 2.6 cho mục đích này. Cũng xem os.stat cho một ví dụ dựng sẵn tương tự.

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

Trong các phiên bản gần đây của Python 3 (3.6+, tôi nghĩ vậy), typingthư viện mới có NamedTuplelớp để làm cho các bộ dữ liệu được đặt tên dễ dàng hơn để tạo và mạnh hơn. Kế thừa từ typing.NamedTuplecho phép bạn sử dụng tài liệu, giá trị mặc định và chú thích loại.

Ví dụ (Từ các tài liệu):

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

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

Đối với các dự án nhỏ, tôi thấy dễ dàng nhất để làm việc với bộ dữ liệu. Khi điều đó trở nên quá khó để quản lý (và không phải trước đây), tôi bắt đầu nhóm các thứ thành các cấu trúc logic, tuy nhiên tôi nghĩ rằng việc sử dụng từ điển và ReturnValueđối tượng được đề xuất của bạn là sai (hoặc quá đơn giản).

Quay trở lại một cuốn từ điển với các phím "y0", "y1", "y2"vv không cung cấp bất kỳ lợi thế hơn các bộ. Trả về một ReturnValueví dụ với các thuộc tính .y0, .y1, .y2vv không cung cấp bất kỳ lợi thế hơn các tuple một trong hai. Bạn cần bắt đầu đặt tên mọi thứ nếu bạn muốn đến bất cứ nơi nào và bạn có thể làm điều đó bằng cách sử dụng bộ dữ liệu:

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

size, type, dimensions = get_image_data(x)

IMHO, kỹ thuật tốt duy nhất ngoài các bộ dữ liệu là trả về các đối tượng thực với các phương thức và thuộc tính phù hợp, như bạn nhận được từ re.match()hoặc open(file).

Rất nhiều câu trả lời gợi ý bạn cần trả về một bộ sưu tập nào đó, như từ điển hoặc danh sách. Bạn có thể bỏ cú pháp phụ và chỉ cần viết ra các giá trị trả về, được phân tách bằng dấu phẩy. Lưu ý: về mặt kỹ thuật này trả về một tuple.

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

cho:

True
False

Tôi bỏ phiếu cho từ điển.

Tôi thấy rằng nếu tôi tạo một hàm trả về bất cứ thứ gì nhiều hơn 2-3 biến tôi sẽ gấp chúng lại trong một từ điển. Nếu không, tôi có xu hướng quên thứ tự và nội dung của những gì tôi sẽ trở lại.

Ngoài ra, việc giới thiệu cấu trúc 'đặc biệt' làm cho mã của bạn khó theo dõi hơn. (Người khác sẽ phải tìm kiếm thông qua mã để tìm hiểu nó là gì)

Nếu bạn quan tâm về loại tra cứu, hãy sử dụng các khóa từ điển mô tả, ví dụ, 'danh sách giá trị x'.

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

Một lựa chọn khác sẽ là sử dụng máy phát điện:

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

Mặc dù các bộ dữ liệu IMHO thường là tốt nhất, ngoại trừ trong trường hợp các giá trị được trả về là các ứng cử viên để đóng gói trong một lớp.

Tôi thích sử dụng tuple bất cứ khi nào một tuple cảm thấy "tự nhiên"; tọa độ là một ví dụ điển hình, trong đó các đối tượng riêng biệt có thể tự đứng, ví dụ: trong các phép tính tỷ lệ chỉ một trục và thứ tự là quan trọng. Lưu ý: nếu tôi có thể sắp xếp hoặc xáo trộn các mục mà không ảnh hưởng xấu đến ý nghĩa của nhóm, thì có lẽ tôi không nên sử dụng một tuple.

Tôi chỉ sử dụng từ điển làm giá trị trả về khi các đối tượng được nhóm không phải lúc nào cũng giống nhau. Hãy suy nghĩ tiêu đề email tùy chọn.

Đối với các trường hợp còn lại, trong đó các đối tượng được nhóm có ý nghĩa vốn có bên trong nhóm hoặc một đối tượng chính thức với các phương thức riêng của nó là cần thiết, tôi sử dụng một lớp.

Tôi thích:

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

Dường như mọi thứ khác chỉ là mã bổ sung để làm điều tương tự.

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

Nói chung, "cấu trúc chuyên biệt" thực sự là một trạng thái hiện tại hợp lý của một đối tượng, với các phương thức riêng của nó.

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

Tôi muốn tìm tên cho các cấu trúc ẩn danh nếu có thể. Tên có ý nghĩa làm cho mọi thứ rõ ràng hơn.

Các tuples, dicts và object của Python cung cấp cho người lập trình một sự đánh đổi suôn sẻ giữa hình thức và sự thuận tiện cho các cấu trúc dữ liệu nhỏ ("mọi thứ"). Đối với tôi, sự lựa chọn làm thế nào để đại diện cho một thứ được quyết định chủ yếu bởi cách tôi sẽ sử dụng cấu trúc. Trong C ++, đó là quy ước chung để sử dụng structcho các mục chỉ dữ liệu và classcho các đối tượng có phương thức, mặc dù bạn có thể đặt phương thức một cách hợp pháp trên a struct; thói quen của tôi là tương tự với Python, với dictvà tuplethay thếstruct .

Đối với các bộ tọa độ, tôi sẽ sử dụng tuplethay vì một điểm classhoặc một dict(và lưu ý rằng bạn có thể sử dụng tuplelàm khóa từ điển, do đó dict, tạo ra các mảng đa chiều thưa thớt tuyệt vời).

Nếu tôi sẽ lặp đi lặp lại một danh sách các thứ, tôi thích giải nén tuples trên vòng lặp:

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

... khi phiên bản đối tượng lộn xộn hơn để đọc:

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

... chứ chưa nói đến dict.

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

Nếu thứ đó được sử dụng rộng rãi và bạn thấy mình thực hiện các hoạt động không tầm thường tương tự trên nó ở nhiều nơi trong mã, thì thường đáng để biến nó thành một đối tượng lớp với các phương thức thích hợp.

Cuối cùng, nếu tôi sẽ trao đổi dữ liệu với các thành phần hệ thống không phải là Python, tôi thường sẽ giữ chúng trong một dictvì nó phù hợp nhất với tuần tự hóa JSON.

+1 trên đề xuất của S.Lott về một lớp container có tên.

Đối với Python 2.6 trở lên, một bộ dữ liệu có tên cung cấp một cách hữu ích để dễ dàng tạo các lớp chứa này và kết quả là "nhẹ và không cần nhiều bộ nhớ hơn các bộ dữ liệu thông thường".

Trong các ngôn ngữ như Python, tôi thường sử dụng một từ điển vì nó liên quan đến ít chi phí hơn là tạo một lớp mới.

Tuy nhiên, nếu tôi thấy mình liên tục trả về cùng một bộ biến, thì điều đó có thể liên quan đến một lớp mới mà tôi sẽ đưa ra.

Tôi sẽ sử dụng một dict để truyền và trả về các giá trị từ một hàm:

Sử dụng hình thức biến như được định nghĩa trong hình thức .

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}

Đây là cách hiệu quả nhất cho tôi và cho đơn vị xử lý.

Bạn phải vượt qua chỉ một con trỏ và trả lại chỉ một con trỏ.

Bạn không phải thay đổi đối số của hàm (hàng nghìn trong số chúng) bất cứ khi nào bạn thực hiện thay đổi trong mã của mình.

"Tốt nhất" là một quyết định chủ quan một phần. Sử dụng bộ dữ liệu cho các bộ hoàn trả nhỏ trong trường hợp chung trong đó bất biến được chấp nhận. Một tuple luôn thích hợp hơn cho một danh sách khi tính đột biến không phải là một yêu cầu.

Đối với các giá trị trả về phức tạp hơn hoặc trong trường hợp hình thức có giá trị (nghĩa là mã giá trị cao), một bộ dữ liệu có tên là tốt hơn. Đối với trường hợp phức tạp nhất, một đối tượng thường là tốt nhất. Tuy nhiên, đó thực sự là tình huống quan trọng. Nếu nó có ý nghĩa để trả về một đối tượng bởi vì đó là những gì bạn tự nhiên có ở cuối hàm (ví dụ mẫu Factory) thì trả về đối tượng.

Như nhà thông thái đã nói:

Tối ưu hóa sớm là gốc rễ của mọi tội lỗi (hoặc ít nhất là phần lớn) trong lập trình.