在python中为字符串和列表编写一个通用函数

Question

所以我像草一样绿，向How to think like a computer scientist: Learn python 3学习编程。我能够回答这个问题（见下文），但担心我错过了课程。

编写一个函数（称为 insert_at_end），它将通过（返回给定之前的两个参数的粗体）所有三个：

test(insert_at_end(5, [1, 3, 4, 6]), **[1, 3, 4, 6, 5]**)
test(insert_at_end('x', 'abc'),  **'abcx'**)
test(insert_at_end(5, (1, 3, 4, 6)), **(1, 3, 4, 6, 5)**)

这本书给出了这样的提示：“这些练习很好地说明了序列抽象是通用的（因为切片、索引和连接是如此通用），因此可以编写通用函数处理所有序列类型。”。

这个版本没有在线解决方案（我可以找到），但我找到了某人对之前版本文本的答案（适用于 python 2.7），他们这样做了：

def encapsulate(val, seq):
    if type(seq) == type(""):
        return str(val)
    if type(seq) == type([]):
        return [val]
    return (val,)

def insert_at_end(val, seq): 
    return seq + encapsulate(val, seq)

这似乎是通过区分列表和字符串来解决问题......违背了提示。那么怎么样 有没有办法在不区分的情况下回答这个问题（以及大约 10 个类似的问题）？即不使用“type()”

Answer 1

我的最大努力：

def insert_at_end(val, seq):
    t = type(seq)
    try:
        return seq + t(val)
    except TypeError:
        return seq + t([val])

这将尝试创建type(seq) 的序列，如果val 不可迭代，则生成一个列表并连接。

Answer 2

我想说这个例子不是对称的，这意味着它要求读者处理两种不同的情况：

• int，列表
• str，str

在我看来，练习应该要求实现这一点：

• 列表，列表：insert_at_end([5], [1, 3, 4, 6])
• str, str: insert_at_end('x', 'abc')

在这种情况下，读者只需使用两个使用相同序列类型的参数，提示会更有意义。

Answer 3

这不是解决方案，而是解释为什么真正优雅的解决方案看起来不可能。

• + 连接序列，但仅连接相同类型的序列。
• 作为第一个参数传递给insert_at_end 的值是“标量”，因此您必须将它们转换为第二个参数所具有的序列类型。
• 为此，您不能简单地调用带有标量参数的序列构造函数并创建该类型的单项序列：tuple(1) 不起作用。
• str 与其他序列类型的工作方式不同：tuple(["a"]) 是 ("a",)，list(["a"]) 是 ["a"]，但 str(["a"])) 是 "['a']" 而不是 "a"。

这会使+ 在这种情况下无用，即使您可以轻松地构造一个给定类型的序列，而无需使用instanceof，只需使用type()。

你也不能使用切片赋值，因为只有列表是可变的。

在这种情况下，@Hamish 的解决方案看起来最干净。

Answer 4

该问题是一长串问题之一，提示适用于所有问题。我认为这是合理的，在编写了 encapsulate 函数后可以重复用于 insert_at_front 之类的东西，其余的实现与类型无关。

但是，我认为encapsulate 的更好实现可能是：

def encapsulate(val, seq):
    if isinstance(seq, basestring):
        return val
    return type(seq)([val])

用更少的代码处理更广泛的类型。

Answer 5

这个问题的挑战（在 Python 2.7 中，我现在正在测试 3.2 来验证）是seq 的两种可能的输入类型是不可变的，并且您应该返回与之前相同的类型传入。对于字符串，这不是什么大问题，因为您可以这样做：

return seq + char

因为这将返回一个新字符串，该字符串是输入序列和附加字符的连接，但这不适用于列表或元组。您只能将列表连接到列表或将元组连接到元组。如果您想避免“类型”检查，您可以使用以下方法：

if hasattr(seq, 'append'): # List input.
  seq.append(char)
elif hasattr(seq, 'strip'): # String input.
  seq = seq + char
else: # Tuple
  seq = seq + (char,)

return seq

这与实际检查类型并没有太大区别，但确实避免了直接使用type 函数。

Answer 6

与列表/元组相比，此解决方案仍然需要一些单独的字符串代码，但它更简洁，不对特定类型进行任何检查。

def insert_at_end(val, seq):
    try:
        return seq + val
    except TypeError:   # unsupported operand type(s) for +
        return seq + type(seq)([val])

Answer 7

也许这更接近答案：

def genappend(x, s):
    if isinstance(s, basestring):
        t = s[0:0].join
    else:
        t = type(s)
    lst = list(s)
    lst.append(x)
    return t(lst)

print genappend(5, [1,2,3,4])    
print genappend(5, (1,2,3,4))
print genappend('5', '1234')

还可以有完全用户定义的序列类型。只要可转换为列表或从列表转换，它们也将起作用。这也有效：

print genappend('5', set('1234'))

Answer 8

我同意重点是item 是否可迭代。

所以我的解决方案是这样的：

def iterate(seq, item):
    for i in seq:
        yield i
    yield item

def insert_at_end(seq, item):
    if hasattr(item, '__iter__'):
        return seq + item
    else:
        return type(seq)(iterate(seq, item))

例子：

>>> insert_at_end('abc', 'x')
'abcx'
>>> insert_at_end([1, 2, 4, 6], 5)
[1, 2, 4, 6, 5]
>>> insert_at_end((1, 2, 4, 6), 5)
(1, 2, 4, 6, 5)

由于insert_at_end 可以处理可迭代和不可迭代，因此即使在以下情况下也能正常工作：

>>> insert_at_end('abc', 'xyz')
'abcxyz'
>>> insert_at_end([1, 2, 4, 6], [5, 7])
[1, 2, 4, 6, 5, 7]
>>> insert_at_end((1, 2, 4, 6), (5, 7))
(1, 2, 4, 6, 5, 7)

Answer 9

虽然封装依赖于类型，但 insert_at_end 中的直接代码不依赖于所有 3 种类型的 + 含义相关的东西，因此从这个意义上说，符合提示。