检索 output 字典 python function 的密钥而不调用 ZC1C425268E68385D1AB5074F14Z

Question

assuming I have the following simple function

def f(name: str):
    print (name) 
    return {'x': 2, 'y': 1}

Assuming I have access to the function f and I want to retrieve the keys of the returned value dict, without calling the function itself , is there a way to achieve this?

EDIT: The expected output in this case is: ['x', 'y']

Answer 1

Why not annotate the return type, using a TypedDict :

from typing import TypedDict


class F(TypedDict):
    x: int
    y: int


def f(name: str) -> F:
    print (name) 
    return {'x': 2, 'y': 1}

Not only does this make it easy to get the keys in the return dictionary from outside the function:

>>> f.__annotations__['return'].__annotations__.keys()
dict_keys(['x', 'y'])

it actually allows the type to be checked , both inside:

def f(name: str) -> F:
    return {'x': 2, 'y': 1}  # OK


def g(name: str) -> F:
    return {'x': 2, 'y': '1'}  # wrong type


def h(name: str) -> F:
    return {'x': 2, 'y': 1, 'z': 'foo'}  # extra key

and outside:

x: int = f('foo')['x']  # OK
y: str = f('foo')['y']  # wrong type
z: int = f('foo')['z']  # missing key

the function (see MyPy playground ). Otherwise the inferred return type is just dict[str, int] , which can't be checked so precisely, and you have to go spelunking into f.__code__ to find the keys.

Answer 2

TLDR: Fetch the values from f.__code__.co_consts[-1] .

>>> f.__code__.co_consts[-1]
('x', 'y')

---

Literals are encoded in the code and constants of a function object. A convenient means to inspect this is to use the builtin dis module :

>>> import dis
>>> dis.dis(f)
  2           0 LOAD_GLOBAL              0 (print)
              2 LOAD_FAST                0 (name)
              4 CALL_FUNCTION            1
              6 POP_TOP

  3           8 LOAD_CONST               1 (2)
             10 LOAD_CONST               2 (1)
             12 LOAD_CONST               3 (('x', 'y'))
             14 BUILD_CONST_KEY_MAP      2
             16 RETURN_VALUE

As one can see, building a dict such as {'x': a, 'y': b, ...} will first load the individual values, then a single tuple of all keys. If nothing else is loaded before returning the dict, the keys are the last constant of the function.

The code and constants of a function object is accessible for programmatic inspection. Fetching "the last constant of the function" f literally translates to f.__code__.co_consts[-1] .

---

Disclaimer: Extracting content from the code and constants of a function may be Python version dependent and especially depend on the function. Such an approach can be brittle and should not be used when arbitrary functions need to be processed.