Hướng dẫn python compare two lists boolean - python so sánh hai danh sách boolean

Tôi đang cố gắng so sánh hai danh sách các chuỗi và trả lại các giá trị boolean. Nhưng nó luôn luôn trả về đúng hoặc chỉ sai.

stringList = ["252.007", "546.658", "252.108"]

paramValue = ["252.017", "546.658", "252.008"]

def compareList[]:
    return [x != stringList for x in paramValue]
   #return [x == stringList for x in paramValue]

Đầu ra phải là một danh sách có chứa như sau:

[False, True, False]

Tôi không thể tìm ra nó và tôi không hiểu, tại sao nó lại trả về [đúng, đúng, đúng] nếu tôi sử dụng! = Và trả về [sai, sai, sai] nếu tôi sử dụng == tôi?

Tia

Vấn đề: Cho là hai danh sách

[False, True, False]

[False, True, False]

[False, True, False]

[False, True, False]

• 1. So sánh Boolean: So sánh danh sách phần tử khôn ngoan và trả về

  [False, True, False]
  

  7 Nếu số liệu so sánh của bạn trả về

  [False, True, False]
  

  7 cho tất cả các cặp phần tử, và nếu không

  [False, True, False]
  

  9.
• 2. Sự khác biệt: Tìm sự khác biệt của các phần tử trong danh sách đầu tiên nhưng không phải trong phần thứ hai.

Ví dụ: Bạn bắt đầu với hai danh sách.: You start with two lists.

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]

# 1. Boolean Comparison
result = False

# 2. Difference
result = [4, 5]

Hãy để thảo luận về những cách pythonic nhất để thực hiện những vấn đề này. Chúng tôi bắt đầu với năm cách để thực hiện so sánh Boolean và xem xét năm cách để thực hiện sự khác biệt đơn giản, tiếp theo.

So sánh Boolean

Cách pythonic nhất để kiểm tra xem hai danh sách được đặt hàng có giống hệt không

Câu trả lời ngắn gọn: Cách pythonic nhất để kiểm tra xem hai danh sách được đặt hàng

[False, True, False]

[False, True, False]

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]

# 1. Boolean Comparison
result = False

# 2. Difference
result = [4, 5]

[False, True, False]

[False, True, False]

[False, True, False]

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]

# 1. Boolean Comparison
result = False

# 2. Difference
result = [4, 5]

[False, True, False]

Vấn đề: Cho là hai danh sách

[False, True, False]

[False, True, False]

[False, True, False]

[False, True, False]

[False, True, False]

[False, True, False]

[False, True, False]

[False, True, False]

[False, True, False]

[False, True, False]

Examples::

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
# compare[l1, l2] --> False

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3, 5, 4]
# compare[l1, l2] --> False

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3, 4, 5]
# compare[l1, l2] --> True

Hãy để thảo luận về những cách pythonic nhất để giải quyết vấn đề này. Tại đây, một tổng quan về mã tương tác nhanh:

Bài tập: Glance qua tất cả các phương pháp và chạy mã. Những câu hỏi nào đến với tâm trí? Bạn có hiểu từng phương pháp không?: Glance over all methods and run the code. What questions come to mind? Do you understand each method?

Đọc để tìm hiểu về từng phương pháp một cách chi tiết!

Phương pháp 1: So sánh đơn giản

Không phải lúc nào cũng là phương pháp đơn giản nhất là phương pháp tốt nhất. Nhưng đối với vấn đề đặc biệt này, nó là! Nhà điều hành bình đẳng

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]

# 1. Boolean Comparison
result = False

# 2. Difference
result = [4, 5]

# 1. Simple Comparison
def method_1[l1, l2]:
    return l1 == l2

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_1[l1, l2]]
# False

Vì vậy, nếu bạn chỉ muốn tìm hiểu về cách pythonic nhất để giải quyết vấn đề này, thì đừng tìm đâu xa.

Nhưng nếu bạn muốn đi sâu vào thế giới tuyệt vời của Python, hãy tìm hiểu về các chức năng Python thú vị và mạnh mẽ khác nhau, hãy đọc tiếp!

Phương pháp 2: Đơn giản cho vòng lặp

Phương pháp sau đây là những gì bạn thấy từ một lập trình viên đến từ một ngôn ngữ lập trình khác hoặc từ người mới bắt đầu không biết về toán tử bình đẳng trong danh sách [xem Phương pháp 1].Method 1].

# 2. Simple For Loop
def method_2[l1, l2]:
    for i in range[min[len[l1], len[l2]]]:
        if l1[i] != l2[i]:
            return False
    return len[l1] == len[l2]

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_2[l1, l2]]
# False

Trong mã, bạn lặp lại tất cả các chỉ số từ 0 đến vị trí cuối cùng của danh sách nhỏ nhất được xác định bởi phần

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
# compare[l1, l2] --> False

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3, 5, 4]
# compare[l1, l2] --> False

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3, 4, 5]
# compare[l1, l2] --> True

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
# compare[l1, l2] --> False

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3, 5, 4]
# compare[l1, l2] --> False

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3, 4, 5]
# compare[l1, l2] --> True

[False, True, False]

Nếu bạn đã trải qua toàn bộ vòng lặp mà không trả lại

[False, True, False]

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
# compare[l1, l2] --> False

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3, 5, 4]
# compare[l1, l2] --> False

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3, 4, 5]
# compare[l1, l2] --> True

[False, True, False]

Rất nhiều mã để hoàn thành một điều đơn giản như vậy! Hãy cùng xem cách một lập trình viên tốt hơn sẽ tận dụng chức năng

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
# compare[l1, l2] --> False

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3, 5, 4]
# compare[l1, l2] --> False

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3, 4, 5]
# compare[l1, l2] --> True

Phương pháp 3: zip [] + cho vòng lặp

Hàm ZIP lấy một số lần lặp và tổng hợp chúng thành một loại duy nhất bằng cách kết hợp các giá trị thứ i của mỗi giá trị có thể sử dụng được thành một tuple cho mỗi i.

Hãy để xem cách bạn có thể sử dụng chức năng để làm cho mã trước đó ngắn gọn hơn:

# 3. Zip + For Loop
def method_3[l1, l2]:
    for x, y in zip[l1, l2]:
        if x != y:
            return False
    return len[l1] == len[l2]

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_3[l1, l2]]
# False

Thay vì lặp lại các chỉ số, bây giờ bạn lặp lại các cặp phần tử [các phần tử được nén lại với nhau]. Nếu các danh sách có kích thước khác nhau, các yếu tố còn lại từ danh sách dài hơn sẽ bị bỏ qua. Bằng cách này, so sánh phần tử khôn ngoan trở nên đơn giản hơn và không cần phải có các sơ đồ lập chỉ mục phức tạp. Tránh các chỉ số bằng hàm

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
# compare[l1, l2] --> False

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3, 5, 4]
# compare[l1, l2] --> False

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3, 4, 5]
# compare[l1, l2] --> True

Phương thức 4: sum [] + zip [] + len []

Nhưng các lập trình viên Python thực sự thường sẽ tránh được một vòng lặp và sử dụng biểu thức trình tạo thay thế.

• Trước tiên, bạn tạo ra một giá trị Boolean có thể sử dụng biểu thức máy phát

  l1 = [1, 2, 3, 4, 5]
  l2 = [1, 2, 3]
  # compare[l1, l2] --> False
  
  l1 = [1, 2, 3, 4, 5]
  l2 = [1, 2, 3, 5, 4]
  # compare[l1, l2] --> False
  
  l1 = [1, 2, 3, 4, 5]
  l2 = [1, 2, 3, 4, 5]
  # compare[l1, l2] --> True

  8.
• Sau đó, bạn tổng hợp các giá trị boolean [một thủ thuật khác của các lập trình viên chuyên nghiệp] để tìm số lượng các phần tử giống nhau và lưu trữ nó trong biến

  l1 = [1, 2, 3, 4, 5]
  l2 = [1, 2, 3]
  # compare[l1, l2] --> False
  
  l1 = [1, 2, 3, 4, 5]
  l2 = [1, 2, 3, 5, 4]
  # compare[l1, l2] --> False
  
  l1 = [1, 2, 3, 4, 5]
  l2 = [1, 2, 3, 4, 5]
  # compare[l1, l2] --> True

  9.
• Cuối cùng, bạn so sánh điều này với độ dài của cả hai danh sách. Nếu cả ba giá trị đều giống nhau, cả hai danh sách đều có cùng một yếu tố và độ dài của chúng cũng giống nhau. Họ đều bình đẳng!

