Python 3.x 如何在特定条件下对列表的子列表进行分类

我有一个包含子列表的列表。如果子列表之间的差异小于0.1，我想对这些子列表进行分组

import numpy as np

def difference(A, B):
    difference = []
    zip_object = zip(sorted(A), sorted(B))
    for l1, l2 in zip_object:
        difference.append(abs(l1-l2))
    sum_ = 0
    for i in difference:
        sum_ += i
    if round(sum_, 5) <=0.1:
        return True
    return False


aaa = [[1.001, 2, 5, 3, 5, 4, 6, 9, 10],
      [2, 5, 3, 5, 4, 6.001, 9, 10, 1],
      [2, 5.5, 3, 5, 4, 6.001, 9, 10, 1], 
      [2, 5.5, 3, 5, 4, 6.001, 9, 10.2, 1],
      [2, 5, 2.999, 5, 4, 6.001, 9, 10, 1],
      [2, 5.5, 2.999, 5, 4, 6.001, 9, 10.2, 1]]
AAA = []
for i in range(len(aaa)):
    a = [i]
    for j in range(len(aaa)):
        if i < j and difference(aaa[i], aaa[j])==True:
            a.append(j)
    AAA.append(a)
print(AAA)

但是我想要这样的结果

[[0, 1, 4], [3, 5]]

---

我已经创建了一个详细的程序，您可以根据需要进行调整

def new_difference(list1, list2):
    list_length = len(list1)
    list1 = sorted(list1)
    list2 = sorted(list2)

    total = 0
    for i in range(list_length):
        total += abs(list1[i] - list2[i])

    return round(total, 5) <= 0.1;

def add_good_diff():
    # if 0 matches with 1, create dictionary 0: [1]
    # if 0 matches with 4, add to the list like so 0: [1, 4]
    if not i in good_diff:
        good_diff[i] = [j]
    else:
        good_diff[i].append(j)

def proceed_with_diff(i, j):
    # let's say 0'th list matches with 1 and 4
    # when we get to the next list, we don't want to compare 1 and 4
    # so, check each list in good_diff. If found, return False
    #   which means, skip matching i and j
    for item in good_diff:
        if i in good_diff[item] and j in good_diff[item]:
            print(f"{i} and {j} already diff'ed successfully")
            return False

    return True

aaa = [[1.001, 2, 5, 3, 5, 4, 6, 9, 10],
      [2, 5, 3, 5, 4, 6.001, 9, 10, 1],
      [2, 5.5, 3, 5, 4, 6.001, 9, 10, 1], 
      [2, 5.5, 3, 5, 4, 6.001, 9, 10.2, 1],
      [2, 5, 2.999, 5, 4, 6.001, 9, 10, 1],
      [2, 5.5, 2.999, 5, 4, 6.001, 9, 10.2, 1]]

sets = len(aaa)
good_diff = {} # stores {0: {1, 4}, 3: {5}} - successful matches
final_list = [] # is used to flatten output to [[0, 1, 4], [3, 5]]

# starts with 0'th item
for i in range(0, sets):

    # compares 0'th item with 1..5
    for j in range(i+1, sets):

        print(f'Matching {i} and {j}')

        # if i and j have been compared already, don't compare them again
        # proceed_with_diff returns True a match has not been done before
        if proceed_with_diff(i, j):

            # if diff is within accepted value, add it to the dictionary
            if new_difference(aaa[i], aaa[j]):
                print(f'{i} matches {j}. Adding to good_diff')
                add_good_diff()

# flatten the dictionary 
# {0: [1, 4]} will become [0, 1, 4]
for item in good_diff:
    final_list.append([item] + good_diff[item])

print(final_list)

---

试一试。

只要您可以导入

numpy

，这里有一个使用

numpy

import numpy as np

aaa = [[1.001, 2, 5, 3, 5, 4, 6, 9, 10],
      [2, 5, 3, 5, 4, 6.001, 9, 10, 1],
      [2, 5.5, 3, 5, 4, 6.001, 9, 10, 1], 
      [2, 5.5, 3, 5, 4, 6.001, 9, 10.2, 1],
      [2, 5, 2.999, 5, 4, 6.001, 9, 10, 1],
      [2, 5.5, 2.999, 5, 4, 6.001, 9, 10.2, 1]]

# sort each row for calculating differences 
aaa = np.sort(aaa,axis=1)
# calculate the difference 
diff = np.sum(np.abs(aaa[:,None,:] - aaa),axis=2)
# don't need an item with itself 
np.fill_diagonal(diff,1e5)
# find the pairs of rows that have a small difference
locs = np.unique(np.sort(np.where(diff <= .1 ),axis=0),axis=1).T

# get the results
res = {}
redundant = []
flattened_list = []
for pair in locs:
    if pair[0] not in res.keys() and pair[0] not in redundant:
        res[pair[0]] = [pair[1]]
        redundant.extend(pair)
    elif pair[0] in res.keys():
        if pair[1] not in res[pair[0]]:
            res[pair[0]].append(pair[1])
            
flattened_list = [[key,*val] for key,val in res.items()]

将numpy导入为np
aaa=[[1.001,2,5,3,5,4,6,9,10]，
[2, 5, 3, 5, 4, 6.001, 9, 10, 1],
[2, 5.5, 3, 5, 4, 6.001, 9, 10, 1], 
[2, 5.5, 3, 5, 4, 6.001, 9, 10.2, 1],
[2, 5, 2.999, 5, 4, 6.001, 9, 10, 1],
[2, 5.5, 2.999, 5, 4, 6.001, 9, 10.2, 1]]
#对每行进行排序以计算差异
aaa=np.排序（aaa，轴=1）
#计算差额
差异=np.和（np.绝对值（aaa[：，无，：]-aaa），轴=2）
#不需要物品本身
np.填充对角线（差异，1e5）
#找出差异较小的行对
locs=np.unique（np.sort）（np.where（diff
[[0, 1, 4], [3, 5]]

import numpy as np

aaa = [[1.001, 2, 5, 3, 5, 4, 6, 9, 10],
      [2, 5, 3, 5, 4, 6.001, 9, 10, 1],
      [2, 5.5, 3, 5, 4, 6.001, 9, 10, 1], 
      [2, 5.5, 3, 5, 4, 6.001, 9, 10.2, 1],
      [2, 5, 2.999, 5, 4, 6.001, 9, 10, 1],
      [2, 5.5, 2.999, 5, 4, 6.001, 9, 10.2, 1]]

# sort each row for calculating differences 
aaa = np.sort(aaa,axis=1)
# calculate the difference 
diff = np.sum(np.abs(aaa[:,None,:] - aaa),axis=2)
# don't need an item with itself 
np.fill_diagonal(diff,1e5)
# find the pairs of rows that have a small difference
locs = np.unique(np.sort(np.where(diff <= .1 ),axis=0),axis=1).T

# get the results
res = {}
redundant = []
flattened_list = []
for pair in locs:
    if pair[0] not in res.keys() and pair[0] not in redundant:
        res[pair[0]] = [pair[1]]
        redundant.extend(pair)
    elif pair[0] in res.keys():
        if pair[1] not in res[pair[0]]:
            res[pair[0]].append(pair[1])
            
flattened_list = [[key,*val] for key,val in res.items()]