众所周知 , java中的运算符 , 都是针对八大基本数据类型的(当然String 可以用 + 实现字符的连接) , 而在学习python的过程中 , 我发现python的set集合 , 居然也支持位运算 , 比如:

set_1 = set("asdfghj")
set_2 = set('zxascff')
print( set_1 & set_2)
print( set_1 | set_2)
print( set_1 ^ set_2)

好奇心驱使下 , 我写了几行测试代码 , 想看一看python中的六个标准类型 , 是不是都能和数字一样 , 使用这些运算符 .
python中的运算符 , 大致分为以下几类:

  1. 算术运算符
  2. 比较（关系）运算符
  3. 赋值运算符
  4. 逻辑运算符
  5. 位运算符
  6. 成员运算符
  7. 身份运算符

其中:

  • 赋值运算符中 , 所有类型都支持 = 赋值 , 其他赋值方式 , 等同于 = 和算术运算符的结合 , 所以只测试算术运算符即可 ;
  • 逻辑运算符 , 其实就是True和False的判断 , 而在python中 , 一切非 0 的对象 , 都被当做True ,所以六种类型都支持该运算符 , 这里也不再测试 ;
  • 身份运算符 , is 和 is not , 比较的是存储单元,也就是 id(obj) , 相当于java中Object的 == 和 != ,这在两种语言中, 都是对所有类型的对象生效的 , 这里就不做测试了, 而python中的 == 和 !=, 对于六个标准类型来说 , 比较的是对象中的值 .

