Универсальный внешний накопитель для всех iOS-устройств, совместим с PC/Mac, Android
Header Banner
8 800 100 5771 | +7 495 540 4266
c 9:00 до 24:00 пн-пт | c 10:00 до 18:00 сб
0 Comments

Содержание

Логические операторы - Введение в Python

Введение в Python

Видео может быть заблокировано из-за расширений браузера. В статье вы найдете решение этой проблемы.

Logical expressions in Python

Logical expressions

  • occur when use compare or boolean operators
  • >, <, ==, is, in, and, or, not
  • are used in if operator
  • return boolean values

Examples

if value > 10:
    # ...
if status == 'active':
    # ...
if user.age > 16 and not user.is_banned:
    # ....

Boolean operators

  • AND (binary) — true if both operands are true
  • OR (binary) — true if at least one of operands is true
  • NOT (unary) — reverse

NOT has higher priority than AND and OR

Examples

10 > 2 and 10 > 9         # True
10 > 2 and 10 > 11        # False
10 > 2 or 10 > 11         # True
10 > 2 and not 10 > 11    # True
not (10 > 2 or 10 > 11)   # False

Any object behaves like bool

# False
None    ''    u""    0    0.0     {}     ()     []    set()

# True
- non-empty string or collection
- non-zero number

bool(0)           # False
bool([])          # False
bool('')          # False
bool({})          # False
bool(0.00001)     # True
bool(-1)          # True
bool(' ')         # True
bool(' '.strip()) # False
bool((0, 0, ))    # True
bool(None)        # False

result = 0
if result:
    # no code
else:
    print "result is zero"

data = {}
if data:
   # no code
else:
   # code goes there

How to override bool behaviour

  • Override __nonzero__ method in Py2
  • __bool__ in Py3

How to override bool behaviour

# rarely
class Balance(int):
    def __nonzero__(self):
        return self > 0

balance = Balance(-10)
if balance: # False

# common
class User(object):
    def is_balance_ok(self):
        return self. balance > 0

user = User(balance=-10)
if user.is_balance_ok(): # False

Expressions return values

# Some languages
if (balance > 0) {
    can_pay = True;
} else {
    can_pay = False;
}

# Python
can_pay = balance > 0
can_pay = user.balance > 0 and not user.is_banned
can_pay = (
    user.balance > 0
    and not user.is_banned
    and user.has_perm('buy')
)
is_active = status not in ('banned', 'pending')
can_exit = user.age > 18 and is_confirmed
ok = 'error' not in response['text']
ok = error is None

Is value None?

# bad
val == None
type(None) == types.NoneType

# OK
value is None
value is not None

Ternary operator

var x = (a > b) ? a : b; // javascript
x = (...) if (...) else (...)
x = a if a > b else b
res = (process_good_result(data)
       if data else process_bad_result(data))

Boolean expressions are lazy

def func(x):
    print x
    return bool(x)

res = func(1) and func(0) and func(2) and func(3)    # False
>>> 1 0
res func(1) and func(3) and func(2) and func(0)      # False
>>> 1 3 2 0

res = func(1) or func(2)       # True
>>> 1
res = func(0) or func(1) or func(2) or func(3) # True
>>> 0 1

So put the easiest expressions in OR at the first place.

Conclusion

  • occur when use compare or logical operators
  • return boolean value
  • any object can be used as a predicate
  • value is None, but not value == None
  • use ternary operator
  • remember about laziness

Остались вопросы? Задайте их в разделе «Обсуждение»

Вам ответят команда поддержки Хекслета или другие студенты.

Ошибки, сложный материал, вопросы >
Нашли опечатку или неточность?

Выделите текст, нажмите ctrl + enter и отправьте его нам. В течение нескольких дней мы исправим ошибку или улучшим формулировку.

Что-то не получается или материал кажется сложным?

Загляните в раздел «Обсуждение»:

  • задайте вопрос. Вы быстрее справитесь с трудностями и прокачаете навык постановки правильных вопросов, что пригодится и в учёбе, и в работе программистом;
  • расскажите о своих впечатлениях. Если курс слишком сложный, подробный отзыв поможет нам сделать его лучше;
  • изучите вопросы других учеников и ответы на них. Это база знаний, которой можно и нужно пользоваться.
Об обучении на Хекслете

Логические выражения и операторы. Python. Урок 5

Логические выражения и логический тип данных

Часто в реальной жизни мы соглашаемся с каким-либо утверждением или отрицаем его. Например, если вам скажут, что сумма чисел 3 и 5 больше 7, вы согласитесь, скажете: «Да, это правда». Если же кто-то будет утверждать, что сумма трех и пяти меньше семи, то вы расцените такое утверждение как ложное.

Подобные фразы предполагают только два возможных ответа – либо "да", когда выражение оценивается как правда, истина, либо "нет", когда утверждение оценивается как ошибочное, ложное. В программировании и математике если результатом вычисления выражения может быть лишь истина или ложь, то такое выражение называется логическим.

Например, выражение 4 > 5 является логическим, так как его результатом является либо правда, либо ложь. Выражение 4 + 5 не является логическим, так как результатом его выполнения является число.

На позапрошлом уроке мы познакомились с тремя типами данных – целыми и вещественными числами, а также строками. Сегодня введем четвертый – логический тип данных (тип bool). Его также называют булевым. У этого типа всего два возможных значения: True (правда) и False (ложь).

>>> a = True
>>> type(a)
<class 'bool'>
>>> b = False
>>> type(b)
<class 'bool'>

Здесь переменной a было присвоено значение True, после чего с помощью встроенной в Python функции type() проверен ее тип. Интерпретатор сообщил, что это переменная класса bool. Понятия "класс" и "тип данных" в данном случае одно и то же. Переменная b также связана с булевым значением.

В программировании False обычно приравнивают к нулю, а True – к единице. Чтобы в этом убедиться, можно преобразовать булево значение к целочисленному типу:

>>> int(True)
1
>>> int(False)
0

Возможно и обратное. Можно преобразовать какое-либо значение к булевому типу:

>>> bool(3.4)
True
>>> bool(-150)
True
>>> bool(0)
False
>>> bool(' ')
True
>>> bool('')
False

И здесь работает правило: всё, что не 0 и не пустота, является правдой.

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

Говоря на естественном языке (например, русском) мы обозначаем сравнения словами "равно", "больше", "меньше". В языках программирования используются специальные знаки, подобные тем, которые используются в математике: > (больше), < (меньше), >= (больше или равно), <= (меньше или равно), == (равно), != (не равно).

Не путайте операцию присваивания значения переменной, обозначаемую в языке Python одиночным знаком "равно", и операцию сравнения (два знака "равно"). Присваивание и сравнение – разные операции.

>>> a = 10
>>> b = 5
>>> a + b > 14
True
>>> a < 14 - b
False
>>> a <= b + 5
True
>>> a != b
True
>>> a == b
False
>>> c = a == b
>>> a, b, c
(10, 5, False)

В данном примере выражение c = a == b состоит из двух подвыражений. Сначала происходит сравнение (==) переменных a и b. После этого результат логической операции присваивается переменной c. Выражение a, b, c просто выводит значения переменных на экран.

Сложные логические выражения

Логические выражения типа kByte >= 1023 являются простыми, так как в них выполняется только одна логическая операция. Однако, на практике нередко возникает необходимость в более сложных выражениях. Может понадобиться получить ответа "Да" или "Нет" в зависимости от результата выполнения двух простых выражений. Например, "на улице идет снег или дождь", "переменная news больше 12 и меньше 20".

В таких случаях используются специальные операторы, объединяющие два и более простых логических выражения. Широко используются два оператора – так называемые логические И (and) и ИЛИ (or).

Чтобы получить True при использовании оператора and, необходимо, чтобы результаты обоих простых выражений, которые связывает данный оператор, были истинными. Если хотя бы в одном случае результатом будет False, то и все сложное выражение будет ложным.

Чтобы получить True при использовании оператора or, необходимо, чтобы результат хотя бы одного простого выражения, входящего в состав сложного, был истинным. В случае оператора or сложное выражение становится ложным лишь тогда, когда ложны оба составляющие его простые выражения.

Допустим, переменной x было присвоено значение 8 (x = 8), переменной y присвоили 13 (y = 13). Логическое выражение y < 15 and x > 8 будет выполняться следующим образом. Сначала выполнится выражение y < 15. Его результатом будет True. Затем выполнится выражение x > 8. Его результатом будет False. Далее выражение сведется к True and False, что вернет False.

>>> x = 8
>>> y = 13
>>> y < 15 and x > 8
False

Если бы мы записали выражение так: x > 8 and y < 15, то оно также вернуло бы False. Однако сравнение y < 15

не выполнялось бы интерпретатором, так как его незачем выполнять. Ведь первое простое логическое выражение (x > 8) уже вернуло ложь, которая, в случае оператора and, превращает все выражение в ложь.

В случае с оператором or второе простое выражение проверяется, если первое вернуло ложь, и не проверяется, если уже первое вернуло истину. Так как для истинности всего выражения достаточно единственного True, неважно по какую сторону от or оно стоит.

>>> y < 15 or x > 8
True

В языке Python есть еще унарный логический оператор not, т. е. отрицание. Он превращает правду в ложь, а ложь в правду. Унарный он потому, что применяется к одному выражению, стоящему после него, а не справа и слева от него как в случае бинарных and и or.

>>> not y < 15
False

Здесь у < 15 возвращает True. Отрицая это, мы получаем False.

>>> a = 5
>>> b = 0
>>> not a
False
>>> not b
True

Число 5 трактуется как истина, отрицание истины дает ложь. Ноль приравнивается к False. Отрицание False дает True.

Практическая работа

  1. Присвойте двум переменным любые числовые значения.

  2. Используя переменные из п. 1, с помощью оператора and составьте два сложных логических выражения, одно из которых дает истину, другое – ложь.

  3. Аналогично выполните п. 2, но уже с оператором or.

  4. Попробуйте использовать в логических выражениях переменные строкового типа. Объясните результат.

  5. Напишите программу, которая запрашивала бы у пользователя два числа и выводила бы True или False в зависимости от того, больше первое число второго или нет.

Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса

3.5.3 Арифметические и логические операции.

В основном нам понадобится пять арифметических операций:

Операция сложения: использует знак„+" и  складывает два числа, например c=a+b складывает значения переменных a и b и сохраняет результат операции в переменную с (c=3+2, следовательно, c=5).

Операция вычитания: использует знак  „ - " и вычитает из первого значения второе, например c=a-b вычитает значение переменной а из значения переменной b и сохраняет результат операции в переменную с (c=3-2, следовательно, c=1).

Операция умножения: использует знак  „*" и умножает два числа, например c=a*b умножает значения переменных a и b и сохраняет результат операции в переменную с(c=3*2, следовательно,  c=6).

Операция деления: использует знак  „/" и делит первое значения на второе, например c=a/b вычитает значение переменной а на значение переменной b и сохраняет результат операции в переменную с (c=3/2, следовательно, c=1,5 или c=1, в зависимости от языка и типов данных используемых переменных).

Операция остаток от деления: использует знак  „%" и делит первое значения на второе, например c=a%b вычитает значение переменной а на значение переменной b и сохраняет остаток от деления в переменную с (c=5%3, следовательно, c=2).

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

В языках, где имеются переменные вероятностного типа, есть возможность использовать и логические операции тоже, например c= a && b, c=true, если a и b равны и c=false, если a и b не равны. Больше информации о логических операциях можно найти в разделе управляющих команд.

Порядок выполнения операций в некоторых языках программирования разный, а  в некоторых языках одинаковый: часть языков сначала совершают операции умножения и деления, а потом сложения и вычитания. Операции выполняются слева направо. Однако порядок операций можно определить и с помощью скобок (прежде всего, совершаются операции находящиеся в скобках). Например, c=a+a*b отличается от операции c=(a+a)*b.

