traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

bpo-32118: Simplify docs for sequence comparison (GH-15450)

This commit is contained in:
Raymond Hettinger 2019-08-24 10:43:55 -07:00 committed by GitHub
parent 5e63ab05f1
commit edd21129dd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 7 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
Doc/reference/expressions.rst
View File

@ -1425,6 +1425,10 @@ built-in types.
themselves. For example, if ``x = float('NaN')``, ``3 < x``, ``x < 3``, ``x
== x``, ``x != x`` are all false. This behavior is compliant with IEEE 754.
* ``None`` and ``NotImplemented`` are singletons. :PEP:`8` advises that
comparisons for singletons should always be done with ``is`` or ``is not``,
never the equality operators.
* Binary sequences (instances of :class:`bytes` or :class:`bytearray`) can be
compared within and across their types. They compare lexicographically using
the numeric values of their elements.
@ -1442,25 +1446,9 @@ built-in types.
:exc:`TypeError`.
Sequences compare lexicographically using comparison of corresponding
elements, whereby reflexivity of the elements is enforced.
In enforcing reflexivity of elements, the comparison of collections assumes
that for a collection element ``x``, ``x == x`` is always true. Based on
that assumption, element identity is compared first, and element comparison
is performed only for distinct elements. This approach yields the same
result as a strict element comparison would, if the compared elements are
reflexive. For non-reflexive elements, the result is different than for
strict element comparison, and may be surprising: The non-reflexive
not-a-number values for example result in the following comparison behavior
when used in a list::
>>> nan = float('NaN')
>>> nan is nan
True
>>> nan == nan
False <-- the defined non-reflexive behavior of NaN
>>> [nan] == [nan]
True <-- list enforces reflexivity and tests identity first
elements. The built-in containers typically assume identical objects are
equal to themselves. That lets them bypass equality tests for identical
objects to improve performance and to maintain their internal invariants.
Lexicographical comparison between built-in collections works as follows: