Python中的函数式编程:不可变的数据结构

让我们首先考虑正方形和长方形。如果我们认为在接口方面，忽略了实现细节，方块是否是矩形的子类型？

子类型的定义取决于liskov代换原理。为了成为一个子类型，它必须能够完成超级类型所做的一切。

如何定义矩形的接口？

zope.interface import interface
class irectangleinterface:
get_length:
"""squares can do that"""
get_width:
"""squares can do that"""
set_dimensions length width:
"""uh oh"""

如果这是定义，则方块不能是矩形的子类型；它们不能响应set_dimensions方法，如果长度和宽度不同。

另一种方法是选择制作矩形。不变.

class irectangleinterface:
get_length:
"""squares can do that"""
get_width:
"""squares can do that"""
with_dimensions length width:
"""returns a new rectangle"""

现在，一个正方形可以是一个矩形。它可以返回一个新的矩形(通常不是正方形)with_dimensions被称为，但它不会停止成为一个正方形。

这似乎是一个学术问题-直到我们考虑到，从某种意义上说，正方形和长方形是它们两边的容器。在我们理解了这个例子之后，更实际的情况是使用更传统的容器。例如，考虑随机访问数组.

我们有isquare和irectangle，和isquare是irectangle.

我们希望在随机访问数组中放置矩形：

class iarrayofrectanglesinterface:
get_element i:
"""returns rectangle"""
set_element i rectangle:
"""'rectangle' can be any irectangle"""

我们也想把正方形放在一个随机存取数组中：

class iarrayofsquareinterface:
get_element i:
"""returns square"""
set_element i square:
"""'square' can be any isquare"""

即使isquare是irectangle，任何数组都不能实现这两者。iarrayofsquare和iarrayofrectangle.

为什么不行?假设bucket实现两者。

>>> rectangle make_rectangle 
>>> bucket.set_element rectangle # this is allowed by iarrayofrectangle
>>> thing bucket.get_element # that has to be a square by iarrayofsquare
>>> assert thing.height thing.width
traceback most recent call last:
file "<stdin>" line module
assertionerror

两者都不能实现，这意味着两者都不是另一种类型的子类型，尽管isquare是irectangle。问题是set_element方法：如果我们有一个只读数组，iarrayofsquare的子类型iarrayofrectangle.

可变性，都是可变的。irectangle接口和可变iarrayof接口使得对类型和子类型的思考变得更加困难-而放弃的能力意味着我们期望类型之间的直观关系实际上仍然有效。

突变也可以非局部效果。当两个地方之间的共享对象被一个突变时，就会发生这种情况。典型的例子是一个线程与另一个线程交互一个共享对象，但是即使在一个单线程程序中，在相距很远的地方之间共享也很容易。考虑到在python中，大多数对象都可以从许多地方访问：作为一个模块全局，或者在堆栈跟踪中，或者作为一个类属性。

如果我们不能限制共享，我们可能会考虑限制可变。

下面是一个不可变的矩形，它利用autos库：

attr.frozen
class rectangeobject:
length attr.
width attr.
classmethod
with_dimensionscls length width:
return clslength width

这里是一个正方形：

attr.frozen
class squareobject:
side attr.
classmethod
with_dimensionscls length width:
return rectanglelength width

使用frozen参数，我们可以很容易地创建一个不可变的类。所有艰苦的写作工作__setitem__正确的做法是别人做的，对我们来说是完全看不见的。

修改对象仍然是容易的，改变它们几乎是不可能的

too_long rectangle 
reasonable attr.evolvetoo_long length

可靠的包装允许我们有不可变的容器

# vector of integers
a = pyrsistent.v(1, 2, 3)
# not a vector of integers
b = a.set(1, "hello")

当b不是整数的向量，任何东西都不会停止。a从成为一个。

万一a一百万个元素长了吗？是b要复制999 999份吗？pyrsistent附带“大o”性能保证：所有操作都采用o(log n)时间到了。它还附带了一个可选的c扩展，以提高性能超越大o。

为了修改嵌套对象，它附带了“转换器”的概念：

blog pyrsistent.
title"my blog"
linkspyrsistent."github" "twitter"
postspyrsistent.
pyrsistent.title"no updates"
content"i'm busy"
pyrsistent.title"still no updates"
content"still busy"
new_blog blog.transform"posts" "content"
"pretty busy"

new_blog将成为不可变的等价物。

'links': 'github' 'twitter'
'posts': 'content': "i'm busy"
'title': 'no updates'
'content': 'pretty busy'
'title': 'still no updates'
'title': 'my blog'

但blog还是一样的。这意味着任何引用旧对象的人都没有受到影响：转换只有本土化效果。

当分享猖獗时，这是有用的。例如，考虑默认参数：

silly_suma b extrav :
extra extra.extenda b
return extra

在这篇文章中，我们了解了为什么不变性对于思考我们的代码是有用的，以及如何在没有昂贵的性能代价的情况下实现它。

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对的支持。如果你想了解更多相关内容请查看下面相关链接