子类 str，并创建与 += 效果相同的新方法
subclass str, and make new method with same effect as +=
我正在尝试 subclass str - 不是为了任何重要的事情，只是为了了解更多关于 Python 内置类型的实验。我用这种方式子 classed str（使用 __new__ 因为 str 是不可变的）：
class MyString(str):
def __new__(cls, value=''):
return str.__new__(cls, value)
def __radd__(self, value): # what method should I use??
return MyString(self + value) # what goes here??
def write(self, data):
self.__radd__(data)
据我所知，它初始化正确。但我无法使用 += 运算符就地修改自身。我已经尝试覆盖 __add__、__radd__、__iadd__ 和各种其他配置。使用 return 语句，我设法让它成为 return 正确附加 MyString 的新实例，但没有就地修改。成功看起来像：
b = MyString('g')
b.write('h') # b should now be 'gh'
有什么想法吗？
更新
为了可能添加某人可能想要这样做的原因，我遵循了创建以下内部使用纯字符串的可变 class 的建议：
class StringInside(object):
def __init__(self, data=''):
self.data = data
def write(self, data):
self.data += data
def read(self):
return self.data
并使用 timeit 测试：
timeit.timeit("arr+='1234567890'", setup="arr = ''", number=10000)
0.004415035247802734
timeit.timeit("arr.write('1234567890')", setup="from hard import StringInside; arr = StringInside()", number=10000)
0.0331270694732666
差异在 number 上升时迅速增加 - 在 100 万次交互时，StringInside 花费的时间比我愿意等待 return 的时间长，而纯 str 版本 return 在 ~100 毫秒内编辑。
更新 2
为了后代，我决定写一个 cython class 包装一个 C++ 字符串，看看与下面松散地基于 Mike Müller 的更新版本相比性能是否可以提高，我成功了。我意识到 cython 是“作弊”，但我提供这个只是为了好玩。
python版本：
class Mike(object):
def __init__(self, data=''):
self._data = []
self._data.extend(data)
def write(self, data):
self._data.extend(data)
def read(self, stop=None):
return ''.join(self._data[0:stop])
def pop(self, stop=None):
if not stop:
stop = len(self._data)
try:
return ''.join(self._data[0:stop])
finally:
self._data = self._data[stop:]
def __getitem__(self, key):
return ''.join(self._data[key])
cython 版本：
from libcpp.string cimport string
cdef class CyString:
cdef string buff
cdef public int length
def __cinit__(self, string data=''):
self.length = len(data)
self.buff = data
def write(self, string new_data):
self.length += len(new_data)
self.buff += new_data
def read(self, int length=0):
if not length:
length = self.length
return self.buff.substr(0, length)
def pop(self, int length=0):
if not length:
length = self.length
ans = self.buff.substr(0, length)
self.buff.erase(0, length)
return ans
表现：
写作
>>> timeit.timeit("arr.write('1234567890')", setup="from pyversion import Mike; arr = Mike()", number=1000000)
0.5992741584777832
>>> timeit.timeit("arr.write('1234567890')", setup="from cyversion import CyBuff; arr = CyBuff()", number=1000000)
0.17381906509399414
阅读
>>> timeit.timeit("arr.write('1234567890'); arr.read(5)", setup="from pyversion import Mike; arr = Mike()", number=1000000)
1.1499049663543701
>>> timeit.timeit("arr.write('1234567890'); arr.read(5)", setup="from cyversion import CyBuff; arr = CyBuff()", number=1000000)
0.2894480228424072
爆裂
>>> # note I'm using 10e3 iterations - the python version wouldn't return otherwise
>>> timeit.timeit("arr.write('1234567890'); arr.pop(5)", setup="from pyversion import Mike; arr = Mike()", number=10000)
0.7390561103820801
>>> timeit.timeit("arr.write('1234567890'); arr.pop(5)", setup="from cyversion import CyBuff; arr = CyBuff()", number=10000)
0.01501607894897461
解决方案
这是对更新问题的回答。
您可以使用列表来保存数据，并且只在读取时构造字符串：
class StringInside(object):
def __init__(self, data=''):
self._data = []
self._data.append(data)
def write(self, data):
self._data.append(data)
def read(self):
return ''.join(self._data)
性能
这个class的表现：
%%timeit arr = StringInside()
arr.write('1234567890')
1000000 loops, best of 3: 352 ns per loop
更接近原生 str:
%%timeit str_arr = ''
str_arr+='1234567890'
1000000 loops, best of 3: 222 ns per loop
与您的版本比较：
%%timeit arr = StringInsidePlusEqual()
arr.write('1234567890')
100000 loops, best of 3: 87 µs per loop
原因
构建字符串的 my_string += another_string 方式长期以来一直是 anti-pattern 性能方面的明智之举。 CPython 对这种情况进行了一些优化。似乎 CPython 无法检测到此处使用了此模式。这可能是因为它有点隐藏在 class 中。
出于各种原因，并非所有实现都具有此优化。例如。通常比 CPython 快得多的 PyPy 对于这个用例来说要慢得多：
PyPy 2.6.0 (Python 2.7.9)
>>>> import timeit
>>>> timeit.timeit("arr+='1234567890'", setup="arr = ''", number=10000)
0.08312582969665527
CPython 2.7.11
>>> import timeit
>>> timeit.timeit("arr+='1234567890'", setup="arr = ''", number=10000)
0.002151966094970703
Slice-able版本
此版本支持切片：
class StringInside(object):
def __init__(self, data=''):
self._data = []
self._data.extend(data)
def write(self, data):
self._data.extend(data)
def read(self, start=None, stop=None):
return ''.join(self._data[start:stop])
def __getitem__(self, key):
return ''.join(self._data[key])
您可以按正常方式切片：
>>> arr = StringInside('abcdefg')
>>> arr[2]
'c'
>>> arr[1:3]
'bc'
现在，read() 还支持可选的开始和停止索引：
>>> arr.read()
'abcdefg'
>>> arr.read(1, 3)
'bc'
>>> arr.read(1)
'bcdefg'
我正在尝试 subclass str - 不是为了任何重要的事情，只是为了了解更多关于 Python 内置类型的实验。我用这种方式子 classed str（使用 __new__ 因为 str 是不可变的）：
class MyString(str):
def __new__(cls, value=''):
return str.__new__(cls, value)
def __radd__(self, value): # what method should I use??
return MyString(self + value) # what goes here??
def write(self, data):
self.__radd__(data)
据我所知，它初始化正确。但我无法使用 += 运算符就地修改自身。我已经尝试覆盖 __add__、__radd__、__iadd__ 和各种其他配置。使用 return 语句，我设法让它成为 return 正确附加 MyString 的新实例，但没有就地修改。成功看起来像：
b = MyString('g')
b.write('h') # b should now be 'gh'
有什么想法吗？
更新
为了可能添加某人可能想要这样做的原因，我遵循了创建以下内部使用纯字符串的可变 class 的建议：
class StringInside(object):
def __init__(self, data=''):
self.data = data
def write(self, data):
self.data += data
def read(self):
return self.data
并使用 timeit 测试：
timeit.timeit("arr+='1234567890'", setup="arr = ''", number=10000)
0.004415035247802734
timeit.timeit("arr.write('1234567890')", setup="from hard import StringInside; arr = StringInside()", number=10000)
0.0331270694732666
差异在 number 上升时迅速增加 - 在 100 万次交互时，StringInside 花费的时间比我愿意等待 return 的时间长，而纯 str 版本 return 在 ~100 毫秒内编辑。
更新 2
为了后代，我决定写一个 cython class 包装一个 C++ 字符串，看看与下面松散地基于 Mike Müller 的更新版本相比性能是否可以提高，我成功了。我意识到 cython 是“作弊”，但我提供这个只是为了好玩。
python版本：
class Mike(object):
def __init__(self, data=''):
self._data = []
self._data.extend(data)
def write(self, data):
self._data.extend(data)
def read(self, stop=None):
return ''.join(self._data[0:stop])
def pop(self, stop=None):
if not stop:
stop = len(self._data)
try:
return ''.join(self._data[0:stop])
finally:
self._data = self._data[stop:]
def __getitem__(self, key):
return ''.join(self._data[key])
cython 版本：
from libcpp.string cimport string
cdef class CyString:
cdef string buff
cdef public int length
def __cinit__(self, string data=''):
self.length = len(data)
self.buff = data
def write(self, string new_data):
self.length += len(new_data)
self.buff += new_data
def read(self, int length=0):
if not length:
length = self.length
return self.buff.substr(0, length)
def pop(self, int length=0):
if not length:
length = self.length
ans = self.buff.substr(0, length)
self.buff.erase(0, length)
return ans
表现：
写作
>>> timeit.timeit("arr.write('1234567890')", setup="from pyversion import Mike; arr = Mike()", number=1000000)
0.5992741584777832
>>> timeit.timeit("arr.write('1234567890')", setup="from cyversion import CyBuff; arr = CyBuff()", number=1000000)
0.17381906509399414
阅读
>>> timeit.timeit("arr.write('1234567890'); arr.read(5)", setup="from pyversion import Mike; arr = Mike()", number=1000000)
1.1499049663543701
>>> timeit.timeit("arr.write('1234567890'); arr.read(5)", setup="from cyversion import CyBuff; arr = CyBuff()", number=1000000)
0.2894480228424072
爆裂
>>> # note I'm using 10e3 iterations - the python version wouldn't return otherwise
>>> timeit.timeit("arr.write('1234567890'); arr.pop(5)", setup="from pyversion import Mike; arr = Mike()", number=10000)
0.7390561103820801
>>> timeit.timeit("arr.write('1234567890'); arr.pop(5)", setup="from cyversion import CyBuff; arr = CyBuff()", number=10000)
0.01501607894897461
解决方案
这是对更新问题的回答。
您可以使用列表来保存数据，并且只在读取时构造字符串：
class StringInside(object):
def __init__(self, data=''):
self._data = []
self._data.append(data)
def write(self, data):
self._data.append(data)
def read(self):
return ''.join(self._data)
性能
这个class的表现：
%%timeit arr = StringInside()
arr.write('1234567890')
1000000 loops, best of 3: 352 ns per loop
更接近原生 str:
%%timeit str_arr = ''
str_arr+='1234567890'
1000000 loops, best of 3: 222 ns per loop
与您的版本比较：
%%timeit arr = StringInsidePlusEqual()
arr.write('1234567890')
100000 loops, best of 3: 87 µs per loop
原因
构建字符串的 my_string += another_string 方式长期以来一直是 anti-pattern 性能方面的明智之举。 CPython 对这种情况进行了一些优化。似乎 CPython 无法检测到此处使用了此模式。这可能是因为它有点隐藏在 class 中。
出于各种原因，并非所有实现都具有此优化。例如。通常比 CPython 快得多的 PyPy 对于这个用例来说要慢得多：
PyPy 2.6.0 (Python 2.7.9)
>>>> import timeit
>>>> timeit.timeit("arr+='1234567890'", setup="arr = ''", number=10000)
0.08312582969665527
CPython 2.7.11
>>> import timeit
>>> timeit.timeit("arr+='1234567890'", setup="arr = ''", number=10000)
0.002151966094970703
Slice-able版本
此版本支持切片：
class StringInside(object):
def __init__(self, data=''):
self._data = []
self._data.extend(data)
def write(self, data):
self._data.extend(data)
def read(self, start=None, stop=None):
return ''.join(self._data[start:stop])
def __getitem__(self, key):
return ''.join(self._data[key])
您可以按正常方式切片：
>>> arr = StringInside('abcdefg')
>>> arr[2]
'c'
>>> arr[1:3]
'bc'
现在，read() 还支持可选的开始和停止索引：
>>> arr.read()
'abcdefg'
>>> arr.read(1, 3)
'bc'
>>> arr.read(1)
'bcdefg'