"prove"

[Lucas Prado Melo]

Hello,
How could I "prove" to someone that python accepts this syntax using
the documentation (I couldn't find it anywhere):
classname.functionname(objectname)

[Marco Mariani]

Lucas Prado Melo wrote:

How could I "prove" to someone that python accepts this syntax using
the documentation (I couldn't find it anywhere):
classname.functionname(objectname)

TUtorial 9.3.4, method objects

What exactly happens when a method is called? You may have noticed that
x.f() was called without an argument above, even though the function
definition for f specified an argument. What happened to the argument?
Surely Python raises an exception when a function that requires an
argument is called without any -- even if the argument isn't actually
used...

Actually, you may have guessed the answer: the special thing about
methods is that the object is passed as the first argument of the
function. In our example, the call x.f() is exactly equivalent to
MyClass.f(x). In general, calling a method with a list of n arguments is
equivalent to calling the corresponding function with an argument list
that is created by inserting the method's object before the first argument.

[Bruno Desthuilliers]

Lucas Prado Melo a écrit :

Hello,
How could I "prove" to someone that python accepts this syntax using
the documentation (I couldn't find it anywhere):
classname.functionname(objectname)

Why do you need the documentation ? Just fire up your python shell and
hack a Q&D example:

Python 2.5.1 (r251:54863, May 2 2007, 16:56:35)
[GCC 4.1.2 (Ubuntu 4.1.2-0ubuntu4)] on linux2
Type "help", "copyright", "credits" or "license" for more information.

>>class Foo(object):

.... def bar(self):
.... print "in %s bar" % self
....

>>f = Foo()
Foo.bar(f)

in <__main__.Foo object at 0xb7dccd2cbar

>>f.bar()

in <__main__.Foo object at 0xb7dccd2cbar

>>>

[Duncan Booth]

"Lucas Prado Melo" <lu*****@dcc.ufba.brwrote:

Hello,
How could I "prove" to someone that python accepts this syntax using
the documentation (I couldn't find it anywhere):
classname.functionname(objectname)

Language reference, mostly section 5.3 Primaries

call ::=
primary "(" [argument_list [","]
| expression genexpr_for] ")"

primary ::=
atom | attributeref
| subscription | slicing | call

attributeref ::=
primary "." identifier

atom ::=
identifier | literal | enclosure
That shows fairly well how the classname.functioname bit works (it is an
attributeref which is a primary which forms the first part of a call),
but you'll have to wade through a fair bit of the grammar to show that
argument_list can be an identifier.
argument_list ::=
positional_arguments ["," keyword_arguments]
["," "*" expression]
["," "**" expression]
| keyword_arguments ["," "*" expression]
["," "**" expression]
| "*" expression ["," "**" expression]
| "**" expression

positional_arguments ::=
expression ("," expression)*

.... and so on ...

[Lucas Prado Melo]

On Fri, May 9, 2008 at 5:32 AM, Bruno Desthuilliers
<br********************@websiteburo.invalidwrote :

Why do you need the documentation ? Just fire up your python shell and hack
a Q&D example:

I agree. I said it to this person, but he insisted I should use documentation...

[Lucas Prado Melo]

Thanks for all the answers. I bet I will convince this guy!