Hướng dẫn python popitem last=false - python popitem own = false

2

Mới! Lưu câu hỏi hoặc câu trả lời và sắp xếp nội dung yêu thích của bạn. Tìm hiểu thêm.
Learn more.

Mô -đun bộ sưu tập trong Python có một kiểu dữ liệu đặt hàng (), cho phép chúng tôi lưu các cặp giá trị chính theo cùng thứ tự như chúng được chèn vào Dict. Nó có một phương pháp popitem, cho phép chúng ta bật các vật phẩm ở đầu hoặc cuối cùng

dict.popitem(last = True)
dict.popitem(last = False)

Dict mặc định trong Python 3 cũng hoạt động như OrderedDict (), tức là, nó duy trì thứ tự của các cặp giá trị chính khi chúng được chèn. Nhưng làm thế nào để loại bỏ phần tử đầu tiên hoặc phần cuối cùng khỏi dict

for key, value in dict:
    dict.pop(key)
    break

Tôi chỉ muốn biết nếu có bất kỳ chức năng inbuild nào để bật phần tử đầu tiên hoặc phần tử cuối cùng theo chế độ mặc định của Python 3 như trong ORDEDDICT (). Tôi đã tìm kiếm nhưng không thể tìm thấy bất kỳ.

Hỏi ngày 25 tháng 5 năm 2021 lúc 7:13May 25, 2021 at 7:13

Hướng dẫn python popitem last=false - python popitem own = false

4

Kể từ Python 3.6,

d = {'a': 1, 'b': 2}
k = next(iter(d)) # k = 'a'
v = d.pop(k) # v = 1
7 luôn hoạt động như một Lifo như
d = {'a': 1, 'b': 2}
k = next(iter(d)) # k = 'a'
v = d.pop(k) # v = 1
8.

Nhưng mặc dù không có sự hỗ trợ trực tiếp nào từ

d = {'a': 1, 'b': 2}
k = next(iter(d)) # k = 'a'
v = d.pop(k) # v = 1
9 để tạo phương thức
>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting a position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
0 xuất phát từ phía trước của dict, bạn có thể mô phỏng hành vi FIFO của
>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting a position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
1 như:

d = OrderedDict(a=1, b=2)
k, v = d.popitem(last=False) # k = 'a', v = 1

Bằng cách nhận khóa đầu tiên của Dict và sau đó bật khóa đó cho giá trị của nó:

d = {'a': 1, 'b': 2}
k = next(iter(d)) # k = 'a'
v = d.pop(k) # v = 1

Đã trả lời ngày 26 tháng 5 năm 2021 lúc 7:11May 26, 2021 at 7:11

blhsingblhsingblhsing

82K6 Huy hiệu vàng63 Huy hiệu bạc94 Huy hiệu Đồng6 gold badges63 silver badges94 bronze badges

Chương này mô tả một số điều mà bạn đã học được về chi tiết hơn và thêm một số điều mới.

5.1. Thêm về Danh sáchMore on Lists¶

Kiểu dữ liệu danh sách có một số phương pháp khác. Dưới đây là tất cả các phương thức của các đối tượng danh sách:

________ 42 ________ 43 (x)(x)

Thêm một mục vào cuối danh sách. Tương đương với

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting a position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
4.

________ 42 ________ 46 (có thể lặp lại)(iterable)

Mở rộng danh sách bằng cách nối thêm tất cả các mục từ Itable. Tương đương với

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting a position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
7.

________ 42 ________ 49 (i, x)(i, x)

Chèn một mục tại một vị trí nhất định. Đối số đầu tiên là chỉ số của phần tử trước đó để chèn, do đó

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
0 chèn ở phía trước của danh sách và
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
1 tương đương với
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
2.

________ 42 ________ 54 (x)(x)

Xóa mục đầu tiên khỏi danh sách có giá trị bằng x. Nó tăng một

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
5 nếu không có mặt hàng như vậy.

________ 42 ________ 57 ([i])([i])

