Path: csiph.com!fu-berlin.de!uni-berlin.de!not-for-mail
From: Terry Reedy <tjreedy@udel.edu>
Newsgroups: comp.lang.python
Subject: Re: What arguments are passed to the __new__ method ?
Date: Tue, 1 Mar 2016 15:27:48 -0500
Lines: 95
Message-ID: <mailman.80.1456864099.20602.python-list@python.org>
References: <56d5d043$0$632$426a74cc@news.free.fr>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: quoted-printable
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:38.0) Gecko/20100101 Thunderbird/38.6.0
In-Reply-To: <56d5d043$0$632$426a74cc@news.free.fr>
Precedence: list
Xref: csiph.com comp.lang.python:103820

On 3/1/2016 12:24 PM, ast wrote:
> Hello
>
> It's not clear to me what arguments are passed to the
> __new__ method.

The objects passed to any function are the objects that are passed.  The =

type and number of objects that *should be* passed depends on the=20
signature of the function.

If class C defines __new__, then C.__new__ will receive as args C and=20
all args passed in a C(...) call.  So the C(...) call should have args=20
that match those expected by __new__.  If C also defines __init__, it=20
will get the same args other than self replacing cls and thus it should=20
have the same signature.

The case is covered by in the entry for __new__ in
https://docs.python.org/3/reference/datamodel.html#basic-customization

"If __new__() returns an instance of cls, then the new instance=E2=80=99s=
=20
__init__() method will be invoked like __init__(self[, ...]), where self =

is the new instance and the remaining arguments are the same as were=20
passed to __new__()."

> class Premiere:
>     def __new__(cls, price):
>          return object.__new__(cls)

This matches "Typical implementations create a new instance of the class =

by invoking the superclass=E2=80=99s __new__() method using super(current=
class,=20
cls).__new__(cls[, ...]) with appropriate arguments and then modifying=20
the newly-created instance as necessary before returning it."=20
object.__new__ only takes the cls parameter.

>     def __init__(self, price):
>             pass
> p =3D Premiere(1000)
>
> No errors, so it seems that 2 arguments are passed
> to __new__, cls and price,

and 2 arguments are passed to __init__, self and price -- as documented.

> But if i do:

> class Premiere:
>     def __new__(cls, price):
>         return object.__new__(cls, price)

You get an error in current python because you sent an extra arg to=20
object.__new__.  If __new__ calls a superclass __new__, then it should=20
only pass the args expected.  At one time, object.__new__ would have=20
accepted the price arg and ignored it.  This is no longer true

>     def __init__(self, price):
>         pass
> p =3D Premiere(1000)
>
> it fails. It is strange because according to me it is equivalent to:

Well, 'you' is wrong ;-), because in the following case,=20
Premiere.__new__ is object.__new__, which has a different signature than =

__new__ above.

> class Premiere:
>     def __init__(self, price):
>          pass
> p =3D Premiere(1000)
>
> which is OK.

Premiere is callable because it inherits object.__call__.  That=20
function, or the implementation of the CALL FUNCTION bytecode, must=20
notice that Premiere.__new__ is object.__new__, by inheritance, and only =

pass Premiere and not 1000.

The doc entry for __init__ says "The arguments are those passed to the=20
class constructor expression."  (The latter is the expression in the=20
code that results in the class call.)  This is always true.  But since=20
the signature of object.__new__ was restricted, the claim that the same=20
args are sent to __new__ and __init__ seems not to be true.

I may open a new doc issue.

--=20
Terry Jan Reedy