【问题标题】:Is it possible to implement .NET-like attributes in Python?是否可以在 Python 中实现类似 .NET 的属性?
【发布时间】:2015-10-15 09:05:30
【问题描述】:

我是 .NET 属性的忠实粉丝——预定义和用户定义的属性。属性是从Attribute 继承的类。 .NET 中的大部分内容(类、方法、成员(属性、字段、枚举值))都可以“装饰”/配备属性。该属性可以通过例如回读。编译器提取编译器提示或由用户作为一种元编程。

C# 示例:

[System.Serializable]
public class SampleClass {
  // Objects of this type can be serialized.
}

VB 示例:

<System.Serializable()>
Public Class SampleClass
  ' Objects of this type can be serialized.
End Class

在我的示例中,Serializable 标记了一个用于序列化的类。序列化程序现在可以检索该类实例的所有成员并将实例数据组装到序列化对象中。也可以标记单个字段是否要序列化。

用户可以借助反射从类中获取定义的属性:System.Attribute.GetCustomAttributes(...)

进一步阅读(MSDN 文档):
- Writing Custom Attributes
- Retrieving Information Stored in Attributes

我也是 Python 和装饰器的忠实粉丝。是否可以在装饰器的帮助下在 Python 中实现类似 .NET 的属性?在 Python 中会是什么样子?

@Serializable
class SampleClass():
  # Objects of this type can be serialized.

另一个用例可能是 Python argparse 库。如果输入包含正确的子命令,则可以注册由子解析器调用的回调函数。定义这种命令行参数语法的更自然的方法是使用装饰器。

这个问题与序列化无关 - 它只是一个用法示例。

【问题讨论】:

  • 如果您希望从 python 社区得到答案,您可能想解释一下“.NET 属性”是什么以及您的 C# 和 VB sn-ps 做了什么。
  • 是的,可以装饰一个类,但更 Pythonic 的方法是定义一个 Serializable abstract base class 并在继承它的类中实现适当的方法。
  • @brunodesthuilliers 我用简短的解释扩展了我的问题。我希望我能解释 .NET 中属性的主要意图。我将添加指向原始文档的更多链接以供进一步阅读,并希望是一个很好的例子。 (在这里发布它的问题很大而且主题很重要:))
  • @jonrsharpe 问题不在于序列化,而在于实现类似 .NET 的属性。序列化只是良好属性使用的一个示例。
  • 我没有回滚任何内容 - 我将您添加的额外信息重新排列为内联信息,而不是在最后添加,并删除了指向一个单独问题的链接,该问题仅是切线相关.如果这不是关于序列化,您能否进一步解释一下 "attribute" 的实际作用? “标记一个类”是什么意思?请注意,定义 ABC 不仅限于序列化...

标签: c# .net python-3.x argparse python-decorators


【解决方案1】:

我玩过一些基于类的装饰器,据我所知我可以说在 Python 中实现类似 .NET 的属性是可能的。

首先让我们开发一个有意义的用例:
我们大多数人都知道 Python argparse 命令行参数解析器。这个解析器可以处理像git commit -m "message" 这样的子命令,其中commit 是一个子命令,-m &lt;message&gt; 是这个子命令解析器的一个参数。可以为每个子命令解析器分配一个回调函数。

适用于 Windows 的 Python 3.4.2 在处理回调函数方面存在错误。它在 3.5.0 中修复(我没有测试其他 3.4.x 版本)。

这是一个经典的argparse 示例:

class MyProg():

  def Run(self):
    # create a commandline argument parser
    MainParser = argparse.ArgumentParser(
      description = textwrap.dedent('''This is the User Service Tool.'''),
      formatter_class = argparse.RawDescriptionHelpFormatter,
      add_help=False)

    MainParser.add_argument('-v', '--verbose', dest="verbose", help='print out detailed messages', action='store_const', const=True, default=False)
    MainParser.add_argument('-d', '--debug', dest="debug", help='enable debug mode', action='store_const', const=True, default=False)
    MainParser.set_defaults(func=self.HandleDefault)
    subParsers = MainParser.add_subparsers(help='sub-command help')

    # UserManagement commads
    # create the sub-parser for the "create-user" command
    CreateUserParser = subParsers.add_parser('create-user', help='create-user help')
    CreateUserParser.add_argument(metavar='<Username>', dest="Users", type=str, nargs='+', help='todo help')
    CreateUserParser.set_defaults(func=self.HandleCreateUser)

    # create the sub-parser for the "remove-user" command
    RemoveUserParser = subParsers.add_parser('remove-user', help='remove-user help')
    RemoveUserParser.add_argument(metavar='<UserID>', dest="UserIDs", type=str, nargs='+', help='todo help')
    RemoveUserParser.set_defaults(func=self.HandleRemoveUser)

  def HandleDefault(self, args):
    print("HandleDefault:")

  def HandleCreateUser(self, args):
    print("HandleCreateUser: {0}".format(str(args.Users)))

  def HandleRemoveUser(self, args):
    print("HandleRemoveUser: {0}".format(str(args.UserIDs)))


my = MyProg()
my.Run()

更好和更具描述性的解决方案可能如下所示:

class MyProg():
  def __init__(self):
    self.BuildParser()
    # ...
  def BuiltParser(self):
    # 1. search self for methods (potential handlers)
    # 2. search this methods for attributes
    # 3. extract Command and Argument attributes
    # 4. create the parser with that provided metadata

  # UserManagement commads
  @CommandAttribute('create-user', help="create-user help")
  @ArgumentAttribute(metavar='<Username>', dest="Users", type=str, nargs='+', help='todo help')
  def HandleCreateUser(self, args):
    print("HandleCreateUser: {0}".format(str(args.Users)))

  @CommandAttribute('remove-user',help="remove-user help")
  @ArgumentAttribute(metavar='<UserID>', dest="UserIDs", type=str, nargs='+', help='todo help')
  def HandleRemoveUser(self, args):
    print("HandleRemoveUser: {0}".format(str(args.UserIDs)))

第 1 步 - 一个普通的 Attribute 类

那么让我们开发一个通用的Attribute 类,它也是一个基于类的装饰器。这个装饰器将自己添加到一个名为__attributes__ 的列表中,该列表已注册在要装饰的函数上。

class Attribute():
  AttributesMemberName =  "__attributes__"
  _debug =                False

  def __call__(self, func):
    # inherit attributes and append myself or create a new attributes list
    if (func.__dict__.__contains__(Attribute.AttributesMemberName)):
      func.__dict__[Attribute.AttributesMemberName].append(self)
    else:
      func.__setattr__(Attribute.AttributesMemberName, [self])
    return func

  def __str__(self):
    return self.__name__

  @classmethod
  def GetAttributes(self, method):
    if method.__dict__.__contains__(Attribute.AttributesMemberName):
      attributes = method.__dict__[Attribute.AttributesMemberName]
      if isinstance(attributes, list):
        return [attribute for attribute in attributes if isinstance(attribute, self)]
    return list()

第 2 步 - 用户定义的属性

现在我们可以创建从Attribute 继承基本装饰功能的自定义属性。我将声明 3 个属性:

  • DefaultAttribute - 如果没有子命令解析器识别命令,则此修饰方法将作为后备处理程序。
  • CommandAttribute - 定义子命令并将装饰函数注册为回调。
  • ArgumentAttribute - 向子命令解析器添加参数。
class DefaultAttribute(Attribute):
  __handler = None

  def __call__(self, func):
    self.__handler = func
    return super().__call__(func)

  @property
  def Handler(self):
    return self.__handler

class CommandAttribute(Attribute):
  __command = ""
  __handler = None
  __kwargs =  None

  def __init__(self, command, **kwargs):
    super().__init__()
    self.__command =  command
    self.__kwargs =   kwargs

  def __call__(self, func):
    self.__handler = func
    return super().__call__(func)

  @property
  def Command(self):
    return self.__command

  @property
  def Handler(self):
    return self.__handler

  @property
  def KWArgs(self):
    return self.__kwargs

class ArgumentAttribute(Attribute):
  __args =   None
  __kwargs = None

  def __init__(self, *args, **kwargs):
    super().__init__()
    self.__args =   args
    self.__kwargs = kwargs

  @property
  def Args(self):
    return self.__args

  @property
  def KWArgs(self):
    return self.__kwargs

第 3 步 - 构建一个 helper mixin 类来处理方法上的属性

为了简化使用属性的工作,我实现了一个AttributeHelperMixin 类,它可以:

  • 检索一个类的所有方法
  • 检查方法是否有属性和
  • 返回给定方法的属性列表。
class AttributeHelperMixin():
  def GetMethods(self):
    return {funcname: func
            for funcname, func in self.__class__.__dict__.items()
            if hasattr(func, '__dict__')
           }.items()

  def HasAttribute(self, method):
    if method.__dict__.__contains__(Attribute.AttributesMemberName):
      attributeList = method.__dict__[Attribute.AttributesMemberName]
      return (isinstance(attributeList, list) and (len(attributeList) != 0))
    else:
      return False

  def GetAttributes(self, method):
    if method.__dict__.__contains__(Attribute.AttributesMemberName):
      attributeList = method.__dict__[Attribute.AttributesMemberName]
      if isinstance(attributeList, list):
        return attributeList
    return list()

第 4 步 - 构建应用程序类

现在是时候构建一个继承自MyBase 和ArgParseMixin 的应用程序类了。我稍后会讨论ArgParseMixin。该类有一个普通的构造函数,它调用两个基类构造函数。它还将 verbose 和 debug 的 2 个参数添加到主解析器。所有回调处理程序都用新的属性修饰。

class MyBase():
  def __init__(self):
    pass

class prog(MyBase, ArgParseMixin):
  def __init__(self):
    import argparse
    import textwrap

    # call constructor of the main interitance tree
    MyBase.__init__(self)

    # Call the constructor of the ArgParseMixin
    ArgParseMixin.__init__(self,
      description = textwrap.dedent('''\
        This is the Admin Service Tool.
        '''),
      formatter_class = argparse.RawDescriptionHelpFormatter,
      add_help=False)

    self.MainParser.add_argument('-v', '--verbose',  dest="verbose",  help='print out detailed messages',  action='store_const', const=True, default=False)
    self.MainParser.add_argument('-d', '--debug',    dest="debug",    help='enable debug mode',            action='store_const', const=True, default=False)

  def Run(self):
    ArgParseMixin.Run(self)

  @DefaultAttribute()
  def HandleDefault(self, args):
    print("DefaultHandler: verbose={0}  debug={1}".format(str(args.verbose), str(args.debug)))

  @CommandAttribute("create-user", help="my new command")
  @ArgumentAttribute(metavar='<Username>', dest="Users", type=str, help='todo help')
  def HandleCreateUser(self, args):
    print("HandleCreateUser: {0}".format(str(args.Users)))

  @CommandAttribute("remove-user", help="my new command")
  @ArgumentAttribute(metavar='<UserID>', dest="UserIDs", type=str, help='todo help')
  def HandleRemoveUser(self, args):
    print("HandleRemoveUser: {0}".format(str(args.UserIDs)))

p = prog()
p.Run()

第 5 步 - ArgParseMixin 助手类。

此类使用属性中提供的数据构造基于argparse 的解析器。解析过程由Run()调用。

class ArgParseMixin(AttributeHelperMixin):
  __mainParser = None
  __subParser =  None
  __subParsers = {}

  def __init__(self, **kwargs):
    super().__init__()

    # create a commandline argument parser
    import argparse
    self.__mainParser = argparse.ArgumentParser(**kwargs)
    self.__subParser =  self.__mainParser.add_subparsers(help='sub-command help')

    for funcname,func in self.GetMethods():
      defAttributes = DefaultAttribute.GetAttributes(func)
      if (len(defAttributes) != 0):
        defAttribute = defAttributes[0]
        self.__mainParser.set_defaults(func=defAttribute.Handler)
        continue

      cmdAttributes = CommandAttribute.GetAttributes(func)
      if (len(cmdAttributes) != 0):
        cmdAttribute = cmdAttributes[0]
        subParser = self.__subParser.add_parser(cmdAttribute.Command, **(cmdAttribute.KWArgs))
        subParser.set_defaults(func=cmdAttribute.Handler)

        for argAttribute in ArgumentAttribute.GetAttributes(func):
          subParser.add_argument(*(argAttribute.Args), **(argAttribute.KWArgs))

        self.__subParsers[cmdAttribute.Command] = subParser
        continue

  def Run(self):
    # parse command line options and process splitted arguments in callback functions
    args = self.__mainParser.parse_args()
    # because func is a function (unbound to an object), it MUST be called with self as a first parameter
    args.func(self, args)

  @property
  def MainParser(self):
    return self.__mainParser

  @property
  def SubParsers(self):
    return self.__subParsers

我将在 GitHub 上以 pyAttribute 存储库的形式提供我的代码和示例。

【讨论】:

  • 很好的例子,但如果它以更 Python 的风格编写会更好: - 不要将此命名为“属性” - 在 Python 中,“属性”具有明确定义且完全不同的含义 - 属性 ( python 含义)名称应该在 all_lower - 使用泛型函数而不是实现 __magic_methods__ 即 setattr(obj, name, attr),而不是 obj.__setattr__(name, attr),并避免直接访问 obj.__dict__,除非您有令人信服的理由这样做
  • pypi.python.org/pypi/plac 是一个 argparse 前端。它可以通过装饰函数来创建子解析器。子解析器的参数是函数的参数。它也可以使用 Python3 function annotations。几年前我开始使用plac,但现在发现直接使用argparse 更自然。
【解决方案2】:

鉴于此Serializable 属性,您可能想要一个简单的解决方案。

class C:
    b = 2

    def __init__(self):
        self.a = 1

    def f(self):
        pass


>>> c = C()
>>> c.__dict__
{'a': 1}

80% 的工作已经在每个对象可用的__dict__ 魔法属性中完成。您可能希望拥有一个可序列化成员的类级别列表,并使用 __getattribute__ 魔术方法来修改您的 __dict__ 属性将为您的类返回的内容。

这同样适用于您要移植的其他 C# 属性。我认为没有一种通用的方法可以在不编写大量代码的情况下将随机属性移植到装饰器语法。所以为了简单起见,我的建议是不要拘泥于装饰器,寻找简洁明了的方法。

【讨论】:

  • 问题不在于序列化——这只是 .NET 使用属性的一个例子。另一种是FlagAttribute 将枚举标记为位字段(单热编码),否则所有成员的整数值都会增加。
  • 并非所有对象都有__dict__,也不是对象的所有属性都存储在__dict__中。
  • @Paebbels 答案也与序列化无关。这是关于我的意见,不要坚持使用装饰器。这是可能的,但不建议这样做。
  • @bruno 是的,这是真的。这就是为什么我说“80%”,而不是“100%”:)
  • @brunodesthuilliers 我更新了自己的答案:借助 Python 装饰器可以实现类似 .NET 的属性。我还发布了一个关于如何使用此类元数据对象的希望好的用例。在 .NET 实现中,Attribute 是一个类,语法相似,用法也大体相同:)
猜你喜欢
  • 2023-04-04
  • 1970-01-01
  • 2019-10-20
  • 2013-07-28
  • 2018-04-13
  • 1970-01-01
  • 1970-01-01
  • 2014-10-01
  • 2010-10-15
相关资源
最近更新 更多