如何在外循环完成后使内循环最后触发一次

Question

我有两份清单：

• 第一个列表包含顶级名称信息；每个项目有多个描述符
• 第二个列表保存第一个列表中项目的变体；每个项目也有多个描述符

外部（第一个）列表有三个项目name1、name2和name3。还有一个source，但我没有在示例中修改它以保持简单

内部（第二个）列表包含外部列表中的名称和源，然后有自己的名称和源

最终结果应该是这样的：

name1 (source1)
===============
* [name1-foo1]: . "description1"
* [name1-foo2]: . "description2"
* [name1-foo3]: . "description3"

subname1 (subsource1)
---------------
* [name1-sub1-bar1]: . "description1"
* [name1-sub1-bar2]: . "description2"
* [name1-sub1-bar3]: . "description3"

subname2 (subsource1)
---------------
* [name1-sub2-bar1]: . "description1"
* [name1-sub2-bar2]: . "description2"
* [name1-sub2-bar3]: . "description3"

...

我的问题是，我的外循环查找name和source中的更改，作为打印标题并转到下一个要打印的内容的触发器。但由于内部循环仅由更改触发，因此当外部循环用完时，它不会最后一次运行内部循环以获取所有子项

import collections

OuterRecord = collections.namedtuple('OuterRecord',
                                     'name, source, thing, level, description')
InnerRecord = collections.namedtuple('InnerRecord',
                                     'name, source, in_name, in_source, thing, level, description')

o = [
    OuterRecord('name1', 'source1', 'name1-foo1', 1, 'description1'),
    OuterRecord('name1', 'source1', 'name1-foo2', 5, 'description2'),
    OuterRecord('name1', 'source1', 'name1-foo3', 10, 'description3'),

    OuterRecord('name2', 'source1', 'name2-foo1', 1, 'description1'),
    OuterRecord('name2', 'source1', 'name2-foo2', 5, 'description2'),
    OuterRecord('name2', 'source1', 'name2-foo3', 10, 'description3'),

    OuterRecord('name3', 'source1', 'name3-foo1', 1, 'description1'),
    OuterRecord('name3', 'source1', 'name3-foo2', 5, 'description2')
]

i = [
    InnerRecord('name1', 'source1', 'subname1', 'subsource1', 'name1-sub1-bar1', 1, 'description1'),
    InnerRecord('name1', 'source1', 'subname1', 'subsource1', 'name1-sub1-bar2', 1, 'description2'),
    InnerRecord('name1', 'source1', 'subname1', 'subsource1', 'name1-sub1-bar3', 1, 'description3'),

    InnerRecord('name1', 'source1', 'subname2', 'subsource1', 'name1-sub2-bar1', 1, 'description1'),
    InnerRecord('name1', 'source1', 'subname2', 'subsource1', 'name1-sub2-bar2', 1, 'description2'),
    InnerRecord('name1', 'source1', 'subname2', 'subsource1', 'name1-sub2-bar3', 1, 'description3'),

    InnerRecord('name2', 'source1', 'subname3', 'subsource1', 'name2-sub3-bar1', 1, 'description1'),
    InnerRecord('name2', 'source1', 'subname3', 'subsource1', 'name2-sub3-bar2', 1, 'description2'),
    InnerRecord('name2', 'source1', 'subname3', 'subsource1', 'name2-sub3-bar2', 1, 'description3'),

    InnerRecord('name3', 'source1', 'subname4', 'subsource1', 'name3-sub4-bar1', 1, 'description1'),
    InnerRecord('name3', 'source1', 'subname4', 'subsource1', 'name3-sub4-bar2', 1, 'description2'),
    InnerRecord('name3', 'source1', 'subname4', 'subsource1', 'name3-sub4-bar2', 1, 'description3'),

    InnerRecord('name3', 'source1', 'subname5', 'subsource1', 'name3-sub5-bar1', 1, 'description1'),
    InnerRecord('name3', 'source1', 'subname5', 'subsource1', 'name3-sub5-bar2', 1, 'description2'),
    InnerRecord('name3', 'source1', 'subname5', 'subsource1', 'name3-sub5-bar3', 1, 'description3'),

    InnerRecord('name3', 'source1', 'subname6', 'subsource1', 'name3-sub6-bar1', 1, 'description1'),
    InnerRecord('name3', 'source1', 'subname6', 'subsource1', 'name3-sub6-bar2', 1, 'description2'),
    InnerRecord('name3', 'source1', 'subname6', 'subsource1', 'name3-sub6-bar3', 1, 'description3'),
]


def loop_over(outer_list, inner_list):
    current_outer_name = None
    current_outer_source = None
    current_inner_name = None
    current_inner_source = None

    for outer in outer_list:
        if current_outer_name is None:
            print('\n{} ({})'.format(outer.name, outer.source))
            print('=' * 15)

            current_outer_name = outer.name
            current_outer_source = outer.source

        if outer.name != current_outer_name or outer.source != current_outer_source:

            for inner in [x for x in inner_list if x.name == current_outer_name and x.source == current_outer_source]:

                if current_inner_name is None:
                    print('\n{} ({})'.format(inner.in_name, inner.in_source))
                    print('-' * 15)
                    current_inner_name = inner.in_name
                    current_inner_source = inner.in_source

                if inner.in_name != current_inner_name or inner.in_source != current_inner_source:
                    print('\n{} ({})'.format(inner.in_name, inner.in_source))
                    print('-' * 15)
                    current_inner_name = inner.in_name
                    current_inner_source = inner.in_source

                print('* [{}]: . "{}"'.format(inner.thing, inner.description))

            print('\n{} ({})'.format(outer.name, outer.source))
            print('=' * 15)
            current_outer_name = outer.name
            current_outer_source = outer.source

        print('* [{}]: . "{}"'.format(outer.thing, outer.description))


