mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-10-29 17:38:56 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 8

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

Browse source
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
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 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. == 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 * Binary sequences (instances of :class:`bytes` or :class:`bytearray`) can be
compared within and across their types. They compare lexicographically using compared within and across their types. They compare lexicographically using
the numeric values of their elements. the numeric values of their elements.
@ -1442,25 +1446,9 @@ built-in types.
:exc:`TypeError`. :exc:`TypeError`.
Sequences compare lexicographically using comparison of corresponding Sequences compare lexicographically using comparison of corresponding
elements, whereby reflexivity of the elements is enforced. elements. The built-in containers typically assume identical objects are
equal to themselves. That lets them bypass equality tests for identical
In enforcing reflexivity of elements, the comparison of collections assumes objects to improve performance and to maintain their internal invariants.
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
Lexicographical comparison between built-in collections works as follows: Lexicographical comparison between built-in collections works as follows: