Логические операторы — AND, OR, NOT, XOR
Логические логические операторы выполняют логические операции с логическими операндами. Операторы включают унарное логическое отрицание ( ! ), двоичное логическое И (), OR ( & | ) и монопольное ИЛИ ( ^ ), а также двоичный условный логический и () и OR ( && || ).
- Унарный ! (логическое отрицание) оператор.
- Бинарные & (логическое И), | (логическое ИЛИ), а также ^ (логическое исключающее ИЛИ) операторы. Эти операторы всегда обрабатывают оба операнда.
- Бинарные && (условное логическое И) и || (условное логическое ИЛИ) операторы. Эти операторы вычисляют правый операнд, только если это необходимо.
Для операндов целочисленных типов операторы & , | и ^ выполняют побитовые логические операции. Дополнительные сведения см. в разделе Побитовые операторы и операторы сдвига.
Оператор логического отрицания !
Унарный префиксный оператор ! выполняет логическое отрицание операнда, возвращая true , если операнд имеет значение false , и false , если операнд имеет значение true .
bool passed = false; Console.WriteLine(!passed); // output: True Console.WriteLine(!true); // output: False Унарный оператор постфикса ! является оператором , допускающим значение NULL.
Оператор логического И &
Оператор & вычисляет логическое И для всех своих операндов. Результат операции x & y принимает значение true , если оба оператора x и y имеют значение true . В противном случае результат будет false .
Оператор & всегда вычисляет оба операнда. При оценке false левого операнда результат false операции независимо от значения правого операнда. Однако, даже тогда, правый операнд оценивается.
В следующем примере правый операнд оператора & является вызовом метода, который выполняется независимо от значения левого операнда:
bool SecondOperand() < Console.WriteLine("Second operand is evaluated."); return true; >bool a = false & SecondOperand(); Console.WriteLine(a); // Output: // Second operand is evaluated. // False bool b = true & SecondOperand(); Console.WriteLine(b); // Output: // Second operand is evaluated. // True Условный оператор логического И && также вычисляет логическое И для своих операндов, но не вычисляет правый операнд, если левый операнд имеет значение false .
Для операндов целочисленных типов оператор & вычисляет побитовое логическое И своих операндов. Унарный оператор & является оператором AddressOf.
Оператор логического исключения ИЛИ ^
Оператор ^ вычисляет логическое исключение ИЛИ для всех своих операндов, возвращая true для x ^ y , если x имеет значение true и y имеет значение false или x имеет значение false и y имеет значение true . В противном случае результат будет false . То есть для операндов bool оператор ^ возвращает тот же результат, что и оператор неравенства != .
Console.WriteLine(true ^ true); // output: False Console.WriteLine(true ^ false); // output: True Console.WriteLine(false ^ true); // output: True Console.WriteLine(false ^ false); // output: False Для операндов целочисленных типов оператор ^ вычисляет побитовое исключающее ИЛИ своих операндов.
Оператор логического ИЛИ |
Оператор | вычисляет логическое ИЛИ для всех своих операндов. Результат операции x | y принимает значение true , если хотя бы один из операторов x или y имеет значение true . В противном случае результат будет false .
Оператор | всегда вычисляет оба операнда. При оценке true левого операнда результат true операции независимо от значения правого операнда. Однако, даже тогда, правый операнд оценивается.
В следующем примере правый операнд оператора | является вызовом метода, который выполняется независимо от значения левого операнда:
bool SecondOperand() < Console.WriteLine("Second operand is evaluated."); return true; >bool a = true | SecondOperand(); Console.WriteLine(a); // Output: // Second operand is evaluated. // True bool b = false | SecondOperand(); Console.WriteLine(b); // Output: // Second operand is evaluated. // True Условный оператор логического ИЛИ || также вычисляет логическое ИЛИ для своих операндов, но не вычисляет правый операнд, если левый операнд имеет значение true .
Для операндов целочисленных типов оператор | вычисляет побитовое логическое ИЛИ своих операндов.
Условный оператор логического И &&
Условный оператор логического И && (оператор короткого замыкания) вычисляет логическое И для своих операндов. Результат операции x && y принимает значение true , если оба оператора x и y имеют значение true . В противном случае результат будет false . Если x вычисляется false значение , y не вычисляется.
В следующем примере правый операнд оператора && является вызовом метода, который не выполняется, если левый операнд имеет значение false :
bool SecondOperand() < Console.WriteLine("Second operand is evaluated."); return true; >bool a = false && SecondOperand(); Console.WriteLine(a); // Output: // False bool b = true && SecondOperand(); Console.WriteLine(b); // Output: // Second operand is evaluated. // True Оператор логического И & также вычисляет логическое И для своих операндов, но он всегда вычисляет оба операнда.
Условный оператор логического ИЛИ ||
Условный оператор логического ИЛИ || (оператор короткого замыкания) вычисляет логическое ИЛИ для своих операндов. Результат операции x || y принимает значение true , если хотя бы один из операторов x или y имеет значение true . В противном случае результат будет false . Если x вычисляется true значение , y не вычисляется.
В следующем примере правый операнд оператора || является вызовом метода, который не выполняется, если левый операнд имеет значение true :
bool SecondOperand() < Console.WriteLine("Second operand is evaluated."); return true; >bool a = true || SecondOperand(); Console.WriteLine(a); // Output: // True bool b = false || SecondOperand(); Console.WriteLine(b); // Output: // Second operand is evaluated. // True Оператор логического ИЛИ | также вычисляет логическое ИЛИ для своих операндов, но всегда вычисляет оба операнда.
Операторы, допускающие логическое значение NULL
Для операндов bool? операторы & (логическое И) и | (логическое ИЛИ) поддерживают следующую логику с тремя значениями:
- Оператор & возвращает true только в том случае, если оба операнда имеют значение true . Если x или y имеет значение false , оператор x & y возвращает false (даже если другой операнд имеет значение null ). В противном случае выражение x & y будет иметь значение null .
- Оператор | возвращает false только в том случае, если оба операнда имеют значение false . Если x или y имеет значение true , оператор x | y возвращает true (даже если другой операнд имеет значение null ). В противном случае выражение x | y будет иметь значение null .
Эта семантика описывается в следующей таблице:
| x | y | x&y | x|y |
|---|---|---|---|
| true | true | true | true |
| true | false | false | true |
| true | null | null | true |
| false | true | false | true |
| false | false | false | false |
| false | null | false | null |
| null | true | null | true |
| null | false | false | null |
| null | null | null | null |
Поведение этих операторов отличается от типичного поведения операторов, допускающих значение NULL. Как правило, оператор, определенный для операндов типа значения, также можно использовать с операндами соответствующего типа значения, допускающего значение NULL. Такой оператор возвращает null , если какой-либо из операндов имеет значение null . При этом операторы & и | могут возвращать отличное от NULL значение, даже если один из операндов имеет значение null . См. подробнее о поведении операторов, допускающих значение NULL, в разделе Операторы с нулификацией в статье Типы, допускающие значение NULL.
Вы также можете также использовать операторы ! и ^ с операндами bool? , как показано в следующем примере:
bool? test = null; Display(!test); // output: null Display(test ^ false); // output: null Display(test ^ null); // output: null Display(true ^ null); // output: null void Display(bool? b) => Console.WriteLine(b is null ? "null" : b.Value.ToString()); Условные логические операторы && и || не поддерживают операнды типа bool? .
Составное присваивание
Для бинарного оператора op выражение составного присваивания в форме
x op= y x = x op y за исключением того, что x вычисляется только один раз.
Операторы & , | и ^ поддерживают составное присваивание, как показано в следующем примере:
bool test = true; test &= false; Console.WriteLine(test); // output: False test |= true; Console.WriteLine(test); // output: True test ^= false; Console.WriteLine(test); // output: True Условные логические операторы && и || не поддерживают составное присваивание.
Приоритет операторов
В следующем списке перечислены логические операторы в порядке убывания приоритета:
- Оператор логического отрицания. !
- Оператор логического И &
- Оператор логического исключающего ИЛИ ^
- Оператор логического ИЛИ |
- Условный оператор логического И &&
- Условный оператор логического ИЛИ ||
Порядок вычисления, определяемый приоритетом операторов, можно изменить с помощью скобок ( () ).
Console.WriteLine(true | true & false); // output: True Console.WriteLine((true | true) & false); // output: False bool Operand(string name, bool value) < Console.WriteLine($"Operand is evaluated."); return value; > var byDefaultPrecedence = Operand("A", true) || Operand("B", true) && Operand("C", false); Console.WriteLine(byDefaultPrecedence); // Output: // Operand A is evaluated. // True var changedOrder = (Operand("A", true) || Operand("B", true)) && Operand("C", false); Console.WriteLine(changedOrder); // Output: // Operand A is evaluated. // Operand C is evaluated. // False Полный список операторов C#, упорядоченный по уровню приоритета, можно найти в разделе Приоритет операторов статьи Операторы C#.
Возможность перегрузки оператора
Определяемый пользователем тип может перегружать операторы ! , & , | и ^ . При перегрузке бинарного оператора соответствующий оператор составного присваивания также неявно перегружается. Явная перегрузка составного оператора присваивания для пользовательского типа невозможна.
Определяемый пользователем тип не может перегружать условные логические операторы && и || . При этом, если определяемый пользователем тип каким-либо образом перегружает операторы true и false и операторы & и | , операция && или || может быть применена для операндов этого типа. Дополнительные сведения см. в разделе Пользовательские условные логические операторы в Спецификации языка C#.
Спецификация языка C#
Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:
- Оператор логического отрицания
- Логические операторы
- Условные логические операторы
- Составное присваивание
См. также
- справочник по C#
- Операторы и выражения C#
- Побитовые операторы и операторы сдвига
Совместная работа с нами на GitHub
Источник этого содержимого можно найти на GitHub, где также можно создавать и просматривать проблемы и запросы на вытягивание. Дополнительные сведения см. в нашем руководстве для участников.
Для чего могут использоваться операторы и или
В языке Python операторы and и or, как вы и ожидали, выполняют булевы операции, но они не возвращают булевы значения: результатом всегда является значение одного из операндов.
Пример 2.16. Оператор and
>>> 'a' and 'b' 'b' >>> '' and 'b' '' >>> 'a' and 'b' and 'c' 'c'
| При использовании оператора and, значения вычисляются в булевом контексте слева напрво. Значения 0, '', [], (), <> и None являются ложью, все остальное является истиной [3] . Если у and оба операнда являются истиной, результатом будет последнее значение. В данном случае вычисляется выражение 'a', которое является истиной, затем 'b', которое также является истиной, и возвращается 'b'. | |
| Если какой-либо из операндов является ложью, результатом будет первое такое значение. В данном случает '' — первое значение, являющееся ложью. | |
| Все значения являются истиной, так что в результате мы получаем последнее — 'c'. |
Пример 2.17. Оператор or
>>> 'a' or 'b' 'a' >>> '' or 'b' 'b' >>> '' or [] or <> <> >>> def sidefx(): . print "in sidefx()" . return 1 >>> 'a' or sidefx() 'a'
| Как и для and опреранды or вычисляются в булевском контексте слева направо. Если операнд является истиной, or немедленно возвращает результат. В данном случае 'a' — первое истинное значение. | |
| or вычисляет выражение '', которое является ложью, затем 'b', которое является истиной, и возвращает 'b'. | |
| Если все значения являются ложью, or возвращает последнее. or вычисляет '' (ложь), [] (ложь), затем <> (ложь) и возвращает <>. | |
| Обратите внимание, что or вычисляет операнды до тех пор, пока не найдет истинное значение, остальное игнорируется. Это имеет значение, когда вычисление операнда дает сторонние эффекты. В данном случае функция sidefx не вызывается, так как для получения результата выражения с опереатором or достаточно того, что первый операнд, 'a', является истиной. |
Если вы используете C, то, наверное, знакомы с выражением bool ? a : b, которое дает a, если bool является истиной, b, если bool ложно. Благодаря особенностям работы операторов and и or в Python, вы можете достигнуть анологичного эффекта.
Пример 2.18. Прием с and-or
>>> a = "first" >>> b = "second" >>> 1 and a or b 'first' >>> 0 and a or b 'second'
| Синтаксис bool ? a : b в языке Python выглядит похоже. Все выражение вычисляется слева направо, так что оператор and применяется первым. 1 and 'first' дает 'first', затем 'first' or 'second' дает 'first'. | |
| 0 and 'first' дает 0, тогда 0 or 'second' дает 'second'. |
Однако, так как такое выражение выполняет обычные логические операции, а не является специальной конструкцией языка, существует очень важная разница между приемом с and-or в языке Python и конструкцией bool ? a : b в C. Если значение a является ложью, это прием не будет работать так как вы могли ожидать. (Вы можете сказать, что обожгись на этом? Более одного раза?)
Пример 2.19. Когда прием с and-or не работает
>>> a = "" >>> b = "second" >>> 1 and a or b 'second'
| Так как a — пустая строка, которую Python считает ложью в булевом контексте, 1 and '' дает '', а '' or 'second' дает 'second'. Ой! Это не то, что мы хотели получить. |
| Прием с and-or, bool and a or b, не будет работать так же, как конструкция bool ? a : b в C, если a является ложью. | |
Для безопасного использования приема с and-or необходимо сделать так, чтобы a всегда было истинным. Один из самых распространенных способо это сделать — заменить a на [a] и b на [b], тогда первый элемент получаемого списка будет либо a, либо b.
Пример 2.20. Безопасное использование приема с and-or
>>> a = "" >>> b = "second" >>> (1 and [a] or [b])[0] ''
| Так как выражение [a] является непустым списком, оно никогда не будет ложно. Даже если a равно 0, '' или другому значению, являющемуся ложью, список [a] всегда будет являться истиной, потому что содержит один элемент. |
Кажется, этот прием не стоит того, чтобы его использовать. В конце концов вы всегда можете воспользоваться интсрукцией if. Тогда зачем вся эта суета? Конечно, в большинстве случаев выбирая между двумя константами вы можете использовать простой синтаксис и не беспокоиться, потому что значение a всегда будет истинным. И даже если придется использовать более сложный синтакс, на это могут найтись весские причины: в некоторых случаях в языке Python использование инструкции if не допускается, например в lambda-функциях.
- В Python Cookbook обсуждаются альтернативы приему с and-or.
[3] Ну, почти все. По умолчанию экземпляры классов являются истиной, но вы можете определить специальные методы в классе, чтобы его экземпляры могли быть ложью. Вы узнаете все о классах и специальных методах в главе 3.
Copyright © 2000, 2001, 2002 Марк Пилгрим
Copyright © 2001, 2002 Перевод, Денис Откидач
Операторы упаковки и распаковки — Python: Функции
В Python операторы * и ** используются, чтобы упаковывать и распаковывать итерабельные объекты и словари. Эти операторы обеспечивают гибкий способ обработки аргументов функций и позволяют писать функции, которые могут принимать переменное количество аргументов. В этом уроке мы узнаем, как пользоваться ими.
Оператор *
Оператор * используется для упаковки и распаковки итерируемых объектов, таких как списки или кортежи. При использовании перед итерируемым объектом, во время вызова функции, оператор * распаковывает его. Элементы итерируемого объекта передаются в качестве аргумента функции:
def sum_of_values(a, b, c): return a + b + c values = [1, 2, 3] result = sum_of_values(*values) print(result) # 6 В этом примере оператор * используется, чтобы распаковывать список значений и передавать его элементы в качестве аргументов функции sum_of_values .
Также оператор * можно использовать, чтобы упаковывать итерабельные переменные. Это позволяет присваивать их отдельным переменным:
my_list = [1, 2, 3, 4] a, b, *c = my_list print(a, b, c) # 1 2 [3, 4] В этом примере оператор * упаковывает оставшуюся часть списка my_list в переменную c .
Оператор * можно использовать для распаковки итерируемого списка в новый список или кортеж:
my_list = [1, 2, 3] new_list = [*my_list, 4, 5, 6] print(new_list) # [1, 2, 3, 4, 5, 6] my_tuple = (1, 2, 3) new_tuple = (*my_tuple, 4, 5, 6) print(new_tuple) # (1, 2, 3, 4, 5, 6) В этих примерах оператор * используется для распаковки итераций my_list и my_tuple в новые списки и кортежи с добавлением дополнительных значений.
Оператор **
Оператор ** используется для упаковки и распаковки словарей. При использовании перед словарем во время вызова функции оператор ** распаковывает пары ключ-значение словаря в аргументы ключевых слов, которые могут быть переданы в функцию:
def print_details(name, age): print(f"Name: name>") print(f"Age: age>") details = "name": "John", "age": 30> print_details(**details) # Name: John # Age: 30 В этом примере оператор ** используется для распаковки словаря details и передачи его пар ключ-значение в качестве аргументов ключевых слов в функцию print_details .
Оператор ** также можно использовать для создания словаря из последовательности пар ключ-значение:
dict1 = "a": 1, "b": 2> dict2 = "c": 3, "d": 4> combined_dict = **dict1, **dict2> print(combined_dict) # В приведенном выше коде определяются два словаря dict1 и dict2 . А оператор ** используется для распаковки их пар ключ-значение и объединения в один словарь combined_dict .
Если ключи дублируются, то значение из второго словаря перезапишет значение из первого словаря.
Открыть доступ
Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно
- 130 курсов, 2000+ часов теории
- 1000 практических заданий в браузере
- 360 000 студентов
Наши выпускники работают в компаниях:
Логическое ИЛИ (||)
Логический оператор ИЛИ ( || ) (дизъюнкция) для набора операндов истинен будет true только в случае, если один или несколько его операндов имеют значение true .
Обычно используется с булевыми (логическими) значениями. Тогда возвращается булевое значение. Однако фактически оператор || возвращает значение одного из операндов, поэтому если этот оператор используется с небулевыми значениями, он вернет небулевое значение.
Интерактивный пример
Синтаксис
|| expr2;
Описание
Если expr1 может быть преобразовано в true , то вернётся expr1 ; в противном случае возвращается expr2 .
Если значение может быть преобразовано в true , то оно рассматривается как истиноподобное (truthy). Если же значение может быть преобразовано в false , то оно называется ложноподобным (falsy).
Примеры выражений, которые могут быть преобразованы в false :
- null ;
- NaN ;
- 0 ;
- пустая строка ( «» , » , « );
- undefined .
Несмотря на то, что оператор || может использоваться с операндами без логических значений, это всё равно булевый оператор, поскольку его возвращаемое значение всегда можно преобразовать в булевый примитив. Чтобы явно преобразовать возвращаемое значение этого оператора (или вообще любое выражение) в соответствующее значение булевого типа, используйте двойной оператор НЕ или конструктор Boolean (en-US).
Сокращённое вычисление
Оператор логического ИЛИ вычисляется слева направо, делая возможным сокращённое вычисление выражения, согласно следующему правилу:
(истинноподобное выражение) || следующее выражение — вычисление останавливается на истинноподобном выражении;
Сокращенное вычисление хорошо тем, что следующее выражение не будет вычислено, т.е. всё, связанное с ним, будет проигнорировано (например, если следующее выражение представляет собой вызов функции, то он никогда не произойдёт). Всё потому, что значение оператора известно уже после вычисления первого операнда. Посмотрите на пример:
function A() console.log("вызвана функция A"); return false; > function B() console.log("вызвана функция B"); return true; > console.log(B() || A()); // В результате вызова функции B, в консоли будет выведено "вызвана функция B", // а далее в консоли появится false (это результат оператора)
Приоритет операторов
Следующие выражения могут показаться эквивалентными, но это не так, потому что оператор && выполняется до оператора || (см. приоритет операторов).
true || (false && false); // вернёт true, поскольку сначала вычисляется && (true || false) && false; // вернёт false, поскольку у группировки выше приоритет
Примеры
Использование оператора ИЛИ
В следующем коде показаны примеры использования оператора || (логическое ИЛИ).
= true || true; // t || t вернёт true o2 = false || true; // f || t вернёт true o3 = true || false; // t || f вернёт true o4 = false || 3 == 4; // f || f вернёт false o5 = "Cat" || "Dog"; // t || t вернёт "Cat" o6 = false || "Cat"; // f || t вернёт "Cat" o7 = "Cat" || false; // t || f вернёт "Cat" o8 = "" || false; // f || f вернёт false o9 = false || ""; // f || f вернёт "" o10 = false || varObject; // f || object вернёт varObject
Примечание: Если вы используете этот оператор, чтобы задать значение по умолчанию для некоторой переменной, имейте в виду, что любое ложноподобное будет проигнорировано. Если вам нужно исключить только null или undefined , попробуйте воспользоваться оператором нулевого слияния.
Правила конвертации для булевых значений
Конвертация И в ИЛИ
Следующая операция с булевыми значениями: