Don’t return NONE in Python to handle missing values

Instead of returning None for missing values in Python, you can use several alternative approaches:

1. Return a Default Value

Instead of None, return a meaningful default value that represents a missing state.

def get_value(data, key, default="N/A"):
    return data.get(key, default)

data = {"name": "Alice"}
print(get_value(data, "age"))  # Output: N/A

2. Raise an Exception

If a missing value is considered an error, raise an appropriate exception.

def get_value(data, key):
    if key not in data:
        raise KeyError(f"Key '{key}' not found")
    return data[key]

data = {"name": "Alice"}
# print(get_value(data, "age"))  # Raises KeyError: Key 'age' not found

3. Use Sentinel Objects

Define a unique object to represent missing values instead of None.

MISSING = object()

def get_value(data, key, default=MISSING):
    return data.get(key, default) if default is not MISSING else data[key]

data = {"name": "Alice"}
print(get_value(data, "age", "Unknown"))  # Output: Unknown

4. Use Optional Types (Type Hints with `Optional`)

Use Optional[T] to explicitly indicate that a value may be missing.

from typing import Optional

def get_value(data, key) -> Optional[str]:
    return data.get(key)

data = {"name": "Alice"}
print(get_value(data, "age"))  # Output: None (but explicitly typed)

5. Return an Empty Data Structure

Instead of None, return an empty list, dictionary, or string.

def get_value(data, key):
    return data.get(key, "")

data = {"name": "Alice"}
print(get_value(data, "age"))  # Output: '' (empty string)

6. Use `dataclass` with `field(default_factory=...)`

For structured data, use dataclasses to provide default values.

from dataclasses import dataclass, field

@dataclass
class Person:
    name: str
    age: int = field(default=0)

p = Person("Alice")
print(p.age)  # Output: 0 (instead of None)

Conclusion

Avoiding None depends on the context:

Use default values when sensible.
Raise exceptions if missing values are errors.
Use sentinel objects for explicit missing-value handling.
Return empty structures when they make sense.

Would you like a more tailored approach based on your use case? 🚀