Python numbers Module

Author:

In this guide, you'll explore Python's numbers module, which defines numeric abstract base classes. Learn its features and examples for type hierarchy.

The numbers module in Python provides a hierarchy of abstract base classes (ABCs) to define and test numeric types. This module is useful for creating your own numeric types and ensuring that they conform to the behavior expected of numbers.

Table of Contents

  1. Introduction
  2. Key Classes in numbers
    • Number
    • Complex
    • Real
    • Rational
    • Integral
  3. Examples
    • Checking Numeric Types
    • Creating Custom Numeric Types
  4. Real-World Use Case
  5. Conclusion
  6. References

Introduction

The numbers module defines a set of abstract base classes that describe the various categories of numbers in Python. These categories range from the most general, Number, to the most specific, Integral. These classes provide a way to define numeric types in a consistent manner and to check if an object is of a particular numeric type.

Key Classes in numbers

Number

The most general ABC for numbers. All other numeric ABCs are derived from this class. It is not intended to be instantiated directly.

import numbers

print(isinstance(5, numbers.Number))  # True
print(isinstance(3.14, numbers.Number))  # True

Output:

True
True

Complex

Represents complex numbers. All numbers in Python (including integers and floats) are complex numbers.

import numbers

print(isinstance(5, numbers.Complex))  # True
print(isinstance(3.14, numbers.Complex))  # True
print(isinstance(1+2j, numbers.Complex))  # True

Output:

True
True
True

Real

Represents real numbers. This includes both integers and floating-point numbers, but not complex numbers.

import numbers

print(isinstance(5, numbers.Real))  # True
print(isinstance(3.14, numbers.Real))  # True
print(isinstance(1+2j, numbers.Real))  # False

Output:

True
True
False

Rational

Represents rational numbers. These are numbers that can be expressed as the quotient of two integers. In Python, this includes integers and fractions.

from fractions import Fraction
import numbers

print(isinstance(5, numbers.Rational))  # True
print(isinstance(Fraction(1, 3), numbers.Rational))  # True
print(isinstance(3.14, numbers.Rational))  # False

Output:

True
True
False

Integral

Represents integral numbers. These are whole numbers, including both positive and negative integers, as well as zero.

import numbers
print(isinstance(5, numbers.Integral))  # True
print(isinstance(-3, numbers.Integral))  # True
print(isinstance(3.14, numbers.Integral))  # False

Output:

True
True
False

Examples

Checking Numeric Types

Use the isinstance function to check if a value is an instance of a particular numeric type.

import numbers

print(isinstance(5, numbers.Number))  # True
print(isinstance(5, numbers.Complex))  # True
print(isinstance(5, numbers.Real))  # True
print(isinstance(5, numbers.Rational))  # True
print(isinstance(5, numbers.Integral))  # True
print(isinstance(3.14, numbers.Integral))  # False

Output:

True
True
True
True
True
False

Creating Custom Numeric Types

You can create custom numeric types by subclassing one of the abstract base classes provided by the numbers module.

import numbers

class MyNumber(numbers.Real):
    def __init__(self, value):
        self.value = value

    def __repr__(self):
        return f"MyNumber({self.value})"

    def __float__(self):
        return float(self.value)

    def __int__(self):
        return int(self.value)

    def __hash__(self):
        return hash(self.value)

    def __trunc__(self):
        return int(self.value)

    def __floor__(self):
        return int(self.value // 1)

    def __ceil__(self):
        return int(-(-self.value // 1))

    def __round__(self, ndigits=None):
        return MyNumber(round(self.value, ndigits))

    def __add__(self, other):
        if isinstance(other, MyNumber):
            return MyNumber(self.value + other.value)
        return MyNumber(self.value + other)

    def __sub__(self, other):
        if isinstance(other, MyNumber):
            return MyNumber(self.value - other.value)
        return MyNumber(self.value - other)

    def __mul__(self, other):
        if isinstance(other, MyNumber):
            return MyNumber(self.value * other.value)
        return MyNumber(self.value * other)

    def __truediv__(self, other):
        if isinstance(other, MyNumber):
            return MyNumber(self.value / other.value)
        return MyNumber(self.value / other)

    def __floordiv__(self, other):
        if isinstance(other, MyNumber):
            return MyNumber(self.value // other.value)
        return MyNumber(self.value // other)

    def __mod__(self, other):
        if isinstance(other, MyNumber):
            return MyNumber(self.value % other.value)
        return MyNumber(self.value % other)

    def __pow__(self, exponent):
        if isinstance(exponent, MyNumber):
            return MyNumber(self.value ** exponent.value)
        return MyNumber(self.value ** exponent)

    def __abs__(self):
        return MyNumber(abs(self.value))

    def __neg__(self):
        return MyNumber(-self.value)

    def __pos__(self):
        return MyNumber(+self.value)

    def __eq__(self, other):
        if isinstance(other, MyNumber):
            return self.value == other.value
        return self.value == other

    def __lt__(self, other):
        if isinstance(other, MyNumber):
            return self.value < other.value
        return self.value < other

    def __le__(self, other):
        if isinstance(other, MyNumber):
            return self.value <= other.value
        return self.value <= other

    def __gt__(self, other):
        if isinstance(other, MyNumber):
            return self.value > other.value
        return self.value > other

    def __ge__(self, other):
        if isinstance(other, MyNumber):
            return self.value >= other.value
        return self.value >= other

    def __radd__(self, other):
        return self.__add__(other)

    def __rsub__(self, other):
        return MyNumber(other).__sub__(self)

    def __rmul__(self, other):
        return self.__mul__(other)

    def __rtruediv__(self, other):
        return MyNumber(other).__truediv__(self)

    def __rfloordiv__(self, other):
        return MyNumber(other).__floordiv__(self)

    def __rmod__(self, other):
        return MyNumber(other).__mod__(self)

    def __rpow__(self, other):
        return MyNumber(other).__pow__(self)

# Example usage
a = MyNumber(3)
b = MyNumber(4)

print(a + b)          # MyNumber(7)
print(a * b)          # MyNumber(12)
print(a ** 2)         # MyNumber(9)
print(abs(MyNumber(-5)))  # MyNumber(5)
print(a + 2)          # MyNumber(5)
print(2 + a)          # MyNumber(5)
print(a // 2)         # MyNumber(1)
print(a % 2)          # MyNumber(1)
print(2 // a)         # MyNumber(0)
print(2 % a)          # MyNumber(2)
print(round(a, 1))    # MyNumber(3)

Output:

MyNumber(7)
MyNumber(12)
MyNumber(9)
MyNumber(5)
MyNumber(5)
MyNumber(5)
MyNumber(1)
MyNumber(1)
MyNumber(0)
MyNumber(2)
MyNumber(3)

Real-World Use Case

Custom Numeric Operations

In scientific computing or financial applications, you might need custom numeric types that adhere to specific rules or provide additional functionality. Using the numbers module, you can create these custom numeric types while ensuring they conform to the expected behavior of standard numeric types.

import numbers

class Currency(numbers.Real):
    def __init__(self, value):
        self.value = value

    def __repr__(self):
        return f"Currency({self.value:.2f})"

    def __float__(self):
        return float(self.value)

    def __int__(self):
        return int(self.value)

    def __hash__(self):
        return hash(self.value)

    def __trunc__(self):
        return int(self.value)

    def __floor__(self):
        return int(self.value // 1)

    def __ceil__(self):
        return int(-(-self.value // 1))

    def __round__(self, ndigits=None):
        return Currency(round(self.value, ndigits))

    def __add__(self, other):
        if isinstance(other, numbers.Real):
            return Currency(self.value + float(other))
        return NotImplemented

    def __sub__(self, other):
        if isinstance(other, numbers.Real):
            return Currency(self.value - float(other))
        return NotImplemented

    def __mul__(self, other):
        if isinstance(other, numbers.Real):
            return Currency(self.value * float(other))
        return NotImplemented

    def __truediv__(self, other):
        if isinstance(other, numbers.Real):
            return Currency(self.value / float(other))
        return NotImplemented

    def __floordiv__(self, other):
        if isinstance(other, numbers.Real):
            return Currency(self.value // float(other))
        return NotImplemented

    def __mod__(self, other):
        if isinstance(other, numbers.Real):
            return Currency(self.value % float(other))
        return NotImplemented

    def __pow__(self, exponent):
        if isinstance(exponent, numbers.Real):
            return Currency(self.value ** float(exponent))
        return NotImplemented

    def __abs__(self):
        return Currency(abs(self.value))

    def __neg__(self):
        return Currency(-self.value)

    def __pos__(self):
        return Currency(+self.value)

    def __eq__(self, other):
        if isinstance(other, numbers.Real):
            return self.value == float(other)
        return NotImplemented

    def __lt__(self, other):
        if isinstance(other, numbers.Real):
            return self.value < float(other)
        return NotImplemented

    def __le__(self, other):
        if isinstance(other, numbers.Real):
            return self.value <= float(other)
        return NotImplemented

    def __gt__(self, other):
        if isinstance(other, numbers.Real):
            return self.value > float(other)
        return NotImplemented

    def __ge__(self, other):
        if isinstance(other, numbers.Real):
            return self.value >= float(other)
        return NotImplemented

    def __radd__(self, other):
        return self.__add__(other)

    def __rsub__(self, other):
        return Currency(float(other)).__sub__(self)

    def __rmul__(self, other):
        return self.__mul__(other)

    def __rtruediv__(self, other):
        return Currency(float(other)).__truediv__(self)

    def __rfloordiv__(self, other):
        return Currency(float(other)).__floordiv__(self)

    def __rmod__(self, other):
        return Currency(float(other)).__mod__(self)

    def __rpow__(self, other):
        return Currency(float(other)).__pow__(self)

# Example usage
salary = Currency(5000.75)
bonus = Currency(1200.50)

total_income = salary + bonus
print(total_income)  # Currency(6201.25)

Output:

Currency(6201.25)

Conclusion

The numbers module in Python provides a robust framework for defining and working with numeric types. By using the abstract base classes in this module, you can ensure that your custom numeric types adhere to the expected behaviors of standard numeric types, making your code more consistent and reliable.

References

Related Python Programs with Output and Step-By-Step Explanation:

Python Program to Reverse a Number Python Program to Check Even or Odd Using Recursion Python Program to Find Largest of 3 Numbers Python Program to Check a Number Is Positive or Negative Python Program to Print Odd Numbers in a Range Python Program to Check if a Number is a Palindrome Python Program to Check Palindrome Using Recursion Python Program to Reverse a Number using While Loop Python Program to Count the Number of Digits in a Number Python Program to Find All the Divisors of an Integer Python Program to Find the Smallest Divisor of an Integer Python Program to Print a Table of Given Number Python Program to Calculate the Grade of a Student Python Program to Check Leap Year Python Program to Find Prime Numbers in a Given Range Python Program to Check Prime Number Python Program to Check Prime Number Using Recursion Python Program to Check Perfect Number Python Program to Check Armstrong Number Python Program to Find Sum of First N Natural Numbers Python Program to Check Strong Number Python Program to Print Numbers Without Using Loop Python Program to Find Prime Factors of a Number Python Program to Check If Two Numbers Are Amicable Numbers Python Program to Check if a Number Is Power of 2 Python Program to Find Fibonacci Series Using Recursion Python Program to Find Fibonacci Series Python Program to Find Factorial of Number Using Recursion Python Program to Find Factorial of a Number Using While Loop Python Program to Find Factorial of a Number Using for Loop Python Program to Find the Roots of a Quadratic Equation Python Program to Find the Area of a Triangle Python Program to Find Simple Interest Python Program to Find Quotient and Remainder of Two Numbers Python Program to Compute a Polynomial Equation Python Program to Swap Two Elements in a List Python Program to Swap Two Numbers without Using Third Variable Python Program to Swap Three Numbers Python Program to Swap Two Tuples Python Program to Print an Identity Matrix Python Program to Calculate the Area of a Tetrahedron Python Program for Pascal Triangle Python Program to Display the Multiplication Table Python Program to Find the LCM of Two Numbers Python Program to Find the GCD of Two Numbers Using Recursion Python Program to Find the LCM of Two Numbers Using Recursion Python Program to Check if a String is a Pangram or Not Python Program to Remove Odd Indexed Characters in a String Python Program to Replace Blank Space With Hyphen in a String Python Program to Reverse a String (Different Ways) Python Program to Reverse a String Using Recursion Python Program to Find the Length of a String Without Library Function Python Program to Count the Number of Words in a String Python Program to Count the Number of Characters in a String Python Program to Count Number of Lowercase Characters in a String Python Program to Count the Number of Vowels in a String Python Program to Count the Number of Digits in a String Python Program to Count Occurrences of an Element in a List Python Program to Count Number of Digits in a Number Python Program to Count Uppercase and Lowercase in a String Python Program to Count Repeated Characters in a String Python Program to Count Vowels and Consonants in a String Python Program to Count Words in a Sentence Python Program to Find Permutations of a String Python Program to Check if a Substring Is Present in a Given String Python Program to Find Common Characters in Two Strings Python Program to Swap the First and the Last Character of a String Python Program to Count the Occurrences of Each Word in a String Python Program to Check if a Given String is Palindrome Python Program to Check whether two Strings are Anagrams Python Program to Check If Binary Representation Is a Palindrome Python Program to Concatenate Two Strings Python: Stack Implementation with Lists Python: Queue Implementation with Lists Python: Implementing Linked List Python: Finding Middle Element in Linked List Python: Detecting Cycle in Linked List Python: Binary Search on List Python: Binary Search Tree Implementation Python: DFS (Depth-First Search) in Graphs Python: BFS (Breadth-First Search) in Graphs Python: Hash Table Implementation Python: Heap Implementation Python: Intersection Point of Two Linked Lists Python: Reverse a Linked List Python: Shortest Path in Maze Python: AVL Tree Implementation Python: Circular Queue Implementation Python: Priority Queue Implementation Python: Shortest Path in Weighted Graph Python: Detect and Remove Loop in Linked List Python: Finding Longest Palindrome in String Python: Huffman Coding Algorithm Python: Merge Sort on Lists Python: Quick Sort on Lists Python: Bubble Sort on Lists Bubble Sort in Ascending Order in Python Bubble Sort in Descending Order in Python Selection Sort in Ascending Order in Python Selection Sort in Descending Order in Python Insertion Sort in Descending Order in Python Insertion Sort in Ascending Order in Python Merge Sort in Ascending Order in Python Merge Sort in Descending Order in Python Quick Sort in Ascending Order in Python Quick Sort in Descending Order in Python Heap Sort in Ascending Order in Python Heap Sort in Descending Order in Python Difference Between Local and Global Variables in PythonDifference Between List and Tuple in PythonDifference Between Array and List in PythonDifference Between List and Dictionary in PythonDifference Between List, Tuple, Set, and Dictionary in PythonDifference Between a Set and Dictionary in PythonDifference between for loop and while loop in PythonDifference Between pass and continue in PythonDifference Between List append and extend in PythonDifference Between == and is operator in PythonDifference Between Deep and Shallow Copy in PythonClass Method vs Static Method in PythonClass Method vs Instance Method in PythonDifference Between List and Set in PythonDifference Between Generator and Iterator in PythonDifference Between str and repr in PythonMethod Overloading vs Overriding in PythonDifference Between Dictionary and Tuple in PythonDifference Between Dictionary and Object in PythonDifference Between Mutable and Immutable in PythonDifference Between Interface and Abstract Class in PythonDifference Between Python Script and ModuleDifference Between for Loop and Iterator in Python Student Management System in PythonBanking System Project in PythonLibrary Management System in PythonTic Tac Toe Game in PythonNumber Guessing Game in PythonCalculator in PythonHangman Game in Python Word Guessing Game in PythonFlames Game in PythonTodo App in PythonQuiz App in PythonSchool Management System in Python

Comments

Post a Comment

Leave Comment

Spring Boot 3 Paid Course Published for Free
on my Java Guides YouTube Channel

Subscribe to my YouTube Channel (165K+ subscribers):
Java Guides Channel

Top 10 My Udemy Courses with Huge Discount:
Udemy Courses - Ramesh Fadatare