Elemen daftar python bijaksana sama

Mainkan artikel ini

Browser Anda tidak mendukung elemen audio. KECEPATAN1X

Daftar isi

Beberapa waktu yang lalu saya menulis panduan tentang cara membandingkan dua kamus di Python 3, dan bagaimana tugas ini tidak sesederhana kedengarannya. Ternyata membandingkan dua daftar dengan Python sama sulitnya dengan membandingkan

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()

Cara kami diajarkan untuk membandingkan dua objek dengan Python agak menyesatkan. Sebagian besar buku dan tutorial mengajarkan perbandingan objek dengan menggunakan operator

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()

Sebagai contoh

• bagaimana jika kita ingin membandingkan daftar bilangan titik-mengambang dengan mempertimbangkan toleransi tertentu?
• bagaimana jika kita ingin mengontraskan dua daftar tetapi mengabaikan urutan kemunculan elemen?
• mungkin kita perlu membandingkan dua daftar dan mengembalikan elemen yang memotong keduanya
• terkadang kita mungkin ingin mendapatkan perbedaan antara dua daftar
• bagaimana jika kita memiliki dua daftar string dan perlu membandingkannya dengan mengabaikan kasus string?
• bagaimana jika kita diberi daftar

  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 array untuk membandingkan satu sama lain, apa yang bisa kita lakukan?
• atau mungkin kita memiliki daftar objek khusus, atau daftar kamus

Daftarnya terus bertambah, dan untuk semua kasus penggunaan ini menggunakan

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()

Itulah yang akan kita lihat di artikel ini. Kami akan mempelajari cara terbaik untuk membandingkan dua daftar dengan Python untuk beberapa kasus penggunaan di mana operator

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()

Siap?

Membandingkan jika dua daftar sama dengan python

Cara termudah untuk membandingkan dua daftar untuk kesetaraan adalah dengan menggunakan operator

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()

Contoh kasus sederhana adalah daftar objek

>>> 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

Cukup sederhana, bukan? . Di dunia nyata, segalanya menjadi rumit dengan sangat cepat. Sebagai ilustrasi, perhatikan kasus berikut

Misalkan Anda memiliki daftar floating point yang dibangun secara dinamis. Anda dapat menambahkan elemen tunggal, atau elemen yang berasal dari operasi matematika seperti

>>> 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]

Jelas, aritmatika floating point memiliki keterbatasan, dan terkadang kami ingin membandingkan dua daftar tetapi mengabaikan kesalahan presisi, atau bahkan menentukan beberapa toleransi. Untuk kasus seperti ini, operator

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()

Segalanya bisa menjadi lebih rumit jika daftar memiliki objek khusus atau objek dari perpustakaan lain, seperti

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()

Anda mungkin juga ingin membandingkan daftar dan mengembalikan kecocokannya. Atau mungkin bandingkan kedua daftar tersebut dan kembalikan perbedaannya. Atau mungkin Anda ingin membandingkan dua daftar dengan mengabaikan duplikatnya, atau membandingkan daftar kamus dengan Python

Dalam setiap kasus, menggunakan

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()

Membandingkan dua daftar angka float

Pada bagian sebelumnya, kita melihat bahwa aritmatika floating point dapat menyebabkan kesalahan presisi. Jika kami memiliki daftar pelampung dan ingin membandingkannya dengan daftar lain, kemungkinan operator

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()

Mari tinjau kembali contoh dari bagian sebelumnya dan lihat apa cara terbaik untuk membandingkan dua daftar pelampung

>>> 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]

Seperti yang Anda lihat,

>>> 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]

Ada beberapa cara untuk mendekati tugas ini. Salah satunya adalah membuat fungsi kustom kita sendiri, yang mengulang elemen dan membandingkannya satu per satu menggunakan fungsi

Untungnya kita tidak perlu menemukan kembali kemudi. Seperti yang saya tunjukkan di artikel "bagaimana membandingkan dua dikte", kita dapat menggunakan perpustakaan bernama

>>> 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]

Contoh di bawah dimulai dengan menyiapkan dua daftar yang ingin kita bandingkan. Kami kemudian meneruskannya ke konstruktor

In [1]: from deepdiff import DeepDiff

In [2]: numbers = []

In [3]: numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation

In [4]: numbers.append(0.2) # add a single element

In [5]: target = [0.3, 0.2]

# if we don't specify the number of significant digits, the comparison will use ==
In [6]: DeepDiff(numbers, target)
Out[6]: 
{'values_changed': {'root[0]': {'new_value': 0.3,
   'old_value': 0.30000000000000004}}}

