老实说，单纯的研究语言细节，比较无趣且容易忘记。这次的研究，起源于一个业务场景的需求，跟着场景需求深入语言细节更容易理解和记忆。
我们有一个玩家的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"本文包括下面几个部分
首先从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)
280python中获取对象属性大概有下面几种方法:
. 点: 访问object的属性attribute，不存在会报AttributeError[] 方括号: 根据索引获取list/map对应的值，字典索引不存在会报KeyError(list索引不存在会报IndexError)get get方法，同方括号，区别是索引不存在不会报错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"]
10c对象即可使用.获取属性, 也可以使用[] 获取属性，兼具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，所以也可以使用[]
要完全理解上面的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__命名空间。
对于普通对象，我们可以这样定义和使用:
>>> 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了。要表现的和 {} 一样，这样才不影响业务使用。
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的字典。简单总结起来就是:
关于字典还有下面2个性能优化的小技巧。
使用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语句，后者还包括调用构造函数等，所以前者要快，性能更好。
同样可以使用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后，创建对象速度也会变快。
Copyright© 2013-2020
All Rights Reserved 京ICP备2023019179号-8