需求
老实说，单纯的研究语言细节，比较无趣且容易忘记。这次的研究，起源于一个业务场景的需求，跟着场景需求深入语言细节更容易理解和记忆。
我们有一个玩家的session字典集合，希望记录玩家的连接信息，大概伪代码是这样的:
# 创建玩家字典集合 player_session_dict = {} # 设置玩家 player_session_dict["1000"]="playerA" # 判断玩家连接 assert player_session_dict["1000"] == "playerA" 复制代码
一般情况下使用 {} 没有问题 , 但是某些协议会把玩家的ID使用int型，获取session就报错了:
assert player_session_dict[1000] == "playerA" # error 复制代码
要解决这个问题，希望实现一个数据结构来存储session，使用int/str均可以获取到玩家对应的session:
player_session_dict = SomeDict() player_session_dict[1000]="playerA" # 使用int作为key可以获取 assert player_session_dict[1000] == "playerA" assert player_session_dict.get(1000) == "playerA" # 使用string作为key也可以获取 assert player_session_dict["1000"] == "playerA" assert player_session_dict.get("1000") == "playerA" 复制代码
本文包括下面几个部分
- object vs dict
- 访问属性的4种方法
- 对象的 __dict__ 属性
- 使用slot限制对象
- 实现SomeDict类
- 总结
- 小技巧
object vs dict
首先从python的对象和字典入手，编写下面的测试用例:
>>> class A: ... pass ... >>> a = A() >>> class B(object): ... pass ... >>> b = B() >>> class C(dict): ... pass ... >>> c = C() 复制代码
A类是旧式写法，B类是新式写法，我习惯使用B类写法，感觉更明确
判断a，b，c三个对象的类型和继承关系:
>>> isinstance(a, object) True >>> isinstance(a, dict) False >>> isinstance(b, object) True >>> isinstance(b, dict) False >>> isinstance(c, object) True >>> isinstance(c, dict) True 复制代码
可以看到dict继承自对象object，这个符合常识。从源码 builtins.py 中也可以验证这一点:
class dict(object): ... 复制代码
目前看来，我们的数据结构SomeDict即可以派生自object，也可以派生自dict。
并且通过测试可以发现，使用{}和dict()都是创建字典，使用上没有差异:
>>> a = {} >>> b = dict() >>> type(a) <class 'dict'> >>> type(b) <class 'dict'> >>> a == b True >>> a is b False 复制代码
内存占用也一样:
>>> import sys >>> >>> sys.getsizeof(a) 280 >>> b = dict() >>> sys.getsizeof(b) 280 复制代码
访问属性的4种方法
python中获取对象属性大概有下面几种方法:
.点: 访问object的属性attribute，不存在会报AttributeError[]方括号: 根据索引获取list/map对应的值，字典索引不存在会报KeyError(list索引不存在会报IndexError)getget方法，同方括号，区别是索引不存在不会报错- 使用
in判断属性是否存在
普通的对象可以使用 . 获取属性：
>>> class A(object): ... pass ... >>> a = A() >>> a.name = "aa" >>> a.name 'aa' 复制代码
同时普通类不可以使用 [] 和 get 方法获取属性:
>>> a["name"] Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'A' object does not support item assignment >>> a.get("name") Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'A' object has no attribute 'get' >>> a <__main__.A object at 0x10de4fad0> 复制代码
普通的字典可以使用 [] 获取属性:
>>> b = {} >>> b["name"] Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'name' >>> b["name"] = "bb" >>> b["name"] 'bb' 复制代码
当属性不存在的时候会报KeyError的错误，可以使用get方法更安全，不存在的属性会返回none:
>>> b.get("age") >>> print(b.get("age")) None 复制代码
也可以使用in对字典属性是否存在进行先行判断，确认存在后再进行获取:
>>> if "age" in b: ... print("age in b") ... print(b["age"]) ... 复制代码
普通的字典不可以使用 . 获取属性:
>>> b.name Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'dict' object has no attribute 'name' 复制代码
如果一个类，派生自字典呢？先看代码:
>>> class C(dict): ... pass ... >>> >>> c = C() >>> c.name = "cc" >>> c.name 'cc' >>> c["age"] = 10 >>> c["age"] 10 复制代码
c对象即可使用.获取属性, 也可以使用[] 获取属性，兼具object和dict的特性。但是需要注意的是不可以混搭使用:
>>> c["name"] Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'name' >>> >>> c.age Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'B' object has no attribute 'age' 复制代码
get和in的使用和[]的表现一致:
>>> c.get("name") >>> c.get("age") 10 >>> "name" in c False >>> "age" in c True 复制代码
查看get方法，可以找到相关定义:
class Mapping(_Collection[_KT], Generic[_KT, _VT_co]): # TODO: We wish the key type could also be covariant, but that doesn't work, # see discussion in https: //github.com/python/typing/pull/273. @abstractmethod def __getitem__(self, k: _KT) -> _VT_co: ... # Mixin methods @overload def get(self, k: _KT) -> Optional[_VT_co]: ... @overload def get(self, k: _KT, default: Union[_VT_co, _T]) -> Union[_VT_co, _T]: ... def items(self) -> AbstractSet[Tuple[_KT, _VT_co]]: ... def keys(self) -> AbstractSet[_KT]: ... def values(self) -> ValuesView[_VT_co]: ... def __contains__(self, o: object) -> bool: ... 复制代码
in 对应的就是 contains 方法。Mapping又mixin自Collection，所以也可以使用[]
对象的 __dict__ 属性
要完全理解上面的c对象的使用差异，需要了解object的实现，其中主要就有 __dict__ 。 先看代码:
>>> class C(dict): ... pass ... >>> c = C() >>> c.name = "cc" >>> >>> c["age"] = 10 >>> >>> c {'age': 10} >>> >>> c.__dict__ {'name': 'bb'} 复制代码
可以看到c对象的表现分离出两个字典。一个是字典部分，从dict而来，可以使用 [] ; 另一种是继承自对象的 __dict__, 可以使用 .。
__dict__是自定义对象的隐藏属性，比如前面的a对象:
>>> a.__dict__ {'name': 'aa'} 复制代码
甚至A类:
>>> A.__dict__ dict_proxy({'__dict__': <attribute '__dict__' of 'A' objects>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}) 复制代码
下面是官方文档中的相关解释:
自定义类(Custom classes)：每个类都有通过一个字典对象实现的独立命名空间。类属性引用会被转化为在此字典中查找，例如 C.x 会被转化为 C.dict["x"]
类实例(Class instances): 每个类实例都有通过一个字典对象实现的独立命名空间，属性引用会首先在此字典中查找。当未在其中发现某个属性，而实例对应的类中有该属性时，会继续在类属性中查找。特殊属性: dict 为属性字典; class 为实例对应的类。
映射/字典(Mapping/Dictionary): 此类对象表示由任意索引集合所索引的对象的集合。通过下标 a[k] 可在映射 a 中选择索引为 k 的条目；这可以在表达式中使用，也可作为赋值或 del 语句的目标。内置函数 len() 可返回一个映射中的条目数。
这里的命名空间可以理解成作用域，比如:
name = "aaa" def func(): name = "bbb" pass 复制代码
这里的name定义在不同的作用域可以是不同的值，global里是aaa，在func里是bbb。同样对于C对象的实例c1和c2，同样的属性名称name指向不同的 __dict__命名空间。
使用slot限制对象
对于普通对象，我们可以这样定义和使用:
>>> class D(object): ... def __init__(self, name): ... self.name = name ... >>> >>> d = D("dd") >>> d.name 'dd' >>> d.__dict__ {'name': 'dd'} 复制代码
定义了name，然后使用name，非常自然。但是也可以这样动态的赋值和使用age属性:
>>> d.age = 10 >>> d.age 10 >>> d.__dict__ {'name': 'dd', 'age': 10} 复制代码
这样写的代码，就难以后期维护。可以使用__slots__来限制对象:
>>> class E(object): ... __slots__=("name") ... def __init__(self,name): ... self.name=name ... >>> e = E("ee") >>> e.name 'ee' >>> e.age = 10 Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'E' object has no attribute 'age' 复制代码
slot是插槽的意思，E定义了一个叫name的插槽，这样只允许使用预先定义的name属性，其它属性会报错。使用slots后，对象的__dict__也被优化了:
>>> b.__dict__ Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'B' object has no attribute '__dict__' 复制代码
实现SomeDict类
了解了上面这么多基础知识后，我们可以实现满足需求的SomeDict了。要表现的和 {} 一样，这样才不影响业务使用。
class SomeDict(dict): def __getitem__(self, item): # [] return super(SomeDict, self).__getitem__(str(item)) def __setitem__(self, key, value): super(SomeDict, self).__setitem__(str(key), value) def __delitem__(self, key): super(SomeDict, self).__delitem__(str(key)) def get(self, item): # get return super(SomeDict, self).get(str(item)) def __contains__(self, item): # in return super(SomeDict, self).__contains__(str(item)) 复制代码
下面是测试用例:
def test_some_dict(): session_clients = SomeDict() session_clients["1000"] = "1000" assert session_clients["1000"] == "1000" assert session_clients[1000] == "1000" assert session_clients.get("1000") == "1000" assert session_clients.get(1000) == "1000" assert session_clients.get("non_key") is None try: session_clients["non_key"] except KeyError as e: pass assert "1000" in session_clients assert 1000 in session_clients assert "non_key" not in session_clients assert 10001 not in session_clients del session_clients[1000] assert 1000 not in session_clients print("success") 复制代码
总结
我们深入了python语言的对象和字典的细节实现，比较了使用 . 和 [] 两种取值方式的差异，实现了一个仅字符串作为key的字典。简单总结起来就是:
- 对于自定义对象，可以使用 . 获取属性值
- 对于字典对象，可以使用 [] 获取属性值
- 对于字典对象，还可以使用 get 和 in 进行友好获取 (无异常)
性能小技巧
关于字典还有下面2个性能优化的小技巧。
{} 和 dict 的性能对比
使用timeit测试一下使用 {} 和 dict() 创建对象的速度:
$ python3 -m timeit 'x={}' 20000000 loops, best of 5: 18.1 nsec per loop $ python3 -m timeit 'x=dict()' 5000000 loops, best of 5: 93.6 nsec per loop 复制代码
可以发现使用{}语法要快很多。我们编写下面测试用例:
a = {} b = dict() 复制代码
这是测试用例编译后的结果:
1 0 BUILD_MAP 0 2 STORE_NAME 0 (a) 3 4 LOAD_NAME 1 (dict) 6 CALL_FUNCTION 0 8 STORE_NAME 2 (b) 10 LOAD_CONST 0 (None) 12 RETURN_VALUE 复制代码
可以看到前者就是一个BUILD_MAP语句，后者还包括调用构造函数等，所以前者要快，性能更好。
slots 性能对比
同样可以使用timeit对slot进行测试:
# python3 -m timeit -s 'class A(object):pass' -- "A()" # 5000000 loops, best of 5: 67.2 nsec per loop # python3 -m timeit -s 'class A(object): __slots__ = ("x",) ' -- "A()" # 5000000 loops, best of 5: 63.1 nsec per loop 复制代码
很容易发现使用slot后，创建对象速度也会变快。
