Comment comparer une liste de listes/jeux en python?

Vous voulez donc la différence entre les deux listes d'éléments.

first_list = [['Test.doc', '1a1a1a', 1111], 
              ['Test2.doc', '2b2b2b', 2222], 
              ['Test3.doc', '3c3c3c', 3333]]
secnd_list = [['Test.doc', '1a1a1a', 1111], 
              ['Test2.doc', '2b2b2b', 2222], 
              ['Test3.doc', '8p8p8p', 9999], 
              ['Test4.doc', '4d4d4d', 4444]]

D'abord que je ferai de chaque liste de listes dans une liste de tuples, de sorte que les n-uplets sont hashable (les listes ne sont pas), de sorte que vous pouvez convertir votre liste de tuples dans un ensemble de n-uplets:

first_tuple_list = [tuple(lst) for lst in first_list]
secnd_tuple_list = [tuple(lst) for lst in secnd_list]

Ensuite, vous pouvez faire des séries:

first_set = set(first_tuple_list)
secnd_set = set(secnd_tuple_list)

MODIFIER (suggéré par sdolan): Vous pourriez avoir fait les deux dernières étapes pour chaque liste dans un one-liner:

first_set = set(map(tuple, first_list))
secnd_set = set(map(tuple, secnd_list))

Remarque: map est une fonctionnelle de la programmation de la commande qui s'applique à la fonction dans le premier argument (dans ce cas, le tuple fonction) pour chaque élément dans la deuxième argument (qui dans notre cas est une liste de listes).

et de trouver le symétrique de différence entre les deux séries:

>>> first_set.symmetric_difference(secnd_set) 
set([('Test3.doc', '3c3c3c', 3333),
     ('Test3.doc', '8p8p8p', 9999),
     ('Test4.doc', '4d4d4d', 4444)])

Note first_set ^ secnd_set est équivalent à symmetric_difference.

Aussi, si vous ne voulez pas utiliser des ensembles (p. ex., à l'aide de python 2.2), il est assez simple à faire. E. g., avec des interprétations de la liste:

>>> [x for x in first_list if x not in secnd_list] + [x for x in secnd_list if x not in first_list]
[['Test3.doc', '3c3c3c', 3333],
 ['Test3.doc', '8p8p8p', 9999],
 ['Test4.doc', '4d4d4d', 4444]]

ou avec la fonctionnelle filter de commande et lambda fonctions. (Vous devez tester les deux et de les combiner).

>>> filter(lambda x: x not in secnd_list, first_list) + filter(lambda x: x not in first_list, secnd_list)

[['Test3.doc', '3c3c3c', 3333],
 ['Test3.doc', '8p8p8p', 9999],
 ['Test4.doc', '4d4d4d', 4444]]

>>> First_list = [['Test.doc', '1a1a1a', '1111'], ['Test2.doc', '2b2b2b', '2222'], ['Test3.doc', '3c3c3c', '3333']] 
>>> Secnd_list = [['Test.doc', '1a1a1a', '1111'], ['Test2.doc', '2b2b2b', '2222'], ['Test3.doc', '3c3c3c', '3333'], ['Test4.doc', '4d4d4d', '4444']] 


>>> z = [tuple(y) for y in First_list]
>>> z
[('Test.doc', '1a1a1a', '1111'), ('Test2.doc', '2b2b2b', '2222'), ('Test3.doc', '3c3c3c', '3333')]
>>> x = [tuple(y) for y in Secnd_list]
>>> x
[('Test.doc', '1a1a1a', '1111'), ('Test2.doc', '2b2b2b', '2222'), ('Test3.doc', '3c3c3c', '3333'), ('Test4.doc', '4d4d4d', '4444')]


>>> set(x) - set(z)
set([('Test4.doc', '4d4d4d', '4444')])

Une vieille question, mais voici une solution que j'utilise pour le retour des éléments uniques ne trouve pas dans les deux listes.

- Je l'utiliser pour comparer les valeurs de retour d'une base de données et les valeurs générées par un répertoire robot paquet. Je n'aimais pas les autres solutions que j'ai trouvé parce que beaucoup d'entre eux ne pouvaient pas dynamiquement gérer à la fois le plat des listes et des listes imbriquées.

def differentiate(x, y):
    """
    Retrieve a unique of list of elements that do not exist in both x and y.
    Capable of parsing one-dimensional (flat) and two-dimensional (lists of lists) lists.

    :param x: list #1
    :param y: list #2
    :return: list of unique values
    """
    # Validate both lists, confirm either are empty
    if len(x) == 0 and len(y) > 0:
        return y  # All y values are unique if x is empty
    elif len(y) == 0 and len(x) > 0:
        return x  # All x values are unique if y is empty

    # Get the input type to convert back to before return
    try:
        input_type = type(x[0])
    except IndexError:
        input_type = type(y[0])

    # Dealing with a 2D dataset (list of lists)
    try:
        # Immutable and Unique - Convert list of tuples into set of tuples
        first_set = set(map(tuple, x))
        secnd_set = set(map(tuple, y))

    # Dealing with a 1D dataset (list of items)
    except TypeError:
        # Unique values only
        first_set = set(x)
        secnd_set = set(y)

    # Determine which list is longest
    longest = first_set if len(first_set) > len(secnd_set) else secnd_set
    shortest = secnd_set if len(first_set) > len(secnd_set) else first_set

    # Generate set of non-shared values and return list of values in original type
    return [input_type(i) for i in {i for i in longest if i not in shortest}]

En utilisant l'ensemble des compréhensions, vous pouvez en faire un one-liner. Si vous le souhaitez:

d'obtenir un ensemble de n-uplets, puis:

Differences = {tuple(i) for i in First_list} ^ {tuple(i) for i in Secnd_list}

Ou pour obtenir une liste de tuples, puis:

Differences = list({tuple(i) for i in First_list} ^ {tuple(i) for i in Secnd_list})

Ou pour obtenir une liste de listes (si vous voulez vraiment), alors:

Differences = [list(j) for j in {tuple(i) for i in First_list} ^ {tuple(i) for i in Secnd_list}]

PS: j'ai lu ici: https://stackoverflow.com/a/10973817/4900095 cette carte() la fonction n'est pas un pythonic façon de faire les choses.