如何组合外部函数为内部函数提供参数的两个函数

Question

我有两个相似的代码需要解析，但我不确定最适合python的方法来完成这一点。在

“我想有两个相似的代码”

secret_code_1 = 'asdf|qwer-sdfg-wert$$otherthing'
secret_code_2 = 'qwersdfg-qw|er$$otherthing'

这两个代码都以$$otherthing结尾，并包含许多由-分隔的值

起初，我考虑使用functools.wrap将一些常见逻辑与特定于每种代码类型的逻辑分开，如下所示：

^{pr2}$

然而，这样做会让您混淆到底应该传递给parse_code_*函数的参数，即

parse_code_1b(secret_code_1)
parse_code_2b(secret_code_2)

为了使函数的形式参数更易于推理，我将逻辑改为如下：

def _parse_secret(parse_func, code):
  _code = code.split('$$')[0]
  return parse_func(code, *_code.split('-'))

def _parse_code_1(code, a, b, c):
  """
  a, b, and c are descriptive parameters that explain
  the different components in the secret code

  returns a tuple of the decoded parts
  """
  a = a.split('|')[0]
  return (a,b,c)

def _parse_code_2(code, a, b):
  """
  a and b are descriptive parameters that explain
  the different components in the secret code

  returns a tuple of the decoded parts
  """
  b = b.split('|')[1]
  return (a,b)

def parse_code_1(code):
  return _parse_secret(_parse_code_1, code)

def parse_code_2(code):
  return _parse_secret(_parse_code_2, code)

现在，更容易对传递给函数的内容进行推理：

parse_code_1(secret_code_1)
parse_code_2(secret_code_2)

然而，这段代码明显更加冗长。在

有更好的方法吗？在这里，类的面向对象方法更有意义吗？在

repl.it example

Answer 1

我相信这样的方法可以奏效：

secret_codes = ['asdf|qwer-sdfg-wert$$otherthing', 'qwersdfg-qw|er$$otherthing']


def parse_code(code):
    _code = code.split('$$')
    if '-' in _code[0]:
        return _parse_secrets(_code[1], *_code[0].split('-'))
    return _parse_secrets(_code[0], *_code[1].split('-'))


def _parse_secrets(code, a, b, c=None):
    """
    a, b, and c are descriptive parameters that explain
    the different components in the secret code

    returns a tuple of the decoded parts
    """
    if c is not None:
        return a.split('|')[0], b, c
    return a, b.split('|')[1]


for secret_code in secret_codes:
    print(parse_code(secret_code))

输出：

^{pr2}$

我不确定您的秘密数据结构，但如果您使用元素位置的索引，其中包含|的数据，并且有适当数量的秘密数据，那么您也可以这样做，并且潜在地拥有无限（几乎）数量的秘密：

def _parse_secrets(code, *data):
    """
    data is descriptive parameters that explain
    the different components in the secret code

    returns a tuple of the decoded parts
    """
    i = 0
    decoded_secrets = []
    for secret in data:
        if '|' in secret:
            decoded_secrets.append(secret.split('|')[i])
        else:
            decoded_secrets.append(secret)
        i += 1
    return tuple(decoded_secrets)

Answer 2

在 我真的不知道你到底是什么意思。但我想到了你想要的。在

使用这样一个简单的函数怎么样：

def split_secret_code(code): 
    return [code] + code[:code.find("$$")].split("-")

而不仅仅是使用：

^{pr2}$

Answer 3

repl.it example

功能方法更简洁，更有意义。在

{我们可以从最简单的形式开始表达概念。在

剥离$$otherthing并拆分值：

parse_secret = lambda code: code.split('$$')[0].split('-')

取一个内部值：

^{pr2}$

将其中一个值替换为其内部值：

parse_code = lambda values, p, q: \
  [take(v, q) if p == i else v for (i, v) in enumerate(values)]

这两种代码有3种不同：

• 值的数目
• 解析“内部”值的位置
• “内部”值的位置

我们可以通过描述这些差异来构造解析函数。拆分值被打包，以便更容易组合。在

compose = lambda length, p, q: \
  lambda code: parse_code(parse_secret(code)[:length], p, q)

parse_code_1 = compose(3, 0, 0)
parse_code_2 = compose(2, 1, 1)

并使用组合函数：

secret_code_1 = 'asdf|qwer-sdfg-wert$$otherthing'
secret_code_2 = 'qwersdfg-qw|er$$otherthing'
results = [parse_code_1(secret_code_1), parse_code_2(secret_code_2)]
print(results)