True false python: True, False в Python | Примеры кода с булевым типом данных

Содержание

True, False в Python | Примеры кода с булевым типом данных

Следующая статья будет полезна тем, кто только начал знакомиться с особенностями программирования на Python. Здесь будет рассмотрен один из ключевых типов данных Python — булев тип. Булев, или логический тип, является важным концептом программирования, который принимает истинное (true) или ложное (false) значение.

Булев тип данный в Python 3

Булев концепт присутствует в каждом языке программирования. Булев тип данных реализует идею истины (true) или лжи (false). Во время составления программы часто всплывают моменты, когда в зависимости от ситуации требуется выполнить различные участки кода. Для этого нужен булев тип.

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

Одно из самых больших сообществ по Python в социальной сети ВК.

Видео уроки и книги для вас!

Объявить булево значение в коде можно при помощи ключевых слов True или False (верхний регистр важен). Следующий код создает два булевых значения и присваивает их переменным.

mullet_looks_good = False python_is_fun = True

mullet_looks_good = False

python_is_fun = True

Чаще всего булево значение возвращается как результат сравнения. В следующем примере кода булево значение False будет сохранено в переменной have_same_name после использования оператора сравнения, это два символа равенства ==.

my_name = «Wammu» your_name = «Kars» have_same_name = my_name == your_name

my_name = «Wammu»

your_name = «Kars»

 

have_same_name = my_name == your_name

Булева логика в Python

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

my_age = 10 if my_age >= 100: print(«Сто лет! Впечатляет.») elif my_age <= 3: print(«Оуу. Совсем малыш.») else: print(«Эх, какой хороший возраст.»)

my_age = 10

 

if my_age >= 100:

  print(«Сто лет! Впечатляет.»)

elif my_age <= 3:

  print(«Оуу. Совсем малыш.»)

else:

  print(«Эх, какой хороший возраст.»)

Вы также можете проверить истинности при помощи использования ключевого слова not.

favorite_team = «Викинги» if not favorite_team == «Викинги»: print(«Ох — не повезло.») else: print(«Вперед, Викинги!»)

favorite_team = «Викинги»

 

if not favorite_team == «Викинги»:

  print(«Ох — не повезло.»)

else:

  print(«Вперед, Викинги!»)

Более сложная булева логика.

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

and и or. Ключевое слово and сравнивает булевы значения и возвращает True, если оба значения верны. Ключевое слово or сравнивает два значения и возвращает True, если истинно хотя бы одно утверждение.

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

favs = [«Донателло», «Микеланджело»] if «Микеланджело» in favs and «Донателло» in favs: print(«Они тоже мои любимые черепашки-ниндзя!») elif «Микеланджело» in favs or «Донателло» in favs: print(«Неплохо, один из них мне тоже нравится.») else: print(«Ха, я бы не стал их выбирать.»)

favs = [«Донателло», «Микеланджело»]

 

if «Микеланджело» in favs and «Донателло» in favs:

  print(«Они тоже мои любимые черепашки-ниндзя!»)

elif «Микеланджело» in favs or «Донателло» in favs:

  print(«Неплохо, один из них мне тоже нравится.»)

else:

  print(«Ха, я бы не стал их выбирать.»)

Заключение

Булев тип важен для любого языка программирования. При помощи булевой логики код может реагировать на различные данные внутри программы и выполнять выбранные инструкции при разных обстоятельствах. Надеюсь, вы немного узнали о том, как работать с логическими значениями в Python 3! Следите за обновлениями, чтобы узнать больше об особенностях работы в Python 3.

Python Tips, Tricks, and Hacks (часть 3) / Хабр

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

4. Выбор значений

4.1. Правильный путь

Начиная с версии 2.5, Python поддерживает синтаксис «value_if_true if test else value_if_false». Таким образом, вы можете выбрать одно из двух значений, не прибегая к странному синтаксису и подробным пояснениям:
test = True
# test = False
result = 'Test is True' if test else 'Test is False'
# result = 'Test is True'

