当两个列表都基于索引匹配时，如何解码列表并从两个列表中删除项目？

Question

I have two lists which contain the following type of information.

List #1:
Request_List = ["1/1/1.34", "1/2/1.3.5", "1/3/1.2.3", ...same format elements]
List #2:
Reply_List = ["1/1/0", "1/3/1", "1/2/0", ...same format elements]

From the "Reply" list, I want to be able to compare the second item in the "#/#/#", in this case it will be 1,3,2, and so on with all the items in the Reply list and check if there is a match with the second item in "Request list". If there is a match, then I want to be able to return a new list which would contain the information of the third index in the request string appended with the third index of the matching string in the reply.

The result would be like the following. 
Result = ["1.34.0", "1.3.5.0", "1.2.3.1"] 

Note that the 0 was appended to the 1.34, the 1 was appended to the 1.3.4 and the 0 was appended to the 1.2.3 from the corresponding indexes in the "Reply" list as the second index existed in the "Reply" list. The 'Reply" list could have the item anywhere placed in the list.

The code which does the problem stated above is shown below.

def get_list_of_error_codes(self, Reply_List , Request_List ):
        decoded_Reply_List = Reply_List .decode("utf-8")  # I am not sure if this is 
                                           the right way to decode all the elements in the list? 

        Result = [
            f"{i.split('/')[-1]}.{j.split('/')[-1]}"
            for i in Request_List 
            for j in decoded_Reply_List
            if (i.split("/")[1] == j.split("/")[1])
        ]
        return Result

res = get_list_of_error_codes(Reply_List , Request_List)
print (res) # ["1.34.0", "1.3.5.0", "1.2.3.1"] 

Issues I am facing right now:

1. I am NOT sure if I decode the Reply_List correctly and in the proper manner. Can someone help me also verify this?

2. I am not sure on how to also remove the corresponding items for the Reply_List and Request_List when I find a match based on the condition if (i.split("/")[1] == j.split("/")[1]) .

Answer 1

1. You can use list comprehension to decode the list:

decoded_Reply_List = [li.decode(encoding='utf-8') for li in Reply_List]

2. In this case, if you wanted to also remove items from the list while you create the new list, I would say list comprehension isn't the right move. Just go with the nested for loops:

def get_list_of_error_codes(self, Reply_List, Request_List):
    decoded_Reply_List = [li.decode(encoding='utf-8') for li in Reply_List]

    Result = []
    for i in list(Request_List):
        for j in decoded_Reply_List:
            if (i.split("/")[1] == j.split("/")[1]):
                Result.append(f"{i.split('/')[-1]}.{j.split('/')[-1]}")
                Reply_List.remove(j)
                break
        else:
            continue
        Request_List.remove(i)
    return Result

Request_List = ["1/1/1.34", "1/2/1.3.5", "1/3/1.2.3"]
Reply_List = [b"1/1/0", b"1/3/1", b"1/2/0"]
print(get_list_of_error_codes("Foo", Reply_List, Request_List))

# Output: ['1.34.0', '1.3.5.0', '1.2.3.1']            

Some things to note: I added a break so that we don't keep looking for matches if we find one. It will only match the first pair, then move on.

In for i in list(Request_List) , I added the list() cast to effectively make a copy of the list. This allows us to remove entries from Request_List without disrupting the loop. I didn't do this for for j in decoded_Reply_List because it's already a copy of Reply_List . (I assumed you wanted to remove the entries from Reply_List )

The last is the else: continue . We don't want to reach Request_List.remove(i) if we didn't find a match. If break is called, else will not be called, which means we will reach Request_List.remove(i) . But if the loop completes without finding a match, the loop will then enter else and we will skip the removal step by calling continue

EDIT:

Actually, Reply_List.remove(j) breaks, since we've decoded j in this method, thus decoded j is not the same object as it is in Reply_List . Here's some revised code which will solve this issue:

def get_list_of_error_codes(Reply_List, Request_List):
    # decoded_Reply_List = [li.decode(encoding='utf-8') for li in Reply_List]

    Result = []
    for i in list(Request_List):
        for j in list(Reply_List):
            dj = j.decode(encoding='utf-8')
            if (i.split("/")[1] == dj.split("/")[1]):
                Result.append(f"{i.split('/')[-1]}.{dj.split('/')[-1]}")
                Reply_List.remove(j)
                break
        else:
            continue
        Request_List.remove(i)
    return Result

Request_List = ["1/1/1.34", "1/2/1.3.5", "1/3/1.2.3"]
Reply_List = [b"1/1/0", b"1/3/1", b"1/2/0"]
print("Result: ", get_list_of_error_codes(Reply_List, Request_List))
print("Reply_List: ", Reply_List)
print("Request_List: ", Request_List)

# Output:
# Result:  ['1.34.0', '1.3.5.0', '1.2.3.1']
# Reply_List:  []
# Request_List:  []

What I've done is that instead of creating a separate decoded list, I just decode the entries as they're looped through, and then remove the un-decoded entry from Reply_List . This should be a little more efficient too, since we're not looping through Reply_List twice now.