> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Python Division
The `/` operator in Python performs true division, dividing the left operand (dividend) by the right operand (divisor). For built-in real numeric types (`int`, `float`, `bool`), it evaluates to a floating-point (`float`) value, even if the division is mathematically exact. For other built-in types like `complex`, or standard library types like `Decimal` and `Fraction`, it returns a result of the corresponding type.
```python theme={"dark"}
result = dividend / divisor
```
## Type Coercion and Return Value
Unlike some C-family languages where integer division truncates the decimal, Python 3's `/` operator performs true division. For standard real numbers (`int`, `float`, `bool`), the operation always yields a `float`. If either or both operands are `complex` numbers, the operation yields a `complex` type.
```python theme={"dark"}
# Integer operands yield a float
8 / 4 # Returns: 2.0 (type: float)
# Float operands yield a float
5.5 / 2.0 # Returns: 2.75 (type: float)
# Boolean operands (True == 1, False == 0) yield a float
True / 2 # Returns: 0.5 (type: float)
# Complex operands yield a complex
(4+2j) / 2 # Returns: (2+1j) (type: complex)
```
## Underlying Data Model
When the `/` operator is evaluated, Python invokes the `__truediv__(self, other)` magic (dunder) method on the left operand. If the left operand's class does not implement this method or returns `NotImplemented`, Python falls back to the `__rtruediv__(self, other)` method on the right operand.
```python theme={"dark"}
a / b
# The interpreter translates this to:
a.__truediv__(b)
```
## Exception Handling
If the right operand evaluates to zero (e.g., `0`, `0.0`, `0j`, `False`), the operation cannot be resolved mathematically, and the interpreter raises a `ZeroDivisionError`.
```python theme={"dark"}
10 / 0 # Raises: ZeroDivisionError: division by zero
10 / 0.0 # Raises: ZeroDivisionError: float division by zero
10 / 0j # Raises: ZeroDivisionError: complex division by zero
```
## Standard Library Types
When used with standard library numeric types like `decimal.Decimal` or `fractions.Fraction`, the `/` operator returns an instance of that specific type rather than a `float`. This behavior is defined by the `__truediv__` implementation of those specific classes to preserve precision rules.
```python theme={"dark"}
from fractions import Fraction
from decimal import Decimal
# Fraction division returns a Fraction object
Fraction(1, 2) / Fraction(1, 4) # Returns: Fraction(2, 1)
# Decimal division returns a Decimal object
Decimal('10.0') / Decimal('3.0') # Returns: Decimal('3.333333333333333333333333333')
```
Tired of Poor Python Skills? Fix That With Deep Grasping!
Learn More
