report very strange behavior of user-defined class lambda function

[gseismic]

Bug report

Bug description:

class X:
    # HARD to define a pure lambda function in class
    fn_a = lambda x: x

    def test(self):
        print(f'{type(self.fn_a)=}')  # type(self.fn_a)=<class 'method'>
        assert self.fn_a() == self    # OK
        # assert self.fn_a(1) == 1    # ERROR: TypeError: X.<lambda>() takes 1 positional argument but 2 were given

    @classmethod
    def cls_test(cls):
        print(f'{type(cls.fn_a)=}') # type(cls.fn_a)=<class 'function'>
        assert cls.fn_a(1) == 1     # OK


x = X()
x.cls_test()
x.test()

print(f'{X.fn_a=}') # X.fn_a=<function X.<lambda> at 0x103086b60>

It is very HARD to define a pure lambda function in class, the result is unexpected.
I’m not sure if it was intentionally designed this way or if I missed something.

CPython versions tested on:

3.12

Operating systems tested on:

macOS

### Tasks

[TeamSpen210]

Lambdas are regular functions, just with no name set. And if you have a function defined in a class which you access on the instance, you get a bound method. To stop that you'll need to wrap it in a staticmethod object.

[tim-one]

To make @TeamSpen210's comment more explicit, your lambda is just a different way to spell this, which acts the same way in all respects:

    def fn_a(x):
        return x

Which in turn works the same as:

    def fn_a(self):
        return self

That is, there's nothing magical about the name "self" either - the first argument to a method is just usually named "self" by convention. Spelling it "x" instead is fine (just unusual).

[skirpichev]

To stop that you'll need to wrap it in a staticmethod object.

Just to keep an explicit example:

>>> class X:
...     fn_a = staticmethod(lambda x: x)
...     def test(self):
...         print(f'{type(self.fn_a)=}')
...         assert self.fn_a(1) == 1
...         
>>> X().test()
type(self.fn_a)=<class 'function'>

I think this can be closed.

[gseismic]

thank you all!
but:

in

    def test(self):
        print(f'{type(self.fn_a)=}')  # type(self.fn_a)=<class 'method'>
        assert self.fn_a() == self    # OK

the self bind as the first argument of function fn_a
but in

    def cls_test(cls):
        print(f'{type(cls.fn_a)=}') # type(cls.fn_a)=<class 'function'>
        assert cls.fn_a(1) == 1     # OK

the cls not bind as the first argument of function fn_a

when we define another class function

     @classmethod
     def fn_b(cls, x):
            return x

we can use like this:

      def test(self):
              self.fn_b(1)
              
       @classmethod
       def cls_test(cls):
               cls.fn_b(1)

both self and cls bind as the first argument of fn_b

I don't known what is making the difference, it not so straightforward

[gseismic]

Maybe the key point is: the doing-things of . is not so clear for outsiders. used for bind or a member of, not so clear.

actually, if . used as a member of, in:

 def test(self):
        print(f'{type(self.fn_a)=}')  # type(self.fn_a)=<class 'method'>
        assert self.fn_a() == self    # OK 

fn_a IS a member of class X, and the result of self.fn_a SHOULD be lambda x: x, so:

self.fn_a(1) is LEGAL, self.fn_a() NOT legal

[skirpichev]

the cls not bind as the first argument of function fn_a

Because cls_test in this example is a class method.

cls.fn_a - reference to the class function fn_a, i.e. cls.__dict__['fn_a'].
self.fn_a - (where self - an instance) reference to the bound method on instance. This method has a different signature.

>>> class A:
...     f = lambda x: x
...     
>>> A.f
<function A.<lambda> at 0x7f7cf5e67890>
>>> A().f
<bound method A.<lambda> of <__main__.A object at 0x7f7cf5e03600>>
>>> A.__dict__['f']
<function A.<lambda> at 0x7f7cf5e67890>
>>> import inspect
>>> inspect.signature(A.f)
<Signature (x)>
>>> inspect.signature(A().f)
<Signature ()>