Hướng dẫn how do you iterate over an object in python? - làm thế nào để bạn lặp lại một đối tượng trong python?

Giả sử bạn có một lớp học như

Show
>>> class Cls(object):
...     foo = 1
...     bar = 'hello'
...     def func(self):
...         return 'call me'
...
>>> obj = Cls()

Gọi

>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
3 trên đối tượng cung cấp cho bạn tất cả các thuộc tính của đối tượng đó, bao gồm các thuộc tính đặc biệt của Python. Mặc dù một số thuộc tính đối tượng có thể gọi được, chẳng hạn như các phương thức.

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']

Bạn luôn có thể lọc ra các phương thức đặc biệt bằng cách sử dụng danh sách hiểu.

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']

hoặc nếu bạn thích bản đồ/bộ lọc.

>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']

Nếu bạn muốn lọc các phương thức, bạn có thể sử dụng

>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
4 tích hợp làm kiểm tra.

>>> [a for a in dir(obj) if not a.startswith('__') and not callable(getattr(obj, a))]
['bar', 'foo']

Bạn cũng có thể kiểm tra sự khác biệt giữa lớp của bạn và đối tượng thể hiện của nó bằng cách sử dụng.

>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])

Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: Bài viết từ điển Python: Lời khuyên & thủ thuật nâng cao This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Python Dictionary Iteration: Advanced Tips & Tricks

Từ điển là một trong những cấu trúc dữ liệu quan trọng và hữu ích nhất trong Python. Họ có thể giúp bạn giải quyết nhiều vấn đề lập trình. Hướng dẫn này sẽ đưa bạn đi sâu vào cách lặp đi lặp lại thông qua một từ điển ở Python.

Đến cuối hướng dẫn này, bạn sẽ biết:

  • Từ điển là gì, cũng như một số tính năng chính và chi tiết triển khai của họ
  • Cách lặp lại thông qua một từ điển trong Python bằng cách sử dụng các công cụ cơ bản mà ngôn ngữ cung cấp
  • Loại nhiệm vụ trong thế giới thực nào bạn có thể thực hiện bằng cách lặp qua từ điển trong Python
  • Cách sử dụng một số kỹ thuật và chiến lược nâng cao hơn để lặp lại thông qua từ điển trong Python

Để biết thêm thông tin về từ điển, bạn có thể kiểm tra các tài nguyên sau:

  • Từ điển trong Python
  • Itertools trong Python 3, ví dụ
  • Tài liệu cho
    >>> set(dir(Cls)) - set(dir(object))
    set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
    
    5 và
    >>> set(dir(Cls)) - set(dir(object))
    set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
    
    6

Sẳn sàng? Đi nào!

Một vài từ về từ điển

Từ điển là một nền tảng của Python. Ngôn ngữ được xây dựng xung quanh từ điển. Các mô -đun, lớp, đối tượng,

>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
7,
>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
8: Tất cả đều là từ điển. Từ điển đã là trung tâm của Python ngay từ đầu.

Tài liệu chính thức của Python, định nghĩa một từ điển như sau:

Một mảng kết hợp, trong đó các khóa tùy ý được ánh xạ tới các giá trị. Các phím có thể là bất kỳ đối tượng nào với các phương thức

>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
9 và
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
0. (Nguồn)

Có một vài điểm cần ghi nhớ:

  1. Từ điển bản đồ các phím cho các giá trị và lưu trữ chúng trong một mảng hoặc bộ sưu tập.
  2. Các khóa phải thuộc loại băm, điều đó có nghĩa là chúng phải có giá trị băm không bao giờ thay đổi trong suốt vòng đời khóa.

Từ điển thường được sử dụng để giải quyết tất cả các loại vấn đề lập trình, vì vậy chúng là một phần cơ bản của bộ công cụ của bạn với tư cách là một nhà phát triển Python.

Không giống như các chuỗi, là các vòng lặp hỗ trợ truy cập phần tử bằng cách sử dụng các chỉ số số nguyên, từ điển được lập chỉ mục bởi các khóa.sequences, which are iterables that support element access using integer indices, dictionaries are indexed by keys.

Các khóa trong từ điển giống như

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
1, đây là một tập hợp các đối tượng có thể băm và độc đáo. Bởi vì các đối tượng cần phải được băm, các đối tượng có thể thay đổi có thể được sử dụng làm khóa từ điển.

Mặt khác, các giá trị có thể thuộc bất kỳ loại Python nào, cho dù chúng có thể băm hay không. Có nghĩa đen không có hạn chế cho các giá trị.

Trong Python 3.6 và hơn thế nữa, các khóa và giá trị của từ điển được lặp lại theo cùng một thứ tự mà chúng được tạo ra. Tuy nhiên, hành vi này có thể thay đổi trên các phiên bản Python khác nhau và nó phụ thuộc vào lịch sử từ điển của các phần chèn và xóa.

Trong Python 2.7, từ điển là các cấu trúc không có thứ tự. Thứ tự của các mặt hàng từ điển được tranh giành. Điều này có nghĩa là thứ tự của các mục là xác định và lặp lại. Hãy để xem một ví dụ:scrambled. This means that the order of the items is deterministic and repeatable. Let’s see an example:

>>>

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}

Nếu bạn rời khỏi thông dịch viên và mở một phiên tương tác mới sau đó, bạn sẽ nhận được cùng một đơn đặt hàng:

>>>

>>> # Python 2.7. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}

Nếu bạn rời khỏi thông dịch viên và mở một phiên tương tác mới sau đó, bạn sẽ nhận được cùng một đơn đặt hàng:

Nhìn kỹ hơn vào hai đầu ra này cho bạn thấy rằng thứ tự kết quả hoàn toàn giống nhau trong cả hai trường hợp. Đó là lý do tại sao bạn có thể nói rằng việc đặt hàng là xác định.randomized data structures. This means that every time you re-run the dictionary, you’ll get a different items order. Let’s take a look:

>>>

>>> # Python 3.5
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}

Nếu bạn rời khỏi thông dịch viên và mở một phiên tương tác mới sau đó, bạn sẽ nhận được cùng một đơn đặt hàng:

>>>

>>> # Python 3.5. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}

Nếu bạn rời khỏi thông dịch viên và mở một phiên tương tác mới sau đó, bạn sẽ nhận được cùng một đơn đặt hàng:

