diff --git a/Doc/tutorial/controlflow.rst b/Doc/tutorial/controlflow.rst
--- a/Doc/tutorial/controlflow.rst
+++ b/Doc/tutorial/controlflow.rst
@@ -383,8 +383,8 @@
 Keyword Arguments
 -----------------
 
-Functions can also be called using keyword arguments of the form ``keyword =
-value``.  For instance, the following function::
+Functions can also be called using keyword arguments of the form
+``kwarg=value``.  For instance, the following function::
 
    def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
        print "-- This parrot wouldn't", action,
@@ -392,26 +392,30 @@
        print "-- Lovely plumage, the", type
        print "-- It's", state, "!"
 
-could be called in any of the following ways::
+accepts one :term:`positional argument` (``voltage``) and three
+:term:`keyword arguments <keyword argument>` (``state``, ``action``,
+and ``type``).  This function can be called in any of the following ways::
 
    parrot(1000)
-   parrot(action = 'VOOOOOM', voltage = 1000000)
-   parrot('a thousand', state = 'pushing up the daisies')
+   parrot(voltage=1000)
+   parrot(voltage=1000000, action='VOOOOOM')
+   parrot(action='VOOOOOM', voltage=1000000)
    parrot('a million', 'bereft of life', 'jump')
+   parrot('a thousand', state='pushing up the daisies')
 
-but the following calls would all be invalid::
+but all the following calls would be invalid::
 
-   parrot()                     # required argument missing
-   parrot(voltage=5.0, 'dead')  # non-keyword argument following keyword
+   parrot()                     # required positional argument missing
+   parrot(voltage=5.0, 'dead')  # non-keyword argument following keyword argument
    parrot(110, voltage=220)     # duplicate value for argument
-   parrot(actor='John Cleese')  # unknown keyword
+   parrot(actor='John Cleese')  # unknown keyword argument
 
-In general, an argument list must have any positional arguments followed by any
-keyword arguments, where the keywords must be chosen from the formal parameter
-names.  It's not important whether a formal parameter has a default value or
-not.  No argument may receive a value more than once --- formal parameter names
-corresponding to positional arguments cannot be used as keywords in the same
-calls. Here's an example that fails due to this restriction::
+In general, in an argument list, keyword arguments must follow positional
+arguments.  All the keyword arguments passed must match one of the arguments
+accepted by the function (e.g. ``actor`` is not a valid argument for the
+``parrot`` function).  This also includes positional arguments
+(e.g. ``parrot(voltage=1000)`` is valid too).  No argument may receive a value
+more than once. Here's an example that fails due to this restriction::
 
    >>> def function(a):
    ...     pass