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

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

二、嵌套结构重构为类

将下面的字典重构为类。

字典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

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

到此这篇关于Python 避免字典和元组的多重嵌套的文章就介绍到这了,更多相关Python 多重嵌套内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • python 字典和列表嵌套用法详解

    python中字典和列表的使用,在数据处理中应该是最常用的,这两个熟练后基本可以应付大部分场景了.不过网上的基础教程只告诉你列表.字典是什么,如何使用,很少做组合说明. 刚好工作中采集prometheus监控接口并做数据处理的时候,用了很多组合场景,列出几个做一些分享. 列表(List) 序列是Python中最基本的数据结构.序列中的每个元素都分配一个数字 - 它的位置,或索引,第一个索引是0,第二个索引是1,依此类推. 列表是最常用的Python数据类型,它可以作为一个方括号内的逗号分隔值出现

  • 浅析python 字典嵌套

    为什么需要嵌套? 有时候,需要将一系列字典存储在列表中,或将列表作为值存储在字典中,这称为嵌套 .你可以在列表中嵌套字典.在字典中嵌套列表甚至在字典中嵌套字典. 字典列表 例如:字典alien_0包含一个外星人的信息,但无法存储第二个外星人的信息.怎么办呢? 我们可以创建三个外星人字典,那么问题来了,我们需要的是大量的外星人,有没有更简单的方式呢? alien_0 = {'color':'blue','points':'5'} alien_1 = {'color':'blue','points'

  • python 中字典嵌套列表的方法

    如下所示: >>> dict={} >>> dict['list']=[] >>> dict['list'].append([1,2,3,4]) >>> dict['list'].append([5,6,7]) >>> dict['list'].append([7,8,9,0,10]) 输出字典: >>> dict {'list': [[1, 2, 3, 4], [5, 6, 7], [7, 8,

  • Python里字典的基本用法(包括嵌套字典)

    Python字典的基本用法 创建字典: myDict1 = { '薛之谦':'我叫薛之谦', '吴青峰':'我叫吴青峰', '李宇春':'我叫李宇春', '花花':'我叫花花', '赵雷':'我叫赵雷' } emptyDict = {} myDict2 = dict(薛之谦 = '我叫薛之谦',吴青峰 = '我叫吴青峰') myDict3 = dict((('薛之谦','我叫薛之谦'),('吴青峰','我叫吴青峰'))) print(myDict1 ,'\n', myDict2 ,'\n', m

  • Python使用字典的嵌套功能详解

    当需要存储很多同类型的不通过数据时可能需要使用到嵌套,先用一个例子说明嵌套的使用 1.在列表中存储字典 #假设年级里有一群国际化的学生,有黄皮肤的中国人.有白皮肤的美国人也有黑皮肤的非洲人,只记录部分特征 student_1={'nationality':'China','colour':'yellow','age':'15'} student_2={'nationality':'America','colour':'white','age':'18'} student_3={'national

  • 基于python list对象中嵌套元组使用sort时的排序方法

    在list中嵌套元组,在进行sort排序的时候,产生的是原数组的副本,排序过程中,先根据第一个字段进行从小到大排序,如果第一个字段相同的话,再根据第二个字段进行排序,依次类推,当涉及到字母的时候,是按照字典序进行排序. 如下: a = [(1, 'B'), (1, 'A'), (1, 'C'), (1, 'AC'), (2, 'B'), (2, 'A'), (1, 'ABC')] a a.sort() a 输出结果为: [(1, 'B'), (1, 'A'), (1, 'C'), (1, 'AC

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

    目录 一.字典.元组的多重嵌套 二.嵌套结构重构为类 一.字典.元组的多重嵌套 例 1:记录全班学生的成绩. 分析:定义一个 SimpleGradebook类, 学生名是字典self._grades的键,成绩是字典self._grades的值. class SimpleGradebook(): def __init__(self): self._grades = {} def add_student(self, name): self._grades[name] = [] def report_

  • python中字典和列表的相互嵌套问题详解

    目录 1.列表中存储字典: 1.列表中存储多个字典 2.访问列表中字典的值 3.遍历访问多个值 2.字典中存储列表 1.访问字典中的列表元素 2.访问字典中的值(字典中的值为列表) 3.字典中存储字典 1.字典中不能全部由字典元素组成,会报错. 2.字典中的值可由字典组成 4.容易出的小错误: 总结 首先明确: 1.访问字典中的元素:dict_name[key] / dict_name.get(key) 2.访问列表中的元素:list_name[索引] 1.列表中存储字典: 1.列表中存储多个字

  • Python中列表、字典、元组、集合数据结构整理

    本文详细归纳整理了Python中列表.字典.元组.集合数据结构.分享给大家供大家参考.具体分析如下: 列表: 复制代码 代码如下: shoplist = ['apple', 'mango', 'carrot', 'banana'] 字典: 复制代码 代码如下: di = {'a':123,'b':'something'} 集合: 复制代码 代码如下: jihe = {'apple','pear','apple'} 元组: 复制代码 代码如下: t = 123,456,'hello' 1.列表 空

  • python列表,字典,元组简单用法示例

    本文实例讲述了python列表,字典,元组简单用法.分享给大家供大家参考,具体如下: 列表 #_*_ coding:utf-8 _*_ # 列表,定义在方括号的形式中,可以进行切片操作. #它没有固定类型的约束,即可以包含不同的数据类型. L=[1,'abc',2.3] print len(L) print '*'*40 L.append('mengtianwxs') print(L) print '*'*40 L.pop(0) print(L) print '*'*40 L.sort() pr

  • 关于python之字典的嵌套,递归调用方法

    一 字典的嵌套 在机器学习实战决策树部分,生成决策树时用到了字典的嵌套. >>>s1={'no surface':{}} >>>s1['no surfacce'][0]='no' >>>s1 {'no surface':{0:'no'}} >>>s2={'flipper':{}} >>>s2['flipper'][0]='no' >>>s2['flipper'][1]='yes' >>&

  • python实现字典嵌套列表取值

    如下所示: dict={'log_id': 5891599090191187877, 'result_num': 1, 'result': [{'probability': 0.9882395267486572, 'top': 205, 'height': 216, 'classname': 'Face', 'width': 191, 'left': 210}]} 访问dict的值: print(dict['log_id']) 访问dict下的result列表的值: print(dict['re

  • Python基础学习列表+元组+字典+集合

    目录 一.列表 二.元组 三.字典 四.集合 五.总节 前言: 这一章的知识紧接上一章,零基础的小伙伴可以从上一章学起来.当然,你也可以收藏起来慢慢学习,学习是不可操之过急的啦… 一.列表 print("-------------创建列表-------------"); list1 = ['JAVA', 'Hello', 'Python', 'VS', 1, 2, 3] print(list1) list2 = list('Python') print(list2) list3 = [

  • Python列表推导式,元组推导式,字典推导式,集合推导式

    目录 1 介绍 2 列表推导式 3 元组推导式 4 字典推导式 5 集合推导式 1 介绍 推导式(解析器):是Python独有的一种特性.使用推导式可以快速生成列表.元组.字典以及集合类型的数据,因此推导式又可分为列表推导式. 2 列表推导式 格式: 格式1: [表达式 for 变量 in 列表][out_exp_res for out_exp in input_list] 格式2:[表达式 for 变量 in 列表 if 条件][out_exp_res for out_exp in input

随机推荐