Hướng dẫn can you use == on dictionaries in python? - bạn có thể sử dụng == trên từ điển trong python không?

Khi tôi phải so sánh hai từ điển lần đầu tiên, tôi đã đấu tranh rất nhiều!

Đối với từ điển đơn giản, so sánh chúng thường đơn giản. Bạn có thể sử dụng toán tử

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 2
}
>>> a == b
False
5 và nó sẽ hoạt động.

Tuy nhiên, khi bạn có nhu cầu cụ thể, mọi thứ trở nên khó khăn hơn. Lý do là, Python không có tính năng tích hợp cho phép chúng tôi:

  • So sánh hai từ điển và kiểm tra xem có bao nhiêu cặp bằng nhau
  • khẳng định từ điển lồng nhau là bằng nhau (so sánh bình đẳng sâu)
  • Tìm sự khác biệt giữa hai
    >>> a = {
        'number': 1,
        'list': ['one', 'two']
    }
    >>> b = {
        'list': ['one', 'two'],
        'number': 2
    }
    >>> a == b
    False
    
    6s (Dict Diff)
  • So sánh
    >>> a = {
        'number': 1,
        'list': ['one', 'two']
    }
    >>> b = {
        'list': ['one', 'two'],
        'number': 2
    }
    >>> a == b
    False
    
    6 có số điểm nổi dưới dạng giá trị

Trong bài viết này, tôi sẽ chỉ ra cách bạn có thể thực hiện các hoạt động đó và nhiều hơn nữa, vì vậy hãy để đi.

Tại sao bạn cần một cách mạnh mẽ để so sánh từ điển

Hãy tưởng tượng kịch bản sau: Bạn có hai từ điển đơn giản. Làm thế nào chúng ta có thể khẳng định nếu chúng phù hợp? Dễ dàng, phải không?

Ừ! Bạn có thể sử dụng toán tử

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 2
}
>>> a == b
False
5, khóa học!

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1
}
>>> a == b
True

Đó là loại mong đợi, từ điển là như nhau. Nhưng điều gì sẽ xảy ra nếu một số giá trị khác nhau, kết quả sẽ là

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 2
}
>>> a == b
False
9 nhưng chúng ta có thể biết chúng khác nhau ở đâu không?

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 2
}
>>> a == b
False

Hum ... chỉ

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 2
}
>>> a == b
False
9 không cho chúng ta biết nhiều ...

Thế còn ________ 21 bên trong

>>> a = {
    'number': 1,
    'list': ['ONE', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1
}
>>> a == b
False
2. Hãy nói rằng chúng tôi muốn bỏ qua các trường hợp của họ.

>>> a = {
    'number': 1,
    'list': ['ONE', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1
}
>>> a == b
False

Oops...

Điều gì sẽ xảy ra nếu con số là

>>> a = {
    'number': 1,
    'list': ['ONE', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1
}
>>> a == b
False
3 và chúng tôi coi hai chiếc phao là giống nhau nếu chúng có ít nhất 3 chữ số đáng kể bằng nhau? Đặt một cách khác, chúng tôi muốn kiểm tra xem chỉ có 3 chữ số sau trận đấu Decimal Point.

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1.00001
}
>>> a == b
False

Bạn cũng có thể muốn loại trừ một số trường khỏi so sánh. Ví dụ, bây giờ chúng tôi có thể muốn xóa giá trị

>>> a = {
    'number': 1,
    'list': ['ONE', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1
}
>>> a == b
False
2-> khỏi kiểm tra. Trừ khi chúng tôi tạo ra một từ điển mới mà không có nó, không có phương pháp nào để làm điều đó cho bạn.

Nó không thể trở nên tồi tệ hơn?

Có, điều gì sẽ xảy ra nếu một giá trị là một mảng

>>> a = {
    'number': 1,
    'list': ['ONE', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1
}
>>> a == b
False
5?

>>> a = {
    'number': 1,
    'list': ['one', 'two'],
     'array': np.ones(3)
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1,
    'array': np.ones(3)
}
>>> a == b
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
-4-eeadcaeab874> in 
----> 1 a == b

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

Ồ không, nó làm tăng một ngoại lệ ở giữa khuôn mặt của chúng tôi!

Chết tiệt, chúng ta có thể làm gì sau đó?

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 2
}
>>> a == b
False
6 không thể thực hiện các so sánh nâng cao, chỉ có hai hình thức đạt được điều đó. Bạn có thể tự thực hiện chức năng hoặc sử dụng thư viện của bên thứ ba. Tại một số điểm trong cuộc sống của bạn, bạn có thể đã nghe về việc không phát minh lại bánh xe. Vì vậy, đó chính xác là những gì chúng ta sẽ làm trong hướng dẫn này.

Chúng tôi sẽ áp dụng một thư viện có tên

>>> a = {
    'number': 1,
    'list': ['ONE', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1
}
>>> a == b
False
7, từ ZepWorks.
>>> a = {
    'number': 1,
    'list': ['ONE', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1
}
>>> a == b
False
7 có thể chọn sự khác biệt giữa từ điển, vòng lặp, chuỗi và các đối tượng khác. Nó hoàn thành rằng bằng cách tìm kiếm các thay đổi một cách đệ quy.

>>> a = {
    'number': 1,
    'list': ['ONE', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1
}
>>> a == b
False
7 không phải là đứa trẻ duy nhất trong khối, cũng có DictDiffer, được phát triển bởi những người ở Cern.
>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1.00001
}
>>> a == b
False
0 cũng rất tuyệt nhưng thiếu rất nhiều tính năng làm cho
>>> a = {
    'number': 1,
    'list': ['ONE', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1
}
>>> a == b
False
7 rất thú vị. Trong mọi trường hợp, tôi khuyến khích bạn xem xét cả hai và xác định cái nào phù hợp nhất với bạn.

Thư viện này tuyệt vời đến mức nó không chỉ hoạt động với từ điển mà còn các vòng lặp, chuỗi và thậm chí các đối tượng tùy chỉnh khác. Ví dụ: bạn có thể "thậm chí trộn và kết hợp" và lấy sự khác biệt giữa hai danh sách các dicts.

Nhận được sự khác biệt đơn giản

Trong ví dụ này, chúng tôi sẽ giải quyết ví dụ đầu tiên tôi chỉ cho bạn. Chúng tôi muốn tìm khóa có giá trị khác nhau giữa hai

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 2
}
>>> a == b
False
6. Hãy xem xét đoạn mã sau, nhưng lần này sử dụng
>>> a = {
    'number': 1,
    'list': ['ONE', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1
}
>>> a == b
False
7.

In [1]: from deepdiff import DeepDiff

In [2]: a = {
   ...:     'number': 1,
   ...:     'list': ['one', 'two']
   ...: }

In [3]: b = {
   ...:     'list': ['one', 'two'],
   ...:     'number': 2
   ...: }

In [4]: diff = DeepDiff(a, b)

In [5]: diff
Out[5]: {'values_changed': {"root['number']": {'new_value': 2, 'old_value': 1}}}

Đáng kinh ngạc! Nó cho chúng ta biết rằng khóa

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1.00001
}
>>> a == b
False
4 có giá trị 1 nhưng
>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 2
}
>>> a == b
False
6, B mới có giá trị mới, 2.

Bỏ qua trường hợp chuỗi

Trong ví dụ thứ hai của chúng tôi, chúng tôi đã thấy một ví dụ trong đó một yếu tố của danh sách ở chữ hoa, nhưng chúng tôi không quan tâm đến điều đó. Chúng tôi muốn bỏ qua nó và coi

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1.00001
}
>>> a == b
False
6 là
>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1.00001
}
>>> a == b
False
7

Bạn có thể giải quyết điều đó bằng cách đặt

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1.00001
}
>>> a == b
False
8

In [10]: a = {
    ...:     'number': 1,
    ...:     'list': ['ONE', 'two']
    ...: }
    ...: 

In [11]: b = {
    ...:     'list': ['one', 'two'],
    ...:     'number': 1
    ...: }

In [12]: diff = DeepDiff(a, b, ignore_string_case=True)

In [13]: diff
Out[13]: {}

Nếu chúng ta không làm điều đó, một thông điệp rất hữu ích được in.

In [14]: diff = DeepDiff(a, b)

In [15]: diff
Out[15]: 
{'values_changed': {"root['list'][0]": {'new_value': 'one',
   'old_value': 'ONE'}}}

So sánh giá trị float

Chúng tôi cũng đã thấy một trường hợp chúng tôi có một số

>>> a = {
    'number': 1,
    'list': ['ONE', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1
}
>>> a == b
False
3 mà chúng tôi chỉ muốn kiểm tra xem 3 chữ số quan trọng đầu tiên có bằng nhau không. Với
>>> a = {
    'number': 1,
    'list': ['one', 'two'],
     'array': np.ones(3)
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1,
    'array': np.ones(3)
}
>>> a == b
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
-4-eeadcaeab874> in 
----> 1 a == b

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
0, có thể vượt qua số chữ số chính xác sau điểm thập phân. Ngoài ra, vì
>>> a = {
    'number': 1,
    'list': ['ONE', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1
}
>>> a == b
False
3 khác với ________ 42, chúng tôi cũng có thể muốn bỏ qua so sánh loại. Chúng ta có thể giải quyết điều đó bằng cách đặt
>>> a = {
    'number': 1,
    'list': ['one', 'two'],
     'array': np.ones(3)
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1,
    'array': np.ones(3)
}
>>> a == b
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
-4-eeadcaeab874> in 
----> 1 a == b

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
3.

In [16]: a = {
    ...:     'number': 1,
    ...:     'list': ['one', 'two']
    ...: }

In [17]: b = {
    ...:     'list': ['one', 'two'],
    ...:     'number': 1.00001
    ...: }

In [18]: diff = DeepDiff(a, b)

In [19]: diff
Out[19]: 
{'type_changes': {"root['number']": {'old_type': int,
   'new_type': float,
   'old_value': 1,
   'new_value': 1.00001}}}
In [24]: diff = DeepDiff(a, b, significant_digits=3, ignore_numeric_type_changes=True)

In [25]: diff
Out[25]: {}

So sánh các giá trị >>> a = { 'number': 1, 'list': ['ONE', 'two'] } >>> b = { 'list': ['one', 'two'], 'number': 1 } >>> a == b False 5

Khi chúng tôi thử so sánh hai từ điển với một mảng

>>> a = {
    'number': 1,
    'list': ['ONE', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1
}
>>> a == b
False
5 trong đó, chúng tôi đã thất bại thảm hại. May mắn thay,
>>> a = {
    'number': 1,
    'list': ['one', 'two'],
     'array': np.ones(3)
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1,
    'array': np.ones(3)
}
>>> a == b
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
-4-eeadcaeab874> in 
----> 1 a == b

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
0 có lưng của chúng tôi ở đây. Nó hỗ trợ các đối tượng
>>> a = {
    'number': 1,
    'list': ['ONE', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1
}
>>> a == b
False
5 theo mặc định!

In [27]: import numpy as np

In [28]: a = {
    ...:     'number': 1,
    ...:     'list': ['one', 'two'],
    ...:      'array': np.ones(3)
    ...: }

In [29]: b = {
    ...:     'list': ['one', 'two'],
    ...:     'number': 1,
    ...:     'array': np.ones(3)
    ...: }

In [30]: diff = DeepDiff(a, b)

In [31]: diff
Out[31]: {}

Điều gì sẽ xảy ra nếu các mảng khác nhau?

Không vấn đề gì!

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 2
}
>>> a == b
False
0

Nó cho thấy rằng không chỉ các giá trị là khác nhau mà còn các loại!

So sánh từ điển với các đối tượng >>> a = { 'number': 1, 'list': ['one', 'two'], 'array': np.ones(3) } >>> b = { 'list': ['one', 'two'], 'number': 1, 'array': np.ones(3) } >>> a == b --------------------------------------------------------------------------- ValueError Traceback (most recent call last) in ----> 1 a == b ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all() 8

Một trường hợp sử dụng phổ biến khác là so sánh các đối tượng

>>> a = {
    'number': 1,
    'list': ['one', 'two'],
     'array': np.ones(3)
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1,
    'array': np.ones(3)
}
>>> a == b
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
-4-eeadcaeab874> in 
----> 1 a == b

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
8. Loại đối tượng này có chữ ký sau:

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 2
}
>>> a == b
False
1

Trong trường hợp chúng tôi có

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 2
}
>>> a == b
False
6 với các đối tượng
>>> a = {
    'number': 1,
    'list': ['one', 'two'],
     'array': np.ones(3)
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1,
    'array': np.ones(3)
}
>>> a == b
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
-4-eeadcaeab874> in 
----> 1 a == b

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
8,
>>> a = {
    'number': 1,
    'list': ['one', 'two'],
     'array': np.ones(3)
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1,
    'array': np.ones(3)
}
>>> a == b
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
-4-eeadcaeab874> in 
----> 1 a == b

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
0 cho phép chúng tôi chỉ so sánh một số phần của nó. Chẳng hạn, nếu chỉ quan tâm đến năm, tháng và ngày, thì chúng ta có thể cắt ngắn nó.

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 2
}
>>> a == b
False
2

So sánh các giá trị chuỗi

Chúng tôi đã xem xét các ví dụ thú vị cho đến nay và đó là trường hợp sử dụng phổ biến để sử dụng

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 2
}
>>> a == b
False
6 để lưu trữ các giá trị chuỗi. Có một cách tốt hơn để đối chiếu họ có thể giúp chúng ta rất nhiều! Trong phần này, tôi sẽ giải thích cho bạn một tính năng đáng yêu khác,
>>> a = {
    'number': 1,
    'list': ['ONE', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1
}
>>> a == b
False
1 Diff.

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 2
}
>>> a == b
False
3

