Is this a contradiction in the docs ?

F

Fuzzyman

The following two passages from the python documentation *appear* to
contradict each other. Equally possible (or more likely !) is that I
misunderstand it :

eval :
This function can also be used to execute arbitrary code objects (such
as those created by compile()). In this case pass a code object instead
of a string. The code object must have been compiled passing 'eval' as
the kind argument.


compile:
The kind argument specifies what kind of code must be compiled; it can
be 'exec' if string consists of a sequence of statements, 'eval' if it
consists of a single expression, or 'single' if it consists of a single
interactive statement (in the latter case, expression statements that
evaluate to something else than None will be printed).

The docs for compile say that if you are creating a code object from a
sequence of statements you must use the kind argument 'exec'. Eval says
that if you are using the eval function you must use 'eval' as your
kind argument.

In practise I have found that using the eval function with code objects
compiled with 'exec' as the kind argument works fine. Is this a 'bug'
in the docs ?
Regards,

Fuzzy
http://www.voidspace.org.uk/python/index.shtml
 
P

Pierre Barbier de Reuille

Fuzzyman a écrit :
The following two passages from the python documentation *appear* to
contradict each other. Equally possible (or more likely !) is that I
misunderstand it :

eval :
This function can also be used to execute arbitrary code objects (such
as those created by compile()). In this case pass a code object instead
of a string. The code object must have been compiled passing 'eval' as
the kind argument.


compile:
The kind argument specifies what kind of code must be compiled; it can
be 'exec' if string consists of a sequence of statements, 'eval' if it
consists of a single expression, or 'single' if it consists of a single
interactive statement (in the latter case, expression statements that
evaluate to something else than None will be printed).

The docs for compile say that if you are creating a code object from a
sequence of statements you must use the kind argument 'exec'. Eval says
that if you are using the eval function you must use 'eval' as your
kind argument.

In practise I have found that using the eval function with code objects
compiled with 'exec' as the kind argument works fine. Is this a 'bug'
in the docs ?
Regards,

Fuzzy
http://www.voidspace.org.uk/python/index.shtml

IMO, it's just logical the code sent to "eval" was compiled with "eval"
as the kind argument. But don't forget the documentation is kind of
"abstract" and that CPython is _just_ an implementation (ok, it's the
reference implementation) of python. You'd better follow the doc if you
want your code to work on other Python implementation (ie. JPython, ...).

Pierre
 
F

Fuzzyman

Pierre said:
Fuzzyman a écrit :

IMO, it's just logical the code sent to "eval" was compiled with "eval"
as the kind argument. But don't forget the documentation is kind of
"abstract" and that CPython is _just_ an implementation (ok, it's the
reference implementation) of python. You'd better follow the doc if you
want your code to work on other Python implementation (ie. JPython, ....).

Yes.. but that would mean that eval could only run code objects that
"consist of a single expression".. which I doubt is the reality or
the intention.

Regards,
Fuzzyman
http://www.voidspace.org.uk/python/index.shtml
 
S

Steve Holden

Fuzzyman said:
The following two passages from the python documentation *appear* to
contradict each other. Equally possible (or more likely !) is that I
misunderstand it :

eval :
This function can also be used to execute arbitrary code objects (such
as those created by compile()). In this case pass a code object instead
of a string. The code object must have been compiled passing 'eval' as
the kind argument.


compile:
The kind argument specifies what kind of code must be compiled; it can
be 'exec' if string consists of a sequence of statements, 'eval' if it
consists of a single expression, or 'single' if it consists of a single
interactive statement (in the latter case, expression statements that
evaluate to something else than None will be printed).

The docs for compile say that if you are creating a code object from a
sequence of statements you must use the kind argument 'exec'. Eval says
that if you are using the eval function you must use 'eval' as your
kind argument.

In practise I have found that using the eval function with code objects
compiled with 'exec' as the kind argument works fine. Is this a 'bug'
in the docs ?
Regards,

"Dear List:

I live close to a railroad, and the tracks are surrounded by a fence
with large signs saying 'Walking on the tracks can be dangerous'.

I have walked on the tracks several times, however, and I don't see why
the railway company put those signs there. In fact I'm walking along the
tracks right now as I enter this post on my hand-held, and

[message ends with sound of locomotive horn followed by an ugly squelch]."

That's the kind of practice best avoided. Are you breaking the rules
just for the fun of it?

regards
Steve
 
P

Pierre Barbier de Reuille

Fuzzyman a écrit :
Yes.. but that would mean that eval could only run code objects that
"consist of a single expression".. which I doubt is the reality or
the intention.

Regards,
Fuzzyman
http://www.voidspace.org.uk/python/index.shtml


[Sorry, I deleted the commented lines because they were completely
unreadable anyway]

It's exactly what eval is for : evaluate a single expression and return
its result ! Try with strings : you can't even evaluate a statement !
You can only evaluate an expression !

And what would be the return result of a sequence of statement ?

If you want to execute a sequence, you want to use exec, not eval ...

Pierre
 
F

Fuzzyman

Steve said:
Fuzzyman said:
The following two passages from the python documentation *appear* to
contradict each other. Equally possible (or more likely !) is that I
misunderstand it :

eval :
This function can also be used to execute arbitrary code objects (such
as those created by compile()). In this case pass a code object instead
of a string. The code object must have been compiled passing 'eval' as
the kind argument.


compile:
The kind argument specifies what kind of code must be compiled; it can
be 'exec' if string consists of a sequence of statements, 'eval' if it
consists of a single expression, or 'single' if it consists of a single
interactive statement (in the latter case, expression statements that
evaluate to something else than None will be printed).

The docs for compile say that if you are creating a code object from a
sequence of statements you must use the kind argument 'exec'. Eval says
that if you are using the eval function you must use 'eval' as your
kind argument.

In practise I have found that using the eval function with code objects
compiled with 'exec' as the kind argument works fine. Is this a 'bug'
in the docs ?
Regards,

"Dear List:

I live close to a railroad, and the tracks are surrounded by a fence
with large signs saying 'Walking on the tracks can be dangerous'.

I have walked on the tracks several times, however, and I don't see why
the railway company put those signs there. In fact I'm walking along the
tracks right now as I enter this post on my hand-held, and

[message ends with sound of locomotive horn followed by an ugly squelch]."

That's the kind of practice best avoided. Are you breaking the rules
just for the fun of it?

Hmm.... documentation on code objects says :

Code objects are returned by the built-in compile() function and can be
extracted from function objects through their func_code attribute.

A code object can be executed or evaluated by passing it (instead of a
source string) to the exec statement or the built-in eval() function.

It mentions no such restriction. I didn't properly absorb the 'must' in
the eval description......

Hmmm... my code will *never* need to run on anything other than CPython
because I use py2exe to turn it into a frozen python distribution. So
if it was always safe in CPython then that would be fine for me.

The reason I like eval is that "If both dictionaries are omitted, the
expression is executed in the environment where eval is called".
However I think exec might do the same thing anyway. I'll just switch
to exec.

Regards,

Fuzzy
http://www.voidspace.org.uk/python/index.shtml
 
F

Fuzzyman

Pierre said:
Fuzzyman a écrit :
Yes.. but that would mean that eval could only run code objects that
"consist of a single expression".. which I doubt is the reality or
the intention.

Regards,
Fuzzyman
http://www.voidspace.org.uk/python/index.shtml


[Sorry, I deleted the commented lines because they were completely
unreadable anyway]


That's alright - I *have* to read via google, which hides quoted lines
anyway......
It's exactly what eval is for : evaluate a single expression and return
its result ! Try with strings : you can't even evaluate a statement !
You can only evaluate an expression !

Right.

And what would be the return result of a sequence of statement ?

:) I'm not interested in the return result. The code object is run in
the current namespace, so I use it to run scripts.
If you want to execute a sequence, you want to use exec, not eval ...

Yup - I've swapped them over in my code.

Thanks
Fuzzyman
http://www.voidspace.org.uk/python/index.shtml
 
S

Stefan Behnel

Fuzzyman said:
Hmmm... my code will *never* need to run on anything other than CPython
because I use py2exe to turn it into a frozen python distribution. So
if it was always safe in CPython then that would be fine for me.

No one will ever need more than 640K of RAM and BTW, my program will be
replaced well before the year 10000, so four digits for the year should be
enough...

Stefan
 
T

Terry Reedy

Fuzzyman said:
Equally possible (or more likely !) is that I misunderstand it :

Or that you did not sufficiently test the indicated difference ;-)
The docs for compile say that if you are creating a code object from a
sequence of statements you must use the kind argument 'exec'. Eval says
that if you are using the eval function you must use 'eval' as your
kind argument.

And I believe that if you use the eval function as a function, rather than
as a subroutine, the latter *is* true.
> In practise I have found that using the eval function with code objects
compiled with 'exec' as the kind argument works fine.

A minimal code example backing your claim would have been illuminative.
Eval'ing exec-compiled expressions does NOT work fine, as least not in 2.2,
and, I suspect, in all other versions:
.... print 'in test'
.... return 1
....in test
None # wrong due to exex-compile-eval mismatch bugin test
1

The compile flag affects the code generation, but it does not get attached
to the resulting code object. Eval runs the code object without knowing
whether the correct flag was used. Therefore, 'must use the correct flag'
means 'must, in order to get correct functioning' (in particular, the
return of the expression value rather than None), and not 'must, in order
to run at all'. A 'practise' that only tests running and ignores incorrect
value returning is not a complete test.

Terry J. Reedy
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

No members online now.

Forum statistics

Threads
473,744
Messages
2,569,484
Members
44,903
Latest member
orderPeak8CBDGummies

Latest Threads

Top