Операторы ‘is’ и ‘==’ в python

Математические методы

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

Оператор «=» присваивает значение, расположенное справа, переменной слева. Например, v = 23 присваивает значение числа 23 переменной v.

В программировании часто используют составные операторы присваивания. Они соединяют арифметический оператор с оператором «=». Поэтому для сложения мы используем оператор «+» с оператором «=», чтобы получить составной оператор «+=». Пример:

w = 5
w += 1
print(w)

Вывод

6

Сначала мы задаём переменной  значение . Затем используем составной оператор присваивания , чтобы прибавить число справа, к переменной, расположенной слева, и присвоить результат переменной .

Составные операторы присваивания часто используются в циклах for:

for x in range (0, 7):
    x *= 2
    print(x)

Вывод

0
2
4
6
8
10
12

При помощи for можно автоматизировать процесс использования оператора «. Он умножает переменную на число , а затем присваивает полученный результат переменной  для следующей итерации цикла.

В Python предусмотрен составной оператор присваивания для каждой арифметической операции:

y += 1          # добавить число и присвоить результат
y -= 1          # отнять число и присвоить результат
y *= 2          # умножить на число и присвоить результат
y /= 3          # разделить на число и присвоить результат
y // = 5        # разделить без остатка на число и присвоить результат
y **= 2         # возвести в степень и присвоить результат
y %= 3          # вернуть остаток от деления и присвоить результат

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

Python больше или равен в списках

Список “больше или равно” Оператор ITERATET по поводу списков и чеки вправо, если i-й элемент левого операнда больше или равен i-го элемента правого операнда.

>>>  >= 
False
>>>  >= 
True
>>>  >= 
False
>>>  >= 
True
>>>  >= 
True

• Отказ Python первые чеки который является Так что это сразу возвращает Отказ
• Отказ Python первые чеки который является Отказ
• Отказ Python сначала сравнивает 1 и 1-я галстук! Итак, он перемещается ко второму элементам 2 и 2-галстук! Итак, он движется к третьим элементам в качестве галстука. Но только второй список имеет третий элемент, поэтому он считается больше, чем первый, и результат операции является Отказ
• Отказ Python сравнивает элементы 1 и 1 – галстук! Но затем он сравнивает второе элементы 2 и 1 и определяет, что первое больше, чем второе, поэтому результат является Отказ
• Отказ Python первые чеки а потом проверяет Отказ Все еще галстук, поэтому результат – как они равны.

Тот же метод также относится к строкам и другим типам последовательности в Python, таких как кортежи.

Перегрузка

Рассмотрим пример перегрузки операторов сравнения в настраиваемом объекте.

# Learn how to override comparison operators for custom objects


class Data:
    id = 0

    def __init__(self, i):
        self.id = i

    def __eq__(self, other):
        print('== operator overloaded')
        if isinstance(other, Data):
            return True if self.id == other.id else False
        else:
            return False

    def __ne__(self, other):
        print('!= operator overloaded')
        if isinstance(other, Data):
            return True if self.id != other.id else False
        else:
            return False

    def __gt__(self, other):
        print('> operator overloaded')
        if isinstance(other, Data):
            return True if self.id > other.id else False
        else:
            return False

    def __lt__(self, other):
        print('< operator overloaded')
        if isinstance(other, Data):
            return True if self.id < other.id else False
        else:
            return False

    def __le__(self, other):
        print('<= operator overloaded')
        if isinstance(other, Data):
            return True if self.id <= other.id else False
        else:
            return False

    def __ge__(self, other):
        print('>= operator overloaded')
        if isinstance(other, Data):
            return True if self.id >= other.id else False
        else:
            return False


d1 = Data(10)
d2 = Data(7)

print(f'd1 == d2 = {d1 == d2}')
print(f'd1 != d2 = {d1 != d2}')
print(f'd1 > d2 = {d1 > d2}')
print(f'd1 < d2 = {d1 < d2}')
print(f'd1 <= d2 = {d1 <= d2}')
print(f'd1 >= d2 = {d1 >= d2}')

Вывод:

