To extract the magnitude of a difference, use the abs() function:

abs(x - y)

But what about extracting the sign of that difference? In the before times, Python2 had cmp():

cmp(20, 30)  # -1
cmp(20, 20)  #  0
cmp(20, 10)  #  1

And it was beautiful, because it could be used to extract the sign of a single number too:

cmp(x, 0)

Unfortunately, cmp() was removed in Python3. Not a problem. It's easy enough to implement by hand:

def cmp(a, b):
    if a < b:
        return -1
    elif a == b:
        return 0
    else:
        return 1

But this seems silly. Why take away the function in the first place? While researching the answer, I discovered that the Python3 release notes recommended their own implementation for cmp():

def cmp(a, b):
    return (a > b) - (a < b)

Whoa. This implementation is elegant, but it's also bonkers. It performs subtraction between numbers, converts those results to booleans, and then performs another subtraction between boolean values! And that boolean subtraction only works because, in Python, True evaluates to 1 when cast to an integer, while False evaluates to 0. I can't believe this is the recommendation!

Getting back to the original question, it seems like cmp() was removed to simplify and unify the various Python comparison functions already available, such as the operator standard library.

And interestingly enough, attempts were made to include a comparable sign() function in Python3. Check out this patch from 2007. However, disagreements on the correct treatment for +/-0 and +/-NAN inputs prevented the patch from being accepted. For example, the patch implementation for sign(0) would return 1, a stark difference from the 0 that cmp(0, 0) would have returned.

This may seem unintuitive, but it matches the behaviour of copysign() from the math standard library. The copysign() function takes the magnitude of its first input and combines it with the sign of the second, like so:

import math

math.copysign(10, -1)  # -10
math.copysign(10,  1)  #  10
math.copysign(10, -5)  # -10
math.copysign(10,  5)  #  10

Note that its behaviour around zeroes can be tricky:

import math

math.copysign(10,  0)    #  10
math.copysign(10, -0)    #  10
math.copysign(10, -0.0)  # -10

This is probably so that it matches the implementation of copysign() functions in other languages, including C++ and Javascript. Don't let it stump you!