loop_over(o, i)

所以我可以在完成所有工作后再次单独运行内部循环，但这闻起来很可怕

有没有更好的方法来组织循环，使其一次完成

Answer 1

您的代码有一个有趣的事实，就是它会在其背后寻找值来检测更改。不幸的是，最后一个值没有机会被检测到，因为循环到此结束

---

而是使用两个指针，一个用于当前&；一个用于列表中的下一个值。使用类似这样的条件来检测下一步中的更改（向前看）

for index, outer in enumerate(outer_list):
    next_outer_source = outer_list[index + 1] if index < len(outer_list) - 1 else None

    show_outer_header = current_outer_name != outer.name or current_outer_source != outer.source
    show_inner_values = next_outer_source is None or outer.name != next_outer_source.name or outer.source != next_outer_source.source 

---

这是您的函数的一份清理副本：

def loop_over(outer_list, inner_list):
    current_outer_name = None
    current_outer_source = None
    current_inner_name = None
    current_inner_source = None
    prev_outer_source = None

    for index, outer in enumerate(outer_list):
        next_outer_source = outer_list[index + 1] if index < len(outer_list) - 1 else None
        
        show_outer_header = current_outer_name != outer.name or current_outer_source != outer.source
        show_inner_values = next_outer_source is None or outer.name != next_outer_source.name or outer.source != next_outer_source.source
        
        # print outer header
        if show_outer_header:
            print('\n{} ({})'.format(outer.name, outer.source))
            print('=' * 15)
            current_outer_name, current_outer_source = outer.name, outer.source

        # print outer value
        print('* [{}]: . "{}"'.format(outer.thing, outer.description))

        # print inner values
        if show_inner_values:
            current_outer_name = outer.name
            current_outer_source = outer.source

            for inner in [x for x in inner_list if x.name == current_outer_name and x.source == current_outer_source]:
                if current_inner_name is None:
                    print('\n{} ({})'.format(inner.in_name, inner.in_source))
                    print('-' * 15)
                    current_inner_name = inner.in_name
                    current_inner_source = inner.in_source

                if inner.in_name != current_inner_name or inner.in_source != current_inner_source:
                    print('\n{} ({})'.format(inner.in_name, inner.in_source))
                    print('-' * 15)
                    current_inner_name = inner.in_name
                    current_inner_source = inner.in_source

                print('* [{}]: . "{}"'.format(inner.thing, inner.description))

输出：

name1 (source1)
===============
* [name1-foo1]: . "description1"
* [name1-foo2]: . "description2"
* [name1-foo3]: . "description3"

subname1 (subsource1)
       -
* [name1-sub1-bar1]: . "description1"
* [name1-sub1-bar2]: . "description2"
* [name1-sub1-bar3]: . "description3"

subname2 (subsource1)
       -
* [name1-sub2-bar1]: . "description1"
* [name1-sub2-bar2]: . "description2"
* [name1-sub2-bar3]: . "description3"

name2 (source1)
===============
* [name2-foo1]: . "description1"
* [name2-foo2]: . "description2"
* [name2-foo3]: . "description3"

subname3 (subsource1)
       -
* [name2-sub3-bar1]: . "description1"
* [name2-sub3-bar2]: . "description2"
* [name2-sub3-bar2]: . "description3"

name3 (source1)
===============
* [name3-foo1]: . "description1"
* [name3-foo2]: . "description2"

subname4 (subsource1)
       -
* [name3-sub4-bar1]: . "description1"
* [name3-sub4-bar2]: . "description2"
* [name3-sub4-bar2]: . "description3"

subname5 (subsource1)
       -
* [name3-sub5-bar1]: . "description1"
* [name3-sub5-bar2]: . "description2"
* [name3-sub5-bar3]: . "description3"

subname6 (subsource1)
       -
* [name3-sub6-bar1]: . "description1"
* [name3-sub6-bar2]: . "description2"
* [name3-sub6-bar3]: . "description3"

Answer 2

考虑到冗长的数据结构，我认为效率并不是你真正想要的，因此这似乎是一种相当简洁易读的方式来获得你所需要的：

def print_outer_and_inner(outer_recs, inner_recs):
    for name, source in {(o_rec.name, o_rec.source): None for o_rec in outer_recs}:
        print(f'{name} ({source})')
        print('=' * 15)
        for o_rec in outer_recs:
            if o_rec.name == name:
                print(f'* [{o_rec.thing}]: . "{o_rec.description}"')
        print()
        for sub_name, sub_source in {(i_rec.in_name, i_rec.in_source): None for i_rec in inner_recs}:
            print(f'{sub_name} ({sub_source})')
            print('-' * 15)
            for i_rec in inner_recs:
                if i_rec.in_name == sub_name:
                    print(f'* [{i_rec.thing}]: . "{i_rec.description}"')
            print()


print_outer_and_inner(o, i)

主要的缺点是它在每个列表上循环多次，但它带来的是简洁性和可读性