== operator overloaded
d1 == d2 = False
!= operator overloaded
d1 != d2 = True
> operator overloaded
d1 > d2 = True
< operator overloaded
d1 < d2 = False
<= operator overloaded
d1 <= d2 = False
>= operator overloaded
d1 >= d2 = True

Пример 1

Мы знаем, что встроенная функция sort() сортирует список в порядке возрастания или убывания. После сортировки списка у вас будет самый большой номер в конце списка, если вы отсортировали его в порядке возрастания, или в начале списка, если вы отсортировали его в порядке убывания.

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

# list
a=

# sort the list, default is in ascending order
a.sort()

# largest number is the last item in the sorted list
ln = a

# print the largest number
print("Largest element is: ",ln)

Вывод:

Largest element is: 52

a выбирает последний элемент в списке.

Пример 2: с помощью цикла For

Хотя найти наибольшее число с помощью функции sort() легко, использование цикла For делает это относительно быстрее с меньшим количеством операций.

a = 

#variable to store largest number
ln = a if a else None

#find largest number
for i in a:
	if i>ln:
		ln=i

print("Largest element is: ",ln)

Вывод:

Largest element is: 52

В этом примере мы приняли список и инициализировали переменную ln с наибольшим числом первым элементом списка. Если в списке нет элементов, ln инициализируется значением None.

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

Когда вы завершите обход списка, вы получите наибольший номер списка в вашей переменной.
Вы можете найти наименьший номер списка в Python, используя функцию min(), функцию sort() или цикл for.

Мы рассмотрим следующие процессы, чтобы найти наименьшее число в списке, с примерами:

• встроенную функцию min();
• функцию сортировки sort();
• Цикл For.

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

Python меньше или равно спискам

Список «Меньше или равно« » Оператор итерации по поводу списков и проверки попарно, если i-й элемент левого операнда меньше или равен i-й элементу правого операнда.

>>>  <= 
True
>>>  <= 
False
>>>  <= 
True
>>>  <= 
False
>>>  <= 
True

• Отказ Python первые чеки который является Так что это сразу возвращает Отказ
• Отказ Python первые чеки который является Отказ
• Отказ Python сначала сравнивает 1 и 1-я галстук! Итак, он перемещается ко второму элементам 2 и 2-галстук! Итак, он движется к третьим элементам в качестве галстука. Но только второй список имеет третий элемент, поэтому он считается больше, чем первый, и результат операции является Отказ
• Отказ Python сравнивает элементы 1 и 1 – галстук! Но затем он сравнивает второе элементы 2 и 1 и определяет, что первое не менее чем второе, поэтому результат является Отказ
• Отказ Списки содержат одни и те же элементы, поэтому парапречным сравнением приводит к Отказ

Тот же метод также относится к строкам и другим типам последовательности в Python, таких как кортежи.

Строки

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

Операции со строками

string извлекает символ в позиции i

string извлекает последний символ

string извлекает символы в диапазоне от i до j

Методы работы сос строками

string.upper() преобразует строку в верхний регистр

String.lower() преобразует в строку в нижний регистр

string.count(x) подсчитывает, сколько раз появляется x

string.find(x) позиция первой строки вхождения x

string.replace(x, y) заменяет x на y

string.strip(x) удаляет как начальные, так и конечные символы x

string.join (List) объединяет список строк

Условный оператор if

Оператор if позволяет изменить порядок выполнения операторов в зависимости от истинности или ложности некоторого условия. Формат оператора может быть записан в двух формах: полной и неполной форме.

if  условие:    # блок if    <операторы>else:    # блок else    <операторы>

Блок инструкций if будет выполнен, если условие истинно. Если условие ложно, будет выполнен блок инструкций else.

В условном операторе  может отсутствовать слово else и последующий блок. Такая инструкция называется неполным ветвлением.

Пример 5.  Записать следующее   выражение  на языке Python.Если a  >  0,  то  b  =  1,   иначе  a  =  0. 

print («Введите значение a: «) a = int(input())if a > :     b = 1       else:     b = print(«b = «, b)

Условный оператор  elif

