Python çoklu dönüş değerini yoksay

Bir tuple içinde birden çok değer döndüren bir Python işlevi var diyelim:

def func():
    return 1, 2

Geçici bir değişkene atamak yerine sonuçlardan birini görmezden gelmenin güzel bir yolu var mı? Diyelim ki sadece ilk değerle ilgileniyorsam, bundan daha iyi bir yol var mı:

x, temp = func()

Yaygın olarak kullanılan bir kural, yoksaymak istediğiniz grubun öğeleri için değişken bir ad olarak "_" kullanmaktır. Örneğin:

def f():
    return 1, 2, 3

_, _, x = f()

Sen kullanabilirsiniz x = func()[0], ilk değer döndürmek için x = func()[1]böylece ikinci dönmek ve.

Bir kerede birden fazla değer almak istiyorsanız, gibi bir şey kullanın x, y = func()[2:4].

Python 3 kullanıyorsanız, paketin açılmasında bir liste olması için bir değişkenin önündeki yıldızı (ödevin sol tarafında) kullanabilirsiniz.

# Example 1: a is 1 and b is [2, 3]

a, *b = [1, 2, 3]

# Example 2: a is 1, b is [2, 3], and c is 4

a, *b, c = [1, 2, 3, 4]

# Example 3: b is [1, 2] and c is 3

*b, c = [1, 2, 3]       

# Example 4: a is 1 and b is []

a, *b = [1]

Birden fazla öğe döndürdüğünüzde, gerçekten bir demet döndürdüğünüzü unutmayın. Böylece böyle şeyler yapabilirsiniz:

def func():
    return 1, 2

print func()[0] # prints 1
print func()[1] # prints 2

Ortak uygulama, daha _önce belirtildiği gibi , kukla değişken (tek alt çizgi) kullanmaktır .

Bununla birlikte, bu değişken adının diğer kullanımlarıyla çarpışmaları önlemek için ( bu yanıta bakın ) __, ncoghlan'ın işaret ettiği gibi, bir değişken değişken olarak (çift alt çizgi) kullanmak daha iyi bir uygulama olabilir . Örneğin:

x, __ = func()

Üç basit seçenek.

Açık

x, _ = func()

x, junk = func()

iğrenç

x = func()[0]

Ve bunu bir dekoratörle yapmanın yolları var.

def val0( aFunc ):
    def pick0( *args, **kw ):
        return aFunc(*args,**kw)[0]
    return pick0

func0= val0(func)

Muhtemelen en iyi çözüm, anlamsız tuples döndürmek yerine işleri adlandırmaktır. İade edilen ürünlerin sırasının arkasında bir mantık olmadığı sürece.

def func():
    return {'lat': 1, 'lng': 2}

latitude = func()['lat']

Döndürdüğünüz şey hakkında daha fazla bilgi eklemek istiyorsanız namedtuple bile kullanabilirsiniz (bu sadece bir sözlük değildir, bunlar koordinatlardır):

from collections import namedtuple 

Coordinates = namedtuple('Coordinates', ['lat', 'lng'])

def func():
    return Coordinates(lat=1, lng=2)

latitude = func().lat

Sözlüğünüzdeki / dizinizdeki nesneler güçlü bir şekilde birbirine bağlıysa, bunun için bir sınıf tanımlamak bile iyi bir fikir olabilir. Bu şekilde, bu tür nesneler arasındaki etkileşimi tanımlayabilir ve onlarla nasıl çalışılacağı konusunda bir API verebilirsiniz. Aşağıdaki doğal bir soru: Python'da ne zaman sınıf kullanmalıyım? .

Bu benim için en iyi seçim gibi görünüyor:

val1, val2, ignored1, ignored2 = some_function()

Şifreli veya çirkin değil (func () [index] yöntemi gibi) ve amacınızı açıkça belirtiyor.

Bu soruya doğrudan bir cevap değildir. Bunun yerine şu soruya cevap verir: "Olası birçok seçenek arasından belirli bir işlev çıktısını nasıl seçerim?".

İşlevi yazabiliyorsanız (yani, değiştiremeyeceğiniz bir kitaplıkta değilse), işlevden ne istediğinizi gösteren bir girdi bağımsız değişkeni ekleyin. Varsayılan değere sahip adlandırılmış bir bağımsız değişken yapın, böylece "ortak durumda" belirtmeniz bile gerekmez.

    def fancy_function( arg1, arg2, return_type=1 ):
        ret_val = None
        if( 1 == return_type ):
            ret_val = arg1 + arg2
        elif( 2 == return_type ):
            ret_val = [ arg1, arg2, arg1 * arg2 ]
        else:
            ret_val = ( arg1, arg2, arg1 + arg2, arg1 * arg2 ) 
        return( ret_val )

Bu yöntem, istenen çıktıya ilişkin "gelişmiş uyarı" işlevini verir. Sonuç olarak, gereksiz işlemeyi atlayabilir ve yalnızca istediğiniz çıktıyı elde etmek için gerekli işi yapabilir. Ayrıca Python dinamik yazım yaptığı için dönüş türü değişebilir. Örneğin nasıl bir skaler, bir liste veya bir demet döndürdüğüne dikkat edin ... ne istersen!

Bu her zaman kullandığınız ancak her zaman ikinci argümanı attığınız bir işlevse, ikinci dönüş değeri kullanmadan işlev için bir diğer ad oluşturmanın daha az dağınık olduğunu iddia ederim lambda.

def func():
    return 1, 2

func_ = lambda: func()[0] 

func_()  # Prints 1 

Bir işlevden çok sayıda çıktınız varsa ve bunu birden çok kez çağırmak istemiyorsanız, sonuçları seçmenin en net yolunun şöyle olacağını düşünüyorum:

results = fct()
a,b = [results[i] for i in list_of_index]

Minimum çalışma örneği olarak, işlevin yalnızca bir kez çağrıldığını da gösterir:

def fct(a):
    b=a*2
    c=a+2
    d=a+b
    e=b*2
    f=a*a
    print("fct called")
    return[a,b,c,d,e,f]

results=fct(3)
> fct called

x,y = [results[i] for i in [1,4]]

Ve değerler beklendiği gibi:

results
> [3,6,5,9,12,9]
x
> 6
y
> 12

Kolaylık sağlamak için Python listesi dizinleri de kullanılabilir:

x,y = [results[i] for i in [0,-2]]

İade: a = 3 ve b = 12