Loại bỏ mục tại vị trí đã cho trong danh sách và trả về nó. Nếu không có chỉ mục được chỉ định,

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
8 sẽ xóa và trả về mục cuối cùng trong danh sách. .

________ 42 ________ 60 ()()

Xóa tất cả các mục khỏi danh sách. Tương đương với

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
1.

________ 42 ________ 63 (x [, bắt đầu [, kết thúc]]))(x[, start[, end]])

Trả về chỉ mục dựa trên 0 trong danh sách mục đầu tiên có giá trị bằng x. Tăng

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
5 nếu không có mặt hàng như vậy.

Các đối số tùy chọn bắt đầu và kết thúc được giải thích là trong ký hiệu lát cắt và được sử dụng để giới hạn tìm kiếm ở một phần trăm cụ thể của danh sách. Chỉ số được trả về được tính toán liên quan đến đầu của chuỗi đầy đủ thay vì đối số bắt đầu.

________ 42 ________ 66 (x)(x)

Trả về số lần x xuất hiện trong danh sách.

________ 42 ________ 68 (*, key = none, lùi = sai)(*, key=None, reverse=False)

Sắp xếp các mục của danh sách tại chỗ (các đối số có thể được sử dụng để sắp xếp sắp xếp, xem

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
9 để giải thích của họ).

________ 42 ________ 71 ()()

Đảo ngược các yếu tố của danh sách tại chỗ.

________ 42 ________ 73 ()()

Trả lại một bản sao nông của danh sách. Tương đương với

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
4.

Một ví dụ sử dụng hầu hết các phương thức danh sách:

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting a position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'

Bạn có thể nhận thấy rằng các phương thức như

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
5,
>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
6 hoặc
>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
7 chỉ sửa đổi danh sách không có giá trị trả về được in - chúng trả lại
>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
8 mặc định. 1 Đây là một nguyên tắc thiết kế cho tất cả các cấu trúc dữ liệu có thể thay đổi trong Python.

Một điều khác bạn có thể nhận thấy là không phải tất cả dữ liệu có thể được sắp xếp hoặc so sánh. Chẳng hạn,

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
9 không sắp xếp vì các số nguyên có thể được so sánh với các chuỗi và không ai có thể so sánh với các loại khác. Ngoài ra, có một số loại don don có mối quan hệ đặt hàng xác định. Ví dụ,
squares = list(map(lambda x: x**2, range(10)))
0 không phải là một so sánh hợp lệ.

5.1.1. Sử dụng danh sách như Stacks¶Using Lists as Stacks¶

Các phương thức danh sách giúp việc sử dụng danh sách như một ngăn xếp rất dễ dàng, trong đó phần tử cuối cùng được thêm vào là phần tử đầu tiên được truy xuất (lần cuối cùng, lần đầu tiên, ra mắt). Để thêm một mục vào đầu ngăn xếp, hãy sử dụng

squares = list(map(lambda x: x**2, range(10)))
1. Để lấy một mục từ đầu ngăn xếp, hãy sử dụng
squares = list(map(lambda x: x**2, range(10)))
2 mà không có chỉ mục rõ ràng. Ví dụ:

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

5.1.2. Sử dụng danh sách như hàng đợiUsing Lists as Queues¶

Cũng có thể sử dụng một danh sách như một hàng đợi, trong đó phần tử đầu tiên được thêm vào là phần tử đầu tiên được truy xuất (từ đầu tiên, lần đầu tiên); Tuy nhiên, danh sách không hiệu quả cho mục đích này. Mặc dù các lần nối và bật từ cuối danh sách rất nhanh, nhưng việc chèn hoặc bật từ đầu danh sách là chậm (vì tất cả các yếu tố khác phải được thay đổi bởi một).

Để thực hiện hàng đợi, hãy sử dụng

squares = list(map(lambda x: x**2, range(10)))
3 được thiết kế để có sự thay đổi nhanh chóng và bật từ cả hai đầu. Ví dụ:

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