if условие_1:   # блок if   <операторы>elif условие_2:   # первый блок elif   <операторы>elif условие_3:   <операторы>...else   # блок else   <операторы>   

Ключевое слово elifрасшифровывается, как else + if. Это конструкция позволяет  реализовать алгоритм  выбора   необходимого варианта из нескольких альтернативных вариантов.  Оператор elif позволяет упростить код. Сделать его легче читаемым и позволяет избежать написание несколько условий  if.

Когда исполняется инструкция if-elif-else, в первую очередь  проверяется условие_1.  Если условие истинно, тогда исполняется блок инструкций if .  Следующие условия и операторы пропускаются, и управление переходит к оператору  за  условным оператором if-elif-else.

Если условие_1 оказывается ложным, тогда управление переходит к следующему условию elif,  и проверяется условие_2.  Если оно истинно, тогда исполняются инструкции внутри первого блока elif. Последующие инструкции внутри этого блока пропускаются. Этот процесс повторяется, пока не находится условие elif, которое оказывается истинным. Если такого нет, тогда исполняется блок операторов else

 Пример.  

x = int(input())
y = int(input())if x > and y > print("Первая четверть")elif x > and y < print("Четвертая четверть")elif y > print("Вторая четверть")else: print("Третья четверть")

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

Арифметические операторы используются для выполнения арифметических операций между двумя операндами. Включает в себя операторы +(сложение), -(вычитание), *(умножение), /(деление),%(напоминание), //(деление по полу) и экспоненты(**).

Рассмотрим следующую таблицу для подробного объяснения арифметических операторов.

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

Строка – это объект в программировании на Python. Посмотрим, работают ли операторы сравнения со строками или нет.

>>> # string comparison
>>> s1 = 'a'
>>> s2 = 'a'
>>> s3 = 'b'
>>> s1 == s2
True
>>> s1 != s2
False
>>> s1 > s3
False
>>> s1 < s3
True
>>> s1 <= s2
True
>>> s1 >= s2
True
>>> 

Значит ли это, что операторы сравнения будут работать с любыми объектами Python?

Давайте проверим это, создав собственный класс.

>>> class Data:
	pass

>>> d1 = Data()
>>> d2 = Data()
>>> d1 == d2
False
>>> d1 != d2
True
>>> d1 > d2
Traceback (most recent call last):
  File "<pyshell#30>", line 1, in <module>
    d1 > d2
TypeError: '>' not supported between instances of 'Data' and 'Data'
>>> d1 < d2
Traceback (most recent call last):
  File "<pyshell#31>", line 1, in <module>
    d1 < d2
TypeError: '<' not supported between instances of 'Data' and 'Data'
>>> d1 <= d2
Traceback (most recent call last):
  File "<pyshell#32>", line 1, in <module>
    d1 <= d2
TypeError: '<=' not supported between instances of 'Data' and 'Data'
>>> d1 >= d2
Traceback (most recent call last):
  File "<pyshell#33>", line 1, in <module>
    d1 >= d2
TypeError: '>=' not supported between instances of 'Data' and 'Data'
>>> 
>>> 

Почему оператор equals и not-equals работал, а другие – нет?

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

Операции сравнения

Операции сравнения
== (равенство),
!=  (неравенство),
>  (больше),
=  (больше или равно),

Обратите внимание, что для сравнения используется не знак равенства
=, а два знака равенства, так как в C- подобных языках один знак равенства используется для операции присваивания

Примеры использования:

Python

$ python3
Python 3.5.3 (default, Sep 27 2018, 17:25:39)
on linux
Type «help», «copyright», «credits» or «license» for more information.
>>> 20 == 30
False
>>> 20 == 20
True
>>> 20 != 30
True
>>> 20 != 20
False
>>> 20 > 30
False
>>> 30 > 20
True
>>> 20 < 30
True
>>> 30 < 20
False
>>> 30 >= 20
True
>>> 20 >= 20
True
>>> 19 >= 20
False
>>> 30 <= 20
False
>>> 20 <= 20
True
>>> 19 <= 20
True
>>>

Сравнения

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

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

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

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

x = 10
y = 20