# 0.30000000000000004 and 0.3 are equal if we only look at the first 3 significant digits
In [7]: DeepDiff(numbers, target, significant_digits=3)
Out[7]: {}

In [8]: numbers
Out[8]: [0.30000000000000004, 0.2]

In [9]: target = [0.341, 0.2]

# 0.341 differs in more than 3 significant digits
In [10]: DeepDiff(numbers, target, significant_digits=3)
Out[10]: 
{'values_changed': {'root[0]': {'new_value': 0.341,
   'old_value': 0.30000000000000004}}}

Karena kami ingin mengabaikan kesalahan presisi, kami dapat mengatur jumlah digit SETELAH koma desimal yang akan digunakan dalam perbandingan

Hasilnya adalah dict kosong, artinya daftarnya sama. Jika kami mencoba membandingkan daftar dengan angka float yang berbeda lebih dari 3 digit signifikan, perpustakaan akan mengembalikan perbedaan itu

Untuk reproduksibilitas, dalam artikel ini saya menggunakan versi terbaru dari

>>> 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]: from deepdiff import DeepDiff

In [2]: numbers = []

In [3]: numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation

In [4]: numbers.append(0.2) # add a single element

In [5]: target = [0.3, 0.2]

# if we don't specify the number of significant digits, the comparison will use ==
In [6]: DeepDiff(numbers, target)
Out[6]: 
{'values_changed': {'root[0]': {'new_value': 0.3,
   'old_value': 0.30000000000000004}}}

# 0.30000000000000004 and 0.3 are equal if we only look at the first 3 significant digits
In [7]: DeepDiff(numbers, target, significant_digits=3)
Out[7]: {}

In [8]: numbers
Out[8]: [0.30000000000000004, 0.2]

In [9]: target = [0.341, 0.2]

# 0.341 differs in more than 3 significant digits
In [10]: DeepDiff(numbers, target, significant_digits=3)
Out[10]: 
{'values_changed': {'root[0]': {'new_value': 0.341,
   'old_value': 0.30000000000000004}}}

In [1]: from deepdiff import DeepDiff

In [2]: numbers = []

In [3]: numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation

In [4]: numbers.append(0.2) # add a single element

In [5]: target = [0.3, 0.2]

# if we don't specify the number of significant digits, the comparison will use ==
In [6]: DeepDiff(numbers, target)
Out[6]: 
{'values_changed': {'root[0]': {'new_value': 0.3,
   'old_value': 0.30000000000000004}}}

# 0.30000000000000004 and 0.3 are equal if we only look at the first 3 significant digits
In [7]: DeepDiff(numbers, target, significant_digits=3)
Out[7]: {}

In [8]: numbers
Out[8]: [0.30000000000000004, 0.2]

In [9]: target = [0.341, 0.2]

# 0.341 differs in more than 3 significant digits
In [10]: DeepDiff(numbers, target, significant_digits=3)
Out[10]: 
{'values_changed': {'root[0]': {'new_value': 0.341,
   'old_value': 0.30000000000000004}}}

Membandingkan jika dua daftar tanpa urutan (unordered list) adalah sama

Daftar di Python tidak diurutkan secara default. Terkadang kami ingin membandingkan dua daftar tetapi memperlakukannya sama selama mereka memiliki elemen yang sama—terlepas dari urutannya

Ada dua cara untuk melakukan hal ini

• menyortir daftar dan menggunakan operator

  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
• mengubahnya menjadi

  In [1]: from deepdiff import DeepDiff
  
  In [2]: numbers = []
  
  In [3]: numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
  
  In [4]: numbers.append(0.2) # add a single element
  
  In [5]: target = [0.3, 0.2]
  
  # if we don't specify the number of significant digits, the comparison will use ==
  In [6]: DeepDiff(numbers, target)
  Out[6]: 
  {'values_changed': {'root[0]': {'new_value': 0.3,
     'old_value': 0.30000000000000004}}}
  
  # 0.30000000000000004 and 0.3 are equal if we only look at the first 3 significant digits
  In [7]: DeepDiff(numbers, target, significant_digits=3)
  Out[7]: {}
  
  In [8]: numbers
  Out[8]: [0.30000000000000004, 0.2]
  
  In [9]: target = [0.341, 0.2]
  
  # 0.341 differs in more than 3 significant digits
  In [10]: DeepDiff(numbers, target, significant_digits=3)
  Out[10]: 
  {'values_changed': {'root[0]': {'new_value': 0.341,
     'old_value': 0.30000000000000004}}}
  

  _4 dan menggunakan operator

  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