Thật tuyệt! Chúng ta có thể thấy các dòng chính xác mà hai chuỗi khác nhau.

Không bao gồm các lĩnh vực

Trong ví dụ cuối cùng này, tôi sẽ cho bạn thấy một trường hợp sử dụng phổ biến khác, không bao gồm một trường. Chúng tôi có thể muốn loại trừ một hoặc nhiều mục từ so sánh. Chẳng hạn, sử dụng ví dụ trước, chúng tôi có thể muốn bỏ trường

In [1]: from deepdiff import DeepDiff

In [2]: a = {
   ...:     'number': 1,
   ...:     'list': ['one', 'two']
   ...: }

In [3]: b = {
   ...:     'list': ['one', 'two'],
   ...:     'number': 2
   ...: }

In [4]: diff = DeepDiff(a, b)

In [5]: diff
Out[5]: {'values_changed': {"root['number']": {'new_value': 2, 'old_value': 1}}}
5.

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['one', 'two'],
    'number': 2
}
>>> a == b
False
4

Nếu bạn muốn các loại trừ cao cấp hơn,

>>> a = {
    'number': 1,
    'list': ['one', 'two'],
     'array': np.ones(3)
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1,
    'array': np.ones(3)
}
>>> a == b
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
-4-eeadcaeab874> in 
----> 1 a == b

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
0 cũng cho phép bạn vượt qua biểu thức regex. Kiểm tra điều này: zepworks.com/deepdiff/civerse/exclude_paths ...