5.1.3. Danh sách toàn diệnList Comprehensions¶

Danh sách toàn diện cung cấp một cách ngắn gọn để tạo danh sách. Các ứng dụng phổ biến là tạo ra các danh sách mới trong đó mỗi yếu tố là kết quả của một số hoạt động được áp dụng cho từng thành viên của một chuỗi khác hoặc có thể lặp lại hoặc tạo ra một phần trăm của các yếu tố đáp ứng một điều kiện nhất định.

Ví dụ: giả sử chúng tôi muốn tạo một danh sách các ô vuông, như:

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Lưu ý rằng điều này tạo ra (hoặc ghi đè) một biến có tên

squares = list(map(lambda x: x**2, range(10)))
4 vẫn tồn tại sau khi vòng lặp hoàn thành. Chúng ta có thể tính toán danh sách các ô vuông mà không cần bất kỳ tác dụng phụ nào bằng cách sử dụng:

squares = list(map(lambda x: x**2, range(10)))

Hoặc, tương đương:

squares = [x**2 for x in range(10)]

đó là ngắn gọn và dễ đọc hơn.

Một danh sách hiểu bao gồm các dấu ngoặc chứa một biểu thức theo sau là mệnh đề

squares = list(map(lambda x: x**2, range(10)))
5, sau đó không hoặc nhiều hơn
squares = list(map(lambda x: x**2, range(10)))
5 hoặc
squares = list(map(lambda x: x**2, range(10)))
7. Kết quả sẽ là một danh sách mới do đánh giá biểu thức trong bối cảnh của các điều khoản
squares = list(map(lambda x: x**2, range(10)))
5 và
squares = list(map(lambda x: x**2, range(10)))
7 theo nó. Ví dụ, ListComp này kết hợp các yếu tố của hai danh sách nếu chúng không bằng nhau:

for key, value in dict:
    dict.pop(key)
    break
0

Và nó tương đương với:

for key, value in dict:
    dict.pop(key)
    break
1

Lưu ý cách thứ tự của các câu lệnh

squares = list(map(lambda x: x**2, range(10)))
5 và
squares = list(map(lambda x: x**2, range(10)))
7 giống nhau trong cả hai đoạn này.

Nếu biểu thức là một tuple (ví dụ:

squares = [x**2 for x in range(10)]
2 trong ví dụ trước), nó phải được đặt dấu ngoặc đơn.

for key, value in dict:
    dict.pop(key)
    break
2

Danh sách các hệ thống có thể chứa các biểu thức phức tạp và các hàm lồng nhau:

for key, value in dict:
    dict.pop(key)
    break
3

5.1.4. Danh sách lồng nhau toàn diệnNested List Comprehensions¶

Biểu thức ban đầu trong khả năng hiểu danh sách có thể là bất kỳ biểu thức tùy ý nào, bao gồm cả sự hiểu biết danh sách khác.

Hãy xem xét ví dụ sau đây của ma trận 3x4 được triển khai dưới dạng danh sách 3 danh sách độ dài 4:

for key, value in dict:
    dict.pop(key)
    break
4

Danh sách hiểu biết sau đây sẽ chuyển đổi các hàng và cột:

for key, value in dict:
    dict.pop(key)
    break
5

Như chúng ta đã thấy trong phần trước, ListComp lồng nhau được đánh giá trong bối cảnh của

squares = list(map(lambda x: x**2, range(10)))
5 theo sau, vì vậy ví dụ này tương đương với:

for key, value in dict:
    dict.pop(key)
    break
6

Điều này, đến lượt nó, giống như:

for key, value in dict:
    dict.pop(key)
    break
7

Trong thế giới thực, bạn nên thích các chức năng tích hợp hơn cho các câu lệnh dòng chảy phức tạp. Hàm

squares = [x**2 for x in range(10)]
4 sẽ làm rất tốt cho trường hợp sử dụng này:

for key, value in dict:
    dict.pop(key)
    break
8