Nhìn kỹ hơn vào hai đầu ra này cho bạn thấy rằng thứ tự kết quả hoàn toàn giống nhau trong cả hai trường hợp. Đó là lý do tại sao bạn có thể nói rằng việc đặt hàng là xác định.ordered data structures, which means that they keep their elements in the same order in which they were introduced, as you can see here:

>>>

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
0

Nếu bạn rời khỏi thông dịch viên và mở một phiên tương tác mới sau đó, bạn sẽ nhận được cùng một đơn đặt hàng:

Nhìn kỹ hơn vào hai đầu ra này cho bạn thấy rằng thứ tự kết quả hoàn toàn giống nhau trong cả hai trường hợp. Đó là lý do tại sao bạn có thể nói rằng việc đặt hàng là xác định.

Cách lặp lại thông qua một từ điển trong Python: những điều cơ bản

Từ điển là một cấu trúc dữ liệu hữu ích và được sử dụng rộng rãi trong Python. Là một lập trình viên Python, bạn sẽ thường xuyên ở trong tình huống mà bạn sẽ cần lặp lại thông qua một từ điển trong Python, trong khi bạn thực hiện một số hành động trên các cặp giá trị khóa của nó.

Khi nói đến việc lặp lại thông qua một từ điển trong Python, ngôn ngữ cung cấp cho bạn một số công cụ tuyệt vời mà chúng tôi sẽ đề cập trong bài viết này.

Lặp lại qua các phím trực tiếp

Từ điển Python sườn là các đối tượng lập bản đồ. Điều này có nghĩa là họ thừa hưởng một số phương pháp đặc biệt, mà Python sử dụng nội bộ để thực hiện một số hoạt động. Các phương thức này được đặt tên bằng cách sử dụng quy ước đặt tên là thêm một dấu gạch dưới kép vào đầu và ở cuối tên phương thức.special methods, which Python uses internally to perform some operations. These methods are named using the naming convention of adding a double underscore at the beginning of and at the end of the method’s name.

Để trực quan hóa các phương thức và thuộc tính của bất kỳ đối tượng Python nào, bạn có thể sử dụng

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
2, đây là hàm tích hợp phục vụ mục đích đó. Nếu bạn chạy
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
2 với một từ điển trống làm đối số, thì bạn sẽ có thể xem tất cả các phương thức và thuộc tính mà từ điển thực hiện:

>>>

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
1

Nếu bạn xem xét kỹ hơn về đầu ra trước đó, bạn sẽ thấy

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
4. Đây là một phương pháp được gọi là khi cần lặp lại cho một thùng chứa và nó sẽ trả về một đối tượng lặp mới có thể lặp qua tất cả các đối tượng trong container.

Đối với ánh xạ (như từ điển),

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
5 nên lặp lại các khóa. Điều này có nghĩa là nếu bạn đặt một từ điển trực tiếp vào vòng lặp
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
6, Python sẽ tự động gọi
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
5 trên từ điển đó và bạn sẽ nhận được một trình lặp qua các khóa của nó:

>>>

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
2

Nếu bạn xem xét kỹ hơn về đầu ra trước đó, bạn sẽ thấy

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
4. Đây là một phương pháp được gọi là khi cần lặp lại cho một thùng chứa và nó sẽ trả về một đối tượng lặp mới có thể lặp qua tất cả các đối tượng trong container.

Đối với ánh xạ (như từ điển),

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
5 nên lặp lại các khóa. Điều này có nghĩa là nếu bạn đặt một từ điển trực tiếp vào vòng lặp
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
6, Python sẽ tự động gọi
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
5 trên từ điển đó và bạn sẽ nhận được một trình lặp qua các khóa của nó:

Python đủ thông minh để biết rằng

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
8 là một từ điển và nó thực hiện
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
5. Trong ví dụ này, Python gọi
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
5 tự động và điều này cho phép bạn lặp lại các khóa của
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
8.

>>>

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
3

Nếu bạn xem xét kỹ hơn về đầu ra trước đó, bạn sẽ thấy

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
4. Đây là một phương pháp được gọi là khi cần lặp lại cho một thùng chứa và nó sẽ trả về một đối tượng lặp mới có thể lặp qua tất cả các đối tượng trong container.

Đối với ánh xạ (như từ điển), >>> # Python 2.7 >>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'} >>> a_dict {'color': 'blue', 'pet': 'dog', 'fruit': 'apple'} >>> a_dict {'color': 'blue', 'pet': 'dog', 'fruit': 'apple'} 5 nên lặp lại các khóa. Điều này có nghĩa là nếu bạn đặt một từ điển trực tiếp vào vòng lặp >>> # Python 2.7 >>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'} >>> a_dict {'color': 'blue', 'pet': 'dog', 'fruit': 'apple'} >>> a_dict {'color': 'blue', 'pet': 'dog', 'fruit': 'apple'} 6, Python sẽ tự động gọi >>> # Python 2.7 >>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'} >>> a_dict {'color': 'blue', 'pet': 'dog', 'fruit': 'apple'} >>> a_dict {'color': 'blue', 'pet': 'dog', 'fruit': 'apple'} 5 trên từ điển đó và bạn sẽ nhận được một trình lặp qua các khóa của nó:

Python đủ thông minh để biết rằng

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
8 là một từ điển và nó thực hiện
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
5. Trong ví dụ này, Python gọi
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
5 tự động và điều này cho phép bạn lặp lại các khóa của
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
8.

>>>

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
4

Nếu bạn xem xét kỹ hơn về đầu ra trước đó, bạn sẽ thấy

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
4. Đây là một phương pháp được gọi là khi cần lặp lại cho một thùng chứa và nó sẽ trả về một đối tượng lặp mới có thể lặp qua tất cả các đối tượng trong container.

Đối với ánh xạ (như từ điển),

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
5 nên lặp lại các khóa. Điều này có nghĩa là nếu bạn đặt một từ điển trực tiếp vào vòng lặp
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
6, Python sẽ tự động gọi
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
5 trên từ điển đó và bạn sẽ nhận được một trình lặp qua các khóa của nó:

>>>

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
5

Nếu bạn xem xét kỹ hơn về đầu ra trước đó, bạn sẽ thấy

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
4. Đây là một phương pháp được gọi là khi cần lặp lại cho một thùng chứa và nó sẽ trả về một đối tượng lặp mới có thể lặp qua tất cả các đối tượng trong container.

