What do these operators mean (** , ^ , %, //)?
Solution 1
-
**
: exponentiation -
^
: exclusive-or (bitwise) -
%
: modulus -
//
: divide with integral result (discard remainder)
Solution 2
You can find all of those operators in the Python language reference, though you'll have to scroll around a bit to find them all. As other answers have said:
- The
**
operator does exponentiation.a ** b
isa
raised to theb
power. The same**
symbol is also used in function argument and calling notations, with a different meaning (passing and receiving arbitrary keyword arguments). - The
^
operator does a binary xor.a ^ b
will return a value with only the bits set ina
or inb
but not both. This one is simple! - The
%
operator is mostly to find the modulus of two integers.a % b
returns the remainder after dividinga
byb
. Unlike the modulus operators in some other programming languages (such as C), in Python a modulus it will have the same sign asb
, rather than the same sign asa
. The same operator is also used for the "old" style of string formatting, soa % b
can return a string ifa
is a format string andb
is a value (or tuple of values) which can be inserted intoa
. - The
//
operator does Python's version of integer division. Python's integer division is not exactly the same as the integer division offered by some other languages (like C), since it rounds towards negative infinity, rather than towards zero. Together with the modulus operator, you can say thata == (a // b)*b + (a % b)
. In Python 2, floor division is the default behavior when you divide two integers (using the normal division operator/
). Since this can be unexpected (especially when you're not picky about what types of numbers you get as arguments to a function), Python 3 has changed to make "true" (floating point) division the norm for division that would be rounded off otherwise, and it will do "floor" division only when explicitly requested. (You can also get the new behavior in Python 2 by puttingfrom __future__ import division
at the top of your files. I strongly recommend it!)
Solution 3
You are correct that **
is the power function.
^
is bitwise XOR.
%
is indeed the modulus operation, but note that for positive numbers, x % m = x
whenever m > x
. This follows from the definition of modulus. (Additionally, Python specifies x % m
to have the sign of m
.)
//
is a division operation that returns an integer by discarding the remainder. This is the standard form of division using the /
in most programming languages. However, Python 3 changed the behavior of /
to perform floating-point division even if the arguments are integers. The //
operator was introduced in Python 2.6 and Python 3 to provide an integer-division operator that would behave consistently between Python 2 and Python 3. This means:
| 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 |
For more details, see this question: Division in Python 2.7. and 3.3
Comments
-
alvas almost 2 years
Other than the standard
+
,-
,*
and/
operators; but what does these mean (**
,^
,%
,//
) ?>>> 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
How about the
^
operator?>>> 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
%
inx%m
returns a normal remainder modulus, but only ifm < x
, why is that so? What does%
do?>>> 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
How about the
//
operator? what does it do?>>> 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
-
phant0m about 11 yearsAs for
%
: not only is the sign different, the absolute values are different, too! -
WestCoastProjects about 7 yearsThanks for these spot-on descriptions especially of the modulus and integer division operators.
-
hyper-neutrino over 6 yearsIt may be worth noting that
x % m
always gives a result with the sign ofm
. -
Kyle Strand over 6 years@HyperNeutrino Thanks. I was originally only interested in explaining the specific situation the OP was asking about, but since this answer has grown into something slightly more general, I've added a note to that effect.
-
Jeremy over 3 years@HyperNeutrino ...in your comment, "x % m always gives a result with the sign of m," please elaborate on "the sign of m." What exactly does that look like? I'm having difficulty understanding it. Thank you!
-
hyper-neutrino over 3 years@Jeremy If
m
is positive, the answer will be positive. For example,5 % 3
is2
but-5 % 3
is1
, not-2
. Similar thing form
being negative. This works differently from certain languages like I believe, Java. -
Jeremy over 3 years@HyperNeutrino ...oooh! The "sign" positive (+) or negative (-). Thank you!