Prev: Got undefined symbol: _PyUnicodeUCS2_AsDefaultEncodedString on OpenSuSE 11.1
Next: llvm vs. parrot
From: kj on 25 Sep 2009 15:01 In Perl, one can label loops for finer flow control. For example: X: for my $x (@X) { Y: for my $y (@Y) { for my $z (@Z) { next X if test1($x, $y, $z); next Y if test2($x, $y, $z); frobnicate($x, $y, $z); } glortz($x, $y); } splat($x); } What's considered "best practice" in the Python world for this sort of situation? The only approach I can think of requires setting up indicator variables that must be set and tested individually; e.g. for x in X: next_X = False for y in Y: next_Y = False for z in Z: if test1(x, y, z): next_X = True break if test2(x, y, z): next_Y = True break frobnicate(x, y, z) if next_X: break if next_Y: continue glortz(x, y) if next_X: continue splat(x) Whereas I find the Perl version reasonably readable, the Python one I find nearly incomprehensible. In fact, I'm not even sure that the Python version faithfully replicates what the Perl one is doing! Is there a better approach? TIA! kynn
From: Simon Forman on 25 Sep 2009 16:06 On Fri, Sep 25, 2009 at 3:01 PM, kj <no.email(a)please.post> wrote: > > > In Perl, one can label loops for finer flow control. For example: > > X: for my $x (@X) { > Y: for my $y (@Y) { > for my $z (@Z) { > next X if test1($x, $y, $z); > next Y if test2($x, $y, $z); > frobnicate($x, $y, $z); > } > glortz($x, $y); > } > splat($x); > } > > What's considered "best practice" in the Python world for this sort > of situation? The only approach I can think of requires setting > up indicator variables that must be set and tested individually; > e.g. > > for x in X: > next_X = False > for y in Y: > next_Y = False > for z in Z: > if test1(x, y, z): > next_X = True > break > if test2(x, y, z): > next_Y = True > break > frobnicate(x, y, z) > if next_X: > break > if next_Y: > continue > glortz(x, y) > if next_X: > continue > splat(x) > > Whereas I find the Perl version reasonably readable, the Python > one I find nearly incomprehensible. In fact, I'm not even sure > that the Python version faithfully replicates what the Perl one is > doing! > > Is there a better approach? > > TIA! > > kynn > <snark>The best approach would be to reorganize your code so you didn't have to do that.</snark> Seriously though, I find both the perl and python versions nonobvious. You have had to use constructs like this in practice? Generally, I would use "flags" in tricky nested loops just like you did, perhaps with some comments to clarify things. An alternative might be to use custom exceptions. Hopefully someone smarter than me will come along and show an even better approach. class NextX(Exception): pass class NextY(Exception): pass for x in X: try: for y in Y: try: for z in Z: if test1(x, y, z): raise NextX if test2(x, y, z): raise NextY frobnicate(x, y, z) except NextY: continue glortz(x, y) except NextX: continue splat(x)
From: Terry Reedy on 25 Sep 2009 16:09 kj wrote: > > In Perl, one can label loops for finer flow control. For example: > > X: for my $x (@X) { > Y: for my $y (@Y) { > for my $z (@Z) { > next X if test1($x, $y, $z); > next Y if test2($x, $y, $z); > frobnicate($x, $y, $z); > } > glortz($x, $y); > } > splat($x); > } > > What's considered "best practice" in the Python world for this sort > of situation? The only approach I can think of requires setting > up indicator variables that must be set and tested individually; > e.g. > > for x in X: > next_X = False > for y in Y: > next_Y = False > for z in Z: > if test1(x, y, z): > next_X = True > break > if test2(x, y, z): > next_Y = True > break > frobnicate(x, y, z) > if next_X: > break > if next_Y: > continue > glortz(x, y) > if next_X: > continue > splat(x) > > Whereas I find the Perl version reasonably readable, the Python > one I find nearly incomprehensible. In fact, I'm not even sure > that the Python version faithfully replicates what the Perl one is > doing! > > Is there a better approach? 1. Put inner loops in a function and return instead of break. 2. Put inner loops in try: for.. for if cond: raise Something # or do operation that raises exception if cond is true except e: whatever tjr
From: Raymond Hettinger on 26 Sep 2009 06:35 On Sep 25, 12:01 pm, kj <no.em...(a)please.post> wrote: > In Perl, one can label loops for finer flow control. For example: > > X: for my $x (@X) { > Y: for my $y (@Y) { > for my $z (@Z) { > next X if test1($x, $y, $z); > next Y if test2($x, $y, $z); > frobnicate($x, $y, $z); > } > glortz($x, $y); > } > splat($x); > > } > > What's considered "best practice" in the Python world for this sort > of situation? The only approach I can think of requires setting > up indicator variables that must be set and tested individually; > e.g. <snip> > Whereas I find the Perl version reasonably readable, the Python > one I find nearly incomprehensible. In fact, I'm not even sure > that the Python version faithfully replicates what the Perl one is > doing! > > Is there a better approach? The Perl syntax is elegant and readable. There is not a Python direct equivalent, but then the situation doesn't come up often. For the outermost loop, a break or continue suffices. To exit multiple levels of loop, there a several choices including try/except, flags, and functions with returns. A try/except approach looks like this: class NextX(Exception):pass class NextY(Exception):pass for x in X: try: for y in Y: try: for z in Z: if test1(x,y,z): raise NextX if test2(x,y,z): raise NextY frobnicate(x,y,z) except NextY: pass except NextX: pass Another approach for exiting multiple levels of loops is wrap the inner calls in a function and return from them when needed: def f(x): for y in y: for z in Z: if test1(x,y,z): return frobnicate(x,y,z) for x in X: f(x) Or you can write a little state machine with flags and a single loop but that isn't very readable or satisfying. Raymond
From: Bearophile on 26 Sep 2009 16:17 Raymond Hettinger: > Another approach for exiting multiple levels of loops is wrap the > inner calls in a function and return from them when needed: > > def f(x): > for y in y: > for z in Z: > if test1(x,y,z): > return > frobnicate(x,y,z) > > for x in X: > f(x) That's usual the solution I use for this problem, it's a little rough and it has some performance cost, but it's readable and simple. In PHP break and continue accept an optional numeric value (default is 1, 0 is of course ignored) "which tells it how many nested enclosing structures are to be broken out of.": http://us2.php.net/manual/en/controlstructures.break.php http://us2.php.net/manual/en/controlstructures.continue.php That PHP design gives me shivers, it's horrid, bugprone and fragile: for x in X: for y in Y: for z in Z: if test1(x, y, z): continue 3 if test2(x, y, z): continue 2 frobnicate(x, y, z) glortz(x, y) splat(x) A better solution is to add labels to Python (I hope this code is equivalent to the original Perl one), that can optionally be used by "continue" and "break". This solution design is also used by D: label OUTER: for x in X: label INNER: for y in Y: for z in Z: if test1(x, y, z): continue OUTER if test2(x, y, z): continue INNER frobnicate(x, y, z) glortz(x, y) splat(x) Bye, bearophile

Pages: 1 Prev: Got undefined symbol: _PyUnicodeUCS2_AsDefaultEncodedString on OpenSuSE 11.1 Next: llvm vs. parrot 