• menggunakan

  >>> 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

Dua metode pertama ini menganggap elemen dapat dibandingkan dengan aman menggunakan operator

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]

Menyortir daftar dan menggunakan operator 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

Anda dapat mengurutkan daftar dengan Python dengan dua cara berbeda

• menggunakan metode

  In [6]: numbers = [10, 30, 20]
  
  In [7]: target = [10, 20, 30]
  
  In [8]: numbers == target
  Out[8]: False
  
  In [9]: sorted(numbers) == sorted(target)
  Out[9]: True
  
  In [10]: sorted(numbers)
  Out[10]: [10, 20, 30]
  
  In [11]: sorted(target)
  Out[11]: [10, 20, 30]
  

  _0
• menggunakan fungsi

  In [6]: numbers = [10, 30, 20]
  
  In [7]: target = [10, 20, 30]
  
  In [8]: numbers == target
  Out[8]: False
  
  In [9]: sorted(numbers) == sorted(target)
  Out[9]: True
  
  In [10]: sorted(numbers)
  Out[10]: [10, 20, 30]
  
  In [11]: sorted(target)
  Out[11]: [10, 20, 30]
  

  1

Metode pertama mengurutkan daftar, dan itu berarti daftar Anda akan dimodifikasi. Merupakan ide bagus untuk tidak mengubah daftar karena dapat menimbulkan bug yang sulit dideteksi

Menggunakan

In [6]: numbers = [10, 30, 20]

In [7]: target = [10, 20, 30]

In [8]: numbers == target
Out[8]: False

In [9]: sorted(numbers) == sorted(target)
Out[9]: True

In [10]: sorted(numbers)
Out[10]: [10, 20, 30]

In [11]: sorted(target)
Out[11]: [10, 20, 30]

Mari kita lihat cara kerjanya

In [6]: numbers = [10, 30, 20]

In [7]: target = [10, 20, 30]

In [8]: numbers == target
Out[8]: False

In [9]: sorted(numbers) == sorted(target)
Out[9]: True

In [10]: sorted(numbers)
Out[10]: [10, 20, 30]

In [11]: sorted(target)
Out[11]: [10, 20, 30]

Akibatnya, dengan mengurutkan daftar terlebih dahulu, kami memastikan bahwa kedua daftar akan memiliki urutan yang sama, sehingga dapat dibandingkan menggunakan operator

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()

Mengubah In [6]: numbers = [10, 30, 20] In [7]: target = [10, 20, 30] In [8]: numbers == target Out[8]: False In [9]: sorted(numbers) == sorted(target) Out[9]: True In [10]: sorted(numbers) Out[10]: [10, 20, 30] In [11]: sorted(target) Out[11]: [10, 20, 30] _4 menjadi In [1]: from deepdiff import DeepDiff In [2]: numbers = [] In [3]: numbers.append(0.1 + 0.1 + 0.1) # derive the element based on a summation In [4]: numbers.append(0.2) # add a single element In [5]: target = [0.3, 0.2] # if we don't specify the number of significant digits, the comparison will use == In [6]: DeepDiff(numbers, target) Out[6]: {'values_changed': {'root[0]': {'new_value': 0.3, 'old_value': 0.30000000000000004}}} # 0.30000000000000004 and 0.3 are equal if we only look at the first 3 significant digits In [7]: DeepDiff(numbers, target, significant_digits=3) Out[7]: {} In [8]: numbers Out[8]: [0.30000000000000004, 0.2] In [9]: target = [0.341, 0.2] # 0.341 differs in more than 3 significant digits In [10]: DeepDiff(numbers, target, significant_digits=3) Out[10]: {'values_changed': {'root[0]': {'new_value': 0.341, 'old_value': 0.30000000000000004}}} 4

Berlawanan dengan daftar, set di Python tidak peduli dengan urutan. Misalnya, himpunan

In [6]: numbers = [10, 30, 20]

In [7]: target = [10, 20, 30]

In [8]: numbers == target
Out[8]: False

In [9]: sorted(numbers) == sorted(target)
Out[9]: True

In [10]: sorted(numbers)
Out[10]: [10, 20, 30]

In [11]: sorted(target)
Out[11]: [10, 20, 30]

In [6]: numbers = [10, 30, 20]

