https://github.com/python/cpython/commit/1d8f3ed2eba762e60a02ff87e782a5c7dcd0e77c
commit: 1d8f3ed2eba762e60a02ff87e782a5c7dcd0e77c
branch: main
author: Serhiy Storchaka <[email protected]>
committer: serhiy-storchaka <[email protected]>
date: 2025-12-05T16:22:38+02:00
summary:
gh-101100: Fix references to the set methods (GH-141857)
files:
M Doc/c-api/set.rst
M Doc/library/stdtypes.rst
M Doc/reference/datamodel.rst
M Doc/whatsnew/2.3.rst
diff --git a/Doc/c-api/set.rst b/Doc/c-api/set.rst
index cba823aa027bd6..09c0fb6b9c5f23 100644
--- a/Doc/c-api/set.rst
+++ b/Doc/c-api/set.rst
@@ -147,7 +147,7 @@ subtypes but not for instances of :class:`frozenset` or its
subtypes.
Return ``1`` if found and removed, ``0`` if not found (no action taken),
and ``-1`` if an
error is encountered. Does not raise :exc:`KeyError` for missing keys.
Raise a
- :exc:`TypeError` if the *key* is unhashable. Unlike the Python
:meth:`~frozenset.discard`
+ :exc:`TypeError` if the *key* is unhashable. Unlike the Python
:meth:`~set.discard`
method, this function does not automatically convert unhashable sets into
temporary frozensets. Raise :exc:`SystemError` if *set* is not an
instance of :class:`set` or its subtype.
diff --git a/Doc/library/stdtypes.rst b/Doc/library/stdtypes.rst
index 086da1a705c30f..3899e5b59d8852 100644
--- a/Doc/library/stdtypes.rst
+++ b/Doc/library/stdtypes.rst
@@ -4826,7 +4826,7 @@ other sequence-like behavior.
There are currently two built-in set types, :class:`set` and
:class:`frozenset`.
The :class:`set` type is mutable --- the contents can be changed using methods
-like :meth:`add <frozenset.add>` and :meth:`remove <frozenset.add>`.
+like :meth:`~set.add` and :meth:`~set.remove`.
Since it is mutable, it has no hash value and cannot be used as
either a dictionary key or as an element of another set.
The :class:`frozenset` type is immutable and :term:`hashable` ---
@@ -4848,164 +4848,172 @@ The constructors for both classes work the same:
objects. If *iterable* is not specified, a new empty set is
returned.
- Sets can be created by several means:
+Sets can be created by several means:
- * Use a comma-separated list of elements within braces: ``{'jack',
'sjoerd'}``
- * Use a set comprehension: ``{c for c in 'abracadabra' if c not in 'abc'}``
- * Use the type constructor: ``set()``, ``set('foobar')``, ``set(['a', 'b',
'foo'])``
+* Use a comma-separated list of elements within braces: ``{'jack', 'sjoerd'}``
+* Use a set comprehension: ``{c for c in 'abracadabra' if c not in 'abc'}``
+* Use the type constructor: ``set()``, ``set('foobar')``, ``set(['a', 'b',
'foo'])``
- Instances of :class:`set` and :class:`frozenset` provide the following
- operations:
+Instances of :class:`set` and :class:`frozenset` provide the following
+operations:
- .. describe:: len(s)
+.. describe:: len(s)
- Return the number of elements in set *s* (cardinality of *s*).
+ Return the number of elements in set *s* (cardinality of *s*).
- .. describe:: x in s
+.. describe:: x in s
- Test *x* for membership in *s*.
+ Test *x* for membership in *s*.
- .. describe:: x not in s
+.. describe:: x not in s
- Test *x* for non-membership in *s*.
+ Test *x* for non-membership in *s*.
- .. method:: isdisjoint(other, /)
+.. method:: frozenset.isdisjoint(other, /)
+ set.isdisjoint(other, /)
- Return ``True`` if the set has no elements in common with *other*. Sets
are
- disjoint if and only if their intersection is the empty set.
+ Return ``True`` if the set has no elements in common with *other*. Sets are
+ disjoint if and only if their intersection is the empty set.
- .. method:: issubset(other, /)
- set <= other
+.. method:: frozenset.issubset(other, /)
+ set.issubset(other, /)
+.. describe:: set <= other
- Test whether every element in the set is in *other*.
+ Test whether every element in the set is in *other*.
- .. method:: set < other
+.. describe:: set < other
- Test whether the set is a proper subset of *other*, that is,
- ``set <= other and set != other``.
+ Test whether the set is a proper subset of *other*, that is,
+ ``set <= other and set != other``.
- .. method:: issuperset(other, /)
- set >= other
+.. method:: frozenset.issuperset(other, /)
+ set.issuperset(other, /)
+.. describe:: set >= other
- Test whether every element in *other* is in the set.
+ Test whether every element in *other* is in the set.
- .. method:: set > other
+.. describe:: set > other
- Test whether the set is a proper superset of *other*, that is, ``set >=
- other and set != other``.
+ Test whether the set is a proper superset of *other*, that is, ``set >=
+ other and set != other``.
- .. method:: union(*others)
- set | other | ...
+.. method:: frozenset.union(*others)
+ set.union(*others)
+.. describe:: set | other | ...
- Return a new set with elements from the set and all others.
+ Return a new set with elements from the set and all others.
- .. method:: intersection(*others)
- set & other & ...
+.. method:: frozenset.intersection(*others)
+ set.intersection(*others)
+.. describe:: set & other & ...
- Return a new set with elements common to the set and all others.
+ Return a new set with elements common to the set and all others.
- .. method:: difference(*others)
- set - other - ...
+.. method:: frozenset.difference(*others)
+ set.difference(*others)
+.. describe:: set - other - ...
- Return a new set with elements in the set that are not in the others.
+ Return a new set with elements in the set that are not in the others.
- .. method:: symmetric_difference(other, /)
- set ^ other
+.. method:: frozenset.symmetric_difference(other, /)
+ set.symmetric_difference(other, /)
+.. describe:: set ^ other
- Return a new set with elements in either the set or *other* but not both.
+ Return a new set with elements in either the set or *other* but not both.
- .. method:: copy()
+.. method:: frozenset.copy()
+ set.copy()
- Return a shallow copy of the set.
+ Return a shallow copy of the set.
- Note, the non-operator versions of :meth:`union`, :meth:`intersection`,
- :meth:`difference`, :meth:`symmetric_difference`, :meth:`issubset`, and
- :meth:`issuperset` methods will accept any iterable as an argument. In
- contrast, their operator based counterparts require their arguments to be
- sets. This precludes error-prone constructions like ``set('abc') & 'cbs'``
- in favor of the more readable ``set('abc').intersection('cbs')``.
+Note, the non-operator versions of :meth:`~frozenset.union`,
+:meth:`~frozenset.intersection`, :meth:`~frozenset.difference`,
:meth:`~frozenset.symmetric_difference`, :meth:`~frozenset.issubset`, and
+:meth:`~frozenset.issuperset` methods will accept any iterable as an argument.
In
+contrast, their operator based counterparts require their arguments to be
+sets. This precludes error-prone constructions like ``set('abc') & 'cbs'``
+in favor of the more readable ``set('abc').intersection('cbs')``.
- Both :class:`set` and :class:`frozenset` support set to set comparisons. Two
- sets are equal if and only if every element of each set is contained in the
- other (each is a subset of the other). A set is less than another set if and
- only if the first set is a proper subset of the second set (is a subset, but
- is not equal). A set is greater than another set if and only if the first
set
- is a proper superset of the second set (is a superset, but is not equal).
+Both :class:`set` and :class:`frozenset` support set to set comparisons. Two
+sets are equal if and only if every element of each set is contained in the
+other (each is a subset of the other). A set is less than another set if and
+only if the first set is a proper subset of the second set (is a subset, but
+is not equal). A set is greater than another set if and only if the first set
+is a proper superset of the second set (is a superset, but is not equal).
- Instances of :class:`set` are compared to instances of :class:`frozenset`
- based on their members. For example, ``set('abc') == frozenset('abc')``
- returns ``True`` and so does ``set('abc') in set([frozenset('abc')])``.
+Instances of :class:`set` are compared to instances of :class:`frozenset`
+based on their members. For example, ``set('abc') == frozenset('abc')``
+returns ``True`` and so does ``set('abc') in set([frozenset('abc')])``.
- The subset and equality comparisons do not generalize to a total ordering
- function. For example, any two nonempty disjoint sets are not equal and
are not
- subsets of each other, so *all* of the following return ``False``: ``a<b``,
- ``a==b``, or ``a>b``.
+The subset and equality comparisons do not generalize to a total ordering
+function. For example, any two nonempty disjoint sets are not equal and are
not
+subsets of each other, so *all* of the following return ``False``: ``a<b``,
+``a==b``, or ``a>b``.
- Since sets only define partial ordering (subset relationships), the output
of
- the :meth:`list.sort` method is undefined for lists of sets.
+Since sets only define partial ordering (subset relationships), the output of
+the :meth:`list.sort` method is undefined for lists of sets.
- Set elements, like dictionary keys, must be :term:`hashable`.
+Set elements, like dictionary keys, must be :term:`hashable`.
- Binary operations that mix :class:`set` instances with :class:`frozenset`
- return the type of the first operand. For example: ``frozenset('ab') |
- set('bc')`` returns an instance of :class:`frozenset`.
+Binary operations that mix :class:`set` instances with :class:`frozenset`
+return the type of the first operand. For example: ``frozenset('ab') |
+set('bc')`` returns an instance of :class:`frozenset`.
- The following table lists operations available for :class:`set` that do not
- apply to immutable instances of :class:`frozenset`:
+The following table lists operations available for :class:`set` that do not
+apply to immutable instances of :class:`frozenset`:
- .. method:: update(*others)
- set |= other | ...
+.. method:: set.update(*others)
+.. describe:: set |= other | ...
- Update the set, adding elements from all others.
+ Update the set, adding elements from all others.
- .. method:: intersection_update(*others)
- set &= other & ...
+.. method:: set.intersection_update(*others)
+.. describe:: set &= other & ...
- Update the set, keeping only elements found in it and all others.
+ Update the set, keeping only elements found in it and all others.
- .. method:: difference_update(*others)
- set -= other | ...
+.. method:: set.difference_update(*others)
+.. describe:: set -= other | ...
- Update the set, removing elements found in others.
+ Update the set, removing elements found in others.
- .. method:: symmetric_difference_update(other, /)
- set ^= other
+.. method:: set.symmetric_difference_update(other, /)
+.. describe:: set ^= other
- Update the set, keeping only elements found in either set, but not in
both.
+ Update the set, keeping only elements found in either set, but not in both.
- .. method:: add(elem, /)
+.. method:: set.add(elem, /)
- Add element *elem* to the set.
+ Add element *elem* to the set.
- .. method:: remove(elem, /)
+.. method:: set.remove(elem, /)
- Remove element *elem* from the set. Raises :exc:`KeyError` if *elem* is
- not contained in the set.
+ Remove element *elem* from the set. Raises :exc:`KeyError` if *elem* is
+ not contained in the set.
- .. method:: discard(elem, /)
+.. method:: set.discard(elem, /)
- Remove element *elem* from the set if it is present.
+ Remove element *elem* from the set if it is present.
- .. method:: pop()
+.. method:: set.pop()
- Remove and return an arbitrary element from the set. Raises
- :exc:`KeyError` if the set is empty.
+ Remove and return an arbitrary element from the set. Raises
+ :exc:`KeyError` if the set is empty.
- .. method:: clear()
+.. method:: set.clear()
- Remove all elements from the set.
+ Remove all elements from the set.
- Note, the non-operator versions of the :meth:`update`,
- :meth:`intersection_update`, :meth:`difference_update`, and
- :meth:`symmetric_difference_update` methods will accept any iterable as an
- argument.
+Note, the non-operator versions of the :meth:`~set.update`,
+:meth:`~set.intersection_update`, :meth:`~set.difference_update`, and
+:meth:`~set.symmetric_difference_update` methods will accept any iterable as an
+argument.
- Note, the *elem* argument to the :meth:`~object.__contains__`,
- :meth:`remove`, and
- :meth:`discard` methods may be a set. To support searching for an
equivalent
- frozenset, a temporary one is created from *elem*.
+Note, the *elem* argument to the :meth:`~object.__contains__`,
+:meth:`~set.remove`, and
+:meth:`~set.discard` methods may be a set. To support searching for an
equivalent
+frozenset, a temporary one is created from *elem*.
.. _typesmapping:
diff --git a/Doc/reference/datamodel.rst b/Doc/reference/datamodel.rst
index ebadbc215a0eed..5f79c6fe8f50ff 100644
--- a/Doc/reference/datamodel.rst
+++ b/Doc/reference/datamodel.rst
@@ -449,7 +449,7 @@ Sets
These represent a mutable set. They are created by the built-in :func:`set`
constructor and can be modified afterwards by several methods, such as
- :meth:`add <frozenset.add>`.
+ :meth:`~set.add`.
Frozen sets
diff --git a/Doc/whatsnew/2.3.rst b/Doc/whatsnew/2.3.rst
index b7e4e73f4ce4aa..f43692b3dce9e8 100644
--- a/Doc/whatsnew/2.3.rst
+++ b/Doc/whatsnew/2.3.rst
@@ -66,7 +66,7 @@ Here's a simple example::
The union and intersection of sets can be computed with the
:meth:`~frozenset.union` and
:meth:`~frozenset.intersection` methods; an alternative notation uses the
bitwise operators
``&`` and ``|``. Mutable sets also have in-place versions of these methods,
-:meth:`!union_update` and :meth:`~frozenset.intersection_update`. ::
+:meth:`!union_update` and :meth:`~set.intersection_update`. ::
>>> S1 = sets.Set([1,2,3])
>>> S2 = sets.Set([4,5,6])
@@ -87,7 +87,7 @@ It's also possible to take the symmetric difference of two
sets. This is the
set of all elements in the union that aren't in the intersection. Another way
of putting it is that the symmetric difference contains all elements that are
in
exactly one set. Again, there's an alternative notation (``^``), and an
-in-place version with the ungainly name
:meth:`~frozenset.symmetric_difference_update`. ::
+in-place version with the ungainly name
:meth:`~set.symmetric_difference_update`. ::
>>> S1 = sets.Set([1,2,3,4])
>>> S2 = sets.Set([3,4,5,6])
_______________________________________________
Python-checkins mailing list -- [email protected]
To unsubscribe send an email to [email protected]
https://mail.python.org/mailman3//lists/python-checkins.python.org
Member address: [email protected]
