Python 2 mặc định

Mô-đun này triển khai các kiểu dữ liệu vùng chứa chuyên dụng cung cấp các lựa chọn thay thế cho các vùng chứa tích hợp sẵn cho mục đích chung của Python,

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
6,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
7,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
8 và
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
9

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
0

chức năng xuất xưởng để tạo các lớp con tuple với các trường được đặt tên

Mới trong phiên bản 2. 6

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
1

vùng chứa giống như danh sách với các phần bổ sung và bật lên nhanh chóng ở hai đầu

Mới trong phiên bản 2. 4

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
2

lớp con dict để đếm các đối tượng có thể băm

Mới trong phiên bản 2. 7

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
3

lớp con dict ghi nhớ các mục nhập đơn hàng đã được thêm vào

Mới trong phiên bản 2. 7

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
4

lớp con dict gọi hàm xuất xưởng để cung cấp các giá trị còn thiếu

Mới trong phiên bản 2. 5

Ngoài các lớp chứa cụ thể, mô-đun bộ sưu tập cung cấp các lớp cơ sở trừu tượng có thể được sử dụng để kiểm tra xem một lớp có cung cấp một lớp cụ thể hay không. .

8. 3. 1. ______42 đối tượng¶

Một công cụ truy cập được cung cấp để hỗ trợ kiểm đếm thuận tiện và nhanh chóng. Ví dụ

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
0

lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
7 ([ lặp lại hoặc ánh xạ ])

Một

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
2 là một phân lớp
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
6 để đếm các đối tượng có thể băm. Nó là một bộ sưu tập không có thứ tự trong đó các phần tử được lưu trữ dưới dạng khóa từ điển và số lượng của chúng được lưu trữ dưới dạng giá trị từ điển. Số lượng được phép là bất kỳ giá trị số nguyên nào kể cả số không hoặc số âm. Lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
2 tương tự như túi hoặc nhiều bộ trong các ngôn ngữ khác

Các phần tử được tính từ một lần lặp hoặc được khởi tạo từ một ánh xạ (hoặc bộ đếm) khác

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
6

Các đối tượng bộ đếm có giao diện từ điển ngoại trừ việc chúng trả về số 0 cho các mục bị thiếu thay vì tăng

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
71

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
8

Đặt số đếm thành 0 không xóa phần tử khỏi bộ đếm. Sử dụng

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
72 để loại bỏ nó hoàn toàn

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry

Mới trong phiên bản 2. 7

Các đối tượng truy cập hỗ trợ ba phương thức ngoài những phương thức có sẵn cho tất cả các từ điển

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
73 ()

Trả về một trình vòng lặp qua các phần tử lặp lại nhiều lần bằng số lượng của nó. Các phần tử được trả về theo thứ tự tùy ý. Nếu số đếm của một phần tử nhỏ hơn một, thì

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
74 sẽ bỏ qua nó

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
75 ([ n ])

Trả về danh sách n phần tử phổ biến nhất và số lượng của chúng từ phổ biến nhất đến ít nhất. Nếu n bị bỏ qua hoặc

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
76,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
77 trả về tất cả các phần tử trong bộ đếm. Các phần tử có số lượng bằng nhau được sắp xếp tùy ý

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
7

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
78 ([ lặp lại hoặc ánh xạ ])

Các phần tử được trừ khỏi một lần lặp hoặc từ một ánh xạ (hoặc bộ đếm) khác. Giống như

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
79 nhưng trừ số lượng thay vì thay thế chúng. Cả đầu vào và đầu ra có thể bằng 0 hoặc âm

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
0

Các phương thức từ điển thông thường có sẵn cho các đối tượng

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
2 ngoại trừ hai đối tượng hoạt động khác nhau đối với bộ đếm

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
01 ( có thể lặp lại )

Phương thức lớp này không được triển khai cho các đối tượng

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
2

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
03 ([ lặp lại hoặc ánh xạ ])