In [7]: target = [10, 20, 30]

In [8]: numbers == target
Out[8]: False

In [9]: sorted(numbers) == sorted(target)
Out[9]: True

In [10]: sorted(numbers)
Out[10]: [10, 20, 30]

In [11]: sorted(target)
Out[11]: [10, 20, 30]

Untuk melakukannya, kami mengonversi setiap daftar menjadi satu set, lalu menggunakan

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 [12]: numbers = [10, 30, 20]

In [13]: target = [10, 20, 30]

In [14]: set(numbers) == set(target)
Out[14]: True

In [15]: set(numbers)
Out[15]: {10, 20, 30}

In [16]: set(target)
Out[16]: {10, 20, 30}

Menggunakan perpustakaan >>> 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

Pustaka ini juga memungkinkan kita untuk mengabaikan urutan dalam urutan seperti

In [6]: numbers = [10, 30, 20]

In [7]: target = [10, 20, 30]

In [8]: numbers == target
Out[8]: False

In [9]: sorted(numbers) == sorted(target)
Out[9]: True

In [10]: sorted(numbers)
Out[10]: [10, 20, 30]

In [11]: sorted(target)
Out[11]: [10, 20, 30]

In [12]: numbers = [10, 30, 20]

In [13]: target = [10, 20, 30]

In [14]: set(numbers) == set(target)
Out[14]: True

In [15]: set(numbers)
Out[15]: {10, 20, 30}

In [16]: set(target)
Out[16]: {10, 20, 30}

In [12]: numbers = [10, 30, 20]

In [13]: target = [10, 20, 30]

In [14]: set(numbers) == set(target)
Out[14]: True

In [15]: set(numbers)
Out[15]: {10, 20, 30}

In [16]: set(target)
Out[16]: {10, 20, 30}

In [11]: numbers = [10, 30, 20]

In [12]: target = [10, 20, 30]

In [13]: DeepDiff(numbers, target)
Out[13]: 
{'values_changed': {'root[1]': {'new_value': 20, 'old_value': 30},
  'root[2]': {'new_value': 30, 'old_value': 20}}}

In [14]: DeepDiff(numbers, target, ignore_order=True)
Out[14]: {}

Menggunakan

>>> 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]: from deepdiff import DeepDiff

In [2]: numbers = []

In [3]: numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation

In [4]: numbers.append(0.2) # add a single element

In [5]: target = [0.3, 0.2]

# if we don't specify the number of significant digits, the comparison will use ==
In [6]: DeepDiff(numbers, target)
Out[6]: 
{'values_changed': {'root[0]': {'new_value': 0.3,
   'old_value': 0.30000000000000004}}}

# 0.30000000000000004 and 0.3 are equal if we only look at the first 3 significant digits
In [7]: DeepDiff(numbers, target, significant_digits=3)
Out[7]: {}

In [8]: numbers
Out[8]: [0.30000000000000004, 0.2]

In [9]: target = [0.341, 0.2]

# 0.341 differs in more than 3 significant digits
In [10]: DeepDiff(numbers, target, significant_digits=3)
Out[10]: 
{'values_changed': {'root[0]': {'new_value': 0.341,
   'old_value': 0.30000000000000004}}}

Bagaimana membandingkan dua daftar dan mengembalikan kecocokan

Di bagian ini, kita akan melihat bagaimana kita dapat membandingkan dua daftar dan menemukan persimpangannya. Dengan kata lain, kami ingin menemukan nilai yang muncul di keduanya

Untuk melakukan itu, kita dapat sekali lagi menggunakan

In [1]: from deepdiff import DeepDiff

In [2]: numbers = []

In [3]: numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation

In [4]: numbers.append(0.2) # add a single element

In [5]: target = [0.3, 0.2]

# if we don't specify the number of significant digits, the comparison will use ==
In [6]: DeepDiff(numbers, target)
Out[6]: 
{'values_changed': {'root[0]': {'new_value': 0.3,
   'old_value': 0.30000000000000004}}}

# 0.30000000000000004 and 0.3 are equal if we only look at the first 3 significant digits
In [7]: DeepDiff(numbers, target, significant_digits=3)
Out[7]: {}

In [8]: numbers
Out[8]: [0.30000000000000004, 0.2]

In [9]: target = [0.341, 0.2]

# 0.341 differs in more than 3 significant digits
In [10]: DeepDiff(numbers, target, significant_digits=3)
Out[10]: 
{'values_changed': {'root[0]': {'new_value': 0.341,
   'old_value': 0.30000000000000004}}}

In [1]: t1 = [2, 1, 0, 7, 4, 9, 3]

In [2]: t2 = [7, 6, 11, 12, 9, 23, 2]

In [3]: set(t1).intersection(set(t2))
Out[3]: {2, 7, 9}

# the & operator is a shorthand for the set.intersection() method 
In [4]: set(t1) & set(t2)
Out[4]: {2, 7, 9}

Bagaimana membandingkan dua daftar dengan python dan mengembalikan perbedaan

Kami dapat menemukan perbedaan antara dua daftar di python dengan dua cara berbeda

• menggunakan

  In [1]: from deepdiff import DeepDiff
  
  In [2]: numbers = []
  
  In [3]: numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation
  
  In [4]: numbers.append(0.2) # add a single element
  
  In [5]: target = [0.3, 0.2]
  
  # if we don't specify the number of significant digits, the comparison will use ==
  In [6]: DeepDiff(numbers, target)
  Out[6]: 
  {'values_changed': {'root[0]': {'new_value': 0.3,
     'old_value': 0.30000000000000004}}}
  
  # 0.30000000000000004 and 0.3 are equal if we only look at the first 3 significant digits
  In [7]: DeepDiff(numbers, target, significant_digits=3)
  Out[7]: {}
  
  In [8]: numbers
  Out[8]: [0.30000000000000004, 0.2]
  
  In [9]: target = [0.341, 0.2]
  
  # 0.341 differs in more than 3 significant digits
  In [10]: DeepDiff(numbers, target, significant_digits=3)
  Out[10]: 
  {'values_changed': {'root[0]': {'new_value': 0.341,
     'old_value': 0.30000000000000004}}}
  

  _4
• menggunakan perpustakaan

  >>> 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

Menggunakan In [1]: from deepdiff import DeepDiff In [2]: numbers = [] In [3]: numbers.append(0.1 + 0.1 + 0.1) # derive the element based on a summation In [4]: numbers.append(0.2) # add a single element In [5]: target = [0.3, 0.2] # if we don't specify the number of significant digits, the comparison will use == In [6]: DeepDiff(numbers, target) Out[6]: {'values_changed': {'root[0]': {'new_value': 0.3, 'old_value': 0.30000000000000004}}} # 0.30000000000000004 and 0.3 are equal if we only look at the first 3 significant digits In [7]: DeepDiff(numbers, target, significant_digits=3) Out[7]: {} In [8]: numbers Out[8]: [0.30000000000000004, 0.2] In [9]: target = [0.341, 0.2] # 0.341 differs in more than 3 significant digits In [10]: DeepDiff(numbers, target, significant_digits=3) Out[10]: {'values_changed': {'root[0]': {'new_value': 0.341, 'old_value': 0.30000000000000004}}} _4

Sama seperti yang kita lakukan untuk menentukan persimpangan, kita dapat memanfaatkan

In [1]: from deepdiff import DeepDiff

In [2]: numbers = []

In [3]: numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation

In [4]: numbers.append(0.2) # add a single element

In [5]: target = [0.3, 0.2]

# if we don't specify the number of significant digits, the comparison will use ==
In [6]: DeepDiff(numbers, target)
Out[6]: 
{'values_changed': {'root[0]': {'new_value': 0.3,
   'old_value': 0.30000000000000004}}}

# 0.30000000000000004 and 0.3 are equal if we only look at the first 3 significant digits
In [7]: DeepDiff(numbers, target, significant_digits=3)
Out[7]: {}

In [8]: numbers
Out[8]: [0.30000000000000004, 0.2]

In [9]: target = [0.341, 0.2]

# 0.341 differs in more than 3 significant digits
In [10]: DeepDiff(numbers, target, significant_digits=3)
Out[10]: 
{'values_changed': {'root[0]': {'new_value': 0.341,
   'old_value': 0.30000000000000004}}}

Jika kita ingin mendapatkan semua elemen yang ada di daftar pertama tetapi tidak di daftar kedua, kita dapat menggunakan

In [11]: numbers = [10, 30, 20]

In [12]: target = [10, 20, 30]

In [13]: DeepDiff(numbers, target)
Out[13]: 
{'values_changed': {'root[1]': {'new_value': 20, 'old_value': 30},
  'root[2]': {'new_value': 30, 'old_value': 20}}}

In [14]: DeepDiff(numbers, target, ignore_order=True)
Out[14]: {}