# 4. Sum + Zip + Len
def method_4[l1, l2]:
    num_equal = sum[x == y for x, y in zip[l1, l2]]
    return num_equal == len[l1] == len[l2]

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_4[l1, l2]]
# False

print[method_4[[1, 2], [1, 2]]]
# True

Từ các phương pháp ngoại trừ phương pháp đầu tiên sử dụng toán tử

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]

# 1. Boolean Comparison
result = False

# 2. Difference
result = [4, 5]

# 1. Simple Comparison
def method_1[l1, l2]:
    return l1 == l2

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_1[l1, l2]]
# False

Bạn cũng có thể viết điều này trong một dòng mã!

sum[x == y for x, y in zip[l1, l2]] == len[l1] == len[l2]

Nếu bạn yêu thích Python One-Liners, hãy xem cuốn sách mới Python Oneer của tôi với nhà xuất bản nổi tiếng quốc tế Nostarch Press. [Liên kết Amazon] Python One-Liners with internationally renowned publisher NoStarch press. [Amazon Link]

Phương pháp 5: Bản đồ [] + Giảm [] + Len []

Phương pháp cuối cùng chỉ là đào tạo kỹ năng lập trình chức năng của bạn.

# 5. map[] + reduce[] + len[]
from functools import reduce
def method_5[l1, l2]:
    equal = map[lambda x, y: x == y, l1, l2]
    result = reduce[lambda x, y: x and y, equal]
    return result and len[l1] == len[l2]

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_5[l1, l2]]
# False

print[method_5[[1, 2, 3], [1, 2, 3]]]
# True

Hàm

# 1. Simple Comparison
def method_1[l1, l2]:
    return l1 == l2

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_1[l1, l2]]
# False

# 1. Simple Comparison
def method_1[l1, l2]:
    return l1 == l2

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_1[l1, l2]]
# False

# 1. Simple Comparison
def method_1[l1, l2]:
    return l1 == l2

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_1[l1, l2]]
# False

Phương pháp 6: Bản đồ [] + All []

Điều này giống như phương thức trước đó, nhưng sử dụng hàm

# 1. Simple Comparison
def method_1[l1, l2]:
    return l1 == l2

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_1[l1, l2]]
# False

# 1. Simple Comparison
def method_1[l1, l2]:
    return l1 == l2

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_1[l1, l2]]
# False

[False, True, False]

Nếu bạn muốn học một cái gì đó mới mỗi ngày, hãy tham gia chuỗi email Python miễn phí của tôi để cải tiến liên tục về Python và khoa học máy tính.

Bài viết gốc: Cách pythonic nhất để kiểm tra xem hai danh sách được đặt hàng có giống hệt nhau khôngThe Most Pythonic Way to Check if Two Ordered Lists Are Identical

Sự khác biệt

Câu trả lời ngắn gọn: Cách pythonic nhất để tính toán sự khác biệt giữa hai danh sách

[False, True, False]

[False, True, False]

# 2. Simple For Loop
def method_2[l1, l2]:
    for i in range[min[len[l1], len[l2]]]:
        if l1[i] != l2[i]:
            return False
    return len[l1] == len[l2]

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_2[l1, l2]]
# False

[False, True, False]

[False, True, False]

# 2. Simple For Loop
def method_2[l1, l2]:
    for i in range[min[len[l1], len[l2]]]:
        if l1[i] != l2[i]:
            return False
    return len[l1] == len[l2]

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_2[l1, l2]]
# False

Điều gì là cách tốt nhất để tính toán sự khác biệt giữa hai danh sách trong Python?

[False, True, False]

Hãy để có một cái nhìn tổng quan trong Shell mã tương tác sau:

Bài tập: Chạy mã và suy nghĩ về cách ưa thích của bạn!: Run the code and think about your preferred way!

Hãy cùng đi sâu vào từng phương pháp để tìm phương pháp pythonic nhất cho kịch bản cụ thể của bạn.

Phương pháp 1: Đặt sự khác biệt

Cách tiếp cận ngây thơ để giải quyết vấn đề này là chuyển đổi cả hai danh sách thành các bộ và sử dụng thao tác SET MINU [hoặc SET BENTER].

[False, True, False]

Cách tiếp cận này là thanh lịch bởi vì nó có thể đọc được, hiệu quả và súc tích.

Tuy nhiên, có một số thuộc tính duy nhất cho phương pháp này mà bạn nên biết:

