Hướng dẫn which does not allow duplicates in python? - cái nào không cho phép trùng lặp trong python?

Có nhiều cách để loại bỏ các bản sao khỏi danh sách Python.

• Sử dụng một danh sách tạm thời và vòng lặp
• Sử dụng phương thức tích hợp set ()
• Sử dụng các phím từ điển
• Danh sách số () hàm
• Danh sách hiểu

Xóa các bản sao khỏi danh sách

Danh sách Python có thể chứa các yếu tố trùng lặp. Hãy cùng xem xét các ví dụ về việc loại bỏ các yếu tố trùng lặp theo những cách khác nhau.

1. Sử dụng danh sách tạm thời

Đây là cách vũ phu để loại bỏ các yếu tố trùng lặp khỏi danh sách. Chúng tôi sẽ tạo ra một danh sách tạm thời và chỉ các yếu tố phụ thuộc vào nó nếu nó không có mặt.

ints_list = [1, 2, 3, 4, 3, 2]

temp = []

for x in ints_list:
    if x not in temp:
        temp.append(x)

ints_list = temp

print(f'Updated List after removing duplicates = {temp}')

Đầu ra:

num_set = {1, 2, 3, 4, 5, 6}
print(num_set)

num_set = {1, 2, 3, 4, 5, 6}
print(num_set)

2. Đặt () hàm

Bộ Python không có các yếu tố trùng lặp. Chúng ta có thể sử dụng hàm set-in () tích hợp để chuyển đổi danh sách thành một tập hợp, sau đó sử dụng hàm danh sách () để chuyển đổi nó trở lại danh sách.

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

3. Liệt kê các yếu tố làm khóa từ điển

Chúng tôi biết rằng các khóa từ điển là duy nhất. Lớp Dict có chức năng FromKeys () chấp nhận một điều có thể tạo ra để tạo từ điển với các phím từ Itable.

ints_list = [1, 2, 3, 4, 3, 2]

ints_list2 = list(dict.fromkeys(ints_list))
print(ints_list2)  # [1, 2, 3, 4]

4. Hàm số lượng () danh sách - không được khuyến nghị

Phương thức Danh sách () trả về số lần xuất hiện của giá trị. Chúng ta có thể sử dụng nó với phương thức Remove () để loại bỏ các phần tử trùng lặp khỏi danh sách.

ints_list = [1, 2, 3, 4, 3, 2]

for x in ints_list:
    if ints_list.count(x) > 1:
        ints_list.remove(x)
print(ints_list)  # [1, 2, 3, 4]

Lưu ý: Như đã chỉ ra trong nhận xét dưới đây, việc sử dụng hàm Count () không được khuyến khích trong khi loại bỏ phần tử khỏi cùng một trình lặp vì nó có thể dẫn đến kết quả không mong muốn. Ví dụ: For example:

values = [87, 94, 45, 94, 94, 41, 65, 94, 41, 99, 94, 94, 94]

for x in values:
    if values.count(x) > 1:
        values.remove(x)
print(values)  # [87, 45, 65, 41, 99, 94, 94] - 94 is still present twice

5. Liệt kê hiểu biết

Chúng ta có thể tạo một danh sách từ một sự khác biệt bằng cách sử dụng danh sách hiểu. Kỹ thuật này giống như sử dụng danh sách tạm thời và vòng lặp For để loại bỏ các phần tử trùng lặp. Nhưng, nó làm giảm số lượng dòng của mã.

int_list = [1, 2, 3, 4, 3, 2]
temp = []
[temp.append(x) for x in ints_list if x not in temp]
print(temp)  # [1, 2, 3, 4]

Cách tốt nhất để loại bỏ các bản sao khỏi danh sách

Nếu bạn không muốn các yếu tố trùng lặp, bạn nên sử dụng Set. Nhưng, nếu bạn phải xóa các giá trị trùng lặp khỏi danh sách, thì tôi sẽ thích hàm đếm () hơn vì nó không tạo ra một đối tượng danh sách hoặc bộ tạm thời khác. Vì vậy, nó có nhiều bộ nhớ hiệu quả hơn.

Phương pháp đặt Python

