可爱的豆子——使用Beans思想让Python代码更易维护

发表于 更新于 分类于 阅读次数： 本文字数： 1.5k 阅读时长 ≈ 5 分钟

我曾经是一个对Java非常反感的人，因为Java的语法非常啰嗦。而用惯了动态类型的Python再使用静态类型的Java就会觉得多出了很多的工作量。

因为工作的关系，我开始使用Java来做项目。在这个过程中，我发现Java在某些方面确实和Python不一样。

有一句话说的好：

语言决定了世界观。

当我Java用的越来越多的时候，我渐渐发现我不是那么讨厌它了。

今天我要讲的，是我从Java里面学到的，一个被称为JavaBeans的东西。

In computing based on the Java Platform, JavaBeans are classes that encapsulate many objects into a single object (the bean). They are serializable, have a zero-argument constructor, and allow access to properties using getter and setter methods.

一句话概括起来： 当一些信息需要使用类似于字典套字典套列表这种很深的结构来储存的时候，请改用类来储存。

在Python里面，我以前会写这样的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
person_list = [{
        'name': 'kingname',
        'age': 23,
        'sex': 'male'
        'detail': {
                    'address': 'xxx',
                    'work': 'engineer',
                    'salary': 100000
            }
},
{
        'name': 'xiaoming',
        'age': 65,
        'sex': 'male'
        'detail': {
                    'address': 'yyy',
                    'work': 'pm',
                    'salary': 0.5
            }
}]

由于Python动态类型的特点，字典里面的value经常是包含了各种类型，有时候，字典里面包含了字典，里面的字典里面还有列表，这个内部字典里面的列表里面又包含了字典……

当我刚刚开始写Java代码的时候，也会保留了这个坏习惯，于是我定义的一个变量类似于这样：

1
public Map<String, List<Map<String, Map<String, Object>>>> info = .....

并且由于Java是静态类型语言，有时候Map里面的Value类型还不一致，需要使用Object来代替，等要使用的时候再做类型转换。

对于这样的写法，真可谓是写代码一时爽，调试代码火葬场。我过几天读自己的代码，自己都不知道这个字典里面有哪些内容，也不知道它们有哪些类型，必须到定义的地方去看。

我的Mentor看了我的Java代码以后，让我去用一下JavaBeans，于是我的世界瞬间就简洁多了。后来我将JavaBeans的思想用到Python中，果然Python代码也变得好看多了。

使用上面person_list这个复杂的结构为例，我用JavaBeans的思想，在Python里面重构它：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
class Person(object):
    def __init__(self, name='', age=0, sex='', detail=None):
        self._name = name
        self._age = age
        self._sex = sex
        self._detail = detail
    
    @property
    def name(self):
        return self._name
    
    @name.setter
    def name(self, new_name):
        self._name = new_name
    
    @property
    def age(self):
        return self._age
    
    @age.setter
    def age(self, new_age):
        self._age = new_age
    
    @property
    def sex(self):
        return self._sex
    
    @sex.setter
    def sex(self, new_sex):
        self._sex = new_sex
    
    @property
    def detail(self):
        return self._detail
    
    @detail.setter
    def detail(self, new_detail):
        self._detail = new_detail
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class Detail(object):
    def __init__(self, address='', work='', salary=0):
        self._address = address
        self._work = work
        self._salary = salary
    
    @property
    def address(self):
        return self._address
    
    @address.setter
    def address(self, new_address):
        self._address = new_address
    
    @property
    def work(self):
        return self._work
    
    @work.setter
    def work(self, new_work):
        self._work = new_work
    
    @property
    def salary(self):
        return self._salary
    
    @salary.setter
    def salary(self, new_salary):
        self._salary = new_salary

从这里可以看到，我把字典变成了类。于是，当我想保存我自己的信息和小明的时候，我就可以这样写：

1
2
3
4
5
6
7
detail_kingname = Detail(address='xxx', work='engineer', salary=10000),
kingname = Person(name='kingname', age=23, sex='male', detail=detail_kingname)

detail_xiaoming = Detail(address='yyy', work='pm', salary=0.5),
xiaoming = Person(name='xiaoming', age=65, sex='male', detail=detail_xiaoming)

person_list = [kingname, xiaoming]

这样写，虽然说代码量确实翻了不止一倍，但是当我们后期维护的时候或者遇到问题来调试代码，我们就能发现这样写的好处。

举一个很简单的例子，在写了代码一年以后，我已经对这段代码没有多少印象了，现在我得到了变量person_list, 我想查看每个人的工资。首先，由于Person和Detail这两个类是已经定义好的，分别放在Person.py和Detail.py两个文件中，于是我点开它们，就知道，原来工资是保存在Detail这个类中的，关键词是salary, 而Detail又是保存在Person中的，关键词是detail。

所以要查看每个人的工资，我可以这样写:

1
2
3
4
for person in person_list:
    detail = person.detail
    salary = detail.salary
    print(salary)

但是如果我使用的是最上面字典的那种方式，那么情况就没有这么简单了。因为我不知道工资是在这个字典的什么地方。于是我首先要找到person_list是在哪里初始化的，然后看它里面有什么。在这个例子中，我是一次性把整个列表字典初始化完成的，直接找到列表初始化的地方就知道，原来这个person_list下面有很多个字典，字典有一个key 叫detail,这个detail的value本身又是一个字典，它下面的keysalary保存了工资的信息。这似乎还比较方便。但是如果字典里面的信息不是一次性初始化完成的呢？万一detail这一个key是后面再加的呢？于是又要去找detail初始化的地方……

第二个好处，使用Beans的时候，每个关键字是定义好的，salary就只能叫做salary，如果写成了salarv, 集成开发环境会立刻告诉你，Detail没有salarv这个属性。但是如果使用字典的方式，我在给字典赋值的时候，一不小心:

1
detail['salarv'] = 0.5

由于这里的salarv是字符串，所以集成开发环境是不会报错的，只有等你运行的时候,尝试读取detail['salary']里面的值，Python会告诉你:

1
2
3
Traceback (most recent call last):
  File "xxx.py", line 1, in <module>
KeyError: 'salary'

总结

将JavaBeans的思想用在Python中，避免字典套字典这种深层嵌套的情况，对于一些需要反复使用的字典，使用类来表示。这样做，别人读代码的时候会更加的容易，自己开发的时候，也会避免出现问题。

本文首发于：http://kingname.info/2016/06/19/bean-in-python/ 转载请注明出处。