python语言支持哪些类型的运算符_python 六个标准类型都支持哪些运算符?

众所周知 , 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中的运算符 , 大致分为以下几类:

算术运算符

比较(关系)运算符

赋值运算符

逻辑运算符

位运算符

成员运算符

身份运算符

其中:

赋值运算符中 , 所有类型都支持 = 赋值 , 其他赋值方式 , 等同于 = 和算术运算符的结合 , 所以只测试算术运算符即可 ;

逻辑运算符 , 其实就是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)

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

Number支持所有其他类型的运算符 ( 以下不再包括Number )

算术运算符中 , String、元组、列表 仅支持 + 和 ( *整型 ) , set 仅支持 - (取差集) , 字典不支持任何算术运算符

位运算符中, 集合仅Set支持 “&”(交集)、”|” (并集)、”^”(不同集) , 其他类型都不支持位运算符

成员运算符, 除了Number不支持, 其他类型都支持 in 和 not in

比较运算符中 , String支持所有比较运算符 , 元组、列表支持但是有限制 , 比较大小的时候 , 在未比较出来大小前 , 相同下标的元素类型必须一致 , 在某一个元素比较出来大小之后 , 后续将不再比较 , 也没有类型限制 ,如果内嵌有其他序列类型 , 比较方式同上 , set也支持所有比较运算符 ,但是只有 == 和 != 有意义 (>=、<= 中的 = 同 == ) , “” 没有任何实际意义 , 但是也不会报错 .