可爱的豆子——使用Beans思想让Python代码更易维护
我曾经是一个对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里面，我以前会写这样的代码：
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代码的时候，也会保留了这个坏习惯，于是我定义的一个变量类似于这样：
public Map<String, List<Map<String, Map<String, Object>>>> info = .....
并且由于Java是强类型语言，有时候Map里面的Value类型还不一致，需要使用Object来代替，等要使用的时候再做类型转换。
对于这样的写法，真可谓是写代码一时爽，调试代码火葬场。我过几天读自己的代码，自己都不知道这个字典里面有哪些内容，也不知道它们有哪些类型，必须到定义的地方去看。
我的Mentor看了我的Java代码以后，让我去用一下JavaBeans，于是我的世界瞬间就简洁多了。后来我将JavaBeans的思想用到Python中，果然Python代码也变得好看多了。
使用上面person_list这个复杂的结构为例，我用JavaBeans的思想，在Python里面重构它：
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
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
从这里可以看到，我把字典变成了类。于是，当我想保存我自己的信息和小明的时候，我就可以这样写：
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 。
所以要查看每个人的工资，我可以这样写:
for person in person_list:
detail = person.detail
salary = detail.salary
print(salary)
但是如果我使用的是最上面字典的那种方式，那么情况就没有这么简单了。因为我不知道工资是在这个字典的什么地方。于是我首先要找到 person_list 是在哪里初始化的，然后看它里面有什么。在这个例子中，我是一次性把整个列表字典初始化完成的，直接找到列表初始化的地方就知道，原来这个 person_list 下面有很多个字典，字典有一个key 叫 detail ,这个 detail 的value本身又是一个字典，它下面的key salary 保存了工资的信息。这似乎还比较方便。但是如果字典里面的信息不是一次性初始化完成的呢？万一 detail 这一个key是后面再加的呢？于是又要去找 detail 初始化的地方……
第二个好处，使用Beans的时候，每个关键字是定义好的， salary 就只能叫做 salary ，如果写成了 salarv , 集成开发环境会立刻告诉你， Detail 没有 salarv 这个属性。但是如果使用字典的方式，我在给字典赋值的时候，一不小心:
detail['salarv'] = 0.5
由于这里的 salarv 是字符串，所以集成开发环境是不会报错的，只有等你运行的时候,尝试读取 detail['salary'] 里面的值，Python会告诉你:
Traceback (most recent call last):
File "xxx.py", line 1, in <module>
KeyError: 'salary'
正文到此结束
热门推荐
相关文章
近期评论
-
666
-
文章和留言都翻到11页了 没有OOM
-
-
朋友，翻页到11页，及以后，会出现OOM，无法访问
-
-
-
-
版本号是多少，你可以下载哪个代码仓库，jdk选1.8 直接跑就行
-
-
Loading...
![[HBLOG]公众号](https://www.liuhaihua.cn/img/qrcode_gzh.jpg)
