Импликация питон как пишется

Additional details based on what I have found here and there as I was looking for an implication operator : you can use a clever hack to define your own operators. Here is a running example annotated with sources leading me to this result.

#!/usr/bin/python

# From http://code.activestate.com/recipes/384122/ (via http://stackoverflow.com/questions/932328/python-defining-my-own-operators)
class Infix:
    def __init__(self, function):
        self.function = function
    def __ror__(self, other):
        return Infix(lambda x, self=self, other=other: self.function(other, x))
    def __rlshift__(self, other):
        return Infix(lambda x, self=self, other=other: self.function(other, x))
    def __or__(self, other):
        return self.function(other)
    def __rshift__(self, other):
        return self.function(other)
    def __call__(self, value1, value2):
        return self.function(value1, value2)

from itertools import product

booleans = [False,True]

# http://stackoverflow.com/questions/16405892/is-there-an-implication-logical-operator-in-python
# http://jacob.jkrall.net/lost-operator/
operators=[
    (Infix(lambda p,q: False),                  "F"),
    (Infix(lambda p,q: True),                   "T"),
    (Infix(lambda p,q: p and q),                "&"),
    (Infix(lambda p,q: p or q)           ,      "V"),
    (Infix(lambda p,q: p != q)           ,      "^"),
    (Infix(lambda p,q: ((not p) or not q)),     "nad"),
    (Infix(lambda p,q: ((not p) and not q)),    "nor"),
    (Infix(lambda p,q: ((not p) or q)),         "=>"),
    ]

for op,sym in operators:
    print "nTruth tables for %s" % sym

    print "nptqtp %s qtq %s p" % (sym,sym)
    for p,q in product(booleans,repeat=2):
        print "%dt%dt%dt%d" % (p,q,p |op| q,q |op| p)

    print "nptqtrtp %s qtq %s rt(p %s q) %s rtp %s (q %s r)tp %s q %s r" % (sym,sym,sym,sym,sym,sym,sym,sym)
    for p,q,r in product(booleans,repeat=3):
        print "%dt%dt%dt%dt%dt%dtt%dtt%d" % (p,q,r,p |op| q,q |op| r, (p |op| q) |op| r, p |op| (q |op| r), p |op| q |op| r)
        assert( (p |op| q) |op| r == p |op| q |op| r)

Источник

Я хотел бы написать инструкцию в python с логической импликацией. Что-то вроде:

Конечно, я знаю, что могу использовать:

Но существует ли в этом случае логический оператор для python?

6 ответов

p => q совпадает с not(p) or q , поэтому вы можете попробовать это!

В вашем вопросе спрашивается, существует ли для Python один логический оператор, простой ответ — нет: Документы перечисляют логические операции, и Python просто не имеет ничего подобного.

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

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

Б ольшинство строк программного кода представляют собой выражения. Например: 1 + 2 — это выражение. Выражение состоит из 2 частей:

  • Оператор (+) — функционал, представленный в виде символов (например + ==) или зарезервированных слов (например and not).
  • Операнды (1 и 2) — это данные, над которыми производится действия.

После того как Python-интерпретатор вычислит выражение, мы можем, как в примере выше, присвоить результат переменной sum . Или, например, сразу вывести результат на экран:

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

Рассмотрим простой пример — 1 + 2 == 3 .

Для проверки истинности данного условия, используется логический тип. Когда мы выполним данное выражение, в результате нам вернется True (истина) или False (ложь).

В данном примере мы используем один из операторов сравнения — «==» (равно). Всего в Python таких операторов 6:

  • == — равно;
  • != — не равно;
  • > — больше;
  • < — меньше;
  • >= — больше или равно;
  • <= — меньше или равно.

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

Правила выполнения логических операций соответствуют таблицам истинности . В Python 3 логических оператора:

  • or — логическое «ИЛИ»;
  • and — логическое «И»;
  • not — логическое отрицание.

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

