[Python-checkins] python/dist/src/Doc/lib libfuncs.tex,1.120,1.121

[jvr@users.sourceforge.net]

Update of /cvsroot/python/python/dist/src/Doc/lib
In directory sc8-pr-cvs1:/tmp/cvs-serv31972/Doc/lib

Modified Files:
	libfuncs.tex 
Log Message:
Patch #642500 with slight modifications: allow keyword arguments in
dict() constructor. Example:
  >>> dict(a=1, b=2)
  {'a': 1, 'b': 2}
  >>>


Index: libfuncs.tex
===================================================================
RCS file: /cvsroot/python/python/dist/src/Doc/lib/libfuncs.tex,v
retrieving revision 1.120
retrieving revision 1.121
diff -C2 -d -r1.120 -r1.121
*** libfuncs.tex	19 Nov 2002 20:49:13 -0000	1.120
--- libfuncs.tex	23 Nov 2002 09:45:03 -0000	1.121
***************
*** 190,214 ****
  
  \begin{funcdesc}{dict}{\optional{mapping-or-sequence}}
!   Return a new dictionary initialized from the optional argument.
!   If an argument is not specified, return a new empty dictionary.
!   If the argument is a mapping object, return a dictionary mapping the
!   same keys to the same values as does the mapping object.
!   Else the argument must be a sequence, a container that supports
!   iteration, or an iterator object.  The elements of the argument must
!   each also be of one of those kinds, and each must in turn contain
    exactly two objects.  The first is used as a key in the new dictionary,
    and the second as the key's value.  If a given key is seen more than
    once, the last value associated with it is retained in the new
    dictionary.
    For example, these all return a dictionary equal to
!   \code{\{1: 2, 2: 3\}}:
  
    \begin{itemize}
!     \item \code{dict(\{1: 2, 2: 3\})}
!     \item \code{dict(\{1: 2, 2: 3\}.items())}
!     \item \code{dict(\{1: 2, 2: 3\}.iteritems())}
!     \item \code{dict(zip((1, 2), (2, 3)))}
!     \item \code{dict([[2, 3], [1, 2]])}
!     \item \code{dict([(i-1, i) for i in (2, 3)])}
    \end{itemize}
  
--- 190,221 ----
  
  \begin{funcdesc}{dict}{\optional{mapping-or-sequence}}
!   Return a new dictionary initialized from an optional positional
!   argument or from a set of keyword arguments.
!   If no arguments are given, return a new empty dictionary.
!   If the positional argument is a mapping object, return a dictionary
!   mapping the same keys to the same values as does the mapping object.
!   Otherwise the positional argument must be a sequence, a container that
!   supports iteration, or an iterator object.  The elements of the argument
!   must each also be of one of those kinds, and each must in turn contain
    exactly two objects.  The first is used as a key in the new dictionary,
    and the second as the key's value.  If a given key is seen more than
    once, the last value associated with it is retained in the new
    dictionary.
+ 
+   If keyword arguments are given, the keywords themselves with their
+   associated values are added as items to the dictionary. If a key
+   is specified both in the positional argument and as a keyword argument,
+   the value associated with the keyword is retained in the dictionary.
    For example, these all return a dictionary equal to
!   \code{\{"one": 2, "two": 3\}}:
  
    \begin{itemize}
!     \item \code{dict(\{'one': 2, 'two': 3\})}
!     \item \code{dict(\{'one': 2, 'two': 3\}.items())}
!     \item \code{dict(\{'one': 2, 'two': 3\}.iteritems())}
!     \item \code{dict(zip(('one', 'two'), (2, 3)))}
!     \item \code{dict([['two', 3], ['one', 2]])}
!     \item \code{dict(one=2, two=3)}
!     \item \code{dict([(['one', 'two'][i-2], i) for i in (2, 3)])}
    \end{itemize}