Python Modulo

The % operator in Python serves two distinct syntactic roles depending on the operand types: it acts as the modulo operator for numeric types and as the string interpolation operator for string and byte types.

Numeric Modulo

When applied to numeric types (int, float), the % operator calculates the remainder of the floor division between a dividend (left operand) and a divisor (right operand).

result = a % b

Mathematical Behavior: Unlike C or Java, Python’s modulo operator guarantees that the sign of the result always matches the sign of the divisor (b), not the dividend (a). The operation is mathematically defined by the following equation: r = a - (b * floor(a / b))

# Positive divisor: result is always positive or zero
10 % 3    # Evaluates to 1
-10 % 3   # Evaluates to 2


# Negative divisor: result is always negative or zero
10 % -3   # Evaluates to -2
-10 % -3  # Evaluates to -1

Floating-Point Operands: The % operator accepts float operands, returning a floating-point remainder based on the same floor division logic.

5.5 % 2.0  # Evaluates to 1.5

Note: Due to IEEE 754 precision limitations and the floor division behavior, the standard library math.fmod() is strictly recommended over the % operator when working with floats, as math.fmod() implements C-style modulo (matching the sign of the dividend).

String and Bytes Formatting

When the left operand is a str or bytes object, the % operator is overloaded to perform legacy printf-style formatting.

formatted_string = format_string % values

Evaluation Mechanics: The left operand is parsed for conversion specifiers (e.g., %s for string, %d for decimal integer, %f for float). The right operand must be a single value, a tuple of values, or a mapping object (such as a dict) that provides the data to substitute into the specifiers.

# Tuple substitution (positional)
"%s is %d years old." % ("Alice", 30)

# Evaluates to: 'Alice is 30 years old.'


# Dictionary substitution (named mapping)
"%(name)s is %(age)d years old." % {"name": "Bob", "age": 25}

# Evaluates to: 'Bob is 25 years old.'

When using a tuple as the right operand, the number of elements in the tuple must exactly match the number of positional conversion specifiers in the format string, otherwise a TypeError is raised.

Tired of Poor Python Skills? Fix That With Deep Grasping!Learn More

Functions

Decorators

Methods

Comprehensions

Classes

Constructors

Context Managers

Pattern Matching

Generics

Type Declarations

Type Aliases

Type Expressions

Type Qualifiers

Type Narrowing

Variables

Attributes

Properties

Parameters

Error Handling

Annotation Syntax

Conditional Statements

Control Flow Statements

Loops

Imports

Built-In Types

Comments & Documentation

Access Operators

Arithmetic Operators

Assignment Operators

Comparison Operators

Logical Operators

Membership Operators

Identity Operators

Unary Operators

Bitwise Operators

Shift Operators

Numeric Modulo

String and Bytes Formatting

​Numeric Modulo

​String and Bytes Formatting

Numeric Modulo

String and Bytes Formatting