Python Enumerate[] là một hàm tích hợp sẵn trong thư viện Python. Nó lấy đầu vào đã cho dưới dạng một tập hợp hoặc bộ dữ liệu và trả về dưới dạng đối tượng liệt kê. Lệnh Python Enumerate[] thêm một bộ đếm vào từng mục của đối tượng có thể lặp lại và trả về một đối tượng liệt kê dưới dạng chuỗi đầu ra
Trong hướng dẫn Enumerate Python này, bạn sẽ học
Cú pháp liệt kê Python[]
enumerate[iterable, startIndex]
Thông số
Ba tham số là
- Có thể lặp lại. một đối tượng có thể được lặp lại
- Bắt đầu Index. [tùy chọn] Số đếm sẽ bắt đầu với giá trị được cung cấp trong startIndex cho mục đầu tiên trong vòng lặp và tăng giá trị đó cho mục tiếp theo cho đến khi đạt đến cuối vòng lặp
Tuy nhiên, nếu start Index không được chỉ định, số đếm sẽ bắt đầu từ 0
Giá trị trả về
Nó sẽ trả về một iterableobject, với giá trị đếm cho từng mục cho iteratorobject được cung cấp làm đầu vào
Enumerate[] trong Python Ví dụ
Phương thức liệt kê đi kèm với bộ đếm/chỉ mục tự động cho từng mục có trong danh sách liệt kê trong Python. Giá trị firstindex sẽ bắt đầu từ 0. Bạn cũng có thể chỉ định startindex bằng cách sử dụng tham số tùy chọn startIndex trong liệt kê
Ví dụ
Trong đoạn mã dưới đây, mylist là danh sách được cung cấp cho hàm Enumerate trong Python. Hàm list[] được sử dụng để hiển thị đầu ra Enumerate Python
Ghi chú. Không có start Index nào được sử dụng do đó chỉ mục cho mục đầu tiên sẽ bắt đầu từ 0
Đầu ra từ liệt kê sẽ theo cách sau
[0, item_1], [1, item_2], [2, item_3], … [n, item_n]
Tập tin. python_enumerate. py
mylist = ['A', 'B' ,'C', 'D'] e_list = enumerate[mylist] print[list[e_list]]
đầu ra
[[0, 'A'], [1, 'B'], [2, 'C'], [3, 'D']]
Sử dụngEnumerate[] trên danh sách với startIndex
Trong ví dụ dưới đây, startindex được cho là 2. Chỉ mục của mục đầu tiên sẽ bắt đầu từ startindex đã cho
Ví dụ
Trong ví dụ bên dưới, danh sách của tôi là danh sách được đưa ra để liệt kê. Hàm list[] được sử dụng để hiển thị đầu ra kiểu liệt kê
mylist = ['A', 'B' ,'C', 'D'] e_list = enumerate[mylist,2] print[list[e_list]]
đầu ra
[[2, 'A'], [3, 'B'], [4, 'C'], [5, 'D']]
Vòng qua một đối tượng Enumerate
Ví dụ hiển thị việc liệt kê một đối tượng có và không có startIndex
- Vòng lặp for đầu tiên không có start Index nên chỉ số bắt đầu từ 0
- Vòng lặp for thứ hai có start Index là 10, vì vậy chỉ mục bắt đầu từ 10
Ví dụ
mylist = ['A', 'B' ,'C', 'D'] for i in enumerate[mylist]: print[i] print["\n"] print["Using startIndex as 10"] for i in enumerate[mylist, 10]: print[i] print["\n"]
đầu ra
[0, 'A'] [1, 'B'] [2, 'C'] [3, 'D'] Using startIndex as 10 [10, 'A'] [11, 'B'] [12, 'C'] [13, 'D']
Liệt kê một Tuple
Trong ví dụ dưới đây, bạn có thể sử dụng một bộ bên trong một kiểu liệt kê. Bạn cũng có thể sử dụng start Index và khóa của mỗi mục sẽ bắt đầu từ start Index đã cho
Theo mặc định, start Index là 0. Ở đó, do đó bạn thấy khóa là 0 cho các mục A và 1 cho B, v.v.
Ví dụ
________số 8đầu ra
[0, 'A'] [1, 'B'] [2, 'C'] [3, 'D'] [4, 'E']
Liệt kê một chuỗi
Trong Python, chuỗi là một mảng và do đó bạn có thể lặp qua nó. Nếu bạn chuyển một chuỗi vào enumerate[], đầu ra sẽ hiển thị cho bạn chỉ mục và giá trị cho từng ký tự của chuỗi
Ví dụ
[0, item_1], [1, item_2], [2, item_3], … [n, item_n]0
đầu ra
[0, item_1], [1, item_2], [2, item_3], … [n, item_n]1
Liệt kê một từ điển
Trong Python, một từ điển được liệt kê trong dấu ngoặc nhọn, bên trong các dấu ngoặc nhọn này, các giá trị được khai báo
Mỗi phần tử là một cặp khóa/giá trị và được phân tách bằng dấu phẩy. Bạn có thể sử dụng một từ điển bên trong một liệt kê[] và xem đầu ra
Vòng lặp với biến đếm/chỉ số - một tác phẩm kinh điển trong Khoa học máy tính. Thông thường, bạn sẽ xác định rõ ràng một biến/chỉ mục bộ đếm và tăng nó theo cách thủ công trên mỗi vòng lặp hoặc bạn sẽ sử dụng một số loại đường cú pháp để tránh quá trình này thông qua các vòng lặp
[[0, 'A'], [1, 'B'], [2, 'C'], [3, 'D']]1 nâng cao
Cả hai đoạn này đều dẫn đến cùng một đầu ra
[0, item_1], [1, item_2], [2, item_3], … [n, item_n]2
Do mức độ phổ biến của vòng lặp như thế này trong công việc hàng ngày - hàm
[[0, 'A'], [1, 'B'], [2, 'C'], [3, 'D']]2 được tích hợp vào không gian tên Python. Bạn có thể, không có bất kỳ phụ thuộc bổ sung nào, lặp qua một lần lặp trong Python, với biến/chỉ mục bộ đếm tự động với cú pháp đơn giản như
[0, item_1], [1, item_2], [2, item_3], … [n, item_n]3
Ghi chú. Thông thường, nhưng không cần thiết, quy ước đặt tên chỉ mục là
[[0, 'A'], [1, 'B'], [2, 'C'], [3, 'D']]3 nếu không có nhãn nào khác được áp dụng, vì
[0, item_1], [1, item_2], [2, item_3], … [n, item_n]30 là từ khóa dành riêng. Thông thường, dựa trên khả năng lặp lại mà bạn đang làm việc, có thể gán các tên có ý nghĩa hơn, chẳng hạn như.
[0, item_1], [1, item_2], [2, item_3], … [n, item_n]31
Đoạn mã này dẫn đến
[0, item_1], [1, item_2], [2, item_3], … [n, item_n]6
Hãy đi sâu vào chức năng và khám phá cách thức hoạt động của nó. Đó là một cách cổ điển và phổ biến - và theo kiểu Python thực sự, nó đơn giản hóa một thao tác phổ biến, dư thừa và cải thiện khả năng đọc mã của bạn
Hàm enumerate[] trong Python
Hàm
[[0, 'A'], [1, 'B'], [2, 'C'], [3, 'D']]2 chấp nhận một bộ sưu tập có thể lặp lại [chẳng hạn như bộ, danh sách hoặc chuỗi] và trả về một đối tượng
[0, item_1], [1, item_2], [2, item_3], … [n, item_n]33, bao gồm một bộ khóa và bộ giá trị, trong đó các khóa tương ứng với một biến bộ đếm [bắt đầu từ 0] và
Ghi chú. Đối tượng
[0, item_1], [1, item_2], [2, item_3], … [n, item_n]33, chính nó, có thể lặp lại. Bạn có thể sử dụng cú pháp
[[0, 'A'], [1, 'B'], [2, 'C'], [3, 'D']]1 tiêu chuẩn, giải nén các khóa và giá trị của đối tượng
[0, item_1], [1, item_2], [2, item_3], … [n, item_n]33
Sử dụng cú pháp
[[0, 'A'], [1, 'B'], [2, 'C'], [3, 'D']]1 tiêu chuẩn của Python, chúng tôi có thể giải nén các khóa và giá trị từ đối tượng này và kiểm tra các loại của chúng
Các loại dữ liệu của các giá trị [các phần tử từ bộ sưu tập ban đầu] được giữ lại, vì vậy ngay cả khi bạn chuyển các loại dữ liệu tùy chỉnh, miễn là chúng là một bộ sưu tập có thể lặp lại hợp lệ - chúng sẽ chỉ được chú thích bằng một biến bộ đếm. Nếu bạn thu thập đối tượng vào một danh sách, cấu trúc của nó sẽ trở nên rất rõ ràng
Nó chỉ là một tập hợp các bộ dữ liệu với mỗi bộ có hai phần tử - một biến đếm, bắt đầu từ 0 và mỗi phần tử của bộ lặp ban đầu được ánh xạ tới các chỉ số
Bạn có thể đặt đối số
[0, item_1], [1, item_2], [2, item_3], … [n, item_n]38 tùy chọn, biểu thị không phải chỉ mục bắt đầu trong lần lặp, mà biểu thị giá trị bắt đầu cho bộ đếm/chỉ mục đầu tiên mà hàm sẽ tạo. Chẳng hạn, giả sử chúng tôi muốn bắt đầu từ
[0, item_1], [1, item_2], [2, item_3], … [n, item_n]39 thay vì
[0, item_1], [1, item_2], [2, item_3], … [n, item_n]60
Lặp qua Iterable với enumerate[]
Đã nói tất cả những điều đó - việc lặp qua một đối tượng
[0, item_1], [1, item_2], [2, item_3], … [n, item_n]33 trông giống như việc lặp qua các lần lặp khác. Vòng lặp
[[0, 'A'], [1, 'B'], [2, 'C'], [3, 'D']]1 có ích ở đây vì bạn có thể gán các biến tham chiếu cho các giá trị bộ dữ liệu được trả về. Ngoài ra, không cần tham chiếu đối tượng một cách rõ ràng, vì nó rất hiếm khi được sử dụng bên ngoài một vòng lặp nên giá trị trả về thường được sử dụng trực tiếp trong chính vòng lặp đó
Kết quả này trong
Hãy xem hướng dẫn thực hành, thực tế của chúng tôi để học Git, với các phương pháp hay nhất, tiêu chuẩn được ngành chấp nhận và bao gồm bảng gian lận. Dừng các lệnh Git trên Google và thực sự tìm hiểu nó
mylist = ['A', 'B' ,'C', 'D'] e_list = enumerate[mylist] print[list[e_list]]4
Nếu bạn muốn đọc thêm về chuỗi f và định dạng đầu ra trong Python, hãy đọc Hướng dẫn định dạng chuỗi bằng chuỗi f của Python 3 của chúng tôi
Chú thích từng phần tử trong một lần lặp - hay đúng hơn là tăng bộ đếm và trả về nó, trong khi truy cập các phần tử của lần lặp cũng dễ dàng như vậy
Điều đáng chú ý là không có gì đặc biệt thực sự xảy ra trong hàm
[[0, 'A'], [1, 'B'], [2, 'C'], [3, 'D']]2. Nó thực sự tương đương về mặt chức năng với vòng lặp ban đầu mà chúng ta đã viết, với một biến đếm rõ ràng được trả về cùng với một phần tử. Nếu bạn xem ghi chú trong tệp , kết quả của hàm có chức năng tương đương với
mylist = ['A', 'B' ,'C', 'D'] e_list = enumerate[mylist] print[list[e_list]]5
Bạn có thể thấy rằng mã khá giống với cách triển khai đầu tiên mà chúng tôi đã xác định
Điểm mấu chốt ở đây là - từ khóa
[0, item_1], [1, item_2], [2, item_3], … [n, item_n]64 định nghĩa một trình tạo, có thể lặp lại. Bằng cách trả lại chỉ mục và chính phần tử đó, chúng ta đang tạo một đối tượng trình tạo có thể lặp lại, sau đó chúng ta có thể lặp lại và trích xuất các phần tử [và chỉ số của chúng] từ vòng lặp
[[0, 'A'], [1, 'B'], [2, 'C'], [3, 'D']]1
Nếu bạn muốn đọc thêm về cách sử dụng từ khóa
[0, item_1], [1, item_2], [2, item_3], … [n, item_n]64 tại đây, hãy đọc Hướng dẫn của chúng tôi để hiểu về từ khóa "yield" của Python
Nếu bạn sử dụng hàm
[0, item_1], [1, item_2], [2, item_3], … [n, item_n]67 thay vì hàm tích hợp sẵn, chúng tôi sẽ có nhiều kết quả tương tự
mylist = ['A', 'B' ,'C', 'D'] e_list = enumerate[mylist] print[list[e_list]]9
Kết quả này trong
[[0, 'A'], [1, 'B'], [2, 'C'], [3, 'D']]0
Sự khác biệt duy nhất là chúng ta chỉ có một đối tượng trình tạo chung, thay vì một tên lớp đẹp hơn
Phần kết luận
Cuối cùng, hàm
[[0, 'A'], [1, 'B'], [2, 'C'], [3, 'D']]2 chỉ đơn giản là đường cú pháp, bao hàm một cách thực hiện vòng lặp cực kỳ phổ biến và đơn giản
Trong hướng dẫn ngắn này, chúng ta đã xem xét hàm
[[0, 'A'], [1, 'B'], [2, 'C'], [3, 'D']]2 trong Python - phương thức tiện lợi được tích hợp sẵn để lặp qua một tập hợp và chú thích các phần tử bằng chỉ số