print(f'equals = {x == y}')
print(f'not equals = {x != y}')
print(f'greater than = {x > y}')
print(f'less than = {x < y}')
print(f'greater than or equal to = {x >= y}')
print(f'less than or equal to = {x <= y}')

Вывод:

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

Унарные арифметические операции Python

Унарное математическое выражение состоит из одного элемента. Знаки плюса и минуса в питоне могут быть использованы как единичный оператор, чтобы вернуть тождественное значение (+) или сменить знак числа (-).

Знак плюса означает тождественное значение. Мы можем использовать его с положительными значениями:

i = 3.3
print(+i)

Вывод

3.3

Когда мы используем знак плюса с отрицательным значением, он также вернёт значение тождественное данному. В этом случае он вернёт отрицательное значение:

j = -19
print(+j)

Вывод

-19

При использовании с отрицательным значением знак плюса возвращает то же отрицательное значение.

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

i = 3.3
print(-i)

Вывод

-3.3

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

j = -19
print(-j)

Вывод

19

Унарные арифметические операторы возвращают тождественное значение в случае с +i, или противоположное по знаку число в случае с -i.

Перегрузка

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

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

class Data:
    id = 0

    def __init__(self, i):
        self.id = i


d1 = Data(10)
d2 = Data(20)

d3 = d1 + d2
print(d3.id)

Вывод:

Traceback (most recent call last):
  File "/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/operators_examples.py", line 9, in <module>
    d3 = d1 + d2
TypeError: unsupported operand type(s) for +: 'Data' and 'Data'

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

class Data:
    id = 0

    def __init__(self, i):
        self.id = i

    def __add__(self, other):
        return Data(self.id + other.id)


d1 = Data(10)
d2 = Data(20)

d3 = d1 + d2
print(d3.id)

Выход: 30

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

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

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

Например,

 
if a = 7  
   b = 6    
then, binary(a) = 0111   
    binary(b) = 0110   
   
hence, a & b = 0011   
      a | b = 0111   
             a ^ b = 0100   
       ~ a = 1000 

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

Давайте посмотрим на пример, где у нас есть несколько логических операторов. Мы не смешиваем разные типы операторов в Python, поэтому приоритет операторов не будет очевиден и будет легче объяснить результат.

Мы также переопределим функцию __bool __() для вывода значения «id».

def my_bool(data):
    print('Data bool method called, id =', data.id)
    return True if data.id > 0 else False


Data.__bool__ = my_bool

d1 = Data(10)
d2 = Data(-20)
d3 = Data(20)

# evaluated from left to right, confirmed from the __bool__() print statement
if d1 and d2 or d3:
    print('At least one of them have a positive id.')

Вывод:

Data bool method called, id = 10
Data bool method called, id = -20
Data bool method called, id = 20
At least one of them have a positive id.

Обратите внимание, что логическое значение сначала вычисляется для d1, тем самым подтверждая, что выполнение происходит слева направо

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

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

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

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

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

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

Библиотека math

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

import math           # подключение модуля библиотеки

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

имя_модуля.имя_функции

Например, пусть мы хотим вызвать функцию вычисления Синус угла, задаваемого в радианахimport math y = sin(5)         # ошибка не подключен модуль mathx = math.sin(5)    # записываем имя модуля и через точку имя функции

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

from <имя подключаемого модуля> import <название функции>

Например.

from math import sin       # подключена только одна функция siny = sin(5)                 # операция выполненаx = cos(5)               # ошибка функция cos не подключена

Ниже приведен список основных функций модуля math. Некоторые из перечисленных функций (int, round, abs) являются стандартными и не требуют подключения модуля math для использования.

Списки Python

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

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

list1 = ;
list2 = ;
list3 = 

Подобно строковым индексам, индексы списков начинаются с 0. Списки могут быть нарезаны, объединены и т.д.

Доступ к значениям в списках

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

list1 = ;
list2 = ;
print("list1: ", list1)
print("list2: ", list2)

Когда приведенный выше код выполняется, он дает следующий результат —

list1:  physics
list2:  

Обновление списков

Вы можете обновить один или несколько элементов списков, предоставив срез в левой части оператора присваивания, а также добавить элементы в список с помощью метода append (). Например —

list = ;
print "Value available at index 2 : "
print list
list = 2001;
print "New value available at index 2 : "
print list

Примечание. Метод append () обсуждается в следующем разделе.

Когда приведенный выше код выполняется, он дает следующий результат —

Value available at index 2 :
1997
New value available at index 2 :
2001

Удалить элементы списка

Чтобы удалить элемент списка, вы можете использовать либо оператор del, если вы точно знаете, какие элементы вы удаляете, либо метод remove (), если вы не знаете. Например —

list1 = ;
print list1
del list1;
print "After deleting value at index 2 : "
print list1

Когда приведенный выше код выполняется, он дает следующий результат —

After deleting value at index 2 :

Примечание. Метод remove () обсуждается в следующем разделе.

Основные операции со списком

Списки реагируют на операторы + и * так же, как строки; здесь они также означают конкатенацию и повторение, за исключением того, что результатом является новый список, а не строка.

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

Индексирование, нарезка и матрицы

Поскольку списки являются последовательностями, индексирование и нарезка для списков работают так же, как и для строк.

Предполагая следующий ввод —

L = 

Встроенные функции и методы списка

Python включает в себя следующие функции списка —

Python включает следующие методы списка

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

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

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

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

x = 15
y = 7

sum = x + y
print("addition =", sum)

subtraction = x - y
print("subtraction =", subtraction)

multiplication = x * y
print("multiplication =", multiplication)

division = x / y
print("division =", division)

modulus = x % y
print("modulus =", modulus)

exponent = x ** 2
print("exponent =", exponent)

floor_division = x // y
print("division =", floor_division)  # 2

Вывод:

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

print("addition of strings =", ("Python" + " " + "Operators"))
print("multiplication of strings =", ("Python" * 2))

Вывод:

addition of strings = Python Operators
multiplication of strings = PythonPython

Python Comparison Operators

These operators compare the values on either side of them and decide the relation among them. They are also called Relational operators.

Assume variable a holds the value 10 and variable b holds the value 20, then −

Битовые операции

Битовые операции работают так же, как и в большинстве других языков. в Python поддерживаются:
&  (битовое И),
|  (битовое ИЛИ),
^  (битовое ИСКЛЮЧАЮЩЕЕ ИЛИ),
~  (унарный префиксный операнд, инвертирует биты),
<<  (битовый сдвиг влево),
>>  (битовый сдвиг вправо). Если вы понимаете двоичную систему исчисления и представление чисел в них, то проблем возникнуть не должно.

Python

$ python3
Python 3.5.3 (default, Sep 27 2018, 17:25:39)
on linux
Type «help», «copyright», «credits» or «license» for more information.
>>> x = 5
>>> y = 6
>>> print(x & y)
4
>>> print(x | y)
7
>>> print(x ^ y)
3
>>> print(~x)
-6
>>> print(x<<2)
20
>>> print(x>>2)
1

Переопределение операторов ‘==’ и ‘!=’

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

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

Если вы реализуете в пользовательском классе собственный метод , то сможете изменить поведение операторов / :

class TestingEQ:
    def __init__(self, n):
        self.n = n

    # используем '==', чтобы проверить четны ли оба числа
    # или нечетны
    def __eq__(self, other):
        if (self.n % 2 == 0 and other % 2 == 0):
            return True
        else:
            return False


print(5 == TestingEQ(1))
print(2 == TestingEQ(10))
print(1 != TestingEQ(2))

Выполнение кода дает следующий результат:

False
True
True

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

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

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

import operator


class Data:
    id = 0

    def __init__(self, i):
        self.id = i

    def __add__(self, other):
        return Data(self.id + other.id)

    def __gt__(self, other):
        return self.id > other.id

    def __mul__(self, other):
        return Data(self.id * other.id)


d1 = Data(10)
d2 = Data(20)

d3 = operator.add(d1, d2)
print(d3.id)

d3 = operator.mul(d1, d2)
print(d3.id)

flag = operator.gt(d1, d2)
print(flag)

От: admin

Эта тема закрыта для публикации ответов.