Оператор in: in operator — JavaScript | MDN

Оператор in вхождения/членства элемента в Python.

Синтаксис:

x in s
x not in s

Оператор in и отрицание not in проверяет наличие элемента в последовательности. Выражение x in s принимает значение True, если x является членом s, и False в противном случае.

Выражение x not in s возвращает отрицание наличие элемента x в s.

Все встроенные последовательности и типы множеств set/frozenset поддерживают эту операцию, а также словарь, для которого проверяется, имеет ли словарь данный ключ.

Для типов контейнеров, таких как list, tuple, set, frozenset, dict или collections.deque, выражение x in y эквивалентно вызову any(x is e or x == e for e in y)

Для строковых и байтовых типов x in y имеет значение True тогда и только тогда, когда

x является подстрокой y. Эквивалентный тест y.find(x) != -1. Пустые строки всегда считаются подстрокой любой другой строки, поэтому '' in 'abc' возвращает True.

Для определяемых пользователем классов, которые имеют метод __contains__(), выражение x in y возвращает True, если y.__contains__(x) возвращает истинное значение, и False в противном случае.

Для определяемых пользователем классов, которые НЕ определяют метод __contains__(), но определяют __iter__(), выражение x in y имеет значение True, если некоторое значение z создается при итерации по y и для которого выражение x is z or x == z истинно.

Наконец, используется протокол итерации старого стиля: если класс определяет метод __getitem__(), выражение

x in y возвращает True тогда и только тогда, когда существует неотрицательный целочисленный индекс i, такой что x is y[i] or x == y[i] и ни один из младших целочисленных индексов не вызывает исключение IndexError.

Оператор not in имеет значение обратной истинности in.

Примеры использования in, тестирование наличия элемента:

Вхождение/наличие элемента в список, кортеж множество

>>> x = [1, 2, 3, 4, 5, 6, 7, 8]
>>> 5 in x
# True
>>> 5 not in x
# False
>>> 0 in x
# False
>>> 0 not in x
# True

Вхождение/наличие подстроки в строке

>>> x = 'возвращает отрицание наличие элемента'
>>> 'отрицание' in x
# True
>>> 'наличие' not in x
# False
>>> x = 'абракадабра'
>>> 'б' in x
# True
>>> 'б' not in x
# False
>>> 'н' in x
# False
>>> 'у' not in x
# True

Вхождение/наличие ключа в словаре

>>> x = {'one':1, 'two':2, 'three':3, 'four':4}
>>> 'one' in x
# True
>>> 'one' not in x
# False
>>> 'five' in x
# False
>>> 'five' not in x
# True

Операторы в Python — CodeChick

В этом уроке вы узнаете все о разных типах операторов в Python, их синтаксисе и примерах использования.

Что такое операторы

Операторы — специальные символы, которые выполняют арифметические и логические вычисления. Значения, на которые действует оператор, называются операндами. 

Например:

>>> 2+3
5

Здесь оператор + выполняет сложение, 2 и 3 — операнды, а 5 — вывод операции.

Арифметические операторы

Арифметические операторы используются для выполнения математических операций — сложения, вычитания, умножения и т. д.

Оператор	Действие	Пример
+	Сложение двух операндов или унарный плюс	x + y + 2
—	Вычитание правого оператора из левого или унарный минус	x — y- 2
*	Умножение двух операндов	x * y
/	Деление левого операнда на правый (результат всегда типа float)	x / y
%	Остаток от деления левого операнда на правый	x % y (остаток от x / y)
//	Деление с округлением — деление, результат которого корректируется в меньшую сторону	x // y
**	Показатель степени — левый операнд возводится в значение правого операнда	x**y

x = 15
y = 4

# Вывод: x + y = 19
print('x + y =', x+y)

# Вывод: x - y = 11
print('x - y =', x-y)

# Вывод: x * y = 60
print('x * y =', x*y)

# Вывод: x / y = 3.  75
print('x / y =', x/y)