Различные языки программирования позволяют использование различных арифметических операторов. Например c += a прибавляет к значению переменной с значение переменной а (т.е. c = a + c), a++ это операция итерации переменной, т.е. увеличения значения переменной на один (т.е. a=a+1) и т.д.

Логические операции - Логика

Логическая операция КОНЪЮНКЦИЯ (логическое умножение):

·  в естественном языке соответствует союзу и;

·  в алгебре высказываний обозначение &;

·  в языках программирования обозначение And.

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

В алгебре множеств конъюнкции соответствует операция пересечения множеств, т.е. множеству получившемуся в результате умножения множеств А и В соответствует множество, состоящее из элементов, принадлежащих одновременно двум множествам.

Логическая операция ДИЗЪЮНКЦИЯ (логическое сложение):

·  в естественном языке соответствует союзу или;

·  обозначение V;

·  в языках программирования обозначение Or.

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

В алгебре множеств дизъюнкции соответствует операция объединения множеств, т.е. множеству получившемуся в результате сложения множеств А и В соответствует множество, состоящее из элементов, принадлежащих либо множеству А, либо множеству В.

Логическая операция ИНВЕРСИЯ (отрицание):

·  в естественном языке соответствует словам неверно, что. .. и частице не;

·  обозначение

 ;

·  в языках программирования обозначение Not;

Отрицание - это логическая операция, которая каждому простому высказыванию ставит в соответствие  составное  высказывание, заключающееся в том, что исходное высказывание отрицается.

В алгебре множеств логическому отрицанию соответствует операция дополнения до универсального множества, т.е. множеству получившемуся в результате отрицания множества А соответствует множество

 , дополняющее его до универсального множества. 

Логическая операция ИМПЛИКАЦИЯ (логическое следование):

·     в естественном языке соответствует обороту  если ..., то ...;

·     обозначение  => .

Импликация - это логическая операция, ставящая в соответствие каждым двум простым высказываниям составное высказывание, являющееся ложным тогда и только тогда, когда условие (первое высказывание) истинно, а следствие (второе высказывание) ложно.

Логическая операция ЭКВИВАЛЕНЦИЯ (равнозначность):

·     в естественном языке соответствует оборотам речи тогда и только тогда; в том и только в том случае;

·     обозначения   <=>, ~ .

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

Логические операторы — Introduction to Programming with Python

Введение

Conditionals are a nice way to make decisions by asking if something equals True or not. But often one condition is not enough. We may want to take the opposite of our result. Or for instance if we want to make a decision upon turtle.xcor() and turtle.ycor() we have to combine them. This can be done with logical operators.

Оператор отрицания

Если мы хотим сделать что-либо ложным, можно использовать not. Это логический оператор:

x = False
if not x :
    print("condition met")
else:
    print("condition not met")

Упражнение

The turtle gives us a useful function to know if it is drawing or not: turtle.isdown(). This function returns True if the turtle is drawing. As we have seen earlier, the function turtle.penup() and turtle.pendown() toggle between drawing while moving, or just moving without a trace.

Можно ли написать функцию, которая заставляет черепашку двигаться вперёд, если перо поднято?

Решение

def stealthed_forward(distance):
    if not turtle.isdown():
        turtle.forward(distance)

This and that or something else

Два простых и понятных оператора: and (“и” в переводе с английского) и or (“или” в переводе с английского), которые делают ровно то, что и обозначают:

if 1 < 2 and 4 > 2:
    print("condition met")

if 1 > 2 and 4 < 10:
    print("condition not met")

if 4 < 10 or 1 < 2:
    print("condition met")

Использовать только один логический оператор не обязательно, можно комбинировать их как угодно.

Упражнение

Earlier we put the turtle in a circular prison. This time let’s make it a box. If the turtle goes more than 100 in the X or Y axis then we turn the turtle back around to the center.

Решение

def forward(distance):
    while distance > 0:
        if (turtle.xcor() > 100
            or turtle.xcor() < -100
            or turtle.ycor() > 100
            or turtle.ycor() < -100):
            turtle.setheading(turtle.towards(0,0))
        turtle.forward(1)
        distance = distance - 1

Логические операции

Чаще всего используются следующие логические операции:

  • инверсия (отрицание, логическое не),
  • конъюнкция (логическое и),
  • дизъюнкция (логическое или),
  • импликация (следование),
  • эквивалентность (тождество).

Рассмотрим каждую из них подробно. Для описания используем диаграммы Эйлера-Венна и таблицы истинности.

Логическая операция/
соответствие в русском языке
Обозначение
Диаграмма Эйлера-Венна
Таблица
истинности
инверсия (отрицание, логическое "НЕ")/

"...не...", "неверно, что..."

¬


A
¬A
0
1
1
0

конъюнкция (логическое "И")/

"...и..."

Λ, &

AB
AΛB
00
0
0
1
0
1
0
0
1
1
1

дизъюнкция (логическое "ИЛИ")

". ..или...", "...либо..."

V
A
B
AVB
0
0
0
0
1
1
1
0
1
1
1
1

импликация (следование)/

"если...,то...", "когда..., тогда..."


A
B
A→B
0
0
1
0
1
1
1
0
0
1
1
1

эквивалентность (тождество)

"тогда и только тогда, когда"

↔, ≡
A
B
A↔B
0
0
1
0
1
0
1
0
0
1
1
1

Основные логические операции: инверсия, конъюнкция, дизъюнкция.

Остальные логические операции можно выразить через них:

A→B=¬AVB;

A↔B=(AΛB)V(¬AΛ¬B).

Порядок выполнения логических операций в выражении (от наибольшего приоритета к наименьшему):

инверсия, конъюнкция, дизъюнкция, импликация, эквивалентность.

Пример:

AV¬BΛC→D↔E.

Порядок выполнения:

  1. ¬B
  2. (¬B)ΛC
  3. AV((¬B)ΛC)
  4. (AV((¬B)ΛC))→D
  5. ((AV((¬B)ΛC))→D)↔E

Перейти к решению задач на алгебру логики из демо ЕГЭ

Урок #4 - Условия и логические операции

