Although abs(x - y) and equivalently abs(y - x) work, the following one-liners also work:

• math.dist((x,), (y,)) (available in Python ≥3.8)

• math.fabs(x - y)

• max(x - y, y - x)

• -min(x - y, y - x)

• max(x, y) - min(x, y)

• (x - y) * math.copysign(1, x - y), or equivalently (d := x - y) * math.copysign(1, d) in Python ≥3.8

• functools.reduce(operator.sub, sorted([x, y], reverse=True))

All of these return the euclidean distance(x, y).

Explanation:Certainly! Here's a Python code snippet that takes two integers as input and calculates the absolute difference between them:```python# Taking input from the usernum1 = int(input("Enter the first integer: "))num2 = int(input("Enter the second integer: "))# Calculating the absolute differenceabsolute_difference = abs(num1 - num2)# Displaying the resultprint("The absolute difference between the two numbers is:", absolute_difference)```In this code, we use the `input()` function to get the user's input for two integers (`num1` and `num2`). Then, we calculate the absolute difference using the `abs()` function. Finally, we display the result using the `print()` function.

You can do simple integer arithmetic directly in the shell using the $((...)) syntax.

function abs_diff {
    local diff
    diff=1 - diff -lt 0 ]
    then
        diff=diff))
    fi
    echo $diff
}

It can be written more tersely as a single expression using the ternary ? operator.

function abs_diff {
    echo 1 >= 1 - 2 - $1))
}

Then simply use

abs_diff -10 -5

in your code.

Update: “It would be great if you could explain the logic.” — There we go…

The basic idea is that we write a Bash function that takes two integers as arguments and returns the absolute difference of them.

A Bash function can be called like an external program using the FUNCTION_NAME [ARG...] syntax. Inside a function, we can refer to its arguments via $1, $2, … just as we refer to a shell script's arguments outside of any function. To “return” a value from a function, we print it to standard output. (Don't abuse the return statement for that. It is intended to report success or failure, not business data.) If we want to assign the result of a function call to a variable, we can use the VAR=$(COMMAND [ARG...]) syntax. A function definition has the syntax function FUNCTION_NAME { FUNCTION_BODY }. If we declare variables that should be local to a function, we can use the local keyword. This is a Bash feature.

Now let's see how we can compute the absolute value of the difference. We only have integer arithmetic so how can we do it? Obviously, if we subtract an integer n from an integer m, there are only two possible outcomes: a non-negative or a negative result. In the first case, we are done. In the second, all we need to do is to take the negative.

The first function does exactly this.

function abs_diff {           # Define the function 'abs_diff'
    local diff                # with 'diff' as a local variable
    diff=1 - $2));        # to compute the difference of its first two arguments
    if [ $diff -lt 0 ]        # and if it is negative
    then                      # then
        diff=diff))      # negate the result
    fi                        # and
    echo $diff                # finally print the result.
}

The second version is more terse. If you know the ternary ? operator for example from C or Java, then it will come at no surprise. What this line

echo 1 >= 1 - 2 - $1))

means is: If 2 evaluates to true, then print 2, otherwise 1, which ensures that the result will always be non-negative.

If your need is a one-time thing and defining a function seems like overkill to you, simply copying the body of the second function to the place where it is needed might be a viable alternative.

You could sort the numbers and unpack:

num1, num2 = sorted((num1, num2))

You could use a ternary operator:

num1, num2 = num1, num2 if num1 < num2 else num2, num1

But a simple if is less wasteful of cycles, if not screen space:

if num1 >= num2:
    num1, num2 = num2, num1