recorrer - listas en python

Obteniendo la diferencia(delta) entre dos listas de diccionarios

Question

Tengo las siguientes estructuras de datos de Python:

data1 = [{''name'': u''String 1''}, {''name'': u''String 2''}]
data2 = [{''name'': u''String 1''}, {''name'': u''String 2''}, {''name'': u''String 3''}]

Estoy buscando la mejor manera de obtener el delta entre las dos listas. ¿Hay algo en Python que sea tan conveniente como la biblioteca JavaScript Underscore.js (_.difference)?

Answer 1

En caso de que quiera la diferencia recursivamente, he escrito un paquete para python: https://github.com/seperman/deepdiff

Instalación

Instalar desde PyPi:

pip install deepdiff

Ejemplo de uso

Importador

>>> from deepdiff import DeepDiff
>>> from pprint import pprint
>>> from __future__ import print_function # In case running on Python 2

El mismo objeto devuelve vacío

>>> t1 = {1:1, 2:2, 3:3}
>>> t2 = t1
>>> print(DeepDiff(t1, t2))
{}

El tipo de un artículo ha cambiado

>>> t1 = {1:1, 2:2, 3:3}
>>> t2 = {1:1, 2:"2", 3:3}
>>> pprint(DeepDiff(t1, t2), indent=2)
{ ''type_changes'': { ''root[2]'': { ''newtype'': <class ''str''>,
''newvalue'': ''2'',
''oldtype'': <class ''int''>,
''oldvalue'': 2}}}

El valor de un artículo ha cambiado

>>> t1 = {1:1, 2:2, 3:3}
>>> t2 = {1:1, 2:4, 3:3}
>>> pprint(DeepDiff(t1, t2), indent=2)
{''values_changed'': {''root[2]'': {''newvalue'': 4, ''oldvalue'': 2}}}

Artículo añadido y / o eliminado

>>> t1 = {1:1, 2:2, 3:3, 4:4}
>>> t2 = {1:1, 2:4, 3:3, 5:5, 6:6}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff)
{''dic_item_added'': [''root[5]'', ''root[6]''],
''dic_item_removed'': [''root[4]''],
''values_changed'': {''root[2]'': {''newvalue'': 4, ''oldvalue'': 2}}}

Diferencia de cadena

>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world"}}
>>> t2 = {1:1, 2:4, 3:3, 4:{"a":"hello", "b":"world!"}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ ''values_changed'': { ''root[2]'': {''newvalue'': 4, ''oldvalue'': 2},
"root[4][''b'']": { ''newvalue'': ''world!'',
''oldvalue'': ''world''}}}

Diferencia de cadena 2

>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world!/nGoodbye!/n1/n2/nEnd"}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world/n1/n2/nEnd"}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ ''values_changed'': { "root[4][''b'']": { ''diff'': ''--- /n''
''+++ /n''
''@@ -1,5 +1,4 @@/n''
''-world!/n''
''-Goodbye!/n''
''+world/n''
'' 1/n''
'' 2/n''
'' End'',
''newvalue'': ''world/n1/n2/nEnd'',
''oldvalue'': ''world!/n''
''Goodbye!/n''
''1/n''
''2/n''
''End''}}}
>>>
>>> print (ddiff[''values_changed'']["root[4][''b'']"]["diff"])
---
+++
@@ -1,5 +1,4 @@
-world!
-Goodbye!
+world
1
2
End

Cambio de tipo

>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world/n/n/nEnd"}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ ''type_changes'': { "root[4][''b'']": { ''newtype'': <class ''str''>,
''newvalue'': ''world/n/n/nEnd'',
''oldtype'': <class ''list''>,
''oldvalue'': [1, 2, 3]}}}

Diferencia de lista

>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3, 4]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2]}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{''iterable_item_removed'': {"root[4][''b''][2]": 3, "root[4][''b''][3]": 4}}

Diferencia de lista 2:

>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 3, 2, 3]}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ ''iterable_item_added'': {"root[4][''b''][3]": 3},
''values_changed'': { "root[4][''b''][1]": {''newvalue'': 3, ''oldvalue'': 2},
"root[4][''b''][2]": {''newvalue'': 2, ''oldvalue'': 3}}}

Enumere las diferencias ignorando el orden o los duplicados: (con los mismos diccionarios que arriba)

>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 3, 2, 3]}}
>>> ddiff = DeepDiff(t1, t2, ignore_order=True)
>>> print (ddiff)
{}

Lista que contiene el diccionario:

>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, {1:1, 2:2}]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, {1:3}]}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ ''dic_item_removed'': ["root[4][''b''][2][2]"],
''values_changed'': {"root[4][''b''][2][1]": {''newvalue'': 3, ''oldvalue'': 1}}}

Conjuntos:

>>> t1 = {1, 2, 8}
>>> t2 = {1, 2, 3, 5}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (DeepDiff(t1, t2))
{''set_item_added'': [''root[3]'', ''root[5]''], ''set_item_removed'': [''root[8]'']}

Tuplas nombradas:

>>> from collections import namedtuple
>>> Point = namedtuple(''Point'', [''x'', ''y''])
>>> t1 = Point(x=11, y=22)
>>> t2 = Point(x=11, y=23)
>>> pprint (DeepDiff(t1, t2))
{''values_changed'': {''root.y'': {''newvalue'': 23, ''oldvalue'': 22}}}

Objetos personalizados:

>>> class ClassA(object):
... a = 1
... def __init__(self, b):
... self.b = b
...
>>> t1 = ClassA(1)
>>> t2 = ClassA(2)
>>>
>>> pprint(DeepDiff(t1, t2))
{''values_changed'': {''root.b'': {''newvalue'': 2, ''oldvalue'': 1}}}

Atributo de objeto añadido:

>>> t2.c = "new attribute"
>>> pprint(DeepDiff(t1, t2))
{''attribute_added'': [''root.c''],
''values_changed'': {''root.b'': {''newvalue'': 2, ''oldvalue'': 1}}}

Answer 2

Qué tal esto:

>>> [x for x in data2 if x not in data1]
[{''name'': u''String 3''}]

Editar :

Si necesitas diferencia simétrica puedes usar:

>>> [x for x in data1 + data2 if x not in data1 or x not in data2]

o

>>> [x for x in data1 if x not in data2] + [y for y in data2 if y not in data1]

Una edición más

También puedes usar sets:

>>> from functools import reduce
>>> s1 = set(reduce(lambda x, y: x + y, [x.items() for x in data1]))
>>> s2 = set(reduce(lambda x, y: x + y, [x.items() for x in data2]))
>>> s2.difference(s1)
>>> s2.symmetric_difference(s1)

Answer 3

Utilice itertools.filterfalse :

import itertools
r = list(itertools.filterfalse(lambda x: x in data1, data2))
+ list(itertools.filterfalse(lambda x: x in data2, data1))
assert r == [{''name'': ''String 3''}]

Answer 4

data1 = [{''name'': u''String 1''}, {''name'': u''String 2''}]
data2 = [{''name'': u''String 1''}, {''name'': u''String 2''}, {''name'': u''String 3''}]
delta = list({dict2[''name''] for dict2 in data2} -
{dict1[''name''] for dict1 in data1})
delta_dict = [{''name'': value} for value in delta]
print delta_dict