1

首先，我为标题道歉，我不知道如何更具体地解决这个问题。我正在尝试创建一个脚本来收集下一步操作列表（如在完成工作方法中）基于使用 TaskPaper 格式的项目的完整列表。这是将进入脚本的字符串类型的示例。

Inbox:

Project 01:
    - Task 01
    - Task 02
    - Task 03

Project 02:
    - Task 01
    - Task 02
    - Task 03
    - Task 04

我设法从可以循环进入的主列表中的每个项目中列出了一个列表。这是我的脚本的实际状态。请考虑arg[1]作为上述字符串：

allTasks = arg[1].split('\n\n')

projects = [filter(None,proj.split('\n')) for proj in allTasks]

next_actions = [task[:2] for task in projects if len(task) > 1]

该变量next_actions将产生以下列表：[['Project 01:', '\t- Task 01'], ['Project 02:', '\t- Task 01']]这正是我想要的，但是，如果我将子任务添加到其中一项任务中，如下所示：

Project 01:
    - Task 01
        - Subtask 01
        - Subtask 02
        - Subtask 03
    - Task 02
    - Task 03

并运行脚本，我的next_actions变量没有改变（我知道为什么，但我不知道如何解决它）。我希望结果是：[['Project 01:', '\t- Task 01\n\t\t- Subtask 01\n\t\t- Subtask 02\n\t\t- Subtask 03'], ['Project 02:', '\t- Task 01']]所以我可以支持子任务。也许早先确定一个带有子任务的任务并从中列出可以解决我的问题，但我不知道从哪里开始。

我错过了您需要的任何信息吗？请让我知道，我会尽快回复。感谢您的帮助。

4

3 回答 3

2

虽然远非优雅或可能是最好的方法，但我相信您应该利用嵌套数据结构来完成这项任务。

给定以下任务字典：

t = {'Inbox':[],

    'Project 01': [
        ['Task 01',['subtask 1', 'subtask 2']],
        'Task 02',
        'Task 03'
    ],
    'Project 02':[
        ['Task 01',['subtask 1', 'subtask 2','subtask 3', 'subtask 4']],
        'Task 02',
        'Task 03',
        'Task 04'
    ]
}

此代码应该相对轻松地处理具有子任务的下一个操作。

print "Next Actions"
for i in t:
    if len(t[i]) > 0:
        print "\n%s:" %i

        if isinstance(t[i][0], list):
            print "- %s" %(t[i][0][0])
            for st in t[i][0][1]:
                print "\t- %s" %(st)
        else:
            print t[i][0]

这将输出：

Next Actions

Project 01:
- Task 01
    - subtask 1
    - subtask 2

Project 02:
- Task 01
    - subtask 1
    - subtask 2
    - subtask 3
    - subtask 4

或者，使用您的初始列表和代码作为起点，您可以通过以下方式获得所需的结果。请注意，这还将处理与下一个操作相关的注释。

鉴于列表

t = '''Inbox:

Project 01:
    - Task 01
    this is a comment
    this is still a comment associate with task 01
        - sub 01
        - sub 02
        - sub 05
    - Task 02
    - Task 03
        - sub 03
        - sub 04

Project 02:
    - Task 01
        - proj 2 sub 01
    - Task 02
    - Task 03
    - Task 04'''

以下代码应该为您提供您所追求的结果。现在我只用有限的数据对此进行了测试，我确信应该有一个更优化的方法，但现在这就是我所拥有的：

temp_list = {}
temp_sub = []
final_list = {}

allTasks = t.split('\n\n')
projects = [filter(None,proj.split('\n\t')) for proj in allTasks]

for i in projects:
    temp_list[i[0]]=i[1:]

for key,value in temp_list.iteritems():
    if len(value) > 0:
        temp_sub = []
        for s in range(1,(len(value)-1)):   
            if value[s].startswith('\t') or not value[s].startswith('-'):
                temp_sub.append(value[s])
            else:
                break
        final_list[key]=[value[0],temp_sub]

for key, value in final_list.iteritems():
    print key
    for sub in value:
        if len(value)>0 and len(sub)>0:
            if isinstance(sub, list):
                for item in sub:
                    print item
            else: 
                print sub

再一次，输出将是：

    Project 02:
- Task 01
    - proj 2 sub 01
Project 01:
- Task 01
this is a comment
this is still a comment associate with task 01
    - sub 01
    - sub 02
    - sub 05

现在，由于我们正在动态创建字典，因此您的最终结果（项目）将失去秩序。我认为需要额外的代码来维护某种形式的排序。

于 2013-11-13T16:43:36.123 回答
1

忽略前面的回答。我，像往常一样把事情复杂化。这应该被证明更简单，更短，同时仍然呈现所需的结果。

源列表

t = '''Inbox:

Project 01:
    - Task 01
    this is a comment
    this is still a comment associate with task 01
        - sub 01
        - sub 02
        - sub 05
    - Task 02
    - Task 03
        - sub 03
        - sub 04

Project 02:
    - Task 01
        - proj 2 sub 01
    - Task 02
    - Task 03
    - Task 04'''

脚本

allTasks = t.split('\n\n')
projects = [filter(None,proj.split('\n\t')) for proj in allTasks]

for i in projects:
    if len(i[1:])>0:
        print i[0]
        print i[1]
        for s in range(2,len(i[1:])):
            if i[s].startswith("\t") or not i[s].startswith("-"):
                print i[s]
            else:
                break

输出

Project 01:
- Task 01
this is a comment
this is still a comment associate with task 01
    - sub 01
    - sub 02
    - sub 05
Project 02:
- Task 01
    - proj 2 sub 01

在使用更少代码的同时，这也可以保持项目的顺序。

于 2013-11-14T16:26:18.507 回答
1

我使用 re.split() 找到了一个合理的解决方案

re.split('\n(?=^\t-\s)', arg[1], 0, re.M)

作为 arg[1] 完整的任务字符串，此操作将在每个任务之前的换行符处拆分，该\n任务只有一个任务。考虑以下字符串：

Project 01:
    - Task 01
        - Subtask 01
        - Subtask 02
        - Subtask 03
    - Task 02
    - Task 03

前面提到的 re.split() 将创建这个列表：

['Project 01:', '\t- Task 01\n\t\t- Subtask 01\n\t\t- Subtask 02\n\t\t- Subtask 03', '\t- Task 02', '\t- Task 03']

之后，我可以project[:2]在一个循环中单独使用每个“项目”，以根据这个问题的真正意图收集每个项目的下一个动作。谢谢你，佩德罗一直在帮助我（：

于 2013-11-19T02:56:43.647 回答