[Python-checkins] cpython (merge 3.3 -> default): merge with 3.3
georg.brandl
python-checkins at python.org
Sun Oct 6 10:47:43 CEST 2013
http://hg.python.org/cpython/rev/ae4ef03b0133
changeset: 86027:ae4ef03b0133
parent: 86023:ab7b5ba360e9
parent: 86026:b370cd67a677
user: Georg Brandl <georg at python.org>
date: Sun Oct 06 10:28:48 2013 +0200
summary:
merge with 3.3
files:
Doc/faq/design.rst | 10 +++++-----
Doc/reference/compound_stmts.rst | 10 +++++-----
Doc/reference/expressions.rst | 13 +++++++------
Doc/tutorial/controlflow.rst | 2 +-
4 files changed, 18 insertions(+), 17 deletions(-)
diff --git a/Doc/faq/design.rst b/Doc/faq/design.rst
--- a/Doc/faq/design.rst
+++ b/Doc/faq/design.rst
@@ -347,20 +347,20 @@
which has a completely redesigned interpreter loop that avoids the C stack.
-Why can't lambda forms contain statements?
-------------------------------------------
+Why can't lambda expressions contain statements?
+------------------------------------------------
-Python lambda forms cannot contain statements because Python's syntactic
+Python lambda expressions cannot contain statements because Python's syntactic
framework can't handle statements nested inside expressions. However, in
Python, this is not a serious problem. Unlike lambda forms in other languages,
where they add functionality, Python lambdas are only a shorthand notation if
you're too lazy to define a function.
Functions are already first class objects in Python, and can be declared in a
-local scope. Therefore the only advantage of using a lambda form instead of a
+local scope. Therefore the only advantage of using a lambda instead of a
locally-defined function is that you don't need to invent a name for the
function -- but that's just a local variable to which the function object (which
-is exactly the same type of object that a lambda form yields) is assigned!
+is exactly the same type of object that a lambda expression yields) is assigned!
Can Python be compiled to machine code, C or some other language?
diff --git a/Doc/reference/compound_stmts.rst b/Doc/reference/compound_stmts.rst
--- a/Doc/reference/compound_stmts.rst
+++ b/Doc/reference/compound_stmts.rst
@@ -536,17 +536,17 @@
by the parameters' names in the :attr:`__annotations__` attribute of the
function object.
-.. index:: pair: lambda; form
+.. index:: pair: lambda; expression
It is also possible to create anonymous functions (functions not bound to a
-name), for immediate use in expressions. This uses lambda forms, described in
-section :ref:`lambda`. Note that the lambda form is merely a shorthand for a
+name), for immediate use in expressions. This uses lambda expressions, described in
+section :ref:`lambda`. Note that the lambda expression is merely a shorthand for a
simplified function definition; a function defined in a ":keyword:`def`"
statement can be passed around or assigned to another name just like a function
-defined by a lambda form. The ":keyword:`def`" form is actually more powerful
+defined by a lambda expression. The ":keyword:`def`" form is actually more powerful
since it allows the execution of multiple statements and annotations.
-**Programmer's note:** Functions are first-class objects. A "``def``" form
+**Programmer's note:** Functions are first-class objects. A "``def``" statement
executed inside a function definition defines a local function that can be
returned or passed around. Free variables used in the nested function can
access the local variables of the function containing the def. See section
diff --git a/Doc/reference/expressions.rst b/Doc/reference/expressions.rst
--- a/Doc/reference/expressions.rst
+++ b/Doc/reference/expressions.rst
@@ -1218,8 +1218,8 @@
.. productionlist::
conditional_expression: `or_test` ["if" `or_test` "else" `expression`]
- expression: `conditional_expression` | `lambda_form`
- expression_nocond: `or_test` | `lambda_form_nocond`
+ expression: `conditional_expression` | `lambda_expr`
+ expression_nocond: `or_test` | `lambda_expr_nocond`
Conditional expressions (sometimes called a "ternary operator") have the lowest
priority of all Python operations.
@@ -1243,10 +1243,10 @@
pair: anonymous; function
.. productionlist::
- lambda_form: "lambda" [`parameter_list`]: `expression`
- lambda_form_nocond: "lambda" [`parameter_list`]: `expression_nocond`
+ lambda_expr: "lambda" [`parameter_list`]: `expression`
+ lambda_expr_nocond: "lambda" [`parameter_list`]: `expression_nocond`
-Lambda forms (lambda expressions) have the same syntactic position as
+Lambda expressions (sometimes called lambda forms) have the same syntactic position as
expressions. They are a shorthand to create anonymous functions; the expression
``lambda arguments: expression`` yields a function object. The unnamed object
behaves like a function object defined with ::
@@ -1255,7 +1255,8 @@
return expression
See section :ref:`function` for the syntax of parameter lists. Note that
-functions created with lambda forms cannot contain statements or annotations.
+functions created with lambda expressions cannot contain statements or
+annotations.
.. _exprlists:
diff --git a/Doc/tutorial/controlflow.rst b/Doc/tutorial/controlflow.rst
--- a/Doc/tutorial/controlflow.rst
+++ b/Doc/tutorial/controlflow.rst
@@ -588,7 +588,7 @@
Small anonymous functions can be created with the :keyword:`lambda` keyword.
This function returns the sum of its two arguments: ``lambda a, b: a+b``.
-Lambda forms can be used wherever function objects are required. They are
+Lambda functions can be used wherever function objects are required. They are
syntactically restricted to a single expression. Semantically, they are just
syntactic sugar for a normal function definition. Like nested function
definitions, lambda functions can reference variables from the containing
--
Repository URL: http://hg.python.org/cpython
More information about the Python-checkins
mailing list