python 对象杂谈

需求

老实说，单纯的研究语言细节，比较无趣且容易忘记。这次的研究，起源于一个业务场景的需求，跟着场景需求深入语言细节更容易理解和记忆。

我们有一个玩家的session字典集合，希望记录玩家的连接信息，大概伪代码是这样的:

1
2
3
4
5
6


# 创建玩家字典集合
player_session_dict = {}
# 设置玩家
player_session_dict["1000"]="playerA"
# 判断玩家连接
assert player_session_dict["1000"] == "playerA"

一般情况下使用 {} 没有问题 , 但是某些协议会把玩家的ID使用int型，获取session就报错了:

1

assert player_session_dict[1000] == "playerA"  # error

要解决这个问题，希望实现一个数据结构来存储session，使用int/str均可以获取到玩家对应的session:

1
2
3
4
5
6
7
8
9


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的对象和字典入手，编写下面的测试用例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


>>> class A:
...     pass
... 
>>> a = A()
>>> class B(object):
...     pass
... 
>>> b = B()
>>> class C(dict):
...     pass
... 
>>> c = C()

A类是旧式写法，B类是新式写法，我习惯使用B类写法，感觉更明确

判断a，b，c三个对象的类型和继承关系:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


>>> 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 中也可以验证这一点:

1
2


class dict(object):
    ...

目前看来，我们的数据结构SomeDict即可以派生自object，也可以派生自dict。

并且通过测试可以发现，使用{}和dict()都是创建字典，使用上没有差异:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


>>> a = {}
>>> b = dict()
>>> type(a)
<class 'dict'>
>>> type(b)
<class 'dict'>
>>> a == b
True
>>> a is b
False

内存占用也一样:

1
2
3
4
5
6
7


>>> import sys
>>>
>>> sys.getsizeof(a)
280
>>> b = dict()
>>> sys.getsizeof(b)
280

访问属性的4种方法

python中获取对象属性大概有下面几种方法:

. 点: 访问object的属性attribute，不存在会报AttributeError
[] 方括号: 根据索引获取list/map对应的值，字典索引不存在会报KeyError(list索引不存在会报IndexError)
get get方法，同方括号，区别是索引不存在不会报错
使用 in 判断属性是否存在

普通的对象可以使用 . 获取属性：

1
2
3
4
5
6
7


>>> class A(object):
...     pass
...
>>> a = A()
>>> a.name = "aa"
>>> a.name
'aa'

同时普通类不可以使用 [] 和 get 方法获取属性:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


>>> 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>

普通的字典可以使用 [] 获取属性:

1
2
3
4
5
6
7
8


>>> 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:

1
2
3


>>> b.get("age")
>>> print(b.get("age"))
None

也可以使用in对字典属性是否存在进行先行判断，确认存在后再进行获取:

1
2
3
4


>>> if "age" in b:
...     print("age in b")
...     print(b["age"])
...

普通的字典不可以使用 . 获取属性:

1
2
3
4


>>> b.name
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'dict' object has no attribute 'name'

如果一个类，派生自字典呢？先看代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


>>> class C(dict):
...     pass
...
>>>
>>> c = C()
>>> c.name = "cc"
>>> c.name
'cc'
>>> c["age"] = 10
>>> c["age"]
10

c对象即可使用.获取属性, 也可以使用[] 获取属性，兼具object和dict的特性。但是需要注意的是不可以混搭使用:

1
2
3
4
5
6
7
8
9


>>> 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的使用和[]的表现一致:

1
2
3
4
5
6
7


>>> c.get("name")
>>> c.get("age")
10
>>> "name" in c
False
>>> "age" in c
True

查看get方法，可以找到相关定义:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


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__ 。先看代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


>>> class C(dict):
...     pass
...
>>> c = C()
>>> c.name = "cc"
>>>
>>> c["age"] = 10
>>>
>>> c
{'age': 10}
>>>
>>> c.__dict__
{'name': 'bb'}

可以看到c对象的表现分离出两个字典。一个是字典部分，从dict而来，可以使用 [] ; 另一种是继承自对象的 __dict__, 可以使用 .。

__dict__是自定义对象的隐藏属性，比如前面的a对象:

1
2


>>> a.__dict__
{'name': 'aa'}

甚至A类:

1
2


>>> 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() 可返回一个映射中的条目数。

这里的命名空间可以理解成作用域，比如:

1
2
3
4


name = "aaa"
    def func():
        name = "bbb"
        pass

这里的name定义在不同的作用域可以是不同的值，global里是aaa，在func里是bbb。同样对于C对象的实例c1和c2，同样的属性名称name指向不同的 __dict__命名空间。

使用slot限制对象

对于普通对象，我们可以这样定义和使用:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


>>> class D(object):
...     def __init__(self, name):
...             self.name = name
...
>>>
>>> d = D("dd")
>>> d.name
'dd'
>>> d.__dict__
{'name': 'dd'}

定义了name，然后使用name，非常自然。但是也可以这样动态的赋值和使用age属性:

1
2
3
4
5


>>> d.age = 10
>>> d.age
10
>>> d.__dict__
{'name': 'dd', 'age': 10}

这样写的代码，就难以后期维护。可以使用__slots__来限制对象:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


>>> 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__也被优化了:

1
2
3
4


>>> b.__dict__
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'B' object has no attribute '__dict__'

实现SomeDict类

了解了上面这么多基础知识后，我们可以实现满足需求的SomeDict了。要表现的和 {} 一样，这样才不影响业务使用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


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))

下面是测试用例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


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() 创建对象的速度:

1
2
3
4


$ 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

可以发现使用{}语法要快很多。我们编写下面测试用例:

1
2
3


a = {}

b = dict()

这是测试用例编译后的结果:

1
2
3
4
5
6
7
8


  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进行测试:

1
2
3
4


# 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后，创建对象速度也会变快。

python 对象杂谈

文章目录

需求

object vs dict

访问属性的4种方法

对象的 dict 属性

使用slot限制对象

实现SomeDict类

总结

性能小技巧

{} 和 dict 的性能对比

slots 性能对比

参考链接

文章目录

需求

object vs dict

访问属性的4种方法

对象的 __dict__ 属性

使用slot限制对象

实现SomeDict类

总结

性能小技巧

{} 和 dict 的性能对比

slots 性能对比

参考链接

对象的 dict 属性