So sánh danh sách hoạt động như thế nào trong Python

Theo dõi bản tin của tôi và không bao giờ bỏ lỡ các bài viết sắp tới của tôi

Chơi bài viết này

Trình duyệt của bạn không hỗ trợ phần tử âm thanh. TỐC ĐỘ1X

Mục lục

Cách đây một thời gian, tôi đã viết một hướng dẫn về cách so sánh hai từ điển trong Python 3 và nhiệm vụ này không đơn giản như nó có vẻ như thế nào. Hóa ra so sánh hai danh sách trong Python cũng khó như so sánh các

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Cách chúng ta được dạy để so sánh hai đối tượng trong Python có một chút sai lệch. Hầu hết các sách và hướng dẫn dạy so sánh đối tượng bằng cách sử dụng toán tử

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Ví dụ

• điều gì sẽ xảy ra nếu chúng ta muốn so sánh một danh sách các số dấu phẩy động có xét đến một dung sai nhất định?
• điều gì sẽ xảy ra nếu chúng ta muốn đối chiếu hai danh sách nhưng bỏ qua thứ tự xuất hiện của các phần tử?
• có lẽ chúng ta cần so sánh hai danh sách và trả về các phần tử giao nhau với cả hai
• đôi khi chúng ta có thể muốn nhận được sự khác biệt giữa hai danh sách
• Nếu chúng ta có hai danh sách chuỗi và cần so sánh chúng bằng cách bỏ qua các trường hợp chuỗi thì sao?
• điều gì sẽ xảy ra nếu chúng tôi đưa ra một danh sách các mảng

  In [1]: import numpy as np
  
  In [2]: numbers = [np.ones(3), np.zeros(2)]
  
  In [3]: numbers
  Out[3]: [array([1., 1., 1.]), array([0., 0.])]
  
  In [4]: target = [np.ones(3), np.zeros(2)]
  
  In [5]: numbers == target
  ---------------------------------------------------------------------------
  ValueError                                Traceback (most recent call last)
  <ipython-input-5-b832db4b039d> in <module>
  ----> 1 numbers == target
  
  ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
  

  6 để so sánh với nhau, chúng tôi có thể làm gì?
• hoặc có thể chúng tôi có danh sách đối tượng tùy chỉnh hoặc danh sách từ điển

Danh sách này cứ lặp đi lặp lại và đối với tất cả các trường hợp sử dụng này, việc sử dụng

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Đó là những gì chúng ta sẽ thấy trong bài viết này. Chúng ta sẽ tìm hiểu những cách tốt nhất để so sánh hai danh sách trong Python cho một số trường hợp sử dụng khi toán tử

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Sẳn sàng?

So sánh nếu hai danh sách bằng nhau trong python

Cách dễ nhất để so sánh hai danh sách bằng nhau là sử dụng toán tử

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Một ví dụ về trường hợp đơn giản sẽ là danh sách các đối tượng

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

>>> numbers = [1, 2, 3]
>>> target = [1, 2, 3]
>>> numbers == target
True
>>> [1, 2, 3] == [1, 3, 2]
False
>>> ['name', 'lastname'] == ['name', 'lastname']
True
>>> ['name', 'lastname'] == ['name', 'last name']   
False

Khá đơn giản, phải không? . Trong thế giới thực, mọi thứ trở nên phức tạp rất nhanh. Để minh họa, hãy xem xét các trường hợp sau

Giả sử bạn có một danh sách các dấu phẩy động được tạo động. Bạn có thể thêm các phần tử đơn lẻ hoặc các phần tử bắt nguồn từ một phép toán chẳng hạn như

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

Rõ ràng, số học dấu phẩy động có những hạn chế của nó và đôi khi chúng ta muốn so sánh hai danh sách nhưng bỏ qua các lỗi chính xác hoặc thậm chí xác định một số dung sai. Đối với những trường hợp như thế này, toán tử

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Mọi thứ có thể trở nên phức tạp hơn nếu danh sách có đối tượng tùy chỉnh hoặc đối tượng từ các thư viện khác, chẳng hạn như

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Bạn cũng có thể muốn so sánh các danh sách và trả lại kết quả khớp. Hoặc có thể so sánh hai danh sách và trả về sự khác biệt. Hoặc có lẽ bạn muốn so sánh hai danh sách bỏ qua các danh sách trùng lặp hoặc so sánh danh sách từ điển trong Python