>>> item_list = [1, 7, 7, 7, 11, 14 ,100, 100, 4, 4, 4]
>>> seen = set()
>>> item_list[:] = [item for item in item_list
                                       if item not in seen and not seen.add(item)]
>>> item_list
[1, 7, 11, 14, 100, 4]

Trong các phần sau, chúng tôi sẽ thảo luận về một số phương pháp được sử dụng phổ biến nhất được cung cấp bởi Python mà chúng tôi chưa thảo luận.

>>> set(item_list)
set([1, 100, 7, 11, 14, 4])

Giới thiệu

Trong Python, một bộ là một cấu trúc dữ liệu lưu trữ các mục chưa được đặt hàng. Các mục đã thiết lập cũng không được đăng ký. Giống như một danh sách, một bộ cho phép bổ sung và loại bỏ các yếu tố. Tuy nhiên, có một vài đặc điểm độc đáo xác định một tập hợp và tách nó khỏi các cấu trúc dữ liệu khác:

• Một bộ không giữ các mục trùng lặp
• Các yếu tố của tập hợp là bất biến, nghĩa là chúng không thể thay đổi, nhưng bản thân bộ này có thể thay đổi, nghĩa là nó có thể được thay đổi
• Vì các mục đã đặt không được lập chỉ mục, các bộ không hỗ trợ bất kỳ hoạt động cắt hoặc lập chỉ mục nào.

Trong hướng dẫn này, chúng tôi sẽ xem xét cách tạo và sử dụng các bộ trong Python, cùng với một số hoạt động phổ biến mà bạn chạy chống lại chúng.

Cách tạo một bộ trong Python

Một bộ có thể chứa bất kỳ số lượng vật phẩm nào và các mục có thể thuộc các loại khác nhau (bộ sưu tập không đồng nhất) như số nguyên, chuỗi, bộ dữ liệu, v.v.

Lưu ý: Một tập hợp không chấp nhận các yếu tố có thể thay đổi, chẳng hạn như danh sách và từ điển. A set does not accept mutable elements, such as lists and dictionaries.

Chúng ta có thể tạo một tập hợp bằng cách chuyển tất cả các phần tử tập hợp bên trong niềng răng xoăn

num_set = {1, 2, 3, 4, 5, 6}
print(num_set)

num_set = {1, 2, 3, 4, 5, 6}
print(num_set)

num_set = {1, 2, 3, 4, 5, 6}
print(num_set)

Điều này sẽ dẫn đến:

{1, 2, 3, 4, 5, 6}

Chúng tôi chỉ tạo ra một tập hợp các số. Chúng ta cũng có thể tạo một tập hợp các giá trị chuỗi:

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

Kết quả là:

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

Lưu ý: Lưu ý cách các phần tử trong đầu ra không được đặt hàng giống như cách chúng tôi đã thêm chúng vào tập hợp. Lý do cho điều này là các mục đặt không được đặt hàng. Nếu bạn chạy cùng một mã một lần nữa, bạn có thể sẽ nhận được đầu ra với các phần tử được sắp xếp theo một thứ tự khác. Notice how elements in the output are not ordered in the same way we added them to the set. The reason for this is that set items are not ordered. If you run the same code again, you're likely to get an output with the elements arranged in a different order.

Chúng ta cũng có thể tạo một tập hợp với các yếu tố của các loại khác nhau:

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

Hãy xác minh điều này mang lại một tập hợp hợp lệ:

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

Tất cả các yếu tố của tập hợp trên thuộc về các loại khác nhau. Chúng tôi cũng có thể tạo một bộ từ một danh sách. Điều này có thể được thực hiện bằng cách gọi phương thức

num_set = {1, 2, 3, 4, 5, 6}
print(num_set)

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

Kết quả này trong:

{1, 2, 3, 4, 5, 6}

Như đã nêu ở trên, các bộ không giữ các mục trùng lặp. Giả sử danh sách của chúng tôi có các mục trùng lặp:

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

Bộ sẽ chỉ lưu trữ các giá trị duy nhất từ ​​danh sách:

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

Bộ này về cơ bản đã loại bỏ các bản sao và chỉ trả về một trong mỗi mục trùng lặp. Điều này cũng xảy ra khi chúng ta đang tạo một bộ từ đầu:

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

Một lần nữa, bộ đã loại bỏ các bản sao và chỉ trả về một trong các mục trùng lặp:

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