Условие (if else), а также оператор switch case это важные вещи в языке программирования c++. В уроке мы изучим логические операции, а также условные операторы, что применяются в языке программирования C++.

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


Конструкция if - else

За счёт if else можно проверить одно или несколько условий и в случае их успешной проверки будет выполнен один, иначе другой.

Рассмотрим пример:

int a = 2, b = 10;
if (a == b) { // Если a будет равным b, тогда будет выполнен код
	// Здесь код что будет выполнен
	// Если все одна строка кода, то фигурные скобки {}
	// можно не ставить
} else if (a 

Вы можете прописать структуру лишь с одним условием if, а можете дописать в неё сколько-угодно вложенных условий else if.

Внутри каждого из условий можно прописывать другие конструкции if else, что будут проверять новые выражения.

Если необходимо проверить несколько условий в одном операторе, то можно воспользоваться логическим «и» или же логическим «или»:

if (a != b && a > b) {
	// Код будет выполнен, если и первое, и второе условие
	// окажутся верными
}

if (a 

Тернарная операция

Это сокращенная форма if else. Записывается следующим образом:

int x = 90, a = 8;
int res = x 

Проверяем: если “x” будет меньше “а”, то в переменную res устанавливаем их сумму, иначе – их разницу. 

Конструкция switch

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

Пример оператора:

int x = 23;
switch (x) { // Проверяем переменную x
	case 1: // Если переменная будет равна 1, то здесь сработает код
		// Может быть множество строк, а не только одна
		cout 

Логические операторы - cppreference.com

Логические операторы применяют к своим операндам стандартные операции логической алгебры.

Оператор Имя оператора Пример Результат
! логическое НЕ ! А логическое отрицание a
&& логическое И a && b логическое И для a и b
|| логическое ИЛИ a || б логическое ИЛИ a и b

[править] Логическое НЕ

Выражение логического НЕ имеет вид

где

Оператор логического НЕ имеет тип int.Его значение равно 0, если выражение оценивается как значение, не равное нулю. Его значение равно 1, если выражение оценивается как значение, равное нулю. (так что! E совпадает с (0 == E))

 #include 
#include 
#include 
int main (пусто)
{
    bool b =! (2 + 2 == 4); // не правда
    printf ("! (2 + 2 == 4) =% s \ n", b? "true": "false");

    int n = isspace ('а'); // ноль, если 'a' - это пробел, ненулевое значение в противном случае
    int x = !! n; // "bang-bang", обычная идиома C для отображения целых чисел на [0,1]
                 // (все ненулевые значения становятся 1)
    char * a [2] = {"непробел", "пробел"};
    printf ("% s \ n", a [x]); // теперь x можно безопасно использовать как индекс для массива из 2 целых чисел
} 

Выход:

! (2 + 2 == 4) = ложь
непространственный 

[править] Логическое И

Логическое выражение И имеет вид

где

лв. - выражение любого скалярного типа
справа - выражение любого скалярного типа, которое оценивается только в том случае, если lhs не равно 0

Оператор логического И имеет тип int и значение 1, если оба значения lhs и rhs не равны нулю.В противном случае он имеет значение 0 (если либо lhs, либо rhs, либо оба сравниваются равными нулю).

После оценки lhs есть точка последовательности. Если результат lhs сравнивается с нулем, тогда rhs вообще не оценивается (так называемая оценка короткого замыкания )

 #include 
#include 
int main (пусто)
{
    bool b = 2 + 2 == 4 && 2 * 2 == 4; // b == истина

    1> 2 && put («это не печатается»);

    char * p = "abc";
    if (p && * p) // обычная идиома C: если p не равно нулю
                // И если p не указывает на конец строки
    {// (обратите внимание, что благодаря оценке короткого замыкания, это
                // не будет пытаться разыменовать нулевой указатель)
    //... // ... затем выполняем некоторую строковую обработку
    }
} 

[править] Логическое ИЛИ

Выражение логического ИЛИ имеет вид

где

лв. - выражение любого скалярного типа
справа - выражение любого скалярного типа, которое оценивается, только если lhs сравнивается с 0

Оператор логического ИЛИ имеет тип int и значение 1, если сравнение lhs или rhs не равно нулю.В противном случае он имеет значение 0 (если оба параметра слева и справа равны нулю).

После оценки lhs есть точка последовательности. Если результат lhs не равен нулю, тогда rhs вообще не оценивается (так называемая оценка короткого замыкания )

 #include 
#include 
#include 
#include 
int main (пусто)
{
    bool b = 2 + 2 == 4 || 2 + 2 == 5; // истинный
    printf ("истина или ложь =% s \ n", b? "истина": "ложь");

    // логическое ИЛИ может использоваться аналогично Perl "или умереть", если rhs имеет скалярный тип
    fopen ("тест.  b 
a << b
a >> b

! A
a && b
a || б

a == b
a! = B
a a> b
a <= b
a> = b

a [b]
* a
и a
a-> b
a.б

a (...)
a, b
(тип) a
? :
размер
_Alignof (начиная с C11)

[править] См. Также

Логические операторы - cppreference.com

Возвращает результат логической операции.

Имя оператора Синтаксис Возможна перегрузка Примеры прототипов (для класса T)
Определение внутреннего класса Определение внешнего класса
отрицание не а

!

Да bool T :: operator! () Const; оператор логического типа! (Const T & a);
И а и б

a && b

Да bool T :: operator && (const T2 & b) const; логический оператор && (const T & a, const T2 & b);
включительно ИЛИ а или б

a || b

Да bool T :: оператор || (const T2 & b) const; логический оператор || (const T & a, const T2 & b);
Примечания
  • Формы, подобные ключевым словам (and, or, not), и символьные формы (&&, || ,!) могут использоваться взаимозаменяемо (см. Альтернативные представления)
  • Все встроенные операторы возвращают bool, и большинство определяемых пользователем перегрузок также возвращают bool, так что определяемые пользователем операторы могут использоваться таким же образом, как и встроенные.Однако при перегрузке определяемого пользователем оператора в качестве возвращаемого типа может использоваться любой тип (включая void).
  • Встроенные операторы && и || выполняет оценку короткого замыкания (не оценивает второй операнд, если результат известен после оценки первого), но перегруженные операторы ведут себя как обычные вызовы функций и всегда оценивают оба операнда

[править] Объяснение

Выражения логического оператора имеют вид

! справа (1)
левый && правый (2)
левый || справа (3)

1) Логическое НЕ

2) Логическое И

3) Логическое включительно ИЛИ

Если операнд не является bool, он преобразуется в bool с помощью контекстного преобразования в bool: он правильно сформирован, только если объявление bool t (arg) правильно сформировано, для некоторых придуманных временных t .

Результат - логическое значение pr.

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

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

Для встроенного логического оператора ИЛИ результат будет истиной, если либо первый, либо второй операнд (или оба) истинны.Этот оператор является коротким замыканием: если первый операнд истинен, второй операнд не оценивается.

Обратите внимание, что побитовые логические операторы не выполняют короткое замыкание.

[править] Результаты

а правда ложь
! А ложь правда
и а
правда ложь
б правда правда ложь
ложь ложь ложь
или а
правда ложь
б правда правда правда
ложь правда ложь

В разрешении перегрузки для определяемых пользователем операторов следующие встроенные сигнатуры функций участвуют в разрешении перегрузки:

оператор bool! (Bool)

оператор bool && (bool, bool)

оператор bool || (bool, bool)

[править] Пример

 #include 
#include <строка>
int main ()
{
    int n = 2;
    int * p = & n;
    // указатели можно преобразовать в bool
    if (p && * p == 2 // "* p" можно использовать после "p &&"
       || ! p && n! = 2) // || имеет более низкий приоритет, чем &&
        std :: cout << "истина \ п";

    // потоки также можно преобразовать в bool
    std :: cout << "Введите 'quit', чтобы выйти.  b 
a << b
a >> b

! A
a && b
a || б

a == b
a! = B
a a> b
a <= b
a> = b
a <=> b

a [b]
* a
и a
a-> b
a.б
а -> * б
а. * б

а (...)
а, б
? :

Специальные операторы

static_cast преобразует один тип в другой связанный тип
dynamic_cast преобразует в иерархиях наследования
const_cast добавляет или удаляет квалификаторы cv
reinterpret_cast преобразует тип в несвязанный тип
C-style cast преобразует один тип в другой путем сочетания static_cast , const_cast , и reinterpret_cast
new создает объекты с динамической продолжительностью хранения.
delete уничтожает объекты, ранее созданные новым выражением, и освобождает полученную область памяти.
sizeof запрашивает размер типа
sizeof... запрашивает размер пакета параметров (начиная с C ++ 11)
typeid запрашивает информацию о типе типа
noexcept проверяет, может ли выражение вызывать исключение (начиная с C ++ 11)
alignof запросы выравнивания требований типа (начиная с C ++ 11)

Логические операторы - основы программирования

Кеннет Лерой Басби и Дэйв Брауншвейг

Обзор

Логический оператор - это символ или слово, используемое для соединения двух или более выражений, так что значение полученного составного выражения зависит только от значения исходных выражений и от значения оператора.Общие логические операторы включают AND, OR и NOT.

Обсуждение

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

Логические операторы часто используются для создания тестового выражения, контролирующего выполнение программы. Этот тип выражения также известен как логическое выражение, поскольку при вычислении они создают логический ответ или значение.Есть три общих логических оператора, которые дают логическое значение, манипулируя другим логическим операндом (ами). Символы и / или названия операторов различаются в зависимости от языка программирования:

Язык И ИЛИ НЕ
C ++ && || !
С № && || !
Java && || !
JavaScript && || !
Python и или не
Swift && || !

Вертикальные черточки или символ трубопровода находятся на той же клавише, что и обратная косая черта \.Вы используете клавишу SHIFT, чтобы получить его. На большинстве клавиатур он находится чуть выше клавиши Enter. Это может быть сплошная вертикальная линия на некоторых клавиатурах и отображаться как сплошная вертикальная линия на некоторых печатных шрифтах.

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

6> 4 && 2 <= 14
6> 4 и 2 <= 14

Это выражение содержит два оператора отношения и один логический оператор. Используя приоритет правил операторов, два оператора «реляционного сравнения» будут выполняться перед оператором «логического и». Таким образом:

true && true
True and True

Окончательная оценка выражения: истина.

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

При формировании логических выражений программисты часто используют круглые скобки (даже если это технически не требуется), чтобы сделать логику выражения очень понятной. Рассмотрим переписанное выше сложное логическое выражение:

(6> 4) && (2 <= 14)
(6> 4) и (2 <= 14)

Большинство языков программирования распознают любое ненулевое значение как истинное.Это делает следующее выражение допустимым:

6> 4 && 8
6> 4 и 8

Но помните порядок действий. По-английски это шесть больше четырех, а восемь - не ноль. Таким образом,

true && true
True and True

Для сравнения 6 с 4 и 8 вместо этого будет записано как:

6> 4 && 6> 8
6> 4 и 6> 8

Это будет ложно как:

верно && ложно
верно и неверно

Таблицы истинности

Обычный способ показать логические отношения - это таблицы истинности.

Логический и (&&)
х y x и y
ложный ложь ложь
ложный правда ложь
правда ложь ложь
правда правда правда

Логический или (||)
х y x или y
ложный ложь ложь
ложный правда правда
правда ложь правда
правда правда правда

Логическое НЕ (!)
х нет x
ложный правда
правда ложь

Примеры

Я называю этот пример того, почему я ненавижу «и» и люблю «или».

Каждый день, когда я приходил из школы с понедельника по четверг; Я спрашивал маму: «Можно мне выйти на улицу поиграть?» Она отвечала: «Если ваша комната чистая и у вас сделана домашняя работа, вы можете выйти на улицу и поиграть». Я научился ненавидеть слово «и». Мне удалось выполнить одно из заданий и у меня было время поиграть до обеда, но оба… ну, я ненавидел «и».

В пятницу моя мать приняла более расслабленную точку зрения, и когда меня спросили, могу ли я выйти на улицу и поиграть, она ответила: «Если ваша комната чистая или ваша домашняя работа сделана, вы можете выйти на улицу и поиграть.«Я научился быстро убирать свою комнату в пятницу днем. Что ж, разумеется, я любил «или».

В качестве следующего примера представьте, что подросток разговаривает со своей матерью. Во время разговора мама говорит: «Ведь папа у тебя разумный!» Подросток говорит: «Разумно. (короткая пауза) Нет. "

Может быть, профессора колледжей подумают, что все их студенты готовились к экзамену. Ха-ха! Нет. Что ж, надеюсь, вы уловили суть.

Примеры:

  • 25 <7 || 15> 36
  • 15> 36 || 3 <7
  • 14> 7 && 5 <= 5
  • 4> 3 && 17 <= 7
  • ! ложь
  • ! (13! = 7)
  • 9! = 7 &&! 0
  • 5> 1 && 7

Дополнительные примеры:

  • 25 <7 или 15> 36
  • 15> 36 или 3 <7
  • 14> 7 и 5 <= 5
  • 4> 3 и 17 <= 7
  • не Ложь
  • нет (13! = 7)
  • 9! = 7, а не 0
  • 5> 1 и 7

Ключевые термины

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

Список литературы

5.7 - Логические операторы | Изучите C ++

Хотя реляционные операторы (сравнения) могут использоваться для проверки того, является ли конкретное условие истинным или ложным, они могут проверять только одно условие за раз. Часто нам нужно знать, выполняются ли одновременно несколько условий. Например, чтобы проверить, выиграли ли мы в лотерею, мы должны сравнить, все ли выбранные нами числа совпадают с выигрышными числами.В лотерее с 6 числами это будет включать 6 сравнений, , все из которых должны быть верными. В других случаях нам нужно знать, выполняется ли какое-либо из нескольких условий. Например, мы можем решить пропустить работу сегодня, если мы заболели, или если мы слишком устали, или если мы выиграли в лотерею в нашем предыдущем примере. Это будет включать проверку того, является ли каким-либо из 3 сравнений правдой.

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

C ++ имеет 3 логических оператора:

Оператор Символ Форма Эксплуатация
Логическое НЕ ! ! Х истина, если x ложь, или ложь, если x истинна
Логический И && х && у истина, если и x, и y истинны, иначе ложь
Логическое ИЛИ || x || y истина, если x или y истинны, иначе ложь

Логическое НЕ

Вы уже встречались с унарным оператором логического НЕ в уроке 4.9 - Логические значения. Мы можем суммировать эффекты логического НЕ так:

Логическое НЕ (оператор!)
Операнд Результат
правда ложь
ложный правда

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

Логическое НЕ часто используется в условных выражениях:

bool tooLarge {x> 100}; // tooLarge истинно, если x> 100

if (! tooLarge)

// делаем что-нибудь с x

else

// выводим ошибку

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

#include

int main ()

{

int x {5};

int y {7};

if (! X> y)

std :: cout << x << "не больше, чем" << y << '\ n';

else

std :: cout << x << "больше, чем" << y << '\ n';

возврат 0;

}

Эта программа напечатает:

 5 больше 7
 

Но x не больше y , так как же это возможно? Ответ заключается в том, что поскольку оператор логическое НЕ имеет более высокий приоритет, чем оператор «больше чем», выражение ! x> y фактически оценивается как (! x)> y .Поскольку x равно 5,! X оценивается как 0 , а 0> y ложно, поэтому выполняется оператор else !

Правильный способ написать приведенный выше фрагмент:

#include

int main ()

{

int x {5};

int y {7};

if (! (X> y))

std :: cout << x << "не больше, чем" << y << '\ n';

else

std :: cout << x << "больше, чем" << y << '\ n';

возврат 0;

}

Таким образом, сначала будет вычислено x> y , а затем логическое НЕ изменит логический результат.

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

Простое использование логического НЕ , например, if (! Value) , скобки не нужны, потому что приоритет не играет роли.

Логическое ИЛИ

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

Логическое ИЛИ (оператор ||)
Левый операнд Правый операнд Результат
ложный ложь ложь
ложный правда правда
правда ложь правда
правда правда правда

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

#include

int main ()

{

std :: cout << "Введите число:";

int value {};

std :: cin >> value;

if (value == 0 || value == 1)

std :: cout << "Вы выбрали 0 или 1 \ n";

else

std :: cout << "Вы не выбрали 0 или 1 \ n";

возврат 0;

}

В этом случае мы используем логический оператор ИЛИ, чтобы проверить, истинно ли левое условие (значение == 0) или правое условие (значение == 1).Если один из них (или оба) истинны, оператор логического ИЛИ принимает значение «истина», что означает выполнение оператора if . Если ни один из них не является истинным, результат логического оператора OR принимает значение false, что означает выполнение оператора else .

Вы можете связать вместе несколько операторов логического ИЛИ :

if (value == 0 || value == 1 || value == 2 || value == 3)

std :: cout << "Вы выбрали 0, 1, 2 или 3 \ n";

Новые программисты иногда путают оператор логического ИЛИ (||) с оператором побитового ИЛИ (|) (будет рассмотрено позже).Несмотря на то, что в названии обоих есть ИЛИ , они выполняют разные функции. Их смешение, вероятно, приведет к неверным результатам.

логическое И

Логический оператор AND используется для проверки истинности обоих операндов. Если оба операнда верны, логическое И вернет истину. В противном случае возвращается false.

Логическое И (оператор &&)
Левый операнд Правый операнд Результат
ложный ложь ложь
ложный правда ложь
правда ложь ложь
правда правда правда

Например, нам может потребоваться узнать, находится ли значение переменной x между 10 и 20 .На самом деле это два условия: нам нужно знать, больше ли x , чем 10 , а также, действительно ли x меньше 20 .

#include

int main ()

{

std :: cout << "Введите число:";

int value {};

std :: cin >> value;

if (value> 10 && value <20)

std :: cout << "Ваше значение от 10 до 20 \ n";

else

std :: cout << "Ваше значение не находится между 10 и 20 \ n";

возврат 0;

}

В этом случае мы используем логический оператор AND , чтобы проверить, истинны ли левое условие (значение> 10) И правое условие (значение <20).Если оба значения истинны, логический оператор AND принимает значение true, а оператор if выполняется. Если ни один из них не является истинным или только одно из них истинно, логический оператор AND принимает значение false, и выполняется оператор else .

Как и в случае с логическим ИЛИ , вы можете связать вместе несколько операторов логических И :

if (value> 10 && value <20 && value! = 16)

// делаем что-то

else

// делаем что-то еще

Если все эти условия верны, оператор if будет выполнен.Если какое-либо из этих условий неверно, будет выполнен оператор else .

Оценка короткого замыкания

Чтобы логическое И возвратило истину, оба операнда должны иметь значение истина. Если первый операнд оценивается как ложь, логическое И знает, что он должен вернуть ложь, независимо от того, оценивается ли второй операнд как истинное или ложное. В этом случае логический оператор AND сразу же вернет false, даже не оценив второй операнд! Это известно как оценка короткого замыкания и выполняется в основном в целях оптимизации.

Аналогично, если первый операнд для логического ИЛИ истинен, тогда все условие ИЛИ должно оцениваться как истинное, а второй операнд не оценивается.

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

if (x == 1 && ++ y == 2)

// что-то сделать

, если x не равно 1 , все условие должно быть ложным, поэтому ++ y никогда не вычисляется! Таким образом, y будет увеличиваться только в том случае, если x оценивается как 1, что, вероятно, не то, что планировал программист!

Оценка короткого замыкания может привести к тому, что Логическое ИЛИ и Логическое И не оценят один операнд.Избегайте использования выражений с побочными эффектами вместе с этими операторами.

Как и в случае с логическим и побитовым ИЛИ, новые программисты иногда путают логический оператор И (&&) с оператором побитового И (&).

Смешивание И и И

Смешивание операторов логического И и логического ИЛИ в одном выражении часто невозможно избежать, но это область, полная потенциальных опасностей.

Многие программисты предполагают, что логическое И и логическое ИЛИ имеют одинаковый приоритет (или забывают, что это не так), точно так же, как сложение / вычитание и умножение / деление.Однако логическое И имеет более высокий приоритет, чем логическое ИЛИ , поэтому операторы логического И будут оцениваться раньше логических операторов ИЛИ (если они не заключены в скобки).

Новые программисты часто пишут такие выражения, как value1 || значение2 && значение3 . Поскольку логическое И имеет более высокий приоритет, это оценивается как значение1 || (значение2 && значение3) , а не (значение1 || значение2) && значение3 .Надеюсь, это то, чего хотел программист! Если программист предполагал оценку слева направо (как это происходит со сложением / вычитанием или умножением / делением), программист получит результат, которого он или она не ожидал!

При смешивании логического И и логического ИЛИ в одном выражении рекомендуется явно заключить в скобки каждый оператор и его операнды. Это помогает предотвратить ошибки приоритета, упрощает чтение кода и четко определяет, как вы планировали оценивать выражение.Например, вместо того, чтобы писать значение1 && значение2 || значение3 && значение4 , лучше написать (значение1 && значение2) || (значение3 && значение4) .

При смешивании логического И и логического ИЛИ в одном выражении явно заключите каждую операцию в скобки, чтобы гарантировать, что они оценивают то, что вы намереваетесь.

Закон Де Моргана

Многие программисты также ошибаются, полагая, что ! (X && y) - это то же самое, что ! X &&! Y .К сожалению, вы не можете «распределить» логическое НЕ таким образом.

Закон Де Моргана говорит нам, как логическое НЕ должно распределяться в этих случаях:

! (X && y) эквивалентно ! X || ! y
! (x || y) эквивалентно ! x &&! y

Другими словами, когда вы распределяете логическое НЕ , вам также необходимо перевернуть логическое И на логическое ИЛИ , и наоборот!

Иногда это может быть полезно при попытке упростить чтение сложных выражений.

Где логический оператор исключающего ИЛИ (XOR)?

Логический XOR - это логический оператор, представленный на некоторых языках, который используется для проверки истинности нечетного числа условий.

Логический XOR
Левый операнд Правый операнд Результат
ложный ложь ложь
ложный правда правда
правда ложь правда
правда правда ложь

C ++ не поддерживает логический оператор XOR .В отличие от логического ИЛИ или логического И , логическое ИЛИ не может быть оценено коротким замыканием. Из-за этого создание логического оператора XOR из логических операторов OR и логических операторов AND является сложной задачей. Однако вы можете легко имитировать логический XOR , используя оператор неравенства (! =):

if (a! = B) ... // a XOR b, если a и b являются логическими

Это может быть расширено до нескольких операндов следующим образом:

если (a! = B! = C! = D)... // a XOR b XOR c XOR d, предполагая, что a, b, c и d являются логическими

Обратите внимание, что приведенные выше шаблоны XOR работают только в том случае, если операнды являются логическими (не целыми). Если вам нужна форма логического XOR , которая работает с не-логическими операндами, вы можете static_cast их в bool:

if (static_cast (a)! = Static_cast (b)! = Static_cast (c)! = Static_cast (d))... // a XOR b XOR c XOR d, для любого типа, который может быть преобразован в bool

Время викторины

Оцените следующие выражения.

Примечание: в следующих ответах мы «объясняем нашу работу», показывая вам шаги, предпринятые для получения окончательного ответа. Шаги разделены символом => . Выражения, которые были проигнорированы из-за правил короткого замыкания, помещены в квадратные скобки. Например,
(1 <2 || 3! = 3) =>
(true || [3! = 3]) =>
(true) =>
true
означает, что мы оценили (1 <2 || 3! = 3), чтобы прийти к (true || [3! = 3]), и вычислил это, чтобы прийти к «true».3! = 3 никогда не выполнялся из-за короткого замыкания.

a) (верно && верно) || ложь

Показать решение

(true && true) || false =>
true || [false] =>
верно

b) (false && true) || правда

Показать решение

(false && [true]) || true =>
ложь || true =>
истинный

Короткое замыкание происходит только в том случае, если первый операнд || - это , правда .

c) (false && true) || ложь || правда

Показать решение

(false && [true]) || ложь || истина =>
ложь || ложь || истина =>
ложь || истина =>
истина

г) (5> 6 || 4> 3) && (7> 8)

Показать решение

(5> 6 || 4> 3) && (7> 8) =>
(ложь || истина) && ложь =>
истина && ложь =>
ложь

e)! (7> 6 || 3> 4)

Показать решение

! (7> 6 || 3> 4) =>
! (True || [3> 4]) =>
! True =>
false


Язык C - Логические операторы

Пример

логическое И

Выполняет логическое логическое И для двух операндов, возвращая 1, если оба операнда не равны нулю.Логический оператор И имеет тип int .

  0 && 0 / * Возвращает 0. * /
0 && 1 / * Возвращает 0. * /
2 && 0 / * Возвращает 0. * /
2 && 3 / * Возвращает 1. * /
  

Логическое ИЛИ

Выполняет логическое ИЛИ двух операндов, возвращая 1, если какой-либо из операндов не равен нулю. Логический оператор ИЛИ имеет тип int .

  0 || 0 / * Возвращает 0. * /
0 || 1 / * Возвращает 1.* /
2 || 0 / * Возвращает 1. * /
2 || 3 / * Возвращает 1. * /
  

Логическое НЕ

Выполняет логическое отрицание. Логический оператор НЕ имеет тип int . Оператор NOT проверяет, равен ли хотя бы один бит 1, если да, то возвращает 0. В противном случае возвращает 1;

 ! 1 / * Возвращает 0. * /
