>>> a=[1,2,3]
>>> a.remove(2)
>>> a
[1, 3]
>>> a=[1,2,3]
>>> del a[1]
>>> a
[1, 3]
>>> a= [1,2,3]
>>> a.pop(1)
2
>>> a
[1, 3]
>>> 

Có sự khác biệt nào giữa ba phương pháp trên để loại bỏ một phần tử khỏi danh sách không?

Có, removeloại bỏ cái đầu tiên giá trị khớp , không phải là một chỉ mục cụ thể:

>>> a = [0, 2, 3, 2]
>>> a.remove(2)
>>> a
[0, 3, 2]

del xóa mục tại một chỉ mục cụ thể:

>>> a = [9, 8, 7, 6]
>>> del a[1]
>>> a
[9, 7, 6]

và pop loại bỏ các mục tại một chỉ mục cụ thể và trả lại nó.

>>> a = [4, 3, 5]
>>> a.pop(1)
3
>>> a
[4, 5]

Các chế độ lỗi của chúng cũng khác nhau:

>>> a = [4, 5, 6]
>>> a.remove(7)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
>>> del a[7]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range
>>> a.pop(7)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: pop index out of range

Sử dụng delđể xóa một phần tử theo chỉ mục, pop()để xóa phần tử theo chỉ mục nếu bạn cần giá trị được trả về và remove()xóa phần tử theo giá trị. Cái sau yêu cầu tìm kiếm danh sách, và tăng ValueErrornếu không có giá trị như vậy xảy ra trong danh sách.

Khi xóa chỉ mục ikhỏi danh sách các nphần tử, độ phức tạp tính toán của các phương thức này là

del     O(n - i)
pop     O(n - i)
remove  O(n)

Vì không ai khác đã đề cập đến nó, lưu ý rằng del(không giống như pop) cho phép loại bỏ một loạt các chỉ mục vì cắt danh sách:

>>> lst = [3, 2, 2, 1]
>>> del lst[1:]
>>> lst
[3]

Điều này cũng cho phép tránh một IndexErrornếu chỉ mục không có trong danh sách:

>>> lst = [3, 2, 2, 1]
>>> del lst[10:]
>>> lst
[3, 2, 2, 1]

Đã được trả lời khá tốt bởi những người khác. Cái này từ cuối của tôi :)

Rõ ràng, poplà người duy nhất trả về giá trị và removelà người duy nhất tìm kiếm đối tượng, trong khi delgiới hạn bản thân trong một thao tác xóa đơn giản.

pop - Lấy chỉ số và trả về giá trị

xóa - Lấy giá trị, xóa lần xuất hiện đầu tiên và không trả lại gì

xóa - Lấy chỉ mục, xóa giá trị tại chỉ mục đó và không trả về

Nhiều lời giải thích tốt nhất ở đây nhưng tôi sẽ cố gắng hết sức để đơn giản hóa hơn nữa.

Trong số tất cả các phương thức này, Reverse & pop là postfix trong khi xóa là tiền tố .

tẩy(): Nó được sử dụng để loại bỏ sự xuất hiện đầu tiên của phần tử

remove(i) => lần xuất hiện đầu tiên của giá trị i

>>> a = [0, 2, 3, 2, 1, 4, 6, 5, 7]
>>> a.remove(2)   # where i = 2
>>> a
[0, 3, 2, 1, 4, 6, 5, 7]

pop (): Nó được sử dụng để loại bỏ phần tử nếu:

không xác định

pop() => từ cuối danh sách

>>>a.pop()
>>>a
[0, 3, 2, 1, 4, 6, 5]

được chỉ định

pop(index) => của chỉ mục

>>>a.pop(2)
>>>a
[0, 3, 1, 4, 6, 5]

CẢNH BÁO: Phương pháp nguy hiểm Trước mắt

xóa bỏ() : Đây là một phương thức tiền tố.

Theo dõi hai cú pháp khác nhau cho cùng một phương thức: [] và (). Nó có sức mạnh để:

1. Chỉ số hoàn thành

del a[index] => được sử dụng để xóa chỉ mục và giá trị liên quan của nó giống như pop.

>>>del a[1]
>>>a
[0, 1, 4, 6, 5]

2. Xóa các giá trị trong phạm vi [chỉ mục 1: chỉ mục N]

del a[0:3] => nhiều giá trị trong phạm vi

>>>del a[0:3]
>>>a
[6, 5]

3.Last nhưng không liệt kê, để xóa toàn bộ danh sách trong một shot

del (a) => như đã nói ở trên.

>>>del (a)
>>>a

Hy vọng điều này làm rõ sự nhầm lẫn nếu có.

Bất kỳ hoạt động / chức năng trên các cấu trúc dữ liệu khác nhau được xác định cho các hành động cụ thể. Ở đây trong trường hợp của bạn tức là loại bỏ một yếu tố, xóa, Pop và xóa. (Nếu bạn xem xét các bộ, Thêm thao tác khác - loại bỏ) Trường hợp khó hiểu khác là trong khi thêm. Chèn / Nối. Để trình diễn, hãy để chúng tôi thực hiện deque. deque là một cấu trúc dữ liệu tuyến tính lai, nơi bạn có thể thêm các phần tử / loại bỏ các phần tử từ cả hai đầu. (Phía sau và kết thúc trước)

class Deque(object):

  def __init__(self):

    self.items=[]

  def addFront(self,item):

    return self.items.insert(0,item)
  def addRear(self,item):

    return self.items.append(item)
  def deleteFront(self):

    return self.items.pop(0)
  def deleteRear(self):
    return self.items.pop()
  def returnAll(self):

    return self.items[:]

Tại đây, xem các hoạt động:

def deleteFront(self):

    return self.items.pop(0)
def deleteRear(self):
    return self.items.pop()

Hoạt động phải trả lại một cái gì đó. Vì vậy, pop - Có và không có chỉ mục. Nếu tôi không muốn trả về giá trị: del self.items [0]

Xóa theo giá trị không phải là Index:

• tẩy :

  list_ez=[1,2,3,4,5,6,7,8]
  for i in list_ez:
      if i%2==0:
          list_ez.remove(i)
  print list_ez

Trả về [1,3,5,7]

Hãy để chúng tôi xem xét trường hợp của bộ.

set_ez=set_ez=set(range(10))

set_ez.remove(11)

# Gives Key Value Error. 
##KeyError: 11

set_ez.discard(11)

# Does Not return any errors.

Trong khi bật và xóa cả hai chỉ số để loại bỏ một yếu tố như đã nêu trong các ý kiến ​​trên. Một sự khác biệt chính là sự phức tạp thời gian cho họ. Độ phức tạp thời gian cho pop () không có chỉ số là O (1) nhưng không phải là trường hợp tương tự để xóa phần tử cuối cùng.

Nếu trường hợp sử dụng của bạn luôn là để xóa phần tử cuối cùng, thì tốt hơn hết là sử dụng pop () thay vì xóa (). Để giải thích thêm về độ phức tạp thời gian, bạn có thể tham khảo https://www.ics.uci.edu/~pattis/ICS-33/lectures/complexitypython.txt

Các hoạt động loại bỏ trên một danh sách được đưa ra một giá trị để loại bỏ. Nó tìm kiếm danh sách để tìm một mục có giá trị đó và xóa mục phù hợp đầu tiên mà nó tìm thấy. Đó là một lỗi nếu không có mục phù hợp, làm tăng ValueError .

>>> x = [1, 0, 0, 0, 3, 4, 5]
>>> x.remove(4)
>>> x
[1, 0, 0, 0, 3, 5]
>>> del x[7]
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    del x[7]
IndexError: list assignment index out of range

Câu lệnh del có thể được sử dụng để xóa toàn bộ danh sách. Nếu bạn có một mục danh sách cụ thể làm đối số của bạn để del (ví dụ: listname [7] để tham chiếu cụ thể mục thứ 8 trong danh sách), nó sẽ xóa mục đó. Thậm chí có thể xóa một "lát" khỏi danh sách. Đó là một lỗi nếu có chỉ mục nằm ngoài phạm vi, làm tăng IndexError .

>>> x = [1, 2, 3, 4]
>>> del x[3]
>>> x
[1, 2, 3]
>>> del x[4]
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    del x[4]
IndexError: list assignment index out of range

Việc sử dụng thông thường của pop là xóa mục cuối cùng khỏi danh sách khi bạn sử dụng danh sách dưới dạng ngăn xếp. Không giống như del, pop trả về giá trị mà nó bật ra khỏi danh sách. Bạn có thể tùy ý đưa ra một giá trị chỉ mục cho pop và pop từ ngoài danh sách (ví dụ listname.pop (0) sẽ xóa mục đầu tiên khỏi danh sách và trả về mục đầu tiên đó làm kết quả). Bạn có thể sử dụng điều này để làm cho danh sách hoạt động giống như một hàng đợi, nhưng có các thói quen thư viện có sẵn có thể cung cấp các hoạt động hàng đợi với hiệu suất tốt hơn so với pop (0). Đó là một lỗi nếu có chỉ mục nằm ngoài phạm vi, làm tăng IndexError .

>>> x = [1, 2, 3] 
>>> x.pop(2) 
3 
>>> x 
[1, 2]
>>> x.pop(4)
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    x.pop(4)
IndexError: pop index out of range

Xem bộ sưu tập.deque để biết thêm chi tiết.

Loại bỏ về cơ bản hoạt động trên giá trị. Xóa và bật công việc trên chỉ mục

Loại bỏ về cơ bản loại bỏ giá trị phù hợp đầu tiên. Xóa xóa mục khỏi một chỉ mục cụ thể Pop về cơ bản lấy một chỉ mục và trả về giá trị tại chỉ mục đó. Lần tới khi bạn in danh sách, giá trị không xuất hiện.

Bạn cũng có thể sử dụng remove để xóa giá trị theo chỉ mục.

n = [1, 3, 5]

n.remove(n[1])

n sau đó sẽ đề cập đến [1, 5]