Cặp biểu tượng nào bạn cần thực hiện danh sách con trong python

Question

Có lẽ bạn nhớ lại việc học về tập hợp và lý thuyết tập hợp tại một thời điểm nào đó trong giáo dục toán học của bạn. Có thể bạn còn nhớ biểu đồ Venn

Nội dung chính Show

Xác định một tập hợp
Đặt kích thước và tư cách thành viên
Hoạt động trên một tập hợp
Toán tử vs. phương pháp
Các toán tử và phương thức khả dụng
Sửa đổi một Set
Phương thức và toán tử gán tăng cường
Các phương pháp khác để sửa đổi bộ
Bộ đông lạnh
Phần kết luận
Danh sách này chứa ba loại dữ liệu Python nào?
Điều nào sau đây là đặc điểm của danh sách Python?
Làm cách nào để chuyển đổi mảng thành danh sách Python?
Danh sách có giống với mảng trong Python không?

Cặp biểu tượng nào bạn cần thực hiện danh sách con trong python

Nếu điều này không đổ chuông, đừng lo lắng. Bạn vẫn có thể dễ dàng truy cập hướng dẫn này

Trong toán học, một định nghĩa chặt chẽ về một tập hợp có thể trừu tượng và khó nắm bắt. Tuy nhiên, trên thực tế, một tập hợp có thể được coi đơn giản là một tập hợp các đối tượng riêng biệt được xác định rõ ràng, thường được gọi là các phần tử hoặc phần tử

Việc nhóm các đối tượng thành một tập hợp cũng có thể hữu ích trong lập trình và Python cung cấp một loại tập hợp tích hợp để làm như vậy. Tập hợp được phân biệt với các loại đối tượng khác bởi các thao tác duy nhất có thể được thực hiện trên chúng

Đây là những gì bạn sẽ học trong hướng dẫn này. Bạn sẽ thấy cách định nghĩa các đối tượng tập hợp trong Python và khám phá các thao tác mà chúng hỗ trợ. Như với các hướng dẫn trước về danh sách và từ điển, khi bạn hoàn thành hướng dẫn này, bạn sẽ có cảm giác tốt khi một bộ là một lựa chọn thích hợp. Bạn cũng sẽ tìm hiểu về các bộ cố định, tương tự như các bộ ngoại trừ một chi tiết quan trọng

Lấy bài kiểm tra. Kiểm tra kiến thức của bạn với bài kiểm tra tương tác “Bộ Python” của chúng tôi. Sau khi hoàn thành, bạn sẽ nhận được điểm số để có thể theo dõi quá trình học tập của mình theo thời gian

Lấy bài kiểm tra "

Xác định một tập hợp

Loại

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

3 tích hợp sẵn của Python có các đặc điểm sau

Bộ không có thứ tự
Các phần tử của tập hợp là duy nhất. Các yếu tố trùng lặp không được phép
Bản thân một tập hợp có thể được sửa đổi, nhưng các phần tử chứa trong tập hợp phải thuộc loại bất biến

Hãy xem tất cả những điều đó có nghĩa là gì và cách bạn có thể làm việc với các tập hợp trong Python

Một bộ có thể được tạo theo hai cách. Đầu tiên, bạn có thể xác định một tập hợp với hàm

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

4 tích hợp

x = set(<iter>)

Trong trường hợp này, đối số

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

5 là một đối số có thể lặp lại—một lần nữa, tại thời điểm này, think list hoặc tuple—tạo ra danh sách các đối tượng được đưa vào tập hợp. Điều này tương tự như đối số

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

5 được cung cấp cho phương thức danh sách

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

7

>>>

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

Các chuỗi cũng có thể lặp lại, do đó, một chuỗi cũng có thể được chuyển đến

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

4. Bạn đã thấy rằng

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

9 tạo ra một danh sách các ký tự trong chuỗi

>>> x = set()
>>> type(x)

>>> x
set()

>>> x = {}
>>> type(x)

0. Tương tự,

>>> x = set()
>>> type(x)

>>> x
set()

>>> x = {}
>>> type(x)

1 tạo ra một tập hợp các ký tự trong

>>> x = set()
>>> type(x)

>>> x
set()

>>> x = {}
>>> type(x)

0

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

2

Bạn có thể thấy rằng các bộ kết quả không có thứ tự. thứ tự ban đầu, như được chỉ định trong định nghĩa, không nhất thiết phải được giữ nguyên. Ngoài ra, các giá trị trùng lặp chỉ được biểu diễn trong tập hợp một lần, như với chuỗi