• Kết quả là một bộ và không phải là một danh sách. Bạn có thể chuyển đổi nó trở lại danh sách bằng cách sử dụng hàm tạo

  # 2. Simple For Loop
  def method_2[l1, l2]:
      for i in range[min[len[l1], len[l2]]]:
          if l1[i] != l2[i]:
              return False
      return len[l1] == len[l2]
  
  l1 = [1, 2, 3, 4, 5]
  l2 = [1, 2, 3]
  print[method_2[l1, l2]]
  # False
  

  1.
• Tất cả các mục Danh sách trùng lặp được xóa trong quy trình vì các bộ không thể có các yếu tố trùng lặp.
• Thứ tự của danh sách ban đầu bị mất vì các bộ không duy trì thứ tự của các yếu tố.

Nếu cả ba thuộc tính đều được bạn chấp nhận, thì đây là cách tiếp cận hiệu quả nhất như được đánh giá sau trong bài viết này!

Tuy nhiên, làm thế nào bạn có thể duy trì thứ tự của các yếu tố danh sách ban đầu trong khi cũng cho phép trùng lặp? Hãy cùng đi sâu vào danh sách hiểu biết thay thế!list comprehension alternative!

Phương pháp 2: Danh sách hiểu biết

Danh sách hiểu là một cách nhỏ gọn để tạo danh sách. Công thức đơn giản là

# 2. Simple For Loop
def method_2[l1, l2]:
    for i in range[min[len[l1], len[l2]]]:
        if l1[i] != l2[i]:
            return False
    return len[l1] == len[l2]

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_2[l1, l2]]
# False

• Biểu thức: Phải làm gì với mỗi yếu tố danh sách?: What to do with each list element?
• Bối cảnh: Những yếu tố nào để chọn? Bối cảnh bao gồm một số lượng tùy ý của các câu lệnh

  # 2. Simple For Loop
  def method_2[l1, l2]:
      for i in range[min[len[l1], len[l2]]]:
          if l1[i] != l2[i]:
              return False
      return len[l1] == len[l2]
  
  l1 = [1, 2, 3, 4, 5]
  l2 = [1, 2, 3]
  print[method_2[l1, l2]]
  # False
  

  3 và

  # 2. Simple For Loop
  def method_2[l1, l2]:
      for i in range[min[len[l1], len[l2]]]:
          if l1[i] != l2[i]:
              return False
      return len[l1] == len[l2]
  
  l1 = [1, 2, 3, 4, 5]
  l2 = [1, 2, 3]
  print[method_2[l1, l2]]
  # False
  

  4.: What elements to select? The context consists of an arbitrary number of

  # 2. Simple For Loop
  def method_2[l1, l2]:
      for i in range[min[len[l1], len[l2]]]:
          if l1[i] != l2[i]:
              return False
      return len[l1] == len[l2]
  
  l1 = [1, 2, 3, 4, 5]
  l2 = [1, 2, 3]
  print[method_2[l1, l2]]
  # False
  

  3 and

  # 2. Simple For Loop
  def method_2[l1, l2]:
      for i in range[min[len[l1], len[l2]]]:
          if l1[i] != l2[i]:
              return False
      return len[l1] == len[l2]
  
  l1 = [1, 2, 3, 4, 5]
  l2 = [1, 2, 3]
  print[method_2[l1, l2]]
  # False
  

  4 statements.

Bạn có thể sử dụng danh sách hiểu để xem tất cả các yếu tố trong danh sách đầu tiên nhưng bỏ qua chúng nếu chúng nằm trong danh sách thứ hai:

[False, True, False]

Chúng tôi đã sử dụng một tối ưu hóa nhỏ nhưng hiệu quả của việc chuyển đổi danh sách thứ hai

# 2. Simple For Loop
def method_2[l1, l2]:
    for i in range[min[len[l1], len[l2]]]:
        if l1[i] != l2[i]:
            return False
    return len[l1] == len[l2]

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_2[l1, l2]]
# False

# 2. Simple For Loop
def method_2[l1, l2]:
    for i in range[min[len[l1], len[l2]]]:
        if l1[i] != l2[i]:
            return False
    return len[l1] == len[l2]

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_2[l1, l2]]
# False

Dưới đây là các thuộc tính đặc biệt của phương pháp này:

• Kết quả của câu lệnh danh sách hiểu là một danh sách.
• Thứ tự của danh sách ban đầu được duy trì.
• Các yếu tố trùng lặp được duy trì.

