Trong Python, làm thế nào để bạn có được yếu tố cuối cùng của một danh sách?
Chỉ để có được yếu tố cuối cùng,
- mà không sửa đổi danh sách, và
- Giả sử bạn biết danh sách có yếu tố cuối cùng [nghĩa là nó không trống]
Chuyển
>>> *head, last = a_list
>>> last
'three'
>>> a_list = ['zero', 'one', 'two', 'three']
>>> a_list[-1]
'three'
Giải trình
Chỉ mục và lát cắt có thể lấy các số nguyên âm làm đối số.
Tôi đã sửa đổi một ví dụ từ tài liệu để chỉ ra mục nào trong chuỗi mỗi tài liệu tham khảo chỉ mục, trong trường hợp này, trong chuỗi
>>> *head, last = a_list
>>> last
'three'
>>> *head, last = a_list
>>> last
'three'
>>> *head, last = a_list
>>> last
'three'
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
>>> p = 'Python'
>>> p[-1]
'n'
Nhiệm vụ thông qua việc giải nén có thể giải quyết được
Phương pháp này có thể thành hiện thực một cách không cần thiết danh sách thứ hai cho các mục đích chỉ nhận được yếu tố cuối cùng, nhưng vì lợi ích của tính hoàn chỉnh [và vì nó hỗ trợ bất kỳ khả năng nào - không chỉ danh sách]:
>>> *head, last = a_list
>>> last
'three'
Tên biến, Head được liên kết với danh sách mới được tạo không cần thiết:
>>> head
['zero', 'one', 'two']
Nếu bạn có ý định không làm gì với danh sách đó, đây sẽ là nhiều apropos hơn:
*_, last = a_list
Hoặc, thực sự, nếu bạn biết đó là danh sách [hoặc ít nhất là chấp nhận ký hiệu đăng ký]:
last = a_list[-1]
Trong một chức năng
Một người bình luận nói:
Tôi ước Python có một chức năng cho First [] và Last [] như Lisp làm ... nó sẽ loại bỏ rất nhiều chức năng Lambda không cần thiết.
Đây sẽ khá đơn giản để xác định:
def last[a_list]:
return a_list[-1]
def first[a_list]:
return a_list[0]
Hoặc sử dụng
>>> *head, last = a_list
>>> last
'three'
>>> import operator
>>> last = operator.itemgetter[-1]
>>> first = operator.itemgetter[0]
Trong cả hai trường hợp:
>>> last[a_list]
'three'
>>> first[a_list]
'zero'
Trường hợp đặc biệt
Nếu bạn đang làm một cái gì đó phức tạp hơn, bạn có thể thấy nó hoạt động nhiều hơn để có được yếu tố cuối cùng theo những cách hơi khác nhau.
Nếu bạn chưa quen với lập trình, bạn nên tránh phần này, bởi vì nó kết hợp các phần khác nhau về mặt ngữ nghĩa của thuật toán. Nếu bạn thay đổi thuật toán của mình ở một nơi, nó có thể có tác động ngoài ý muốn đến một dòng mã khác.
Tôi cố gắng cung cấp cảnh báo và điều kiện hoàn toàn nhất có thể, nhưng tôi có thể đã bỏ lỡ điều gì đó. Hãy bình luận nếu bạn nghĩ rằng tôi sẽ bỏ đi.
Cắt lát
Một lát của danh sách trả về một danh sách mới - vì vậy chúng tôi có thể cắt từ -1 đến cuối nếu chúng tôi sẽ muốn phần tử trong một danh sách mới:
>>> a_slice = a_list[-1:]
>>> a_slice
['three']
Điều này có mặt trái không thất bại nếu danh sách trống:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
>>> p = 'Python'
>>> p[-1]
'n'
Trong khi đó cố gắng truy cập bằng chỉ mục làm tăng một
>>> *head, last = a_list
>>> last
'three'
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
>>> p = 'Python'
>>> p[-1]
'n'
Nhưng một lần nữa, việc cắt cho mục đích này chỉ nên được thực hiện nếu bạn cần:
- một danh sách mới được tạo
- Và danh sách mới sẽ trống nếu danh sách trước trống.
>>> *head, last = a_list
>>> last
'three'
6 vòng lặp
>>> *head, last = a_list
>>> last
'three'
Là một đặc điểm của Python, không có phạm vi bên trong trong vòng lặp
>>> *head, last = a_list
>>> last
'three'
Nếu bạn đang thực hiện một lần lặp hoàn chỉnh trong danh sách, phần tử cuối cùng vẫn sẽ được tham chiếu bằng tên biến được gán trong vòng lặp:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
>>> p = 'Python'
>>> p[-1]
'n'
Đây không phải là ngữ nghĩa là điều cuối cùng trong danh sách. Đây là điều về mặt ngữ nghĩa là điều cuối cùng mà tên,
>>> *head, last = a_list
>>> last
'three'
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
>>> p = 'Python'
>>> p[-1]
'n'
Do đó, điều này chỉ nên được sử dụng để có được yếu tố cuối cùng nếu bạn
- đã lặp lại, và
- Bạn biết vòng lặp sẽ kết thúc [không bị hỏng hoặc thoát do lỗi], nếu không nó sẽ trỏ đến phần tử cuối cùng được tham chiếu bởi vòng lặp.
Nhận và loại bỏ nó
Chúng tôi cũng có thể biến đổi danh sách ban đầu của mình bằng cách xóa và trả về phần tử cuối cùng:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
>>> p = 'Python'
>>> p[-1]
'n'
Nhưng bây giờ danh sách ban đầu được sửa đổi.
[
>>> *head, last = a_list
>>> last
'three'
>>> head
['zero', 'one', 'two']
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
>>> p = 'Python'
>>> p[-1]
'n'
Chỉ làm điều này nếu
- Bạn biết danh sách có các yếu tố trong đó hoặc được chuẩn bị để xử lý ngoại lệ nếu nó trống và
- Bạn có ý định loại bỏ phần tử cuối cùng khỏi danh sách, coi nó như một ngăn xếp.
Đây là những trường hợp sử dụng hợp lệ, nhưng không phổ biến lắm.
Tiết kiệm phần còn lại của ngược lại sau:
Tôi không biết tại sao bạn làm điều đó, nhưng để hoàn thiện, vì
>>> head
['zero', 'one', 'two']
>>> head
['zero', 'one', 'two']
>>> head
['zero', 'one', 'two']
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
>>> p = 'Python'
>>> p[-1]
'n'
Vì vậy, nó giống như làm ngược lại điều này:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
>>> p = 'Python'
>>> p[-1]
'n'
Nhưng tôi không thể nghĩ ra một lý do chính đáng để làm điều này, trừ khi bạn cần phần còn lại của trình lặp ngược sau đó, điều này có thể trông giống như thế này hơn:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
>>> p = 'Python'
>>> p[-1]
'n'
và bây giờ:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
>>> p = 'Python'
>>> p[-1]
'n'