Python内置类型(3)——比较

python有8种比较运算符:<、<=、>、>=、==、!=、is、is not，它们具有相同的优先级。它们具体的含义如下：

运算符	含义
<	小于
<=	小于或等于
>	大于
>=	大于或等于
==	等于
!=	不等于
is	是否同一个对象
is not	是否不是同一个对象

比较运算符有如下一些特性：

相同类型间的2个不同对象都能进行比较

# 整形
>>> 2 > 1
True
>>> 2 >= 1
True
>>> 2 < 1
False
>>> 2 <= 1
False
>>> 2 == 1
False
>>> 2 != 1
True
>>> 2 is 1
False
>>> 2 is not 1
True

# 字符串
>>> 'a' > 'b'
False
>>> 'a' >= 'b'
False
>>> 'a' < 'b'
True
>>> 'a' <= 'b'
True
>>> 'a' == 'b'
False
>>> 'a' != 'b'
True
>>> a is 'b'
False
>>> a is not 'b'
True

# 序列类型
>>> (1,2) > (2,3)
False
>>> (1,2) >= (2,3)
False
>>> (1,2) < (2,3)
True
>>> (1,2) <= (2,3)
True
>>> (1,2) == (2,3)
False
>>> (1,2) != (2,3)
True
>>> (1,2) is (2,3)
False
>>> (1,2) is not (2,3)
True

大小比较运算符只能在类型相同的2个对象间比较，不同的类型进行比较会报语法错误

# 类型相同的对象间可以比较大小
>>> 1 >= 0
True
>>> 'a' < 'b'
True
>>> (1,2) > (1,1)
True

# 类型不相同的对象间不可以比较大小
>>> 1 >= '1'
Traceback (most recent call last):
  File "<pyshell#15>", line 1, in <module>
    1 >= '1'
TypeError: unorderable types: int() > str()
>>> (1,2) <= [1,2]
Traceback (most recent call last):
  File "<pyshell#16>", line 1, in <module>
    (1,2) <= [1,2]
TypeError: unorderable types: tuple() >= list()

同是数值类型，整形类型对象和浮点型对象间可以比较大小，复数类型对象和整形或者浮点型对象不能比较大小

# 整形类型对象和浮点型对象间可以比较大小
>>> 2.1 > 2
True
>>> -1.1 < 0
True

# 复数类型对象和整形或者浮点型对象不能比较大小
>>> 1 + 1j > 1
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    1 + 1j > 1
TypeError: unorderable types: complex() > int()

不同类型间的对象间可以进行相等==和!=比较，结果均不相等

>>> 1 == "1"
False

>>> 1 == (1)
False

>>> 1 == [1]
False

整数类型和浮点数类型间的对象相等比较时，如果两个对象的数值相同，则结果相等

>>> 1 == 1.0
True

自定义类的2个实例对象都是不相等的，它们之间不能比较大小

>>> class Man():
    def __init__(self,name):
        self.name = name

>>> a = Man('xiaoming')
>>> b = Man('xiaoming')
>>> a == b
False
>>> a != b
True
>>> a > b
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    a > b
TypeError: unorderable types: Man() > Man()

自定义类如果实现了__eq__()方法，则可进行相等比较，相等比较结果是__eq__()方法执行返回的结果；不等比较的结果则优先看自定义是否实现了__ne__()方法，如果有实现则不等比较结果是__ne__()方法执行返回的结果，否则是相等比较结果取反后的值

# 实现__eq__
>>> class Man():

    def __init__(self,name):
        self.name = name

    def __eq__(self,other):
        return self.name == other.name

>>> a = Man('xiaoming')
>>> b = Man('xiaoming')
>>> a == b # 实现了__eq__方法
True
>>> a != b # 实现了__eq__方法，是相等比较结果的取反后结果
False

# 同时实现__eq__和__ne__
>>> class Man():
    def __init__(self,name):
        self.name = name

    def __eq__(self,other):
        return self.name == other.name

    def __ne__(self,other):
        return False

>>> a = Man('ming')
>>> b = Man('ming')
>>> a == b
True
>>> a != b
False
# 不能进行大小比
>>> a > b
Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    a>b
TypeError: unorderable types: Man() > Man()

类似的，如果自定义类实现了__lt __（），__le __（），__gt __（）和__ge __（）相关方法，则自定义类的不同实例间可以进行大小比较，一般来说，实现__lt __（）和__le __（）2个方法就足够了，这样实例对象就可以进行比较判断了

>>> class Man():

    def __init__(self,name):
        self.name = name

    def __le__(self,other):
        return self.name <= other.name

    def __lt__(self,other):
        return self.name < other.name

>>> a = Man('a')
>>> b = Man('b')
>>> a > b
False
>>> a >= b
False
>>>

is和is not运算符，用来比较2个对象是否含有一样的数值或者指向的是否是同1个对象，它们无法自定义；也可以应用于任何两个对象，从不引发异常。

# 相同类型的对象
>>> 1 is 1
True
>>> 1 is 1.0
False

# 不同类型的对象
>>> 1 is '1'
False
>>> 1 is not '1'
True

# 类的不同实例对象
>>> a = object()
>>> b = object()
>>> a is b
False

in和not in运算符，用来在1个对象是否在序列中，而且只能用于序列类型。

>>> '1' in '12'
True

>>> '1' in (1,2,3)
False

​