请问 "luffy.deng": 如何访问属性（一句话描述不清楚）

tianshizhiluan

问题（简化版）：
     用户随意的填写一个字典，例如这样：

1. foo = {'a': 1,
   
2.        'b': 2,
   
3.        'c': {'a': 22,
   
4.              'b': 23
   
5.            }
   
6.        }
   

复制代码

这是一个函数，名字get_value，下面会用到：

1. def get_value(x):
   
2.     return x + rand()
   

复制代码

用户可以输入任意深度的，任意key的字典，也就是这个dict可以任意的大，还有就是这个dict的key可以是任意的，也就是相当于这个dict可以任意构造。
我想要这样的效果：

1. bar = you_define_class(foo)
   
2. print bar.c.a #我希望打印的结果就类似于get_value(foo['c']['a'])
   

复制代码

这个会用到python里面的data decriptor，但是我有点崩溃，没有看懂。

luffy.deng

回复 1# tianshizhiluan
我想你想实现的就是根据用户输入的字典 来动态定义一个类 ，我想这正是 type('klass',(object,),d)的用途。

shhgs

1. 
   
2. def dictToObject(d):
   
3.     class dct(object):
   
4.         def __init__(self, d):
   
5.             self.__d = d
   
6.         def __getattr__(self, k):
   
7.             try:
   
8.                 result = self.__d.get(k)
   
9.                 if isinstance(result, dict):
   
10.                     return dictToObject(result)
    
11.                 else:
    
12.                     return result
    
13.             except:
    
14.                 raise AttributeError
    
15.     return dct(d)
    

复制代码

shhgs

回复  tianshizhiluan
我想你想实现的就是根据用户输入的字典 来动态定义一个类 ，我想这正是 type('klas ...
luffy.deng 发表于 2010-08-22 23:02

    杀鸡用牛刀

luffy.deng

回复 4# shhgs
相对于递归函数，我个人更喜欢用牛刀的写法，当然只是个人爱好。

盖茨他爹

web.py有一个类

1. class Storage(dict):
   
2.     """
   
3.     A Storage object is like a dictionary except `obj.foo` can be used
   
4.     in addition to `obj['foo']`.
   
5.    
   
6.         >>> o = storage(a=1)
   
7.         >>> o.a
   
8.         1
   
9.         >>> o['a']
   
10.         1
    
11.         >>> o.a = 2
    
12.         >>> o['a']
    
13.         2
    
14.         >>> del o.a
    
15.         >>> o.a
    
16.         Traceback (most recent call last):
    
17.             ...
    
18.         AttributeError: 'a'
    
19.    
    
20.     """
    
21.     def __getattr__(self, key):
    
22.         try:
    
23.             return self[key]
    
24.         except KeyError, k:
    
25.             raise AttributeError, k
    
26.    
    
27.     def __setattr__(self, key, value):
    
28.         self[key] = value
    
29.    
    
30.     def __delattr__(self, key):
    
31.         try:
    
32.             del self[key]
    
33.         except KeyError, k:
    
34.             raise AttributeError, k
    
35.    
    
36.     def __repr__(self):     
    
37.         return '<Storage ' + dict.__repr__(self) + '>'

复制代码

tianshizhiluan

恩，已经实现了，我写了个通用的函数to_obj（有点函数式编程的意思），可以用来完成所有类似的功能，当然还是那样：动态生成。下面是代码。感谢 """ luffy.deng """
新问题：对于一个大的dict，需要调用很多次type来生成类，我不知道这样是不是会导致性能降低很多，或者可以找到一个更好的方法来解决这个问题？谁有解决方案吗？请上代码。谢谢

1. #! /usr/bin/env python                                                                                                                                                                  
   
2. 
   
3. import types
   
4. 
   
5. foo = {'a': 1,
   
6.        'b': 2,
   
7.        'c': {'a': 22,
   
8.              'b': 23
   
9.            }
   
10.        }
    
11. 
    
12. 
    
13. def test_key(d):
    
14.     return isinstance(d, types.IntType)
    
15. 
    
16. 
    
17. class Data(object):
    
18.     def __init__(self, value):
    
19.         self._value = value
    
20.         pass
    
21. 
    
22.     def __get__(self, obj, type=None):
    
23.         return self._value + 2
    
24. 
    
25.     pass
    
26. 
    
27. 
    
28. def to_obj(dct, test_key, descriptor):
    
29.     x = type('xo0pP', (object,), dict())
    
30. 
    
31.     for key in dct.keys():
    
32.         if test_key(dct[key]):
    
33.             setattr(x, key, descriptor(dct[key]))
    
34.             pass
    
35.         else:
    
36.             setattr(x, key, to_obj(dct[key], test_key, descriptor))
    
37.             pass
    
38.         pass
    
39.     return x
    
40. 
    
41. 
    
42. if __name__ == "__main__":
    
43.     x = to_obj(foo, test_key, Data)
    
44.     print x.a      # 3                                                                                                                                                                  
    
45.     print x.c.b    # 25                                                                                                                                                                 
    
46. 
    

复制代码

shhgs

回复 7# tianshizhiluan


    看了你的代码，我不禁又想起了那句名言。

好的编程语言，能让你写出优雅的代码，但是谁都挡不住你去写烂代码。

shhgs

回复 5# luffy.deng


    对于你，恐怕得改成，谁都挡不住你去教别人去写烂代码。

luffy.deng

回复 9# shhgs
必须得说你的代码写的好，但这个问题不见得非得用你的办法。不但用type可以解决，而且还可以用元类来避免对动态生成的类实例化。
为什么不用你的办法就是烂办法？提一个不一样的解决问题的途径就是教别人写烂代码？

1. d= {'a':1,
   
2.     'b':2,
   
3.     'c':{'e':1,
   
4.          'f':2
   
5.          }
   
6.     }
   
7. class Meta(type):
   
8.     def __getattribute__(self,name):
   
9.         _attr=object.__getattribute__(self,name)
   
10.         if isinstance(_attr,dict):
    
11.             setattr(self,name,Meta('',(object,),_attr))
    
12.             _attr=object.__getattribute__(self,name)
    
13.         return _attr
    
14. foo=Meta('foo',(object,),d)
    
15. print foo.c.g

复制代码

实际上你写的那段还是有点问题的，对于一个不存在的属性比如foo.c.xxxx会返回None而不是抛出AttributeError异常。