Python döngülerinin "else" maddesini nasıl anlayabilirim?

Birçok Python programcısı muhtemelen whiledöngülerin ve fordöngülerin sözdiziminin isteğe bağlı bir else:cümle içerdiğinin farkında değildir :

for val in iterable:
    do_something(val)
else:
    clean_up()

Vücut elsemaddesi, temizlik hareketleri belirli türdeki iyi bir yerdir ve döngü normal fesih da yürütülüyor: ile döngüsünden çıkar, Ie returnveya breakatlar elsemaddesini; bir continueyürütmeden sonra çıkılıyor . Ben sadece çünkü sadece bu biliyorum baktım ben hatırlayamıyorum, çünkü (yine) ne zamanelse bloğu icra edilir.

Her zaman? Adından da anlaşılacağı gibi, döngü "hatası"? Düzenli fesih mi? Döngüden çıkılsa bile return? Bakmadan asla tam olarak emin olamam.

Anahtar kelime seçimindeki belirsizliğimi suçluyorum: elseBu anlambilim için inanılmaz derecede anımsatıcı değilim. Benim sorum "bu anahtar kelime neden bu amaç için kullanılıyor" değil (muhtemelen cevapları ve yorumları okuduktan sonra kapatmak için oy vereceğim) değil, ama anlambiliminin anlamlı olması için elseanahtar kelimeyi nasıl düşünebilirim ve ben bu yüzden hatırlıyor musun?

Bu konuda oldukça fazla tartışma olduğundan eminim ve seçimin tryifadenin tutarlılığına else:(ayrıca da bakmam gerekiyor) ve Python'un ayrılmış sözleri. Belki de seçim nedenleri elseişlevini açıklığa kavuşturacak ve daha akılda kalıcı hale getirecektir, ancak ismin işleve bağlandıktan sonra değil, tarihsel açıklamadan sonra değil.

Sorumun bir nüshası olarak kısaca kapatıldığı bu sorunun cevapları , birçok ilginç arka hikaye içeriyor. Sorumun farklı bir odağı var ( elseanahtar kelime seçimiyle belirli anlambilimi nasıl bağlayacağım ), ancak bu soruya bir yerde bir bağlantı olması gerektiğini hissediyorum.