>>> x = set()
>>> type(x)

>>> x
set()

>>> x = {}
>>> type(x)

3 trong hai ví dụ đầu tiên và chữ cái

>>> x = set()
>>> type(x)

>>> x
set()

>>> x = {}
>>> type(x)

4 trong ví dụ thứ ba

Ngoài ra, một tập hợp có thể được xác định bằng dấu ngoặc nhọn (______95)

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

6

Khi một tập hợp được xác định theo cách này, mỗi

>>> x = set()
>>> type(x)

>>> x
set()

>>> x = {}
>>> type(x)

6 sẽ trở thành một phần tử riêng biệt của tập hợp, ngay cả khi nó là một tập hợp có thể lặp lại. Hành vi này tương tự như hành vi của phương thức danh sách

>>> x = set()
>>> type(x)

>>> x
set()

>>> x = {}
>>> type(x)

7

Do đó, các tập hợp hiển thị ở trên cũng có thể được định nghĩa như thế này

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

9

Tóm lại

Đối số của
```
>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}
```
4 là một đối số có thể lặp lại. Nó tạo ra một danh sách các phần tử được đặt vào tập hợp
Các đối tượng trong dấu ngoặc nhọn được đặt nguyên vẹn vào tập hợp, ngay cả khi chúng có thể lặp lại

Quan sát sự khác biệt giữa hai định nghĩa tập hợp này

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

Một bộ có thể trống. Tuy nhiên, hãy nhớ rằng Python diễn giải các dấu ngoặc nhọn trống (______95) là một từ điển rỗng, vì vậy cách duy nhất để xác định một tập rỗng là sử dụng hàm

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

4

>>>

>>> x = set()
>>> type(x)

>>> x
set()

>>> x = {}
>>> type(x)

Một tập hợp trống là sai trong ngữ cảnh Boolean

>>>

x = set(<iter>)

5

Bạn có thể nghĩ rằng các tập hợp trực quan nhất sẽ chứa các đối tượng tương tự—ví dụ: số chẵn hoặc họ

>>>

x = set(<iter>)

6

Tuy nhiên, Python không yêu cầu điều này. Các phần tử trong một tập hợp có thể là các đối tượng thuộc các loại khác nhau

>>>

x = set(<iter>)

7

Đừng quên rằng các phần tử tập hợp phải là bất biến. Ví dụ, một bộ có thể được bao gồm trong một tập hợp

>>>

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

0

Nhưng danh sách và từ điển có thể thay đổi, vì vậy chúng không thể được đặt thành phần tử

>>>

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

1

Loại bỏ các quảng cáo

Đặt kích thước và tư cách thành viên

Hàm

x = set(<iter>)

51 trả về số lượng phần tử trong một tập hợp và các toán tử

x = set(<iter>)

52 và

x = set(<iter>)

53 có thể được sử dụng để kiểm tra tư cách thành viên

>>>

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

2

Hoạt động trên một tập hợp

Nhiều thao tác có thể được sử dụng cho các kiểu dữ liệu tổng hợp khác của Python không có ý nghĩa đối với các tập hợp. Ví dụ: các bộ không thể được lập chỉ mục hoặc cắt lát. Tuy nhiên, Python cung cấp một loạt các thao tác trên các đối tượng tập hợp thường bắt chước các hoạt động được xác định cho các tập hợp toán học

Toán tử vs. phương pháp

Hầu hết, mặc dù không hoàn toàn là tất cả, các thao tác thiết lập trong Python có thể được thực hiện theo hai cách khác nhau. bởi nhà điều hành hoặc bởi phương pháp. Hãy cùng xem cách thức hoạt động của các toán tử và phương thức này, sử dụng liên kết tập hợp làm ví dụ

Cho hai tập hợp,

x = set(<iter>)

54 và

x = set(<iter>)

55, hợp của

x = set(<iter>)

54 và

x = set(<iter>)

55 là một tập hợp bao gồm tất cả các phần tử trong cả hai tập hợp

Xét hai tập hợp này

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

3

Hợp của

x = set(<iter>)

54 và

x = set(<iter>)

55 là

x = set(<iter>)

60

Ghi chú. Lưu ý rằng phần tử

x = set(<iter>)

61, xuất hiện trong cả

x = set(<iter>)

54 và

x = set(<iter>)

55, chỉ xuất hiện một lần trong hợp. Các bộ không bao giờ chứa các giá trị trùng lặp

Trong Python, set union có thể được thực hiện với toán tử

x = set(<iter>)

64

>>>

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

4

Set union cũng có thể đạt được bằng phương pháp

x = set(<iter>)

65. Phương thức được gọi trên một trong các tập hợp và phương thức kia được truyền dưới dạng đối số

>>>

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

5

Cách chúng được sử dụng trong các ví dụ trên, toán tử và phương thức hoạt động giống hệt nhau. Nhưng có một sự khác biệt tinh tế giữa chúng. Khi bạn sử dụng toán tử

x = set(<iter>)

64, cả hai toán hạng phải được đặt. Mặt khác, phương thức

x = set(<iter>)

65 sẽ lấy bất kỳ iterable nào làm đối số, chuyển đổi nó thành một tập hợp và sau đó thực hiện phép hợp

Quan sát sự khác biệt giữa hai tuyên bố này

>>>

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

6

Cả hai đều cố gắng tính toán hợp của

x = set(<iter>)

54 và bộ

x = set(<iter>)

69. Điều này không thành công với toán tử

x = set(<iter>)

64 nhưng thành công với phương thức

x = set(<iter>)

65

Loại bỏ các quảng cáo

Các toán tử và phương thức khả dụng

Dưới đây là danh sách các thao tác thiết lập có sẵn trong Python. Một số được thực hiện bởi toán tử, một số theo phương pháp và một số bởi cả hai. Nguyên tắc nêu trên thường được áp dụng. trong đó một tập hợp được mong đợi, các phương thức thường sẽ chấp nhận bất kỳ khả năng lặp nào làm đối số, nhưng các toán tử yêu cầu các tập hợp thực tế làm toán hạng

x = set(<iter>)

72

x = set(<iter>)

73

Tính hợp của hai hay nhiều tập hợp

Đặt liên minh

x = set(<iter>)

74 và

x = set(<iter>)

75 đều trả về tập hợp tất cả các phần tử trong

x = set(<iter>)

54 hoặc

x = set(<iter>)

55

>>>

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

7

Có thể chỉ định nhiều hơn hai bộ bằng toán tử hoặc phương thức

>>>

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

8

Tập hợp kết quả chứa tất cả các phần tử có trong bất kỳ tập hợp nào đã chỉ định

x = set(<iter>)

78

x = set(<iter>)

79

Tính giao của hai hay nhiều tập hợp

Đặt giao lộ

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

00 và

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

01 trả về tập hợp các phần tử chung cho cả

x = set(<iter>)

54 và

x = set(<iter>)

55

>>>

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

9

Bạn có thể chỉ định nhiều tập hợp bằng toán tử và phương thức giao nhau, giống như bạn có thể làm với liên kết tập hợp

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

20

Tập hợp kết quả chỉ chứa các phần tử có trong tất cả các tập hợp đã chỉ định

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

04

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

05

Tính toán sự khác biệt giữa hai hoặc nhiều bộ

Đặt sự khác biệt

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

06 và

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

07 trả về tập hợp tất cả các phần tử nằm trong

x = set(<iter>)

54 nhưng không nằm trong

x = set(<iter>)

55

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

21

Một cách khác để nghĩ về điều này là

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

06 và

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

07 trả về tập kết quả khi bất kỳ phần tử nào trong

x = set(<iter>)

55 bị xóa hoặc trừ khỏi

x = set(<iter>)

54

Một lần nữa, bạn có thể chỉ định nhiều hơn hai bộ

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

22

Khi nhiều bộ được chỉ định, thao tác được thực hiện từ trái sang phải. Trong ví dụ trên,

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

14 được tính trước, kết quả là

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

15. Sau đó,

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

16 được trừ khỏi tập hợp đó, để lại

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

17

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

18

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

19

Tính hiệu đối xứng giữa các tập hợp

Đặt chênh lệch đối xứng

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

18 và

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

21 trả về tập hợp tất cả các phần tử trong

x = set(<iter>)

54 hoặc

x = set(<iter>)

55, nhưng không phải cả hai

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

23

Toán tử

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

24 cũng cho phép nhiều hơn hai bộ

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

24

Cũng như toán tử sai phân, khi chỉ định nhiều bộ, phép toán được thực hiện từ trái sang phải

Thật kỳ lạ, mặc dù toán tử

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

24 cho phép nhiều bộ, phương thức

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

26 không

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

25

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

27

Xác định xem hai tập hợp có phần tử chung hay không

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

27 trả về

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

29 nếu

x = set(<iter>)

54 và

x = set(<iter>)