Арифметические операторы в Python производят арифметические операции над числами (сложение, вычитание, деление и т.д.);

  • + — сложение;
  • — — вычитание;
  • * — умножение;
  • / — деление;
  • // — целочисленное деление (возвращает только целую часть от деления, значение после запятой отбрасывается);
  • % — деление по модулю (возвращает остаток от деления);
  • ** — возведение в степень.

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

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

  • = — значение правого операнда присвоится левому операнду;
  • += — сумма левого и правого операнда присвоится левому операнду;
  • -= — разность левого и правого операнда присвоится левому операнду;
  • *= — произведение левого и правого операнда присвоится левому операнду;
  • /= — разделит левый операнд на правый и результат присвоится левому операнду;
  • //= — результат целочисленного деления левого операнда на правый операнд присвоится левому операнду;
  • %= — разделит левый операнд на правый по модулю и результат присвоится левому операнду;
  • **= — возведет левый операнд в степень правого и результат присвоится левому операнду.

Python поддерживает не только обычное присваивание правого операнда левому, но и множественное присваивание.

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

Также с помощью множественного присваивания можно «распаковывать» строки (str), списки (list), кортежи (tuple) и словари (dict).

Распаковка особенно удобна, когда функция возвращает несколько значений в виде кортежа (tuple):

>>> def test_page(): return 404, «Not found» >>> code, message = test_page() >>> print(code, message) 404 Not found

Главное условие распаковки – количество элементов должно совпадать

Если необходимо распаковать лишь несколько элементов, воспользуйтесь переменной со знаком » * «:

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

Данные операторы предназначены для работы с данными в битовом (двоичном) формате. Про битовые операции смотрите статью на википедии .

Операторы членства

В Python существует всего 2 оператора принадлежности — in и not in и предназначены они для проверки наличия элемента в строке (str), списке (list), словаре (dict) или кортеже (tuple).

  • in — возвращает True если элемент присутствует в последовательности;
  • not in — возвращает True если элемент отсутствует в последовательности.

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

Данные операторы сравнивают размещение двух объектов в памяти.

  • is — возвращает True если оба операнда указывают на один и тот же объект;
  • is not — возвращает True если оба операнда указывают на разные объекты.

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

Таблица приоритетов операторов в Python показана ниже.

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

Например, в выражении 1 + 2 ** 2 * 10 сначала выполнится возведение в степень, далее умножение, потом сложение. Итого результат: 41 .

Основные операторы Python

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

Типы операторов Python

Операторы Python можно разделить на следующие категории.

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

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

  • +: оператор сложения;
  • -: оператор вычитания;
  • *: оператор умножения;
  • /: оператор деления;
  • **: экспоненциальный оператор;
  • //: оператор деления.

Давайте посмотрим на пример арифметических операторов в Python.

2. Сравнения

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

Список операторов сравнения:

  • ==: возвращает True, если оба значения равны.
  • ! =: возвращает True, если оба операнда не равны.
  • >: возвращает True, если левый операнд больше правого.
  • <: возвращает True, если левый операнд меньше правого.
  • > =: возвращает True, если левое значение больше или равно правому.
  • <=: возвращает True, если левое значение меньше или равно правому значению.

Давайте посмотрим на пример.

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

Эти операторы работают и со строками. Строка считается большей, чем другая строка, если она идет после нее лексикографически. Например, «Привет» больше, чем «Привет» при лексикографическом сравнении.

3. Побитовые

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

В Python 6 побитовых операторов.

  • : Побитовый оператор И;
  • | : Побитовый оператор ИЛИ;
  • ^: Побитовый оператор XOR;

4. Логические

  • and: логический оператор И;
  • или: логический оператор ИЛИ;
  • not: оператор логического НЕ.

Логические

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

Оператор присваивания (=) используется для присвоения значения левого операнда правому операнду.

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

  • =: простой оператор присваивания;
  • + =: складывает два операнда, а затем присваивает значение правому операнду;
  • — =: вычитает правый операнд из левого и затем присваивает значение левому операнду;
  • * =: умножает оба операнда, а затем присваивает левому;
  • / =: делит левый операнд от правого операнда, а затем присваивает значение левому операнду;
  • % =: модуль левого и правого операндов, а затем присваивается левому операнду;
  • ** =: экспонента для операндов слева направо и затем присвоение левому операнду;
  • // =: нижнее деление левого и правого операндов, а затем значение присваивается левому операнду.

