python学习之lambda匿名函数

In [120]: def make_incrementor (n): return lambda x: x + n

In [121]: f = make_incrementor(2)

In [122]: g = make_incrementor(6)

In [123]: f
Out[123]: <function __main__.<lambda>>

In [124]: g
Out[124]: <function __main__.<lambda>>

In [125]: print(42)
42

In [126]: print f(42)
44

In [127]: print g(42)
48

In [133]: foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]

In [134]: print filter(lambda x: x % 3 == 0, foo)
[18, 9, 24, 12, 27]

In [135]: ?filter
Type:        builtin_function_or_method
String form: <built-in function filter>
Namespace:   Python builtin
Docstring:
filter(function or None, sequence) -> list, tuple, or string

Return those items of sequence for which function(item) is true.  If
function is None, return the items that are true.  If sequence is a tuple
or string, return the same type, else return a list.

In [136]: print filter(foo)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-136-a3d764429161> in <module>()
----> 1 print filter(foo)

TypeError: filter expected 2 arguments, got 1

In [137]: print filter(None,foo)
[2, 18, 9, 22, 17, 24, 8, 12, 27]

          ?map
Type:        builtin_function_or_method
String form: <built-in function map>
Namespace:   Python builtin
Docstring:
map(function, sequence[, sequence, ...]) -> list

Return a list of the results of applying the function to the items of
the argument sequence(s).  If more than one sequence is given, the
function is called with an argument list consisting of the corresponding
item of each sequence, substituting None for missing values when not all
sequences have the same length.  If the function is None, return a list of
the items of the sequence (or a list of tuples if more than one sequence).

In [140]: print map(lambda x: x* 2 + 100, foo)
[104, 136, 118, 144, 134, 148, 116, 124, 154]

In [141]: foo
Out[141]: [2, 18, 9, 22, 17, 24, 8, 12, 27]

In [142]: 

In [146]: print reduce(lambda x,y: x + y, foo)
139

In [147]: ?reduce
Type:        builtin_function_or_method
String form: <built-in function reduce>
Namespace:   Python builtin
Docstring:
reduce(function, sequence[, initial]) -> value

Apply a function of two arguments cumulatively to the items of a sequence,
from left to right, so as to reduce the sequence to a single value.
For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
((((1+2)+3)+4)+5).  If initial is present, it is placed before the items
of the sequence in the calculation, and serves as a default when the
sequence is empty.

In [148]: foo
Out[148]: [2, 18, 9, 22, 17, 24, 8, 12, 27]