二十一点

比较

Python 支持以下基本比较运算符：

它们的优先级都相同（高于布尔运算，但低于算术运算或位运算）。

不同数据类型之间的比较

类型不同的对象（数字类型除外）默认永远不会比较为相等。 class的非同一实例也不会比较为相等，除非该class定义了特殊的富比较方法，用来自定义默认的object比较行为。 通过rich comparisons进行自定义将在后续练习中介绍。 想了解这个主题的（更多）细节，请参阅 Python 文档中的值比较。

数字类型（大部分情况下）是这条类型匹配规则的例外。 只要类型可以为比较而隐式转换，integer可以被认为等于float（或者octal等于hexadecimal）。

对于 Python 标准库中的其他数字类型（复数、十进制数、分数），比较运算符只在“讲得通”的地方定义（也就是隐式转换不会改变结果的地方），但如果底层对象无法为了比较而准确转换，就会抛出TypeError。 想进一步了解 Python 进行数字转换的规则，请参阅 Python 文档中的算术转换。

>>> import fractions

# A string cannot be converted to an int.
>>> 17 == '17'
False

# An int can be converted to float for comparison.
>>> 17 == 17.0
True

# The fraction 6/3 can be converted to the int 2
# The int 2 can be converted to 0b10 in binary.
>>> 6/3 == 0b10
True

# An int can be converted to a complex number with a 0 imaginary part.
>>> 17 == complex(17)
True

# The fraction 2/5 can be converted to the float 0.4
>>> 0.4 == 2/5
True

>>> complex(2/5, 1/2) == complex(0.4, 0.5)
True

将数字与NaN（非数字）类型进行任何有序比较，结果都是False。 Python 对NaN的定义有一个令人困惑的副作用：NaN永远不会比较为等于NaN。

>>> x = float('NaN')

>>> 3 < x
False

>>> x < 3
False

# NaN never compares equal to NaN
>>> x == x
False

比较字符串

与数字不同，字符串（str）是按字典序比较的，依据的是它们各自的 Unicode 码位（也就是把str中每个码位传给内置函数ord()所得到的结果，该函数返回一个int）。 如果两个字符串中的所有码位都相同，并且顺序也一致，那么这两个字符串就被认为是相等的。 这种比较是“逐对”进行的：第一个对第一个，第二个对第二个，依此类推。 在 Python 3.x 中，str和bytes不能直接强制转换或比较。

>>> 'Python' > 'Rust'
False

>>> 'Python' > 'JavaScript'
True

# Examples with Mandarin.
# hello < goodbye
>>> '你好' < '再见'
True

# ord() of first characters
>>> ord('你'), ord('再')
(20320, 20877)

# ord() of second characters
>>> ord('好'), ord('见')
(22909, 35265)

# And with Korean words.
# Pretty < beautiful.
>>> '예쁜' < '아름다운'
False

>>> ord('예'), ord('아')
(50696, 50500)

比较链

比较运算符可以任意串联，也就是说可以用任意长度、任意组合来使用。 请注意，表达式的求值是从left到right进行的。

举例来说，x < y <= z等价于x < y and y <= z，区别在于y只求值一次。 这两种情况下，一旦发现x < y为False，z就完全不求值。 这通常被称为short-circuit evaluation：如果表达式的真值已经确定，求值就会停止。

Python 中的各种布尔运算符、函数以及比较链都支持Short circuiting。 与包括C、C++、C#和Java在内的许多其他编程语言不同，Python 中像a < b < c这样的链式表达式具有传统的数学解释和优先级。

>>> x = 2
>>> y = 5
>>> z = 10

>>> x < y < z
True

>>> x < y > z
False

>>> x > y < z
False

比较对象同一性

运算符is和is not测试的是对象的同一性，而不是对象的值。 对象的同一性在创建之后永远不会改变，可以通过id()函数获取。

当且仅当id(<apple>) == id(<orange>)时，<apple> is <orange>的求值结果为True。 <apple> is not <orange>则得出相反的结果。

由于None和NotImplemented都是单例，比较它们时应该始终使用is和is not。 关于这一惯例的更多细节，请参阅 Python 参考文档中的值比较和PEP8。

>>> my_fav_numbers = [1, 2, 3]

>>> your_fav_numbers = my_fav_numbers

>>> my_fav_numbers is your_fav_numbers
True

# The returned id will differ by system and python version.
>>> id(my_fav_numbers)
4517478208

# your_fav_numbers is only an alias pointing to the original my_fav_numbers object.
# Assigning a new name does not create a new object.
>>> id(your_fav_numbers)
4517478208


>>> my_fav_numbers is not your_fav_numbers
False

>>> my_fav_numbers is not None
True

>>> my_fav_numbers is NotImplemented
False

成员关系比较

运算符in和not in测试的是成员关系。 如果<fish>是<soup>的成员（也就是<fish>是<soup>的子集，或者包含在<soup>中），<fish> in <soup>的求值结果为True，否则为False。 <fish> not in <soup>返回的是否定结果，也就是<fish> in <soup>的相反结果。

对于字符串和 bytes 类型，当且仅当<name>是<fullname>的子串时，<name> in <fullname>为True。

# A set of lucky numbers.
>>> lucky_numbers = {11, 22, 33}
>>> 22 in lucky_numbers
True

>>> 44 in lucky_numbers
False

# A dictionary of employee information.
>>> employee = {'name': 'John Doe', 
                'id': 67826, 'age': 33, 
                'title': 'ceo'}

# Checking for the membership of certain keys.
>>> 'age' in employee
True

>>> 33 in employee
False

>>> 'lastname' not in employee
True

# Checking for substring membership
>>> name = 'Super Batman'
>>> 'Bat' in name
True

>>> 'Batwoman' in name
False