6. Операторы членства

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

Эти операторы обычно используются с условием if-else.

Членства

7. Идентификации

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

Приоритет

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

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

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

Перегрузка

Python поддерживает перегрузку операторов. Существуют определенные методы перегрузки оператора для объекта.

Посмотрим, что произойдет, если оператор не поддерживается для класса.

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

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

Оператор Описание Метод
+ Сложение __add__(self, other)
– Вычитание __sub__(self, other)
* Умножение __mul__(self, other)
/ Истинное деление __truediv__(self, other)
// Floor Division __floordiv__(self, other)
% Остаток __mod__(self, other)
** Power __pow__(self, other)
& побитовый AND __and__(self, other)
| побитовый OR __or__(self, other)
^ побитовый XOR __xor__(self, other)
> Больше чем __gt__(self, other)
>= Больше чем или равно __ge__(self, other)
< Меньше чем __lt__(self, other)
<= Меньше чем или равно __le__(self, other)
== Равенства __eq__(self, other)
!= Не равно __ne__(self, other)

Модуль оператора Python

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

Давайте посмотрим на пример настраиваемого класса, который поддерживает операторы — +,> и *. Мы будем использовать функции операторского модуля для вызова этих методов для объектов класса.

Вывод

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

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

Источник

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

#!/usr/bin/python

# From http://code.activestate.com/recipes/384122/ (via http://stackoverflow.com/questions/932328/python-defining-my-own-operators)
class Infix:
    def __init__(self, function):
        self.function = function
    def __ror__(self, other):
        return Infix(lambda x, self=self, other=other: self.function(other, x))
    def __rlshift__(self, other):
        return Infix(lambda x, self=self, other=other: self.function(other, x))
    def __or__(self, other):
        return self.function(other)
    def __rshift__(self, other):
        return self.function(other)
    def __call__(self, value1, value2):
        return self.function(value1, value2)

from itertools import product

booleans = [False,True]

# http://stackoverflow.com/questions/16405892/is-there-an-implication-logical-operator-in-python
# http://jacob.jkrall.net/lost-operator/
operators=[
    (Infix(lambda p,q: False),                  "F"),
    (Infix(lambda p,q: True),                   "T"),
    (Infix(lambda p,q: p and q),                "&"),
    (Infix(lambda p,q: p or q)           ,      "V"),
    (Infix(lambda p,q: p != q)           ,      "^"),
    (Infix(lambda p,q: ((not p) or not q)),     "nad"),
    (Infix(lambda p,q: ((not p) and not q)),    "nor"),
    (Infix(lambda p,q: ((not p) or q)),         "=>"),
    ]

for op,sym in operators:
    print "nTruth tables for %s" % sym

    print "nptqtp %s qtq %s p" % (sym,sym)
    for p,q in product(booleans,repeat=2):
        print "%dt%dt%dt%d" % (p,q,p |op| q,q |op| p)

    print "nptqtrtp %s qtq %s rt(p %s q) %s rtp %s (q %s r)tp %s q %s r" % (sym,sym,sym,sym,sym,sym,sym,sym)
    for p,q,r in product(booleans,repeat=3):
        print "%dt%dt%dt%dt%dt%dtt%dtt%d" % (p,q,r,p |op| q,q |op| r, (p |op| q) |op| r, p |op| (q |op| r), p |op| q |op| r)
        assert( (p |op| q) |op| r == p |op| q |op| r)
Источник
Доступ в студенческое облако: https://cloud.nntc.nnov.ru

Доступ осуществляется с учётными данными от moodle.nntc.nnov.ru
При возникновении проблем

сообщите на:

support@nntc.nnov.ru

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

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

  • xor (исключающее или, работает так же как и обычное, но ложно, если и a — истина и b — истина)
  • импликация (в математике обозначается как a => b, в Python можно выразить как not(a) or b)
Источник

Понравилась статья? Поделить с друзьями:
  • Имя моя как пишется
  • Имнида на корейском как пишется
  • Имя молодец как пишется
  • Иммущество или имущество как правильно пишется
  • Имя митя полное мужское как пишется