Python运算符

算术运算符 

>>> 1+1 #加
2
>>> 2-2 #减
0
>>> 3*3 #乘
9
>>> 2**5 #乘方运算
32
>>> 4/4 #除
1.0
>>> 5//3 #整除取整
1
>>> 5%3 #整除取余数（或者叫取模）
2

#字符串的拼接
>>> 'hello'+'world' #运用+
'helloworld'
>>>'hello'*3 #运用*
'hellohellohello'
>>> 'hellohellohello'-'hello' #无法使用-
Traceback (most recent call last):
  File "<pyshell#163>", line 1, in <module>
    'hellohellohello'-'hello'
TypeError: unsupported operand type(s) for -: 'str' and 'str'

赋值运算符

>>> a=1 #将1赋值给变量a
>>> a+=1 #加法赋值运算，即a=a+1
>>> print(a)
2

>>> a=2
>>> b=3
>>> b+=a #加法赋值运算，即b=b+a
>>> print(b)
5
>>> b-=a #减法赋值运算，即b=b-a
>>> print(b)
3
>>> b*=a #乘法赋值运算，即b=b*a
>>> print(b)
6
>>> b**=a #幂赋值运算，即b=b**a
>>> print(b)
36
>>> b/=a #除法赋值运算，即b=b/a
>>> print(b)
18.0
>>> b//=a #取整除赋值运算，即b=b//a
>>> print(b)
9
>>> b%=a #取模（余数）赋值运算，即b=b//a
>>> print(b)
1

比较（关系）运算符

>>> a=1
>>> b=2
>>> a==b #变量a与变量b是否相等，返回布尔值
False
>>> a!=b #变量a与变量b是否不相等
True
>>> a>b #变量a是否大于变量b
False
>>> a<b #变量a是否小于变量b
True
>>> a>=b #变量a是否大于或等于变量b
False
>>> a<=b #变量a是否小于或等于变量b
True

>>> 'a'>'b' #单个字符组成的字符串型数据比较ascii码
False
>>> ord('a')
97
>>> ord('b')
98
>>> 'adc'<'bbd' #多个字符组成的字符串从左到右分别比较单个字符串的ascii码
True
>>> [0,2,0]<[1,0,1] #两个列表关系的比较：从左到右分别比较列表单个元素
True
>>> (0,2,2)<(1,2,0) #两个元组关系的比较：从左到右分别比较元组单个元素
True

一个综合分析

>>> a=1
>>> a+=a>=1 #比较（关系）运算符>=优先级高于赋值运算符+=
>>> print(a)
2
解释👇
# a+=a>=1
>>> print(a>=1)
True
# a+=True
>>> int(True)
1
# a+=1
>>> print(a)
2

逻辑运算符（操作和返回结构均是布尔类型）「逻辑运算符讲逻辑」

>>> True and True
True
>>> True and False
False
>>> True or False
True
>>> False or False
False
>>> not True
False
>>> not False
True

>>> not not True
True

#非布尔类型的逻辑运算
>>> [] and 0    #and运算：数据全False，结果为False「第一个数据为False，无需判断第二个数据是否为False」
[]  #实际意义为False
>>> 0 and 1     #and运算：数据有一False，结果为False「第一个数据为False，无需判断第二个数据是否为False」
0   #实际意义为False
>>> 1 and 0     #and运算：数据有一False，结果为False「第一个数据为True，需要判断第二个数据是否为False」
0   #实际意义为False
>>> 1 and 'a'   #and运算：数据全True，结果为True「第一个数据为True时，需判断第二个数据是否为True」
'a' #实际意义为True
>>> 'a' and 'b' #and运算：数据全True，结果为True「第一个数据为True时，需判断第二个数据是否为True」
'b' #实际意义为True

>>> 'a' or 'b' #or运算，数据全True，结果为True「第一个数据为True，无需判断第二个数据是否为True」
'a' #实际意义为True
>>> 1 or []    #or运算，数据有一True，结果为True「第一个数据为True，无需判断第二个数据是否为True」
1
>>> 0 or 1     #or运算，数据有一True，结果为True「第一个数据为False，需要判断第二个数据是否为True」
1
>>> '' or 0    #or运算，数据全False，结果为False「第一个数据为False，需要判断第二个数据是否为False」
0

>>> not 1
False
>>> not 'a'
False

>>> not ''  #空字符串、空列表、空元组、空集合、空字典均Python被认为是False;而数字型数据0表示False,1表示True
True
>>> not '0' #'0'表示非空字符串 
False
>>> [] or [1]
[1] #实际意义为True

成员运算符（一个元素是否在另外的一组元素中，返回结果为布尔值）

>>> 'h' in 'hello'
True
>>> a=1
>>> a not in [1,2,3]
False
>>> 3 in (1,2,3)
True
>>> {2,3} in {2,4,5}
False

#字典的成员关系运算针对的是字典的键key，而不是值
>>> a=3
>>> a in {1:'hi',2:'hello'}
False
>>> a=3
>>> a not in {1:'hi',2:'hello'}
True
>>> a='hi'
>>> a in {1:'hi',2:'hello'}
False
>>> a=1
>>> a in {1:'hi',2:'hello'} 
True

身份运算符（需要理解‘对象’，返回值为布尔值）

>>> 1 is 2
False
>>> 1 is 1
True
>>> a='hello'
>>> b='world'
>>> c='hello'
>>> a is b
False
>>> a is c
True
>>> b is not c
True

>>> a=1
>>> b=1.0
>>> a==b   #关系运算符比较的是两个变量的值
True
>>> a is b #身份运算符比较的是两个变量的身份id「内存地址是否相等」
False
>>> id(a)  #id()函数用于判断数据的内存地址
140596598675760
>>> id(b)
140596652127504

>>> a={1,2,3}
>>> b={2,1,3}
>>> a==b    #集合是无序的
True
>>> a is b  #a与b的内存地址不同
False
>>> a=(1,2,3)
>>> b=(2,1,3)
>>> a==b    #元组是有序的
False
>>> a is b  #a与b的内存地址不同
False

Python中，一切均为对象。‘对象’的3个特征：值value、身份id、类型type

#类型的判断
>>> a='1'
>>> type(a) 
<class 'str'>

>>> a='1'
>>> type(a)==int
False
>>> a='1'
>>> type(a)==str
True

#建议用以下函数
>>> a='1'
>>> isinstance(a,int)
False
>>> isinstance(a,str)
True
>>> isinstance(a,(int,str,float)) #isinstance()函数第二个参数可以设置为元组
True
>>> isinstance(a,(int,float))
False

位运算符（将数据「十进制」先转换为二进制数运算，然后再转回「十进制」）

&按位与运算符：参与运算的两个数据,如果相应的二进位的对应位都为1,则该位的结果为1,否则为0
>>> 0 & 1
0
>>> 1 & 2
0
>>> 2 & 3
2
>>> 60 & 80
16

&按位或运算符：参与运算的两个数据,如果相应的二进位的对应位只要有一个二进位为1,则该位的结果为1,否则为0
>>> 0 | 1
1
>>> 1 | 2
3
>>> 2 | 3
3
>>> 60 | 80
124

^按位异或运算符：参与运算的两个数据,如果相应的二进位的对应位相异时，则该位的结果为1,否则为0
>>> 0 ^ 1
1
>>> 1 ^ 2
3
>>> 2 ^ 3
1
>>> 60 ^ 80
108

~按位取反运算符:参与运算的数据,对每个数据相应的二进位取反，即把0变成1，1变成0「一个数与与自身的按位取反值相加等于-1，输入十进位数~x，输出结果为-x-1=-（x+1）」
#在Python中，输入和输出的数据一般为十进制数
#>>> 0b00111100 #二进制数转换为十进制数60
60
>>> bin(60) #十进制数60转换为二进制数
'0b111100'

>>> ~0b00111100 #利用60的二进制数按位取反运算
-61 #输出结果为十进制数-61「-（00111100+1）」
#>>> bin(-61)
'-0b111101' #十进制数-61转换为二进制数
#>>> -0b00111101 #二进制数转换为十进制数-61
-61

>>> ~60 #利用十进制数60按位取反运算
-61 #输出结果为十进制数-61「-60-1=-（60+1）」
>>> bin(60)
'0b111100' #理论上，a=00111100,~a=11000011，【知识点：二进制数,最高位为符号位「其余位为数值位，表示数值大小」，0表示正数,最高位为1表示负数】，在JavaScript内部采用负数补码的形式表示负数，即需要将此负数减去1，再取一次反「即把0变成1，1变成0」，然后加上负号，才能得到这个负数对应的十进制值
#推导如下
a=00111100 #二进制数a最高位是0，为正数
a的反码「即把0变成1，1变成0」：11000011 #a的反码最高位是1，为负数，需要采用补码形式表示
a的反码减1:11000010
（a的反码减1）后再取反：00111101 #取反后变为正数
加上负号：-00111101 #转换为十进位数即可
>>> -0b00111101
-61 #所以，~60输出结果为-61；a=0b00111100，~a输出结果为-61，即-0b00111101
#正数的反码、补码与其原码相同，负数的反码是「符号位保持1，其余数值位逐位取反」，负数的补码是在其反码的末尾加1
#已知负数原码，求补码「负数原码符号位1不变，数值位取反得到反码，反码数值位末尾加1得到补码」
#已知负数补码，求原码「负数补码数值位末尾减1得到反码，反码符号位1不变，数值位取反得到原码」

>>> bin(-61) #十进制数-61转换为二进制数
'-0b111101'
>>> 0b00111101 #二进制数转换为十进制数61
61
>>> -0b00111101 #二进制转换为十进制数-61
-61
>>> 0b11000011 #二进制数转换为十进制数195
195

<<左移动运算符：参与运算的数据,运算数的各二进位全部左移若干位，移动位数由<<右边的数字指定，「高位丢弃，低位补0」
>>> a=60
>>> a<<2
240
>>> bin(60)
'0b111100'
>>> bin(240)
'0b11110000' #补了两位0
>>> a=15
>>> a<<2
60
>>> bin(15)
'0b1111'
>>> bin(60)
'0b111100' #补了两位0

>>右移动运算符：参与运算的数据,运算数的各二进位全部右移若干位，移动位数由>>右边的数字指定，「高位丢弃，低位补0」
>>> a=60
>>> a>>2
15
>>> bin(60)
'0b111100'
>>> bin(15)
'0b1111' #舍弃两位0
>>> a=15
>>> a>>2
3
>>> bin(15)
'0b1111'
>>> bin(3)
'0b11' #舍弃两位1