Python: Dış döngüde sonraki yinelemeye devam ediliyor

Python'da dış döngüde bir sonraki yinelemeye devam etmenin herhangi bir yerleşik yolu olup olmadığını bilmek istedim. Örneğin, kodu düşünün:

for ii in range(200):
    for jj in range(200, 400):
        ...block0...
        if something:
            continue
    ...block1...

Bu continue ifadesinin jj döngüsünden çıkmasını ve ii döngüsündeki sonraki öğeye gitmesini istiyorum. Bu mantığı başka bir şekilde uygulayabilirim (bir bayrak değişkeni ayarlayarak), ancak bunu yapmanın kolay bir yolu var mı, yoksa bu çok fazlasını istemek gibi bir şey mi?

for i in ...:
    for j in ...:
        for k in ...:
            if something:
                # continue loop i

Genel bir durumda, birden fazla döngü düzeyiniz olduğunda ve breaksizin için çalışmadığında (çünkü mevcut döngüden değil, üst döngülerden birine devam etmek istiyorsanız), aşağıdakilerden birini yapabilirsiniz.

Kaçmak istediğiniz döngüleri bir işleve yeniden düzenleyin

def inner():
    for j in ...:
        for k in ...:
            if something:
                return


for i in ...:
    inner()

Dezavantajı, bu yeni işleve daha önce kapsamda olan bazı değişkenleri aktarmanız gerekebilmesidir. Bunları sadece parametre olarak iletebilir, onları bir nesne üzerinde örnek değişkenler yapabilirsiniz (eğer mantıklıysa, sadece bu fonksiyon için yeni bir nesne yaratabilirsiniz) veya global değişkenler, tekli tonlar, ne olursa olsun (ehm, ehm).

Veya inneriç içe geçmiş bir işlev olarak tanımlayabilir ve sadece ihtiyaç duyduğu şeyi yakalamasına izin verebilirsiniz (daha yavaş olabilir mi?)

for i in ...:
    def inner():
        for j in ...:
            for k in ...:
                if something:
                    return
    inner()

İstisnaları kullanın

Felsefi olarak, gerektiğinde yapısal programlama yapı taşlarından (if, for, while) program akışını kırmak için istisnalar budur.

Bunun avantajı, tek bir kod parçasını birden çok parçaya bölmeniz gerekmemesidir. Bu, Python'da yazarken tasarladığınız bir tür hesaplamaysa iyidir. Bu erken noktada soyutlamalara başlamak sizi yavaşlatabilir.

Bu yaklaşımla ilgili kötü olan şey, yorumlayıcı / derleyici yazarların genellikle istisnaların istisnai olduğunu varsaymaları ve buna göre optimize etmeleridir.

class ContinueI(Exception):
    pass


continue_i = ContinueI()

for i in ...:
    try:
        for j in ...:
            for k in ...:
                if something:
                    raise continue_i
    except ContinueI:
        continue

Bunun için özel bir istisna sınıfı oluşturun, böylece yanlışlıkla başka bir istisnayı susturma riskine girmezsiniz.

Tamamen başka bir şey

Eminim başka çözümler de vardır.

for ii in range(200):
    for jj in range(200, 400):
        ...block0...
        if something:
            break
    else:
        ...block1...

Break iç döngüyü kırar ve blok1 çalıştırılmaz (yalnızca iç döngüden normal olarak çıkılırsa çalışır).

Diğer dillerde, döngüyü etiketleyebilir ve etiketli döngüden kopabilirsiniz. Python Geliştirme Önerisi (PEP) 3136, bunları Python'a eklemeyi önerdi, ancak Guido bunu reddetti :

Ancak, bu özelliği gerektirecek kadar karmaşık bir kodun çok nadir olması nedeniyle reddediyorum. Çoğu durumda, örneğin 'dönüş' kullanarak temiz kod üreten mevcut çözüm yolları vardır. Geri dönüşü kullanmayı mümkün kılan bir yeniden düzenleme işleminden kodun netliğinin zarar görebileceği bazı (nadir) gerçek durumlar olduğundan eminim, ancak bu iki sorunla dengeleniyor:

1. Karmaşıklık dile kalıcı olarak eklendi. Bu sadece tüm Python uygulamalarını değil, aynı zamanda her kaynak analiz aracını ve elbette dil için tüm dokümantasyonu etkiler.

2. Özelliğin doğru kullanılacağından daha fazla kötüye kullanılacağına dair beklentim, kod netliğinde net bir düşüşe yol açacak (bundan sonra yazılan tüm Python kodlarında ölçülmüştür). Tembel programcılar her yerdedir ve siz farkına varmadan ellerinizde anlaşılmaz kodlardan inanılmaz bir karmaşa var.

Yani eğer şansınız kalmamışsa bunu umuyorsunuz, ama orada iyi seçenekler olduğu için diğer cevaplardan birine bakın.

Sanırım böyle bir şey yapabilirsin:

for ii in range(200):
    restart = False
    for jj in range(200, 400):
        ...block0...
        if something:
            restart = True
            break
    if restart:
        continue
    ...block1...

Bence bunu başarmanın en kolay yollarından biri "devam et" i "ara" ile değiştirmektir, yani

for ii in range(200):
 for jj in range(200, 400):
    ...block0...
    if something:
        break
 ...block1...       

Örneğin, tam olarak nasıl gittiğini görmek için işte kolay kod:

for i in range(10):
    print("doing outer loop")
    print("i=",i)
    for p in range(10):
        print("doing inner loop")
        print("p=",p)
        if p==3:
            print("breaking from inner loop")
            break
    print("doing some code in outer loop")

Bu tür bir sorunu çözmenin başka bir yolu da Exception () kullanmaktır.

for ii in range(200):
    try:
        for jj in range(200, 400):
            ...block0...
            if something:
                raise Exception()
    except Exception:
        continue
    ...block1...

Örneğin:

for n in range(1,4):
    for m in range(1,4):
        print n,'-',m

sonuç:

    1-1
    1-2
    1-3
    2-1
    2-2
    2-3
    3-1
    3-2
    3-3

M = 3 ise m döngüsünden dış n döngüsüne atlamak istediğimizi varsayarsak:

for n in range(1,4):
    try:
        for m in range(1,4):
            if m == 3:
                raise Exception()            
            print n,'-',m
    except Exception:
        continue

sonuç:

    1-1
    1-2
    2-1
    2-2
    3-1
    3-2

Referans bağlantısı: http://www.programming-idioms.org/idiom/42/continue-outer-loop/1264/python

Bir şey bulmak ve sonra içsel yinelemeyi durdurmak istiyoruz. Bayrak sistemi kullanıyorum.

for l in f:
    flag = True
    for e in r:
        if flag==False:continue
        if somecondition:
            do_something()
            flag=False

Ben sadece böyle bir şey yaptım. Bunun için benim çözümüm, iç for döngüsünü bir liste anlayışıyla değiştirmekti.

for ii in range(200):
    done = any([op(ii, jj) for jj in range(200, 400)])
    ...block0...
    if done:
        continue
    ...block1...

burada op, ii ve jj'nin bir kombinasyonuna göre hareket eden bir boole operatörüdür. Benim durumumda, işlemlerden herhangi biri doğru döndüyse, bitirdim.

Bu, kodu bir işleve bölmekten gerçekten farklı değil, ancak mantıksal OR yapmak için "herhangi" operatörünü kullanmanın ve mantığı tek bir satırda yapmanın ilginç olduğunu düşündüm. Aynı zamanda işlev çağrısını da önler.