Как реализовать преобразование значения, если x может быть 0 или 1, и нужно получить противоположное?

Преобразование 0 и 1 в противоположные значения

Этот вопрос проверяет уровень Python и знание различных подходов. Существует много способов реализации, от примитивных до элегантных.

Простые подходы

1. Условное выражение (if-else)

x = 1
result = 1 if x == 0 else 0
print(result)  # 0

# С переменными
result = 0 if x else 1
print(result)  # 0

# Более явно
if x == 0:
    result = 1
else:
    result = 0

Плюсы: явно, легко читать. Минусы: многословно.

2. Арифметическое вычитание

x = 1
result = 1 - x  # Вычитаем из 1
print(result)  # 0

x = 0
result = 1 - x  # 1 - 0 = 1
print(result)  # 1

# Работает с большими числами
x = 5
result = 10 - x  # 10 - 5 = 5

Плюсы: компактно, быстро. Минусы: менее выразительно для булевых значений.

3. XOR операция (исключающее ИЛИ)

x = 1
result = x ^ 1  # XOR с 1 инвертирует бит
print(result)  # 0

x = 0
result = x ^ 1
print(result)  # 1

# Работает для любых чисел
print(5 ^ 1)  # 4 (инвертирует последний бит)
print(6 ^ 1)  # 7

Плюсы: быстро на уровне процессора, компактно. Минусы: менее очевидно для начинающих.

4. NOT оператор

x = 1
result = not x  # True для 0, False для 1
print(result)  # False

# Преобразуем обратно в число
result = int(not x)
print(result)  # 0

# Или через логику
result = 1 if not x else 0
print(result)  # 0

Плюсы: выразительно для булевых значений. Минусы: требует преобразования в int.

Функциональные подходы

5. Словарь маппинга

mapping = {0: 1, 1: 0}

x = 1
result = mapping[x]
print(result)  # 0

# Более общий пример
mapping = {
    0: 1,
    1: 0,
    2: 3,
    3: 2
}

Плюсы: легко расширять для других значений. Минусы: требует предопределённого словаря.

6. Использование get() с default

mapping = {0: 1, 1: 0}

x = 1
result = mapping.get(x, x)  # Если не найден, возвращаем сам x
print(result)  # 0

# Безопасно для неожиданных значений
result = mapping.get(5, 5)  # 5

7. Lambda функция

invert = lambda x: 1 - x

print(invert(0))  # 1
print(invert(1))  # 0

# Или через XOR
invert = lambda x: x ^ 1
print(invert(0))  # 1
print(invert(1))  # 0

# Более сложные преобразования
transform = lambda x: {0: 'off', 1: 'on'}.get(x, 'unknown')
print(transform(0))  # 'off'
print(transform(1))  # 'on'

Для булевых значений

8. Прямое НЕ

flag = True
flipped = not flag  # False
print(flipped)  # False

# Двойное НЕ инвертирует в число
result = int(not flag)  # 0
print(result)

9. Используя math

import math

x = 1
result = abs(1 - x)  # |1 - 1| = 0
print(result)  # 0

# Более сложные функции
from operator import sub
result = sub(1, x)  # 1 - 1 = 0

Производительность

import timeit

# Тестируем разные подходы
code_variants = {
    '1-x': 'lambda x: 1 - x',
    'x^1': 'lambda x: x ^ 1',
    'ternary': 'lambda x: 0 if x else 1',
    'dict': 'lambda x: {0:1, 1:0}[x]',
    'not+int': 'lambda x: int(not x)',
}

for name, code in code_variants.items():
    time = timeit.timeit(f'{code}(1)', number=1000000)
    print(f'{name}: {time:.4f}s')

# Результаты (примерно):
# 1-x: 0.0350s (быстро)
# x^1: 0.0355s (быстро)
# ternary: 0.0420s (чуть медленнее)
# dict: 0.0580s (медленнее из-за поиска)
# not+int: 0.0450s

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

Пример 1: Toggle флаг

class Settings:
    def __init__(self):
        self.debug = 0  # или 1
    
    def toggle_debug(self):
        self.debug = 1 - self.debug  # Самый читаемый

settings = Settings()
settings.toggle_debug()
print(settings.debug)  # 1

Пример 2: Бинарные флаги

class User:
    def __init__(self):
        self.active = 1
        self.premium = 0
    
    def deactivate(self):
        self.active ^= 1  # XOR для инверсии

user = User()
user.deactivate()
print(user.active)  # 0

Пример 3: В списке понимании

values = [0, 1, 0, 1, 1, 0]

# Инвертируем все значения
inverted = [1 - v for v in values]
print(inverted)  # [1, 0, 1, 0, 0, 1]

# Или через map
inverted = list(map(lambda x: 1 - x, values))
print(inverted)  # [1, 0, 1, 0, 0, 1]

Пример 4: В NumPy (для больших данных)

import numpy as np

array = np.array([0, 1, 0, 1, 0])
inverted = 1 - array  # Векторизованная операция
print(inverted)  # [1 0 1 0 1]

# Или через XOR
inverted = array ^ 1

Рекомендации по выбору

# 1. ДЛЯ ЧИТАЕМОСТИ И ПРОСТОТЫ:
result = 1 - x  # Лучший выбор

# 2. ДЛЯ БУЛЕВЫХ ЗНАЧЕНИЙ:
result = not x
result_int = int(result)

# 3. ДЛЯ ПРОИЗВОДИТЕЛЬНОСТИ:
result = x ^ 1  # Самый быстрый

# 4. ДЛЯ РАСШИРЯЕМОСТИ (много значений):
mapping = {0: 1, 1: 0, ...}
result = mapping[x]

# 5. НИКОГДА НЕ ИСПОЛЬЗУЙ:
# result = x ^ 1  # Если нужна читаемость для junior разработчиков

Ответ на собеседовании

"Самый простой и читаемый способ — result = 1 - x, так как это понятно с первого взгляда. Для производительности можно использовать XOR операцию x ^ 1. Если нужна гибкость для разных значений, используем словарь маппинга. Выбор зависит от контекста: читаемость vs производительность vs расширяемость."