Skip to content

bpo-32118: Simplify docs for sequence comparison #15450

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Aug 24, 2019
Merged

bpo-32118: Simplify docs for sequence comparison #15450

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
5db1b13
bpo-32118: Simplify docs for sequence comparison
rhettinger Aug 24, 2019
10ce12c
Address the OP's question about 'None'
rhettinger Aug 24, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
26 changes: 7 additions & 19 deletions Doc/reference/expressions.rst
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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.
Expand All @@ -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:

Expand Down