先上测试代码( #注释掉的代码表示报错 , 不支持该类型操作) :
先是Number型:

print("Number型")
aa = 3
bb = 2
# 算数运算符
print(aa + bb )
print(aa - bb )
print(aa * bb )
print(aa / bb )
print(aa % bb )
print(aa ** bb )
print(aa // bb )
# 比较运算符
print(aa  == bb)
print(aa != bb)
print(aa > bb)
print(aa < bb)
print(aa >= bb)
print(aa <= bb)
#位运算符
print(aa & bb)
print(aa | bb)
print(aa ^ bb)
print(aa >> bb)
print(aa << bb)
print(~aa)
#成员运算符 , 不支持!!!
#print(2 in 22)
#print(3 not in 22)
print("String型")
str_1 = "aaa"
str_2 = "aab"
# 算数运算符
print(str_1 + str_2 )   #字符串拼接
#print(str_1 - str_2 )
print(str_1 * 2 )       #相当于多个字符串相加
#print(str_1 * str_2 )
#print(str_1 / str_2 )
#print(str_1 % str_2 )
#print(str_1 ** str_2 )
#print(str_1 // str_2 )
# 比较运算符
print(str_1  == str_2)  
print(str_1 != str_2)
print(str_1 > str_2)    #大小比较是按照字符从前到后
print(str_1 < str_2)    #一个一个比较转化为ascii的大小
print(str_1 >= str_2)   #如果第一个就比较出来大小 , 后边不再比较
print(str_1 <= str_2)
#位运算符
#print(str_1 & str_2)
#print(str_1 | str_2)
#print(str_1 ^ str_2)
#print(str_1 >> str_2)
#print(str_1 << str_2)
#print(~str_1)
#成员运算符
print("a" in str_1)
print("a" not in str_1)
print("列表型")
list_1 = [1 , [3 , "a"] , "aa" , 1]
list_2 = [1 , [3 , "a"] , "bb" ]
# 算数运算符
print(list_1 + list_2 ) #两个列表组合在一起的新列表
#print(list_1 - list_2 )
print(list_1 * 2 )      #相当于多个列表相加
#print(list_1 * list_2 )
#print(list_1 / list_2 )
#print(list_1 % list_2 )
#print(list_1 ** list_2 )
#print(list_1 // list_2 )
# 比较运算符
print(list_1  == list_2)
print(list_1 != list_2)
print(list_1 > list_2)      #大小比较 , 索引位置相同的元素做比较
print(list_1 < list_2)      #在比较出来结果之前的所有元素,必须类型相同 , 如果内嵌有其他元素, 也必须相同
print(list_1 >= list_2) #比如例子中 ,如果吧list_2 的 元素1改为"1" ,则报错
print(list_1 <= list_2) #直到某一个索引位置的两个元素比较出大小 ,之后的元素没有类型要求

#位运算符
#print(list_1 & list_2)
#print(list_1 | list_2)
#print(list_1 ^ list_2)
#print(list_1 >> list_2)
#print(list_1 << list_2)
#print(~list_1)
#成员运算符
print("aa" in list_1)
print("aa" not in list_1)
print("元组型")
tuple_1 = (1 , (3 , "3") , "aa" , 1)
tuple_2 = (1 , (3 , "2") , "bb" )
# 算数运算符
print(tuple_1 + tuple_2 )   #两个元组组合在一起的新元组
#print(tuple_1 - tuple_2 )
print(tuple_1 * 2 )     #相当于多个元组相加
#print(tuple_1 * tuple_2 )
#print(tuple_1 / tuple_2 )
#print(tuple_1 % tuple_2 )
#print(tuple_1 ** tuple_2 )
#print(tuple_1 // tuple_2 )
# 比较运算符
print(tuple_1  == tuple_2)
print(tuple_1 != tuple_2)
print(tuple_1 > tuple_2)        #大小比较 , 索引位置相同的元素做比较
print(tuple_1 < tuple_2)        #在比较出来结果之前的所有元素,类型必须相同 , 如果内嵌有其他元素, 也必须相同
print(tuple_1 >= tuple_2)   #比如例子中 ,如果吧tuple_2 的 元素1改为"1" ,则报错
print(tuple_1 <= tuple_2)   #直到某一个索引位置的两个元素比较出大小 ,之后的元素没有类型要求

#位运算符
#print(tuple_1 & tuple_2)
#print(tuple_1 | tuple_2)
#print(tuple_1 ^ tuple_2)
#print(tuple_1 >> tuple_2)
#print(tuple_1 << tuple_2)
#print(~tuple_1)
#成员运算符
print("aa" in tuple_1)
print("aa" not in tuple_1)
print("集合型")
set_1 = {1 , 2 , "aa" ,4}
set_2 = {1 , 3 , "aa" }
# 算数运算符
#print(set_1 + set_2 )
print(set_1 - set_2 )   # 差集 1中有 2中没有的元素组成的新集合
#print(set_1 * 2 )
#print(set_1 * set_2 )
#print(set_1 / set_2 )
#print(set_1 % set_2 )
#print(set_1 ** set_2 )
#print(set_1 // set_2 )
# 比较运算符
print(set_1  == set_2)
print(set_1 != set_2)
print(set_1 > set_2)        # 如果两个集合不相同, 除了 != 其他比较符都为False
print(set_1 < set_2)        # 如果两个集合相同 , == 和 >= <= 都为True
print(set_1 >= set_2)       # > 和< 对于集合没有意义 
print(set_1 <= set_2)

#位运算符
print(set_1 & set_2)    #逻辑与为交集组成的集合
print(set_1 | set_2)    #逻辑或为并集组成的集合
print(set_1 ^ set_2)    #逻辑异或为两集合中不相同的元素组成的集合
#print(set_1 >> set_2)
#print(set_1 << set_2)
#print(~set_1)
#成员运算符
print("aa" in set_1)
print("aa" not in set_1)
print("字典型")
dict_1 = {"id" : 1 , "name" : "lzc"}
dict_2 = {"id":  2 , "job" : "java" }
# 算数运算符
#print(dict_1 + dict_2 )
#print(dict_1 - dict_2 )
#print(dict_1 * 2 )
#print(dict_1 * dict_2 )
#print(dict_1 / dict_2 )
#print(dict_1 % dict_2 )
#print(dict_1 ** dict_2 )
#print(dict_1 // dict_2 )
# 比较运算符
print(dict_1  == dict_2)
print(dict_1 != dict_2)
#print(dict_1 > dict_2)
#print(dict_1 < dict_2)     
#print(dict_1 >= dict_2)         
#print(dict_1 <= dict_2)

#位运算符
#print(dict_1 & dict_2) 
#print(dict_1 | dict_2) 
#print(dict_1 ^ dict_2)
#print(dict_1 >> dict_2)
#print(dict_1 << dict_2)
#print(~dict_1)
#成员运算符
print("id" in dict_1)   #字典的in 和 not in 判断的是键
print("id" not in dict_1)

由以上测试可以总结几点:

  1. Number支持所有其他类型的运算符 ( 以下不再包括Number )
  2. 算术运算符中 , String、元组、列表 仅支持 + 和 ( *整型 ) , set 仅支持 - (取差集) , 字典不支持任何算术运算符
  3. 位运算符中, 集合仅Set支持 “&”(交集)、”|” (并集)、”^”(不同集) , 其他类型都不支持位运算符
  4. 成员运算符, 除了Number不支持, 其他类型都支持 in 和 not in
  5. 比较运算符中 , String支持所有比较运算符 , 元组、列表支持但是有限制 , 比较大小的时候 , 在未比较出来大小前 , 相同下标的元素类型必须一致 , 在某一个元素比较出来大小之后 , 后续将不再比较 , 也没有类型限制 ,如果内嵌有其他序列类型 , 比较方式同上 , set也支持所有比较运算符 ,但是只有 == 和 != 有意义 (>=、<= 中的 = 同 == ) , “<” 和 “>” 没有任何实际意义 , 但是也不会报错 .