(Bu ilham @ Mark Tolonen'in cevabıdır.)

Bir ififade else, koşulu yanlış olarak değerlendirilirse yan tümcesini çalıştırır . Aynı şekilde, bir whiledurum, durumu false olarak değerlendirilirse else yan tümcesini çalıştırır.

Bu kural tanımladığınız davranışla eşleşir:

• Normal yürütmede, while döngüsü koşul false olarak değerlendirilinceye kadar art arda çalışır ve bu nedenle döngüden doğal olarak çıkıldığında başka deyimi çalıştırır.
• Bir breakdeyimi yürüttüğünüzde , koşulu değerlendirmeden döngüden çıkarsınız, böylece koşul false olarak değerlendirilemez ve asla başka bir cümle çalıştırmazsınız.
• Bir continuedeyimi yürüttüğünüzde , koşulu yeniden değerlendirirsiniz ve bir döngü yinelemesinin başlangıcında tam olarak ne yaparsanız yapın. Bu nedenle, koşul doğruysa, döngü yapmaya devam edersiniz, ancak yanlışsa başka bir cümle çalıştırırsınız.
• Döngüden çıkmanın diğer yöntemleri, örneğin returndurumu değerlendirmez ve bu nedenle else yan tümcesini çalıştırmaz.

fordöngüler aynı şekilde davranır. Yineleyicinin daha fazla öğesi varsa durumu doğru, aksi halde yanlış olarak düşünün.

Daha Bunu şu şekilde düşünmek: elseblok olacak hep herşey giderse yürütülecek sağ önceki içinde forbu yorgunluk ulaşacağı şekilde bloğun.

Sağ bu bağlamda hiçbir anlamına gelecektir exceptionhayır, breakhayır, return. Kontrolü ele forgeçiren herhangi bir ifade , elsebloğun atlanmasına neden olur .

Bir öğede iterablearama yaparken, öğe bulunduğunda aramanın kapatıldığı veya "not found"aşağıdaki elseblok yoluyla bir bayrak kaldırıldığı / yazdırıldığı yaygın bir kullanım durumu bulunur :

for items in basket:
    if isinstance(item, Egg):
        break
else:
    print("No eggs in basket")  

A continuekontrolünü ele geçirmez for, bu yüzden kontrol elsebittikten sonra devam eder for.

Ne zaman bir ifyürütmeelse ? Durumu yanlış olduğunda. while/ İçin tamamen aynıdır else. Aklınıza gelebilecek Yani while/ ' elsesadece olarak ifyanlış değerlendirir kadar gerçek durumunu çalışmaya devam söyledi. A breakbunu değiştirmez. Değerlendirme içermeyen sadece döngü içerisinden atlar. elseKeşke yürütülür değerlendirirkenif / whiledurumunu yanlıştır.

forOnun sahte koşulu onun yineleyici yorucudur dışında benzerdir.

continueve breakyürütme else. Bu onların işlevi değil. breakİçeren döngü çıkar. continueDöngü koşulu değerlendirilir içeren döngünün, üstüne gider. Yürütme if/ whileyanlış yapma (veya forbaşka bir öğeye sahip olmayan) değerlendirme elseve başka bir yol yoktur.

Aslında bunun anlamı şudur:

for/while ...:
    if ...:
        break
if there was a break:
    pass
else:
    ...

Bu ortak kalıbı yazmanın daha güzel bir yolu:

found = False
for/while ...:
    if ...:
        found = True
        break
if not found:
    ...

elseYantümce varsa yürütülmez return, çünkü returno amaçlandığı anlaşılacaktır, yaprakların fonksiyonu. Aklınıza gelebilecek tek istisna finally, amacı her zaman yürütüldüğünden emin olmaktır.

continuebu konuyla özel bir ilgisi yok. Döngünün geçerli yinelemesinin sona ermesine neden olur, bu da tüm döngüyü bitirebilir ve bu durumda döngü a ile sona ermemiştir break.

try/else benzer:

try:
    ...
except:
    ...
if there was an exception:
    pass
else:
    ...

Döngülerinizi buna benzer bir yapı olarak düşünüyorsanız (biraz sahte kod):

loop:
if condition then

   ... //execute body
   goto loop
else
   ...

biraz daha mantıklı olabilir. Bir döngü aslında sadece ifkoşul olana kadar yinelenen bir ifadedir false. Ve önemli olan nokta bu. Döngü durumunu kontrol eder vefalse , böylece else(normal gibiif/else ) ve sonra döngü yapılır.

Bu nedenle else , koşul kontrol edildiğinde yalnızca get'in yürütüldüğüne dikkat edin . Bu, örneğin a returnveya a ile yürütmenin ortasında döngü gövdesinden çıkarsanız,break , koşul tekrar kontrol edilmediğinden,else durum yürütülmez.

continueÖte yandan A , geçerli yürütmeyi durdurur ve daha sonra döngünün durumunu tekrar kontrol etmek için geri atlar, bu yüzden elsebu senaryoda ulaşılabilir.

Döngünün elsemaddesiyle ilgili anım , Raymond Hettinger tarafından nasıl çağrılması gerektiğini düşündüğünü anlatan bir konuşmayı izlediğim zamandı nobreak. Aşağıdaki koda bir bakın, ne yapacağını düşünüyorsunuz?

for i in range(10):
    if test(i):
        break
    # ... work with i
nobreak:
    print('Loop completed')

Ne olacağını tahmin ederdin? Peki, bu kısım nobreaksadece breakdöngüde bir cümle vurulmamışsa yürütülür .

Genellikle böyle bir döngü yapısını düşünme eğilimindeyim:

for item in my_sequence:
    if logic(item):
        do_something(item)
        break

Değişken sayıda if/elififadeye çok benzemek için :

if logic(my_seq[0]):
    do_something(my_seq[0])
elif logic(my_seq[1]):
    do_something(my_seq[1])
elif logic(my_seq[2]):
    do_something(my_seq[2])
....
elif logic(my_seq[-1]):
    do_something(my_seq[-1])

Bu durumda elsefor döngüsündeki elsedeyim, elifs zincirindeki deyim gibi çalışır , ancak koşullardan hiçbiri True olarak değerlendirilmeden önce yürütülür. (veya yürütme ile returnbir istisna veya bir istisna) Döngüm bu spesifikasyona uymuyorsa, genellikle for: elsebu soruyu yayınladığınız nedenden dolayı kullanmayı tercih etmeyi seçerim : sezgisel değildir.

Diğerleri zaten mekaniği açıkladık while/for...elseve Python 3 dil referans (bkz yetkili tanıma sahip iken ve için ), ama burada benim kişisel anımsatıcı FWIW olduğunu. Sanırım benim için anahtar bunu iki parçaya ayırmak oldu: biri elsedöngü koşuluyla ilişkili anlamını anlamak için ve diğeri döngü kontrolünü anlamak için.

Anlayarak başlamak en kolay yolu buluyorum while...else:

whileDaha fazla eşyaya sahipsin, bir şeyler yap, elsebiterse, bunu yap

for...elseAnımsatıcı temelde aynıdır:

forher öğe, bir şeyler yapın, ama elsebiterse, bunu yapın

Her iki durumda da, elseparçaya yalnızca işlenecek başka öğe kalmadığında ve son öğe düzenli bir şekilde işlendikten sonra ulaşılır (örn.break veya return). A continuesadece geri döner ve daha fazla öğe olup olmadığını görür. Bu kuralların için My anımsatıcı için geçerlidir whileve for:

ne zaman breaking veya returning , elseyapacak bir şey yok
ve dediğimde continue, bu sizin için "geri dönmek için geri dön"

- "başlamak için geri dön" ile, açıkçası, yinelenebilirde daha fazla öğe olup olmadığını kontrol ettiğimiz döngü başlangıcı else , söz konusu olduğunda, continuegerçekten hiçbir rol oynamaz.

In gelişme Test güdümlü kullanırken, (TDD) Dönüşüm Öncelik öncül paradigma, koşullu ifadelerin bir genelleme olarak döngüler davranın.

Yalnızca basit if/else(hayır elif) ifadeleri göz önünde bulundurursanız, bu yaklaşım bu sözdizimi ile iyi bir şekilde birleşir :

if cond:
    # 1
else:
    # 2

genelleme:

while cond:  # <-- generalization
    # 1
else:
    # 2

güzelce.

Diğer bir deyişle, TDD tek bir vakadan koleksiyonları olan vakalara doğru adımlar daha fazla yeniden düzenleme gerektirir.

İşte 8thlight blogundan bir örnek :

8thlight blogundaki bağlantılı makalede, Word Wrap kata dikkate alınır: sbelirli bir genişliğe (aşağıdaki snippet'lerde değişken) sığdırmak için dizelere satır kesmeleri ( aşağıdaki snippet'lerde değişken) ekleme length. Bir noktada uygulama aşağıdaki gibi görünür (Java):

String result = "";
if (s.length() > length) {
    result = s.substring(0, length) + "\n" + s.substring(length);
} else {
    result = s;
}
return result;

ve şu anda başarısız olan bir sonraki test:

@Test
public void WordLongerThanTwiceLengthShouldBreakTwice() throws Exception {
    assertThat(wrap("verylongword", 4), is("very\nlong\nword"));
    }

Koşullu olarak çalışan bir kodumuz var: belirli bir koşul karşılandığında satır sonu eklenir. Birden çok satır sonunu işlemek için kodu geliştirmek istiyoruz. Makalede sunulan çözüm, (if-> while) dönüşümünü , ancak yazar şu yorumu yapar:

Döngüler elseyan tümcelere sahip olamazken,else yolu daha az yaparak yoluif . Yine, bu bir yeniden düzenleme.

başarısız bir test bağlamında kodda daha fazla değişiklik yapmaya zorlar:

String result = "";
while (s.length() > length) {
    result += s.substring(0, length) + "\n";
    s = s.substring(length);
}
result += s;

TDD'de testleri geçmek için mümkün olduğunca az kod yazmak istiyoruz. Python'un sözdizimi sayesinde aşağıdaki dönüşüm mümkündür:

dan:

result = ""
if len(s) > length:
    result = s[0:length] + "\n"
    s = s[length:]
else:
    result += s

için:

result = ""
while len(s) > length:
    result += s[0:length] + "\n"
    s = s[length:]
else:
    result += s

Gördüğüm şekilde else:, döngünün sonunu geçtiğinizde ateşlenir.

Siz breakya returnda ya da raisedöngü sonunu aşmazsanız, hemen durursunuz ve böylece else:blok çalışmaz. Eğer varsa continuedöngünün sonuna geçmiş hala yinelerler devam beri hemen yanında yineleme atlar. Döngüyü durdurmaz.

Maddeyi elsedöngü yapısının bir parçası olarak düşünün ; breakdöngü yapısından tamamen kopar ve böyleceelse yan .

Ama gerçekten, zihinsel eşlemem basitçe desen C / C ++ deseninin 'yapılandırılmış' versiyonu:

  for (...) {
    ...
    if (test) { goto done; }
    ...
  }
  ...
done:
  ...

Yani, for...elsekendimle karşılaştığımda ya da yazdığımda, doğrudan anlamak yerine , onu zihinsel olarak yukarıdaki örüntü anlayışına çeviriyorum ve sonra python sözdiziminin hangi bölümlerinin örüntünün hangi bölümlerine eşlendiğini anlıyorum.

(Korku tırnak içine 'yapılandırılmış' koydum çünkü fark kodun yapılandırılmış veya yapılandırılmamış olması değil, sadece belirli yapıya adanmış anahtar kelimeler ve dilbilgisi olup olmadığıdır)

Eğer eşleştirirseniz elseile for, bu kafa karıştırıcı olabilir. Anahtar kelimenin elsebu sözdizimi için mükemmel bir seçim olduğunu düşünmüyorum , ancak hangisini içeren elseile ifeşlerseniz break, bunun gerçekten mantıklı olduğunu görebilirsiniz. elseönceki bir ififade yoksa zar zor yararlıdır ve ben bu yüzden sözdizimi tasarımcı anahtar kelimeyi seçti inanıyorum.

İnsan dilinde göstereyim.

forşüpheli bir gruptaki her kişi soruşturmanın ifsuçlu olduğunu break. elserapor hatası.

Bunu düşünmek yolu, anahtar anlamını ele almaktır continueziyade else.

Bahsettiğiniz diğer anahtar kelimeler döngüden çıkar (anormal olarak çıkar) continue , ancak döngü içinde kod bloğunun geri kalanını atlıyor. Döngü sonlandırmadan önce gelmesi rastlantısaldır: sonlandırma, döngü koşullu ifadesinin değerlendirilmesi ile gerçekte normal şekilde yapılır.

O zaman elseyan tümcenin normal döngü sonlandırmasından sonra yürütüldüğünü hatırlamanız gerekir .

# tested in Python 3.6.4
def buy_fruit(fruits):
    '''I translate the 'else' below into 'if no break' from for loop '''
    for fruit in fruits:
        if 'rotten' in fruit:
            print(f'do not want to buy {fruit}')
            break
    else:  #if no break
        print(f'ready to buy {fruits}')


if __name__ == '__main__':
    a_bag_of_apples = ['golden delicious', 'honeycrisp', 'rotten mcintosh']
    b_bag_of_apples = ['granny smith', 'red delicious', 'honeycrisp', 'gala', 'fuji']
    buy_fruit(a_bag_of_apples)
    buy_fruit(b_bag_of_apples)

'''
do not want to buy rotten mcintosh
ready to buy ['granny smith', 'red delicious', 'honeycrisp', 'gala', 'fuji']
'''