從嵌套列表中刪除子列表（子列表的查找索引）

Question

我有一個這樣的嵌套列表：

lists = [[['L', 5], ['B', 20], ['A', 10]], 
        [['B', 200], ['J', 90]], 
        [['L', 5], ['L', 6]], 
        [['A', 10], ['L', 12], ['A', 11], ['A', 15]]]

如何刪除字符串不是A，B，L的子列表（刪除整個子列表，不僅刪除不是A，B，L的列表）如何找到無效項所屬的子列表的索引（在這種情況下）是1）（需要下一個任務的索引）

這是我嘗試過的，它可以找到無效的項目，但是我不知道找到子列表的索引

for j in range (len(lists)):
    for i in range (len(lists[j])):
        if lists[j][i][0] != 'L' and lists[j][i][0] != 'A' and lists[j][i][0] != 'B':
            return False
return True 

我希望結果是這樣的：

lists = [[['L', 5], ['B', 20], ['A', 10]],  
        [['L', 5], ['L', 6]], 
        [['A', 10], ['L', 12], ['A', 11], ['A', 15]]]

Answer 1

您可以使用反向刪除慣用法有效地就地修改lists ：

keep = ('A', 'B', 'L')
for i in reversed(range(len(lists))):
    if any(l[0] not in keep for l in lists[i]):  
        del lists[i]

print(lists)
# [[['L', 5], ['B', 20], ['A', 10]],
#  [['L', 5], ['L', 6]],
#  [['A', 10], ['L', 12], ['A', 11], ['A', 15]]]

如果子列表的第一個元素不在keep ，則any返回True。

---

或者，您可以創建一個具有列表理解的新列表：

[l for l in lists if not any(l_[0] not in keep for l_ in l)]
# [[['L', 5], ['B', 20], ['A', 10]],
#  [['L', 5], ['L', 6]],
#  [['A', 10], ['L', 12], ['A', 11], ['A', 15]]]

Answer 2

正如@coldspeed所建議的那樣，使用一組檢查字母是否存在可以實現最佳的O（1）查找。

如果您不想使用任何內置函數（例如any() ，請首先創建一個檢查每個子列表內部列表的第一個字母是否存在的函數：

valid = {"A", "B", "L"}

def check_valid(sublst):
    for fst, *_ in sublst: 
        if fst not in valid:
            return False
    return True

或者，如果您願意，也可以不進行元組拆箱：

def check_valid(sublst):
    for lst in sublst:
        if lst[0] not in valid:
            return False
    return True

然后，您可以重構出一個新列表，並過濾掉不正確的列表：

result = []
for sublst in lists:
    if check_valid(sublst):
        result.append(sublst)

print(result)
# [[['L', 5], ['B', 20], ['A', 10]], [['L', 5], ['L', 6]], [['A', 10], ['L', 12], ['A', 11], ['A', 15]]]

或作為列表理解：

result = [sublst for sublst in lists if check_valid(sublst)]
print(result)
# [[['L', 5], ['B', 20], ['A', 10]], [['L', 5], ['L', 6]], [['A', 10], ['L', 12], ['A', 11], ['A', 15]]]

注意：為了方便起見，最好使用內置函數，因為這樣可以省去重新編寫輪子的麻煩，並且通常可以使代碼更短，更簡潔。