5 Best Ways to Check if a Number is Negative in Python

💡 Problem Formulation: Checking if a number is negative in Python is a fundamental task that can be performed in several ways. Suppose you are provided with an input number, such as -10, and you want to determine whether it is negative. In this article, we will explore different methods of achieving this check, with each method’s input being a numeric value and the desired output being a boolean value indicating whether the number is negative.

Method 1: Using the Less Than Operator

In Python, the less than operator < is a straightforward tool for comparing two values. By checking if the number is less than zero, we can efficiently determine its negativity. This operation is fundamental and well-understood across different programming paradigms.

Here’s an example:

def is_negative(num):
    return num < 0

print(is_negative(-5))
print(is_negative(10))

Output:

True
False

The function is_negative() uses the less than operator to check if the given number is lower than zero. If so, it returns True; otherwise, it returns False. This example checks two numbers, -5 and 10, and appropriately identifies -5 as negative.

Method 2: Using a Conditional Expression

Conditional expressions in Python allow for concise one-liner evaluations. A conditional expression after an if statement checks if the number satisfies a condition—in this case, being negative—and returns the corresponding result.

Here’s an example:

num = -25
result = "Negative" if num < 0 else "Non-negative"

print(result)

Output:

Negative

This snippet assigns the string “Negative” to result if num is negative, otherwise “Non-negative”. It is a useful and compact way to express the check and act on the result in the same line of code.

Method 3: Using the math Module’s copysign Function

Python’s math module provides a function copysign() that can be used to check the sign of a number. While not a direct check for negativity, this function copies the sign from one number to another and can be leveraged to identify the negativity of the original number.

Here’s an example:

import math

def is_negative(num):
    return math.copysign(1, num) == -1.0

print(is_negative(-3.14))
print(is_negative(1.618))

Output:

True
False

The is_negative() function checks for negativity by comparing the result of math.copysign(1, num) against -1.0. If the number is negative, copysign returns -1.0, as shown when checking the value -3.14.

Method 4: Using the numpy.sign Function

For numerical computing, the numpy library offers a sign function that returns -1 if the number is negative, 0 if zero, and 1 if positive. By comparing the output of numpy.sign(num) to -1, we can ascertain whether the number is negative.

Here’s an example:

import numpy as np

num = -42
is_neg = np.sign(num) == -1

print(is_neg)

Output:

True

In the code above, np.sign(num) evaluates to -1 because num is negative. So, the variable is_neg receives True.

Bonus One-Liner Method 5: Using the Bitwise Negative Sign Check

The bitwise operators can be creatively used to check if a number is negative. By shifting the sign bit right, we can effectively check if the number is negative, as the result of the shift for a negative number is -1 due to the way negative numbers are represented in binary (two’s complement).

Here’s an example:

num = -64
is_negative = (num >> 31) & 1

print(is_negative)

Output:

This method is more esoteric and relies on the binary representation of numbers. In the example, shifting the sign bit of -64 right by 31 places yields 1, indicating the number is negative. However, this method is specific to 32-bit integers and is not directly applicable in Python, which does not enforce strict fixed integer sizes.

Summary/Discussion

Method 1: Less Than Operator. Easy to understand and implement. Works for all numeric types. It’s the most straightforward solution.
Method 2: Conditional Expression. It allows expressing both condition checking and action compactly. Ideal for simple inline checks without the need for a reusable function.
Method 3: Math’s copysign Function. An indirect method requiring knowledge of the math library. Not as intuitive as others but a valid alternative for handling special numeric cases.
Method 4: NumPy’s sign Function. Useful for arrays of numbers and scientific computing. Overkill for checking a single number, especially when not already using NumPy.
Method 5: Bitwise Negative Sign Check. Low-level, system-dependent. Not recommended for general Python programming as it breaks Python’s abstraction over integer size and the specific implementation of negative number representation.