一. 使用字典和元组保存内部状态

Python 内置的 dict 类型可以很好地保存对象在其生命周期的动态内部状态。所谓动态，即这些被保存的信息，其标识符无法提前获知。

例如，下面的简易成绩簿类中，将学生和学生成绩保存在一个字典中，但这些学生的名字，我们事先并不知道：

class SimpleGradebook:
    def __init__(self):
        self._grades = {}
        
    def add_student(self, name):
        self._grades[name] = []
        
    def report_grade(self, name, score):
        self._grades[name].append(score)
        
    def average_grade(self, name):
        grades = self._grades[name]
        return sum(grades) / len(grades)

使用示例：

>> grade_book = SimpleGradebook()
>> grade_book.add_student('Alex')
>> grade_book.report_grade('Alex', 100)
>> grade_book.report_grade('Alex', 60)
>> grade_book.average_grade('Alex')
80.0

现在，假设提出了新的需求，需要按科目来分类保存每个学生的成绩，而不是像前面那样把所有科目的成绩都保存到一起。扩充后的 SimpleGradebook 类我们使用 BySubjectGradeBook 表示：

class BySubjectGradebook:
    def __init__(self):
        self._grades = {}
        
    def add_student(self, name):
        self._grades[name] = {}
        
    def report_grade(self, name, subject, score):
        by_subject = self._grades[name]
        grade_list = by_subject.setdefault(subject, [])
        grade_list.append(score)
        
    def average_grade(self, name):
        by_subject = self._grades[name]
        total, count = 0, 0
        for grades in by_subject.values():
            total += sum(grades)
            count += len(grades)
        return total / count

使用示例：

>> grade_book = BySubjectGradebook()
>> grade_book.add_student('Alex')
>> grade_book.report_grade('Alex', 'Math', 100)
>> grade_book.report_grade('Alex', 'Math', 80)
>> grade_book.report_grade('Alex', 'English',60)
>> grade_book.report_grade('Alex', 'English',120)
>> grade_book.average_grade('Alex')
90.0

由于维护内部状态的 _grade 变成了一个嵌套字典，所以 report_grade 和 average_grade 的处理也开始变得复杂。我们不妨可以打印一下 _grade 的结构：

>> grade_book._grades
{'Alex': {'Math': [100, 80], 'English': [60, 120]}}

如果上面的类你还可以接受，那接下来的扩展，如果继续使用字典，将会变得十分复杂难懂。新的需求：除了需要记录每次考试的成绩，还需要记录每次考试的权重，比如期末和其中考试所占的权重自然是要大于月考成绩的。

下面，我们继续修改内部维护的字典，并将成绩和权重作为一个元组，放入科目对应的列表：

class WeightedGradebook:
    def __init__(self):
        self._grades = {}
        
    def add_student(self, name):
        self._grades[name] = {}
        
    def report_grade(self, name, subject, score, weight):
        by_subject = self._grades[name]
        grade_list = by_subject.setdefault(subject, [])
        grade_list.append((score, weight))
        
    def average_grade(self, name):
        by_subject = self._grades[name]
        score_sum, weight_sum = 0, 0
        for subject, grades in by_subject.items():
            subject_avg, subject_total, total_weight = 0, 0, 0
            for score, weight in grades:
                subject_total += score * weight
                total_weight += weight
            subject_avg = subject_total / total_weight
            score_sum += subject_avg
            weight_sum += 1
        return score_sum / weight_sum

使用示例：

>> grade_book = WeightedGradebook()
>> grade_book.add_student('Alex')
>> grade_book.report_grade('Alex', 'Math', 80, 0.1)
>> grade_book.report_grade('Alex', 'Math', 80, 0.4)
>> grade_book.report_grade('Alex', 'English',60, 0.6)
>> grade_book.report_grade('Alex', 'English',120, 0.4)
>> grade_book.average_grade('Alex')
82.0

上述的加权计算过程即：((80*0.1+80*0.4)/(0.1+0.4) + (60*0.6+120*0.4)/(0.6+0.4))/2 = 82，可见 average_grade 方法已经变得非常复杂，包含了嵌套循环，非常不利于代码的阅读和维护。

二. 把嵌套结构重构为类

起初，我们并不知道后来需要实现带权重的分数统计，根据当时的复杂度来看没必要编写辅助类。使用 Python 内置的 dict 和 tuple 很容易就能构建出分层的数据结构，从而保存程序的内部状态。但是，当嵌套多余一层的时候，就应避免这样做了，例如，不要使用包含字典的字典。这种多层嵌套的代码，非常不易于阅读和维护。

用来保存程序状态的数据结构一旦变得过于复杂，就应该将其拆解为类，以便提供更为明确的接口，并更好地封装数据。这样做也能够在接口与具体实现之间创建抽象层。

下面，我们就从依赖关系的最底层 - 成绩，开始重构。成绩包含分数和权重两个属性，但这两个属性都是不会发生变化的，因此可以使用具名元组来定义精简而又不可变的数据类型：

import collections

Grade = collections.namedtuple('Grade', ['score', 'weight'])

接下来是表示科目的类，该类包含一系列考试成绩：

class Subject:
    def __init__(self):
        self._grades = []
        
    def report_grade(self, score, weight):
        self._grades.append(Grade(score, weight))
        
    def average_grade(self):
        total, total_weight = 0, 0
        for grade in self._grades:
            total += grade.score * grade.weight
            total_weight += grade.weight
        return total / total_weight

然后是表示学生的类，该类包含了此学生参加考试的所有课程：

class Student:
    def __init__(self):
        self._subjects = {}
        
    def subject(self, name):
        if name not in self._subjects:
            self._subjects[name] = Subject()
        return self._subjects[name]
    
    def average_grade(self):
        total, count = 0, 0
        for subject in self._subjects.values():
            total += subject.average_grade()
            count += 1
        return total / count

最后，编写包含所有考生考试成绩的类，该容器以学生的名字为键，并且可以动态地添加学生：

class Gradebook:
    def __init__(self):
        self._students = {}
        
    def student(self, name):
        if name not in self._students:
            self._students[name] = Student()
        return self._students[name]

重构完成，我们来使用以下重构之后的类：
创建成绩簿 book ，添加学生 Alex ，并录入参加考试的两门课程：

>> book = Gradebook()
>> alex = book.student('Alex')
>> math = alex.subject('Math')
>> english = alex.subject('English')

记录每门课程每次的考试成绩以及权重：

>> math.report_grade(80, 0.1)
>> math.report_grade(80, 0.4)
>> english.report_grade(60, 0.6)
>> english.report_grade(120, 0.4)

计算 Alex 考生所有科目的平均成绩：

>> alex.average_grade()
82.0