Пустой словарь переводится как True или False

Пустой словарь в контексте истинности (truthiness)

Пустой словарь {} переводится как False в Python.

Основное правило

# Пустой словарь
empty_dict = {}
bool(empty_dict)  # False

if empty_dict:
    print("Dictionary is not empty")  # ❌ Не выполнится
else:
    print("Dictionary is empty")      # ✅ Выполнится

Правила для других типов

В Python есть глобальное правило: контейнеры оцениваются как False, если пусты.

# ❌ False (пусто)
bool({})           # False - пустой словарь
bool([])           # False - пустой список
bool(())           # False - пустой кортеж
bool("")           # False - пустая строка
bool(set())        # False - пустое множество
bool(frozenset())  # False - пустой frozenset

# ✅ True (не пусто)
bool({"key": "value"})  # True - словарь с данными
bool([1, 2, 3])         # True - список с данными
bool("hello")           # True - строка с данными
bool({1, 2, 3})         # True - множество с данными

Практические примеры

Проверка наличия данных

def process_config(config: dict):
    """Обработать конфиг, если он не пустой"""
    
    if not config:  # Эквивалентно: if len(config) == 0
        print("No configuration provided")
        return
    
    for key, value in config.items():
        print(f"{key}: {value}")

# Использование
process_config({})                    # Ничего не выведет
process_config({"debug": True})       # Выведет debug: True

Установка значений по умолчанию

# ❌ Неправильно (проверяет только существование ключа)
result = user_data.get('preferences') or {}
# Если user_data['preferences'] = {}, всё равно используем пустой словарь

# ✅ Правильно (явная проверка на None)
result = user_data.get('preferences') or {}
if not result:  # Результат пустой
    result = get_default_preferences()

Фильтрация пустых результатов

def search_users(filters: dict):
    """Искать пользователей, если есть фильтры"""
    
    if not filters:  # Если filters пустой
        # Вернуть всех пользователей без фильтрации
        return User.objects.all()
    
    # Применить фильтры
    query = User.objects.all()
    for field, value in filters.items():
        query = query.filter(**{field: value})
    return query

# Использование
search_users({})                              # Все пользователи
search_users({"is_active": True, "role": "admin"})  # С фильтрами

Важный нюанс: разница между None и {}

# Это РАЗНЫЕ вещи!
bool(None)  # False - отсутствие значения
bool({})    # False - пустой контейнер

# Но оба дают False!
if None:
    print("Won't print")  # ❌

if {}:
    print("Won't print")  # ❌

# Нужно проверить явно если нужно различить
def handle_config(config):
    if config is None:
        print("Config not provided")  # None — не передали
    elif not config:
        print("Config is empty")      # {} — пустой словарь
    else:
        print(f"Config: {config}")    # Есть данные

handle_config(None)              # Config not provided
handle_config({})                # Config is empty
handle_config({"key": "value"})  # Config: {...}

В контексте условий

data = {}

# Все эти условия эквивалентны для пустого словаря:
if not data:             # ✅ Самое понятное
if len(data) == 0:       # ✅ Явное, но многословное
if data == {}:           # ✅ Очень явное
if bool(data) == False:  # ❌ Излишне сложно

# Все вернут True для пустого словаря
print(not {})            # True
print(len({}) == 0)      # True
print({} == {})          # True

Проверка пустого словаря в функциях

from typing import Optional

def process_data(options: dict) -> str:
    """Обработать данные с опциями"""
    
    if not options:  # Пустой словарь → False
        return "Processing with defaults"
    
    return f"Processing with options: {options}"

process_data({})              # Processing with defaults
process_data({"mode": "fast"})  # Processing with options: {'mode': 'fast'}

Класс с методом bool

Вы можете определить, как ваш класс оценивается:

class Config:
    def __init__(self, data: dict):
        self.data = data
    
    def __bool__(self):
        """Определяем, что означает истина для Config"""
        return len(self.data) > 0  # True если есть данные

config_empty = Config({})
config_full = Config({"key": "value"})

bool(config_empty)  # False
bool(config_full)   # True

if config_empty:
    print("Config has data")  # ❌ Не выполнится
else:
    print("Config is empty")  # ✅ Выполнится

Частая ошибка

# ❌ НЕПРАВИЛЬНО: проверяем просто существование
response = make_api_call()  # может вернуть {} или None

if response:
    print(f"Got response: {response}")
else:
    print("No response")

# Если response = {}, условие выдаст False,
# хотя вызов был успешным!

# ✅ ПРАВИЛЬНО: проверяем явно
if response is None:
    print("No response")
elif not response:  # Пустой ответ
    print("Empty response")
else:
    print(f"Got response: {response}")

Итоговая справка

# ПАМЯТКА
dict_empty = {}

# Проверка на пустоту
bool(dict_empty)        # False
if not dict_empty: ...  # True (пусто)
len(dict_empty) == 0    # True

# Проверка на наличие ключей
if dict_empty:          # False (пусто)
if dict_empty.keys():   # False (пусто)

# Проверка на наличие значения
dict_empty.get('key')   # None (нет ключа)
'key' in dict_empty     # False (нет ключа)

Практический пример из Django

# Django ORM QuerySet
users = User.objects.filter(is_active=False)

# Проверка, нашли ли пользователей
if users:  # Если QuerySet не пустой
    print(f"Found {users.count()} inactive users")
else:      # QuerySet пустой (не найдено)
    print("No inactive users")

# Для словарей работает аналогично
user_data = {}

if user_data:  # False — нет данных
    print("User data found")
else:          # True — пусто
    print("No user data")

Вывод

Пустой словарь {} переводится как False в контексте истинности. Это следует из общего правила Python: пустые контейнеры ([], (), "", set(), dict()) оцениваются как False, а непустые — как True.

Это удобно для проверок:

if my_dict:
    # Делаем что-то если словарь не пустой
else:
    # Словарь пустой