Nếu bạn dựa vào những đảm bảo mạnh mẽ hơn này, hãy sử dụng phương pháp hiểu danh sách vì nó là phương pháp pythonic nhất.

Phương pháp 3: Đơn giản cho vòng lặp

Đáng ngạc nhiên, một số hướng dẫn trực tuyến khuyến nghị sử dụng một vòng lặp cho vòng lặp [ví dụ: những người đó]:

[False, True, False]

Theo tôi, cách tiếp cận này sẽ chỉ được sử dụng bởi những người mới bắt đầu tuyệt đối hoặc các lập trình viên đến từ các ngôn ngữ lập trình khác như C ++ hoặc Java và donith biết các tính năng python thiết yếu như hiểu danh sách. Bạn có thể tối ưu hóa phương pháp này bằng cách chuyển đổi danh sách

# 2. Simple For Loop
def method_2[l1, l2]:
    for i in range[min[len[l1], len[l2]]]:
        if l1[i] != l2[i]:
            return False
    return len[l1] == len[l2]

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_2[l1, l2]]
# False

# 2. Simple For Loop
def method_2[l1, l2]:
    for i in range[min[len[l1], len[l2]]]:
        if l1[i] != l2[i]:
            return False
    return len[l1] == len[l2]

l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_2[l1, l2]]
# False

Bài viết gốc: Danh sách khác biệt | Cách pythonic nhất: List Difference | The Most Pythonic Way

Đi đâu từ đây?

Đủ lý thuyết. Hãy để có được một số thực hành!

Các lập trình viên được trả tiền sáu con số và hơn thế nữa vì họ có thể giải quyết các vấn đề hiệu quả hơn bằng cách sử dụng trí thông minh máy móc và tự động hóa.

Để trở nên thành công hơn trong việc mã hóa, giải quyết nhiều vấn đề thực sự hơn cho người thực. Đó là cách bạn đánh bóng các kỹ năng bạn thực sự cần trong thực tế. Rốt cuộc, những gì mà việc sử dụng lý thuyết học tập mà không ai cần?

Bạn xây dựng các kỹ năng mã hóa có giá trị cao bằng cách làm việc trên các dự án mã hóa thực tế!

Bạn có muốn ngừng học hỏi với các dự án đồ chơi và tập trung vào các dự án mã thực tế kiếm tiền cho bạn và giải quyết các vấn đề thực sự cho mọi người?

Nếu câu trả lời của bạn là có !, Hãy xem xét việc trở thành một nhà phát triển tự do Python! Đó là cách tốt nhất để tiếp cận nhiệm vụ cải thiện các kỹ năng trăn của bạn, ngay cả khi bạn là người mới bắt đầu hoàn toàn.YES!, consider becoming a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.

Nếu bạn chỉ muốn tìm hiểu về cơ hội làm việc tự do, vui lòng xem hội thảo trên web miễn phí của tôi Làm thế nào để xây dựng kỹ năng thu nhập cao của bạn Python và tìm hiểu cách tôi phát triển kinh doanh mã hóa của mình trực tuyến và làm thế nào bạn có thể, từ sự thoải mái của bạn riêng nhà.

Tham gia hội thảo trên web miễn phí ngay bây giờ!

Trong khi làm việc như một nhà nghiên cứu trong các hệ thống phân tán, Tiến sĩ Christian Mayer đã tìm thấy tình yêu của mình đối với việc dạy các sinh viên khoa học máy tính.

Để giúp học sinh đạt được thành công cao hơn của Python, ông đã thành lập trang web giáo dục chương trình Finxter.com. Ông là tác giả của cuốn sách lập trình phổ biến Python Oneer [Nostarch 2020], đồng tác giả của loạt sách Break Break Python, những cuốn sách tự xuất bản, người đam mê khoa học máy tính, freelancer và chủ sở hữu của một trong 10 blog Python lớn nhất trên toàn thế giới.

Niềm đam mê của ông là viết, đọc và mã hóa. Nhưng niềm đam mê lớn nhất của anh là phục vụ các lập trình viên đầy tham vọng thông qua Finxter và giúp họ tăng cường các kỹ năng của họ. Bạn có thể tham gia học viện email miễn phí của anh ấy ở đây.

Làm thế nào để bạn so sánh hai giá trị boolean trong Python?