Bunu destekleyen dillerde birden çok değer döndürmenin standart yolu genellikle tupling .

Seçenek: Bir demet kullanma

Bu önemsiz örneği düşünün:

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

Ancak, döndürülen değerlerin sayısı arttıkça bu hızla sorunlu hale gelir. Dört veya beş değer döndürmek isterseniz ne olur? Elbette, onları yakalamaya devam edebilirsiniz, ancak hangi değerin nerede olduğunu unutmak kolaylaşır. Bunları almak istediğiniz her yerde açmak oldukça çirkin.

Seçenek: Sözlük kullanma

Bir sonraki mantıklı adım, bir çeşit 'kayıt gösterimi' tanıtmak gibi görünüyor. Python'da bunu yapmanın bariz yolu a dict.

Aşağıdakileri göz önünde bulundur:

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

(Açık olmak gerekirse, y0, y1 ve y2 sadece soyut tanımlayıcılar içindir. Belirtildiği gibi, pratikte anlamlı tanımlayıcılar kullanırsınız.)

Şimdi, iade edilen nesnenin belirli bir üyesini yansıtabileceğimiz bir mekanizmamız var. Örneğin,

result['y0']

Seçenek: Sınıf kullanma

Ancak başka bir seçenek daha var. Bunun yerine özel bir yapıya dönebiliriz. Bunu Python bağlamında çerçeveledim, ancak eminim diğer diller için de geçerlidir. Gerçekten, eğer C'de çalışıyorsanız, bu tek seçeneğiniz olabilir. İşte gidiyor:

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 önceki iki belki sıhhi tesisat açısından çok benzerdir - sonuçta { y0, y1, y2 }sadece iç girişler olma sonunda __dict__bir ReturnValue.

Küçük nesneler için Python tarafından sağlanan bir ek özellik daha vardır __slots__. Sınıf şu şekilde ifade edilebilir:

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

Gönderen Python Reference Manual :

__slots__Bildirimi, her bir değişken için bir değeri saklamak için, her bir durumda, örneğin değişken ve rezerv yeterli alan bir dizi alır. __dict__Her örnek için oluşturulmadığı için boşluk kaydedilir .

Seçenek: Veri kullanma (Python 3.7+)

Python 3.7'nin yeni verilerini kullanarak, otomatik olarak eklenen özel yöntemlerle, yazarak ve diğer faydalı araçlarla bir sınıfa dönün:

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

Seçenek: Liste kullanma

Göz ardı ettiğim bir diğer öneri ise Kertenkele Bill'den geliyor:

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

Bu benim en sevdiğim yöntem olsa. Sanırım Haskell'e maruz kaldığım için rahatsız oldum, ancak karışık tip listeler fikri her zaman beni rahatsız etti. Bu özel örnekte liste -not- karışık tiptedir, ancak makul olabilir.

Bu şekilde kullanılan bir liste, tuple ile ilgili olarak anlayabildiğim kadarıyla hiçbir şey kazanmaz. Python'daki listeler ve tuples arasındaki tek gerçek fark, listelerin değiştirilebilir olması , tuples olmamasıdır.

Ben şahsen fonksiyonel programlamadan gelen kuralları yerine getirme eğilimindeyim: aynı türden herhangi bir eleman için listeler ve önceden belirlenmiş türlerde sabit sayıda eleman için tuples kullanın.

Soru

Uzun önsözden sonra kaçınılmaz soru geliyor. Hangi yöntem (sizce) en iyisidir?

Bu amaçla 2.6'da adlandırılmış kaplar eklendi. Benzer yerleşik örnek için os.stat'a da bakın .

>>> 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'ün (3.6+, sanırım) son sürümlerinde, yeni typingkütüphane, NamedTupleadlandırılmış tupleslerin oluşturulmasını daha kolay ve daha güçlü hale getirmek için sınıfı aldı . Kaynağından devralma typing.NamedTupledocstring'leri, varsayılan değerleri ve yazım notlarını kullanmanıza izin verir.

Örnek (Dokümanlardan):

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

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

Küçük projeler için tupllerle çalışmanın en kolay yolunu buluyorum. Bu, yönetilmesi çok zorlaştığında (ve daha önce değil) bir şeyleri mantıksal yapılarda gruplandırmaya başladım, ancak sözlük ve ReturnValuenesneleri önerilen kullanımınızın yanlış (veya çok basit) olduğunu düşünüyorum.

Tuşlarıyla bir sözlük dönersek "y0", "y1", "y2"vb küpe karşısında hiçbir avantaj sağlamamaktadır. Geri Gelen ReturnValueözelliklere sahip örneği .y0, .y1, .y2vb ya küpe karşısında hiçbir avantaj sağlamamaktadır. Herhangi bir yere ulaşmak istiyorsanız bir şeyleri adlandırmaya başlamanız gerekir ve bunu yine de tuples kullanarak yapabilirsiniz:

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

size, type, dimensions = get_image_data(x)

IMHO, tuple'lerin ötesinde tek iyi teknik, gerçek nesneleri re.match()veya gibi elde ettiğiniz uygun yöntem ve özelliklerle döndürmektir open(file).

Yanıtların çoğu, sözlük veya liste gibi bir tür koleksiyonu geri döndürmeniz gerektiğini gösterir. Ek sözdizimini bırakıp virgülle ayrılmış dönüş değerlerini yazabilirsiniz. Not: Bu teknik olarak bir demet döndürür.

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

verir:

True
False

Sözlüğe oy veriyorum.

2-3 değişkenten daha fazla bir şey döndüren bir işlev yaparsam, bunları bir sözlüğe katlayacağım. Aksi takdirde iade ettiğim şeyin sırasını ve içeriğini unutma eğilimindeyim.

Ayrıca, 'özel' bir yapının sunulması kodunuzun takip edilmesini zorlaştırır. (Başka birinin ne olduğunu öğrenmek için kodda arama yapması gerekir)

Türle ilgili endişeleriniz varsa, açıklayıcı sözlük anahtarları kullanın, örneğin, 'x-değerleri listesi'.

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

Başka bir seçenek jeneratörleri kullanmak olabilir:

>>> 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 tuples genellikle en iyi olmasına rağmen, döndürülen değerlerin bir sınıfta kapsülleme adayları hariç, genellikle en iyisidir.

Bir tuple "doğal" hissettiğinde tuples kullanmayı tercih ederim; koordinatlar, ayrı nesnelerin kendi başlarına durabildiği tipik bir örnektir, örneğin yalnızca tek eksenli ölçeklendirme hesaplamalarında ve sıra önemlidir. Not: Grubun anlamı üzerinde olumsuz bir etkisi olmayan öğeleri sıralayabilir veya karıştırabilirsem, muhtemelen bir demet kullanmamalıyım.

Sözlükleri bir dönüş değeri olarak yalnızca gruplanmış nesneler her zaman aynı olmadığında kullanırım. İsteğe bağlı e-posta başlıklarını düşünün.

Gruplanmış nesnelerin grup içinde doğal bir anlama sahip oldukları veya kendi yöntemleriyle tam teşekküllü bir nesneye ihtiyaç duyulduğu diğer durumlarda, bir sınıf kullanıyorum.

Tercih ederim:

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

Görünüşe göre her şey aynı şeyi yapmak için ekstra bir kod.

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

Genel olarak, "özelleşmiş yapı" aslında bir nesnenin kendi yöntemleriyle mantıklı bir güncel halidir.

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

Mümkün olduğunca anonim yapıların isimlerini bulmayı seviyorum. Anlamlı isimler işleri daha net hale getirir.

Python'un tuples, dikte ve nesneleri, programcıya küçük veri yapıları ("şeyler") için formalite ve kolaylık arasında düzgün bir denge sağlar. Benim için, bir şeyi nasıl temsil edeceğimin seçimi esas olarak yapıyı nasıl kullanacağım tarafından belirlenir. C ++ 'da, yöntemleri structyalnızca classyasal olarak koyabilseniz bile, yalnızca veri içeren öğeler ve yöntem içeren nesneler için kullanılan yaygın bir kuraldır struct; alışkanlığım Python'da dictvetuple yerinestruct .

Koordinat kümeleri için tuplebir nokta classveya a yerine bir nokta kullanacağım dict(ve a'yı tuplesözlük anahtarı olarak kullanabileceğinizi unutmayın.dict çok seyrek çok boyutlu diziler yapın).

Bir şeyler listesi üzerinde yineleme yapacaksam, yinelemede paketleri açmayı tercih ederim tuple:

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

... nesne sürümü daha okunaklı olduğu için:

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

... bırak gitsin dict.

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

Eğer şey yaygın olarak kullanılıyorsa ve kendinizi kodda birden fazla yerde benzer önemsiz işlemler yaparken bulursanız, genellikle uygun yöntemlerle bir sınıf nesnesi haline getirmeye değer.

Son olarak, Python olmayan sistem bileşenleri ile veri alışverişinde bulunacaksam, çoğu zaman bunları saklayacağım dictçünkü bu JSON serileştirmesine en uygun olanıdır .

S.Lott'un adlandırılmış bir kapsayıcı sınıfı önerisinde +1.

Python 2.6 ve üstü için, adlandırılmış bir grup bu kap sınıflarını kolayca oluşturmanın yararlı bir yolunu sunar ve sonuçlar "hafiftir ve normal gruplardan daha fazla bellek gerektirmez".

Python gibi dillerde, genellikle yeni bir sınıf oluşturmaktan daha az ek yük içerdiğinden sözlük kullanırım.

Ancak, kendimi sürekli olarak aynı değişkenleri döndürürken bulursam, bu muhtemelen hesaba katacağım yeni bir sınıfı içerir.

Bir fonksiyondan değerleri iletmek ve döndürmek için bir dikte kullanırdım:

'De tanımlandığı gibi değişken formu kullanarak formu .

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}

Bu benim ve işlem birimi için en etkili yoldur.

Sadece bir işaretçi geçirmeniz ve sadece bir işaretçi döndürmeniz gerekir.

Kodunuzda her değişiklik yaptığınızda işlevlerin (binlerce) bağımsız değişkenini değiştirmeniz gerekmez.

"En iyi" kısmen öznel bir karardır. Değiştirilemez olan genel durumda küçük dönüş setleri için tuples kullanın. Değiştirilebilirlik şart olmadığında bir demet her zaman bir listeye tercih edilir.

Daha karmaşık dönüş değerleri veya formalitenin değerli olduğu durumlarda (yani yüksek değer kodu) adlandırılmış bir demet daha iyidir. En karmaşık durumda bir nesne genellikle en iyisidir. Ancak, gerçekten önemli olan durum budur. Bir nesneyi döndürmek mantıklıysa, çünkü fonksiyonun sonunda doğal olarak sahip olduğunuz şey budur (örn. Fabrika deseni), nesneyi iade edin.

Bilge adamın dediği gibi:

Erken optimizasyon, programlamadaki tüm kötülüklerin (veya en azından çoğunun) köküdür.