Speed up inspect.signature() for Python functions

For real Python functions the parameter kinds and defaults come straight
from the code object, so the validation done by Parameter.__init__ is
redundant. Construct the Parameter objects directly, falling back to the
regular constructor for names that are not plain identifiers (e.g. the
".0" implicit argument of comprehensions). Parameter subclasses and
duck-typed functions keep the full validation.

inspect.signature() on a function with 7 parameters: 23.4 us -> 14.5 us.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: eendebakpt

Lib/inspect.py

@@ -2348,6 +2348,8 @@ def _signature_from_function(cls, func, skip_bound_arg=True,
         return _signature_fromstr(cls, func, s, skip_bound_arg)
 
     Parameter = cls._parameter_cls
+    if Parameter is _Parameter and not is_duck_function:
+        Parameter = _parameter_from_code
 
     # Parameter information.
     func_code = func.__code__
@@ -2835,6 +2837,25 @@ def __eq__(self, other):
                 self._annotation == other._annotation)
 
 
+_Parameter = Parameter
+
+
+def _parameter_from_code(name, kind, *, default=_empty, annotation=_empty):
+    """Private helper: fast Parameter construction for Python functions.
+
+    The kind and default are taken from the function itself and are
+    known to be valid, so only the name has to be checked.
+    """
+    if iskeyword(name) or not name.isidentifier():
+        return _Parameter(name, kind, default=default, annotation=annotation)
+    self = object.__new__(_Parameter)
+    self._name = name
+    self._kind = kind
+    self._default = default
+    self._annotation = annotation
+    return self
+
+
 class BoundArguments:
     """Result of `Signature.bind` call.  Holds the mapping of arguments
     to the function's parameters.

Lib/test/test_inspect/test_inspect.py

@@ -5656,6 +5656,20 @@ def test_signature_parameter_implicit(self):
         self.assertEqual(param.kind, inspect.Parameter.POSITIONAL_ONLY)
         self.assertEqual(param.name, 'implicit0')
 
+    @cpython_only
+    def test_signature_from_code_unusual_names(self):
+        def f(a, b): pass
+        f.__code__ = f.__code__.replace(co_varnames=('.0', 'b'))
+        sig = inspect.signature(f)
+        self.assertEqual(list(sig.parameters), ['implicit0', 'b'])
+        self.assertEqual(sig.parameters['implicit0'].kind,
+                         inspect.Parameter.POSITIONAL_ONLY)
+
+        f.__code__ = f.__code__.replace(co_varnames=('if', 'b'))
+        with self.assertRaisesRegex(ValueError,
+                                    'is not a valid parameter name'):
+            inspect.signature(f)
+
     def test_signature_parameter_immutability(self):
         p = inspect.Parameter('spam', kind=inspect.Parameter.KEYWORD_ONLY)