Python 避免字典和元组的多重嵌套

一、字典、元组的多重嵌套

例 1：记录全班学生的成绩。

分析：定义一个 SimpleGradebook类，

学生名是字典self._grades的键，成绩是字典self._grades的值。

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 self._grades, sum(grades) / len(grades)

book = SimpleGradebook()
book.add_student(\'qinlu\')
book.report_grade(\'qinlu\', 99)
print(book.average_grade(\'qinlu\'))

({\'qinlu\': [99]}, 99.0)

字典可能因为功能过多导致结果多重嵌套。

例 2：扩充 SimpleGradebook类，按科目保存成绩。

分析：定义一个 BySubjectGradebook类，字典by_subject嵌套在字典self._grades内。

学生名是字典self._grades的键，科目、成绩是self._grades的值。

科目是字典by_subject的键，成绩是字典by_subject的值。

class BySubjectGradebook():
    \"\"\"
        report_grade(), average_grade()嵌套了两层的字典
    \"\"\"
    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 scores in by_subject.values():
            total += sum(scores)
            count += len(scores)
        return self._grades, total / count

book = BySubjectGradebook()
book.add_student(\'qinlu\')
book.report_grade(\'qinlu\', \'Math\', 99)
book.report_grade(\'qinlu\', \'Math\', 88)
book.report_grade(\'qinlu\', \'Computer\', 90)
book.report_grade(\'qinlu\', \'Computer\', 80)
print(book.average_grade(\'qinlu\'))

({\'qinlu\': {\'Math\': [99, 88], \'Computer\': [90, 80]}}, 89.25)

例 3：需求变更，需记录每次成绩占总成绩的权重。（期中、期末考试所占的分量比随堂考大）

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, score_count = 0, 0
        for subject, scores in by_subject.items():
            subject_avg, total_weight = 0, 0
            for score, weight in scores:
                #...
        return score_sum / score_count

book = WeightedGradebook()
book.add_student(\'qinlu\')
book.report_grade(\'qinlu\', \'Math\', 99, 0.1)
book.report_grade(\'qinlu\', \'Math\', 88, 0.6)
book.report_grade(\'qinlu\', \'Computer\', 90, 0.1)
book.report_grade(\'qinlu\', \'Computer\', 80, 0.6)
print(book.average_grade(\'qinlu\'))

该代码出现字典、元组的多层嵌套，应拆解为类。多层嵌套的代码，很难维护。

二、嵌套结构重构为类

将下面的字典重构为类。

字典by_subject嵌套在字典self._students内。

{\'qinlu\': {\'Math\': [(99, 0.1), (88, 0.9)], \'Computer\': [(90. 0.1), (80, 0.9)]}}

分析：

① Gradebook()类，学生名是字典self._students的键；科目、成绩、权重是self._grades的值。

② Student()类，科目是字典self._subjects的键；成绩、权重是self._subjects的值。

③ Subject()类，成绩是列表self._grades的第一位；权重是列表self._grades的第二位。

从最底层开始重构，即考试成绩。这么简单的信息，没必要写成类。

namedtuple()命名元组。

\'\'\'
学习中遇到问题没人解答？小编创建了一个Python学习交流群：711312441
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
\'\'\'
from collections import namedtuple

Grade = 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
        # print(self._grades)
        for grade in self._grades:
            # print(grade)
            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 = Gradebook()
qin = book.student(\'qinlu\')
math = qin.subject(\'Math\')
math.report_grade(99, 0.1)
math.report_grade(88, 0.9)
print(qin.average_grade())

89.1

虽然代码量是原来的两倍，但更清晰，更易扩展，理解起来比原来容易。

来源：https://www.cnblogs.com/djdjdj123/p/16492100.html
本站部分图文来源于网络，如有侵权请联系删除。