Sự kết luận

Đó là nó cho ngày hôm nay, các bạn! Tôi thực sự hy vọng bạn đã học được một cái gì đó mới và hữu ích. So sánh ____ 16 là một trường hợp sử dụng phổ biến vì chúng có thể được sử dụng để lưu trữ hầu hết mọi loại dữ liệu. Kết quả là, có một công cụ thích hợp để dễ dàng nỗ lực này là không thể thiếu.

>>> a = {
    'number': 1,
    'list': ['one', 'two'],
     'array': np.ones(3)
}
>>> b = {
    'list': ['one', 'two'],
    'number': 1,
    'array': np.ones(3)
}
>>> a == b
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
-4-eeadcaeab874> in 
----> 1 a == b

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
0 có nhiều tính năng và có thể thực hiện so sánh nâng cao một cách hợp lý. Nếu bạn cần so sánh ____ 16, hãy kiểm tra nó.

Bài viết khác mà bạn có thể thích:

  • Cách so sánh hai chuỗi trong Python (theo 8 cách dễ dàng)

  • Những cách tốt nhất để so sánh hai danh sách trong Python

  • Cách sắp xếp một quyền theo thứ tự giảm dần theo giá trị với Python

  • 3 cách để đơn vị kiểm tra API API trong Python

  • 7 tính năng và plugin pytest sẽ giúp bạn tiết kiệm hàng tấn thời gian

  • Cách sử dụng datetime.timedelta trong python với các ví dụ

  • Python's F-Strings: 73 ví dụ để giúp bạn làm chủ nó

Hẹn gặp lại bạn lần sau!

Bài đăng này ban đầu được xuất bản tại https://miguendes.me

Làm cách nào để kiểm tra xem hai từ điển có bằng nhau trong Python không?

Sử dụng == Toán tử để so sánh hai từ điển ở đây, chúng tôi đang sử dụng toán tử so sánh bình đẳng trong Python để so sánh hai từ điển cho dù cả hai có cùng một cặp giá trị khóa hay không. to Compare Two Dictionaries Here we are using the equality comparison operator in Python to compare two dictionaries whether both have the same key value pairs or not.

Làm cách nào để so sánh từ điển trong Python?

Đối với từ điển đơn giản, so sánh chúng thường đơn giản.Bạn có thể sử dụng toán tử == và nó sẽ hoạt động.use the == operator, and it will work.

Bạn có thể so sánh các giá trị trong một python từ điển không?

Phương thức so sánh CMP () được sử dụng trong Python để so sánh các giá trị và khóa của hai từ điển.Nếu phương thức trả về 0 nếu cả hai từ điển đều bằng nhau, 1 nếu dic1> dict2 và -1 nếu dict1 . If method returns 0 if both dictionaries are equal, 1 if dic1 > dict2 and -1 if dict1 < dict2.

Hai khóa từ điển có thể có cùng giá trị không?

Không, mỗi khóa trong một từ điển phải là duy nhất.Bạn không thể có hai khóa có cùng giá trị.Cố gắng sử dụng cùng một khóa sẽ chỉ ghi đè lên giá trị trước đó được lưu trữ.Nếu một khóa cần lưu trữ nhiều giá trị, thì giá trị được liên kết với khóa phải là danh sách hoặc từ điển khác.You can't have two keys with the same value. Attempting to use the same key again will just overwrite the previous value stored. If a key needs to store multiple values, then the value associated with the key should be a list or another dictionary.