Đối với ánh xạ (như từ điển),

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
5 nên lặp lại các khóa. Điều này có nghĩa là nếu bạn đặt một từ điển trực tiếp vào vòng lặp
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
6, Python sẽ tự động gọi
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
5 trên từ điển đó và bạn sẽ nhận được một trình lặp qua các khóa của nó:

>>>

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
6

Nếu bạn xem xét kỹ hơn về đầu ra trước đó, bạn sẽ thấy

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
4. Đây là một phương pháp được gọi là khi cần lặp lại cho một thùng chứa và nó sẽ trả về một đối tượng lặp mới có thể lặp qua tất cả các đối tượng trong container.

>>>

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
7

Nếu bạn xem xét kỹ hơn về đầu ra trước đó, bạn sẽ thấy

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
4. Đây là một phương pháp được gọi là khi cần lặp lại cho một thùng chứa và nó sẽ trả về một đối tượng lặp mới có thể lặp qua tất cả các đối tượng trong container.

Đối với ánh xạ (như từ điển), >>> # Python 2.7 >>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'} >>> a_dict {'color': 'blue', 'pet': 'dog', 'fruit': 'apple'} >>> a_dict {'color': 'blue', 'pet': 'dog', 'fruit': 'apple'} 5 nên lặp lại các khóa. Điều này có nghĩa là nếu bạn đặt một từ điển trực tiếp vào vòng lặp >>> # Python 2.7 >>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'} >>> a_dict {'color': 'blue', 'pet': 'dog', 'fruit': 'apple'} >>> a_dict {'color': 'blue', 'pet': 'dog', 'fruit': 'apple'} 6, Python sẽ tự động gọi >>> # Python 2.7 >>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'} >>> a_dict {'color': 'blue', 'pet': 'dog', 'fruit': 'apple'} >>> a_dict {'color': 'blue', 'pet': 'dog', 'fruit': 'apple'} 5 trên từ điển đó và bạn sẽ nhận được một trình lặp qua các khóa của nó:

Python đủ thông minh để biết rằng

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
8 là một từ điển và nó thực hiện
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
5. Trong ví dụ này, Python gọi
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
5 tự động và điều này cho phép bạn lặp lại các khóa của
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
8.

>>>

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
8

Nếu bạn xem xét kỹ hơn về đầu ra trước đó, bạn sẽ thấy

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
4. Đây là một phương pháp được gọi là khi cần lặp lại cho một thùng chứa và nó sẽ trả về một đối tượng lặp mới có thể lặp qua tất cả các đối tượng trong container.

Đối với ánh xạ (như từ điển),

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
5 nên lặp lại các khóa. Điều này có nghĩa là nếu bạn đặt một từ điển trực tiếp vào vòng lặp
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
6, Python sẽ tự động gọi
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
5 trên từ điển đó và bạn sẽ nhận được một trình lặp qua các khóa của nó:

>>>

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
9

Khi bạn gọi

>>> # Python 3.5. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}
0 trên
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
8, bạn sẽ có một cái nhìn về các phím. Python biết rằng các đối tượng xem là lặp đi lặp lại, vì vậy nó bắt đầu lặp và bạn có thể xử lý các khóa của
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
8.

Mặt khác, sử dụng cùng một thủ thuật mà bạn đã thấy trước đây (toán tử lập chỉ mục

>>> # Python 2.7. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
3), bạn có thể có quyền truy cập vào các giá trị của từ điển:

>>>

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
0

Bằng cách này, bạn đã nhận được quyền truy cập vào các khóa (

>>> # Python 2.7. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
4) và các giá trị (
>>> # Python 2.7. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
5) của
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
8 cùng một lúc và bạn sẽ có thể thực hiện bất kỳ hành động nào đối với chúng.

Lặp qua >>> dir(obj) ['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func'] 05

Nó cũng phổ biến chỉ sử dụng các giá trị để lặp lại thông qua từ điển trong Python. Một cách để làm điều đó là sử dụng

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
05, trả về chế độ xem với các giá trị của từ điển:

>>>

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
1

Trong mã trước,

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
07 giữ tham chiếu đến đối tượng xem chứa các giá trị của
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
8.

Như bất kỳ đối tượng xem nào, đối tượng được trả về bởi

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
05 cũng có thể được lặp lại. Trong trường hợp này,
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
05 mang lại các giá trị của
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
8:

>>>

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
2

Sử dụng

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
05, bạn sẽ chỉ nhận được quyền truy cập vào các giá trị của
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
8, mà không xử lý các khóa.

Điều đáng chú ý là họ cũng hỗ trợ các bài kiểm tra thành viên (

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
14), đây là một tính năng quan trọng nếu bạn đang cố gắng biết liệu một yếu tố cụ thể có nằm trong từ điển hay không:

>>>

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
3

Thử nghiệm thành viên sử dụng

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
14 trả về
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
16 nếu khóa (hoặc giá trị hoặc mục) có mặt trong từ điển mà bạn đang kiểm tra và trả về
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
17. Bài kiểm tra thành viên cho phép bạn không lặp lại thông qua từ điển trong Python nếu bạn chỉ muốn biết liệu một số khóa (hoặc giá trị hoặc mục) nhất định có xuất hiện trong từ điển hay không.

Sửa đổi các giá trị và khóa

Nó có thể khá phổ biến để cần sửa đổi các giá trị và khóa khi bạn lặp đi lặp lại thông qua một từ điển trong Python. Có một số điểm bạn sẽ cần phải tính đến để hoàn thành nhiệm vụ này.

Ví dụ, các giá trị có thể được sửa đổi bất cứ khi nào bạn cần, nhưng bạn sẽ cần sử dụng từ điển gốc và khóa ánh xạ giá trị bạn muốn sửa đổi:

>>>

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
4

Trong ví dụ mã trước, để sửa đổi các giá trị của

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
18 và áp dụng giảm giá 10%, bạn đã sử dụng biểu thức
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
19.

Vậy tại sao bạn phải sử dụng từ điển ban đầu nếu bạn có quyền truy cập vào khóa của nó (

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
20) và các giá trị của nó (
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
21)? Bạn có nên sửa đổi chúng trực tiếp không?

Vấn đề thực sự là

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
20 và
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
21 thay đổi aren được phản ánh trong từ điển ban đầu. Đó là, nếu bạn sửa đổi bất kỳ trong số chúng (
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
20 hoặc
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
21) trực tiếp bên trong vòng lặp, thì điều thực sự xảy ra là bạn sẽ mất tham chiếu đến thành phần từ điển có liên quan mà không thay đổi bất cứ điều gì trong từ điển.

Mặt khác, các phím có thể được thêm hoặc xóa khỏi từ điển bằng cách chuyển đổi chế độ xem được trả về bởi

>>> # Python 3.5. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}
0 thành đối tượng
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
27:

>>>

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
5

Cách tiếp cận này có thể có một số ý nghĩa hiệu suất, chủ yếu liên quan đến tiêu thụ bộ nhớ. Ví dụ: thay vì đối tượng xem mang lại các yếu tố theo yêu cầu, bạn sẽ có một

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
27 hoàn toàn mới trong bộ nhớ hệ thống của bạn. Tuy nhiên, đây có thể là một cách an toàn để sửa đổi các khóa trong khi bạn lặp lại thông qua một từ điển trong Python.

Cuối cùng, nếu bạn cố gắng xóa một khóa từ

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
18 bằng cách sử dụng trực tiếp
>>> # Python 3.5. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}
0, thì Python sẽ tăng
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
31 cho bạn biết rằng kích thước từ điển đã thay đổi trong quá trình lặp lại:

>>>

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
6

Điều này là do

>>> # Python 3.5. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}
0 trả về một đối tượng từ điển, mang lại các khóa theo yêu cầu một lần và nếu bạn xóa một mục (
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
33), thì Python tăng
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
31, vì bạn đã sửa đổi từ điển trong quá trình lặp.

Ví dụ trong thế giới thực

Cho đến nay, bạn đã nhìn thấy những cách lặp đi lặp lại cơ bản hơn thông qua một từ điển trong Python. Bây giờ, thời gian để xem làm thế nào bạn có thể thực hiện một số hành động với các mục của từ điển trong quá trình lặp. Hãy cùng nhìn vào một số ví dụ trong thế giới thực.

Biến các phím thành các giá trị và ngược lại

Giả sử bạn có một từ điển và vì một số lý do cần phải biến các khóa thành các giá trị và ngược lại. Trong tình huống này, bạn có thể sử dụng vòng lặp

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
6 để lặp qua từ điển và xây dựng từ điển mới bằng cách sử dụng các khóa làm giá trị và ngược lại:

>>>

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
7

Biểu thức

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
36 đã làm tất cả công việc cho bạn bằng cách biến các khóa thành các giá trị và sử dụng các giá trị làm khóa. Để mã này hoạt động, dữ liệu được lưu trữ trong các giá trị ban đầu phải thuộc loại dữ liệu có thể băm.

Lọc các mục

Đôi khi, bạn sẽ ở trong các tình huống mà bạn có một từ điển và bạn muốn tạo một từ mới để chỉ lưu trữ dữ liệu thỏa mãn một điều kiện nhất định. Bạn có thể làm điều này với câu lệnh

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
37 bên trong vòng lặp
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
6 như sau:

>>>

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
8

Trong ví dụ này, bạn đã lọc ra các mục có giá trị lớn hơn

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
39. Bây giờ
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
40 chỉ chứa các mục đáp ứng điều kiện
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
41. Đây là một giải pháp khả thi cho loại vấn đề này. Sau đó, bạn sẽ thấy một cách pythonic và dễ đọc hơn để có được kết quả tương tự.

Làm một số tính toán

Nó cũng phổ biến cần phải thực hiện một số tính toán trong khi bạn lặp lại thông qua một từ điển trong Python. Giả sử bạn đã lưu trữ dữ liệu cho doanh số của công ty bạn trong một từ điển và bây giờ bạn muốn biết tổng thu nhập của năm.

Để giải quyết vấn đề này, bạn có thể xác định một biến có giá trị ban đầu là 0. Sau đó, bạn có thể tích lũy mọi giá trị của từ điển trong biến đó:

>>>

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
9

Ở đây, bạn đã lặp lại thông qua

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
42 và tích lũy tuần tự các giá trị của nó trong
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
43 như bạn muốn làm. Biểu thức
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
44 thực hiện phép thuật và ở cuối vòng lặp, bạn sẽ nhận được tổng thu nhập của năm. Lưu ý rằng
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
44 tương đương với
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
46.

Sử dụng sự hiểu biết

Sự hiểu biết từ điển là một cách nhỏ gọn để xử lý tất cả hoặc một phần của các yếu tố trong một bộ sưu tập và trả về một từ điển làm kết quả. Trái ngược với các toàn bộ danh sách, họ cần hai biểu thức được phân tách bằng một dấu hai chấm sau đó là các điều khoản

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
6 và
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
37 (tùy chọn). Khi một sự hiểu biết từ điển được chạy, các cặp giá trị khóa kết quả được chèn vào một từ điển mới theo cùng một thứ tự mà chúng được sản xuất.dictionary comprehension is a compact way to process all or part of the elements in a collection and return a dictionary as a results. In contrast to list comprehensions, they need two expressions separated with a colon followed by
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
6 and
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
37 (optional) clauses. When a dictionary comprehension is run, the resulting key-value pairs are inserted into a new dictionary in the same order in which they were produced.

Giả sử, ví dụ, bạn có hai danh sách dữ liệu và bạn cần tạo một từ điển mới từ họ. Trong trường hợp này, bạn có thể sử dụng Python từ

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
49 để lặp qua các yếu tố của cả hai danh sách trong các cặp:

>>>

>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
0

Ở đây,

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
50 nhận được hai lần lặp (
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
51 và
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
52) làm đối số và tạo ra một trình lặp lại tập hợp các phần tử từ mỗi phần mềm. Các đối tượng
>>> # Python 3.5
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
3 được tạo bởi
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
50 sau đó được giải nén vào
>>> # Python 2.7. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
4 và
>>> # Python 3.5
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
6, cuối cùng được sử dụng để tạo từ điển mới.

Sự hiểu biết từ điển mở ra một loạt các khả năng mới và cung cấp cho bạn một công cụ tuyệt vời để lặp lại thông qua một từ điển trong Python.

Biến các phím thành các giá trị và ngược lại: Xem lại

Nếu bạn có cái nhìn khác về vấn đề biến các khóa thành các giá trị và ngược lại, bạn sẽ thấy rằng bạn có thể viết một giải pháp hiệu quả và hiệu quả hơn bằng cách sử dụng khả năng hiểu từ điển:

>>>

>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
1

Với sự hiểu biết từ điển này, bạn đã tạo ra một từ điển hoàn toàn mới trong đó các khóa đã thay thế các giá trị và ngược lại. Cách tiếp cận mới này đã cho bạn khả năng viết mã dễ đọc, cô đọng, hiệu quả và pythonic dễ đọc hơn.

Điều kiện để mã này hoạt động là cùng một loại bạn đã thấy trước đây: các giá trị phải là các đối tượng có thể băm. Nếu không, bạn đã thắng được có thể sử dụng chúng làm phím cho

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
40.

Lọc các mục: Xem lại

Để lọc các mục trong từ điển với sự hiểu biết, bạn chỉ cần thêm một mệnh đề

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
37 xác định điều kiện bạn muốn đáp ứng. Trong ví dụ trước mà bạn đã lọc từ điển, điều kiện đó là
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
59. Với điều khoản
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
37 này được thêm vào cuối từ điển hiểu, bạn sẽ lọc ra các mục có giá trị lớn hơn
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
39. Hãy để một cái nhìn:

>>>

>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
2

Bây giờ

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
40 chỉ chứa các mục đáp ứng tình trạng của bạn. So với các giải pháp trước đó, cái này là Pythonic và hiệu quả hơn.

Thực hiện một số tính toán: Xem lại

Bạn có nhớ ví dụ với doanh số bán hàng của công ty không? Nếu bạn sử dụng danh sách hiểu được lặp lại thông qua các giá trị từ điển, thì bạn sẽ nhận được mã nhỏ gọn, nhanh và Pythonic hơn:

>>>

>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
3

Độ hiểu hiểu danh sách đã tạo ra một đối tượng

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
27 chứa các giá trị của
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
42, và sau đó bạn đã tổng hợp tất cả chúng bằng cách sử dụng
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
65 và lưu trữ kết quả trong
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
43.

Nếu bạn làm việc với một từ điển thực sự lớn và việc sử dụng bộ nhớ là một vấn đề đối với bạn, thì bạn có thể sử dụng biểu thức máy phát thay vì hiểu danh sách. Biểu thức của trình tạo là một biểu thức trả về một trình lặp. Nó trông giống như một sự hiểu biết danh sách, nhưng thay vì dấu ngoặc, bạn cần sử dụng dấu ngoặc đơn để xác định nó:generator expression is an expression that returns an iterator. It looks like a list comprehension, but instead of brackets you need to use parentheses to define it:

>>>

>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
4

Nếu bạn thay đổi dấu ngoặc vuông cho một cặp dấu ngoặc đơn (dấu ngoặc đơn của

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
65 tại đây), bạn sẽ biến danh sách hiểu thành biểu thức của trình tạo và mã của bạn sẽ hiệu quả bộ nhớ, bởi vì các biểu thức tạo mang lại các phần tử theo yêu cầu. Thay vì tạo và lưu trữ toàn bộ danh sách trong bộ nhớ, bạn sẽ chỉ phải lưu trữ một yếu tố tại một thời điểm.

Cuối cùng, có một cách đơn giản hơn để giải quyết vấn đề này bằng cách sử dụng trực tiếp

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
68 làm đối số với
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
65:

>>>

>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
5

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
65 nhận được một cuộc đối số có thể lặp lại và trả về tổng số phần tử của nó. Ở đây,
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
68 đóng vai trò của những người được chuyển sang
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
65. Kết quả là tổng thu nhập bạn đang tìm kiếm.

Loại bỏ các mặt hàng cụ thể

Bây giờ, giả sử bạn có một từ điển và cần phải tạo một cái mới với các khóa được chọn bị xóa. Hãy nhớ làm thế nào các đối tượng xem khóa giống như các bộ? Chà, những điểm tương đồng này vượt xa chỉ là bộ sưu tập các đối tượng có thể băm và độc đáo. Các đối tượng xem khóa cũng hỗ trợ các hoạt động chung

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
1. Hãy để xem cách bạn có thể tận dụng điều này để loại bỏ các mục cụ thể trong từ điển:

>>>

>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
6

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
65 nhận được một cuộc đối số có thể lặp lại và trả về tổng số phần tử của nó. Ở đây,
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
68 đóng vai trò của những người được chuyển sang
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
65. Kết quả là tổng thu nhập bạn đang tìm kiếm.

Loại bỏ các mặt hàng cụ thể

Bây giờ, giả sử bạn có một từ điển và cần phải tạo một cái mới với các khóa được chọn bị xóa. Hãy nhớ làm thế nào các đối tượng xem khóa giống như các bộ? Chà, những điểm tương đồng này vượt xa chỉ là bộ sưu tập các đối tượng có thể băm và độc đáo. Các đối tượng xem khóa cũng hỗ trợ các hoạt động chung

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
1. Hãy để xem cách bạn có thể tận dụng điều này để loại bỏ các mục cụ thể trong từ điển:

>>>

>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
7

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
65 nhận được một cuộc đối số có thể lặp lại và trả về tổng số phần tử của nó. Ở đây,
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
68 đóng vai trò của những người được chuyển sang
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
65. Kết quả là tổng thu nhập bạn đang tìm kiếm.

Loại bỏ các mặt hàng cụ thể

Bây giờ, giả sử bạn có một từ điển và cần phải tạo một cái mới với các khóa được chọn bị xóa. Hãy nhớ làm thế nào các đối tượng xem khóa giống như các bộ? Chà, những điểm tương đồng này vượt xa chỉ là bộ sưu tập các đối tượng có thể băm và độc đáo. Các đối tượng xem khóa cũng hỗ trợ các hoạt động chung >>> # Python 2.7 >>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'} >>> a_dict {'color': 'blue', 'pet': 'dog', 'fruit': 'apple'} >>> a_dict {'color': 'blue', 'pet': 'dog', 'fruit': 'apple'} 1. Hãy để xem cách bạn có thể tận dụng điều này để loại bỏ các mục cụ thể trong từ điển:

Mã này hoạt động vì các đối tượng quan điểm khóa hỗ trợ các hoạt động

