python · serhiy-storchaka · Sep 30, 2018 · Oct 1, 2018 · terryjreedy · May 14, 2023
@@ -320,7 +320,7 @@ The :mod:`bdb` module also defines two classes:
       ``(frame, lineno)`` tuple:
 
       * The canonical form of the filename which contains the frame.
-      * The function name, or ``"<lambda>"``.
+      * The function name.
       * The input arguments.
       * The return value.
       * The line of code (if it exists).

diff --git a/Doc/library/pickle.rst b/Doc/library/pickle.rst
@@ -922,8 +922,7 @@ The following example reads the resulting pickled data. ::
 
 .. [#] Don't confuse this with the :mod:`marshal` module
 
-.. [#] This is why :keyword:`lambda` functions cannot be pickled:  all
-    :keyword:`lambda` functions share the same name:  ``<lambda>``.
+.. [#] This is why :keyword:`lambda` functions cannot be pickled.
 
 .. [#] The exception raised will likely be an :exc:`ImportError` or an
    :exc:`AttributeError` but it could be something else.

diff --git a/Doc/library/unittest.mock.rst b/Doc/library/unittest.mock.rst
@@ -172,7 +172,7 @@ code if they are used incorrectly:
    >>> mock_function('wrong arguments')
    Traceback (most recent call last):
     ...
-   TypeError: <lambda>() takes exactly 3 arguments (1 given)
+   TypeError: missing a required argument: 'b'
 
 :func:`create_autospec` can also be used on classes, where it copies the signature of
 the ``__init__`` method, and on callable objects where it copies the signature of
@@ -2236,7 +2236,7 @@ we try to call it incorrectly:
     >>> req = request.Request()
     Traceback (most recent call last):
      ...
-    TypeError: <lambda>() takes at least 2 arguments (1 given)
+    TypeError: missing a required argument: 'url'
 
 The spec also applies to instantiated classes (i.e. the return value of
 specced mocks):

@@ -107,6 +107,18 @@ Other Language Changes
   and :keyword:`return` statements.
   (Contributed by David Cuthbert and Jordan Chapman in :issue:`32117`.)
 
+* The repr and the name of :keyword:`lambda` functions will now contain
+  the signature and body expression. For example::
+
+    >>> f = lambda x, y=1: x+y
+    >>> f
+    <lambda x, y=1: x + y at 0x7f437cd27890>
+    >>> f.__name__
+    '<lambda x, y=1: x + y>'
+
+  (Contributed by Serhiy Storchaka in :issue:`32489`.)
+
+
 New Modules
 ===========
 

diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py
@@ -431,6 +431,7 @@ def test_compile_ast(self):
             ['<ifblock>', """if True:\n    pass\n"""],
             ['<forblock>', """for n in [1, 2, 3]:\n    print(n)\n"""],
             ['<deffunc>', """def foo():\n    pass\nfoo()\n"""],
+            ['<lambda>', """f = lambda x: x+1"""],
             [fname, fcontents],
         ]
 

diff --git a/Lib/test/test_docxmlrpc.py b/Lib/test/test_docxmlrpc.py
@@ -114,8 +114,8 @@ def test_lambda(self):
         self.client.request("GET", "/")
         response = self.client.getresponse()
 
-        self.assertIn((b'<dl><dt><a name="-&lt;lambda&gt;"><strong>'
-                       b'&lt;lambda&gt;</strong></a>(x, y)</dt></dl>'),
+        self.assertIn((b'<dl><dt><a name="-&lt;lambda x, y: x - y&gt;"><strong>'
+                       b'&lt;lambda x, y: x - y&gt;</strong></a>(x, y)</dt></dl>'),
                       response.read())
 
     @make_request_and_skipIf(sys.flags.optimize >= 2,

diff --git a/Lib/test/test_funcattrs.py b/Lib/test/test_funcattrs.py
@@ -135,7 +135,7 @@ def test___qualname__(self):
         self.assertEqual(FuncAttrsTest.setUp.__qualname__, 'FuncAttrsTest.setUp')
         self.assertEqual(global_function.__qualname__, 'global_function')
         self.assertEqual(global_function().__qualname__,
-                         'global_function.<locals>.<lambda>')
+                         '<lambda: inner_function>')
         self.assertEqual(global_function()().__qualname__,
                          'global_function.<locals>.inner_function')
         self.assertEqual(global_function()()().__qualname__,

diff --git a/Lib/test/test_reprlib.py b/Lib/test/test_reprlib.py
@@ -145,8 +145,8 @@ def test_instance(self):
         self.assertIn(s.find("..."), [12, 13])
 
     def test_lambda(self):
-        r = repr(lambda x: x)
-        self.assertTrue(r.startswith("<function ReprTests.test_lambda.<locals>.<lambda"), r)
+        r = repr(lambda x, y=1: x+y)
+        self.assertTrue(r.startswith("<lambda x, y=1: x + y "), r)
         # XXX anonymous functions?  see func_repr
 
     def test_builtin_function(self):

diff --git a/Lib/tkinter/__init__.py b/Lib/tkinter/__init__.py
@@ -1360,15 +1360,18 @@ def _register(self, func, subst=None, needcleanup=1):
         be executed. An optional function SUBST can
         be given which will be executed before FUNC."""
         f = CallWrapper(func, subst, self).__call__
-        name = repr(id(f))
         try:
             func = func.__func__
         except AttributeError:
             pass
         try:
-            name = name + func.__name__
+            name = func.__name__
         except AttributeError:
-            pass
+            name = ''
+        else:
+            if not re.fullmatch('[a-zA-Z0-9_]+', name):
+                name = ''
+        name = repr(id(f)) + name
         self.tk.createcommand(name, f)
         if needcleanup:
             if self._tclCommands is None:

diff --git a/Lib/unittest/test/test_case.py b/Lib/unittest/test/test_case.py
@@ -1299,11 +1299,11 @@ def Stub():
 
     def testAssertNotRaisesRegex(self):
         self.assertRaisesRegex(
-                self.failureException, '^Exception not raised by <lambda>$',
+                self.failureException, '^Exception not raised by <lambda: None>$',
                 self.assertRaisesRegex, Exception, re.compile('x'),
                 lambda: None)
         self.assertRaisesRegex(
-                self.failureException, '^Exception not raised by <lambda>$',
+                self.failureException, '^Exception not raised by <lambda: None>$',
                 self.assertRaisesRegex, Exception, 'x',
                 lambda: None)
         # Custom message

diff --git a/Misc/NEWS.d/next/Core and Builtins/2018-09-30-21-15-54.bpo-34856.uQBZD7.rst b/Misc/NEWS.d/next/Core and Builtins/2018-09-30-21-15-54.bpo-34856.uQBZD7.rst
@@ -0,0 +1 @@
+The repr of lambda now contains the signature and body expression.
-The repr of lambda now contains the signature and body expression.
+Add signature and body expression to the repr of lambda.
-The repr of lambda now contains the signature and body expression.
+Add signature and body expression to the repr of lambda.
diff --git a/Objects/funcobject.c b/Objects/funcobject.c
@@ -554,8 +554,19 @@ func_dealloc(PyFunctionObject *op)
 static PyObject*
 func_repr(PyFunctionObject *op)
 {
-    return PyUnicode_FromFormat("<function %U at %p>",
-                               op->func_qualname, op);
+    PyObject *name = op->func_qualname;
+    Py_ssize_t len = PyUnicode_GET_LENGTH(name);
+    if (len > 2
+        && PyUnicode_READ_CHAR(name, 0) == '<'
+        && PyUnicode_READ_CHAR(name, len-1) == '>')
+    {
+        PyObject *repr = PyUnicode_Substring(name, 0, len-1);
+        if (repr) {
+            Py_SETREF(repr, PyUnicode_FromFormat("%U at %p>", repr, op));
+        }
+        return repr;
+    }
+    return PyUnicode_FromFormat("<function %U at %p>", name, op);
 }
 
 static int

@@ -2306,31 +2306,40 @@ static int
 compiler_lambda(struct compiler *c, expr_ty e)
 {
     PyCodeObject *co;
-    PyObject *qualname;
-    static identifier name;
+    PyObject *name, *exprstr;
     Py_ssize_t funcflags;
     arguments_ty args = e->v.Lambda.args;
     assert(e->kind == Lambda_kind);
 
+    exprstr = _PyAST_ExprAsUnicode(e);
+    if (!exprstr) {
+        return 0;
+    }
+    name = PyUnicode_FromFormat("<%U>", exprstr);
+    Py_DECREF(exprstr);
     if (!name) {
-        name = PyUnicode_InternFromString("<lambda>");
-        if (!name)
-            return 0;
+        return 0;
     }
 
     funcflags = compiler_default_arguments(c, args);
     if (funcflags == -1) {
+        Py_DECREF(name);
         return 0;
     }
 
     if (!compiler_enter_scope(c, name, COMPILER_SCOPE_LAMBDA,
                               (void *)e, e->lineno))
+    {
+        Py_DECREF(name);
         return 0;
+    }
 
     /* Make None the first constant, so the lambda can't have a
        docstring. */
-    if (compiler_add_const(c, Py_None) < 0)
+    if (compiler_add_const(c, Py_None) < 0) {
+        Py_DECREF(name);
         return 0;
+    }
 
     c->u->u_argcount = asdl_seq_LEN(args->args);
     c->u->u_kwonlyargcount = asdl_seq_LEN(args->kwonlyargs);
@@ -2342,14 +2351,14 @@ compiler_lambda(struct compiler *c, expr_ty e)
         ADDOP_IN_SCOPE(c, RETURN_VALUE);
         co = assemble(c, 1);
     }
-    qualname = c->u->u_qualname;
-    Py_INCREF(qualname);
     compiler_exit_scope(c);
-    if (co == NULL)
+    if (co == NULL) {
+        Py_DECREF(name);
         return 0;
+    }
 
-    compiler_make_closure(c, co, funcflags, qualname);
-    Py_DECREF(qualname);
+    compiler_make_closure(c, co, funcflags, name);
+    Py_DECREF(name);
     Py_DECREF(co);
 
     return 1;