Sebaliknya, jika kita ingin menemukan semua elemen yang ada di salah satu daftar tetapi tidak keduanya, maka kita dapat menggunakan

In [11]: numbers = [10, 30, 20]

In [12]: target = [10, 20, 30]

In [13]: DeepDiff(numbers, target)
Out[13]: 
{'values_changed': {'root[1]': {'new_value': 20, 'old_value': 30},
  'root[2]': {'new_value': 30, 'old_value': 20}}}

In [14]: DeepDiff(numbers, target, ignore_order=True)
Out[14]: {}

In [8]: t1 = [2, 1, 0, 7, 4, 9, 3]

In [9]: t2 = [7, 6, 11, 12, 9, 23, 2]

In [10]: set(t1).difference(set(t2))
Out[10]: {0, 1, 3, 4}

In [11]: set(t2).difference(set(t1))
Out[11]: {6, 11, 12, 23}

In [12]: set(t1).symmetric_difference(set(t2))
Out[12]: {0, 1, 3, 4, 6, 11, 12, 23}

In [13]: set(t1) - set(t2)
Out[13]: {0, 1, 3, 4}

In [14]: set(t1) ^ set(t2)
Out[14]: {0, 1, 3, 4, 6, 11, 12, 23}

Metode ini memiliki keterbatasan. itu mengelompokkan apa yang berbeda antara daftar menjadi satu hasil akhir yang merupakan perbedaan yang ditetapkan. Bagaimana jika kita ingin mengetahui elemen mana di diff itu yang termasuk dalam daftar apa?

Menggunakan >>> 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

Seperti yang telah kita lihat sejauh ini, perpustakaan ini kuat dan mengembalikan diff yang bagus. Mari kita lihat apa yang terjadi ketika kita menggunakan

>>> 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]

Dengan demikian,

>>> 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 [11]: numbers = [10, 30, 20]

In [12]: target = [10, 20, 30]

In [13]: DeepDiff(numbers, target)
Out[13]: 
{'values_changed': {'root[1]': {'new_value': 20, 'old_value': 30},
  'root[2]': {'new_value': 30, 'old_value': 20}}}

In [14]: DeepDiff(numbers, target, ignore_order=True)
Out[14]: {}

In [1]: from deepdiff import DeepDiff

In [2]: numbers = []

In [3]: numbers.append(0.1 + 0.1 + 0.1)  # derive the element based on a summation

In [4]: numbers.append(0.2) # add a single element

In [5]: target = [0.3, 0.2]

# if we don't specify the number of significant digits, the comparison will use ==
In [6]: DeepDiff(numbers, target)
Out[6]: 
{'values_changed': {'root[0]': {'new_value': 0.3,
   'old_value': 0.30000000000000004}}}

# 0.30000000000000004 and 0.3 are equal if we only look at the first 3 significant digits
In [7]: DeepDiff(numbers, target, significant_digits=3)
Out[7]: {}

In [8]: numbers
Out[8]: [0.30000000000000004, 0.2]

In [9]: target = [0.341, 0.2]

# 0.341 differs in more than 3 significant digits
In [10]: DeepDiff(numbers, target, significant_digits=3)
Out[10]: 
{'values_changed': {'root[0]': {'new_value': 0.341,
   'old_value': 0.30000000000000004}}}

Bagaimana membandingkan dua daftar string

Membandingkan dua daftar string dengan Python sangat bergantung pada jenis perbandingan apa yang ingin Anda buat. Itu karena kita bisa membandingkan sebuah string dengan beberapa cara

Di bagian ini, kita akan melihat 3 cara berbeda untuk melakukannya

Yang paling sederhana adalah menggunakan operator

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]

Hal-hal mulai menjadi berantakan jika Anda ingin membandingkan daftar string tetapi mengabaikan kasusnya. Menggunakan

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]

Alat terbaik untuk itu lagi

>>> 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]

Kita juga dapat mengabaikan urutan kemunculan string dalam daftar

>>> 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]

Anda juga dapat melangkah lebih jauh dan melakukan perbandingan lanjutan dengan meneruskan operator khusus ke

In [11]: numbers = [10, 30, 20]

In [12]: target = [10, 20, 30]

In [13]: DeepDiff(numbers, target)
Out[13]: 
{'values_changed': {'root[1]': {'new_value': 20, 'old_value': 30},
  'root[2]': {'new_value': 30, 'old_value': 20}}}

In [14]: DeepDiff(numbers, target, ignore_order=True)
Out[14]: {}