Xem danh sách đối số giải nén để biết chi tiết về dấu hoa thị trong dòng này.Unpacking Argument Lists for details on the asterisk in this line.

5.2. Tuyên bố squares = [x**2 for x in range(10)] 5The squares = [x**2 for x in range(10)] 5 statement¶

Có một cách để xóa một mục khỏi danh sách được đưa ra chỉ mục của nó thay vì giá trị của nó: câu lệnh

squares = [x**2 for x in range(10)]
5. Điều này khác với phương thức
squares = list(map(lambda x: x**2, range(10)))
2 trả về giá trị. Tuyên bố
squares = [x**2 for x in range(10)]
5 cũng có thể được sử dụng để xóa các lát khỏi danh sách hoặc xóa toàn bộ danh sách (mà chúng tôi đã làm trước đó bằng cách gán một danh sách trống cho lát cắt). Ví dụ:

for key, value in dict:
    dict.pop(key)
    break
9

squares = [x**2 for x in range(10)]
5 cũng có thể được sử dụng để xóa toàn bộ biến:

Tham khảo tên

for key, value in dict:
    dict.pop(key)
    break
00 sau đây là một lỗi (ít nhất là cho đến khi một giá trị khác được gán cho nó). Chúng tôi sẽ tìm thấy các công dụng khác cho
squares = [x**2 for x in range(10)]
5 sau.

5.3. Tuples and Streak¶Tuples and Sequences¶

Chúng tôi đã thấy rằng các danh sách và chuỗi có nhiều thuộc tính chung, chẳng hạn như các hoạt động lập chỉ mục và cắt lát. Chúng là hai ví dụ về các loại dữ liệu chuỗi (xem các loại trình tự - danh sách, tuple, phạm vi). Vì Python là một ngôn ngữ phát triển, các loại dữ liệu trình tự khác có thể được thêm vào. Ngoài ra còn có một loại dữ liệu trình tự tiêu chuẩn khác: Tuple.Sequence Types — list, tuple, range). Since Python is an evolving language, other sequence data types may be added. There is also another standard sequence data type: the tuple.

Một tuple bao gồm một số giá trị được phân tách bằng dấu phẩy, ví dụ:

d = OrderedDict(a=1, b=2)
k, v = d.popitem(last=False) # k = 'a', v = 1
0

Như bạn thấy, trên các bộ dữ liệu đầu ra luôn được đặt trong ngoặc đơn, do đó các bộ dữ liệu lồng nhau được giải thích chính xác; Chúng có thể là đầu vào có hoặc không có dấu ngoặc đơn xung quanh, mặc dù dù sao cũng thường là dấu ngoặc đơn (nếu tuple là một phần của biểu thức lớn hơn). Không thể gán cho các mục riêng lẻ của một tuple, tuy nhiên có thể tạo các bộ dữ liệu có chứa các đối tượng có thể thay đổi, chẳng hạn như danh sách.

Mặc dù các bộ dữ liệu có vẻ giống với danh sách, nhưng chúng thường được sử dụng trong các tình huống khác nhau và cho các mục đích khác nhau. Các bộ dữ liệu là bất biến và thường chứa một chuỗi các yếu tố không đồng nhất được truy cập thông qua việc giải nén (xem sau trong phần này) hoặc lập chỉ mục (hoặc thậm chí bởi thuộc tính trong trường hợp

for key, value in dict:
    dict.pop(key)
    break
02). Danh sách có thể thay đổi, và các yếu tố của chúng thường đồng nhất và được truy cập bằng cách lặp lại trong danh sách.immutable, and usually contain a heterogeneous sequence of elements that are accessed via unpacking (see later in this section) or indexing (or even by attribute in the case of
for key, value in dict:
    dict.pop(key)
    break
02). Lists are mutable, and their elements are usually homogeneous and are accessed by iterating over the list.

Một vấn đề đặc biệt là việc xây dựng các bộ dữ liệu chứa 0 hoặc 1 mục: cú pháp có thêm một số quirks để phù hợp với những thứ này. Các bộ dữ liệu trống được xây dựng bởi một cặp dấu ngoặc đơn trống; Một tuple với một mục được xây dựng bằng cách làm theo giá trị bằng dấu phẩy (không đủ để gửi một giá trị duy nhất trong ngoặc đơn). Xấu xí, nhưng hiệu quả. Ví dụ:

d = OrderedDict(a=1, b=2)
k, v = d.popitem(last=False) # k = 'a', v = 1
1

Tuyên bố

for key, value in dict:
    dict.pop(key)
    break
03 là một ví dụ về đóng gói tple: các giá trị
for key, value in dict:
    dict.pop(key)
    break
04,
for key, value in dict:
    dict.pop(key)
    break
05 và
for key, value in dict:
    dict.pop(key)
    break
06 được đóng gói với nhau trong một tuple. Hoạt động ngược cũng có thể:

Điều này được gọi, đủ thích hợp, giải nén trình tự và hoạt động cho bất kỳ chuỗi nào ở phía bên phải. Trình tự giải nén yêu cầu có nhiều biến ở phía bên trái của dấu bằng như có các phần tử trong chuỗi. Lưu ý rằng nhiều bài tập thực sự chỉ là sự kết hợp của việc đóng gói và giải nén trình tự.

5.4. ĐặtSets¶

Python cũng bao gồm một loại dữ liệu cho các bộ. Một bộ là một bộ sưu tập không có thứ tự không có yếu tố trùng lặp. Sử dụng cơ bản bao gồm kiểm tra thành viên và loại bỏ các mục trùng lặp. Đặt các đối tượng cũng hỗ trợ các hoạt động toán học như liên minh, giao lộ, sự khác biệt và sự khác biệt đối xứng.

Niềng răng xoăn hoặc hàm

for key, value in dict:
    dict.pop(key)
    break
07 có thể được sử dụng để tạo các bộ. Lưu ý: Để tạo một bộ trống, bạn phải sử dụng
for key, value in dict:
    dict.pop(key)
    break
07, không phải
for key, value in dict:
    dict.pop(key)
    break
09; Cái sau tạo ra một từ điển trống, một cấu trúc dữ liệu mà chúng ta thảo luận trong phần tiếp theo.

Đây là một cuộc biểu tình ngắn gọn:

d = OrderedDict(a=1, b=2)
k, v = d.popitem(last=False) # k = 'a', v = 1
2

Tương tự như danh sách toàn diện, bộ toàn diện cũng được hỗ trợ:list comprehensions, set comprehensions are also supported:

d = OrderedDict(a=1, b=2)
k, v = d.popitem(last=False) # k = 'a', v = 1
3

5.5. Từ điển bàiDictionaries¶

Một loại dữ liệu hữu ích khác được tích hợp vào Python là từ điển (xem các loại ánh xạ - dict). Từ điển đôi khi được tìm thấy trong các ngôn ngữ khác như là ký ức liên kết của người Hồi giáo hoặc các mảng liên kết của người Hồi giáo. Không giống như các chuỗi, được lập chỉ mục bởi một loạt các số, từ điển được lập chỉ mục bởi các khóa, có thể là bất kỳ loại bất biến; Chuỗi và số luôn có thể là chìa khóa. Bộ dữ liệu có thể được sử dụng làm khóa nếu chúng chỉ chứa chuỗi, số hoặc bộ dữ liệu; Nếu một tuple chứa bất kỳ đối tượng có thể thay đổi trực tiếp hoặc gián tiếp, nó không thể được sử dụng làm khóa. Bạn có thể sử dụng danh sách làm khóa làm khóa, vì danh sách có thể được sửa đổi tại chỗ bằng cách sử dụng các bài tập chỉ mục, bài tập lát cắt hoặc các phương thức như

squares = list(map(lambda x: x**2, range(10)))
1 và
for key, value in dict:
    dict.pop(key)
    break
11.Mapping Types — dict). Dictionaries are sometimes found in other languages as “associative memories” or “associative arrays”. Unlike sequences, which are indexed by a range of numbers, dictionaries are indexed by keys, which can be any immutable type; strings and numbers can always be keys. Tuples can be used as keys if they contain only strings, numbers, or tuples; if a tuple contains any mutable object either directly or indirectly, it cannot be used as a key. You can’t use lists as keys, since lists can be modified in place using index assignments, slice assignments, or methods like
squares = list(map(lambda x: x**2, range(10)))
1 and
for key, value in dict:
    dict.pop(key)
    break
11.

Tốt nhất là nghĩ về một từ điển như một tập hợp các khóa: các cặp giá trị, với yêu cầu rằng các khóa là duy nhất (trong một từ điển). Một cặp niềng răng tạo ra một từ điển trống:

for key, value in dict:
    dict.pop(key)
    break
09. Đặt một danh sách phân tách bằng dấu phẩy: các cặp giá trị trong niềng răng thêm khóa ban đầu: các cặp giá trị vào từ điển; Đây cũng là cách từ điển được viết trên đầu ra.

Các hoạt động chính trên từ điển đang lưu trữ một giá trị với một số khóa và trích xuất giá trị được đưa ra khóa. Cũng có thể xóa một cặp khóa: giá trị với

squares = [x**2 for x in range(10)]
5. Nếu bạn lưu trữ bằng cách sử dụng một khóa đã được sử dụng, giá trị cũ được liên kết với khóa đó sẽ bị lãng quên. Đó là một lỗi để trích xuất một giá trị bằng cách sử dụng khóa không tồn tại.

Thực hiện

for key, value in dict:
    dict.pop(key)
    break
14 trên một từ điển trả về danh sách tất cả các khóa được sử dụng trong từ điển, theo thứ tự chèn (nếu bạn muốn nó được sắp xếp, chỉ cần sử dụng
for key, value in dict:
    dict.pop(key)
    break
15 thay thế). Để kiểm tra xem một khóa duy nhất có trong từ điển hay không, hãy sử dụng từ khóa
for key, value in dict:
    dict.pop(key)
    break
16.

Dưới đây là một ví dụ nhỏ bằng cách sử dụng từ điển:

d = OrderedDict(a=1, b=2)
k, v = d.popitem(last=False) # k = 'a', v = 1
4

Trình xây dựng

for key, value in dict:
    dict.pop(key)
    break
17 xây dựng từ điển trực tiếp từ các chuỗi của các cặp giá trị khóa:

d = OrderedDict(a=1, b=2)
k, v = d.popitem(last=False) # k = 'a', v = 1
5

Ngoài ra, các toàn bộ Dict có thể được sử dụng để tạo từ điển từ các biểu thức chính và giá trị tùy ý:

d = OrderedDict(a=1, b=2)
k, v = d.popitem(last=False) # k = 'a', v = 1
6

Khi các phím là các chuỗi đơn giản, đôi khi việc chỉ định các cặp bằng các đối số từ khóa sẽ dễ dàng hơn:

d = OrderedDict(a=1, b=2)
k, v = d.popitem(last=False) # k = 'a', v = 1
7

5.6. Kỹ thuật lặp lạiLooping Techniques¶

Khi lặp qua từ điển, khóa và giá trị tương ứng có thể được truy xuất cùng một lúc bằng phương pháp

for key, value in dict:
    dict.pop(key)
    break
18.

d = OrderedDict(a=1, b=2)
k, v = d.popitem(last=False) # k = 'a', v = 1
8

Khi lặp qua một chuỗi, chỉ số vị trí và giá trị tương ứng có thể được truy xuất cùng một lúc bằng cách sử dụng hàm

for key, value in dict:
    dict.pop(key)
    break
19.

d = OrderedDict(a=1, b=2)
k, v = d.popitem(last=False) # k = 'a', v = 1
9

Để lặp qua hai hoặc nhiều chuỗi cùng một lúc, các mục có thể được ghép nối với hàm

squares = [x**2 for x in range(10)]
4.

d = {'a': 1, 'b': 2}
k = next(iter(d)) # k = 'a'
v = d.pop(k) # v = 1
0

Để lặp qua một chuỗi ngược lại, trước tiên chỉ định chuỗi theo hướng chuyển tiếp và sau đó gọi hàm

for key, value in dict:
    dict.pop(key)
    break
21.

d = {'a': 1, 'b': 2}
k = next(iter(d)) # k = 'a'
v = d.pop(k) # v = 1
1

Để lặp qua một chuỗi theo thứ tự được sắp xếp, hãy sử dụng hàm

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
9 trả về một danh sách được sắp xếp mới trong khi để lại nguồn không thay đổi.

d = {'a': 1, 'b': 2}
k = next(iter(d)) # k = 'a'
v = d.pop(k) # v = 1
2

Sử dụng

for key, value in dict:
    dict.pop(key)
    break
07 trên một chuỗi loại bỏ các phần tử trùng lặp. Việc sử dụng
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
9 kết hợp với
for key, value in dict:
    dict.pop(key)
    break
07 qua một chuỗi là một cách thành ngữ để lặp qua các yếu tố duy nhất của chuỗi theo thứ tự được sắp xếp.

d = {'a': 1, 'b': 2}
k = next(iter(d)) # k = 'a'
v = d.pop(k) # v = 1
3

Đôi khi thật hấp dẫn khi thay đổi một danh sách trong khi bạn đang lặp lại nó; Tuy nhiên, thay vào đó, nó thường đơn giản và an toàn hơn để tạo một danh sách mới.

d = {'a': 1, 'b': 2}
k = next(iter(d)) # k = 'a'
v = d.pop(k) # v = 1
4

5.7. Thêm về điều kiện lorMore on Conditions¶

Các điều kiện được sử dụng trong các câu lệnh

for key, value in dict:
    dict.pop(key)
    break
26 và
squares = list(map(lambda x: x**2, range(10)))
7 có thể chứa bất kỳ toán tử nào, không chỉ so sánh.

Các toán tử so sánh

for key, value in dict:
    dict.pop(key)
    break
16 và
for key, value in dict:
    dict.pop(key)
    break
29 là các thử nghiệm thành viên xác định xem một giá trị có ở (hoặc không) trong một thùng chứa hay không. Các toán tử
for key, value in dict:
    dict.pop(key)
    break
30 và
for key, value in dict:
    dict.pop(key)
    break
31 so sánh xem hai đối tượng có thực sự là cùng một đối tượng hay không. Tất cả các toán tử so sánh có cùng mức độ ưu tiên, thấp hơn so với tất cả các toán tử số.

So sánh có thể được xích. Ví dụ:

for key, value in dict:
    dict.pop(key)
    break
32 kiểm tra xem
for key, value in dict:
    dict.pop(key)
    break
00 có nhỏ hơn
for key, value in dict:
    dict.pop(key)
    break
34 và hơn nữa
for key, value in dict:
    dict.pop(key)
    break
34 bằng
for key, value in dict:
    dict.pop(key)
    break
36.

So sánh có thể được kết hợp bằng cách sử dụng các toán tử boolean

for key, value in dict:
    dict.pop(key)
    break
37 và
for key, value in dict:
    dict.pop(key)
    break
38, và kết quả của một so sánh (hoặc của bất kỳ biểu thức boolean nào khác) có thể bị phủ định với
for key, value in dict:
    dict.pop(key)
    break
39. Chúng có các ưu tiên thấp hơn các nhà khai thác so sánh; Giữa họ,
for key, value in dict:
    dict.pop(key)
    break
39 có mức ưu tiên cao nhất và
for key, value in dict:
    dict.pop(key)
    break
38 thấp nhất, do đó
for key, value in dict:
    dict.pop(key)
    break
42 tương đương với
for key, value in dict:
    dict.pop(key)
    break
43. Như mọi khi, dấu ngoặc đơn có thể được sử dụng để thể hiện thành phần mong muốn.

Các toán tử Boolean

for key, value in dict:
    dict.pop(key)
    break
37 và
for key, value in dict:
    dict.pop(key)
    break
38 được gọi là toán tử ngắn mạch: đối số của họ được đánh giá từ trái sang phải và việc đánh giá dừng ngay khi kết quả được xác định. Ví dụ: nếu
for key, value in dict:
    dict.pop(key)
    break
46 và
for key, value in dict:
    dict.pop(key)
    break
47 là đúng nhưng
for key, value in dict:
    dict.pop(key)
    break
48 là sai,
for key, value in dict:
    dict.pop(key)
    break
49 không đánh giá biểu thức
for key, value in dict:
    dict.pop(key)
    break
47. Khi được sử dụng làm giá trị chung và không phải là boolean, giá trị trả về của toán tử ngắn mạch là đối số được đánh giá cuối cùng.

Có thể gán kết quả so sánh hoặc biểu thức boolean khác cho một biến. Ví dụ,

d = {'a': 1, 'b': 2}
k = next(iter(d)) # k = 'a'
v = d.pop(k) # v = 1
5

Lưu ý rằng trong Python, không giống như C, việc gán bên trong các biểu thức phải được thực hiện rõ ràng với toán tử Walrus

for key, value in dict:
    dict.pop(key)
    break
51. Điều này tránh được một nhóm vấn đề phổ biến gặp phải trong các chương trình C: gõ
for key, value in dict:
    dict.pop(key)
    break
52 vào biểu thức khi
for key, value in dict:
    dict.pop(key)
    break
53 được dự định.walrus operator
for key, value in dict:
    dict.pop(key)
    break
51. This avoids a common class of problems encountered in C programs: typing
for key, value in dict:
    dict.pop(key)
    break
52 in an expression when
for key, value in dict:
    dict.pop(key)
    break
53 was intended.

5,8. So sánh trình tự và các loại khácComparing Sequences and Other Types¶

Các đối tượng trình tự thường có thể được so sánh với các đối tượng khác có cùng loại trình tự. Việc so sánh sử dụng thứ tự từ vựng: đầu tiên hai mục đầu tiên được so sánh và nếu chúng khác nhau thì điều này sẽ xác định kết quả của so sánh; Nếu chúng bằng nhau, hai mục tiếp theo được so sánh, v.v., cho đến khi một trong hai chuỗi bị cạn kiệt. Nếu hai mục được so sánh là các chuỗi cùng loại, so sánh từ vựng được thực hiện đệ quy. Nếu tất cả các mục của hai chuỗi so sánh bằng nhau, các chuỗi được coi là bằng nhau. Nếu một chuỗi là một chuỗi con ban đầu của bảng khác, trình tự ngắn hơn là phần nhỏ hơn (nhỏ hơn). Đặt hàng từ vựng cho các chuỗi sử dụng số điểm mã Unicode để đặt hàng các ký tự riêng lẻ. Một số ví dụ về so sánh giữa các chuỗi cùng loại:

d = {'a': 1, 'b': 2}
k = next(iter(d)) # k = 'a'
v = d.pop(k) # v = 1
6

Lưu ý rằng việc so sánh các đối tượng thuộc các loại khác nhau với

for key, value in dict:
    dict.pop(key)
    break
54 hoặc
for key, value in dict:
    dict.pop(key)
    break
55 là hợp pháp với điều kiện là các đối tượng có các phương pháp so sánh phù hợp. Ví dụ, các loại số hỗn hợp được so sánh theo giá trị số của chúng, do đó 0 bằng 0,0, v.v. Nếu không, thay vì cung cấp một thứ tự tùy ý, trình thông dịch sẽ tăng ngoại lệ
for key, value in dict:
    dict.pop(key)
    break
56.

Chú thích

1

Các ngôn ngữ khác có thể trả về đối tượng đột biến, cho phép chuỗi phương thức, chẳng hạn như

for key, value in dict:
    dict.pop(key)
    break
57.