55 không có phần tử chung

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

26

Nếu

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

27 là

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

29 thì

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

01 là tập hợp rỗng

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

27

Ghi chú. Không có toán tử nào tương ứng với phương thức

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

35

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

36

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

37

Xác định xem một tập hợp có phải là tập hợp con của tập hợp kia không

Trong lý thuyết tập hợp, một tập hợp

x = set(<iter>)

54 được coi là tập hợp con của một tập hợp khác

x = set(<iter>)

55 nếu mọi phần tử của

x = set(<iter>)

54 đều thuộc

x = set(<iter>)

55

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

36 và

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

37 trả về

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

29 nếu

x = set(<iter>)

54 là tập con của

x = set(<iter>)

55

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

28

Tập hợp được coi là tập con của chính nó

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

29

Nó có vẻ kỳ lạ, có lẽ. Nhưng nó phù hợp với định nghĩa—mọi phần tử của

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

47 đều nằm trong

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

47

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

49

Xác định xem một tập hợp có phải là tập hợp con thích hợp của tập hợp kia hay không

Một tập hợp con thích hợp giống như một tập hợp con, ngoại trừ các tập hợp không thể giống hệt nhau. Một tập hợp

x = set(<iter>)

54 được coi là một tập hợp con thực sự của một tập hợp khác

x = set(<iter>)

55 nếu mọi phần tử của

x = set(<iter>)

54 đều nằm trong

x = set(<iter>)

55 và

x = set(<iter>)

54 và

x = set(<iter>)

55 không bằng nhau

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

49 trả về

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

29 nếu

x = set(<iter>)

54 là một tập hợp con thích hợp của

x = set(<iter>)

55

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

60

Mặc dù một tập hợp được coi là một tập hợp con của chính nó, nhưng nó không phải là một tập hợp con thực sự của chính nó

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

61

Ghi chú. Toán tử

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

60 là cách duy nhất để kiểm tra xem một tập hợp có phải là tập con phù hợp hay không. Không có phương pháp tương ứng

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

61

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

62

Xác định xem một tập hợp có phải là siêu tập hợp của tập hợp kia không

Một superset là đảo ngược của một subset. Tập hợp

x = set(<iter>)

54 được coi là tập hợp lớn nhất của tập hợp khác

x = set(<iter>)

55 nếu

x = set(<iter>)

54 chứa mọi phần tử của

x = set(<iter>)

55

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

61 và

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

62 trả về

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

29 nếu

x = set(<iter>)

54 là tập hợp lớn nhất của

x = set(<iter>)

55

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

62

Bạn đã thấy rằng một tập hợp được coi là một tập hợp con của chính nó. Một tập hợp cũng được coi là siêu tập hợp của chính nó

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

63

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

72

Xác định xem một tập hợp có phải là tập hợp lớn nhất của tập hợp kia hay không

Một superset phù hợp cũng giống như một superset, ngoại trừ việc các set không được giống nhau. Một tập hợp

x = set(<iter>)

54 được coi là một siêu tập hợp của một tập hợp khác

x = set(<iter>)

55 nếu

x = set(<iter>)

54 chứa mọi phần tử của

x = set(<iter>)

55 và

x = set(<iter>)

54 và

x = set(<iter>)

55 không bằng nhau

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

72 trả về

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

29 nếu

x = set(<iter>)

54 là một siêu bộ thích hợp của

x = set(<iter>)

55

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

64

Một tập hợp không phải là tập hợp lớn nhất của chính nó

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

65

Ghi chú. Toán tử

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

83 là cách duy nhất để kiểm tra xem một tập hợp có phải là một siêu tập hợp hay không. Không có phương pháp tương ứng

Loại bỏ các quảng cáo

Sửa đổi một Set

Mặc dù các phần tử chứa trong một tập hợp phải thuộc loại bất biến, nhưng bản thân các tập hợp có thể được sửa đổi. Giống như các thao tác ở trên, có nhiều toán tử và phương thức có thể được sử dụng để thay đổi nội dung của một tập hợp

Phương thức và toán tử gán tăng cường

Mỗi toán tử hợp, giao, hiệu và hiệu đối xứng được liệt kê ở trên có một biểu mẫu gán tăng cường có thể được sử dụng để sửa đổi một tập hợp. Đối với mỗi, có một phương pháp tương ứng là tốt

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

84

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

85

Sửa đổi một tập hợp bằng công đoàn

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

86 và

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

87 thêm vào

x = set(<iter>)

54 bất kỳ yếu tố nào trong

x = set(<iter>)

55 mà

x = set(<iter>)

54 chưa có

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

66

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

91

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

92

Sửa đổi một tập hợp theo giao điểm

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

93 và

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

94 cập nhật

x = set(<iter>)

54, chỉ giữ lại các phần tử có trong cả

x = set(<iter>)

54 và

x = set(<iter>)

55

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

67

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

98

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

99

Sửa đổi một tập hợp theo sự khác biệt

Cập nhật

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

200 và

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

201

x = set(<iter>)

54, loại bỏ các phần tử được tìm thấy trong

x = set(<iter>)

55

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

68

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

204

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

205

Sửa đổi một tập hợp bằng sự khác biệt đối xứng

Cập nhật

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

204 và

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

205

x = set(<iter>)

54, giữ lại các phần tử có trong

x = set(<iter>)

54 hoặc

x = set(<iter>)

55, nhưng không phải cả hai

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

69

Loại bỏ các quảng cáo

Các phương pháp khác để sửa đổi bộ

Ngoài các toán tử tăng cường ở trên, Python hỗ trợ một số phương thức bổ sung để sửa đổi các tập hợp

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

211

Thêm một phần tử vào một tập hợp

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

211 thêm

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

213, phải là một đối tượng bất biến duy nhất, vào

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

47

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

90

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

215

Loại bỏ một phần tử khỏi một tập hợp

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

215 xóa

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

213 khỏi

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

47. Python đưa ra một ngoại lệ nếu

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

213 không có trong

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

47

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

91

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

221

Loại bỏ một phần tử khỏi một tập hợp

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

221 cũng loại bỏ

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

213 khỏi

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

47. Tuy nhiên, nếu

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

213 không có trong

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

47, phương pháp này lặng lẽ không làm gì thay vì đưa ra một ngoại lệ

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

92

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

227

Xóa một phần tử ngẫu nhiên khỏi một tập hợp

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

227 xóa và trả về phần tử được chọn tùy ý từ

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

47. Nếu

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

47 trống,

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

227 sẽ đưa ra một ngoại lệ

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

93

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

232

Xóa một tập hợp

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

232 xóa tất cả các phần tử khỏi

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

47

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

94

Loại bỏ các quảng cáo

Bộ đông lạnh

Python cung cấp một loại dựng sẵn khác được gọi là Frozenset, về mọi mặt giống hệt như một tập hợp, ngoại trừ một điều là Frozenset là bất biến. Bạn có thể thực hiện các thao tác không sửa đổi trên một bộ đóng băng

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

95

Nhưng các phương pháp cố gắng sửa đổi một bộ đóng băng không thành công

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

96

Lặn sâu. Frozensets và Nhiệm vụ tăng cường
Vì một freezeset là bất biến, nên bạn có thể nghĩ rằng nó không thể là mục tiêu của toán tử gán tăng cường. Nhưng quan sát
>>>
>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}
97
Đưa cái gì?
Python không thực hiện các bài tập tăng cường trên các bộ đóng băng tại chỗ. Câu lệnh
>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}
235 có hiệu quả tương đương với
>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}
236. Nó không sửa đổi bản gốc
>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}
47. Nó đang gán lại
>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}
47 cho một đối tượng mới và đối tượng
>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}
47 được tham chiếu ban đầu đã biến mất
Bạn có thể xác minh điều này bằng hàm
>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}
240
>>>
>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}
98
>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}
241 có một mã định danh số nguyên khác sau phép gán tăng cường. Nó đã được gán lại, không sửa đổi tại chỗ
Một số đối tượng trong Python được sửa đổi tại chỗ khi chúng là mục tiêu của toán tử gán tăng cường. Nhưng Frozensets không

Frozensets rất hữu ích trong các trường hợp bạn muốn sử dụng một bộ, nhưng bạn cần một đối tượng không thể thay đổi. Ví dụ: bạn không thể xác định một tập hợp có các phần tử cũng là tập hợp, vì các phần tử của tập hợp phải không thay đổi

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

99

Nếu bạn thực sự cảm thấy bắt buộc phải xác định một tập hợp các tập hợp (này, điều đó có thể xảy ra), bạn có thể làm điều đó nếu các phần tử là tập hợp cố định, bởi vì chúng là bất biến

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

0

Tương tự như vậy, hãy nhớ lại hướng dẫn trước về từ điển rằng khóa từ điển phải là bất biến. Bạn không thể sử dụng loại bộ tích hợp làm khóa từ điển

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

