mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-09-30 20:31:52 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 11

bpo-16011: clarify that 'in' always returns a boolean value (GH-874)

Browse source 
(cherry picked from commit 0ae7c8bd61)
This commit is contained in:
Mariatta 2017-03-28 09:33:54 -07:00 • committed by GitHub
parent f01de61a8e
commit c4021af505
1 changed files with 10 additions and 9 deletions
Download patch file Download diff file Expand all files Collapse all files

19
Doc/reference/expressions.rst
View file

@ -1431,28 +1431,29 @@ Membership test operations
-------------------------- --------------------------
The operators :keyword:`in` and :keyword:`not in` test for membership. ``x in The operators :keyword:`in` and :keyword:`not in` test for membership. ``x in
s`` evaluates to true if *x* is a member of *s*, and false otherwise. ``x not s`` evaluates to ``True`` if *x* is a member of *s*, and ``False`` otherwise.
in s`` returns the negation of ``x in s``. All built-in sequences and set types ``x not in s`` returns the negation of ``x in s``. All built-in sequences and
support this as well as dictionary, for which :keyword:`in` tests whether the set types support this as well as dictionary, for which :keyword:`in` tests
dictionary has a given key. For container types such as list, tuple, set, whether the dictionary has a given key. For container types such as list, tuple,
frozenset, dict, or collections.deque, the expression ``x in y`` is equivalent set, frozenset, dict, or collections.deque, the expression ``x in y`` is equivalent
to ``any(x is e or x == e for e in y)``. to ``any(x is e or x == e for e in y)``.
For the string and bytes types, ``x in y`` is true if and only if *x* is a For the string and bytes types, ``x in y`` is ``True`` if and only if *x* is a
substring of *y*. An equivalent test is ``y.find(x) != -1``. Empty strings are substring of *y*. An equivalent test is ``y.find(x) != -1``. Empty strings are
always considered to be a substring of any other string, so ``"" in "abc"`` will always considered to be a substring of any other string, so ``"" in "abc"`` will
return ``True``. return ``True``.
For user-defined classes which define the :meth:`__contains__` method, ``x in For user-defined classes which define the :meth:`__contains__` method, ``x in
y`` is true if and only if ``y.__contains__(x)`` is true. y`` returns ``True`` if ``y.__contains__(x)`` returns a true value, and
``False`` otherwise.
For user-defined classes which do not define :meth:`__contains__` but do define For user-defined classes which do not define :meth:`__contains__` but do define
:meth:`__iter__`, ``x in y`` is true if some value ``z`` with ``x == z`` is :meth:`__iter__`, ``x in y`` is ``True`` if some value ``z`` with ``x == z`` is
produced while iterating over ``y``. If an exception is raised during the produced while iterating over ``y``. If an exception is raised during the
iteration, it is as if :keyword:`in` raised that exception. iteration, it is as if :keyword:`in` raised that exception.
Lastly, the old-style iteration protocol is tried: if a class defines Lastly, the old-style iteration protocol is tried: if a class defines
:meth:`__getitem__`, ``x in y`` is true if and only if there is a non-negative :meth:`__getitem__`, ``x in y`` is ``True`` if and only if there is a non-negative
integer index *i* such that ``x == y[i]``, and all lower integer indices do not integer index *i* such that ``x == y[i]``, and all lower integer indices do not
raise :exc:`IndexError` exception. (If any other exception is raised, it is as raise :exc:`IndexError` exception. (If any other exception is raised, it is as
if :keyword:`in` raised that exception). if :keyword:`in` raised that exception).