Trong mọi trường hợp, sử dụng

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

So sánh hai danh sách số float

Trong phần trước, chúng ta đã thấy rằng số học dấu phẩy động có thể gây ra lỗi chính xác. Nếu chúng ta có một danh sách các float và muốn so sánh nó với một danh sách khác, rất có thể toán tử

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Hãy xem lại ví dụ từ phần trước và xem cách tốt nhất để so sánh hai danh sách float là gì

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

Như bạn thấy,

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

Có một số cách để tiếp cận nhiệm vụ này. Một là tạo chức năng tùy chỉnh của riêng chúng ta, chức năng này lặp lại các phần tử và so sánh từng phần tử một bằng cách sử dụng hàm

May mắn thay, chúng ta không phải phát minh lại bánh xe. Như tôi đã trình bày trong bài viết "cách so sánh hai ký tự", chúng ta có thể sử dụng thư viện có tên là

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

Ví dụ dưới đây bắt đầu bằng cách thiết lập hai danh sách mà chúng tôi muốn so sánh. Sau đó, chúng tôi chuyển nó tới hàm tạo

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Vì chúng tôi muốn bỏ qua lỗi chính xác, chúng tôi có thể đặt số chữ số SAU dấu thập phân được sử dụng trong so sánh

Kết quả là một lệnh trống, có nghĩa là các danh sách bằng nhau. Nếu chúng ta thử so sánh một danh sách với một số float khác nhau hơn 3 chữ số có nghĩa, thư viện sẽ trả về sự khác biệt đó

Để tái tạo, trong bài viết này tôi đã sử dụng phiên bản mới nhất của

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

So sánh nếu hai danh sách không có thứ tự (danh sách không có thứ tự) bằng nhau

Các danh sách trong Python không được sắp xếp theo mặc định. Đôi khi chúng ta muốn so sánh hai danh sách nhưng coi chúng như nhau miễn là chúng có các phần tử giống nhau—bất kể thứ tự của chúng là gì

Có hai cách để làm điều này

• sắp xếp danh sách và sử dụng toán tử

  In [1]: import numpy as np
  
  In [2]: numbers = [np.ones(3), np.zeros(2)]
  
  In [3]: numbers
  Out[3]: [array([1., 1., 1.]), array([0., 0.])]
  
  In [4]: target = [np.ones(3), np.zeros(2)]
  
  In [5]: numbers == target
  ---------------------------------------------------------------------------
  ValueError                                Traceback (most recent call last)
  <ipython-input-5-b832db4b039d> in <module>
  ----> 1 numbers == target
  
  ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
  

  4
• chuyển đổi chúng thành

  In [1]: import numpy as np
  
  In [2]: numbers = [np.ones(3), np.zeros(2)]
  
  In [3]: numbers
  Out[3]: [array([1., 1., 1.]), array([0., 0.])]
  
  In [4]: target = [np.ones(3), np.zeros(2)]
  
  In [5]: numbers == target
  ---------------------------------------------------------------------------
  ValueError                                Traceback (most recent call last)
  <ipython-input-5-b832db4b039d> in <module>
  ----> 1 numbers == target
  
  ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
  

  04 và sử dụng toán tử

  In [1]: import numpy as np
  
  In [2]: numbers = [np.ones(3), np.zeros(2)]
  
  In [3]: numbers
  Out[3]: [array([1., 1., 1.]), array([0., 0.])]
  
  In [4]: target = [np.ones(3), np.zeros(2)]
  
  In [5]: numbers == target
  ---------------------------------------------------------------------------
  ValueError                                Traceback (most recent call last)
  <ipython-input-5-b832db4b039d> in <module>
  ----> 1 numbers == target
  
  ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
  

  4
