Hướng dẫn remove second last element from list python - xóa phần tử cuối cùng thứ hai khỏi python danh sách

Giống như những người khác đã đề cập POP và DEL là những cách hiệu quả để loại bỏ một mục của chỉ mục đã cho. Tuy nhiên, chỉ vì mục đích hoàn thành (vì điều tương tự có thể được thực hiện thông qua nhiều cách trong Python):

Sử dụng các lát cắt (điều này không thực hiện để loại bỏ mục khỏi danh sách ban đầu):

.

>>> a = [1, 2, 3, 4, 5, 6]
>>> index = 3 # Only positive index

>>> a = a[:index] + a[index+1 :]
# a is now [1, 2, 3, 5, 6]

Lưu ý: Xin lưu ý rằng phương pháp này không sửa đổi danh sách tại chỗ như

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

Điều này làm cho phương pháp này rất không hiệu quả và nó cũng có thể tạo ra các tác dụng phụ không mong muốn (đặc biệt là khi các biến khác trỏ đến đối tượng danh sách ban đầu không được sửa đổi).

Cảm ơn @markdickinson đã chỉ ra điều này ...

Câu trả lời tràn ngăn xếp này giải thích khái niệm cắt lát.

Cũng lưu ý rằng điều này chỉ hoạt động với các chỉ số tích cực.

Mặc dù sử dụng với các đối tượng, phương thức __getitem__ phải được xác định và quan trọng hơn là phương thức

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

Về bản chất, điều này hoạt động với bất kỳ đối tượng nào có định nghĩa lớp giống như:

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

Điều này hoạt động với

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

So sánh ba cách về hiệu quả:

Giả sử những điều sau đây được xác định trước:

a = range(10)
index = 3

Phương pháp

a = range(10)
index = 3

Cho đến nay là phương pháp hiệu quả nhất. Nó hoạt động sẽ tất cả các đối tượng xác định phương thức

a = range(10)
index = 3

Việc tháo gỡ như sau:

Code:

def del_method():
    global a
    global index
    del a[index]

Disassembly:

 10    0 LOAD_GLOBAL     0 (a)
       3 LOAD_GLOBAL     1 (index)
       6 DELETE_SUBSCR   # This is the line that deletes the item
       7 LOAD_CONST      0 (None)
      10 RETURN_VALUE
None

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

Nó kém hiệu quả hơn phương pháp DEL và được sử dụng khi bạn cần có được mục đã xóa.

Code:

def pop_method():
    global a
    global index
    a.pop(index)

Disassembly:

 17     0 LOAD_GLOBAL     0 (a)
        3 LOAD_ATTR       1 (pop)
        6 LOAD_GLOBAL     2 (index)
        9 CALL_FUNCTION   1
       12 POP_TOP
       13 LOAD_CONST      0 (None)
       16 RETURN_VALUE

Các lát cắt và thêm phương thức.

Ít hiệu quả nhất.

Code:

def slice_method():
    global a
    global index
    a = a[:index] + a[index+1:]

Disassembly:

 24     0 LOAD_GLOBAL    0 (a)
        3 LOAD_GLOBAL    1 (index)
        6 SLICE+2
        7 LOAD_GLOBAL    0 (a)
       10 LOAD_GLOBAL    1 (index)
       13 LOAD_CONST     1 (1)
       16 BINARY_ADD
       17 SLICE+1
       18 BINARY_ADD
       19 STORE_GLOBAL   0 (a)
       22 LOAD_CONST     0 (None)
       25 RETURN_VALUE
None

Lưu ý: Trong cả ba sự tháo rời bỏ qua hai dòng cuối cùng về cơ bản là

a = range(10)
index = 3

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

a = range(10)
index = 3

Python cung cấp ba cách khác nhau để loại bỏ phần tử cuối cùng khỏi danh sách. Trong bài đăng trên blog này, chúng tôi sẽ khám phá từng phương pháp này và xem phương pháp nào là hiệu quả nhất cho nhu cầu của chúng tôi. Phương pháp đầu tiên là sử dụng hàm pop (). Hàm này loại bỏ và trả về phần tử cuối cùng khỏi danh sách. Phương pháp thứ hai là sử dụng lát chỉ số. Phương pháp thứ ba là sử dụng hàm del (). Hàm này xóa một phần tử khỏi danh sách. Hãy cùng xem xét kỹ hơn từng phương pháp này!

Xóa phần tử cuối cùng khỏi danh sách bằng phương thức pop trong Python

Hàm pop () là cách phổ biến nhất để loại bỏ phần tử cuối cùng khỏi danh sách. Hàm này loại bỏ và trả về phần tử cuối cùng khỏi danh sách. Cú pháp cho chức năng này như sau: list.pop ()

Ví dụ: nếu chúng ta có một danh sách các số nguyên gọi là my_list, chúng ta có thể xóa phần tử cuối cùng bằng cách sử dụng mã sau:

my_list = [1, 2, 3] my_list.pop () # Trả về 3 # my_list bây giờ là [1, 2]
my_list.pop()
# Returns 3 # my_list is now [1, 2]

Phương thức pop () được sử dụng phổ biến nhất để loại bỏ phần tử cuối cùng khỏi danh sách. Tuy nhiên, nó cũng có thể được sử dụng để loại bỏ bất kỳ yếu tố nào khỏi danh sách. Ví dụ: nếu chúng tôi có một danh sách các số nguyên gọi là my_list và chúng tôi muốn xóa phần tử thứ hai khỏi danh sách, chúng tôi có thể sử dụng mã sau:

my_list = [1, 2, 3] my_list.pop (1) # trả về 2 # my_list bây giờ [1,3]
my_list.pop(1)
# Returns 2 # my_list is now [1,3]

Xóa phần tử cuối cùng khỏi danh sách bằng cách sử dụng chỉ mục cắt trong Python

Python cũng cung cấp một cách để loại bỏ phần tử cuối cùng khỏi danh sách bằng cách cắt lát. Cú pháp cho điều này như sau: list [:-1]. Ví dụ: nếu chúng ta có một danh sách các số nguyên gọi là my_list, chúng ta có thể xóa phần tử cuối cùng bằng cách sử dụng mã sau:

my_list = [1, 2, 3] my_list [:-1] # trả về [1, 2] #
my_list[:-1]
# Returns [1, 2] #

Cắt danh sách là một thực tế phổ biến và nó là kỹ thuật được sử dụng nhiều nhất cho các lập trình viên để giải quyết các vấn đề hiệu quả. Hãy xem xét một danh sách Python, theo đơn đặt hàng để truy cập vào một loạt các yếu tố trong danh sách, bạn cần cắt một danh sách. Một cách để làm điều này là sử dụng toán tử cắt lát đơn giản, tức là đại tràng (:)

Với toán tử này, người ta có thể chỉ định nơi bắt đầu cắt lát, nơi kết thúc và chỉ định bước. Danh sách cắt giảm trả về một danh sách mới từ danh sách hiện có.

Xóa phần tử cuối cùng khỏi danh sách bằng hàm del trong Python

Hàm del () xóa một phần tử khỏi danh sách. Cú pháp cho hàm này như sau: DEL (MYLIST [INDEX]) Ví dụ: nếu chúng ta có danh sách các số nguyên gọi là my_list, chúng ta có thể xóa phần tử cuối cùng bằng cách sử dụng mã sau:

my_list = [1, 2, 3] del (mylist [-1]) # return none # my_list bây giờ [1,2]
del(myList[-1])
# Returns None # my_list is now [1,2]

Hàm del () được sử dụng để xóa một phần tử khỏi danh sách. Điều quan trọng cần lưu ý là hàm del () không trả lại bất cứ điều gì, vì vậy điều quan trọng là phải kiểm tra xem việc xóa có thành công không. Ví dụ: nếu chúng ta có một danh sách các số nguyên gọi là my_list và chúng ta muốn xóa phần tử thứ hai khỏi danh sách, chúng ta có thể sử dụng mã sau:

my_list = [1, 2, 3] del (mylist [1]) # my_list bây giờ [1, 3]
del(myList[1])
# my_list is now [1, 3]

Ba phương pháp được mô tả ở trên là tất cả các cách để loại bỏ phần tử cuối cùng khỏi danh sách trong Python. Phương pháp nào bạn chọn sẽ phụ thuộc vào nhu cầu của bạn. Nếu bạn chỉ cần xóa phần tử cuối cùng khỏi danh sách, thì sử dụng hàm pop () có lẽ là cách hiệu quả nhất để làm điều này.

Tuy nhiên, nếu bạn cần xóa bất kỳ phần tử nào khỏi danh sách, thì sử dụng hàm del () có lẽ là cách hiệu quả nhất để làm điều này. Cuối cùng, nếu bạn cần xóa phần tử cuối cùng khỏi danh sách và bạn không quan tâm đến thứ tự của các phần tử trong danh sách, thì việc sử dụng cắt lát có lẽ là cách hiệu quả nhất để làm điều này.

Cảm ơn bạn đã đọc! Tôi hy vọng nó sẽ có ích! 🙂

Làm thế nào để bạn loại bỏ 2 yếu tố cuối cùng trong danh sách Python?

Làm cách nào để loại bỏ sự xuất hiện thứ hai khỏi danh sách trong Python?

Làm thế nào để bạn xóa phần tử cuối cùng trong danh sách Python?

Làm cách nào để loại bỏ 5 yếu tố cuối cùng khỏi danh sách?