Misalnya, Anda ingin membandingkan string tetapi mungkin ada

Atau mungkin Anda ingin melakukan metrik jarak edit

Untuk melakukannya, kita dapat menulis logika perbandingan di kelas operator dan meneruskannya ke

In [11]: numbers = [10, 30, 20]

In [12]: target = [10, 20, 30]

In [13]: DeepDiff(numbers, target)
Out[13]: 
{'values_changed': {'root[1]': {'new_value': 20, 'old_value': 30},
  'root[2]': {'new_value': 30, 'old_value': 20}}}

In [14]: DeepDiff(numbers, target, ignore_order=True)
Out[14]: {}

Dalam contoh pertama ini, kami akan mengabaikan spasi apa pun dengan memangkas string sebelum membandingkannya

>>> 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]

Kemudian kita cukup menyambungkan ke

In [11]: numbers = [10, 30, 20]

In [12]: target = [10, 20, 30]

In [13]: DeepDiff(numbers, target)
Out[13]: 
{'values_changed': {'root[1]': {'new_value': 20, 'old_value': 30},
  'root[2]': {'new_value': 30, 'old_value': 20}}}

In [14]: DeepDiff(numbers, target, ignore_order=True)
Out[14]: {}

In [1]: t1 = [2, 1, 0, 7, 4, 9, 3]

In [2]: t2 = [7, 6, 11, 12, 9, 23, 2]

In [3]: set(t1).intersection(set(t2))
Out[3]: {2, 7, 9}

# the & operator is a shorthand for the set.intersection() method 
In [4]: set(t1) & set(t2)
Out[4]: {2, 7, 9}

In [1]: t1 = [2, 1, 0, 7, 4, 9, 3]

In [2]: t2 = [7, 6, 11, 12, 9, 23, 2]

In [3]: set(t1).intersection(set(t2))
Out[3]: {2, 7, 9}

# the & operator is a shorthand for the set.intersection() method 
In [4]: set(t1) & set(t2)
Out[4]: {2, 7, 9}

>>> 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]

Cara membandingkan dua daftar kamus

Membandingkan dua daftar kamus dengan Python pasti rumit tanpa bantuan perpustakaan eksternal. Seperti yang telah kita lihat sejauh ini,

>>> 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]

Mari kita lihat apa yang terjadi jika kita melewati dua daftar kamus

>>> 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]

Ini menampilkan lokasi yang tepat di mana elemen berbeda dan apa perbedaannya

Mari kita lihat contoh lain di mana daftar memiliki elemen yang hilang

>>> 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]

Dikatakan kamus kedua telah dihapus, yang merupakan kasus untuk contoh ini

Bagaimana membandingkan dua daftar daftar

Membandingkan daftar multidimensi—a. k. daftar daftar—mudah untuk ________7______9. Ini berfungsi seperti daftar

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()

Pada contoh di bawah ini, kami memiliki dua daftar multidimensi yang ingin kami bandingkan. Saat diteruskan ke

In [11]: numbers = [10, 30, 20]

In [12]: target = [10, 20, 30]

In [13]: DeepDiff(numbers, target)
Out[13]: 
{'values_changed': {'root[1]': {'new_value': 20, 'old_value': 30},
  'root[2]': {'new_value': 30, 'old_value': 20}}}

In [14]: DeepDiff(numbers, target, ignore_order=True)
Out[14]: {}

Misalnya, untuk posisi

In [1]: t1 = [2, 1, 0, 7, 4, 9, 3]

In [2]: t2 = [7, 6, 11, 12, 9, 23, 2]

In [3]: set(t1).intersection(set(t2))
Out[3]: {2, 7, 9}

# the & operator is a shorthand for the set.intersection() method 
In [4]: set(t1) & set(t2)
Out[4]: {2, 7, 9}

>>> 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 [8]: t1 = [2, 1, 0, 7, 4, 9, 3]

In [9]: t2 = [7, 6, 11, 12, 9, 23, 2]

In [10]: set(t1).difference(set(t2))
Out[10]: {0, 1, 3, 4}

In [11]: set(t2).difference(set(t1))
Out[11]: {6, 11, 12, 23}

In [12]: set(t1).symmetric_difference(set(t2))
Out[12]: {0, 1, 3, 4, 6, 11, 12, 23}

In [13]: set(t1) - set(t2)
Out[13]: {0, 1, 3, 4}

