Hướng dẫn how to access a list in reverse order python - cách truy cập danh sách theo thứ tự ngược lại trong python

Giả sử nhiệm vụ là tìm phần tử cuối cùng thỏa mãn một số điều kiện trong danh sách (nghĩa là trước tiên khi nhìn về phía sau), tôi sẽ nhận được các số.

Python 2:

>>> min(timeit.repeat('for i in xrange(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', repeat=8))
4.6937971115112305
>>> min(timeit.repeat('for i in reversed(xrange(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', repeat=8))
4.809093952178955
>>> min(timeit.repeat('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', repeat=8))
4.931743860244751
>>> min(timeit.repeat('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', repeat=8))
5.548468112945557
>>> min(timeit.repeat('for i in xrange(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', repeat=8))
6.286104917526245
>>> min(timeit.repeat('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', repeat=8))
8.384078979492188

Vì vậy, tùy chọn xấu nhất

>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.48873088900001
>>> timeit.timeit('for i in reversed(range(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.540959084000008
>>> timeit.timeit('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998

4 là nhanh nhất.

Python 3 (máy khác):

>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.48873088900001
>>> timeit.timeit('for i in reversed(range(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.540959084000008
>>> timeit.timeit('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998

Ở đây,

>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.48873088900001
>>> timeit.timeit('for i in reversed(range(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.540959084000008
>>> timeit.timeit('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998

5 là nhanh nhất.

Bạn có thể đảo ngược một danh sách trong Python bằng các phương thức

>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.48873088900001
>>> timeit.timeit('for i in reversed(range(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.540959084000008
>>> timeit.timeit('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998

6 hoặc

>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.48873088900001
>>> timeit.timeit('for i in reversed(range(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.540959084000008
>>> timeit.timeit('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998

7 tích hợp. Các phương pháp này sẽ đảo ngược danh sách mà không tạo ra một danh sách mới. Python

>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.48873088900001
>>> timeit.timeit('for i in reversed(range(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.540959084000008
>>> timeit.timeit('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998

6 và

>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.48873088900001
>>> timeit.timeit('for i in reversed(range(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.540959084000008
>>> timeit.timeit('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998

7 sẽ đảo ngược các yếu tố trong đối tượng danh sách ban đầu.

---

Đảo ngược danh sách là một phần phổ biến của bất kỳ ngôn ngữ lập trình nào. Trong hướng dẫn này, chúng tôi sẽ phá vỡ các phương pháp danh sách ngược Python hiệu quả nhất.

Tìm Bootcamp của bạn phù hợp

• Karma nghề nghiệp phù hợp với bạn với bootcamp công nghệ hàng đầu
• Truy cập các học bổng và khóa học chuẩn bị độc quyền

Chọn mối quan tâm của bạn họ Tên điện thoại Email Tên của bạn
First name

Last name

Email

Phone number

Bằng cách tiếp tục, bạn đồng ý với các điều khoản dịch vụ và chính sách quyền riêng tư của chúng tôi và bạn đồng ý nhận được các ưu đãi và cơ hội từ Karma nghề nghiệp qua điện thoại, tin nhắn văn bản và email.

Hãy nói rằng bạn có một danh sách trong Python của tên khách hàng theo thứ tự bảng chữ cái ngược nhưng muốn xem chúng theo thứ tự bảng chữ cái. Bạn sẽ phải đảo ngược danh sách để làm như vậy. Nếu bạn có một danh sách dài và muốn xem những gì ở phía dưới, bạn có thể cuộn xuống. Hoặc, bạn có thể đảo ngược để có được dữ liệu nhanh chóng.

Danh sách Python và Danh sách cắt lát: Một người bồi dưỡng

Trong Python, danh sách là các mảng của các mặt hàng. Danh sách của bạn có thể bao gồm các chuỗi, booleans, số, đối tượng hoặc bất kỳ loại dữ liệu nào khác trong Python và có thể chứa bao nhiêu tùy thích. Khi làm việc với nhiều dữ liệu, có thể hữu ích khi khai báo một danh sách thay vì khai báo nhiều biến.

Danh sách cắt lát

Mặc dù bạn không cần biết về việc cắt danh sách để thực hiện hoạt động danh sách ngược, nhưng nó có thể hữu ích.

Đây là cách bạn sẽ tuyên bố một danh sách trong Python:

studentNames = ["Hannah", "Imogen", "Lewis", "Peter"]

Chúng tôi vừa khai báo một biến,

studentNames = ["Hannah", "Imogen", "Lewis", "Peter"]

0 và gán một danh sách các giá trị trong trường hợp này, tên của học sinh cho biến. & NBSP;

Nếu chúng tôi muốn nhận được một giá trị cụ thể từ danh sách của mình, chúng tôi có thể sử dụng số chỉ mục của nó và cắt danh sách. Đó là rất nhiều thứ để tham gia, vì vậy, hãy để nó phá vỡ nó. Mỗi mục trong danh sách của chúng tôi có giá trị chỉ mục, bắt đầu từ 0. Chúng tôi có thể sử dụng chúng để nhận một giá trị nhất định từ danh sách của chúng tôi. Dưới đây là các giá trị chỉ mục cho mảng của chúng tôi:

Hannah	Imogen	Lewis	Peter
	1	2	3

Nếu chúng tôi muốn nhận

studentNames = ["Hannah", "Imogen", "Lewis", "Peter"]

1 từ danh sách của mình, chúng tôi sẽ làm như vậy bằng cách sử dụng mã sau:

studentNames = ["Hannah", "Imogen", "Lewis", "Peter"]
print(studentNames[1])

Chúng tôi đã tuyên bố biến của chúng tôi với tên sinh viên. Tiếp theo, chúng tôi đã nói rằng chúng tôi muốn lấy mục danh sách với giá trị chỉ mục là

studentNames = ["Hannah", "Imogen", "Lewis", "Peter"]

2. Trong trường hợp này, giá trị là

studentNames = ["Hannah", "Imogen", "Lewis", "Peter"]

1.

Chúng tôi cũng có thể thay đổi số chỉ mục để có được một phạm vi bằng cách thêm một số khác. Đây là một ví dụ:

studentNames = ["Hannah", "Imogen", "Lewis", "Peter"]
print(studentNames[1:3])

Đầu ra cho mã của chúng tôi sẽ như sau:

["Imogen", "Lewis", "Peter"]

Bây giờ chúng tôi biết những điều cơ bản của việc cắt danh sách, chúng tôi có thể bắt đầu thảo luận về các danh sách đảo ngược trong Python.

Hướng dẫn danh sách ngược Python

Ba cách chính mà bạn có thể đảo ngược danh sách trong Python là:

• Đảo ngược bằng cách sử dụng cắt
• Đảo ngược bằng ngược ()
• Đảo ngược bằng cách sử dụng đảo ngược

Đảo ngược bằng cách sử dụng cắt

Đầu tiên là sử dụng một thủ thuật cắt lát để đảo ngược danh sách của bạn. Đây là cú pháp Python:

studentNames = ["Hannah", "Imogen", "Lewis", "Peter"]
print(studentNames[::-1])

Đầu ra cho mã của chúng tôi là:

["Peter", "Lewis", "Imogen", "Hannah"]

Trong mã của chúng tôi, chúng tôi đã khai báo biến

studentNames = ["Hannah", "Imogen", "Lewis", "Peter"]

0 của chúng tôi, và sau đó tạo một hàm lát cắt sẽ đảo ngược danh sách. Đây là một cách phổ biến để cắt danh sách. Nhưng nó có thể không hiệu quả vì nó tạo ra một bản sao của danh sách, chiếm bộ nhớ. Ngoài ra, chức năng này có thể là một chút nâng cao liên quan đến các phương pháp đảo ngược khác.

Đảo ngược bằng ngược ()

Tùy chọn thứ hai chúng ta có thể thực hiện là sử dụng chức năng tích hợp,

>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.48873088900001
>>> timeit.timeit('for i in reversed(range(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.540959084000008
>>> timeit.timeit('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998

6. Phương thức

>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.48873088900001
>>> timeit.timeit('for i in reversed(range(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.540959084000008
>>> timeit.timeit('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998

6 có thể được gọi để đảo ngược nội dung của đối tượng danh sách tại chỗ. Điều này có nghĩa là bạn đã thắng được tạo ra một danh sách mới. Thay vào đó, chúng tôi sẽ sửa đổi đối tượng danh sách ban đầu.

Mã sau đây hiển thị cú pháp Python cho

>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.48873088900001
>>> timeit.timeit('for i in reversed(range(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.540959084000008
>>> timeit.timeit('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998

6 trong hành động:

studentNames = ["Hannah", "Imogen", "Lewis", "Peter"]
studentNames.reverse()

print(studentNames)

Đầu ra cho mã của chúng tôi như sau:

["Peter", "Lewis", "Imogen", "Hannah"]

Điều quan trọng cần lưu ý là chức năng

>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.48873088900001
>>> timeit.timeit('for i in reversed(range(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.540959084000008
>>> timeit.timeit('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998

6 tự trả về giá trị

studentNames = ["Hannah", "Imogen", "Lewis", "Peter"]

9. Vì vậy, nếu chúng tôi muốn có được danh sách sửa đổi của mình, chúng tôi cần in lại, như chúng tôi đã làm ở trên. Đây là một cách hiệu quả để đảo ngược danh sách và không yêu cầu nhiều bộ nhớ, không giống như ví dụ của chúng tôi. Cú pháp cũng rõ ràng và đơn giản.

Đảo ngược bằng cách sử dụng đảo ngược ()

Cách tiếp cận thứ ba và cuối cùng chúng ta có thể sử dụng để đảo ngược danh sách là sử dụng hàm

>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.48873088900001
>>> timeit.timeit('for i in reversed(range(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.540959084000008
>>> timeit.timeit('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998

7. Đây là một chức năng tích hợp mà chúng tôi sử dụng bằng cách tạo một trình lặp ngược để tạo một thứ tự đảo ngược của danh sách của chúng tôi trong Python. Điều này có nghĩa là một danh sách mới được tạo ra và danh sách cũ của chúng tôi không được sửa đổi. Thay vào đó, chức năng sẽ đạp xe qua tất cả các yếu tố trong danh sách của chúng tôi và trả lại chúng theo thứ tự ngược lại.

Cú pháp sau đây hiển thị chức năng

>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.48873088900001
>>> timeit.timeit('for i in reversed(range(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.540959084000008
>>> timeit.timeit('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998

7 trong hành động:

>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.48873088900001
>>> timeit.timeit('for i in reversed(range(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.540959084000008
>>> timeit.timeit('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998

0

Đầu ra cho mã của chúng tôi là:

>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.48873088900001
>>> timeit.timeit('for i in reversed(range(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.540959084000008
>>> timeit.timeit('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998

1

Nếu chúng tôi thực sự muốn tạo một bản sao đảo ngược của danh sách, chúng tôi có thể sử dụng mã này:

>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.48873088900001
>>> timeit.timeit('for i in reversed(range(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.540959084000008
>>> timeit.timeit('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998

2

Điều này sẽ trở lại:

"Karma nghề nghiệp bước vào cuộc sống của tôi khi tôi cần nó nhất và nhanh chóng giúp tôi kết hợp với bootcamp. Hai tháng sau khi tốt nghiệp, tôi tìm thấy công việc mơ ước của mình phù hợp với các giá trị và mục tiêu của tôi trong cuộc sống!"

Sao Kim, Kỹ sư phần mềm tại Rockbot

["Peter", "Lewis", "Imogen", "Hannah"]

Đây là một cách dễ dàng khác để đảo ngược danh sách. Nó cho thấy rõ những gì đang xảy ra. Một danh sách mới đang được tạo ra sẽ bao gồm tất cả các giá trị trong danh sách khác của chúng tôi, nhưng đảo ngược. & NBSP;

Sự kết luận

Đó là cách mà các phương pháp danh sách ngược khác nhau hoạt động. Trong hướng dẫn này, chúng tôi đã khám phá những điều cơ bản của danh sách, đó là các mảng của các mục như chuỗi hoặc đối tượng và thảo luận về các giá trị chỉ mục. Chúng tôi cũng đã phác thảo ba phương pháp bạn có thể sử dụng để đảo ngược danh sách.

Tất nhiên, bạn chỉ cần biết một. Nhưng nhận thức được cả ba có thể giúp bạn nếu những người khác có cách tiếp cận khác nhau và sử dụng chúng trong mã bạn đọc.

Làm thế nào bạn sẽ truy cập phần tử danh sách theo thứ tự ngược lại?

Làm thế nào để bạn đảo ngược một danh sách trong một python vòng lặp?

Làm thế nào để bạn đảo ngược một danh sách nhanh chóng trong Python?