Увы, это всё еще немного некрасиво. Вы также можете использовать несколько таких конструкций в одной строке:
test1 = False
test2 = True
result = 'Test1 is True' if test1 else 'Test1 is False, test2 is True' if test2 else 'Test1 and Test2 are both False'

Сначала выполняется первый if/else, а если test1 = false, выполняется второй if/else. Вы можете делать и более сложные вещи, особенно если воспользуетесь скобками.

Этот способ весьма новый, и я испытываю к нему смешанные чувства. Это правильная, понятная конструкция, она мне нравится… но она всё еще уродлива, особенно при использовании нескольких вложенных конструкций. Конечно, синтаксис всех уловок для выбора значений некрасив. У меня слабость к описанному ниже способу с and/or, сейчас я нахожу его интуитивным, сейчас я понимаю, как он работает. К тому же он ничуть не менее эффективен, чем «правильный» способ.

Хотя инлайновый if/else — новый, более правильный способ, вам всё же стоит ознакомиться со следующими пунктами. Даже если вы планируете использовать Python 2.5, вы встретите эти способы в старом коде. Разумеется, если вам нужна обратная совместимость, будет действительно лучше просмотреть их.

4.2. Уловка and/or

«and» и «or» в Python — сложные создания. Применение and к нескольким выражениям не просто возвращает True или False. Оно возвращает первое false-выражение, либо последнее из выражений, если все они true. Результат ожидаем: если все выражения верны, возвращается последнее, являющееся true; если одно из них false, оно и возвращается и преобразуется к False при проверке логического значения.

Аналогично, операция or возвращает первое true-значение, либо последнее, если ни одно из них не true.

Это вам не поможет, если вы просто проверяете логическое значение выражения. Но можно использовать and и or в других целях. Мой любимый способ — выбор значения в стиле, аналогичном тернарному оператору языка C «test? value_if_true: value_if_false»:

test = True
# test = False
result = test and 'Test is True' or 'Test is False'
# теперь result = 'Test is True'

Как это работает? Если test=true, оператор and пропускает его и возвращает второе (последнее) из данных ему значений: ‘Test is True’ 
or
 ‘Test is False’. Далее, or вернет первое true выражение, т. е. ‘Test is True’.

Если test=false, and вернет test, останется test or ‘Test is False’. Т. к. test=false, or его пропустит и вернет второе выражение, ‘Test is False’.

Внимание, будьте осторожны со средним значением («if_true»). Если оно окажется false, выражение с or будет всегда пропускать его и возвращать последнее значение («if_false»), независимо от значения test.

После использования этого метода правильный способ (п. 4.1) кажется мне менее интуитивным. Если вам не нужна обратная совместимость, попробуйте оба способа и посмотрите, какой вам больше нравится. Если не можете определиться, используйте правильный.

Конечно, если вам нужна совместимость с предыдущими версиями Python, «правильный» способ не будет работать. В этом случае and/or — лучший выбор в большинстве ситуаций.

4.3. True/False в качестве индексов

Другой способ выбора из двух значений — использование True и False как индексов списка с учетом того факта, что False == 0 и True == 1:
test = True
# test = False
result = ['Test is False','Test is True'][test]
# теперь result = 'Test is True'

Этот способ более честный, и value_if_true не обязано быть true. Однако у него есть существенный недостаток: оба элемента списка вычисляются перед проверкой. Для строк и других простых элементов это не проблема. Но если каждый из них требует больших вычислений или операций ввода-вывода, вычисление обоих выражений недопустимо. Поэтому я предпочитаю обычную конструкцию или and/or.

Также заметьте, что этот способ работает только тогда, когда вы уверены, что test — булево значение, а не какой-то объект. Иначе придется писать bool(test) вместо test, чтобы он работал правильно.

5. Функции

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

