I know here in not the right place for make this question but:
I can't find tutorials about this operators. I don't know how use it.
: (// << >> & | ^ ~
Gee, I'm surprised too, but I can't find a tutorial either. Okay, here's
my best attempt.
First of all, let me cover "//":
"//" (integer division):
This operator is the complement of "%" -- it gives the NON-remainder
integer part of division. For instance, 14 // 4 == 3 because 4 goes into
15 three times (with a remainder of 2). Actually, for the moment, this
behaves EXACTLY like the "/" operator with integer operands, but the "/"
operator is going to change. For official definitions, see
PEP 238 – Changing the Division Operator | peps.python.org.
Now, all of the other operators you mention share something in common --
they are "bitwise" operators. That is, they operate on numbers (normally),
but instead of treating that number as if it were a single value, they
treat it as if it were a string of bits, written in twos-complement
binary. So a brief summary of twos-complement binary is in order:
0 is written as "0"
1 is written as "1"
2 is written as "10"
3 is "11"
4 is "100"
5 is "101"
and so forth. Thus
1029 is "10000000101" == 2**10 + 2**2 + 2**0 == 1024 + 4 + 1
Negative numbers are written with a leading one instead of a leading
zero. So if you are using only 8 bits for your twos-compliment
numbers, then you treat patterns from "00000000" to "01111111" as
the whole numbers from 0 to 127, and reserve "1xxxxxxx" for writing
negative numbers. A negative number, -x, is written using the bit
pattern for (x-1) with all of the bits complimented (switched from 1
to 0 or 0 to 1). So -1 is compliment(1 - 1) = compliment(0) = "11111111",
and -10 is compliment(10 - 1) = compliment(9) = compliment("00001001")
= "11110110". This means that negative numbers go all the way down
to -128 ("10000000").
Of course, Python doesn't use 8-bit numbers. It USED to use however
many bits were native to your machine, but since that was non-portable,
it has recently switched to using an INFINITE number of bits. Thus
the number -5 is treated by bitwise operators as if it were written
"...1111111111111111111010".
Whew! With that preamble out of the way (and hey, you probably knew
this already), the operators are easy to explain.
x << y: Returns x with the bits shifted to the left by y places (and
new bits on the right-hand-side are zeros). This is the same
as multiplying x by 2**y.
x >> y: Returns x with the bits shifted to the right by y places.
This is the same as //'ing x by 2**y.
x & y: Does a "bitwise and". Each bit of the output is 1 if the
corresponding bit of x AND of y is 1, otherwise it's 0.
x | y: Does a "bitwise or". Each bit of the output is 0 if the
corresponding bit of x AND of y is 0, otherwise it's 1.
~ x: Returns the compliment of x - the number you get by switching
each 1 for a 0 and each 0 for a 1. This is the same as -x - 1.
x ^ y: Does a "bitwise exclusive or". Each bit of the output is
the same as the corresponding bit in x if that bit in y is
0, and it's the compliment of the bit in x if that bit in y
is 1.
Just remember about that infinite series of 1 bits in a negative
number, and these will all make sense.
One more point: Python allows operator overloading, so some classes
may be written to allow the bitwise operators, but with some other
meaning. For instance, the new sets module for Python 2.3 uses | and
& for union and intersection.
-- Michael Chermside