In [14]: set(t1) ^ set(t2)
Out[14]: {0, 1, 3, 4, 6, 11, 12, 23}

>>> 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]

Saat memberi makan perpustakaan dengan dua daftar multidimensi yang identik, ini mengembalikan respons kosong

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()

Bagaimana membandingkan dua daftar objek

Terkadang kami memiliki daftar objek khusus yang ingin kami bandingkan. Mungkin kami ingin mendapatkan diff, atau hanya memeriksa apakah mengandung elemen yang sama. Solusi untuk masalah ini tidak bisa berbeda. gunakan

>>> 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]

Contoh berikut menunjukkan kekuatan perpustakaan ini. Kami akan membandingkan dua daftar yang berisi objek khusus, dan kami akan dapat menyatakan apakah keduanya sama atau tidak dan apa perbedaannya

Dalam contoh di bawah ini, kami memiliki dua daftar

In [8]: t1 = [2, 1, 0, 7, 4, 9, 3]

In [9]: t2 = [7, 6, 11, 12, 9, 23, 2]

In [10]: set(t1).difference(set(t2))
Out[10]: {0, 1, 3, 4}

In [11]: set(t2).difference(set(t1))
Out[11]: {6, 11, 12, 23}

In [12]: set(t1).symmetric_difference(set(t2))
Out[12]: {0, 1, 3, 4, 6, 11, 12, 23}

In [13]: set(t1) - set(t2)
Out[13]: {0, 1, 3, 4}

In [14]: set(t1) ^ set(t2)
Out[14]: {0, 1, 3, 4, 6, 11, 12, 23}

In [8]: t1 = [2, 1, 0, 7, 4, 9, 3]

In [9]: t2 = [7, 6, 11, 12, 9, 23, 2]

In [10]: set(t1).difference(set(t2))
Out[10]: {0, 1, 3, 4}

In [11]: set(t2).difference(set(t1))
Out[11]: {6, 11, 12, 23}

In [12]: set(t1).symmetric_difference(set(t2))
Out[12]: {0, 1, 3, 4, 6, 11, 12, 23}

In [13]: set(t1) - set(t2)
Out[13]: {0, 1, 3, 4}

In [14]: set(t1) ^ set(t2)
Out[14]: {0, 1, 3, 4, 6, 11, 12, 23}

>>> 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 [8]: t1 = [2, 1, 0, 7, 4, 9, 3]

In [9]: t2 = [7, 6, 11, 12, 9, 23, 2]

In [10]: set(t1).difference(set(t2))
Out[10]: {0, 1, 3, 4}

In [11]: set(t2).difference(set(t1))
Out[11]: {6, 11, 12, 23}

In [12]: set(t1).symmetric_difference(set(t2))
Out[12]: {0, 1, 3, 4, 6, 11, 12, 23}

In [13]: set(t1) - set(t2)
Out[13]: {0, 1, 3, 4}

In [14]: set(t1) ^ set(t2)
Out[14]: {0, 1, 3, 4, 6, 11, 12, 23}

In [8]: t1 = [2, 1, 0, 7, 4, 9, 3]

In [9]: t2 = [7, 6, 11, 12, 9, 23, 2]

In [10]: set(t1).difference(set(t2))
Out[10]: {0, 1, 3, 4}

In [11]: set(t2).difference(set(t1))
Out[11]: {6, 11, 12, 23}

In [12]: set(t1).symmetric_difference(set(t2))
Out[12]: {0, 1, 3, 4, 6, 11, 12, 23}

In [13]: set(t1) - set(t2)
Out[13]: {0, 1, 3, 4}

In [14]: set(t1) ^ set(t2)
Out[14]: {0, 1, 3, 4, 6, 11, 12, 23}

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()

Bagaimana membandingkan dua daftar array numpy

Pada bagian ini, kita akan melihat bagaimana membandingkan dua daftar array

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()

Kita melihat di bagian pertama bahwa menggunakan operator

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()

Contoh di bawah menunjukkan dua daftar dengan array

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()

Kesimpulan

Dalam posting ini, kami melihat banyak cara untuk membandingkan dua daftar dengan Python. Metode terbaik bergantung pada jenis elemen yang kita miliki dan bagaimana kita ingin membandingkannya. Mudah-mudahan, Anda sekarang tahu caranya

Bisakah Anda membandingkan daftar dengan == di Python?

Bagaimana Anda membandingkan dua elemen daftar dengan bijaksana?

Bagaimana Anda memeriksa apakah item dalam daftar sama dengan Python?