More conversion to new-style optional args.
diff --git a/Doc/library/functions.rst b/Doc/library/functions.rst
index 23f5214..f0c7195 100644
--- a/Doc/library/functions.rst
+++ b/Doc/library/functions.rst
@@ -65,14 +65,14 @@
.. index:: pair: Boolean; type
-.. function:: bytearray([arg[, encoding[, errors]]])
+.. function:: bytearray([source[, encoding[, errors]]])
Return a new array of bytes. The :class:`bytearray` type is a mutable
sequence of integers in the range 0 <= x < 256. It has most of the usual
methods of mutable sequences, described in :ref:`typesseq-mutable`, as well
as most methods that the :class:`str` type has, see :ref:`bytes-methods`.
- The optional *arg* parameter can be used to initialize the array in a few
+ The optional *source* parameter can be used to initialize the array in a few
different ways:
* If it is a *string*, you must also give the *encoding* (and optionally,
@@ -91,7 +91,7 @@
Without an argument, an array of size 0 is created.
-.. function:: bytes([arg[, encoding[, errors]]])
+.. function:: bytes([source[, encoding[, errors]]])
Return a new "bytes" object, which is an immutable sequence of integers in
the range ``0 <= x < 256``. :class:`bytes` is an immutable version of
@@ -139,7 +139,7 @@
type hierarchy in :ref:`types`.
-.. function:: compile(source, filename, mode[, flags[, dont_inherit]])
+.. function:: compile(source, filename, mode, flags=0, dont_inherit=False)
Compile the *source* into a code or AST object. Code objects can be executed
by an :keyword:`exec` statement or evaluated by a call to :func:`eval`.
@@ -263,25 +263,26 @@
.. note::
Because :func:`dir` is supplied primarily as a convenience for use at an
- interactive prompt, it tries to supply an interesting set of names more than it
- tries to supply a rigorously or consistently defined set of names, and its
- detailed behavior may change across releases. For example, metaclass attributes
- are not in the result list when the argument is a class.
+ interactive prompt, it tries to supply an interesting set of names more
+ than it tries to supply a rigorously or consistently defined set of names,
+ and its detailed behavior may change across releases. For example,
+ metaclass attributes are not in the result list when the argument is a
+ class.
.. function:: divmod(a, b)
Take two (non complex) numbers as arguments and return a pair of numbers
- consisting of their quotient and remainder when using integer division. With mixed
- operand types, the rules for binary arithmetic operators apply. For integers,
- the result is the same as ``(a // b, a % b)``. For floating point
- numbers the result is ``(q, a % b)``, where *q* is usually ``math.floor(a / b)``
- but may be 1 less than that. In any case ``q * b + a % b`` is very close to
- *a*, if ``a % b`` is non-zero it has the same sign as *b*, and ``0 <= abs(a % b)
- < abs(b)``.
+ consisting of their quotient and remainder when using integer division. With
+ mixed operand types, the rules for binary arithmetic operators apply. For
+ integers, the result is the same as ``(a // b, a % b)``. For floating point
+ numbers the result is ``(q, a % b)``, where *q* is usually ``math.floor(a /
+ b)`` but may be 1 less than that. In any case ``q * b + a % b`` is very
+ close to *a*, if ``a % b`` is non-zero it has the same sign as *b*, and ``0
+ <= abs(a % b) < abs(b)``.
-.. function:: enumerate(iterable[, start=0])
+.. function:: enumerate(iterable, start=0)
Return an enumerate object. *iterable* must be a sequence, an
:term:`iterator`, or some other object which supports iteration. The
@@ -299,7 +300,7 @@
3 Winter
-.. function:: eval(expression[, globals[, locals]])
+.. function:: eval(expression, globals=None, locals=None)
The arguments are a string and optional globals and locals. If provided,
*globals* must be a dictionary. If provided, *locals* can be any mapping
@@ -550,18 +551,19 @@
case, a :exc:`TypeError` exception is raised.
-.. function:: iter(o[, sentinel])
+.. function:: iter(object[, sentinel])
- Return an :term:`iterator` object. The first argument is interpreted very differently
- depending on the presence of the second argument. Without a second argument, *o*
- must be a collection object which supports the iteration protocol (the
- :meth:`__iter__` method), or it must support the sequence protocol (the
- :meth:`__getitem__` method with integer arguments starting at ``0``). If it
- does not support either of those protocols, :exc:`TypeError` is raised. If the
- second argument, *sentinel*, is given, then *o* must be a callable object. The
- iterator created in this case will call *o* with no arguments for each call to
- its :meth:`__next__` method; if the value returned is equal to *sentinel*,
- :exc:`StopIteration` will be raised, otherwise the value will be returned.
+ Return an :term:`iterator` object. The first argument is interpreted very
+ differently depending on the presence of the second argument. Without a
+ second argument, *object* must be a collection object which supports the
+ iteration protocol (the :meth:`__iter__` method), or it must support the
+ sequence protocol (the :meth:`__getitem__` method with integer arguments
+ starting at ``0``). If it does not support either of those protocols,
+ :exc:`TypeError` is raised. If the second argument, *sentinel*, is given,
+ then *object* must be a callable object. The iterator created in this case
+ will call *object* with no arguments for each call to its :meth:`__next__`
+ method; if the value returned is equal to *sentinel*, :exc:`StopIteration`
+ will be raised, otherwise the value will be returned.
One useful application of the second form of :func:`iter` is to read lines of
a file until a certain line is reached. The following example reads a file
@@ -584,22 +586,23 @@
items. *iterable* may be either a sequence, a container that supports
iteration, or an iterator object. If *iterable* is already a list, a copy is
made and returned, similar to ``iterable[:]``. For instance, ``list('abc')``
- returns ``['a', 'b', 'c']`` and ``list( (1, 2, 3) )`` returns ``[1, 2, 3]``. If
- no argument is given, returns a new empty list, ``[]``.
+ returns ``['a', 'b', 'c']`` and ``list( (1, 2, 3) )`` returns ``[1, 2, 3]``.
+ If no argument is given, returns a new empty list, ``[]``.
:class:`list` is a mutable sequence type, as documented in :ref:`typesseq`.
+
.. function:: locals()
Update and return a dictionary representing the current local symbol table.
.. note::
- The contents of this dictionary should not be modified; changes may not affect
- the values of local variables used by the interpreter.
+ The contents of this dictionary should not be modified; changes may not
+ affect the values of local variables used by the interpreter.
- Free variables are returned by :func:`locals` when it is called in a function block.
- Modifications of free variables may not affect the values used by the
+ Free variables are returned by :func:`locals` when it is called in a function
+ block. Modifications of free variables may not affect the values used by the
interpreter. Free variables are not returned in class blocks.
@@ -666,7 +669,7 @@
:meth:`__index__` method that returns an integer.
-.. function:: open(file[, mode='r'[, buffering=None[, encoding=None[, errors=None[, newline=None[, closefd=True]]]]]])
+.. function:: open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True)
Open *file* and return a corresponding stream. If the file cannot be opened,
an :exc:`IOError` is raised.
@@ -812,7 +815,7 @@
must be of integer types, and *y* must be non-negative.
-.. function:: print([object, ...][, sep=' '][, end='\\n'][, file=sys.stdout])
+.. function:: print([object, ...], *, sep=' ', end='\\n', file=sys.stdout)
Print *object*\(s) to the stream *file*, separated by *sep* and followed by
*end*. *sep*, *end* and *file*, if present, must be given as keyword
@@ -828,7 +831,7 @@
is not present or ``None``, :data:`sys.stdout` will be used.
-.. function:: property([fget[, fset[, fdel[, doc]]]])
+.. function:: property(fget=None, fset=None, fdel=None, doc=None)
Return a property attribute.
@@ -987,7 +990,7 @@
for an alternate version that returns an iterator.
-.. function:: sorted(iterable[, key[, reverse]])
+.. function:: sorted(iterable[, key][, reverse])
Return a new sorted list from the items in *iterable*.
@@ -1103,7 +1106,8 @@
class C(B):
def method(self, arg):
- super().method(arg) # This does the same thing as: super(C, self).method(arg)
+ super().method(arg) # This does the same thing as:
+ # super(C, self).method(arg)
Note that :func:`super` is implemented as part of the binding process for
explicit dotted attribute lookups such as ``super().__getitem__(name)``.
@@ -1209,7 +1213,7 @@
True
-.. function:: __import__(name[, globals[, locals[, fromlist[, level]]]])
+.. function:: __import__(name, globals={}, locals={}, fromlist=[], level=-1)
.. index::
statement: import