检查字符串中是否包含禁果列表中的任何字符串

Question

假设我要检查字符串是否在列表中包含任何字符串。 一种方法是

word = 'hello world'
any(substring in word for substring in ['hello','apple'])

尽管这对我来说似乎有些冗长。 理想情况下，我要

word.ContainsAny('hello','apple')

我已经读过，可以使用forbiddenfruit包来完成针对内置对象的扩展方法，但是我无法解决。 有人可以告诉我，还是建议更简洁的方法？

编辑：我知道我可以编写这样的函数：

ContainsAny(word,['hello','apple'])

但是扩展方法对我来说显得更整洁。

Answer 1

好吧，您可以将str子类化：

class MyStr(str):
    def ContainsAny(self, *args):
        return any(substring in word for substring in args)

word = MyStr('hello world')
word.ContainsAny('hello', 'apple')  # True

但是令人怀疑的是， 为什么要创建一个子类以美观地访问单个方法。

Answer 2

禁果似乎很简单：

>>> from forbiddenfruit import curse, reverse
>>> def contains_any(self, *args):
...     return any(substring in self for substring in args)
... 
>>> curse(str, "contains_any", contains_any)
>>> word = "hello world"
>>> word.contains_any("hello", "apple")
True

我确实必须同意这是一个糟糕的主意。 引用禁果自述文件：

如果用于生产代码，可能会导致您下地狱。

Answer 3

1.子类示例

>>> import string
>>> class MyString(str):
...     def disemvowel(self):
...         return MyString(string.translate(self, None, "aeiou"))
... 
>>> s = MyString("this is only a test")
>>> s.disemvowel()
'ths s nly  tst'

2.禁果的例子

来自评论：
https://stackoverflow.com/a/15975791/10552105

import functools
import ctypes
import __builtin__
import operator

class PyObject(ctypes.Structure):
    pass

Py_ssize_t = hasattr(ctypes.pythonapi, 'Py_InitModule4_64') and ctypes.c_int64 or ctypes.c_int

PyObject._fields_ = [
    ('ob_refcnt', Py_ssize_t),
    ('ob_type', ctypes.POINTER(PyObject)),
]

class SlotsPointer(PyObject):
    _fields_ = [('dict', ctypes.POINTER(PyObject))]

def proxy_builtin(klass):
    name = klass.__name__
    slots = getattr(klass, '__dict__', name)

    pointer = SlotsPointer.from_address(id(slots))
    namespace = {}

    ctypes.pythonapi.PyDict_SetItem(
        ctypes.py_object(namespace),
        ctypes.py_object(name),
        pointer.dict,
    )

    return namespace[name]

def die(message, cls=Exception):
    """
        Raise an exception, allows you to use logical shortcut operators to test for object existence succinctly.

        User.by_name('username') or die('Failed to find user')
    """
    raise cls(message)

def unguido(self, key):
    """
        Attempt to find methods which should really exist on the object instance.
    """
    return functools.partial((getattr(__builtin__, key, None) if hasattr(__builtin__, key) else getattr(operator, key, None)) or die(key, KeyError), self)

class mapper(object):
    def __init__(self, iterator, key):
        self.iterator = iterator
        self.key = key
        self.fn = lambda o: getattr(o, key)

    def __getattribute__(self, key):
        if key in ('iterator', 'fn', 'key'): return object.__getattribute__(self, key)
        return mapper(self, key)

    def __call__(self, *args, **kwargs):
        self.fn = lambda o: (getattr(o, self.key, None) or unguido(o, self.key))(*args, **kwargs)
        return self

    def __iter__(self):
        for value in self.iterator:
            yield self.fn(value)

class foreach(object):
    """
        Creates an output iterator which will apply any functions called on it to every element
        in the input iterator. A kind of chainable version of filter().

        E.g:

        foreach([1, 2, 3]).__add__(2).__str__().replace('3', 'a').upper()

        is equivalent to:

        (str(o + 2).replace('3', 'a').upper() for o in iterator)

        Obviously this is not 'Pythonic'.
    """
    def __init__(self, iterator):
        self.iterator = iterator

    def __getattribute__(self, key):
        if key in ('iterator',): return object.__getattribute__(self, key)
        return mapper(self.iterator, key)

    def __iter__(self):
        for value in self.iterator:
            yield value

proxy_builtin(list)['foreach'] = property(foreach)

import string

print string.join([1, 2, 3].foreach.add(2).str().add(' cookies').upper(), ', ')

>>> 3 COOKIES, 4 COOKIES, 5 COOKIES