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

- Introduction to Built-in Constants
- Numeric Constants

`True`

,`False`

, and`None`

`NotImplemented`

and`Ellipsis`

`Inf`

and`NaN`

- String Constants

`__doc__`

and`__file__`

`__name__`

and`__package__`

- Examples

- Mathematical Calculations
- Boolean Logic

- 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.