1

Nếu bạn thấy mình cần sử dụng bộ làm khóa từ điển, bạn có thể sử dụng bộ đóng băng

>>>

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

2

Phần kết luận

Trong hướng dẫn này, bạn đã học cách định nghĩa các đối tượng tập hợp trong Python và bạn đã làm quen với các hàm, toán tử và phương thức có thể được sử dụng để làm việc với các tập hợp

Bây giờ bạn có thể cảm thấy thoải mái với các kiểu dữ liệu tích hợp cơ bản mà Python cung cấp

Tiếp theo, bạn sẽ bắt đầu khám phá cách mã hoạt động trên các đối tượng đó được tổ chức và cấu trúc trong chương trình Python

Lấy bài kiểm tra. Kiểm tra kiến thức của bạn với bài kiểm tra tương tác “Bộ Python” của chúng tôi. Sau khi hoàn thành, bạn sẽ nhận được điểm số để có thể theo dõi quá trình học tập của mình theo thời gian

Lấy bài kiểm tra "

« Từ điển trong Python

Cấu trúc từ vựng của chương trình Python »

Đánh dấu là đã hoàn thành

Xem ngay Hướng dẫn này có một khóa học video liên quan do nhóm Real Python tạo. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn. Bộ trong Python

🐍 Thủ thuật Python 💌

Nhận một Thủ thuật Python ngắn và hấp dẫn được gửi đến hộp thư đến của bạn vài ngày một lần. Không có thư rác bao giờ. Hủy đăng ký bất cứ lúc nào. Được quản lý bởi nhóm Real Python

Gửi cho tôi thủ thuật Python »

Giới thiệu về John Sturtz

John là một Pythonista cuồng nhiệt và là thành viên của nhóm hướng dẫn Real Python

» Thông tin thêm về John

Mỗi hướng dẫn tại Real Python được tạo bởi một nhóm các nhà phát triển để nó đáp ứng các tiêu chuẩn chất lượng cao của chúng tôi. Các thành viên trong nhóm đã làm việc trong hướng dẫn này là

David

Joanna

Bậc thầy Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng nghìn hướng dẫn, khóa học video thực hành và cộng đồng các Pythonista chuyên gia

Nâng cao kỹ năng Python của bạn »

Bậc thầy Kỹ năng Python trong thế giới thực
Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng Pythonistas chuyên gia

Nâng cao kỹ năng Python của bạn »

Bạn nghĩ sao?

Đánh giá bài viết này

Tweet Chia sẻ Chia sẻ Email

Bài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?

Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi

Danh sách này chứa ba loại dữ liệu Python nào?

Python có sáu Kiểu dữ liệu tiêu chuẩn. .

số

Chuỗi

Tuple

Từ điển

Điều nào sau đây là đặc điểm của danh sách Python?

Các đặc điểm quan trọng của danh sách Python như sau. Danh sách được sắp xếp . Danh sách có thể chứa bất kỳ đối tượng tùy ý nào. Các phần tử danh sách có thể được truy cập theo chỉ mục.

Làm cách nào để chuyển đổi mảng thành danh sách Python?

các đối tượng mảng có thể được chuyển đổi thành danh sách bằng hàm tolist() . Hàm tolist() không chấp nhận bất kỳ đối số nào. Nếu mảng là một chiều, một danh sách với các phần tử mảng được trả về. Đối với một mảng nhiều chiều, một danh sách lồng nhau được trả về.

Danh sách có giống với mảng trong Python không?

Danh sách được sử dụng để thu thập các mục thường bao gồm các phần tử thuộc nhiều loại dữ liệu. Mảng cũng là một thành phần quan trọng tập hợp nhiều mục có cùng kiểu dữ liệu . Danh sách không thể quản lý các hoạt động số học. Mảng có thể quản lý các phép tính số học.

programming python

Cặp biểu tượng nào bạn cần thực hiện danh sách con trong python

Xác định một tập hợp

Đặt kích thước và tư cách thành viên

Hoạt động trên một tập hợp

Toán tử vs. phương pháp

Các toán tử và phương thức khả dụng

Sửa đổi một Set

Phương thức và toán tử gán tăng cường

Các phương pháp khác để sửa đổi bộ

Bộ đông lạnh

Phần kết luận

Danh sách này chứa ba loại dữ liệu Python nào?

Điều nào sau đây là đặc điểm của danh sách Python?

Làm cách nào để chuyển đổi mảng thành danh sách Python?

Danh sách có giống với mảng trong Python không?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội