# How to parse this line of code manually

Discussion in 'Python' started by Davy, Aug 28, 2007.

1. ### DavyGuest

Hi all,

It is well known that Python is appreciated for its merit of concise.
However, I found the over concise code is too hard to understand for
me.

Consider, for instance,
def known_edits2(word):
return set(e2 for e1 in edits1(word) for e2 in edits1(e1) if e2 in
NWORDS)

Shall I understand the code in set() as
for e2 in edits1(e1) {
if e2 in NWORDS {
for e1 in edits1(word) {
e2
}
}
}

And a general question is: Is there any tip available to understand
the code in one line, or what's the parsing priority (left to right,
right to left, or other possibilities)

Any suggestions are welcome!

The code is a simple spell checker from
http://www.norvig.com/spell-correct.html

Best regards,
Davy

Davy, Aug 28, 2007

2. ### DavyGuest

On Aug 28, 11:00 am, Davy <> wrote:
> Hi all,
>
> It is well known that Python is appreciated for its merit of concise.
> However, I found the over concise code is too hard to understand for
> me.
>
> Consider, for instance,
> def known_edits2(word):
> return set(e2 for e1 in edits1(word) for e2 in edits1(e1) if e2 in
> NWORDS)
>
> Shall I understand the code in set() as
> for e2 in edits1(e1) {
> if e2 in NWORDS {
> for e1 in edits1(word) {
> e2
> }
> }
>
> }
>

[SNIP]
Hi all, I figured it myself. It is left to righ parse, right?
So the above one is like
for e1 in edits1(word) {
for e2 in edits1(e1) {
if e2 in NWORDS {
push e2 to set
}
}
}
> And a general question is: Is there any tip available to understand
> the code in one line, or what's the parsing priority (left to right,
> right to left, or other possibilities)
>
> Any suggestions are welcome!
>
> The code is a simple spell checker fromhttp://www.norvig.com/spell-correct.html
>
> Best regards,
> Davy

Davy, Aug 28, 2007

3. ### A.T.HofkampGuest

On 2007-08-28, Davy <> wrote:
> On Aug 28, 11:00 am, Davy <> wrote:
>> Hi all,
>>
>> It is well known that Python is appreciated for its merit of concise.
>> However, I found the over concise code is too hard to understand for
>> me.
>>
>> Consider, for instance,
>> def known_edits2(word):
>> return set(e2 for e1 in edits1(word) for e2 in edits1(e1) if e2 in
>> NWORDS)
>>
>> Shall I understand the code in set() as
>> for e2 in edits1(e1) {
>> if e2 in NWORDS {
>> for e1 in edits1(word) {
>> e2
>> }
>> }
>>
>> }
>>

> [SNIP]
> Hi all, I figured it myself. It is left to righ parse, right?
> So the above one is like
> for e1 in edits1(word) {
> for e2 in edits1(e1) {
> if e2 in NWORDS {
> push e2 to set
> }
> }
> }

This is correct, although I am not sure what language you are using here, it
looks like a strange mix of Python and C to me.

>> Any suggestions are welcome!

The idea is known as List comprehension (for lists, obviously), and comes from
functional programming, Bird & Wadler used it in their book.

The notation is very close to mathematics:

{ e2 | e1: edits(word), e2: edits(e1) in NWORDS }

or in LaTeX:

$\{ e_2 | \forall e_1: \mathrm{edits}(\mathrm{words}), \forall e_2: \mathrm{edits}(e_1) \in \mathrm{NWORDS} \}$

(which in words is something like: collect values e2, where e1 comes from
'edits(word)', e2 comes from 'edits(e1)', and e2 in NWORDS)

Sincerely,
Albert

A.T.Hofkamp, Aug 28, 2007
4. ### DustanGuest

On Aug 28, 2:59 am, "A.T.Hofkamp" <> wrote:
> On 2007-08-28, Davy <> wrote:
>
>
>
> > On Aug 28, 11:00 am, Davy <> wrote:
> >> Hi all,

>
> >> It is well known that Python is appreciated for its merit of concise.
> >> However, I found the over concise code is too hard to understand for
> >> me.

>
> >> Consider, for instance,
> >> def known_edits2(word):
> >> return set(e2 for e1 in edits1(word) for e2 in edits1(e1) if e2 in
> >> NWORDS)

>
> >> Shall I understand the code in set() as
> >> for e2 in edits1(e1) {
> >> if e2 in NWORDS {
> >> for e1 in edits1(word) {
> >> e2
> >> }
> >> }

>
> >> }

>
> > [SNIP]
> > Hi all, I figured it myself. It is left to righ parse, right?
> > So the above one is like
> > for e1 in edits1(word) {
> > for e2 in edits1(e1) {
> > if e2 in NWORDS {
> > push e2 to set
> > }
> > }
> > }

>
> This is correct, although I am not sure what language you are using here, it
> looks like a strange mix of Python and C to me.
>
> >> Any suggestions are welcome!

>
> The idea is known as List comprehension (for lists, obviously), and comes from
> functional programming, Bird & Wadler used it in their book.
>
> The notation is very close to mathematics:
>
> { e2 | e1: edits(word), e2: edits(e1) in NWORDS }
>
> or in LaTeX:
>
> $\{ e_2 | \forall e_1: \mathrm{edits}(\mathrm{words}), > \forall e_2: \mathrm{edits}(e_1) \in \mathrm{NWORDS} \}$
>
>
>
> (which in words is something like: collect values e2, where e1 comes from
> 'edits(word)', e2 comes from 'edits(e1)', and e2 in NWORDS)
>

For more examples:
http://docs.python.org/tut/node7.html#SECTION007140000000000000000

A 'list comprehension' with parentheses instead of square-brackets
creates a generator instead of a list, which can be more memory-
efficient and allows for lazy evaluation.

Dustan, Aug 28, 2007
5. ### DavyGuest

On Aug 28, 7:28 pm, Dustan <> wrote:
> On Aug 28, 2:59 am, "A.T.Hofkamp" <> wrote:
>
>
>
>
>
> > On 2007-08-28, Davy <> wrote:

>
> > > On Aug 28, 11:00 am, Davy <> wrote:
> > >> Hi all,

>
> > >> It is well known that Python is appreciated for its merit of concise.
> > >> However, I found the over concise code is too hard to understand for
> > >> me.

>
> > >> Consider, for instance,
> > >> def known_edits2(word):
> > >> return set(e2 for e1 in edits1(word) for e2 in edits1(e1) if e2 in
> > >> NWORDS)

>
> > >> Shall I understand the code in set() as
> > >> for e2 in edits1(e1) {
> > >> if e2 in NWORDS {
> > >> for e1 in edits1(word) {
> > >> e2
> > >> }
> > >> }

>
> > >> }

>
> > > [SNIP]
> > > Hi all, I figured it myself. It is left to righ parse, right?
> > > So the above one is like
> > > for e1 in edits1(word) {
> > > for e2 in edits1(e1) {
> > > if e2 in NWORDS {
> > > push e2 to set
> > > }
> > > }
> > > }

>
> > This is correct, although I am not sure what language you are using here, it
> > looks like a strange mix of Python and C to me.

>
> > >> Any suggestions are welcome!

>
> > The idea is known as List comprehension (for lists, obviously), and comes from
> > functional programming, Bird & Wadler used it in their book.

>
> > The notation is very close to mathematics:

>
> > { e2 | e1: edits(word), e2: edits(e1) in NWORDS }

>
> > or in LaTeX:

>
> > $\{ e_2 | \forall e_1: \mathrm{edits}(\mathrm{words}), > > \forall e_2: \mathrm{edits}(e_1) \in \mathrm{NWORDS} \}$

>
> >

>
> > (which in words is something like: collect values e2, where e1 comes from
> > 'edits(word)', e2 comes from 'edits(e1)', and e2 in NWORDS)

>
> For more examples:http://docs.python.org/tut/node7.html#SECTION007140000000000000000

[SNIP]
Hi Hofkamp and Dustan,

Davy
>
> A 'list comprehension' with parentheses instead of square-brackets
> creates a generator instead of a list, which can be more memory-
> efficient and allows for lazy evaluation.- Hide quoted text -
>
> - Show quoted text -

Davy, Aug 29, 2007