! 5 / * Возвращает 0. * /
! 0 / * Возвращает 1. * /
  

Оценка короткого замыкания

Есть несколько важных свойств, общих для && и || :

  • левый операнд (LHS) полностью вычисляется до того, как правый операнд (RHS) вообще оценивается,
  • существует точка последовательности между вычислением левого операнда и правого операнда,
  • и, что наиболее важно, правый операнд вообще не оценивается, если результат левого операнда определяет общий результат.

Это означает, что:

  • , если LHS принимает значение «истина» (ненулевое значение), RHS составляет || не будет оцениваться (потому что результат «истина ИЛИ что-либо» равен «истина»),
  • , если LHS оценивается как «ложь» (ноль), RHS && не будет оцениваться (потому что результат «ложь И что-нибудь» - «ложь»).

Это важно, поскольку позволяет писать такой код, как:

  const char * name_for_value (целое значение)
{
    static const char * names [] = {"ноль", "один", "два", "три",};
    перечисление {NUM_NAMES = sizeof (имена) / sizeof (имена [0])};
    return (значение> = 0 && значение <ЧИСЛО)? имена [значение]: "бесконечность";
}
  

Если в функцию передается отрицательное значение, значение > = 0 член оценивается как ложное, а значение <ЧИСЛО члена не оценивается.




логических операторов на языке программирования C

Логические операторы в C - это некоторые из операторов, которые используются для объединения двух или более условий. И выполните логические операции с помощью && (логическое И), || (Логическое ИЛИ) и! (Логическое НЕ)

Операторы отношения в C используются для сравнения двух переменных, что, если мы хотим сравнить более одного условия? Очень простые логические операторы Си помогут вам.

В таблице ниже показан весь список логических операторов в C с примерами.

, если оба условия истинны, если оба условия соответствуют <= 35)
ОПЕРАТОРЫ ИМЯ ОПИСАНИЕ ПРИМЕР
&& логическое И Если возраст
|| логическое ИЛИ Возвращает истину, если хотя бы одно из условий истинно. Если (возраст> 35 || возраст <60)
! логическое НЕ Если условие истинно, оператор логического НЕ делает его ложным Если age = 18, то! (Age = 18) возвращает false.

Давайте посмотрим на таблицы истинности логических операторов в программировании на C для лучшего понимания операторов.

&& ЛОГИЧЕСКИЙ И оператор

65 Ложь Ложь Ложь
Условие 1 Условие 2 Условие 1 && Условие 2
Истина Истина Истина
Ложь Истина Ложь
Ложь Ложь Ложь

|| (Оператор ЛОГИЧЕСКОГО ИЛИ)

