Check if two Python functions are equal

Question

I am wondering how I could check to see if two functions are the same. An example would be (lambda x: x) == (lambda y: y) evaluating to true. As far as I know, Python will check to see if the functions occupy the same location in memory, but not whether they have the same operation. I know it seems impractical to have that functionality.

Another solution would be some method I can run on a function to see what it contains or how it works. So a kind of (lambda x: x).what() that would return how the method works, maybe in a dictionary or something.

I would love an answer, but I doubt it's possible.

Closely related: [Developing a heuristic to test simple anonymous Python functions for equivalency](http://stackoverflow.com/q/9963155), [Clojure test for equality of function expression](http://stackoverflow.com/q/9393713) — jscs, Nov 18 '13 at 22:13
… although the answers to the Python question seem to assume that it's impossible to get the bytecode directly, and therefore you have to disassemble it and then try to strip out all the extra stuff the disassembler added from sources other than the bytecode, which is silly when it's actually perfectly possible (and a lot simpler) to just get the bytecode directly… — abarnert, Nov 18 '13 at 22:34
In case anybody else came here to find out how to compare two references to the same function: `f==g` works for me — lucidbrot, Feb 05 '18 at 21:11

Martijn Pieters · Answer 1 · 2017-04-09T16:59:28.387

52

The one thing you could test for is code object equality:

>>> x = lambda x: x
>>> y = lambda y: y
>>> x.__code__.co_code
'|\x00\x00S'
>>> x.__code__.co_code == y.__code__.co_code
True

Here the bytecode for both functions is the same. You'll perhaps need to verify more aspects of the code objects (constants and closures spring to mind), but equal bytecode should equal the same execution path.

There are of course ways to create functions that return the same value for the same input, but with different bytecode; there are always more ways to skin a fish.

edited Apr 09 '17 at 16:59

answered Nov 18 '13 at 22:12

Martijn Pieters

1,048,767
296
4,058
3,343

You can also create objects where your test is true, but the result is different. (This is a bit contrived, but whatever...): https://gist.github.com/sharth/7536465 – Bill Lynch Nov 18 '13 at 22:24
2

@sharth: And the answer already covers that: "You'll perhaps need to verify…" He gave closures as one example. Custom function attributes are another. Giving the function a different `__globals__` is another. I don't think we need an exhaustive list. – abarnert Nov 18 '13 at 22:28
*You say fish and I say catato.* ♪‎ – Jean-François Corbett Oct 08 '18 at 10:52
5

`lambda x: x+1` and `lambda x: x+2` are also equal according to this definition. – Andreas Mueller Dec 09 '20 at 23:56
4

@AndreasMueller: that falls under the same heading as abarnert's comment; there it is the code object's `co_consts` tuple that varies. – Martijn Pieters Dec 13 '20 at 10:53
Thanks! that makes sense but was quite surprising to me. – Andreas Mueller Dec 14 '20 at 19:34

score 15 · Accepted Answer · answered Nov 18 '13 at 22:27

If you really want to know whether two functions always do the same thing for all inputs, you will have to run them both on all inputs (which will take infinite time), and also intercept all possible side effects (which is effectively impossible).

You could of course come up with some heuristics, throwing a set of different values at them that, for your application area, are very likely to generate different outputs if the functions are different. But there's obviously no general-purpose solution to that—otherwise, all unit tests would be generated automatically, saving us all a whole lot of work, right?

Conversely, you might just want to know whether two functions have the exact same implementation. For that, Martijn Pieters's answer is the obvious starting point, and possibly even the ending point (depending on whether you care about closures, globals, etc.).

But what you asked for is something different from either of these; you apparently want to look over the code manually to see "how it works":

Another solution would be some method I can run on a function to see what it contains or how it works. So a kind of (lambda x: x).what() that would return how the method works, maybe in a dictionary or something.

That function already exists: dis.dis. When you run it on a function, it tells you how that function works. Not in a dictionary (a dictionary of what?) but in a sequence of lines of bytecode for the Python interpreter (which is a relatively simple stack machine with some higher-level stuff added on top, mostly described right there in the dis docs).

Or, even more simply, you can get the source with inspect.getsource.

Here's what the two look like with your examples:

>>> f1 = lambda x: x
>>> f2 = lambda y: y
>>> def f3(z):
...     return z
>>> dis.dis(f1)
  1           0 LOAD_FAST                0 (x)
              3 RETURN_VALUE
>>> dis.dis(f2)
  1           0 LOAD_FAST                0 (y)
              3 RETURN_VALUE
>>> dis.dis(f3)
  1           0 LOAD_FAST                0 (z)
              3 RETURN_VALUE
>>> inspect.getsource(f1)
'f1 = lambda x: x\n'
>>> inspect.getsource(f2)
'f2 = lambda y: y\n'
>>> inspect.getsource(f3)
'def f3(z):\n    return z\n'

In the first case, you need to know enough about dis to realize that the (x), etc., are not part of the bytecode, but rather part of the function's list of local names. (This is explained as much in the inspect docs as in the dis docs.) In the second, you need to know enough about Python to realize that the def and the lambda are defining the exact same function. So, either way, there's no way to automate this (or, really, anything much beyond Martijn's answer).

In some cases, it is possible to prove the equivalence of functions using automated theorem provers such as [Z3](https://stackoverflow.com/a/13935888/975097). — Anderson Green, Jan 12 '22 at 20:48

Check if two Python functions are equal

2 Answers2

Linked

Related