Начнем этот раздел с предупреждения. Эта проблема много раз смущала многих программистов, включая меня, даже после того, как я разобрался в проблеме. Легко ошибиться, используя значения по умолчанию:
def function(item, stuff = []):
    stuff.append(item)
    print stuff

function(1)
# выводит '[1]'

function(2)
# выводит '[1,2]' !!!

Значения по умолчанию для аргументов вычисляются только один раз, в момент определения функции. Python просто присваивает это значение нужной переменной при каждом вызове функции. При этом он не проверяет, изменилось ли это значение. Поэтому, если вы изменили его, изменение будет в силе при следующих вызовах функции. В предыдущем примере, когда мы добавили значение к списку stuff, мы изменили его значение по умолчанию навсегда. Когда мы вызываем функцию снова, ожидая дефолтное значение, мы получаем измененное.

Решение проблемы: не используйте изменяемые объекты в качестве значений по умолчанию. Вы можете оставить всё как есть, если не изменяете их, но это плохая идея. Вот как следовало написать предыдущий пример:

def function(item, stuff = None):
    if stuff is None:
        stuff = []
    stuff.append(item)
    print stuff

function(1)
# выводит '[1]'

function(2)
# выводит '[2]', как и ожидалось

None неизменяем (в любом случае, мы не пытаемся его изменить), так что мы обезопасили себя от внезапного изменения дефолтного значения.

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

5.1.1. Заставляем дефолтные значения вычисляться каждый раз

Если вы не хотите вносить в код функции лишний беспорядок, можно заставить интерпретатор заново вычислять значения аргументов перед каждым вызовом. Следующий декоратор делает это:
from copy import deepcopy

def resetDefaults(f):
    defaults = f.func_defaults
    def resetter(*args, **kwds):
        f.func_defaults = deepcopy(defaults)
        return f(*args, **kwds)
    resetter.__name__ = f.__name__
    return resetter

Просто примените этот декоратор к функции, чтобы получить ожидаемые результаты:
@resetDefaults # так мы применяем декоратор
def function(item, stuff = []):
    stuff.append(item)
    print stuff

function(1)
# выводит '[1]'

function(2)
# выводит '[2]', как и ожидалось

5.2. Переменное число аргументов

Python позволяет использовать произвольное число аргументов в функциях. Сначала определяются обязательные аргументы (если они есть), затем нужно указать переменную со звездочкой. Python присвоит ей значение списка остальных (не именованных) аргументов:
def do_something(a, b, c, *args):
    print a, b, c, args

do_something(1,2,3,4,5,6,7,8,9)
# выводит '1, 2, 3, (4, 5, 6, 7, 8, 9)'

Зачем это нужно? Например, функция должна принимать несколько элементов и делать с ними одно и то же (например, складывать). Можно заставить пользователя передавать функции список: sum_all([1,2,3]). А можно позволить передавать произвольное число аргументов, тогда получится более чистый код: sum_all(1,2,3).

Функция также может иметь переменное число именованных аргументов. После определения всех остальных аргументов укажите переменную с «**» в начале. Python присвоит этой переменной словарь полученных именованных аргументов, кроме обязательных:

def do_something_else(a, b, c, *args, **kwargs):
    print a, b, c, args, kwargs

do_something_else(1,2,3,4,5,6,7,8,9, timeout=1.5)
# выводит '1, 2, 3, (4, 5, 6, 7, 8, 9), {"timeout": 1.5}'

Зачем так делать? Я считаю, самая распространенная причина — функция является оберткой другой функции (или функций), и неиспользуемые именованные аргументы могут быть переданы другой функции (см. п. 5.3).
5.2.1. Уточнение
Использование именованных аргументов и произвольного числа обычных аргументов после них, по-видимому, невозможно, потому что именованные аргументы должны быть определены до «*»-параметра. Например, представим функцию:
def do_something(a, b, c, actually_print = True, *args):
    if actually_print:
        print a, b, c, args

У нас проблема: не получится передать actually_print как именованный аргумент, если при этом нужно передать несколько неименованных. Оба следующих варианта вызовут ошибку:
do_something(1, 2, 3, 4, 5, actually_print = True)
# actually_print сначала приравнивается к 4 (понятно, почему?), а затем 
# переопределяется, вызывая TypeError ('got multiple values for keyword argument')

do_something(1, 2, 3, actually_print = True, 4, 5, 6)
# Именованные аргументы не могут предшествовать обычным. Происходит SyntaxError.

Единственный способ задать actually_print в этой ситуации — передать его как обычный аргумент:

do_something(1, 2, 3, True, 4, 5, 6)
# результат: '1, 2, 3, (4, 5, 6)'

Единственный способ задать actually_print в этой ситуации — передать его как обычный аргумент:
do_something(1, 2, 3, True, 4, 5, 6)
# результат: '1, 2, 3, (4, 5, 6)'

5.3. Передача списка или словаря в качестве нескольких аргументов

Поскольку можно получить переданные аргументы в виде списка или словаря, нет ничего удивительного в том, что передавать аргументы функции тоже можно из списка или словаря. Синтаксис совершенно такой же, как в предыдущем пункте, нужно поставить перед списком звездочку:
args = [5,2]
pow(*args)
# возвращает pow(5,2), т. е. 25

А для словаря (что используется чаще) нужно поставить две звездочки:
def do_something(actually_do_something=True, print_a_bunch_of_numbers=False):
    if actually_do_something:
        print 'Something has been done'
        #
        if print_a_bunch_of_numbers:
            print range(10)

kwargs = {'actually_do_something': True, 'print_a_bunch_of_numbers': True}
do_something(**kwargs)

# печатает 'Something has been done', затем '[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]'

Историческая справка: в Python до версии 2.3 для этих целей использовалась встроенная функция apply (function, arg_list, keyword_arg_dict)’.

Статья целиком в PDF

True и False в Python 3 имеют разные размеры. Python. Евгений Зятев

Python 2.7:

>>> False.__sizeof__()
24
>>> True.__sizeof__()
24

Python 3.x:

>>> False.__sizeof__()
24
>>> True.__sizeof__()
28

Почему в Python 3 размер True больше размера False?

Так происходит, поскольку тип bool является подклассом int и в Python 2, и в Python 3.

>>> issubclass(bool, int)
True

Но реализация int изменилась.

В Python 2 int имел размер 32 или 64 бита, в зависимости от системы, а long — произвольную длину.

В Python 3 int произвольной длины: long из Python 2 был переименован в int, а исходный int полностью удален.

В Python 2 можно наблюдать такое же поведение для long-объектов 1L и 0L:

>>> import sys
>>> sys.getsizeof(1L)
28
>>> sys.getsizeof(0L)
24

long (int в Python 3) — объект переменной длины, как и кортеж, — выделяется достаточное количество памяти для хранения всех двоичных цифр, необходимых для его представления. Длина переменной части хранится в заголовке объекта. Нулю не нужны двоичных цифры (его переменная длина равна 0), но в случае с единицей происходит переполнение, и требуются дополнительные цифры.

То есть 0 представляется как двоичная строка нулевой длины:

<>

А единица представляется как 30-битная двоичная строка:

<000000000000000000000000000001>

Python в конфигурации по умолчанию использует 30 бит для uint32_t; поэтому 2**30-1 по-прежнему укладывается в 28 байтов на x86-64, а для 2**30 потребуется уже 32.

2**30-1 будет представляться так:

<111111111111111111111111111111>

Т. е. значения всех 30 битов будут установлены в 1; числу 2**30 потребуется больше, у него будет внутреннее представление:

<000000000000000000000000000001000000000000000000000000000000>

Поскольку True использует 28 байт, а не 24, можно не беспокоиться. True — синглтон и поэтому всего 4 байта в общей сложности уйдет на любую программу Python, а не по 4 на каждый True.


Спасибо Antti Haapala.

Как преобразовать false в 0 и true в 1 в python

вот еще одно решение вашей проблемы:

def to_bool(s):
    return 1 - sum(map(ord, s)) % 2
    # return 1 - sum(s.encode('ascii')) % 2  # alternative for python3

это работает, потому что сумма кодов ASCII 'true' is 448, который является четным, в то время как сумма кодов ASCII 'false' is 523 что странно.


самое смешное в этом решении заключается в том, что его результат довольно случайный, если вход не одним из 'true' или 'false'. Половину времени он будет возвращаться 0, а другая половина 1. Вариант используя encode вызовет ошибку кодирования, если вход не является ASCII (таким образом, увеличивая неопределенность поведения).


серьезно, я считаю наиболее читаемым,и быстрее, решение заключается в использовании if:

def to_bool(s):
    return 1 if s == 'true' else 0

см. некоторые microbenchmarks:

In [14]: def most_readable(s):
    ...:     return 1 if s == 'true' else 0

In [15]: def int_cast(s):
    ...:     return int(s == 'true')

In [16]: def str2bool(s):
    ...:     try:
    ...:         return ['false', 'true'].index(s)
    ...:     except (ValueError, AttributeError):
    ...:         raise ValueError()

In [17]: def str2bool2(s):
    ...:     try:
    ...:         return ('false', 'true').index(s)
    ...:     except (ValueError, AttributeError):
    ...:         raise ValueError()

In [18]: def to_bool(s):
    ...:     return 1 - sum(s.encode('ascii')) % 2

In [19]: %timeit most_readable('true')
10000000 loops, best of 3: 112 ns per loop

In [20]: %timeit most_readable('false')
10000000 loops, best of 3: 109 ns per loop

In [21]: %timeit int_cast('true')
1000000 loops, best of 3: 259 ns per loop

In [22]: %timeit int_cast('false')
1000000 loops, best of 3: 262 ns per loop

In [23]: %timeit str2bool('true')
1000000 loops, best of 3: 343 ns per loop

In [24]: %timeit str2bool('false')
1000000 loops, best of 3: 325 ns per loop

In [25]: %timeit str2bool2('true')
1000000 loops, best of 3: 295 ns per loop

In [26]: %timeit str2bool2('false')
1000000 loops, best of 3: 277 ns per loop

In [27]: %timeit to_bool('true')
1000000 loops, best of 3: 607 ns per loop

In [28]: %timeit to_bool('false')
1000000 loops, best of 3: 612 ns per loop

обратите внимание, как if решение по крайней мере 2.5 x времени быстрее чем все другой решения. Это не смысла выставлять как требование избегать использования ifs за исключением того, что это какая-то домашняя работа (в этом случае вы не должны были спрашивать об этом в первую очередь).

Логические значения Python


Логические значения представляют одно из двух значений: Верно или Неверно .


Логические значения

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

Вы можете оценить любое выражение в Python и получить одно из двух ответы, Верно или Неверно .

Когда вы сравниваете два значения, выражение вычисляется и Python возвращает логический ответ:

Когда вы запускаете условие в операторе if, Python возвращает Верно или Ложно :

Пример

Распечатать сообщение в зависимости от того, является ли условие Истинно или Ложь :

a = 200
b = 33

, если b> a:
print («b больше, чем a»)
else:
print («b не больше a»)

Попробуй сам »

Оценить значения и переменные

Функция bool () позволяет оценивать любое значение, и дать вам Верно или Ложно взамен

Пример

Вычислить строку и число:

print (bool («Привет»))
print (bool (15))

Попробуй сам »

Пример

Оцените две переменные:

x = «Hello»
y = 15

print (bool (x))
print (bool (y))

Попробуй сам »

Большинство значений верны

Почти любое значение оценивается как Истинно , если оно имеет какое-то содержание.

Любая строка — Истинно , кроме пустых строк.

Любое число Истинно , кроме 0 .

Любой список, кортеж, набор и словарь — Истинно , кроме пустые.

Пример

Следующее вернет True:

bool («abc»)
bool (123)
bool ([«яблоко», «вишня», «банан»])

Попробуй сам »

Некоторые значения неверны

На самом деле не так много значений, которые оцениваются как Ложь , кроме пустых значений, таких как () , [] , {} , "" , номер 0 , а значение Нет .И, конечно же, значение False оценивается как Неверно .

Пример

Следующее вернет False:

bool (Ложь)
bool (Нет)
bool (0)
bool («»)
bool (())
bool ([])
bool ({})

Попробуй сам »

Еще одно значение или объект в этом случае оценивается как Ложь , и это если у вас есть объект, создается из класса с функцией __len__ , которая возвращает 0 или Ложь :

Пример

class myclass ():
def __len __ (self):
return 0

myobj = myclass ()
print (bool (myobj))

Попробуй сам »

Функции могут возвращать логическое значение

Вы можете создавать функции, возвращающие логическое значение:

Пример

Вывести ответ функции:

def myFunction ():
return True

print (myFunction ())

Попробуй сам »

Вы можете выполнить код на основе логического ответа функции:

Пример

Распечатайте «ДА!» если функция возвращает True, иначе выведите «NO!»:

def myFunction ():
return True

, если myFunction ():
print («ДА!»)
else:
print («НЕТ!»)

Попробуй сам »

Python также имеет множество встроенных функций, которые возвращают логическое значение, например isinstance () функция, с помощью которой можно определить, имеет ли объект определенный тип данных:

Пример

Проверить, является ли объект целым числом:

x = 200
печать (isinstance (x, int))

Попробуй сам »


.

boolean — True = присвоение False в Python 2.x

Переполнение стека
  1. Около
  2. Продукты
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
  3. Вакансии Программирование и связанные с ним технические возможности карьерного роста
  4. Талант Нанимайте технических специалистов и создавайте свой бренд работодателя
  5. Реклама Обратитесь к разработчикам и технологам со всего мира
  6. О компании
.

Операторы в Python

Прежде чем углубиться в программирование, давайте изучим некоторые основные, но очень важные вещи; ‘ Boolean ‘.

Так же, как целое число может принимать значения -1, 1, 0 и т. Д., А число с плавающей запятой может принимать 0,01, 1,2 и т. Д. Логическое значение — это то, что может быть либо true , либо false .

Тип печати
 (True)
тип печати (Ложь)
 
 print (тип (True))
print (type (False))
 

Выход

<класс 'bool'>
<класс 'bool'>

Тип ‘True’ и ‘False’ — это bool ( bool для Boolean ).Мы также можем присвоить любой переменной значение True или False . См. Пример, приведенный ниже.

 x = Истина
y = ложь
напечатать x
напечатать y
 
 x = Истина
y = ложь
печать (х)
печать (у)
 

Выход

Теперь давайте сделаем еще кое-что.

Мы уже сделали x = 10 и знаем, что это означает, что x равен 10. Давайте попробуем следующее:

‘==’ Оператор используется для сравнения двух значений в Python. Это эквивалентно вопросу, равно ли x 10? Сделаем это еще раз.

 х = 10
у = 10
напечатать x == y
 
 х = 10
у = 10
печать (x == y)
 

Выход

Здесь он проверяет, равны ли x и y . Поскольку и x , и y имеют одинаковые значения, поэтому x == y равно True

 name = "Сэм"
print name == "Сэм"
print name == "Aam"
 
 name = "Сэм"
print (name == "Сэм")
print (name == "Aam")
 

Выход

Здесь = присвоило значение «Sam» переменной name и == проверило, является ли значение переменной name «Sam» или нет.

AND и OR


Сначала см. Эту таблицу.

Опыт 1 Оператор Опыт2 логическое
Истинно и Истинно Истинно
Истинно и Ложь Ложь
Ложь и Ложь Ложь
Истинно или Истинно Истинно
Истинно или Ложь Истинно
Ложь или Ложь Ложь

Итак, если мы используем и с любыми двумя операндами, и если оба они равны True , то результатом будет True .В противном случае это False
И если мы используем или и если какой-либо из двух операндов равен True , то это будет True и будет False , если оба операнда False .

‘и’ могут пониматься как и (первый и второй оба)
‘или’ могут пониматься как либо (первое или второе любое). См. Следующую строку, чтобы понять это более четко.

‘and’ and ‘or’ программирования очень похожи на английские слова ‘and’ and ‘or’.

По-английски,
A и B — И A, и B.
A или B — Либо A, либо B.

В программировании также
A и B — И A, и B.
A или B — Либо A, либо B, либо оба.

Итак, если вы пишете A и B , тогда выражение будет true , если и A, и B истинны . Принимая во внимание, что если вы пишете A или B , тогда выражение истинно , если либо A, либо B, либо оба истинны .

Истина или Ложь → Поскольку используется ‘или’ , либо из двух истинно → Истина
Истинно и Ложно → Поскольку используются ‘и’ , оба неверны → Ложь

 х = 10
у = 20
напечатайте x == 10 и y == 20
напечатайте x == 3 или y == 20
 
 х = 10
у = 20
печать (x == 10 и y == 20)
печать (x == 3 или y == 20)
 

Выход

Здесь x равно 10, а y — 20.Итак, x == 10 — это True , а также y == 20 — это True . Итак, x == 10 и y == 20 также является True , поскольку оба операнда истинны (используются и ).

В следующей строке x == 3 False , но y == 20 True . Итак, x == 3 или y == 20 — это True , потому что по крайней мере один операнд — True (используется или ).

не


, а не → Вы можете понять «не», думая, что оно будет делать наоборот.
не неверно верно
не верно неверно

Да уж! Это просто. Посмотрим еще несколько примеров.

нет (Верно или Ложь) → Ложь.

Истина или ложь — это Истина , поскольку используется или и хотя бы один из операндов имеет значение Истина. Итак, not (True) is False.

 х = 10
у = 20
не печатать (x == 10 и y == 20)
не печатать (x == 3 или y == 20)
 
 х = 10
у = 20
печать (не (x == 10 и y == 20))
печать (не (x == 3 или y == 20))
 

Выход

Это тот же пример, что и предыдущий.Мы просто использовали здесь , а не , и видим, что ответы поменялись местами. Раньше это было True , но теперь это False .

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


Сначала посмотрите на следующую таблицу:

Оператор Описание Пример
! = Не равно (5! = 2) верно, (5! = 5) неверно
> Больше (5> 5) неверно
< Менее (5 <5) неверно
> = Больше или равно (2> = 2) истинно
<= Меньше или равно (5 <= 2) ложно

! = — это , отличный от оператора .Он дает True , если оба операнда не равны, иначе он дает False .

> — это больше или равно оператору . Он дает Истинно , если первый операнд больше второго.

> = — это больше или равно оператору . Он дает True , если первый операнд больше или равен второму операнду.

Аналогично, <и <= на меньше и меньше или равно операторов соответственно.

Вы узнаете больше об операторах в следующей главе.

Талант - это хорошо, практика - лучше, страсть - лучше.

- Фрэнк Ллойд Райт


.

python - True = False == True

Переполнение стека
  1. Около
  2. Продукты
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
  3. Вакансии Программирование и связанные с ним технические возможности карьерного роста
  4. Талант Нанимайте технических специалистов и создавайте свой бренд работодателя
  5. Реклама Обратитесь к разработчикам и технологам со всего мира
  6. О компании
.

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

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