def double_everything_in(data):     result = []     for i in data:         result.append(2 * i)     return result  def quadruple_everything_in(data):     result = []     for i in data:         result.append(4 * i)     return result  double_everything_in([1, 2, 3, 4, 5])  [2, 4, 6, 8, 10]  quadruple_everything_in([1, 2, 3, 4, 5])  [4, 8, 12, 16, 20]

• 上述代码没有很好的践行软件工程中“不要重复自己”的原则。
• 应该如何避免重复呢？

def multiply_by_x_everything_in(x, data):     result = []     for i in data:         result.append(x * i)     return result  multiply_by_x_everything_in(2, [1, 2, 3, 4, 5]) [2, 4, 6, 8, 10] multiply_by_x_everything_in(4, [1, 2, 3, 4, 5]) [4, 8, 12, 16, 20]

• 再考虑下面的代码

def squared(x):     return x*x  def double(x):     return x*2  def square_everything_in(data):     result = []     for i in data:         result.append(squared(i))     return result  def double_everything_in(data):     result = []     for i in data:         result.append(double(i))     return result  square_everything_in([1, 2, 3, 4, 5]) [1, 4, 9, 16, 25] double_everything_in([1, 2, 3, 4, 5]) [2, 4, 6, 8, 10]

• 应该如何避免重复呢

把函数作为值

def apply_f_to_everything_in(f, data): 
    result = [] 
    for x in data: 
        result.append(f(x)) 
    return result 
apply_f_to_everything_in(squared, [1, 2, 3, 4, 5]) 
[1, 4, 9, 16, 25] 
apply_f_to_everything_in(double, [1, 2, 3, 4, 5]) 
[2, 4, 6, 8, 10]

• Lambda表达式：每次想用map的时候又不得不定义一个函数的时候可以用匿名函数。

apply_f_to_everything_in(lambda x: x*x, [1, 2, 3, 4, 5])

Python’s map function

map(lambda x: x*x, [1, 2, 3, 4, 5]) 
[1, 4, 9, 16, 25]

def foldl(f, data, z): 
    if (len(data) == 0): 
        print z 
        return z 
    else: 
        head = data[0] 
        tail = data[1:] 
        print "Folding", head, "with", tail, "using", z 
        partial_result = f(z, data[0]) 
        print "Partial result is", partial_result 
        return foldl(f, tail, partial_result)  
 
def add(x, y): 
    return x + y 
 
foldl(add, [1, 2, 3, 4, 5], 0) 
 
 
Folding 1 with [2, 3, 4, 5] using 0 
Partial result is 1 
Folding 2 with [3, 4, 5] using 1 
Partial result is 3 
Folding 3 with [4, 5] using 3 
Partial result is 6 
Folding 4 with [5] using 6 
Partial result is 10 
Folding 5 with [] using 10 
Partial result is 15 
15

foldl(lambda x, y: x + y, [1, 2, 3, 4, 5], 0) 
 
Folding 1 with [2, 3, 4, 5] using 0 
Partial result is 1 
Folding 2 with [3, 4, 5] using 1 
Partial result is 3 
Folding 3 with [4, 5] using 3 
Partial result is 6 
Folding 4 with [5] using 6 
Partial result is 10 
Folding 5 with [] using 10 
Partial result is 15 
15

reduce(lambda x, y: x + y, [1, 2, 3, 4, 5]) 
15 
reduce(lambda x, y: x - y, [1, 2, 3, 4, 5], 0) 
-15 

def perform_computation(f, result, data, i):     print "Computing the ", i, "th result..."     # This could be scheduled on a different CPU     result[i] = f(data[i])  def my_map(f, data):     result = [None] * len(data)     for i in range(len(data)):         perform_computation(f, result, data, i)     # Wait for other CPUs to finish, and then..     return result  my_map(lambda x: x * x, [1, 2, 3, 4, 5])  Computing the  0 th result... Computing the  1 th result... Computing the  2 th result... Computing the  3 th result... Computing the  4 th result... [1, 4, 9, 16, 25]

A multi-threaded map function

from threading import Thread  def schedule_computation_threaded(f, result, data, threads, i):         # Each function evaluation is scheduled on a different core.     def my_job():          print "Processing data:", data[i], "... "         result[i] = f(data[i])         print "Finished job #", i             print "Result was", result[i]             threads[i] = Thread(target=my_job)      def my_map_multithreaded(f, data):     n = len(data)     result = [None] * n     threads = [None] * n     print "Scheduling jobs.. "     for i in range(n):         schedule_computation_threaded(f, result, data, threads, i)     print "Starting jobs.. "     for i in range(n):         threads[i].start()     print "Waiting for jobs to finish.. "     for i in range(n):         threads[i].join()     print "All done."     return result  my_map_multithreaded(lambda x: x*x, [1, 2, 3, 4, 5])  Scheduling jobs..  Starting jobs..  Processing data: 1 ...  Finished job # 0 Result was 1 Processing data: 2 ...  Finished job # 1 Result was 4 Processing data: 3 ...  Finished job # 2 Result was 9 Processing data: 4 ...  Finished job # 3 Result was 16 Processing data: 5 ...  Finished job # 4 Result was 25 Waiting for jobs to finish..  All done. [1, 4, 9, 16, 25]

from numpy.random import uniform 
from time import sleep 
 
def a_function_which_takes_a_long_time(x): 
    sleep(uniform(2, 10))  # Simulate some long computation 
    return x*x 
 
my_map_multithreaded(a_function_which_takes_a_long_time, [1, 2, 3, 4, 5]) 
 
Scheduling jobs..  
Starting jobs..  
Processing data: 1 ...  
Processing data: 2 ...  
Processing data: 3 ...  
Processing data: 4 ...  
Processing data: 5 ...  
Waiting for jobs to finish..  
Finished job # 4 
Result was 25 
Finished job # 0 
Result was 1 
Finished job # 3 
Result was 16 
Finished job # 2 
Result was 9 
Finished job # 1 
Result was 4 
All done. 
Out[31]: 
[1, 4, 9, 16, 25]