Cara kanonik untuk mengembalikan beberapa nilai dalam bahasa yang mendukungnya seringkali tupling .

Opsi: Menggunakan tuple

Pertimbangkan contoh sepele ini:

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

Namun, ini dengan cepat menjadi bermasalah karena jumlah nilai yang dikembalikan meningkat. Bagaimana jika Anda ingin mengembalikan empat atau lima nilai? Tentu, Anda bisa terus menggelitiknya, tetapi mudah melupakan nilai mana. Ini juga agak jelek untuk membongkar mereka di mana pun Anda ingin menerimanya.

Opsi: Menggunakan kamus

Langkah logis berikutnya tampaknya adalah memperkenalkan semacam 'catatan notasi'. Dalam Python, cara yang jelas untuk melakukan ini adalah dengan cara a dict.

Pertimbangkan yang berikut ini:

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

(Untuk lebih jelasnya, y0, y1, dan y2 hanya dimaksudkan sebagai pengidentifikasi abstrak. Seperti yang ditunjukkan, dalam praktiknya Anda akan menggunakan pengidentifikasi yang bermakna.)

Sekarang, kami memiliki mekanisme di mana kami dapat memproyeksikan anggota tertentu dari objek yang dikembalikan. Sebagai contoh,

result['y0']

Opsi: Menggunakan kelas

Namun, ada opsi lain. Kami malah bisa mengembalikan struktur khusus. Saya telah membingkai ini dalam konteks Python, tapi saya yakin itu berlaku untuk bahasa lain juga. Memang, jika Anda bekerja di C ini mungkin satu-satunya pilihan Anda. Ini dia:

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)

Dalam Python dua sebelumnya mungkin sangat mirip dalam hal pipa - setelah semua { y0, y1, y2 }hanya berakhir menjadi entri dalam internal __dict__dari ReturnValue.

Ada satu fitur tambahan yang disediakan oleh Python untuk objek kecil, yaitu __slots__atribut. Kelas dapat dinyatakan sebagai:

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

Dari Manual Referensi Python :

The __slots__deklarasi mengambil urutan variabel instance dan cadangan cukup ruang di setiap contoh untuk mengadakan nilai untuk setiap variabel. Spasi disimpan karena __dict__tidak dibuat untuk setiap instance.

Opsi: Menggunakan dataclass (Python 3.7+)

Menggunakan kacamata baru Python 3.7, kembalikan kelas dengan metode khusus yang ditambahkan secara otomatis, pengetikan dan alat lain yang bermanfaat:

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

Opsi: Menggunakan daftar

Saran lain yang saya abaikan berasal dari Bill the Lizard:

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

Ini adalah metode yang paling tidak kusukai. Saya kira saya dinodai oleh paparan Haskell, tetapi gagasan daftar tipe campuran selalu terasa tidak nyaman bagi saya. Dalam contoh khusus ini daftarnya adalah -tidak- jenis campuran, tetapi bisa dibayangkan bisa.

Daftar yang digunakan dengan cara ini benar-benar tidak mendapatkan apa pun sehubungan dengan tuple sejauh yang saya tahu. Satu-satunya perbedaan nyata antara daftar dan tupel dalam Python adalah bahwa daftar dapat diubah , sedangkan tupel tidak.

Saya pribadi cenderung membawa konvensi dari pemrograman fungsional: gunakan daftar untuk sejumlah elemen dari jenis yang sama, dan tuple untuk sejumlah elemen tetap dari tipe yang telah ditentukan.

Pertanyaan

Setelah pembukaan panjang, muncul pertanyaan yang tak terhindarkan. Metode mana (menurut Anda) yang terbaik?

Tuple tuple ditambahkan dalam 2.6 untuk tujuan ini. Juga lihat os.stat untuk contoh bawaan serupa.

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

Dalam versi terbaru Python 3 (3,6+, saya pikir), typingperpustakaan baru membuat NamedTuplekelas untuk membuat tuple bernama lebih mudah untuk dibuat dan lebih kuat. Mewarisi dari typing.NamedTuplememungkinkan Anda menggunakan dokumen, nilai default, dan ketik anotasi.

Contoh (Dari dokumen):

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

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

Untuk proyek kecil saya merasa paling mudah untuk bekerja dengan tuple. Ketika itu menjadi terlalu sulit untuk dikelola (dan bukan sebelumnya) saya mulai mengelompokkan hal-hal ke dalam struktur logis, namun saya pikir Anda menyarankan penggunaan kamus dan ReturnValueobjek adalah salah (atau terlalu sederhana).

Kembali kamus dengan tombol "y0", "y1", "y2", dll tidak menawarkan keuntungan apapun atas tupel. Mengembalikan ReturnValuecontoh dengan sifat .y0, .y1, .y2, dll tidak menawarkan keuntungan apapun atas tupel baik. Anda harus mulai memberi nama hal-hal jika Anda ingin pergi ke mana saja, dan Anda bisa melakukannya menggunakan tuple:

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

size, type, dimensions = get_image_data(x)

IMHO, satu-satunya teknik yang baik di luar tuple adalah mengembalikan objek nyata dengan metode dan properti yang tepat, seperti yang Anda dapatkan dari re.match()atau open(file).

Banyak jawaban menyarankan Anda perlu mengembalikan koleksi, seperti kamus atau daftar. Anda dapat mengabaikan sintaks tambahan dan cukup menuliskan nilai-nilai pengembalian, dipisahkan dengan koma. Catatan: ini secara teknis mengembalikan tupel.

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

memberi:

True
False

Saya memilih kamus.

Saya menemukan bahwa jika saya membuat fungsi yang mengembalikan lebih dari 2-3 variabel, saya akan melipatnya dalam kamus. Kalau tidak, saya cenderung lupa urutan dan isi dari apa yang saya kembalikan.

Juga, memperkenalkan struktur 'khusus' membuat kode Anda lebih sulit untuk diikuti. (Orang lain harus mencari melalui kode untuk mencari tahu apa itu)

Jika Anda khawatir tentang mengetikkan pencarian, gunakan kunci kamus deskriptif, misalnya, 'daftar nilai x'.

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

Opsi lain akan menggunakan generator:

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

Meskipun tuple IMHO biasanya yang terbaik, kecuali dalam kasus di mana nilai yang dikembalikan adalah kandidat untuk enkapsulasi di kelas.

Saya lebih suka menggunakan tuple setiap kali tuple terasa "alami"; koordinat adalah contoh khas, di mana objek yang terpisah dapat berdiri sendiri, misalnya dalam perhitungan penskalaan hanya satu sumbu, dan urutannya penting. Catatan: jika saya bisa mengurutkan atau mengacak item tanpa efek buruk pada arti dari grup, maka saya mungkin tidak boleh menggunakan tuple.

Saya menggunakan kamus sebagai nilai kembali hanya ketika objek yang dikelompokkan tidak selalu sama. Pikirkan tajuk email opsional.

Untuk sisa kasus, di mana objek yang dikelompokkan memiliki makna yang melekat di dalam grup atau objek yang lengkap dengan metode sendiri diperlukan, saya menggunakan kelas.

Saya lebih memilih:

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

Sepertinya yang lainnya hanyalah kode tambahan untuk melakukan hal yang sama.

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

Secara umum, "struktur khusus" sebenarnya adalah keadaan saat objek yang masuk akal, dengan metode sendiri.

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

Saya suka mencari nama untuk struktur anonim jika memungkinkan. Nama yang bermakna membuat segalanya lebih jelas.

Tuple, dikts, dan objek Python menawarkan program pertukaran yang mulus antara formalitas dan kenyamanan untuk struktur data kecil ("barang"). Bagi saya, pilihan bagaimana mewakili sesuatu ditentukan terutama oleh bagaimana saya akan menggunakan struktur. Di C ++, ini adalah konvensi yang umum digunakan structuntuk item data saja dan classuntuk objek dengan metode, meskipun Anda dapat menggunakan metode secara legal struct; kebiasaan saya mirip dengan Python, dengan dictdantuple di tempatstruct .

Untuk set koordinat, saya akan menggunakan tupledaripada titik classatau dict(dan perhatikan bahwa Anda dapat menggunakan tuplesebagai kunci kamus, jadidict buatlah array multidimensi yang jarang).

Jika saya akan mengulangi daftar hal-hal, saya lebih suka membongkar tuplepada iterasi:

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

... karena versi objek lebih berantakan untuk dibaca:

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

... apalagi itu dict.

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

Jika hal itu banyak digunakan, dan Anda menemukan diri Anda melakukan operasi non-sepele yang serupa di beberapa tempat dalam kode, maka biasanya bermanfaat untuk menjadikannya objek kelas dengan metode yang tepat.

Akhirnya, jika saya akan bertukar data dengan komponen sistem non-Python, saya paling sering menyimpannya di dictkarena itu paling cocok untuk serialisasi JSON.

Beri +1 pada saran S.Lott tentang kelas wadah bernama.

Untuk Python 2.6 dan yang lebih tinggi, tuple yang diberi nama menyediakan cara yang berguna untuk dengan mudah membuat kelas kontainer ini, dan hasilnya "ringan dan tidak memerlukan lebih banyak memori daripada tupel biasa".

Dalam bahasa seperti Python, saya biasanya menggunakan kamus karena melibatkan lebih sedikit overhead daripada membuat kelas baru.

Namun, jika saya menemukan diri saya terus-menerus mengembalikan set variabel yang sama, maka itu mungkin melibatkan kelas baru yang saya akan faktor keluar.

Saya akan menggunakan dict untuk meneruskan dan mengembalikan nilai dari suatu fungsi:

Gunakan formulir variabel seperti yang didefinisikan dalam formulir .

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}

Ini adalah cara paling efisien untuk saya dan untuk unit pemrosesan.

Anda harus melewati hanya satu pointer dan mengembalikan hanya satu pointer.

Anda tidak perlu mengubah argumen fungsi (ribuan dari mereka) setiap kali Anda membuat perubahan dalam kode Anda.

"Terbaik" adalah keputusan yang sebagian subjektif. Gunakan tuple untuk set return kecil dalam kasus umum di mana immutable dapat diterima. Sebuah tuple selalu lebih disukai daripada daftar ketika mutabilitas bukan keharusan.

Untuk nilai pengembalian yang lebih kompleks, atau untuk kasus di mana formalitas bernilai (yaitu kode nilai tinggi), tuple bernama lebih baik. Untuk kasus yang paling kompleks, objek biasanya adalah yang terbaik. Namun, sebenarnya situasi itulah yang penting. Jika masuk akal untuk mengembalikan objek karena itulah yang secara alami Anda miliki di akhir fungsi (misalnya pola Pabrik), maka kembalikan objek tersebut.

Seperti kata orang bijak:

Optimalisasi prematur adalah akar dari semua kejahatan (atau setidaknya sebagian besar) dalam pemrograman.