• sử dụng

  >>> numbers = []
  >>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
  >>> numbers.append(0.2) # add a single element
  >>> target = [0.3, 0.2]
  >>> numbers == target  # compares the lists
  False
  >>> numbers  # Ooopppssss....
  [0.30000000000000004, 0.2]
  >>> target
  [0.3, 0.2]
  

  9

Hai phương thức đầu tiên này giả định rằng các phần tử có thể được so sánh một cách an toàn bằng cách sử dụng toán tử

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

Sắp xếp danh sách và sử dụng toán tử In [1]: import numpy as np In [2]: numbers = [np.ones(3), np.zeros(2)] In [3]: numbers Out[3]: [array([1., 1., 1.]), array([0., 0.])] In [4]: target = [np.ones(3), np.zeros(2)] In [5]: numbers == target --------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-5-b832db4b039d> in <module> ----> 1 numbers == target ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all() 4

Bạn có thể sắp xếp danh sách trong Python theo hai cách khác nhau

• sử dụng phương pháp

  In [1]: import numpy as np
  
  In [2]: numbers = [np.ones(3), np.zeros(2)]
  
  In [3]: numbers
  Out[3]: [array([1., 1., 1.]), array([0., 0.])]
  
  In [4]: target = [np.ones(3), np.zeros(2)]
  
  In [5]: numbers == target
  ---------------------------------------------------------------------------
  ValueError                                Traceback (most recent call last)
  <ipython-input-5-b832db4b039d> in <module>
  ----> 1 numbers == target
  
  ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
  

  10
• sử dụng chức năng

  In [1]: import numpy as np
  
  In [2]: numbers = [np.ones(3), np.zeros(2)]
  
  In [3]: numbers
  Out[3]: [array([1., 1., 1.]), array([0., 0.])]
  
  In [4]: target = [np.ones(3), np.zeros(2)]
  
  In [5]: numbers == target
  ---------------------------------------------------------------------------
  ValueError                                Traceback (most recent call last)
  <ipython-input-5-b832db4b039d> in <module>
  ----> 1 numbers == target
  
  ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
  

  11

Phương pháp đầu tiên sắp xếp danh sách tại chỗ và điều đó có nghĩa là danh sách của bạn sẽ được sửa đổi. Bạn không nên sửa đổi danh sách tại chỗ vì nó có thể gây ra các lỗi khó phát hiện

Sử dụng

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Hãy xem nó hoạt động như thế nào

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Do đó, bằng cách sắp xếp các danh sách trước, chúng tôi đảm bảo rằng cả hai danh sách sẽ có cùng thứ tự và do đó có thể được so sánh bằng cách sử dụng toán tử

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Chuyển đổi các In [1]: import numpy as np In [2]: numbers = [np.ones(3), np.zeros(2)] In [3]: numbers Out[3]: [array([1., 1., 1.]), array([0., 0.])] In [4]: target = [np.ones(3), np.zeros(2)] In [5]: numbers == target --------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-5-b832db4b039d> in <module> ----> 1 numbers == target ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all() 14 thành một In [1]: import numpy as np In [2]: numbers = [np.ones(3), np.zeros(2)] In [3]: numbers Out[3]: [array([1., 1., 1.]), array([0., 0.])] In [4]: target = [np.ones(3), np.zeros(2)] In [5]: numbers == target --------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-5-b832db4b039d> in <module> ----> 1 numbers == target ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all() 04

Trái ngược với danh sách, bộ trong Python không quan tâm đến thứ tự. Ví dụ: bộ

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Để làm như vậy, chúng tôi chuyển đổi từng danh sách thành một tập hợp, sau đó sử dụng

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Sử dụng thư viện >>> numbers = [] >>> numbers.append(0.1 + 0.1 + 0.1) # derive the element based on a summation >>> numbers.append(0.2) # add a single element >>> target = [0.3, 0.2] >>> numbers == target # compares the lists False >>> numbers # Ooopppssss.... [0.30000000000000004, 0.2] >>> target [0.3, 0.2] 9

Thư viện này cũng cho phép chúng tôi bỏ qua thứ tự theo thứ tự, chẳng hạn như

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Sử dụng

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Cách so sánh hai danh sách và trả về kết quả khớp

Trong phần này, chúng ta sẽ xem cách so sánh hai danh sách và tìm giao điểm của chúng. Nói cách khác, chúng tôi muốn tìm các giá trị xuất hiện trong cả hai

Để làm điều đó, một lần nữa chúng ta có thể sử dụng

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Cách so sánh hai danh sách trong python và trả về sự khác biệt

Chúng ta có thể tìm sự khác biệt giữa hai danh sách trong python theo hai cách khác nhau

• sử dụng

  In [1]: import numpy as np
  
  In [2]: numbers = [np.ones(3), np.zeros(2)]
  
  In [3]: numbers
  Out[3]: [array([1., 1., 1.]), array([0., 0.])]
  
  In [4]: target = [np.ones(3), np.zeros(2)]
  
  In [5]: numbers == target
  ---------------------------------------------------------------------------
  ValueError                                Traceback (most recent call last)
  <ipython-input-5-b832db4b039d> in <module>
  ----> 1 numbers == target
  
  ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
  

  04
• sử dụng thư viện the

  >>> numbers = []
  >>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
  >>> numbers.append(0.2) # add a single element
  >>> target = [0.3, 0.2]
  >>> numbers == target  # compares the lists
  False
  >>> numbers  # Ooopppssss....
  [0.30000000000000004, 0.2]
  >>> target
  [0.3, 0.2]
  

  9

Sử dụng In [1]: import numpy as np In [2]: numbers = [np.ones(3), np.zeros(2)] In [3]: numbers Out[3]: [array([1., 1., 1.]), array([0., 0.])] In [4]: target = [np.ones(3), np.zeros(2)] In [5]: numbers == target --------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-5-b832db4b039d> in <module> ----> 1 numbers == target ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all() 04

Giống như chúng ta đã làm để xác định giao điểm, chúng ta có thể tận dụng cấu trúc dữ liệu

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Nếu chúng ta muốn lấy tất cả các phần tử có trong danh sách đầu tiên nhưng không có trong danh sách thứ hai, chúng ta có thể sử dụng hàm

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Mặt khác, nếu chúng ta muốn tìm tất cả các phần tử nằm trong một trong hai danh sách nhưng không phải cả hai, thì chúng ta có thể sử dụng

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Phương pháp này có một hạn chế. nó nhóm những gì khác nhau giữa các danh sách thành một kết quả cuối cùng, đó là sự khác biệt đã đặt. Điều gì sẽ xảy ra nếu chúng ta muốn biết phần tử nào trong sự khác biệt đó thuộc về danh sách nào?

Sử dụng >>> numbers = [] >>> numbers.append(0.1 + 0.1 + 0.1) # derive the element based on a summation >>> numbers.append(0.2) # add a single element >>> target = [0.3, 0.2] >>> numbers == target # compares the lists False >>> numbers # Ooopppssss.... [0.30000000000000004, 0.2] >>> target [0.3, 0.2] 9

Như chúng ta đã thấy cho đến nay, thư viện này rất mạnh mẽ và nó trả về một sự khác biệt tốt đẹp. Hãy xem điều gì sẽ xảy ra khi chúng ta sử dụng

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

Theo đó,

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Cách so sánh hai danh sách chuỗi

So sánh hai danh sách chuỗi trong Python phụ thuộc phần lớn vào loại so sánh bạn muốn thực hiện. Đó là bởi vì chúng ta có thể so sánh một chuỗi theo một số cách

Trong phần này, chúng ta sẽ thấy 3 cách khác nhau để làm điều đó

Cách đơn giản nhất là sử dụng toán tử

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

Mọi thứ bắt đầu trở nên lộn xộn nếu bạn muốn so sánh danh sách các chuỗi nhưng bỏ qua trường hợp. Sử dụng

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

Công cụ tốt nhất cho điều đó lại là

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

Chúng ta cũng có thể bỏ qua thứ tự xuất hiện của các chuỗi trong danh sách

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

