Что означают эти операторы (**, ^,%,//)? - Python?

Кроме стандартных операторов +, -, * и /; но что они означают (**, ^, %, //)?

>>> 9+float(2) # addition
11.0
>>> 9-float(2) # subtraction
7.0
>>> 9*float(2) # multiplication
18.0
>>> 9/float(2) # division
4.5
>>>
>>> 9**float(2) # This looks like a square, (i.e. power 2) 
81.0
>>> 9**float(3) # So ** is equivalent to `math.pow(x,p)` ?
729.0

Как насчет оператора ^?

>>> 9^int(2) # What is `^` in `x^u` , it only allows `int` for `u`
11
>>> 9^int(3)
10
>>> 9^int(4)
13
>>> 9^int(5)
12
>>> 9^int(6)
15
>>> 9^int(7)
14
>>> 9^int(8)
1
>>> 9^int(9)
0
>>> 9^int(10)
3
>>> 9^int(11)
2
>>> 9^int(12)
5

% в x%m возвращает нормальный модуль останова, но только если m < x, почему это так? Что делает %?

>>> 9%float(2)
1.0
>>> 9%float(3)
0.0
>>> 9%float(4)
1.0
>>> 9%float(5)
4.0
>>> 9%float(6)
3.0
>>> 9%float(7)
2.0
>>> 9%float(8)
1.0
>>> 9%float(9)
0.0
>>> 9%float(10)
9.0
>>> 9%float(11)
9.0
>>> 9%float(12)
9.0

Как насчет оператора //? что он делает?

>>> 9//float(2)
4.0
>>> 9//float(3)
3.0
>>> 9//float(4)
2.0
>>> 9//float(5)
1.0
>>> 9//float(6)
1.0
>>> 9//float(7)
1.0
>>> 9//float(8)
1.0
>>> 9//float(9)
1.0
>>> 9//float(1)
9.0
>>> 9//float(0.5)
18.0

Ответы

Ответ 1

**: возведение в степень
^: эксклюзивный или (побитовый)
%: модуль
//: разделите интегральный результат (отбросить остаток)

Ответ 2

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

Оператор ** выполняет возведение в степень. a ** b имеет значение a, поднятое до степени b. Тот же символ ** также используется в аргументе функции и вызывается нотациям с другим значением (передача и получение произвольных аргументов ключевого слова).
Оператор ^ выполняет двоичный xor. a ^ b вернет значение только с битами, установленными в a или в b, но не с обоими. Это просто!
Оператор % в основном должен найти модуль из двух целых чисел. a % b возвращает остаток после деления a на b. В отличие от операторов модуля в некоторых других языках программирования (таких как C), в Python модуль будет иметь тот же знак, что и b, а не тот же знак, что и a. Тот же оператор также используется для "старого" стиля форматирования строк, поэтому a % b может возвращать строку, если a - это строка формата, а b - значение (или набор значений), которое может быть вставлено в a.
Оператор // выполняет Python-версию целочисленного деления. Целочисленное деление Python не совсем такое же, как целочисленное деление, предлагаемое некоторыми другими языками (например, C), поскольку оно округляется до отрицательной бесконечности, а не к нулю. Вместе с оператором модуля вы можете сказать, что a == (a // b)*b + (a % b). В Python 2 разделение полов является поведением по умолчанию, когда вы делите два целых числа (используя оператор нормального деления /). Поскольку это может быть неожиданным (особенно, когда вы не придирчивы к тому, какие типы чисел вы получаете в качестве аргументов функции), Python 3 изменился, чтобы сделать "истинное" (с плавающей запятой) разделение нормой для деления, которое будет округлено в противном случае, и он будет выполнять разделение "пол" только при явной просьбе. (Вы также можете получить новое поведение в Python 2, поставив from __future__ import division в начало ваших файлов. Я настоятельно рекомендую!)

Ответ 3

Вы правы, что ** - это функция мощности.

^ является побитовым XOR.

% - действительно операция модуля, но обратите внимание, что для положительных чисел x % m = x всякий раз, когда m > x. Это следует из определения модуля. (Кроме того, Python указывает x % m на знак m.)

// - операция деления, которая возвращает целое число, отбрасывая остаток. Это стандартная форма деления, использующая / в большинстве языков программирования. Однако Python 3 изменил поведение / для выполнения деления с плавающей запятой, даже если аргументы являются целыми числами. Оператор // был введен в Python 2.6 и Python 3 для обеспечения оператора целочисленного деления, который будет вести себя последовательно между Python 2 и Python 3. Это означает:

| context                                | `/` behavior   | `//` behavior |
---------------------------------------------------------------------------
| floating-point arguments, Python 2 & 3 | float division | int divison   |
---------------------------------------------------------------------------
| integer arguments, python 2            | int division   | int division  |
---------------------------------------------------------------------------
| integer arguments, python 3            | float division | int division  |

Подробнее см. в этом вопросе: Отдел в Python 2.7. и 3.3