拒绝通知

本 PEP 有助于将 PEP 3119 推向一个更合理、更简约的途径。但鉴于 PEP 3119 的最新版本，我更倾向于后者。GvR。

摘要

Python 现有的对象模型根据对象的实现来组织对象。通常，尤其是在像 Python 这样的基于鸭子类型的语言中，我们希望根据对象在更大系统中所扮演的角色（其意图）来组织对象，而不是根据它们如何实现该角色（其实现）。本 PEP 引入了“角色”的概念，这是一种根据对象的意图而不是其实现来组织对象的机制。

基本原理

起初，世间有对象。它们允许程序员将函数和状态结合起来，并通过多态和继承等概念来提高代码的可重用性，于是，一切都变得美好。然而，时有继承和多态不足的时候。随着狗和树的发明，我们不再满足于只知道“它是否理解‘叫’（bark）？”我们现在需要知道给定对象如何理解“叫”的含义。

一种解决方案，即这里详述的方案，是角色，这是一种与传统类/实例系统正交且互补的机制。类关注状态和实现，而角色机制则完全关注给定类所体现的行为。

该系统最初被称为“traits”，并为 Squeak Smalltalk 实现 [4]。此后，它被改编用于 Perl 6 [3]，在那里被称为“roles”，并且主要是从那里，这个概念现在被解释用于 Python 3。Python 3 将保留“roles”这个名称。

简而言之：角色告诉你对象 *做什么*，类告诉你对象 *如何* 做。

在本 PEP 中，我将概述一个 Python 3 系统，该系统将能够轻松确定给定对象的“叫”的含义是树状的还是狗状的。（也可能有一些更严肃的例子。）

履行你的角色

class Tree(Vegetable):

  def bark(self):
    return self.is_rough()


class Dog(Animal):

  def bark(self):
    return self.goes_ruff()

@perform_role(Doglike)
class Dog(Animal):
  ...

@perform_role(Treelike)
class Tree(Vegetable):
  ...

@perform_role(SitThere)
class Rock(Mineral):
  ...

@perform_role(Guard, MummysLittleDarling)
class GermanShepherd(Dog):

  def guard(self, the_precious):
    while True:
      if intruder_near(the_precious):
        self.growl()

  def get_petted(self):
    self.swallow_pride()

>>> perform(Guard)(Robot)

>>> performs(our_robot, Guard)
True

>>> performs(that_robot_over_there, Guard)
True

>>> performs(Robot, Guard)
False

定义新角色

class Doglike(metaclass=Role):
  ...

class FourLegs(metaclass=Role):
  pass

class Doglike(FourLegs, Carnivor):
  pass

@perform_role(Doglike)
class Dog(Mammal):
  pass

class Doglike(FourLegs):

  def bark(self):
    pass

@perform_role(FourLegs)
class Horse(Mammal):

  def run_like_teh_wind(self)
    ...

@perform_role(Doglike)
class Coyote(Mammal):

  def bark(self, target=moon):
    pass

机制

以下是关于角色如何在 Python 中表达的暂定提案。这里的例子以一种方式措辞，即角色机制可以在不更改 Python 解释器的情况下实现。（示例改编自 Curtis Poe 关于 Perl 6 角色的文章 [2]。）

1. 静态类角色分配

   @perform_role(Thieving)
   class Elf(Character):
     ...
   

   perform_role() 接受多个参数，因此以下也是合法的

   @perform_role(Thieving, Spying, Archer)
   class Elf(Character):
     ...
   

   Elf 类现在扮演 Thieving、Spying 和 Archer 角色。

2. 查询实例

   if performs(my_elf, Thieving):
     ...
   

   performs() 的第二个参数也可以是任何具有 __contains__() 方法的对象，这意味着以下是合法的

   if performs(my_elf, set([Thieving, Spying, BoyScout])):
     ...
   

   与 isinstance() 一样，对象只需要扮演一组中的一个角色，表达式就为真。

与抽象基类的关系

本 PEP 的早期草稿 [5] 设想角色与 PEP 3119 中提出的抽象基类竞争。经过进一步的讨论和审议，已经达成了一项折衷方案，并对职责和用例进行了如下分配。

• 角色提供了一种指示对象语义和抽象能力的方法。角色可以定义抽象方法，但只是为了划定一个接口，通过该接口可以访问一组特定的语义。一个 Ordering 角色可能要求定义一组排序运算符。

  class Ordering(metaclass=Role):
    def __ge__(self, other):
      pass
  
    def __le__(self, other):
      pass
  
    def __ne__(self, other):
      pass
  
    # ...and so on
  

  通过这种方式，我们能够指示对象在更大系统中的角色或功能，而无需约束或关心特定的实现。

• 相比之下，抽象基类是重用常见、离散实现单元的一种方式。例如，可以定义一个 OrderingMixin，它根据其他运算符实现多个排序运算符。

  class OrderingMixin:
    def __ge__(self, other):
      return self > other or self == other
  
    def __le__(self, other):
      return self < other or self == other
  
    def __ne__(self, other):
      return not self == other
  
    # ...and so on
  

  使用这个抽象基类——更准确地说，一个具体的混入（mixin）——允许程序员定义一组有限的运算符，让混入实际上“派生”出其他运算符。

通过结合这两个正交系统，我们能够 a) 提供功能，b) 向消费者系统发出该功能存在和可用的警报。例如，由于上面的 OrderingMixin 类满足 Ordering 角色的接口和语义，我们说该混入扮演了该角色。

@perform_role(Ordering)
class OrderingMixin:
  def __ge__(self, other):
    return self > other or self == other

  def __le__(self, other):
    return self < other or self == other

  def __ne__(self, other):
    return not self == other

  # ...and so on

现在，任何使用该混入的类都将自动——也就是说，无需程序员进一步努力——被标记为扮演 Ordering 角色。

将关注点分离到两个不同的、正交的系统中是可取的，因为它允许我们分别使用它们。例如，考虑一个提供 RecursiveHash 角色的第三方包，该角色指示一个容器在确定其哈希值时会考虑其内容。由于 Python 的内置 tuple 和 frozenset 类遵循此语义，因此可以将 RecursiveHash 角色应用于它们。

>>> perform_role(RecursiveHash)(tuple)
>>> perform_role(RecursiveHash)(frozenset)

现在，任何使用 RecursiveHash 对象的代码都将能够使用元组和冻结集合。

未解决的问题

my_elf = Elf()
my_elf.goes_on_quest()
my_elf.becomes_evil()
now_performs(my_elf, Thieving) # Only this one elf is a thief
my_elf.steals(["purses", "candy", "kisses"])

>>> from literature import role, BildungsRoman
>>> from dickens import Urchin, Gentleman
>>>
>>> with BildungsRoman() as OliverTwist:
...   mr_brownlow = Gentleman()
...   oliver, artful_dodger = Urchin(), Urchin()
...   now_performs(artful_dodger, [role.Thief, role.Scoundrel])
...
...   oliver.has_adventures_with(ArtfulDodger)
...   mr_brownlow.adopt_orphan(oliver)
...   now_performs(oliver, role.RichWard)

@perform_role(Y)
class X(metaclass=Role):
  ...

>>> isinstance(my_dwarf, Dwarf)
True
>>> performs(my_dwarf, Surly)
True
>>> performs(Dwarf, Surly)
False
>>> class_performs(Dwarf, Surly)
True

>>> now_perform(Dwarf, GoldMiner)

>>> perform_role(GoldMiner)(Dwarf)

class MyRole(metaclass=Role):
  ...

role MyRole:
  ...

class MyClass(performs=MyRole):
  ...

实施

参考实现即将推出。

致谢

感谢 Jeffery Yasskin、Talin 和 Guido van Rossum 在数小时的面对面讨论中，对角色和抽象基类的差异、重叠和细微差别进行了梳理。

参考资料

版权

本文档已置于公共领域。