关系运算符
 
①关系运算符等级
②逻辑运算符
③按位运算符
总结
 

 
①关系运算符等级
 
a. > <
 b. >= <=
 c. == !=
 可以用来比较大小 长短等
 
②逻辑运算符
 
 
③按位运算符
 
 
总结
 

 
python 按位运算符
 

  

  

 
 
Python bitwise operators are used to perform bitwise calculations on integers. The integers are converted into binary format and then operations are performed bit by bit, hence the name bitwise operators.
 
 Python按位运算符用于对整数执行按位计算。 整数转换为二进制格式，然后逐位执行运算，因此命名为按位运算符。 
 
 
Python bitwise operators work on integers only and the final output is returned in the decimal format. Python bitwise operators are also called binary operators.
 
 Python按位运算符仅对整数起作用，并且最终输出以十进制格式返回。 Python按位运算符也称为二进制运算符。 
 
 

 
 
 
 Python按位运算符 (Python Bitwise Operators)
 
 
There are 6 bitwise operators in Python. The below table provides short details about them.
 
 Python中有6个按位运算符。 下表提供了有关它们的简短详细信息。 
 
 
Bitwise Operator
Description
Simple Example
&
Bitwise AND Operator
10 & 7 = 2
|
Bitwise OR Operator
10 | 7 = 15
^
Bitwise XOR Operator
10 ^ 7 = 13
~
Bitwise Ones’ Compliment Operator
~10 = -11
<<
Bitwise Left Shift operator
10<<2 = 40
>>
Bitwise Right Shift Operator
10>>1 = 5
 
 按位运算符 
 描述 
 简单的例子 
 和 
 按位与运算符 
 10＆7 = 2 
 | 
 按位或运算符 
 10 | 7 = 15 
 ^ 
 按位XOR运算符 
 10 ^ 7 = 13 
 〜 
 按位补码运算符 
 〜10 = -11 
 << 
 按位左移运算符 
 10 << 2 = 40 
 >> 
 按位右移运算符 
 10 >> 1 = 5 
 
 
Let’s look into these operators one by one and understand how they work.
 
 让我们逐一研究这些运算符，并了解它们的工作方式。 
 
 
 1.按位与运算符 (1. Bitwise AND Operator)
 
 
Python bitwise and operator returns 1 if both the bits are 1, otherwise 0.
 
 如果两个位均为1，Python按位运算符将返回1，否则返回0。 
 
 
>>> 10&7
2
>>>
 

  
  
Python Bitwise And Operator
  
 Python按位与运算符 
 
  

   

   

  
 
 
 2.按位或运算符 (2. Bitwise OR Operator)
 
 
Python bitwise or operator returns 1 if any of the bits is 1. If both the bits are 0, then it returns 0.
 
 如果任何位为1，Python按位或运算符将返回1。如果两个位均为0，则它​​将返回0。 
 
 
>>> 10|7
15
>>>
 

  
  
Python Bitwise Or Operator
  
 Python按位或运算符 
 
 
 
 3.按位XOR运算符 (3. Bitwise XOR Operator)
 
 
Python bitwise XOR operator returns 1 if one of the bits is 0 and the other bit is 1. If both the bits are 0 or 1, then it returns 0.
 
 如果位之一为0，另一位为1，则Python按位XOR运算符将返回1。如果两个位均为0或1，则它将返回0。 
 
 
>>> 10^7
13
>>>
 

  
  
Python Bitwise XOR Operator
  
 Python按位XOR运算符 
 
  

   

   

  
 
 
 4.按位补码运算符 (4. Bitwise Ones’ Complement Operator)
 
 
Python Ones’ complement of a number ‘A’ is equal to -(A+1).
 
 Python Ones的数字'A'的补码等于-（A + 1）。 
 
 
>>> ~10
-11
>>> ~-10
9
>>>
 

  
  
Python Bitwise Ones Complement Operator
  
 Python逐位补码运算符 
 
 
 
 5.按位左移运算符 (5. Bitwise Left Shift Operator)
 
 
Python bitwise left shift operator shifts the left operand bits towards the left side for the given number of times in the right operand. In simple terms, the binary number is appended with 0s at the end.
 
 Python按位左移运算符将右操作数中的给定次数向左移动左操作数位。 简而言之，二进制数末尾带有0。 
 
 
>>> 10 << 2
40
>>>
 

  
  
Python Bitwise Left Shift Operator
  
 Python按位左移运算符 
 
 
 
 6.按位右移运算符 (6. Bitwise Right Shift Operator)
 
 
Python right shift operator is exactly the opposite of the left shift operator. Then left side operand bits are moved towards the right side for the given number of times. In simple terms, the right side bits are removed.
 
 Python的右移运算符与左移运算符完全相反。 然后将左侧操作数位向右侧移动给定次数。 简单来说，右侧位已删除。 
 
 
>>> 10 >> 2
2
>>>
 

  
  
Python Bitwise Right Shift Operator
  
 Python按位右移运算符 
 
 
 
 Python按位运算符重载 (Python Bitwise Operator Overloading)
 
 
Python supports operator overloading. There are various methods that we can implement to support bitwise operators for our custom objects.
 
 Python支持运算符重载。 我们可以实现多种方法来支持自定义对象的按位运算符。 
 
 
Bitwise Operator
Method to Implement
&
__and__(self, other)
|
__or__(self, other)
^
__xor__(self, other)
~
__invert__(self)
<<
__lshift__(self, other)
>>
__rshift__(self, other)
 
 按位运算符 
 实施方法 
 和 
 __和__（自己，其他） 
 | 
 __或__（自己，其他） 
 ^ 
 __xor __（自己，其他） 
 〜 
 __invert __（个体经营） 
 << 
 __lshift __（自己，其他） 
 >> 
 __rshift __（自己，其他） 
 
 
Here is an example of a bitwise operator overloading for our custom object.
 
 这是我们的自定义对象按位运算符重载的示例。 
 
 
class Data:
    id = 0

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

    def __and__(self, other):
        print('Bitwise AND operator overloaded')
        if isinstance(other, Data):
            return Data(self.id & other.id)
        else:
            raise ValueError('Argument must be object of Data')

    def __or__(self, other):
        print('Bitwise OR operator overloaded')
        if isinstance(other, Data):
            return Data(self.id | other.id)
        else:
            raise ValueError('Argument must be object of Data')

    def __xor__(self, other):
        print('Bitwise XOR operator overloaded')
        if isinstance(other, Data):
            return Data(self.id ^ other.id)
        else:
            raise ValueError('Argument must be object of Data')

    def __lshift__(self, other):
        print('Bitwise Left Shift operator overloaded')
        if isinstance(other, int):
            return Data(self.id << other)
        else:
            raise ValueError('Argument must be integer')

    def __rshift__(self, other):
        print('Bitwise Right Shift operator overloaded')
        if isinstance(other, int):
            return Data(self.id >> other)
        else:
            raise ValueError('Argument must be integer')

    def __invert__(self):
        print('Bitwise Ones Complement operator overloaded')
        return Data(~self.id)

    def __str__(self):
        return f'Data[{self.id}]'


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<<2 = {d1<<2}')
print(f'd1>>2 = {d1>>2}')
print(f'~d1 = {~d1}')
 
Output:
 
 输出： 
 
 
Bitwise AND operator overloaded
d1&d2 = Data[2]
Bitwise OR operator overloaded
d1|d2 = Data[15]
Bitwise XOR operator overloaded
d1^d2 = Data[13]
Bitwise Left Shift operator overloaded
d1<<2 = Data[40]
Bitwise Right Shift operator overloaded
d1>>2 = Data[2]
Bitwise Ones Complement operator overloaded
~d1 = Data[-11]
 

  f-strings in Python.
  Python中的f-strings 。 
 
 
 摘要 (Summary)
 
 
Python bitwise operators are mostly used in mathematical calculations. We can implement specific methods to support bitwise operators for our custom class implementations too.
 
 Python按位运算符通常用于数学计算。 我们也可以实现特定的方法来为我们的自定义类实现支持按位运算符。 
 
 

  
翻译自: https://www.journaldev.com/26737/python-bitwise-operators
 
 
python 按位运算符

 java位运算符详讲


 一、位运算符分类
    java中位运算符主要有：按位与&、按位或|、按位非~、按位异或^。
 在使用时，需要将运算数都转换为二进制再进行运算，若为负数则使用补码表示。
二、位运算符使用方式
    1、按位与&
 



     使用规则：全一则一，否则为零。
    eg：计算7&-5的结果
    第一步：byte中的二进制
       7的二进制
       被除数    除数    商    余数
        7         2      3      1
        3         2      1      1
        1         2      0      1
        7的二进制为：00000111


        -5的二进制
        被除数    除数    商    余数
        5         2      2      1
        2         2      1      0
        1         2      0      1
        -5的二进制为：10000101
        -5的补码为：  11111010  + 1   11111011


         00000111&11111011：


         00000111
        11111011
        00000011——>对应十进制的3


 
    ②、按位或|


 
    使用规则：全0为0，否则为1；
    eg：byte位的 2|-6
    2的二进制位：  0000 0010
    -6的二进制位：1000 0110
    -6的补码：       1111 1010
    运算结果：       1111 1010
    计算原码：       1000 0110
    相当于十进制位的：-6
    
 ③、按位非~



 
  使用规则：遇0则1，遇1则0；
  eg：~-6
  -6的二进制位：1000 0110
  -6的补码：       1111 1010
  计算结果：       0000 0101
  相当于十进制：5
  注意：按位非是单目运算符。
 ④、按位异或^
     使用规则：相同位0，否则为1；
  eg：2^-6
  2的二进制位：  0000 0010
  -6的二进制位：1000 0110
  -6的补码：       1111 1010
  计算结果：       1111 1000
  原码：              1000 1000
  相当于十进制位：-8；


 
三、位运算的意义
    二进制运算符，包括位运算符和移位运算符，使程序员可以在二进制基础上操作数字，可以更有效的进行运算，
 并且可以以二进制的形式存储和转换数据，是实现网络协议解析以及加密等算法的基础。
 
    
 
     

JAVA的运算符，分为四类：
算数运算符、关系运算符、逻辑运算符、位运算符
算数运算符(9)：+  -  *  /  %  ++  --
关系运算符(6)：==  !=  >  >=  <  <=
逻辑运算符(6)：&&  ||  !  ^  &  |
位运算符(7)：&  |  ~  ^  >>  <<  >>>；
 
Java基本数据类型：
数值类型：
整型：byte、short、int、long
非整型：double、float
非数值类型：char[字符]、boolean[布尔]
 
一：算数运算符：
注：算数运算符操作数必须是数值类型。
分为一元运算符和二元运算符；
一元运算符，只有一个操作数；
二元运算符有两个操作数，运算符在两个操作数之间。
一元运算符：正‘+’，负‘-’，自加‘++’，自减‘--‘这四个。
①”++“和”--“运算符，只允许用于数值类型的变量，不允许用于表达式中；
    "++"和”--“可以用于数值变量之前或者之后；
    两处使用差别：
           ”++“和”--“用于数值变量之前，在赋值操作中，先对被”++“或”--“操作变量值先加1或者先减1，然后在进行其他的操作；
           "++"和”--“用于数值变量之后，在赋值操作中，先用被”++“或”--“的操作变量值进行其他的操作，然后在对其值加1或者减1。
 

 

  
 
 
 1     package com.numerical;  
 2       
 3     public class Operator {  
 4         public static void main(String[] args) {  
 5             int a = 5;  
 6             int b,c,d,f,g,h;  
 7             b = +a; //正值  
 8             System.out.println("b="+b+",a="+a);  
 9             c = -a; //负值  
10             System.out.println("c="+c+",a="+a);  
11             int l = 2;  
12             d = ++l; //先l=l+1;再d=l  
13             System.out.println("d="+d+",l="+l);  
14             int m = 3;  
15             f = m++;//先f=m;再m=m+1  
16             System.out.println("f="+f+",m="+m);  
17             int n = 4;  
18             g = --n;//先n=n-1;再g=n  
19             System.out.println("g="+g+",n="+n);  
20             int o = 6;  
21             h = o--;//先h=o;再o=o-1  
22             System.out.println("h="+h+",o="+o);  
23         }  
24     }  
 

  
 

上代码，输出结果为：
b=5,a=5
c=-5,a=5
d=3,l=3
f=3,m=4
g=3,n=3
h=6,o=5

注：一元运算符和前后的操作数之间有空格，可能在有些编译器下编译时会出错。
 
2.二元运算符，加'+'，减'-'，乘'*'，除'/'，求余'%'。
在算数运算符中，”+“，”-“，”*“，”/“完成加减乘除四则运算，%是求两个操作数相除后的余数。
运算规则和数学运算基本相同，在算数运算中，计算时按照从左向右的顺序计算，乘除和求余优先于加减，不同的是，程序中的乘运算符不可省略，在数学中可写为”y=2x“而程序中必须写为”y=2*x“。
当二元运算的两个操作数的数据类型不同时，运算结果的数据类型和参与运算的操作数的数据类型中精度较高(或位数较长)一致。

 

  
 
 
1 1 int a = 3;  
2 2 double b = 3.53;//或者3.53d  
3 3 float c = 1.7f;  
4 4 int d = 1;  
5 5 System.out.println("int /int :a/d="+a/d);  
6 6 System.out.println("double/int:b/a="+b/a);  
7 7 System.out.println("float/int:c/a="+c/a);
 

  
 

输出结果为：
int /int :a/d=3
double/int:b/a=1.1766666666666665
float/int:c/a=0.56666666

转换原则：
    从低精度向高精度转换byte 、short、int、long、float、double

        低精度到高精度会自动转换，而高精度到低精度则要类型强制转换。
 1 int a = 7; 2 double b = 5.33; 3 b = a; 4 a = (int) b;  
 
计算机的数据长度:
位：一个二进制数据0或1，是1bit(位)；
字节：存储空间的计量单位,是1byte = 8bit；如数据库的VARCHAR为字节；   
 

 

  
 
 
1 boolean 类型变量的取值有：ture、false,1字节（8位）  
2 char数据类型有：unicode字符,16位  
3 byte：一个字节（8位）（-128~127）（-2的7次方到2的7次方-1）  
4 short：两个字节（16位）（-32768~32767）（-2的15次方到2的15次方-1）  
5 int：四个字节（32位）（一个字长）（-2147483648~2147483647）（-2的31次方到2的31次方-1）  
6 long：八个字节（64位）（-9223372036854774808~9223372036854774807）（-2的63次方到2的63次方-1）  
7 float：四个字节（32位）（3.402823e+38 ~ 1.401298e-45）（e+38是乘以10的38次方，e-45是乘以10的负45次方）  
8 double：八个字节（64位）（1.797693e+308~ 4.9000000e-324）
 

  
 

 
 对应java的基本数据类类型：Integer、Float、Boolean、Character、Double、Short、Byte、Long
注意：
①数值计算中语法现象——“晋升”，即：byte、short和char(低于int的数据类型)进行算术运算后，结果会自动提升成int类型；
②两个char型运算时，自动转换为int型；当char与别的类型运算时，也会先自动转换为int型的，再做其它类型的自动转换；
③算数运算可以加入小括号"()"提高优先级，优先小括号内运算，再其他运算符运算；
④算数运算前操作数变量必须赋值，反之，报语法错误。
 
 二：关系运算符：
关系运算符用于比较两个数值之间的大小，其运算结果为一个逻辑类型(boolean布尔类型)的数值。

等于'=='，不等于'!='，大于'>'，大于等于'>='，小于'<'，小于等于'<='
以下代码为：
 

 
1     System.out.println("9.5<8 :"+(9.5<8));  
2     System.out.println("8.5<=8.5:"+(8.5<=8.5));  
3     System.out.println("a~z："+((int)'a')+"~"+((int)'z'));  
4     System.out.println("A~Z："+((int)'A')+"~"+((int)'Z'));  
5     System.out.println("'A' < 'a':"+('A' < 'a'));//字符'A'的Unicode编码值小于字符'a'  

 
 
 
 输出结果为:

9.5<8 :false
8.5<=8.5:true
a~z：97~122
A~Z：65~90
'A' < 'a':true

注： boolean类型只能比较相等和不相等，不能比较大小；

     >=的意思是大于或等于，两者成立一个即可,结果为true，<=亦如此；
     判断相等的符号是两个等号，而不是一个等号，这个需要特别小心。
     实际代码中，数值、变量以及运算结果都可以直接参与比较，只是程序中为了增强可读性，有些时候需要将比较分开进行书写。
     比较运算符是程序设计中实现数据比较的基础，也是很多逻辑实现的基础，在程序逻辑中，经常通过比较一定的条件，来判断后续的程序该如何执行。

三：逻辑运算符：
逻辑运算符要求操作数的数据类型为逻辑型，其运算结果也是逻辑型值。
逻辑运算的数据和逻辑运算符的运算结果是boolean类型。
 逻辑与'&&'，逻辑或'||'，逻辑非'!'，逻辑异或'^'，逻辑与'&'，逻辑或'|'

逻辑运算符的真值表：

A和B是逻辑运算的两个逻辑变量；
两种逻辑与（&&和&）的运算规则基本相同，两种逻辑或（||和|）的运算规则也基本相同。
&和|运算是把逻辑表达式全部计算完，而&&和||运算具有短路计算功能。
对于&来说，如果左侧条件为false，也会计算右侧条件的值，而对于&&来说，如果左侧的条件为false，则不计算右侧的条件，这种现象被称作短路现象。
所谓短路计算，是指系统从左至右进行逻辑表达式的计算，一旦出现计算结果已经确定的情况，则计算过程即被终止。
对于&&运算来说，只要运算符左端的值为false，则因无论运算符右端的值为true或为false，其最终结果都为false。
所以，系统一旦判断出&&运算符左端的值为false，则系统将终止其后的计算过程；
对于 || 运算来说，只要运算符左端的值为true，则因无论运算符右端的值为true或为false，其最终结果都为true。
所以，系统一旦判断出|| 运算符左端的值为true，则系统将终止其后的计算过程。 

利用短路现象：
在程序设计时使用&&和||运算符，不建议使用&和|运算符。 
四：位运算符：
位运算是以二进制位为单位进行的运算，其操作数和运算结果都是整型值。 
位与'&'，位或'|'，位非'~'，位异或'^'，右移'>>'，左移'<<'，0填充的右移'>>>' 
位运算的位与'&'，位或'|'，位非'~'，位异或'^'与逻辑运算的相应操作的真值表完全相同，其差别只是位运算操作的操作数和运算结果都是二进制整数，而逻辑运算相应操作的操作数和运算结果都是逻辑值boolean型。


下边为位&运算：
    int a = 15;    //x等于二进制数的00001111
    int b = 6;     //y等于二进制数的00000110
    int c = x&y    //z等于二进制数的00000110

二进制数的00000110
右移是将一个二进制数按指定移动的位数向右移位，移掉的被丢弃，左边移进的部分或者补0（当该数为正时），或者补1（当该数为负时）。这是因为整数在机器内部采用补码表示法，正数的符号位为0，负数的符号位为1。
     将一个数左移"<<"会使该值乘以2的幂。
　　 将一个数右移>>"会使该值除以2的幂。
　　 右移（补零）运算符，即无符号右移，">>>"永远不会产生负号，因为其符号位总是被补零。 不论被移动数是正数还是负数，左边移进的部分一律补0。
 1 System.out.println(1<<3); 2 System.out.println(8>>3);  


 
    int x = 70;   //x等于二进制数的01000110
    int y = 2;
    int z = x>>y  //z等于二进制数的00010001
    即运算结果为z等于二进制数00010001，即z等于十进制数17。
    int x = -70;  //x等于二进制数的11000110
    int y = 2;
    int z = x>>y  //z等于二进制数的11101110
    即运算结果为z等于二进制数11101110，即z等于十进制数-18。
    右移和左移操作，是整数机器数的补码表示法。
&运算符规定必须信号A和B都被充电，其结果才是充电。(1表示充电，0表示未充电)
^异或（XOR）运算符规定如果信号A或B之一被充电，但是信号A和B不是同时被充电，则结果为充电。
~运算符也称为按位求补，它翻转所有的充电状态值。

五：赋值运算符与其他运算符的简捷使用方式 ：

① 赋值运算符可以与二元算术运算符、逻辑运算符和位运算符组合成简捷运算符，从而可以简化一些常用表达式的书写。

 
在程序开发中，大量使用“一元运算符或移位运算符等”该区别简化代码的书写，这样做，因为这样将增加阅读代码的难度，尽量注释。

② 方括号[]和圆括号（）运算符 

 方括号[]是数组运算符，方括号[]中的数值是数组的下标，整个表达式就代表数组中该下标所在位置的元素值。

 圆括号（）运算符用于改变表达式中运算符的优先级。

 
    String [] sa = {"a","b","c","d"};  
    System.out.println(sa[2]);  

 
 输出为：c ③ 字符串加（+）运算符 
当操作数是字符串时，加（+）运算符用来合并两个字符串；当加（+）运算符的一边是字符串，另一边是数值时，机器将自动将数值转换为字符串，并连接为一个字符串。

 
String a ="aa";  
int c = 555;  
String b = a+"bbb"+c;  
System.out.println(b); 

 
 输出为：aabbb555
 
④ 条件运算符(三目运算符)
    <表达式1> ？<表达式2> : <表达式3> 
先计算<表达式1>的值，
当<表达式1>的值为true时，则将<表达式2>的值作为整个表达式的值；
当<表达式1>的值为false时，则将<表达式3>的值作为整个表达式的值。

 
    int a = 55,b = 132,res;  
    res = a > b ? a : b;  
    System.out.println(res);  



 输出为：132
 
⑤强制类型转换符
强制类型转换符能将一个表达式的类型强制转换为某一指定数据类型
 

 
1     int a;  
2     double b = 5.66600;  
3     a = (int) b;  
4     System.out.println(a);  

 输出为：5
 
运算符优先级表


优先级自上而下，级别由高到低。