Python Built-in Constants (With Examples)

Python, as a versatile and powerful programming language, comes with a wide range of built-in constants that provide essential information or fixed values for various purposes. Constants are predefined values that remain unchanged during the course of a program’s execution. They are used to enhance code readability, improve maintainability, and reduce the likelihood of errors caused by hardcoding values.

In this tutorial, we will explore the most commonly used built-in constants in Python, along with examples demonstrating their usage and significance.

Table of Contents

1. Introduction to Built-in Constants
2. Numeric Constants

• True, False, and None
• NotImplemented and Ellipsis
• Inf and NaN

1. String Constants

• __doc__ and __file__
• __name__ and __package__

1. Examples

• Mathematical Calculations
• Boolean Logic

1. Conclusion

1. Introduction to Built-in Constants

Built-in constants in Python are predefined values that are accessible without the need for explicit definition. They offer a convenient way to use essential values throughout your codebase. Python provides various types of constants, including numeric constants, string constants, and special-purpose constants.

In this tutorial, we will focus on numeric constants, which include boolean values, special numeric values like infinity and NaN (Not-a-Number), and string constants related to module and package attributes.

2. Numeric Constants

True, False, and None

Python’s boolean constants are True and False, representing the truth values in logical expressions. They are often used in conditions and control flow statements to make decisions based on certain conditions.

Example:

is_valid = True
if is_valid:
    print("This is valid.")

is_checked = False
if not is_checked:
    print("Not checked yet.")

The constant None is used to represent the absence of a value or a null value. It is often used to initialize variables or indicate that a function has no return value.

Example:

result = None

def do_something():
    # Do something here
    return None

NotImplemented and Ellipsis

The constant NotImplemented is used to indicate that a certain functionality or method is not implemented yet. It’s often returned by methods that subclasses need to override.

Example:

class MyCustomClass:
    def my_method(self):
        raise NotImplementedError("This method needs to be implemented in subclasses.")

The constant Ellipsis represents an ellipsis and is used to denote incomplete code, placeholders, or slicing in certain contexts, especially in NumPy arrays.

Inf and NaN

Python provides constants for representing infinity and NaN (Not-a-Number) in floating-point arithmetic.

Example:

positive_infinity = float('inf')
negative_infinity = float('-inf')
not_a_number = float('nan')

3. String Constants

__doc__ and __file__

The __doc__ constant provides access to the docstring of a module, class, function, or method. It contains the documentation and description of the object.

Example:

def my_function():
    """This function does something."""
    pass

print(my_function.__doc__)

The __file__ constant holds the path of the current module’s source file. It’s particularly useful when you want to determine the location of the file in which the code is executing.

Example:

print(__file__)

__name__ and __package__

The __name__ constant holds the name of the current module. When a module is run as the main program, its __name__ attribute is set to '__main__'.

Example:

if __name__ == '__main__':
    print("This module is the main program.")

The __package__ constant holds the name of the package to which the current module belongs. It is mainly used in modules that are part of a package.

Example:

print(__package__)

4. Examples

Mathematical Calculations

Constants play a significant role in mathematical calculations. Let’s consider an example of calculating the area of a circle using the constant pi from the math module.

import math

radius = 5
area = math.pi * (radius ** 2)
print(f"The area of the circle with radius {radius} is {area:.2f}")

Boolean Logic

Boolean constants True and False are essential for implementing conditional statements and boolean logic. Here’s an example of using boolean constants to check if a number is positive.

def is_positive(number):
    return number > 0

num = 10
if is_positive(num):
    print(f"{num} is a positive number.")
else:
    print(f"{num} is not a positive number.")

5. Conclusion

Built-in constants are powerful tools that enhance code readability, improve maintainability, and reduce the risk of errors by avoiding hardcoded values. In this tutorial, we explored some of the most commonly used built-in constants in Python, including boolean values, special numeric values like infinity and NaN, and string constants related to module and package attributes.

By leveraging these constants in your Python code, you can write more clear and expressive programs that are easier to understand and maintain. Whether you’re performing mathematical calculations, implementing boolean logic, or documenting your code, built-in constants are valuable resources that contribute to the elegance and effectiveness of your codebase.