Python中如何避免字典和元组的多重嵌套的方法

星空下的回忆

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

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

分析：定义一个 SimpleGradebook类，
学生名是字典self._grades的键，成绩是字典self._grades的值。

1. class SimpleGradebook():
2.     def __init__(self):
3.         self._grades = {}
4.     def add_student(self, name):
5.         self._grades[name] = []
6.     def report_grade(self, name, score):
7.         self._grades[name].append(score)
8.     def average_grade(self, name):
9.         grades = self._grades[name]
10.         return self._grades, sum(grades) / len(grades)

复制代码

1. book = SimpleGradebook()
2. book.add_student('qinlu')
3. book.report_grade('qinlu', 99)
4. print(book.average_grade('qinlu'))

复制代码

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

复制代码

字典可能因为功能过多导致结果多重嵌套。
例 2：扩充 SimpleGradebook类，按科目保存成绩。

分析：定义一个 BySubjectGradebook类，字典by_subject嵌套在字典self._grades内。
学生名是字典self._grades的键，科目、成绩是self._grades的值。
科目是字典by_subject的键，成绩是字典by_subject的值。

1. class BySubjectGradebook():
2.     """
3.         report_grade(), average_grade()嵌套了两层的字典
4.     """
5.     def __init__(self):
6.         self._grades = {}
7.     def add_student(self, name):
8.         self._grades[name] = {}
9.     def report_grade(self, name, subject, score):
10.         by_subject = self._grades[name]
11.         grade_list = by_subject.setdefault(subject, [])
12.         grade_list.append(score)
13.     def average_grade(self, name):
14.         by_subject = self._grades[name]
15.         total, count = 0, 0
16.         for scores in by_subject.values():
17.             total += sum(scores)
18.             count += len(scores)
19.         return self._grades, total / count

复制代码

1. book = BySubjectGradebook()
2. book.add_student('qinlu')
3. book.report_grade('qinlu', 'Math', 99)
4. book.report_grade('qinlu', 'Math', 88)
5. book.report_grade('qinlu', 'Computer', 90)
6. book.report_grade('qinlu', 'Computer', 80)
7. print(book.average_grade('qinlu'))

复制代码

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

复制代码

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

1. class WeightedGradebook():
2.     def __init__(self):
3.         self._grades = {}
4.     def add_student(self, name):
5.         self._grades[name] = {}
6.     def report_grade(self, name, subject, score, weight):
7.         by_subject = self._grades[name]
8.         grade_list = by_subject.setdefault(subject, [])
9.         grade_list.append(score, weight)
10.     def average_grade(self, name):
11.         by_subject = self._grades[name]
12.         score_sum, score_count = 0, 0
13.         for subject, scores in by_subject.items():
14.             subject_avg, total_weight = 0, 0
15.             for score, weight in scores:
16.                 #...
17.         return score_sum / score_count

复制代码

1. book = WeightedGradebook()
2. book.add_student('qinlu')
3. book.report_grade('qinlu', 'Math', 99, 0.1)
4. book.report_grade('qinlu', 'Math', 88, 0.6)
5. book.report_grade('qinlu', 'Computer', 90, 0.1)
6. book.report_grade('qinlu', 'Computer', 80, 0.6)
7. print(book.average_grade('qinlu'))

复制代码

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

将下面的字典重构为类。
字典by_subject嵌套在字典self._students内。

1. {'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()命名元组。

1. from collections import namedtuple
2. #学习中遇到问题没人解答？小编创建了一个Python学习交流群：153708845
4. Grade = namedtuple('Grade', ('score', 'weight'))
6. # 科目类，该类包含考试成绩
7. class Subject():
8.     def __init__(self):
9.         self._grades = []
10.     def report_grade(self, score, weight):
11.         self._grades.append(Grade(score, weight))
12.     def average_grade(self):
13.         total, total_weight = 0, 0
14.         # print(self._grades)
15.         for grade in self._grades:
16.             # print(grade)
17.             total += grade.score * grade.weight
18.             total_weight += grade.weight
19.         return total / total_weight
21. # 学生类，该类包含学习课程
22. class Student():
23.     def __init__(self):
24.         self._subjects = {}
25.     def subject(self, name):
26.         if name not in self._subjects:
27.             self._subjects[name] = Subject()
28.         return self._subjects[name]
29.     def average_grade(self):
30.         total, count = 0, 0
31.         for subject in self._subjects.values():
32.             total += subject.average_grade()
33.             count += 1
34.         return total / count
36. # 成绩册类，包含所有学生考试成绩的容器类，该容器类以学生名字为键，可动态添加学生
37. class Gradebook():
38.     def __init__(self):
39.         self._students = {}
40.     def student(self, name):
41.         if name not in self._students:
42.             self._students[name] = Student()
43.         return self._students[name]
45. book = Gradebook()
46. qin = book.student('qinlu')
47. math = qin.subject('Math')
48. math.report_grade(99, 0.1)
49. math.report_grade(88, 0.9)
50. print(qin.average_grade())

复制代码

1. 89.1

复制代码

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

来源:https://www.cnblogs.com/python1111/p/18191668
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！