Python中有没有内置方法来获取类的所有实例变量的数组？例如，如果我有以下代码：
class hi:
def __init__(self):
self.ii = "foo"
self.kk = "bar"
我有办法做到这一点吗：
>>> mystery_method(hi)
["ii", "kk"]
编辑：我最初错误地要求了类变量。
每个对象都有一个
__dict__试试这个
>>> hi_obj = hi()
>>> hi_obj.__dict__.keys()
输出
dict_keys(['ii', 'kk'])
使用 vars()
class Foo(object):
def __init__(self):
self.a = 1
self.b = 2
vars(Foo()) #==> {'a': 1, 'b': 2}
vars(Foo()).keys() #==> ['a', 'b']
通常无法获取仅给定类的实例属性，至少在不实例化该类的情况下是这样。不过，您可以获取给定实例的实例属性，或给定类的类属性。请参阅“检查”模块。您无法获取实例属性列表，因为实例实际上可以具有任何属性，并且 - 正如您的示例中一样 - 创建它们的正常方法是在 __init__ 方法中分配给它们。
一个例外是，如果您的类使用槽，槽是类允许实例拥有的固定属性列表。插槽在http://www.python.org/2.2.3/descrintro.html中进行了解释，但是插槽存在各种陷阱；它们会影响内存布局，因此多重继承可能会出现问题，并且继承通常也必须考虑插槽。
Vars() 和 dict 方法都适用于 OP 发布的示例，但它们不适用于“松散”定义的对象，例如：
class foo:
a = 'foo'
b = 'bar'
要打印所有不可调用的属性，可以使用以下函数：
def printVars(object):
for i in [v for v in dir(object) if not callable(getattr(object,v))]:
print '\n%s:' % i
exec('print object.%s\n\n') % i
您还可以使用以下方法测试对象是否具有特定变量：
>>> hi_obj = hi()
>>> hasattr(hi_obj, "some attribute")
False
>>> hasattr(hi_obj, "ii")
True
>>> hasattr(hi_obj, "kk")
True
您的示例显示“实例变量”，而不是真正的类变量。
在
hi_obj.__class__.__dict__.items()class Hi( object ):
class_var = ( 23, 'skidoo' ) # class variable
def __init__( self ):
self.ii = "foo" # instance variable
self.jj = "bar"
类变量由类的所有实例共享。
建议
>>> print vars.__doc__
vars([object]) -> dictionary
Without arguments, equivalent to locals().
With an argument, equivalent to object.__dict__.
换句话说，它本质上只是包装了 __dict__
虽然不是OP问题的直接答案，但有一种非常好的方法可以找出函数范围内的变量。看看这段代码：
>>> def f(x, y):
z = x**2 + y**2
sqrt_z = z**.5
return sqrt_z
>>> f.func_code.co_varnames
('x', 'y', 'z', 'sqrt_z')
>>>
func_code 属性里面有各种有趣的东西。它可以让你做一些很酷的事情。这是我如何使用它的示例：
def exec_command(self, cmd, msg, sig):
def message(msg):
a = self.link.process(self.link.recieved_message(msg))
self.exec_command(*a)
def error(msg):
self.printer.printInfo(msg)
def set_usrlist(msg):
self.client.connected_users = msg
def chatmessage(msg):
self.printer.printInfo(msg)
if not locals().has_key(cmd): return
cmd = locals()[cmd]
try:
if 'sig' in cmd.func_code.co_varnames and \
'msg' in cmd.func_code.co_varnames:
cmd(msg, sig)
elif 'msg' in cmd.func_code.co_varnames:
cmd(msg)
else:
cmd()
except Exception, e:
print '\n-----------ERROR-----------'
print 'error: ', e
print 'Error proccessing: ', cmd.__name__
print 'Message: ', msg
print 'Sig: ', sig
print '-----------ERROR-----------\n'
有时您想根据公共/私有变量过滤列表。 例如
def pub_vars(self):
"""Gives the variable names of our instance we want to expose
"""
return [k for k in vars(self) if not k.startswith('_')]
建立在 dmark 的答案之上以获得以下内容，如果您想要 sprintf 的等效项，这将非常有用，并希望能帮助某人...
def sprint(object):
result = ''
for i in [v for v in dir(object) if not callable(getattr(object, v)) and v[0] != '_']:
result += '\n%s:' % i + str(getattr(object, i, ''))
return result
您需要首先，检查类，接下来，检查函数的字节码，然后，复制字节码，最后，使用
__code__.co_varnamestypes
def print_inspect(obj):
print(f"{type(obj)}\n")
var_names = [attr for attr in dir(obj) if not callable(getattr(obj, attr)) and not attr.startswith("__")]
for v in var_names:
print(f"\tself.{v} = {getattr(obj, v)}\n")
import inspect
class A:
d = 4 # Class attribute
def __init__(self):
self.a = 1 # Instance attribute
self.b = 2 # Instance attribute
self.c = 3 # Instance attribute
def method1(self):
pass
def method2(self):
pass
@staticmethod
def static_method1():
pass
@staticmethod
def static_method2():
pass
if __name__ == '__main__':
# Create an instance of A
instance = A()
# Get all members of the class
class_members = inspect.getmembers(A)
instance_members = inspect.getmembers(instance)
# Filter and categorize members
instance_attributes = {
name: value
for name, value in instance_members
if not callable(value) and not name.startswith('__')
}
class_attributes = {
name: value
for name, value in class_members
if not callable(value) and not name.startswith('__')
}
static_methods = {
name: value
for name, value in class_members
if isinstance(value, staticmethod)
}