# Вывод: x // y = 3
print('x // y =', x//y)

# Вывод: x ** y = 50625
print('x ** y =', x**y)

Вывод:

x + y = 19
x - y = 11
x * y = 60
x / y = 3.75
x // y = 3
x ** y = 50625

Операторы сравнения

Операторы сравнения используются для сравнения значений, они возвращают True или False в зависимости от условия.

Оператор	Действие	Пример
>	Больше чем: True, если левый операнд больше правого	x > y
<	Меньше чем: True, если левый операнд меньше правого	x < y
==	Равно: True, если операнды равны между собой	x == y
!=	Не равно: True, если операнды не равны между собой	x != y
>=	Больше или равно: True, если левый операнд больше или равен правому	x >= y
<=	Меньше или равно: True, если левый операнд меньше или равен правому	x <= y

x = 10
y = 12

# Вывод: x > y — False
print('x > y —', x>y)

# Вывод: x < y — True
print('x < y —', x<y)

# Вывод: x == y — False
print('x == y —', x==y)

# Вывод: x != y — True
print('x != y —', x!=y)

# Вывод: x >= y — False
print('x >= y —', x>=y)

# Вывод: x <= y — True
print('x <= y —', x<=y)

Вывод:

x > y — False
x < y — True
x == y — False
x != y — True
x >= y — False
x <= y — True

Логические операторы

Операторы and, or, not — логические.

Оператор	Действие	Пример
and	True, если значения обоих операндов True	x and y
or	True, если значение одного из операндов True	x or y
not	True, если значение операнда False (дополняет значение операнда)	not x

x = True
y = False

print('x and y —', x and y)
print('x or y —', x or y)
print('not x —', not x)

Вывод:

x and y — False
x or y — True
not x — False

Побитовые операторы

Побитовые операторы работают с операндами как со строками из 0 и 1. Они действуют бит за битом, как и говорит название.

Например, 2 в двоичной системе счисления — 10, а 7 — 111. y = 14 (00001110)

>>

Побитовый сдвиг вправо

x >> 2 = 2 (00000010)

<<

Побитовый сдвиг влево

x << 2 = 40 (00101000)

Операторы присваивания

Операторы присваивания используются для назначения переменной некоторого значения. 

a = 5 — простой оператор присваивания, который приравнивает значение 5 справа переменной а слева.

В Python множество составных операторов, подобных a += 5 — он прибавляет 5 к переменной a и позже присваивает ей получившееся значение. Этот оператор равносилен записи a = a + 5.

Оператор	Пример	Эквивалентно
=	x = 5	x = 5
+=	x += 5	x = x + 5
-=	x -= 5	x = x — 5
*=	x *= 5	x = x * 5
/=	x /= 5	x = x / 5
%=	x %= 5	x = x % 5
//=	x //= 5	x = x // 5
**=	x **= 5	x = x ** 5
&=	x &= 5	x = x & 5
|=	x |= 5	x = x | 5
^=	x ^= 5	x = x ^ 5
>>=	x >>= 5	x = x >> 5
<<=	x <<= 5	x = x << 5

В Python есть особые типы операторов: операторы тождественности и принадлежности.

Операторы тождественности

is и is not — операторы тождественности в Python. Они проверяют, находятся ли два значения (или две переменные) по одному адресу в памяти. То, что две переменные равны еще не значит, что они идентичны.

Оператор	Действие	Пример
is	True, если операнды идентичны (указывают на один объект)	x is True
is not	True, если операнды не идентичны (не указывают на один объект)	x is not True

x1 = 5
y1 = 5
x2 = 'Привет'
y2 = 'Привет'
x3 = [1,2,3]
y3 = [1,2,3]

# Вывод: False
print(x1 is not y1)

# Вывод: True
print(x2 is y2)

# Вывод: False
print(x3 is y3)

Вывод:

False
True
False

Мы видим, что x1 и y1 — целочисленные переменные с одинаковыми значениями, поэтому они равны и идентичны. То же с x2 и y2 (строки).

Но x3 и y3 — списки. Они равны, но не идентичны, поскольку интерпретатор кладет их в разные места в памяти, хоть эти списки и равны.

Операторы принадлежности

in и not in — операторы принадлежности в Python. Они проверяют, есть ли значение или переменная в последовательности (строке, списке, кортеже, множестве или словаре). Иначе говоря, проверяют вхождение элемента в коллекцию. В словаре можно проверить только присутствие ключа, не значения.

Оператор	Действие	Пример
in	True, если значение или переменная есть в последовательности	5 in x
not in	True, если значения или переменной нет в последовательности	5 not in x

x = 'Привет, мир'
y = {1:'a',2:'b'}

# Вывод: True
print('П' in x)

# Вывод: True
print('привет' not in x)

# Вывод: True
print(1 in y)

# Вывод: False
print('б' in y)

Вывод:

True
True
True
False

'П' есть в x, а вот строки 'привет' в x нет (помните: Python чувствителен к регистру). Таким же образом образом 1— ключ, а 'a' — значение в словаре y, поэтому вывод 'б' in y — False.

Оператор IN в DAX

ОБНОВЛЕНИЕ 01.03.2022 : доступна новая статья Понимание оператора IN в DAX , которая содержит более обновленный контент и примеры запросов, которые вы можете попробовать онлайн на dax.do!

Новый синтаксис IN доступен в Power BI с ноября 2016 г. и в Excel 2016 с версии 1701 (февраль 2017 г. в Current Channel). Этот синтаксис также будет доступен в будущих версиях служб Analysis Services (после SQL Server 2016). Для поддержки этого нового оператора DAX также представил два новых синтаксиса: конструктор таблиц и строк, которые позволяют создавать «анонимные» таблицы, которые можно использовать для сравнения значений двух или более столбцов вместо одного.

Например, рассмотрим следующий синтаксис:

RedOrBlack Продажи ИЛИ :=
ВЫЧИСЛИТЬ (
    [Объем продаж],
    Товары[Цвет] = "Красный" || Товары[Цвет] = "Черный"
)
 

С новым синтаксисом IN вы можете написать:

RedOrBlack Продажи В :=
ВЫЧИСЛИТЬ (
    [Объем продаж],
    Товары[Цвет] IN { "Красный", "Черный" }
)
 

Как вы увидите в следующих разделах, оператор IN можно использовать также с динамическими выражениями, и он может сравнивать более одного столбца или. Синтаксис, который следует за оператором IN в предыдущем примере, представляет собой конструктор таблицы, и каждая строка может иметь конструктор строки, если ее содержимое содержит более одного столбца.

Оператор IN — это функция CONTAINSROW

Как это часто бывает в DAX, оператор IN — это просто синтаксический сахар для вызова другой функции DAX, в данном случае — CONTAINSROW. Например, предыдущую меру RedOrBlack Sales можно записать как:

.
RedOrBlack Продажи CR :=
ВЫЧИСЛИТЬ (
    [Объем продаж],
    СОДЕРЖАТЬ (
        {"Красный", "Черный"},
        Продукты[Цвет]
    )
)
 

Новая функция CONTAINSROW похожа на функцию CONTAINS, но позволяет использовать анонимную таблицу, которую вы создаете с помощью конструктора таблиц. На самом деле синтаксис CONTAINS:

СОДЕРЖИТ (
    <таблица поиска>,
    [lookupColumn]
    <внешняя таблица> [внешняя колонка]
)
 

Поскольку второй аргумент CONTAINS требует ссылки на столбец в таблице поиска, передаваемой в качестве первого параметра, вы можете использовать CONTAINS только с таблицей, имеющей имена. Таким образом, вы можете использовать CONTAINS с таблицей, созданной в том же выражении с помощью DATATABLE, но синтаксис будет слишком подробным:

Диск с продажами RedOrBlack :=
ВЫЧИСЛИТЬ (
    [Объем продаж],
    ФИЛЬТР (
        ВСЕ (Товары[Цвет]),
        СОДЕРЖИТ (
            DATATABLE ("Цвет", STRING, { { "Красный" }, { "Черный" } } ),
            [Цвет], Товары[Цвет]
        )
    )
)
 

Оператор IN с одним столбцом

Функция CONTAINSROW требует, чтобы все столбцы, указанные в таблице, имели соответствующий столбец в выражении перед IN. Таким образом, простой синтаксис для одного столбца:

<таблица>[столбец] IN 
 

В этом синтаксисе lookupTable представляет собой таблицу только с одним столбцом. Это может быть динамическое табличное выражение, как в следующем примере, которое возвращает значение продаж всех других цветов, кроме выбранных:

Другие цвета :=
ВЫЧИСЛИТЬ (
    [Объем продаж],
    Продукты[Цвет] В
        КРОМЕ (
            ВСЕ (Товары[Цвет]),
            ЦЕННОСТИ ( Продукты [Цвет] )
        )
)
 

Обратите внимание, что приведенный выше синтаксис является лишь примером динамического выражения, применяемого к IN. В этом конкретном случае вы получите точный результат, используя только EXCEPT в аргументе фильтра CALCULATE:

.
Другие цвета 2 :=
ВЫЧИСЛИТЬ (
    [Объем продаж],
    КРОМЕ (
        ВСЕ (Товары[Цвет]),
        ЦЕННОСТИ ( Продукты [Цвет] )
    )
)
 

Или вы можете использовать более интуитивно понятный синтаксис, используя NOT перед оператором IN:

Другие цвета 3 :=
ВЫЧИСЛИТЬ (
    [Объем продаж],
    НЕ ( Товары [Цвет] В ЗНАЧЕНИЯХ ( Товары [Цвет] ) )
)
 

Вам нужно написать NOT перед первым аргументом оператора IN, а не только перед оператором IN, как в SQL. Скобки после NOT не обязательны, но я предпочитаю делать их явными, чтобы улучшить читаемость.

Оператор IN с несколькими столбцами

Оператор IN позволяет сравнивать несколько столбцов за одну операцию. Например, вы можете написать:

('Календарь'[Год], 'Календарь'[Название месяца])
    В {
        (2005, "Декабрь"),
        (2006, "Январь")
    }
 

Однако этот синтаксис нельзя использовать непосредственно в аргументе фильтра функции ВЫЧИСЛИТЬ, так как для этого требуется контекст строки с двумя столбцами (Год и ИмяМесяца в таблице Календарь), поэтому вы должны написать явный ФИЛЬТР. Тем не менее, это все еще упрощает синтаксис. Например, рассмотрим следующую меру, которая суммирует два последовательных месяца декабря и января двух разных лет.

Нью-Йорк 2007 Старый 1 :=
ВЫЧИСЛИТЬ (
    [Объем продаж],
    ФИЛЬТР (
        ВСЕ ("Календарь"),
        ИЛИ (
            'Календарь' [Год] = 2006
                && 'Календарь'[Название месяца] = "Декабрь",
            «Календарь» [Год] = 2007
                && 'Календарь'[Название месяца] = "Январь"
        )
    )
)
 

Вы можете написать его, используя CONTAINS, но это не более короткий синтаксис, если только список возможных месяцев и лет не будет очень длинным:

Нью-Йорк 2007 Старый 2 :=
ВЫЧИСЛИТЬ (
    [Объем продаж],
    ФИЛЬТР (
        ВСЕ ("Календарь"),
        СОДЕРЖИТ (
            ТАБЛИЦА ДАННЫХ (
                "Год", ЦЕЛОЕ,
                "Месяц", STRING,
                {
                    {2006, "Декабрь"},
                    { 2007 г. , "Январь" }
                }
            ),
            [Год], «Календарь» [Год],
            [Месяц], «Календарь» [Название месяца]
        )
    )
)
 

При использовании IN вам все равно придется писать ФИЛЬТР, но вы немного улучшите читаемость:

Нью-Йорк 2007 ВСЕ :=
ВЫЧИСЛИТЬ (
    [Объем продаж],
    ФИЛЬТР (
        ВСЕ ("Календарь"),
        ('Календарь'[Год], 'Календарь'[Название месяца])
            В {
                (2006, "Декабрь"),
                (2007, "Январь")
            }
    )
)
 

Однако синтаксис последних трех мер использует итератор для таблицы Calendar, удаляя любой предыдущий контекст фильтра. Применение фильтра таблицы вместо фильтра столбца часто является плохой идеей, поэтому вам следует рассмотреть ФИЛЬТР, который включает только столбцы, задействованные в операторе IN, как в следующем примере:

Нью-Йорк 2007: =
ВЫЧИСЛИТЬ (
    [Объем продаж],
    ФИЛЬТР (
        ВСЕ («Календарь» [Год], «Календарь» [Название месяца]),
        ('Календарь'[Год], 'Календарь'[Название месяца])
            В {
                (2006, "Декабрь"),
                (2007, "Январь")
            }
    )
)
 

Как видно на следующем снимке экрана, NY 2007 не удаляет фильтр по дням недели, тогда как NY ​​2007 ALL игнорирует фильтры, примененные к любому столбцу таблицы Calendar.

Также в этом случае оператор IN является просто синтаксическим сахаром для соответствующей функции CONTAINSROW:

Нью-Йорк 2007 CR :=
ВЫЧИСЛИТЬ (
    [Объем продаж],
    ФИЛЬТР (
        ВСЕ («Календарь» [Год], «Календарь» [Название месяца]),
        СОДЕРЖАТЬ (
            {
                (2006, "Декабрь"),
                (2007, "Январь")
            },
            'Календарь'[Год], 'Календарь'[Название месяца]
        )
    )
)
 

Конструкторы таблиц и строк в DAX

В предыдущих примерах вы видели новый синтаксис DAX для создания анонимных таблиц. Конструктор таблицы создает таблицу, включающую все строки, определенные с помощью синтаксиса конструкторов строк.

Конструктор таблицы в DAX

Конструктор таблицы определяет таблицу с одной или несколькими строками, используя список конструкторов строк. Например, следующий синтаксис определяет конструктор таблицы, состоящий из двух строк, каждая из которых имеет два столбца: первая — целочисленное значение, а вторая — строка.

{
    (2006, "Декабрь"),
    (2007, "Январь")
}
 

Если у вас есть список значений для одного столбца, вы можете опустить синтаксис конструктора строк. Например, рассмотрим следующее выражение:

{ ("Красный"), ("Черный")}
 

Идентичен:

{ "Красный", "Черный" }
 

Обычно конструктор строк используется только при наличии двух или более столбцов.

Конструктор строк в DAX

Конструктор строки определяет список значений для строки между двумя круглыми скобками. Обычно он указывается слева от оператора IN или в конструкторе таблицы, когда задействованы два или более столбца. Вы также можете указать конструктор строки для одного столбца, но это не улучшит читабельность и обычно пропускается в таких условиях.

Обычно в конструкторе строк можно увидеть список постоянных значений, например:

 (2007, "Январь")
 

Однако вы можете указать выражения в конструкторе строк:

( 2005 + 2, ВЛЕВО ("Январь", 3 ))
 

Написанное вами выражение может получить доступ к контексту оценки, поэтому вы можете использовать как контекст строки, так и контекст фильтра, если он у вас есть.

Например, следующая мера показывает сумму января текущего года и декабря предыдущего года, читая год, выбранный из контекста фильтра:

Нью-Йорк Динамический :=
ЕСЛИ (
    HASONEVALUE ("Календарь" [Год]),
    ВЫЧИСЛИТЬ (
        [Объем продаж],
        ФИЛЬТР (
            ВСЕ («Календарь» [Год], «Календарь» [Название месяца]),
            ('Календарь'[Год], 'Календарь'[Название месяца])
                В {
                    (ЗНАЧЕНИЯ («Календарь» [Год]) — 1, «декабрь»),
                    ( ЗНАЧЕНИЯ («Календарь» [Год]), «Январь»)
                }
        )
    )
)
 

Мера оценивается, только если выбран один год:

Даже если это необычно, вы также можете получить доступ к контексту строки в конструкторе строк. Например, следующий вычисляемый столбец записывает строку «Последние 3 дня» для последних трех дней каждого месяца в таблицу «Календарь», используя столбец MonthDays, который содержит количество дней месяца в текущей строке:

Календарь[Период] =
ЕСЛИ (
    ДЕНЬ («Календарь» [Дата])
        В {
            'Календарь'[Дни Месяца],
            'Календарь'[Дней Месяца] - 1,
            'Календарь'[Дней Месяца] - 2 },
    "Последние 3 дня"
)
 

Этот столбец можно использовать в качестве фильтра в отчете:

Происхождение данных, имена столбцов и типы данных для конструкторов таблиц

Результатом конструктора таблиц является «анонимная» таблица, в которой каждый столбец имеет тип данных, выведенный используемыми конструкторами строк, но он не имеет никакого происхождения данных, соответствующего базовым столбцам базы данных. Таким образом, если вы примените конструктор таблицы в качестве прямого фильтра в таблице CALCULATE, вы не получите никакого эффекта.

Имена столбцов, созданные конструктором таблицы, — Value1, Value2 и т. д. Тип данных каждого столбца автоматически приводится к типу данных, который может представлять все значения в одном и том же столбце таблицы. Например, следующая вычисляемая таблица создает четыре столбца:

• Значение1 — строка (текст)
• Значение2 является целым числом (целым числом)
• Value3 является валютой (фиксированный десятичный тип)
• Значение4 представляет собой число с плавающей запятой (десятичный тип)

Примеры типов данных =
    {
        ( 2005, 1, 10, 100 ),
        ("2006", 2, 20, 200),
        ("2007", 3, ВАЛЮТА (30.1), ВАЛЮТА (30.1)),
        ("2008", 4, 40, 40,5)
    }
 

Заключение

Оператор IN упрощает синтаксис DAX, необходимый для сопоставления списка значений. Даже если его можно использовать для сравнения нескольких столбцов, он чаще используется только для одного столбца, поэтому он может иметь более простой синтаксис и более эффективный план выполнения запроса. Если вы планируете использовать несколько столбцов, убедитесь, что окружающий фильтр не добавляет ненужные столбцы, которые могут повлиять на производительность запроса.

CONTAINSROW

Возвращает TRUE, если существует хотя бы одна строка, в которой все столбцы имеют указанные значения.

CONTAINSROW (

, [ [ … ] ] )

CONTAINS

Возвращает TRUE, если существует хотя бы одна строка, в которой все столбцы имеют указанные значения.

СОДЕРЖИТ ( <Таблица>, <Имя столбца>, <Значение> [ <Имя столбца>, <Значение> [ … ] ] )

ЗА ИСКЛЮЧЕНИЕМ

Возвращает строки левой таблицы, которых нет в правой таблице.

ЗА ИСКЛЮЧЕНИЕМ ( , )

ВЫЧИСЛИТЬ

Переход контекста

Оценивает выражение в контексте, измененном фильтрами.

ВЫЧИСЛИТЬ ( <Выражение> [ <Фильтр> [ <Фильтр> [ … ] ] ] )

ФИЛЬТР

Возвращает отфильтрованную таблицу.

ФИЛЬТР ( <Таблица>, <ВыражениеФильтра> )

ВСЕ

РАСЧЕТ модификатор

Возвращает все строки в таблице или все значения в столбце, игнорируя любые фильтры, которые могли быть применены.

ALL ([] [ [ [ …] ] ] )

Оператор IN в M/Power Query

Вы пытаетесь использовать оператор IN в Power Query но не знаешь как? Оператор IN не встроен в Power Query, но мы можем добиться того же результата, используя другие функции. В этой статье я покажу вам, как использовать оператор IN в Power Query.

Введение

При создании условных операторов if общим требованием является проверка того, равно ли значение одному из многих. В этом операторе вы можете комбинировать несколько операторов ИЛИ.

В большинстве языков программирования для этого используется оператор IN. Затем оператор IN предназначен для упрощения условий, чтобы можно было легко предоставить список значений для проверки.

Допустим, у вас есть компания по продаже одежды. В настоящее время у вас есть скидка на джинсы, юбки и колготки. Вы хотите классифицировать их по категориям «Распродажа» и «Обычно». Вы можете классифицировать их, создав оператор if:

, если [Товар] = "Джинсы" или [Товар] = "Юбки" или [Товар] = "Колготки"
   потом "Распродажа"
   else "Regular" 

Этот оператор работает хорошо и возвращает правильные результаты в подробном виде. Мы проиллюстрировали это только тремя продуктами, но представьте, что делаем это для 15 или более продуктов.

Помимо того, что очень неудобно вручную набирать список товаров, это еще и требует большого количества ненужного повторения кода. При этом столбец [Товар] повторяется для каждого товара.

Репликация оператора IN

Итак, какой код можно использовать для репликации оператора IN? Вы можете переписать приведенный выше оператор следующим образом:

 if List. Contains( { "Джинсы", "Юбки", "Колготки" }, [Продукт] )
   потом "Распродажа"
   else "Regular" 

Таким образом, функция List.Contains копирует оператор IN в M. Она проверяет, равно ли значение в столбце [Product] одному из значений в списке.

Вы также можете комбинировать эту конструкцию и одновременно проверять несколько условий ИЛИ.

 if List.Contains( { "Джинсы", "Юбки", "Колготки" }, [Товар] )
     и List.Contains({ "Синий", "Красный", "Желтый" }, [Цвет])
   потом "Распродажа"
   else "Обычный" 

Чтобы пометить все товары, кроме тех, что указаны в вашем списке, вы можете изменить результат, используя слово not:

 if not List.Contains( { "Джинсы", "Юбки", "Колготки" }, [Продукт] )
   потом "Распродажа"
   else "Обычный" 

Оператор IN с несколькими столбцами

Вы также можете реплицировать оператор IN на несколько столбцов. Это может быть полезно, если вы хотите проверить, существует ли комбинация значений в таблице. Примеры предполагают работу с таблицами и записями и могут выглядеть так:

 = Список.Содержит(
  {{"Джинсы", "Синий"},
    {"Юбка", "Желтый"} },
    { [Product], [Color] } // Превращает столбцы в список
)
 
= Таблица.Содержит(
    #table(// создает таблицу
       {"Товар", "Цвет"}, // с именами столбцов
       { {"Джинсы", "Синие"}, // значения 1-й строки
         {"Юбка", "Желтый"} } ), // значения 2-й строки
    [[Product], [Color]] // проверяет, существуют ли значения в таблице
  )
 
= Таблица.Содержит(
     Таблица.ОтЗаписей(
         { [Товар = "Джинсы", Цвет = "Синий"],
           [Товар = "Юбка", Цвет = "Желтый"] },
         таблица типов [Product = Text.Type, Color = Text.Type]
     ),
  [[Продукт], [Цвет]]
 ) 

Это были всего лишь три примера. Есть несколько других способов построения таблиц, дающих аналогичные результаты. В следующей статье вы можете узнать больше о создании таблиц в Power Query.

Заключение

В этой статье показано, как можно воспроизвести оператор IN в языке Power Query M.