Các phần tử được tính từ một lần lặp hoặc phần bổ sung từ một ánh xạ (hoặc bộ đếm) khác. Giống như

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
79 nhưng thêm số lượng thay vì thay thế chúng. Ngoài ra, iterable dự kiến ​​là một chuỗi các phần tử, không phải là chuỗi các cặp
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
05

Các mẫu phổ biến để làm việc với các đối tượng

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
2

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
8

Một số phép toán được cung cấp để kết hợp các đối tượng

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
2 để tạo ra nhiều bộ (bộ đếm có số đếm lớn hơn 0). Phép cộng và phép trừ kết hợp các bộ đếm bằng cách cộng hoặc trừ số lượng các phần tử tương ứng. Giao lộ và liên kết trả lại số lượng tối thiểu và tối đa tương ứng. Mỗi hoạt động có thể chấp nhận đầu vào có số lượng đã ký, nhưng đầu ra sẽ loại trừ các kết quả có số lượng bằng 0 hoặc ít hơn

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
0

Ghi chú

Bộ đếm chủ yếu được thiết kế để hoạt động với các số nguyên dương để biểu thị số lượng đang chạy; . Để trợ giúp với các trường hợp sử dụng đó, phần này ghi lại các hạn chế về phạm vi và loại tối thiểu

  • Bản thân lớp

    >>> c = Counter(a=4, b=2, c=0, d=-2)
    >>> list(c.elements())
    ['a', 'a', 'a', 'a', 'b', 'b']
    
    2 là một lớp con từ điển không có giới hạn về khóa và giá trị của nó. Các giá trị được dự định là các số đại diện cho số lượng, nhưng bạn có thể lưu trữ bất kỳ thứ gì trong trường giá trị

  • Phương thức

    >>> c['sausage'] = 0                        # counter entry with a zero count
    >>> del c['sausage']                        # del actually removes the entry
    
    77 chỉ yêu cầu các giá trị có thể sắp xếp được

  • Đối với các hoạt động tại chỗ như

    >>> c['sausage'] = 0                        # counter entry with a zero count
    >>> del c['sausage']                        # del actually removes the entry
    
    80, loại giá trị chỉ cần hỗ trợ cộng và trừ. Vì vậy, phân số, số thực và số thập phân sẽ hoạt động và các giá trị âm được hỗ trợ. Điều này cũng đúng với
    >>> c['sausage'] = 0                        # counter entry with a zero count
    >>> del c['sausage']                        # del actually removes the entry
    
    81 và
    >>> c['sausage'] = 0                        # counter entry with a zero count
    >>> del c['sausage']                        # del actually removes the entry
    
    82 cho phép các giá trị âm và 0 cho cả đầu vào và đầu ra

  • Các phương thức multiset chỉ được thiết kế cho các trường hợp sử dụng có giá trị dương. Các đầu vào có thể âm hoặc bằng 0, nhưng chỉ các đầu ra có giá trị dương mới được tạo. Không có hạn chế về loại, nhưng loại giá trị cần hỗ trợ cộng, trừ và so sánh

  • Phương pháp

    >>> c['sausage'] = 0                        # counter entry with a zero count
    >>> del c['sausage']                        # del actually removes the entry
    
    74 yêu cầu số nguyên. Nó bỏ qua số không và số âm

Xem thêm

  • Lớp truy cập được điều chỉnh cho Python 2. 5 và một công thức Bag sớm cho Python 2. 4

  • Lớp túi trong Smalltalk

  • Mục nhập Wikipedia cho Multisets

  • Hướng dẫn multiset C++ với các ví dụ

  • Đối với các hoạt động toán học trên multisets và các trường hợp sử dụng của chúng, xem Knuth, Donald. Nghệ thuật lập trình máy tính Tập II, Phần 4. 6. 3, Bài tập 19

  • Để liệt kê tất cả các nhóm khác nhau có kích thước nhất định trên một tập hợp các phần tử nhất định, hãy xem

    >>> c['sausage'] = 0                        # counter entry with a zero count
    >>> del c['sausage']                        # del actually removes the entry
    
    84

    bản đồ (Bộ đếm, tổ hợp_with_replacement ('ABC', 2)) -> AA AB AC BB BC CC

8. 3. 2. ______41 đối tượng¶

lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
87 ([ có thể lặp lại [, maxlen]])

Trả về một đối tượng deque mới được khởi tạo từ trái sang phải (sử dụng

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
88) với dữ liệu từ iterable. Nếu iterable không được chỉ định, deque mới trống

Deques là sự khái quát hóa của ngăn xếp và hàng đợi (tên được phát âm là “bộ bài” và là viết tắt của “hàng đợi hai đầu”). Deques hỗ trợ nối thêm và bật hiệu quả bộ nhớ, an toàn cho luồng từ hai bên của deque với hiệu suất O(1) xấp xỉ như nhau theo cả hai hướng

Mặc dù các đối tượng

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
7 hỗ trợ các thao tác tương tự, nhưng chúng được tối ưu hóa cho các thao tác có độ dài cố định nhanh và phát sinh chi phí di chuyển bộ nhớ O(n) cho các thao tác
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
00 và
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
01 làm thay đổi cả kích thước và vị trí của biểu diễn dữ liệu cơ bản

Mới trong phiên bản 2. 4

Nếu maxlen không được chỉ định hoặc là

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
76, deques có thể phát triển đến độ dài tùy ý. Mặt khác, deque được giới hạn ở độ dài tối đa được chỉ định. Khi deque có độ dài giới hạn đầy, khi các mục mới được thêm vào, một số mục tương ứng sẽ bị loại bỏ ở đầu đối diện. Bounded length deques cung cấp chức năng tương tự như bộ lọc
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
03 trong Unix. Chúng cũng hữu ích để theo dõi các giao dịch và các nhóm dữ liệu khác chỉ quan tâm đến hoạt động gần đây nhất

Đã thay đổi trong phiên bản 2. 6. Đã thêm tham số maxlen.

Các đối tượng Deque hỗ trợ các phương thức sau

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
04 ( x )

Thêm x vào bên phải của deque

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
05 ( x )

Thêm x vào bên trái của deque

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
06 ()

Xóa tất cả các phần tử khỏi deque để lại nó có độ dài 0

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
07 ( x )

Đếm số phần tử deque bằng x

Mới trong phiên bản 2. 7

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
08 ( có thể lặp lại )

Mở rộng phía bên phải của deque bằng cách nối thêm các phần tử từ đối số có thể lặp lại

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
09 ( có thể lặp lại )

Mở rộng phía bên trái của deque bằng cách nối thêm các phần tử từ iterable. Lưu ý, chuỗi nối trái dẫn đến đảo ngược thứ tự các phần tử trong đối số có thể lặp lại

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
30 ()

Xóa và trả lại một phần tử từ phía bên phải của deque. Nếu không có phần tử nào, hãy tăng một

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
31

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
32 ()

Xóa và trả lại một phần tử từ phía bên trái của deque. Nếu không có phần tử nào, hãy tăng một

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
31

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
34 ( giá trị )

Xóa lần xuất hiện đầu tiên của giá trị. Nếu không tìm thấy, tăng một

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
35

Mới trong phiên bản 2. 5

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
36 ()

Đảo ngược các phần tử của deque tại chỗ và sau đó trả về

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
76

Mới trong phiên bản 2. 7

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
38 ( n=1 ) ¶Xoay deque n bước sang phải. Nếu n âm, xoay sang trái

Khi deque không trống, xoay một bước sang phải tương đương với ____639 và xoay một bước sang trái tương đương với ____1600

Các đối tượng Deque cũng cung cấp một thuộc tính chỉ đọc

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
601¶

Kích thước tối đa của deque hoặc

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
76 nếu không bị chặn

Mới trong phiên bản 2. 7

Ngoài những điều trên, deques hỗ trợ lặp, pickling,

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
603,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
604,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
605,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
606, kiểm tra tư cách thành viên với toán tử
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
607 và tham chiếu chỉ số dưới như
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
608. Truy cập được lập chỉ mục là O(1) ở cả hai đầu nhưng chậm lại thành O(n) ở giữa. Để truy cập ngẫu nhiên nhanh, hãy sử dụng danh sách thay thế

Ví dụ

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
3

8. 3. 2. 1. ______41 Công thức nấu ăn¶

Phần này cho thấy các cách tiếp cận khác nhau để làm việc với deques

Bounded length deques cung cấp chức năng tương tự như bộ lọc

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
03 trong Unix

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
60

Một cách tiếp cận khác để sử dụng deques là duy trì một chuỗi các phần tử được thêm gần đây bằng cách thêm vào bên phải và bật ra bên trái

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
61

Phương thức

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
611 cung cấp một cách để thực hiện cắt và xóa
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
1. Ví dụ: một triển khai Python thuần túy của
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
613 dựa trên phương thức
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
611 để định vị các phần tử sẽ được bật lên

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
62

Để thực hiện cắt lát

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
1, hãy sử dụng cách tiếp cận tương tự áp dụng
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
611 để đưa phần tử mục tiêu sang phía bên trái của deque. Xóa các mục cũ bằng
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
617, thêm các mục mới bằng
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
618, sau đó đảo ngược vòng quay. Với các biến thể nhỏ trong cách tiếp cận đó, thật dễ dàng thực hiện các thao tác ngăn xếp kiểu Forth, chẳng hạn như
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
619,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
620,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
621,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
622,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
623,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
624 và
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
625

8. 3. 3. ______44 đối tượng¶

lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
628 ([ default_factory [, ...]])

Trả về một đối tượng giống như từ điển mới.

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
4 là một lớp con của lớp
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
6 tích hợp. Nó ghi đè một phương thức và thêm một biến thể hiện có thể ghi. Các chức năng còn lại giống như đối với lớp
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
6 và không được ghi lại ở đây

Đối số đầu tiên cung cấp giá trị ban đầu cho thuộc tính

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
632; . Tất cả các đối số còn lại được xử lý giống như khi chúng được chuyển đến hàm tạo
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
6, bao gồm cả các đối số từ khóa

Mới trong phiên bản 2. 5

Các đối tượng

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
4 hỗ trợ phương thức sau ngoài các hoạt động tiêu chuẩn của
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
6

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
637 ( phím )

Nếu thuộc tính

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
632 là
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
76, điều này sẽ tạo ra một ngoại lệ
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
71 với khóa là đối số

Nếu

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
632 không phải là
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
76, thì nó được gọi mà không có đối số để cung cấp giá trị mặc định cho khóa đã cho, giá trị này được chèn vào từ điển cho khóa và được trả về

Nếu gọi

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
632 đưa ra một ngoại lệ, ngoại lệ này được truyền bá không thay đổi

Phương thức này được gọi bởi phương thức

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
644 của lớp
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
6 khi không tìm thấy khóa được yêu cầu;

Lưu ý rằng

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
647 không được gọi cho bất kỳ hoạt động nào ngoài
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
644. Điều này có nghĩa là, giống như các từ điển thông thường,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
649 sẽ trả về giá trị mặc định là
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
76 thay vì sử dụng
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
632

Các đối tượng

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
4 hỗ trợ biến đối tượng sau

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
653¶

Thuộc tính này được sử dụng bởi phương pháp

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
647;

8. 3. 3. 1. ______44 Ví dụ¶

Sử dụng

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
7 làm
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
632, thật dễ dàng để nhóm một chuỗi các cặp khóa-giá trị thành một danh sách từ điển

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
63

Khi mỗi khóa được tìm thấy lần đầu tiên, nó chưa có trong ánh xạ; . Thao tác

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
661 sau đó gắn giá trị vào danh sách mới. Khi gặp lại các phím, quá trình tra cứu sẽ diễn ra bình thường (trả về danh sách cho phím đó) và thao tác
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
661 sẽ thêm một giá trị khác vào danh sách. Kỹ thuật này đơn giản và nhanh hơn kỹ thuật tương đương sử dụng
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
663

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
64

Đặt

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
632 thành
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
665 làm cho
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
4 trở nên hữu ích khi đếm (như một cái túi hoặc nhiều bộ trong các ngôn ngữ khác)

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
65

Khi lần đầu tiên gặp một chữ cái, nó bị thiếu trong ánh xạ, vì vậy hàm

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
632 gọi
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
668 để cung cấp số lượng mặc định là 0. Sau đó, thao tác tăng dần sẽ tạo số lượng cho mỗi chữ cái

Hàm

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
668 luôn trả về 0 chỉ là trường hợp đặc biệt của hàm hằng. Một cách nhanh hơn và linh hoạt hơn để tạo các hàm hằng là sử dụng
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
670 có thể cung cấp bất kỳ giá trị hằng nào (không chỉ bằng 0)

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
66

Đặt

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
632 thành
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
8 làm cho
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
4 trở nên hữu ích để xây dựng từ điển các tập hợp

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
67

8. 3. 4. ______40 Hàm xuất xưởng cho các bộ có trường được đặt tên¶

Các bộ dữ liệu được đặt tên gán ý nghĩa cho từng vị trí trong một bộ dữ liệu và cho phép mã tự ghi lại, dễ đọc hơn. Chúng có thể được sử dụng ở bất cứ nơi nào sử dụng bộ dữ liệu thông thường và chúng thêm khả năng truy cập các trường theo tên thay vì chỉ mục vị trí

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
676 ( typename, field_names [ , verbose= ][, rename=False])

Trả về một lớp con tuple mới có tên typename. Lớp con mới được sử dụng để tạo các đối tượng giống như bộ dữ liệu có các trường có thể truy cập được bằng cách tra cứu thuộc tính cũng như có thể lập chỉ mục và có thể lặp lại. Các thể hiện của lớp con cũng có một chuỗi tài liệu hữu ích (với tên kiểu và tên_trường) và một phương thức

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
677 hữu ích liệt kê các nội dung của bộ theo định dạng
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
678

Tên trường là một chuỗi các chuỗi chẳng hạn như

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
679. Ngoài ra, field_names có thể là một chuỗi với mỗi tên trường được phân tách bằng khoảng trắng và/hoặc dấu phẩy, ví dụ:
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
680 hoặc
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
681

Bất kỳ mã định danh Python hợp lệ nào cũng có thể được sử dụng cho tên trường ngoại trừ tên bắt đầu bằng dấu gạch dưới. Số nhận dạng hợp lệ bao gồm các chữ cái, chữ số và dấu gạch dưới nhưng không bắt đầu bằng chữ số hoặc dấu gạch dưới và không thể là một

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
682 chẳng hạn như class, for, return, global, pass, print hoặc raise

Nếu đổi tên là đúng, tên trường không hợp lệ sẽ tự động được thay thế bằng tên vị trí. Ví dụ:

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
683 được chuyển đổi thành
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
684, loại bỏ từ khóa
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
685 và tên trường trùng lặp
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
686

Nếu verbose là đúng, định nghĩa lớp được in ngay trước khi được xây dựng

Các phiên bản bộ dữ liệu được đặt tên không có từ điển cho mỗi phiên bản, vì vậy chúng nhẹ và không yêu cầu nhiều bộ nhớ hơn các bộ dữ liệu thông thường

Mới trong phiên bản 2. 6

Đã thay đổi trong phiên bản 2. 7. đã thêm hỗ trợ đổi tên.

Ví dụ

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
68

Các bộ dữ liệu được đặt tên đặc biệt hữu ích để gán tên trường cho các bộ dữ liệu kết quả được trả về bởi các mô-đun

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
687 hoặc
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
688

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
69

Ngoài các phương thức kế thừa từ các bộ dữ liệu, các bộ dữ liệu được đặt tên hỗ trợ ba phương thức bổ sung và một thuộc tính. Để tránh xung đột với tên trường, tên phương thức và thuộc tính bắt đầu bằng dấu gạch dưới

classmethod
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
689
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
690 ( có thể lặp lại )

Phương thức lớp tạo một thể hiện mới từ một chuỗi hiện có hoặc có thể lặp lại

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
80

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
689
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
692 ()

Trả lại một

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
3 mới ánh xạ tên trường tới các giá trị tương ứng của chúng

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
81

Đã thay đổi trong phiên bản 2. 7. Trả về một

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
3 thay vì một
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
6 thông thường.

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
689
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
697 ( **kwargs ) ¶Trả về một phiên bản mới của bộ dữ liệu được đặt tên thay thế các trường đã chỉ định bằng các giá trị mới

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
82

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
689
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
699¶

Bộ chuỗi liệt kê tên trường. Hữu ích cho việc xem xét nội quan và để tạo các loại bộ dữ liệu được đặt tên mới từ các bộ dữ liệu được đặt tên hiện có

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
83

Để truy xuất một trường có tên được lưu trữ trong một chuỗi, hãy sử dụng hàm

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
800

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
84

Để chuyển đổi từ điển thành bộ có tên, hãy sử dụng toán tử sao đôi (như được mô tả trong Giải nén danh sách đối số ).

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
85

Vì một bộ có tên là một lớp Python thông thường, nên dễ dàng thêm hoặc thay đổi chức năng với một lớp con. Đây là cách thêm trường được tính toán và định dạng in có chiều rộng cố định

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
86

Lớp con được hiển thị ở trên đặt

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
801 thành một bộ trống. Điều này giúp giữ cho yêu cầu bộ nhớ ở mức thấp bằng cách ngăn việc tạo từ điển cá thể

Phân lớp không hữu ích để thêm các trường mới, được lưu trữ. Thay vào đó, chỉ cần tạo một loại bộ dữ liệu có tên mới từ thuộc tính

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
802

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
87

Giá trị mặc định có thể được triển khai bằng cách sử dụng

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
803 để tùy chỉnh phiên bản nguyên mẫu

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
88

Các hằng số được liệt kê có thể được triển khai với các bộ dữ liệu được đặt tên, nhưng sẽ đơn giản và hiệu quả hơn khi sử dụng một khai báo lớp đơn giản

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
89

Xem thêm

Công thức tuple được đặt tên được điều chỉnh cho Python 2. 4

8. 3. 5. ______43 đối tượng¶

Từ điển có thứ tự giống như từ điển thông thường nhưng chúng nhớ thứ tự các mục được chèn vào. Khi lặp lại một từ điển đã sắp xếp, các mục được trả về theo thứ tự các khóa của chúng được thêm vào lần đầu tiên

lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
806 ([ mục ])

Trả về một thể hiện của lớp con dict, hỗ trợ các phương thức

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
6 thông thường. OrderedDict là một lệnh ghi nhớ thứ tự các phím được chèn lần đầu tiên. Nếu một mục mới ghi đè lên một mục hiện có, vị trí chèn ban đầu sẽ không thay đổi. Xóa một mục nhập và chèn lại nó sẽ di chuyển nó đến cuối

Mới trong phiên bản 2. 7

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
808
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
809 ( last=True ) ¶Phương thức
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
810 cho từ điển có thứ tự trả về và xóa một cặp (khóa, giá trị). Các cặp được trả về theo thứ tự LIFO nếu giá trị cuối cùng là đúng hoặc thứ tự FIFO nếu sai

Ngoài các phương pháp ánh xạ thông thường, các từ điển có thứ tự cũng hỗ trợ phép lặp ngược bằng cách sử dụng

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
811

Các bài kiểm tra bình đẳng giữa các đối tượng

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
3 có thứ tự nhạy cảm và được triển khai như
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
813. Kiểm tra bình đẳng giữa các đối tượng
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
3 và các đối tượng
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
815 khác không phân biệt thứ tự như từ điển thông thường. Điều này cho phép các đối tượng
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
3 được thay thế ở bất kỳ nơi nào sử dụng từ điển thông thường

Hàm tạo

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
3 và phương thức
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
81 đều chấp nhận các đối số từ khóa, nhưng thứ tự của chúng bị mất do hàm của Python gọi các đối số từ khóa truyền vào ngữ nghĩa bằng cách sử dụng một từ điển không có thứ tự thông thường

Xem thêm

Công thức OrderedDict tương đương chạy trên Python 2. 4 hoặc muộn hơn

8. 3. 5. 1. ______43 Ví dụ và Công thức¶

Vì một từ điển được sắp xếp ghi nhớ thứ tự chèn của nó, nó có thể được sử dụng kết hợp với sắp xếp để tạo một từ điển được sắp xếp

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
0

Các từ điển được sắp xếp mới duy trì thứ tự sắp xếp của chúng khi các mục nhập bị xóa. Nhưng khi các khóa mới được thêm vào, các khóa sẽ được thêm vào cuối và sắp xếp không được duy trì

Cũng dễ dàng để tạo một biến thể từ điển theo thứ tự ghi nhớ thứ tự các phím được chèn lần cuối. Nếu một mục mới ghi đè lên một mục hiện có, vị trí chèn ban đầu sẽ được thay đổi và di chuyển đến cuối

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
1

Một từ điển có thứ tự có thể được kết hợp với lớp

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
2 để bộ đếm ghi nhớ các phần tử thứ tự được gặp lần đầu tiên

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
2

8. 3. 6. Các lớp cơ sở trừu tượng của bộ sưu tập¶

Mô-đun bộ sưu tập cung cấp ABC sau.

ABC

Kế thừa từ

phương pháp trừu tượng

Phương pháp Mixin

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
821

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
822

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
823

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
824

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
825

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
826

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
827

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
825

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
829

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
826

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
831

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
832

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
833

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
834

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
835

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
831,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
825,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
821

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
839,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
832

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
822,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
826,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
843,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
844 và
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
845

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
846

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
835

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
839,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
849,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
850,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
832,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
852

Kế thừa các phương pháp

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
835 và
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
854,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
855,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
856,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
857,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
858 và
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
859

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
860

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
831,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
825,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
821

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
822,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
826,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
832

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
867,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
868,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
869,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
870,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
871,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
872,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
873,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
874,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
875,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
876, và
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
877

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
878

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
860

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
822,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
826,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
832,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
883,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
884

Các phương thức kế thừa của

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
860 và
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
886,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
857,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
858, ________ 1889, ________ 1890, ________ 1891 và ________ 1892

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
815

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
831,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
825,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
821

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
839,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
826,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
832

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
822,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
01,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
02,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
03,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
04,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
869 và
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
870

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
07

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
815

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
839,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
849,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
850,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
826,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
832

Các phương thức kế thừa của

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
815 và
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
857,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
16,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
886,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
18 và
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
19

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
20

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
831

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
832

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
23

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
20,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
860

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
822,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
826

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
28

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
20,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
860

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
822,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
826

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
33

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
20

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
822,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
826

lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
38¶lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
40¶lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
42¶lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
44¶

ABC cho các lớp cung cấp các phương thức tương ứng

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
45,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
46,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
47 và
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
48

lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6____050¶

ABC cho các lớp cung cấp phương thức

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
51. Xem thêm định nghĩa về có thể lặp lại .

lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6____053¶

ABC cho các lớp cung cấp phương thức

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
51 và
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
55. Xem thêm định nghĩa của iterator .

lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
57¶lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
59¶

ABC cho trình tự chỉ đọc và có thể thay đổi .

lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
61¶lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
63¶

ABC cho các bộ chỉ đọc và có thể thay đổi

lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
65¶lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
67¶

ABC cho ánh xạ chỉ đọc và có thể thay đổi .

lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
69¶lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
71¶lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
73¶lớp
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
6
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
75¶

ABC để ánh xạ, mục, khóa và giá trị chế độ xem .

Các ABC này cho phép chúng tôi hỏi các lớp hoặc trường hợp nếu chúng cung cấp chức năng cụ thể, ví dụ:

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
3

Một số ABC cũng hữu ích như mixin giúp phát triển các lớp hỗ trợ API vùng chứa dễ dàng hơn. Ví dụ: để viết một lớp hỗ trợ API

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
860 đầy đủ, chỉ cần cung cấp ba phương thức trừu tượng cơ bản.
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
45,
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
51 và
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
47. ABC cung cấp các phương pháp còn lại như
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
80 và
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
81

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
4

Lưu ý khi sử dụng

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
860 và
>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry
878 làm mixin

  1. Vì một số hoạt động thiết lập tạo ra các tập hợp mới, các phương thức mixin mặc định cần một cách để tạo các phiên bản mới từ một lần lặp. Hàm tạo của lớp được giả sử có chữ ký ở dạng

    >>> c['sausage'] = 0                        # counter entry with a zero count
    >>> del c['sausage']                        # del actually removes the entry
    
    84. Giả định đó được đưa ra đối với một phương pháp phân lớp nội bộ có tên là
    >>> c['sausage'] = 0                        # counter entry with a zero count
    >>> del c['sausage']                        # del actually removes the entry
    
    85, phương pháp này gọi
    >>> c['sausage'] = 0                        # counter entry with a zero count
    >>> del c['sausage']                        # del actually removes the entry
    
    86 để tạo một tập hợp mới. Nếu mixin
    >>> c['sausage'] = 0                        # counter entry with a zero count
    >>> del c['sausage']                        # del actually removes the entry
    
    860 đang được sử dụng trong một lớp có chữ ký hàm tạo khác, bạn sẽ cần ghi đè lên
    >>> c['sausage'] = 0                        # counter entry with a zero count
    >>> del c['sausage']                        # del actually removes the entry
    
    85 bằng một phương thức lớp có thể tạo các thể hiện mới từ một đối số có thể lặp lại

  2. Để ghi đè các phép so sánh (có lẽ là về tốc độ, vì ngữ nghĩa đã được cố định), hãy xác định lại

    >>> c['sausage'] = 0                        # counter entry with a zero count
    >>> del c['sausage']                        # del actually removes the entry
    
    89 và
    >>> c['sausage'] = 0                        # counter entry with a zero count
    >>> del c['sausage']                        # del actually removes the entry
    
    90, sau đó các thao tác khác sẽ tự động thực hiện theo

  3. Mixin

    >>> c['sausage'] = 0                        # counter entry with a zero count
    >>> del c['sausage']                        # del actually removes the entry
    
    860 cung cấp phương thức
    >>> c['sausage'] = 0                        # counter entry with a zero count
    >>> del c['sausage']                        # del actually removes the entry
    
    92 để tính giá trị băm cho tập hợp; . Để thêm khả năng băm đã đặt bằng cách sử dụng mixin, hãy kế thừa từ cả
    >>> c['sausage'] = 0                        # counter entry with a zero count
    >>> del c['sausage']                        # del actually removes the entry
    
    94 và
    >>> c['sausage'] = 0                        # counter entry with a zero count
    >>> del c['sausage']                        # del actually removes the entry
    
    95, sau đó xác định
    >>> c['sausage'] = 0                        # counter entry with a zero count
    >>> del c['sausage']                        # del actually removes the entry
    
    96