Условие 1 Условие 2 Условие 1 || Условие 2
Истина Истина Истина
Истина Ложь Истина
Ложь Истина Истина
Ложь Ложь Ложь

Логические операторы в C - Codeforwin

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

Например, предположим, что вам нужно проверить диапазон числа. Вам нужно проверить, находится ли число n между 1-100 или нет. Для этого вы должны проверить два условия: сначала проверьте, не превышает ли n> 1 , наконец, проверьте, не превышает ли n <100 .

Мы используем логических операторов для объединения двух или более выражений отношения в одно выражение отношения. Логические операторы оценивают логическое значение (целое число в случае C) в зависимости от используемого оператора.

C поддерживает три логических оператора.

Оператор Описание
&& Логическое И
|| Логическое ИЛИ
! Логическое НЕ

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

&&

Логическое AND && является бинарным оператором. Он объединяет два реляционных выражения и оценивает 1 (истина), если оба выражения истинны, иначе 0 (ложь).

Мы используем логический оператор И в ситуациях, когда для принятия решения должны выполняться два или более условий. Например, «Он имеет право на работу, если он знает язык C и у него опыт работы более 2 лет» . Мы можем программно записать приведенный выше оператор как -

  if (skill == ‘C’ && experience> = 2)
{
    // Он имеет право на работу
}  

Примечание: Не путайте логическое И и с побитовым И и .

Логическое ИЛИ

|| оператор

Логическое ИЛИ || также является бинарным оператором. Оператор логического ИЛИ используется в ситуациях, когда необходимо принять решение при выполнении любого из двух условий.

Он принимает значение 1 (истина), если любое из двух выражений истинно, в противном случае принимает значение 0 (ложь).

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *