检查python类属性

问题描述

我需要一种检查类的方法，以便我可以安全地识别哪些属性是用户定义的类属性.问题是 dir()、inspect.getmembers() 和朋友之类的函数会返回所有类属性，包括预定义的属性，例如:__class__、__doc__、__dict__，__hash__.这当然是可以理解的，有人可能会争辩说我可以只列出一个要忽略的命名成员，但不幸的是，这些预定义的属性必然会随着 Python 的不同版本而改变，因此我的项目很容易在 python 项目中发生变化- 我不喜欢那样.

I need a way to inspect a class so I can safely identify which attributes are user-defined class attributes. The problem is that functions like dir(), inspect.getmembers() and friends return all class attributes including the pre-defined ones like: __class__, __doc__, __dict__, __hash__. This is of course understandable, and one could argue that I could just make a list of named members to ignore, but unfortunately these pre-defined attributes are bound to change with different versions of Python therefore making my project volnerable to changed in the python project - and I don't like that.

示例:

>>> class A:
...   a=10
...   b=20
...   def __init__(self):
...     self.c=30
>>> dir(A)
['__doc__', '__init__', '__module__', 'a', 'b']
>>> get_user_attributes(A)
['a','b']

在上面的示例中，我想要一种安全的方法来仅检索用户定义的类属性 ['a','b'] 而不是 'c'，因为它是实例属性.所以我的问题是......谁能帮助我使用上述虚构函数 get_user_attributes(cls)?

In the example above I want a safe way to retrieve only the user-defined class attributes ['a','b'] not 'c' as it is an instance attribute. So my question is... Can anyone help me with the above fictive function get_user_attributes(cls)?

我花了一些时间尝试通过解析 AST 级别的类来解决这个问题，这很容易.但是我找不到将已解析的对象转换为 AST 节点树的方法.我想一旦一个类被编译成字节码，所有的 AST 信息都会被丢弃.

I have spent some time trying to solve the problem by parsing the class in AST level which would be very easy. But I can't find a way to convert already parsed objects to an AST node tree. I guess all AST info is discarded once a class has been compiled into bytecode.

推荐答案

下面是困难的方法.这是简单的方法.不知道为什么我没有早点想到.

Below is the hard way. Here's the easy way. Don't know why it didn't occur to me sooner.

import inspect

def get_user_attributes(cls):
    boring = dir(type('dummy', (object,), {}))
    return [item
            for item in inspect.getmembers(cls)
            if item[0] not in boring]

<小时>

这是一个开始

Here's a start

def get_user_attributes(cls):
    boring = dir(type('dummy', (object,), {}))
    attrs = {}
    bases = reversed(inspect.getmro(cls))   
    for base in bases:
        if hasattr(base, '__dict__'):
            attrs.update(base.__dict__)
        elif hasattr(base, '__slots__'):
            if hasattr(base, base.__slots__[0]): 
                # We're dealing with a non-string sequence or one char string
                for item in base.__slots__:
                    attrs[item] = getattr(base, item)
            else: 
                # We're dealing with a single identifier as a string
                attrs[base.__slots__] = getattr(base, base.__slots__)
    for key in boring:
        del attrs['key']  # we can be sure it will be present so no need to guard this
    return attrs

这应该是相当健壮的.本质上，它的工作原理是让 object 的默认子类上的属性被忽略.然后它获取传递给它的类的 mro 并以相反的顺序遍历它，以便子类键可以覆盖超类键.它返回一个键值对字典.如果您想要 inspect.getmembers 中的键值元组列表，则只需返回 attrs.items() 或 list(attrs.items()) 在 Python 3 中.

This should be fairly robust. Essentially, it works by getting the attributes that are on a default subclass of object to ignore. It then gets the mro of the class that's passed to it and traverses it in reverse order so that subclass keys can overwrite superclass keys. It returns a dictionary of key-value pairs. If you want a list of key, value tuples like in inspect.getmembers then just return either attrs.items() or list(attrs.items()) in Python 3.

如果您实际上不想遍历 mro，而只想直接在子类上定义属性，那么会更容易:

If you don't actually want to traverse the mro and just want attributes defined directly on the subclass then it's easier:

def get_user_attributes(cls):
    boring = dir(type('dummy', (object,), {}))
    if hasattr(cls, '__dict__'):
        attrs = cls.__dict__.copy()
    elif hasattr(cls, '__slots__'):
        if hasattr(base, base.__slots__[0]): 
            # We're dealing with a non-string sequence or one char string
            for item in base.__slots__:
                attrs[item] = getattr(base, item)
            else: 
                # We're dealing with a single identifier as a string
                attrs[base.__slots__] = getattr(base, base.__slots__)
    for key in boring:
        del attrs['key']  # we can be sure it will be present so no need to guard this
    return attrs

这篇关于检查python类属性的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持html5模板网！