Bạn cũng có thể đi xa hơn và thực hiện so sánh nâng cao bằng cách chuyển một toán tử tùy chỉnh tới

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Ví dụ: giả sử bạn muốn so sánh các chuỗi nhưng chúng có thể có

Hoặc có lẽ bạn muốn thực hiện bằng cách sử dụng chỉ số chỉnh sửa khoảng cách

Để làm điều đó, chúng ta có thể viết logic so sánh trong lớp toán tử và chuyển nó tới

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Trong ví dụ đầu tiên này, chúng tôi sẽ bỏ qua mọi khoảng trắng bằng cách cắt các chuỗi trước khi so sánh chúng

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

Sau đó, chúng ta có thể cắm vào

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

Cách so sánh hai danh sách từ điển

So sánh hai danh sách từ điển trong Python chắc chắn rất phức tạp nếu không có sự trợ giúp của thư viện bên ngoài. Như chúng ta đã thấy cho đến nay,

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

Hãy xem điều gì sẽ xảy ra khi chúng ta chuyển hai danh sách từ điển

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

Nó xuất ra vị trí chính xác nơi các phần tử khác nhau và sự khác biệt là gì

Hãy xem một ví dụ khác trong đó một danh sách có một phần tử bị thiếu

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

Nó nói từ điển thứ hai đã bị xóa, đó là trường hợp của ví dụ này

Cách so sánh hai danh sách danh sách

So sánh các danh sách đa chiều—a. k. một danh sách các danh sách—thật dễ dàng cho

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Trong ví dụ dưới đây, chúng tôi có hai danh sách đa chiều mà chúng tôi muốn so sánh. Khi được chuyển đến

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Ví dụ: đối với vị trí

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

Khi cung cấp cho thư viện hai danh sách đa chiều giống hệt nhau, nó sẽ trả về một phản hồi trống

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Cách so sánh hai danh sách đối tượng

Đôi khi chúng tôi có một danh sách các đối tượng tùy chỉnh mà chúng tôi muốn so sánh. Có lẽ chúng tôi muốn có sự khác biệt hoặc chỉ cần kiểm tra xem chúng có chứa các phần tử giống nhau không. Giải pháp cho vấn đề này không thể khác. sử dụng

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

Ví dụ sau minh họa sức mạnh của thư viện này. Chúng ta sẽ so sánh hai danh sách có chứa một đối tượng tùy chỉnh và chúng ta sẽ có thể khẳng định xem chúng có bằng nhau hay không và sự khác biệt là gì

Trong ví dụ bên dưới, chúng tôi có hai danh sách đối tượng

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

>>> numbers = []
>>> numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
>>> numbers.append(0.2) # add a single element
>>> target = [0.3, 0.2]
>>> numbers == target  # compares the lists
False
>>> numbers  # Ooopppssss....
[0.30000000000000004, 0.2]
>>> target
[0.3, 0.2]

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Cách so sánh hai danh sách các mảng có nhiều mảng

Trong phần này, chúng ta sẽ xem cách so sánh hai danh sách của mảng

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Trong phần đầu tiên, chúng ta đã thấy rằng việc sử dụng toán tử

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Ví dụ bên dưới hiển thị hai danh sách có các mảng

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

In [1]: import numpy as np

In [2]: numbers = [np.ones(3), np.zeros(2)]

In [3]: numbers
Out[3]: [array([1., 1., 1.]), array([0., 0.])]

In [4]: target = [np.ones(3), np.zeros(2)]

In [5]: numbers == target
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-b832db4b039d> in <module>
----> 1 numbers == target

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

Phần kết luận

Trong bài đăng này, chúng tôi đã thấy nhiều cách để so sánh hai danh sách trong Python. Phương pháp tốt nhất phụ thuộc vào loại yếu tố chúng ta có và cách chúng ta muốn so sánh. Hy vọng rằng, bây giờ bạn biết làm thế nào để

Python so sánh kích thước danh sách như thế nào?

So sánh danh sách là gì?

Làm cách nào để so sánh 4 danh sách trong Python?