Nếu bạn muốn tạo một bộ trống và sử dụng niềng răng xoăn trống (

num_set = {1, 2, 3, 4, 5, 6}
print(num_set)

ints_list = [1, 2, 3, 4, 3, 2]

ints_list2 = list(dict.fromkeys(ints_list))
print(ints_list2)  # [1, 2, 3, 4]

Để tạo một tập trống trong Python, chúng tôi chỉ cần gọi trên phương thức

num_set = {1, 2, 3, 4, 5, 6}
print(num_set)

ints_list = [1, 2, 3, 4, 3, 2]

ints_list2 = list(dict.fromkeys(ints_list))
print(ints_list2)  # [1, 2, 3, 4]

Cách truy cập các mục đặt trong Python

Python không cung cấp cho chúng tôi một cách truy cập vào một mục đặt riêng lẻ bằng cách sử dụng ký hiệu đăng ký (

{1, 2, 3, 4, 5, 6}

{1, 2, 3, 4, 5, 6}

ints_list = [1, 2, 3, 4, 3, 2]

ints_list2 = list(dict.fromkeys(ints_list))
print(ints_list2)  # [1, 2, 3, 4]

Điều này sẽ in từng phần tử trong một bộ

{1, 2, 3, 4, 5, 6}

ints_list = [1, 2, 3, 4, 3, 2]

ints_list2 = list(dict.fromkeys(ints_list))
print(ints_list2)  # [1, 2, 3, 4]

Chúng tôi cũng có thể kiểm tra sự hiện diện của một phần tử trong một bộ bằng từ khóa

{1, 2, 3, 4, 5, 6}

ints_list = [1, 2, 3, 4, 3, 2]

ints_list2 = list(dict.fromkeys(ints_list))
print(ints_list2)  # [1, 2, 3, 4]

Vì

{1, 2, 3, 4, 5, 6}

{1, 2, 3, 4, 5, 6}

{1, 2, 3, 4, 5, 6}

ints_list = [1, 2, 3, 4, 3, 2]

ints_list2 = list(dict.fromkeys(ints_list))
print(ints_list2)  # [1, 2, 3, 4]

Tương tự, việc tìm kiếm một phần tử không tồn tại trong bộ trả về

{1, 2, 3, 4, 5, 6}

ints_list = [1, 2, 3, 4, 3, 2]

ints_list2 = list(dict.fromkeys(ints_list))
print(ints_list2)  # [1, 2, 3, 4]

Điều này sẽ dẫn đến:

ints_list = [1, 2, 3, 4, 3, 2]

ints_list2 = list(dict.fromkeys(ints_list))
print(ints_list2)  # [1, 2, 3, 4]

Cách thêm các mục vào bộ Python

Python cho phép chúng tôi thêm các mục mới vào một bộ bằng phương thức

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list2 = list(dict.fromkeys(ints_list))
print(ints_list2)  # [1, 2, 3, 4]

Mục

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list2 = list(dict.fromkeys(ints_list))
print(ints_list2)  # [1, 2, 3, 4]

Nếu đó là một tập hợp các số, chúng tôi sẽ không vượt qua phần tử mới trong các trích dẫn như chúng tôi phải làm cho một chuỗi:

ints_list = [1, 2, 3, 4, 3, 2]

for x in ints_list:
    if ints_list.count(x) > 1:
        ints_list.remove(x)
print(ints_list)  # [1, 2, 3, 4]

Sẽ thêm

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

for x in ints_list:
    if ints_list.count(x) > 1:
        ints_list.remove(x)
print(ints_list)  # [1, 2, 3, 4]

Trong phần tiếp theo, chúng tôi sẽ thảo luận về cách loại bỏ các yếu tố khỏi các bộ.

Cách xóa các mục khỏi bộ python

Python một cách tự nhiên cho phép chúng tôi xóa một mục khỏi một bộ, nhưng chúng tôi không thể xóa nó thông qua một chỉ mục vì các phần tử đặt không được lập chỉ mục. Các mục có thể được loại bỏ bằng các phương thức

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

Lưu ý: Hãy nhớ rằng phương thức

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

discard()

Hãy trình bày cách xóa một phần tử bằng phương pháp

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

for x in ints_list:
    if ints_list.count(x) > 1:
        ints_list.remove(x)
print(ints_list)  # [1, 2, 3, 4]

Phần tử

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

for x in ints_list:
    if ints_list.count(x) > 1:
        ints_list.remove(x)
print(ints_list)  # [1, 2, 3, 4]

remove()

Tương tự, phương pháp

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

for x in ints_list:
    if ints_list.count(x) > 1:
        ints_list.remove(x)
print(ints_list)  # [1, 2, 3, 4]

Điều này sẽ mang lại kết quả tương tự:

ints_list = [1, 2, 3, 4, 3, 2]

for x in ints_list:
    if ints_list.count(x) > 1:
        ints_list.remove(x)
print(ints_list)  # [1, 2, 3, 4]

Loại bỏ các yếu tố không tồn tại?

Bây giờ, chúng ta hãy cố gắng loại bỏ một yếu tố không tồn tại trong tập hợp. Trước tiên hãy sử dụng phương pháp

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

for x in ints_list:
    if ints_list.count(x) > 1:
        ints_list.remove(x)
print(ints_list)  # [1, 2, 3, 4]

Chạy mã ở trên sẽ không ảnh hưởng đến tập hợp theo bất kỳ cách nào:

{1, 2, 3, 4, 5, 6}

Bây giờ, hãy xem điều gì xảy ra khi chúng ta sử dụng phương thức

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

for x in ints_list:
    if ints_list.count(x) > 1:
        ints_list.remove(x)
print(ints_list)  # [1, 2, 3, 4]

Trong trường hợp này, việc cố gắng xóa một phần tử không tồn tại sẽ gây ra lỗi:

ints_list = [1, 2, 3, 4, 3, 2]

for x in ints_list:
    if ints_list.count(x) > 1:
        ints_list.remove(x)
print(ints_list)  # [1, 2, 3, 4]

pop()

Với phương thức

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

values = [87, 94, 45, 94, 94, 41, 65, 94, 41, 99, 94, 94, 94]

for x in values:
    if values.count(x) > 1:
        values.remove(x)
print(values)  # [87, 45, 65, 41, 99, 94, 94] - 94 is still present twice

Điều này sẽ trả về phần tử bị loại bỏ từ tập hợp:

values = [87, 94, 45, 94, 94, 41, 65, 94, 41, 99, 94, 94, 94]

for x in values:
    if values.count(x) > 1:
        values.remove(x)
print(values)  # [87, 45, 65, 41, 99, 94, 94] - 94 is still present twice

Bạn có thể sử dụng cùng một phương thức để xóa một phần tử và trả về các phần tử còn lại trong tập hợp:

values = [87, 94, 45, 94, 94, 41, 65, 94, 41, 99, 94, 94, 94]

for x in values:
    if values.count(x) > 1:
        values.remove(x)
print(values)  # [87, 45, 65, 41, 99, 94, 94] - 94 is still present twice

Sẽ in ra các yếu tố còn lại trong tập hợp:

values = [87, 94, 45, 94, 94, 41, 65, 94, 41, 99, 94, 94, 94]

for x in values:
    if values.count(x) > 1:
        values.remove(x)
print(values)  # [87, 45, 65, 41, 99, 94, 94] - 94 is still present twice

clear()

Phương thức

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

values = [87, 94, 45, 94, 94, 41, 65, 94, 41, 99, 94, 94, 94]

for x in values:
    if values.count(x) > 1:
        values.remove(x)
print(values)  # [87, 45, 65, 41, 99, 94, 94] - 94 is still present twice

Kiểm tra hướng dẫn thực hành của chúng tôi, thực tế để học Git, với các thực hành tốt nhất, các tiêu chuẩn được công nghiệp chấp nhận và bao gồm bảng gian lận. Ngừng các lệnh git googling và thực sự tìm hiểu nó!

Đầu ra là một

num_set = {1, 2, 3, 4, 5, 6}
print(num_set)

values = [87, 94, 45, 94, 94, 41, 65, 94, 41, 99, 94, 94, 94]

for x in values:
    if values.count(x) > 1:
        values.remove(x)
print(values)  # [87, 45, 65, 41, 99, 94, 94] - 94 is still present twice

Liên minh các bộ Python

Giả sử chúng ta có hai bộ, A và B. Sự kết hợp của hai bộ là một bộ với tất cả các yếu tố từ cả hai bộ. Một hoạt động như vậy được thực hiện bằng phương pháp

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

Ví dụ: giả sử chúng tôi có hai bộ chứa tên tháng:

values = [87, 94, 45, 94, 94, 41, 65, 94, 41, 99, 94, 94, 94]

for x in values:
    if values.count(x) > 1:
        values.remove(x)
print(values)  # [87, 45, 65, 41, 99, 94, 94] - 94 is still present twice

Sau khi chạy mã này, bộ

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

values = [87, 94, 45, 94, 94, 41, 65, 94, 41, 99, 94, 94, 94]

for x in values:
    if values.count(x) > 1:
        values.remove(x)
print(values)  # [87, 45, 65, 41, 99, 94, 94] - 94 is still present twice

Một liên minh cũng có thể được thực hiện trên hơn hai bộ và tất cả các yếu tố của chúng sẽ được kết hợp thành một bộ duy nhất:

values = [87, 94, 45, 94, 94, 41, 65, 94, 41, 99, 94, 94, 94]

for x in values:
    if values.count(x) > 1:
        values.remove(x)
print(values)  # [87, 45, 65, 41, 99, 94, 94] - 94 is still present twice

Điều này sẽ dẫn đến:

values = [87, 94, 45, 94, 94, 41, 65, 94, 41, 99, 94, 94, 94]

for x in values:
    if values.count(x) > 1:
        values.remove(x)
print(values)  # [87, 45, 65, 41, 99, 94, 94] - 94 is still present twice

Trong quá trình hoạt động của Liên minh, các bản sao bị bỏ qua và chỉ có một trong số các mục trùng lặp được hiển thị:

int_list = [1, 2, 3, 4, 3, 2]
temp = []
[temp.append(x) for x in ints_list if x not in temp]
print(temp)  # [1, 2, 3, 4]

Điều này sẽ dẫn đến tập hợp chỉ chứa các giá trị duy nhất từ ​​các bộ bắt đầu:

int_list = [1, 2, 3, 4, 3, 2]
temp = []
[temp.append(x) for x in ints_list if x not in temp]
print(temp)  # [1, 2, 3, 4]

Toán tử

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

int_list = [1, 2, 3, 4, 3, 2]
temp = []
[temp.append(x) for x in ints_list if x not in temp]
print(temp)  # [1, 2, 3, 4]

Điều này sẽ mang lại kết quả tương tự như sử dụng phương thức

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

int_list = [1, 2, 3, 4, 3, 2]
temp = []
[temp.append(x) for x in ints_list if x not in temp]
print(temp)  # [1, 2, 3, 4]

Nếu bạn muốn thực hiện một liên minh trên hơn hai bộ, hãy tách các tên bộ bằng toán tử

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

int_list = [1, 2, 3, 4, 3, 2]
temp = []
[temp.append(x) for x in ints_list if x not in temp]
print(temp)  # [1, 2, 3, 4]

Điều này sẽ dẫn đến:

int_list = [1, 2, 3, 4, 3, 2]
temp = []
[temp.append(x) for x in ints_list if x not in temp]
print(temp)  # [1, 2, 3, 4]

Giao điểm của bộ Python

Giả sử bạn có hai bộ, A và B. Giao điểm của chúng là một tập hợp với các yếu tố có mặt cả trong A và B.

Có thể đạt được hoạt động giao nhau trong các bộ bằng cách sử dụng toán tử

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

int_list = [1, 2, 3, 4, 3, 2]
temp = []
[temp.append(x) for x in ints_list if x not in temp]
print(temp)  # [1, 2, 3, 4]

Yếu tố chung duy nhất là

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

int_list = [1, 2, 3, 4, 3, 2]
temp = []
[temp.append(x) for x in ints_list if x not in temp]
print(temp)  # [1, 2, 3, 4]

Điều tương tự cũng có thể đạt được với phương pháp

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

int_list = [1, 2, 3, 4, 3, 2]
temp = []
[temp.append(x) for x in ints_list if x not in temp]
print(temp)  # [1, 2, 3, 4]

Điều này cũng sẽ dẫn đến:

int_list = [1, 2, 3, 4, 3, 2]
temp = []
[temp.append(x) for x in ints_list if x not in temp]
print(temp)  # [1, 2, 3, 4]

Sự khác biệt giữa các bộ python

Giả sử bạn có hai bộ A và B. Sự khác biệt giữa A và B (A - B) là tập hợp với tất cả các phần tử trong A nhưng không phải trong B. Do đó, (B - A) là tập hợp với tất cả các yếu tố trong B nhưng không phải ở A.

Để xác định sự khác biệt trong Python, chúng ta có thể sử dụng phương thức

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

>>> item_list = [1, 7, 7, 7, 11, 14 ,100, 100, 4, 4, 4]
>>> seen = set()
>>> item_list[:] = [item for item in item_list
                                       if item not in seen and not seen.add(item)]
>>> item_list
[1, 7, 11, 14, 100, 4]

Mã trên tính toán sự khác biệt giữa

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

Toán tử trừ (

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

>>> item_list = [1, 7, 7, 7, 11, 14 ,100, 100, 4, 4, 4]
>>> seen = set()
>>> item_list[:] = [item for item in item_list
                                       if item not in seen and not seen.add(item)]
>>> item_list
[1, 7, 11, 14, 100, 4]

Điều này sẽ dẫn đến đầu ra giống như sử dụng phương thức

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

Sự khác biệt đối xứng của các tập A và B là tập hợp với tất cả các phần tử trong A và B ngoại trừ các phần tử phổ biến trong cả hai tập hợp. Nó được xác định bằng phương pháp

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

>>> item_list = [1, 7, 7, 7, 11, 14 ,100, 100, 4, 4, 4]
>>> seen = set()
>>> item_list[:] = [item for item in item_list
                                       if item not in seen and not seen.add(item)]
>>> item_list
[1, 7, 11, 14, 100, 4]

Điều này sẽ dẫn đến:

>>> item_list = [1, 7, 7, 7, 11, 14 ,100, 100, 4, 4, 4]
>>> seen = set()
>>> item_list[:] = [item for item in item_list
                                       if item not in seen and not seen.add(item)]
>>> item_list
[1, 7, 11, 14, 100, 4]

Như chúng tôi đã nêu trước đây, sự khác biệt đối xứng cũng có thể được tìm thấy bằng cách sử dụng toán tử

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

>>> item_list = [1, 7, 7, 7, 11, 14 ,100, 100, 4, 4, 4]
>>> seen = set()
>>> item_list[:] = [item for item in item_list
                                       if item not in seen and not seen.add(item)]
>>> item_list
[1, 7, 11, 14, 100, 4]

Điều này sẽ mang lại cùng đầu ra như trước:

>>> item_list = [1, 7, 7, 7, 11, 14 ,100, 100, 4, 4, 4]
>>> seen = set()
>>> item_list[:] = [item for item in item_list
                                       if item not in seen and not seen.add(item)]
>>> item_list
[1, 7, 11, 14, 100, 4]

So sánh các bộ python

Chúng ta có thể so sánh các bộ tùy thuộc vào các yếu tố họ có. Bằng cách này, chúng ta có thể biết liệu một tập hợp là một superset hay một tập hợp con của một bộ khác. Kết quả từ một so sánh như vậy sẽ là

{1, 2, 3, 4, 5, 6}

{1, 2, 3, 4, 5, 6}

Để kiểm tra xem SET A có phải là tập hợp con của SET B hay không, chúng ta có thể sử dụng thao tác sau:

>>> item_list = [1, 7, 7, 7, 11, 14 ,100, 100, 4, 4, 4]
>>> seen = set()
>>> item_list[:] = [item for item in item_list
                                       if item not in seen and not seen.add(item)]
>>> item_list
[1, 7, 11, 14, 100, 4]

Để kiểm tra xem B có phải là siêu của A hay không, chúng ta có thể sử dụng thao tác sau:

>>> item_list = [1, 7, 7, 7, 11, 14 ,100, 100, 4, 4, 4]
>>> seen = set()
>>> item_list[:] = [item for item in item_list
                                       if item not in seen and not seen.add(item)]
>>> item_list
[1, 7, 11, 14, 100, 4]

Ví dụ:

>>> set(item_list)
set([1, 100, 7, 11, 14, 4])

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

>>> set(item_list)
set([1, 100, 7, 11, 14, 4])

Tập hợp con và superset cũng có thể được kiểm tra bằng các phương thức

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

>>> set(item_list)
set([1, 100, 7, 11, 14, 4])

Mang lại cùng một đầu ra trong ví dụ trên:

>>> set(item_list)
set([1, 100, 7, 11, 14, 4])

Phương pháp đặt Python

Trong các phần sau, chúng tôi sẽ thảo luận về một số phương pháp được sử dụng phổ biến nhất được cung cấp bởi Python mà chúng tôi chưa thảo luận.

copy()

Phương thức này trả về một bản sao của bộ trong câu hỏi:

>>> set(item_list)
set([1, 100, 7, 11, 14, 4])

Đầu ra cho thấy

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

>>> set(item_list)
set([1, 100, 7, 11, 14, 4])

isdisjoint()

Phương pháp này kiểm tra xem các bộ trong câu hỏi có giao điểm hay không. Nếu các bộ không có các mục phổ biến, phương thức này sẽ trả về

{1, 2, 3, 4, 5, 6}

{1, 2, 3, 4, 5, 6}

>>> set(item_list)
set([1, 100, 7, 11, 14, 4])

Hai bộ không có các mục phổ biến, do đó đầu ra là

{1, 2, 3, 4, 5, 6}

ints_list = [1, 2, 3, 4, 3, 2]

ints_list2 = list(dict.fromkeys(ints_list))
print(ints_list2)  # [1, 2, 3, 4]

len()

Phương thức này trả về độ dài của một tập hợp, là tổng số phần tử trong tập hợp:

>>> set(item_list)
set([1, 100, 7, 11, 14, 4])

Đầu ra cho thấy tập hợp có độ dài 4:

>>> set(item_list)
set([1, 100, 7, 11, 14, 4])

Python Frozen Set

Frozenset là một lớp với các đặc điểm của một tập hợp, nhưng một khi các yếu tố của nó đã được chỉ định, chúng không thể thay đổi. Tuples có thể được coi là danh sách bất biến, trong khi các bộ đông lạnh có thể được xem là các bộ bất biến.

LƯU Ý: Các bộ có thể thay đổi và không thể thay đổi, điều đó có nghĩa là chúng tôi không thể sử dụng chúng làm khóa từ điển. Các bộ đông lạnh có thể băm và chúng ta có thể sử dụng chúng làm khóa từ điển. Sets are mutable and unhashable, which means we cannot use them as dictionary keys. Frozen sets are hashable and we can use them as dictionary keys.

Để tạo các bộ đông lạnh, chúng tôi sử dụng phương thức

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

num_set = {1, 2, 3, 4, 5, 6}
print(num_set)

Điều này sẽ dẫn đến:

num_set = {1, 2, 3, 4, 5, 6}
print(num_set)

Các frozensets hỗ trợ việc sử dụng các phương pháp đặt Python như

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

ints_list = [1, 2, 3, 4, 3, 2]

ints_list1 = list(set(ints_list))
print(ints_list1)  # [1, 2, 3, 4]

Sự kết luận

Hướng dẫn cung cấp một giới thiệu chi tiết về các bộ trong Python. Định nghĩa toán học của các tập hợp giống như định nghĩa của các bộ trong Python. Một bộ chỉ đơn giản là một bộ sưu tập các mục chưa được đặt hàng. Bản thân bộ là có thể thay đổi, nhưng các yếu tố đã đặt là bất biến. Tuy nhiên, chúng ta có thể thêm và loại bỏ các phần tử khỏi một tập hợp tự do. Trong hầu hết các cấu trúc dữ liệu, các yếu tố được lập chỉ mục. Tuy nhiên, các yếu tố đặt không được lập chỉ mục. Điều này làm cho chúng tôi không thể thực hiện các hoạt động nhắm mục tiêu các yếu tố tập hợp cụ thể.

Bộ sưu tập Python nào không cho phép trùng lặp?

Điều nào cho phép trùng lặp trong Python?

Bộ sưu tập nào không cho phép trùng lặp?

Danh sách có cho phép trùng lặp trong Python không?