>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
1 như các công đoàn, giao lộ và sự khác biệt. Khi bạn đã viết
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
75 bên trong sự hiểu biết từ điển, bạn thực sự đã thực hiện một hoạt động khác biệt
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
1. Nếu bạn cần thực hiện bất kỳ hoạt động
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
1 nào với các khóa của từ điển, thì bạn chỉ có thể sử dụng đối tượng xem khóa trực tiếp mà không cần chuyển đổi nó thành
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
1. Đây là một tính năng ít được biết đến của các đối tượng xem khóa có thể hữu ích trong một số tình huống.

Sắp xếp một từ điển

Nó thường cần thiết để sắp xếp các yếu tố của một bộ sưu tập. Vì Python 3.6, từ điển được đặt hàng các cấu trúc dữ liệu, vì vậy nếu bạn sử dụng Python 3.6 (và hơn thế nữa), bạn sẽ có thể sắp xếp các mục của bất kỳ từ điển nào bằng cách sử dụng >>> dir(obj) ['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func'] 79 và với sự trợ giúp của sự hiểu biết từ điển:

Mã này cho phép bạn tạo một từ điển mới với các khóa của nó theo thứ tự được sắp xếp. Điều này là có thể bởi vì

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
80 trả về một danh sách các khóa được sắp xếp mà bạn có thể sử dụng để tạo từ điển mới
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
81.

>>>

>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
8

Để biết thêm thông tin về cách tinh chỉnh sắp xếp của bạn, hãy xem sắp xếp từ điển Python: giá trị, khóa, v.v.

Lặp lại theo thứ tự sắp xếp

Đôi khi bạn có thể cần lặp lại thông qua một từ điển trong Python nhưng muốn làm điều đó theo thứ tự được sắp xếp. Điều này có thể đạt được bằng cách sử dụng

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
79. Khi bạn gọi
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
83, bạn sẽ nhận được
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
27 với các yếu tố của
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
85 theo thứ tự được sắp xếp.

Hãy để xem cách bạn có thể sử dụng

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
79 để lặp lại thông qua một từ điển trong Python khi bạn cần thực hiện theo thứ tự được sắp xếp.

Được sắp xếp theo chìa khóa

>>>

>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
9

Nếu bạn cần lặp lại thông qua một từ điển trong Python và muốn nó được sắp xếp bằng các khóa, thì bạn có thể sử dụng từ điển của mình như một đối số cho

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
79. Điều này sẽ trả về một
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
27 chứa các khóa theo thứ tự được sắp xếp và bạn sẽ có thể lặp lại thông qua chúng:

Trong ví dụ này, bạn đã sắp xếp từ điển (theo thứ tự bảng chữ cái) bằng các phím sử dụng

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
80 trong tiêu đề của vòng lặp
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
6. Lưu ý rằng bạn cũng có thể sử dụng
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
91 để có được kết quả tương tự. Trong cả hai trường hợp, bạn sẽ nhận được một
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
27 chứa các khóa từ điển của bạn theo thứ tự được sắp xếp.

>>>

>>> [a for a in dir(obj) if not a.startswith('__') and not callable(getattr(obj, a))]
['bar', 'foo']
0

Được sắp xếp theo các giá trị

Bạn cũng có thể cần lặp lại thông qua một từ điển trong Python với các mục của nó được sắp xếp theo các giá trị. Bạn cũng có thể sử dụng >>> dir(obj) ['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func'] 79, nhưng với một đối số thứ hai gọi là >>> # Python 2.7. New interactive session >>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'} >>> a_dict {'color': 'blue', 'pet': 'dog', 'fruit': 'apple'} >>> a_dict {'color': 'blue', 'pet': 'dog', 'fruit': 'apple'} 4.

Đối số từ khóa

>>> # Python 2.7. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
4 chỉ định một hàm của một đối số được sử dụng để trích xuất một khóa so sánh từ mỗi yếu tố mà bạn đang xử lý.

>>>

>>> [a for a in dir(obj) if not a.startswith('__') and not callable(getattr(obj, a))]
['bar', 'foo']
1

Để sắp xếp các mục của từ điển theo các giá trị, bạn có thể viết một hàm trả về giá trị của từng mục và sử dụng hàm này làm đối số

>>> # Python 2.7. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
4 thành
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
79:

Trong ví dụ này, bạn đã xác định

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
98 và sử dụng nó để sắp xếp các mục của
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
42 theo giá trị. Sau đó, bạn lặp lại thông qua từ điển theo thứ tự được sắp xếp bằng cách sử dụng
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
79. Hàm chính (
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
98) cho
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
79 sắp xếp
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
03 theo phần tử thứ hai của mỗi mục, nghĩa là, theo giá trị (
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
04).

>>>

>>> [a for a in dir(obj) if not a.startswith('__') and not callable(getattr(obj, a))]
['bar', 'foo']
2

Mã này cho bạn thấy rằng

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
42 đã không thay đổi.
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
79 didn sửa đổi
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
42. Nó chỉ tạo ra một danh sách được sắp xếp mới từ các khóa của
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
42.

Lặp lại một cách phá hủy với ________ 222 ()

Đôi khi bạn cần lặp lại thông qua một từ điển trong Python và xóa các mục của nó một cách tuần tự. Để thực hiện nhiệm vụ này, bạn có thể sử dụng

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
23, sẽ xóa và trả lại một cặp giá trị khóa tùy ý từ một từ điển. Mặt khác, khi bạn gọi
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
23 trên một từ điển trống, nó sẽ tăng một
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
25.

Nếu bạn thực sự cần phải phá hủy một cách phá hủy thông qua một từ điển trong Python, thì

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
23 có thể hữu ích. Đây là một ví dụ:

>>> [a for a in dir(obj) if not a.startswith('__') and not callable(getattr(obj, a))]
['bar', 'foo']
3

Ở đây, bạn đã sử dụng vòng lặp

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
27 thay vì vòng
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
6. Lý do cho điều này là vì nó không bao giờ an toàn khi lặp lại thông qua một từ điển trong Python nếu bạn giả vờ sửa đổi nó theo cách này, nghĩa là, nếu bạn đang xóa hoặc thêm các mục vào nó.

Bên trong vòng

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
27, bạn đã xác định một khối
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
30 để bắt
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
25 được nâng lên bởi
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
32 khi
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
8 trống. Trong khối
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
30, bạn xử lý từ điển, loại bỏ một mục trong mỗi lần lặp. Biến
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
35 giữ một tham chiếu đến các mục liên tiếp và cho phép bạn thực hiện một số hành động với chúng.

Nếu bạn chạy tập lệnh này từ dòng lệnh của mình, thì bạn sẽ nhận được kết quả sau:

>>> [a for a in dir(obj) if not a.startswith('__') and not callable(getattr(obj, a))]
['bar', 'foo']
4

Ở đây

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
23 đã loại bỏ tuần tự các mục của
>>> # Python 2.7
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
8. Vòng lặp bị vỡ khi từ điển trở nên trống rỗng và
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
23 đã tăng ngoại lệ
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
25.

Sử dụng một số chức năng tích hợp của Python,

Python cung cấp một số chức năng tích hợp có thể hữu ích khi bạn làm việc với các bộ sưu tập, như từ điển. Các chức năng này là một loại công cụ lặp cung cấp cho bạn một cách khác để lặp lại thông qua một từ điển trong Python. Hãy cùng xem một số trong số họ.

>>> set(dir(Cls)) - set(dir(object)) set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__']) 5

Python sườn

>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
5 được định nghĩa là
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
42 và trả về một trình lặp lại áp dụng
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
43 cho mọi mục của
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
85, mang lại kết quả theo yêu cầu. Vì vậy,
>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
5 có thể được xem như một công cụ lặp mà bạn có thể sử dụng để lặp lại thông qua một từ điển trong Python.

Giả sử bạn có một từ điển chứa giá của một loạt các sản phẩm và bạn cần phải áp dụng giảm giá cho chúng. Trong trường hợp này, bạn có thể xác định một chức năng quản lý giảm giá và sau đó sử dụng nó làm đối số đầu tiên cho

>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
5. Đối số thứ hai có thể là
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
47:

>>>

>>> [a for a in dir(obj) if not a.startswith('__') and not callable(getattr(obj, a))]
['bar', 'foo']
5

Ở đây,

>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
5 đã lặp lại thông qua các mục của từ điển (
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
47) để áp dụng giảm giá 5% cho mỗi loại trái cây bằng cách sử dụng
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
50. Trong trường hợp này, bạn cần sử dụng
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
51 để tạo từ điển
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
52 từ trình lặp được trả về bởi
>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
5.

Lưu ý rằng

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
50 trả về
>>> # Python 3.5
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
3 của mẫu
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
56, trong đó
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
57 đại diện cho khóa và
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
58 đại diện cho giá trị mới.

>>> set(dir(Cls)) - set(dir(object)) set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__']) 6

>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
6 là một chức năng tích hợp khác mà bạn có thể sử dụng để lặp lại thông qua từ điển trong Python và lọc ra một số mục của nó. Hàm này được định nghĩa là
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
61 và trả về một trình lặp lại từ các phần tử của
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
85 mà
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
43 trả về
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
16.

Giả sử bạn muốn biết các sản phẩm có giá thấp hơn

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
65. Bạn cần xác định một hàm để xác định xem giá có thỏa mãn điều kiện đó hay không và chuyển nó như đối số đầu tiên cho
>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
6. Đối số thứ hai có thể là
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
67:

>>>

>>> [a for a in dir(obj) if not a.startswith('__') and not callable(getattr(obj, a))]
['bar', 'foo']
6

Ở đây, bạn đã lặp lại thông qua các khóa của

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
18 với
>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
6. Sau đó
>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
6 áp dụng
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
71 cho mọi khóa của
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
18. Cuối cùng, bạn cần sử dụng
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
73 để tạo danh sách các sản phẩm có giá thấp, bởi vì
>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
6 trả về một trình lặp và bạn thực sự cần một đối tượng
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
27.

Sử dụng >>> [a for a in dir(obj) if not a.startswith('__')] ['bar', 'foo', 'func'] 76

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
77 là một mô -đun hữu ích từ thư viện tiêu chuẩn Python cung cấp các loại dữ liệu container chuyên dụng. Một trong những loại dữ liệu này là
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
78, đây là một lớp giống như từ điển để tạo một chế độ xem nhiều ánh xạ (như từ điển). Với
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
78, bạn có thể nhóm nhiều từ điển lại với nhau để tạo một chế độ xem duy nhất, có thể cập nhật.

Bây giờ, giả sử bạn có hai (hoặc nhiều) từ điển, và bạn cần lặp lại thông qua chúng cùng nhau như một. Để đạt được điều này, bạn có thể tạo một đối tượng

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
78 và khởi tạo nó bằng từ điển của bạn:

>>>

>>> [a for a in dir(obj) if not a.startswith('__') and not callable(getattr(obj, a))]
['bar', 'foo']
7

Sau khi nhập

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
78 từ
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
77, bạn cần tạo một đối tượng
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
78 với các từ điển bạn muốn chuỗi, và sau đó bạn có thể tự do lặp lại thông qua đối tượng kết quả như bạn sẽ làm với một từ điển thông thường.

Các đối tượng

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
78 cũng triển khai
>>> # Python 3.5. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}
0,
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
86 và
>>> # Python 2.7. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
7 như một từ điển tiêu chuẩn, vì vậy bạn có thể sử dụng các phương thức này để lặp lại thông qua đối tượng giống như từ điển được tạo bởi
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
78, giống như bạn sẽ làm với một từ điển thông thường:

>>>

>>> [a for a in dir(obj) if not a.startswith('__') and not callable(getattr(obj, a))]
['bar', 'foo']
8

Trong trường hợp này, bạn đã gọi

>>> # Python 2.7. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
7 trên đối tượng
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
78. Đối tượng
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
78 hoạt động như thể nó là một từ điển thông thường và
>>> # Python 2.7. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
>>> a_dict
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
7 đã trả về một đối tượng chế độ xem từ điển có thể được lặp lại như bình thường.

Sử dụng >>> [a for a in dir(obj) if not a.startswith('__')] ['bar', 'foo', 'func'] 93

Python sườn

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
93 là một mô -đun cung cấp một số công cụ hữu ích để thực hiện các tác vụ lặp. Hãy cùng xem cách bạn có thể sử dụng một số trong số chúng để lặp lại thông qua một từ điển trong Python.

Lặp đi lặp theo chu kỳ với >>> [a for a in dir(obj) if not a.startswith('__')] ['bar', 'foo', 'func'] 95

Giả sử bạn muốn lặp lại thông qua một từ điển trong Python, nhưng bạn cần lặp lại qua nó liên tục trong một vòng lặp duy nhất. Để hoàn thành nhiệm vụ này, bạn có thể sử dụng

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
96, điều này làm cho một trình lặp trả về các phần tử từ
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
85 và lưu một bản sao của mỗi phần. Khi
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
85 cạn kiệt,
>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
95 trả về các phần tử từ bản sao đã lưu. Điều này được thực hiện theo kiểu theo chu kỳ, vì vậy, bạn sẽ dừng chu kỳ.

Trong ví dụ sau, bạn sẽ lặp đi lặp lại thông qua các mục của từ điển ba lần liên tiếp:

>>>

>>> [a for a in dir(obj) if not a.startswith('__') and not callable(getattr(obj, a))]
['bar', 'foo']
9

Mã trước cho phép bạn lặp lại thông qua

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
18 một số lần nhất định (
>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
01 trong trường hợp này). Chu kỳ này có thể miễn là bạn cần, nhưng bạn có trách nhiệm ngăn chặn nó. Điều kiện
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
37 phá vỡ chu kỳ khi
>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
03 đếm xuống bằng không.

Xếp vòng lặp với >>> filter(lambda a: not a.startswith('__'), dir(obj)) ['bar', 'foo', 'func'] 04

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
93 cũng cung cấp
>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
06, nhận được một số
>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
07 như các đối số và tạo ra một trình lặp lại mang lại các yếu tố từ lần đầu tiên có thể sử dụng được cho đến khi nó cạn kiệt, sau đó lặp đi lặp lại tiếp theo, cho đến khi tất cả chúng bị kiệt sức.

Điều này cho phép bạn lặp lại qua nhiều từ điển trong một chuỗi, thích những gì bạn đã làm với

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
76:

>>>

>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
0

Trong mã trên,

>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
04 đã trả về một số ít kết hợp các mục từ
>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
10 và
>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
11.

Nó cũng có thể sử dụng

>>> # Python 3.5. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}
0 hoặc
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']
05, tùy thuộc vào nhu cầu của bạn, với điều kiện đồng nhất: Nếu bạn sử dụng
>>> # Python 3.5. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}
0 cho một đối số với
>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
04, thì bạn cần sử dụng
>>> # Python 3.5. New interactive session
>>> a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}
>>> a_dict
{'fruit': 'apple', 'pet': 'dog', 'color': 'blue'}
0 cho phần còn lại của chúng.

Sử dụng toán tử giải nén từ điển (>>> filter(lambda a: not a.startswith('__'), dir(obj)) ['bar', 'foo', 'func'] 17)

Python 3,5 mang đến một tính năng mới và thú vị. PEP 448 - Các khái quát hóa việc giải nén bổ sung có thể giúp cuộc sống của bạn dễ dàng hơn khi lặp đi lặp lại thông qua nhiều từ điển trong Python. Hãy cùng xem cách thức hoạt động của nó với một ví dụ ngắn.

Giả sử bạn có hai (hoặc nhiều) từ điển, và bạn cần lặp lại thông qua chúng cùng nhau, mà không cần sử dụng

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']
76 hoặc
>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
19, như bạn đã thấy trong các phần trước. Trong trường hợp này, bạn có thể sử dụng toán tử giải nén từ điển (
>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
17) để hợp nhất hai từ điển thành một từ mới và sau đó lặp lại thông qua nó:

>>>

>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
1

Nhà điều hành giải nén từ điển (

>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
17) thực sự là một tính năng tuyệt vời trong Python. Nó cho phép bạn hợp nhất nhiều từ điển thành một từ mới, như bạn đã làm trong ví dụ với
>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
11 và
>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
10. Khi bạn đã hợp nhất các từ điển với toán tử giải nén, bạn có thể lặp lại thông qua từ điển mới như bình thường.

Điều quan trọng cần lưu ý là nếu các từ điển mà bạn đang cố gắng hợp nhất có các khóa lặp đi lặp lại hoặc thông thường, thì các giá trị của từ điển bên phải sẽ chiếm ưu thế:

>>>

>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])
2

Khóa

>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
24 có mặt trong cả hai từ điển. Sau khi bạn hợp nhất chúng, giá trị
>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
10 cho
>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
24 (
>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
27) đã chiếm ưu thế, bởi vì
>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']
10 là từ điển bên phải.

Sự kết luận

Bây giờ bạn đã biết những điều cơ bản về cách lặp lại thông qua một từ điển trong Python, cũng như một số kỹ thuật và chiến lược nâng cao hơn!

Bạn đã học:

  • Từ điển là gì, cũng như một số tính năng chính và chi tiết triển khai của họ
  • Những cách cơ bản để lặp lại thông qua một từ điển trong Python là gì
  • Loại nhiệm vụ nào bạn có thể hoàn thành bằng cách lặp lại thông qua một từ điển trong Python
  • Cách sử dụng một số kỹ thuật và chiến lược được xây dựng để lặp lại thông qua từ điển trong Python

Bạn có các công cụ và kiến ​​thức mà bạn sẽ cần để tận dụng tối đa từ điển trong Python. Điều này sẽ giúp bạn hiệu quả và hiệu quả hơn trong việc sử dụng phép lặp từ điển trong tương lai.

Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: Bài viết từ điển Python: Lời khuyên & thủ thuật nâng cao This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Python Dictionary Iteration: Advanced Tips & Tricks

Bạn có thể lặp lại một đối tượng?

Sự vật.Nó lấy đối tượng mà bạn muốn lặp lại như một đối số và trả về một mảng chứa tất cả các thuộc tính (hoặc khóa).Sau đó bạn có thể sử dụng bất kỳ phương thức lặp mảng nào, chẳng hạn như foreach (), để lặp qua mảng và lấy giá trị của mỗi thuộc tính.use any of the array looping methods, such as forEach(), to iterate through the array and retrieve the value of each property.

Một đối tượng có thể lặp lại trong Python là gì?

Có thể lặp lại là một đối tượng có thể được lặp qua hoặc lặp đi lặp lại với sự trợ giúp của một vòng lặp.Các đối tượng như danh sách, bộ dữ liệu, bộ, từ điển, chuỗi, vv được gọi là Iterables.Nói ngắn gọn và đơn giản hơn, có thể là bất cứ điều gì bạn có thể lặp lại.an object which can be looped over or iterated over with the help of a for loop. Objects like lists, tuples, sets, dictionaries, strings, etc. are called iterables. In short and simpler terms, iterable is anything that you can loop over.