Question

我有一个很长的管道，它对字符串列表input_list进行各种操作。管道将每个单词映射为小写，替换下划线，过滤掉特定单词，删除重复项和剪辑到一定长度。

result = list(set(filter(lambda x : x != word, map(lambda x : x.lower().replace('_',' '), input_list))))[:clip_length]

我的问题是它的可读性不高：它不太清楚这个管道的输入是什么以及应用了什么顺序的操作。看起来有点痛，我可能不知道它后来会做什么，除非它得到很好的评论。

有没有办法在python中编写管道，我可以清楚地看到哪些操作以什么顺序发生，进入的内容和出现的内容？更具体地说，我希望能够编写它，以便操作从右到左或从左到右，而不是从内到外。

Answer 1

这种功能风格，你可以从最里面的表达到最外面的阅读。

将其放在包含一些注释的多行上有助于提高可读性：

result = list(                                # (5) convert to list
  set(                                        # (4) convert to set (remove dupes)
    filter(
      lambda x: x != word,                    # (3) filter items != to word
      map(
        lambda x: x.lower().replace('_',' '), # (2) apply transformation
        input_list                            # (1) take input_list
      )
    )
  )
)[:clip_length]                               # (6) limit number of results

这是品味问题。我倾向于选择像这样的单个表达式，使用最小的格式来使其适合：

result = list(set(filter(lambda x : x != word,
    map(lambda x : x.lower().replace('_',' '), input_list))))[:clip_length]

等效的命令式处理是：

result = set()
for x in input_list:
    x = x.lower().replace('_', ' ')
    if x != word:
        result.add(x)
result = list(result)[:clip_length]

Answer 2

它有功能，但没有（一致）风格。 “问题”是用于这些表达式的各种语法。

使用普通前缀表示法f(arg)
获取子数组使用特殊语法arr[n?:m?]，而不是函数slice(n,m)
set是一个完全不同的类型，但是它被中间使用，因为集合恰好具有我们想要的行为的某些 - 我们想要的是可迭代的“唯一”元素，所以我们的函数应该被称为unique。如果我们碰巧使用unique来实施set，那很好，但这并不是读者的关注，他们的思想没有这种干扰
x.lower()是一个动态调用，lower位于中缀位置。与前缀位置lower(x)比较。这同样适用于s.replace(pat,rep) vs replace(s, pat, rep)
map和filter但确实有功能界面map(f,iter)和filter(f,iter)

但要编写一个类似于你所分享的程序，有点错过了功能风格最强大，最通用的特性：功能。是的，函数式编程也是关于编写漂亮的表达式链，但不以牺牲可读性为代价！如果可读性开始受到伤害，请使用...功能：D

考虑使用统一功能样式的程序。它仍然是一个常规的python程序。

def program (word = '', clip_length = 5, input = ''):
  make_words = \
    compose ( lower
            , partial (replace, '_', ' ')
            )

  process = \
    compose ( partial (map, make_words)
            , partial (filter, lambda x: x != word)
            , unique
            , partial (take, clip_length)
            )

  return process (input)

print (program ('b', 4, 'A_a_a_B_b_b_c_c_c_d_e'))
# ['d', ' ', 'e', 'a']
# Note, your output may vary. More on this later.

现在依赖。每个函数仅对其参数进行操作并返回输出。

def partial (f, *xs):
  return lambda *ys: f (*xs, *ys)

def compose (f = None, *fs):
  def comp (x):
    if f is None:
      return x
    else:
      return compose (*fs) (f (x))
  return comp

def take (n = 0, xs = []):
  return xs [:n]

def lower (s = ''):
  return s .lower ()

def replace (pat = '', rep = '', s = ''):
  return s .replace (pat, rep)

def unique (iter):
  return list (set (iter))

真的，这个问题无法为这些要点设置一个更好的舞台。我将重新考虑原始问题（以及上面的程序）中使用的set的选择，因为存在一个很大的问题：如果你多次重新运行我们的程序，我们将得到一个不同的输出。用更高级的话说，我们没有referential transparency。那是因为Python的集合是无序的，当我们从有序列表转换为集合，然后返回到列表时，不能保证我们总是得到相同的元素。

使用set这种方式显示了如何使用现有语言功能解决唯一问题的良好直觉，但我们希望恢复参照透明度。在我们上面的程序中，我们通过调用它上面的unique函数清楚地编码了我们获取输入唯一元素的意图。

# deterministic implementation of unique
def unique (iter):
  result = list ()
  seen = set ()
  for x in iter:
    if x not in seen:
      seen .add (x)
      result .append (x)
  return result

现在，当我们运行程序时，总是得到相同的结果

print (program ('b', 4, 'A_a_a_B_b_b_c_c_c_d_e'))
# ['a', ' ', 'c', 'd']
# always the same output now

这让我想到另一点。因为我们将unique抽象为自己的函数，我们会自动给出一个范围来定义它的行为。我选择在unique的实现中使用命令式样式，但这很好，因为它仍然是纯粹的功能和功能的消费者无法区分。只要unique有效，您就可以提出其他100个program的实现，这没关系。

功能编程是关于功能。这种语言是你的驯服。它仍然是一个常规的python程序。

def fwd (x):
  return lambda k: fwd (k (x))

def program (word = '', clip_length = 5, input = ''):
  make_words = \
    compose ( lower
            , partial (replace, '_', ' ')
            )

  fwd (input)                               \
    (partial (map, make_words))             \
    (partial (filter, lambda x: x != word)) \
    (unique)                                \
    (partial (take, clip_length))           \
    (print)

program ('b', 4, 'A_a_a_B_b_b_c_c_c_d_e')
# ['a', ' ', 'c', 'd']

在repl.it

上触摸并试用此计划

在python中清理操作管道

2 个答案: