在Python中，你可以这样说：
s = 'fred loves mary'
r = s.replace
s = r('fred','ben')
print s
。你得到，非常方便，有点：
ben loves mary
但是，因为当您说r = s.place时，您创建了一个始终包含"fred loves mary"的对象，因此不会产生"ben loves deb"...
s = 'fred loves mary'
r = s.replace
s = r('fred','ben')
s = r('mary','deb')
print s
。相反，它产生：
fred loves deb
我明白发生了什么。但是实际编写快速代码(如后者集(并使其工作的能力，即产生：
ben loves deb
。会很棒。所以我的问题是，除了定义 ObviousFunction(s，x，y( 或类之外，有没有办法做到这一点，即：
class xs:
def __init__(self,s):
self.s = s
def r(self,x,y):
self.s = self.s.replace(x,y)
def __str__(self):
return self.s
s = xs('fred loves mary')
s = s.r('mary','deb')
s = s.r('fred','ben')
print s
。这实际上确实会产生：
ben loves deb
。但对于进一步的弦乐操作，需要以下类型的体操：
print s.s.upper()
。
BEN LOVES DEB
我看了一下扩展现有类(在本例中为 str(的任何能力，但结果很干。弱谷歌福？
嗯，好的，我到此为止了：
class xs(str)
def r(self,x,y):
return xs(self.replace(x,y))
。这将这样做：
s = xs('fred loves mary')
s = s.r('fred','ben')
s = s.r('mary','deb')
# so far, so good; s is still class xs and you can go on forever
# but if you do this:
s = s.replace('ben','meezer')
# now s is an object of class str
。那么有没有办法将返回值通常强制到原始类，因为我已经强制返回值 .r(( 返回？除了说...
s = xs(s)
。之后？
我可以看到可以扩展这个类，直到设法包装返回字符串的每种类型的字符串调用，然后将(大(结果扔到一个人的工具箱中，但对于看起来应该很容易的事情来说，这是很多工作。不过，这可能是唯一的解决方案，如果是这样的话......我肯定会上这样的课。班级str可以获得的东西数量很多，除了缩短所有冗长的好处之外，工作/性格因素就会增加。
感谢您的任何见解。
好的，在这里提供了所有帮助以及一些关于网络的进一步拖钓之后，我有一些非常接近我想要的东西。我写了一个更完整的类，但以下代码片段练习了与我的原始查询直接相关的问题：
class xs(str):
def __add__(self,a): # OPERATORS
return xs(str(self) + a) # +
def __mod__(self,tup):
return xs(str(self) % tup) # %
def __getslice__(self,b,c):
return xs(str(self)[b:c]) # [:]
def r(self,x,y): # replace, as 'r'
return xs(self.replace(x,y))
使用上述方法，可以保持类标识，可以为每个返回字符串的类str函数编写替换代码，并且其他所有内容都像处理字符串一样工作。 所以...
a = xs('fred loves mary')
a = a.r('fred','ben')
a = a.r('mary','deb')
print a
。结果在...
ben loves deb
。和。。。
b = a[:3] # get 'ben'
c = a[-3:] # get 'deb'
d = xs('%s adores %s') # format string
e = d % (b,c) # do the formatting
e = e.r('ben','charlie')
f = e + ' (so I hear)'
print f,str(type(f))
。收益 率。。。
charlie adores deb (so I hear) <class '__main__.xs'>
因此，正如我们所看到的，xs 类始终保持，标准操作照常适用。类 str 中不返回字符串的任何内容都可以保持不受干扰;任何执行的操作都应该处理，因为 .replace(( 在这里。xs 类的对象几乎可以在字符串可以使用的任何地方使用，并且在许多情况下，字符串可以与 xs 类的对象一起使用而不会引起问题;值得注意的例外是 + 和 % 的第一个操作数，因为它们必须是 X 类，以便运算符覆盖首先掌握它们。
最好的办法是能够扩展类空间。但是对它进行子类化提供了大部分好处。
如果有人真的感兴趣，我会把完整的课程(到目前为止大部分已经完成(发布到你可以抓住它的地方。包括虚线四弦方便，类例外，yadda yadda。在 Python 2.6.1 下运行，Python 3 需要额外的工作。
感谢大家的帮助！
你只需要做一点硬编码：
s = 'fred loves mary'
s = s.replace('fred','ben')
s = s.replace('mary','deb')
print s
输出：
ben loves deb
我希望以下代码对您有所帮助，我正在使用python 2.7
class xs(object):
def __init__(self,s):
self.s = s
def r(self,x,y):
self.s = self.s.replace(x,y)
return self
def __getattr__(self, name ):
return getattr(self.s, name)
def __str__(self):
return self.s
s = xs('fred loves mary')
s = s.r('mary','deb')
s = s.r('fred','ben')
print s
print s.upper()