Sự khác biệt giữa các phương pháp danh sách append()và là extend()gì?

append: Nối đối tượng ở cuối.

x = [1, 2, 3]
x.append([4, 5])
print (x)

mang đến cho bạn: [1, 2, 3, [4, 5]]

extend: Mở rộng danh sách bằng cách nối thêm các phần tử từ iterable.

x = [1, 2, 3]
x.extend([4, 5])
print (x)

mang đến cho bạn: [1, 2, 3, 4, 5]

appendthêm một phần tử vào danh sách và extendnối danh sách đầu tiên với một danh sách khác (hoặc một lần lặp khác, không nhất thiết phải là danh sách.)

>>> li = ['a', 'b', 'mpilgrim', 'z', 'example']
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']

>>> li.append("new")
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new']

>>> li.append(["new", 2])
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]

>>> li.insert(2, "new")
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]

>>> li.extend(["two", "elements"])
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', ['new', 2], 'two', 'elements']

Sự khác biệt giữa các phương pháp danh sách nối và mở rộng là gì?

• appendthêm đối số của nó dưới dạng một phần tử vào cuối danh sách. Độ dài của danh sách sẽ tăng thêm một.
• extendLặp lại đối số của nó thêm từng phần tử vào danh sách, mở rộng danh sách. Độ dài của danh sách sẽ tăng lên tuy nhiên nhiều yếu tố nằm trong đối số lặp lại.

append

Các list.appendphương pháp gắn thêm một đối tượng vào cuối danh sách.

my_list.append(object) 

Dù đối tượng là gì, cho dù một số, một chuỗi, một danh sách khác hoặc một cái gì đó khác, nó sẽ được thêm vào cuối của my_listmột mục trong danh sách.

>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']

Vì vậy, hãy nhớ rằng một danh sách là một đối tượng. Nếu bạn thêm một danh sách khác vào danh sách, danh sách đầu tiên sẽ là một đối tượng ở cuối danh sách (có thể không phải là điều bạn muốn):

>>> another_list = [1, 2, 3]
>>> my_list.append(another_list)
>>> my_list
['foo', 'bar', 'baz', [1, 2, 3]]
                     #^^^^^^^^^--- single item at the end of the list.

extend

Các list.extendphương pháp mở rộng danh sách bằng cách thêm các yếu tố từ một iterable:

my_list.extend(iterable)

Vì vậy, với phần mở rộng, mỗi phần tử của iterable sẽ được thêm vào danh sách. Ví dụ:

>>> my_list
['foo', 'bar']
>>> another_list = [1, 2, 3]
>>> my_list.extend(another_list)
>>> my_list
['foo', 'bar', 1, 2, 3]

Hãy nhớ rằng một chuỗi là một lần lặp, vì vậy nếu bạn mở rộng danh sách bằng một chuỗi, bạn sẽ nối thêm từng ký tự khi bạn lặp qua chuỗi (có thể không phải là điều bạn muốn):

>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']

Toán tử quá tải, __add__( +) và __iadd__( +=)

Cả hai +và +=toán tử được định nghĩa cho list. Họ là tương tự về mặt ngữ nghĩa để mở rộng.

my_list + another_list tạo một danh sách thứ ba trong bộ nhớ, vì vậy bạn có thể trả về kết quả của nó, nhưng nó yêu cầu lần lặp thứ hai là một danh sách.

my_list += another_listsửa đổi danh sách tại chỗ (nó là toán tử tại chỗ và các danh sách là các đối tượng có thể thay đổi, như chúng ta đã thấy) để nó không tạo ra một danh sách mới. Nó cũng hoạt động như mở rộng, trong đó lần lặp thứ hai có thể là bất kỳ loại lặp nào.

Đừng nhầm lẫn - my_list = my_list + another_listkhông tương đương với +=- nó cung cấp cho bạn một danh sách hoàn toàn mới được gán cho my_list.

Độ phức tạp thời gian

Nối có độ phức tạp thời gian không đổi , O (1).

Kéo dài có độ phức tạp thời gian, O (k).

Lặp lại qua nhiều lệnh gọi để appendtăng thêm độ phức tạp, làm cho nó tương đương với phần mở rộng và vì việc lặp lại của phần mở rộng được thực hiện trong C, sẽ luôn nhanh hơn nếu bạn có ý định thêm các mục liên tiếp từ một lần lặp vào danh sách.

Hiệu suất

Bạn có thể tự hỏi những gì là hiệu suất cao hơn, vì phụ lục có thể được sử dụng để đạt được kết quả tương tự như mở rộng. Các chức năng sau đây làm điều tương tự:

def append(alist, iterable):
    for item in iterable:
        alist.append(item)

def extend(alist, iterable):
    alist.extend(iterable)

Vì vậy, hãy dành thời gian cho họ:

import timeit

>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
2.867846965789795
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))
0.8060121536254883

Giải quyết một bình luận về thời gian

Một bình luận cho biết:

Câu trả lời hoàn hảo, tôi chỉ bỏ lỡ thời điểm so sánh chỉ thêm một yếu tố

Làm điều đúng ngữ nghĩa. Nếu bạn muốn nối tất cả các thành phần trong một lần lặp, hãy sử dụng extend. Nếu bạn chỉ thêm một yếu tố, hãy sử dụng append.

Ok, vậy hãy tạo một thử nghiệm để xem cách thức hoạt động của nó kịp thời:

def append_one(a_list, element):
    a_list.append(element)

def extend_one(a_list, element):
    """creating a new list is semantically the most direct
    way to create an iterable to give to extend"""
    a_list.extend([element])

import timeit

Và chúng tôi thấy rằng việc cố gắng tạo ra một vòng lặp chỉ để sử dụng kéo dài là một sự lãng phí thời gian (nhỏ):

>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295

Chúng tôi học được điều này rằng không có gì đạt được từ việc sử dụng extendkhi chúng tôi chỉ có một yếu tố để nối thêm.

Ngoài ra, những thời gian này không quan trọng. Tôi chỉ cho họ thấy rằng, trong Python, làm điều đúng đắn về mặt ngữ nghĩa là thực hiện mọi thứ theo cách đúng đắn ™.

Có thể hình dung rằng bạn có thể kiểm tra thời gian trên hai hoạt động tương đương và nhận được kết quả không rõ ràng hoặc nghịch đảo. Chỉ cần tập trung vào việc làm điều đúng ngữ nghĩa.

Phần kết luận

Chúng ta thấy rằng extendlà ngữ nghĩa rõ ràng hơn, và rằng nó có thể chạy nhanh hơn nhiều so append, khi bạn có ý định thêm mỗi phần tử trong một iterable vào một danh sách.

Nếu bạn chỉ có một phần tử duy nhất (không có trong một lần lặp) để thêm vào danh sách, hãy sử dụng append.

appendnối thêm một yếu tố extendnối thêm một danh sách các yếu tố

Lưu ý rằng nếu bạn vượt qua một danh sách để chắp thêm, nó vẫn thêm một yếu tố:

>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]

Nối với mở rộng

Với phần bổ sung, bạn có thể nối thêm một phần tử sẽ mở rộng danh sách:

>>> a = [1,2]
>>> a.append(3)
>>> a
[1,2,3]

Nếu bạn muốn mở rộng nhiều hơn một phần tử, bạn nên sử dụng phần mở rộng, bởi vì bạn chỉ có thể nối thêm một phần tử hoặc một danh sách các phần tử:

>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]

Vì vậy, bạn có được một danh sách lồng nhau

Thay vì mở rộng, bạn có thể mở rộng một yếu tố như thế này

>>> a = [1,2]
>>> a.extend([3])
>>> a
[1,2,3]

Hoặc, khác nhau, từ nối thêm, mở rộng nhiều phần tử trong một lần mà không lồng danh sách vào danh sách gốc (đó là lý do của tên mở rộng)

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

Thêm một yếu tố với cả hai phương thức

Cả chắp thêm và mở rộng có thể thêm một yếu tố vào cuối danh sách, mặc dù việc nối thêm đơn giản hơn.

nối 1 phần tử

>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]

mở rộng một yếu tố

>>> x = [1,2]
>>> x.extend([3])
>>> x
[1,2,3]

Thêm nhiều yếu tố ... với các kết quả khác nhau

Nếu bạn sử dụng nối thêm nhiều phần tử, bạn phải chuyển danh sách các phần tử làm đối số và bạn sẽ có được danh sách NESTED!

>>> x = [1,2]
>>> x.append([3,4])
>>> x
[1,2,[3,4]]

Với phần mở rộng, thay vào đó, bạn chuyển một danh sách dưới dạng đối số, nhưng bạn sẽ có được một danh sách với phần tử mới không được lồng trong danh sách cũ.

>>> z = [1,2] 
>>> z.extend([3,4])
>>> z
[1,2,3,4]

Vì vậy, với nhiều yếu tố hơn, bạn sẽ sử dụng phần mở rộng để có được danh sách có nhiều mục hơn. Tuy nhiên, việc thêm một danh sách sẽ không thêm nhiều phần tử vào danh sách, mà là một phần tử là danh sách lồng nhau như bạn có thể thấy rõ trong đầu ra của mã.

Hai đoạn mã sau tương đương về mặt ngữ nghĩa:

for item in iterator:
    a_list.append(item)

và

a_list.extend(iterator)

Cái sau có thể nhanh hơn khi vòng lặp được thực hiện trong C.

Các append()phương pháp bổ sung thêm một mục duy nhất đến cuối danh sách.

x = [1, 2, 3]
x.append([4, 5])
x.append('abc')
print(x)
# gives you
[1, 2, 3, [4, 5], 'abc']

Các extend()phương pháp có một đối số, một danh sách, và gắn thêm mỗi mục của các đối số vào danh sách gốc. (Danh sách được triển khai dưới dạng các lớp. Tạo ra một danh sách thực sự bắt đầu một lớp. Như vậy, một danh sách có các phương thức hoạt động trên nó.)

x = [1, 2, 3]
x.extend([4, 5])
x.extend('abc')
print(x)
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']

Từ lặn vào Python .

Bạn có thể sử dụng "+" để trả về gia hạn, thay vì mở rộng tại chỗ.

l1=range(10)

l1+[11]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11]

l2=range(10,1,-1)

l1+l2

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2]

Tương tự như vậy +=đối với hành vi tại chỗ, nhưng với sự khác biệt nhỏ từ append& extend. Một trong những khác biệt lớn nhất của +=từ appendvà extendlà khi nó được sử dụng trong phạm vi chức năng, xem bài viết trên blog này .

append(object) - Cập nhật danh sách bằng cách thêm một đối tượng vào danh sách.

x = [20]
# List passed to the append(object) method is treated as a single object.
x.append([21, 22, 23])
# Hence the resultant list length will be 2
print(x)
--> [20, [21, 22, 23]]

extend(list) - Chủ yếu nối hai danh sách.

x = [20]
# The parameter passed to extend(list) method is treated as a list.
# Eventually it is two lists being concatenated.
x.extend([21, 22, 23])
# Here the resultant list's length is 4
print(x)
[20, 21, 22, 23]

extend()có thể được sử dụng với một đối số lặp. Đây là một ví dụ. Bạn muốn tạo một danh sách ra khỏi danh sách các danh sách theo cách này:

Từ

list2d = [[1,2,3],[4,5,6], [7], [8,9]]

bạn muốn

>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Bạn có thể sử dụng itertools.chain.from_iterable()để làm như vậy. Đầu ra của phương thức này là một trình vòng lặp. Việc thực hiện của nó tương đương với

def from_iterable(iterables):
    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

Quay lại ví dụ của chúng tôi, chúng tôi có thể làm

import itertools
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))

và có được danh sách mong muốn.

Đây là cách tương đương extend()có thể được sử dụng với một đối số lặp:

merged = []
merged.extend(itertools.chain.from_iterable(list2d))
print(merged)
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Đây là tương đương appendvà extendsử dụng +toán tử:

>>> x = [1,2,3]
>>> x
[1, 2, 3]
>>> x = x + [4,5,6] # Extend
>>> x
[1, 2, 3, 4, 5, 6]
>>> x = x + [[7,8]] # Append
>>> x
[1, 2, 3, 4, 5, 6, [7, 8]]

append () : Về cơ bản, nó được sử dụng trong Python để thêm một phần tử.

Ví dụ 1:

>> a = [1, 2, 3, 4]
>> a.append(5)
>> print(a)
>> a = [1, 2, 3, 4, 5]

Ví dụ 2:

>> a = [1, 2, 3, 4]
>> a.append([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, [5, 6]]

extend () : Trong đó extend (), được sử dụng để hợp nhất hai danh sách hoặc chèn nhiều phần tử vào một danh sách.

Ví dụ 1:

>> a = [1, 2, 3, 4]
>> b = [5, 6, 7, 8]
>> a.extend(b)
>> print(a)
>> a = [1, 2, 3, 4, 5, 6, 7, 8]

Ví dụ 2:

>> a = [1, 2, 3, 4]
>> a.extend([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, 5, 6]

Một điểm thú vị đã được gợi ý, nhưng không được giải thích, đó là mở rộng nhanh hơn so với nối thêm. Đối với bất kỳ vòng lặp nào có phần bổ sung bên trong nên được coi là được thay thế bởi list.extend (process_elements).

Hãy nhớ rằng việc bổ sung các yếu tố mới có thể dẫn đến việc sắp xếp lại toàn bộ danh sách vào một vị trí tốt hơn trong bộ nhớ. Nếu điều này được thực hiện nhiều lần vì chúng tôi đang nối thêm 1 phần tử cùng một lúc, hiệu suất tổng thể bị ảnh hưởng. Theo nghĩa này, list.extend tương tự như "" .join (danh sách chuỗi).

Nối thêm toàn bộ dữ liệu cùng một lúc. Toàn bộ dữ liệu sẽ được thêm vào chỉ mục mới được tạo. Mặt khác extend, như tên gọi của nó, mở rộng mảng hiện tại.

Ví dụ

list1 = [123, 456, 678]
list2 = [111, 222]

Với appendchúng tôi nhận được:

result = [123, 456, 678, [111, 222]]

Trong khi trên extendchúng tôi nhận được:

result = [123, 456, 678, 111, 222]

Một từ điển tiếng Anh định nghĩa các từ appendvà extendnhư:

chắp thêm : thêm (một cái gì đó) vào cuối của một tài liệu bằng văn bản.
mở rộng : làm cho lớn hơn. Phóng to hoặc mở rộng

Với kiến ​​thức đó, bây giờ hãy hiểu

1) Sự khác biệt giữa appendvàextend

append:

• Nối bất kỳ đối tượng Python nào vào cuối danh sách (nghĩa là phần tử cuối cùng trong danh sách).
• Danh sách kết quả có thể được lồng nhau và chứa các phần tử không đồng nhất (ví dụ: danh sách, chuỗi, bộ dữ liệu, từ điển, bộ, v.v.)

extend:

• Chấp nhận bất kỳ lần lặp nào làm đối số của nó và làm cho danh sách lớn hơn .
• Danh sách kết quả luôn là danh sách một chiều (nghĩa là không lồng nhau) và nó có thể chứa các phần tử không đồng nhất trong đó (ví dụ: ký tự, số nguyên, dấu phẩy) do áp dụng list(iterable).

2) Sự tương đồng giữa appendvàextend

• Cả hai có chính xác một đối số.
• Cả hai sửa đổi danh sách tại chỗ .
• Kết quả là cả hai trở về None.

Thí dụ

lis = [1, 2, 3]

# 'extend' is equivalent to this
lis = lis + list(iterable)

# 'append' simply appends its argument as the last element to the list
# as long as the argument is a valid Python object
list.append(object)

Tôi hy vọng tôi có thể bổ sung hữu ích cho câu hỏi này. Ví dụ Info, nếu danh sách của bạn lưu trữ một đối tượng loại cụ thể, thì đây là tình huống mà extendphương thức không phù hợp: Trong một forvòng lặp và tạo một Infođối tượng mỗi lần và sử dụng extendđể lưu trữ nó vào danh sách của bạn, nó sẽ thất bại. Ngoại lệ như dưới đây:

LoạiError: Đối tượng 'Thông tin' không thể lặp lại

Nhưng nếu bạn sử dụng appendphương pháp, kết quả là OK. Bởi vì mỗi lần sử dụng extendphương thức, nó sẽ luôn coi nó như một danh sách hoặc bất kỳ loại bộ sưu tập nào khác, lặp lại nó và đặt nó sau danh sách trước đó. Một đối tượng cụ thể không thể được lặp đi lặp lại, rõ ràng.

Để phân biệt chúng bằng trực giác

l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]

Nó giống như l1tái tạo một cơ thể bên trong cơ thể cô ấy (lồng nhau).

# Reset l1 = ['a', 'b', 'c']
l1.extend(l2)
l1
['a', 'b', 'c', 'd', 'e', 'f']

Giống như hai cá thể tách biệt kết hôn và xây dựng một gia đình thống nhất.

Bên cạnh đó, tôi tạo ra một bộ quần áo đầy đủ tất cả các phương pháp của danh sách để bạn tham khảo.

list_methods = {'Add': {'extend', 'append', 'insert'},
                'Remove': {'pop', 'remove', 'clear'}
                'Sort': {'reverse', 'sort'},
                'Search': {'count', 'index'},
                'Copy': {'copy'},
                }

extend(L)mở rộng danh sách bằng cách nối thêm tất cả các mục trong danh sách đã cho L.

>>> a
[1, 2, 3]
a.extend([4])  #is eqivalent of a[len(a):] = [4]
>>> a
[1, 2, 3, 4]
a = [1, 2, 3]
>>> a
[1, 2, 3]
>>> a[len(a):] = [4]
>>> a
[1, 2, 3, 4]

append"mở rộng" danh sách (tại chỗ) chỉ bằng một mục , đối tượng duy nhất được thông qua (dưới dạng đối số).

extend"Mở rộng" danh sách (tại chỗ) bằng số lượng mục mà đối tượng được truyền (dưới dạng đối số) chứa.

Điều này có thể hơi khó hiểu cho strcác đối tượng.

1. Nếu bạn truyền một chuỗi dưới dạng đối số: appendsẽ thêm một mục chuỗi ở cuối nhưng extendsẽ thêm nhiều mục "đơn" 'str' theo chiều dài của chuỗi đó.
2. Nếu bạn chuyển một danh sách các chuỗi làm đối số: appendvẫn sẽ thêm một mục 'danh sách' ở cuối và extendsẽ thêm bao nhiêu mục 'danh sách' theo độ dài của danh sách đã qua.

def append_o(a_list, element):
    a_list.append(element)
    print('append:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()

def extend_o(a_list, element):
    a_list.extend(element)
    print('extend:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()
append_o(['ab'],'cd')

extend_o(['ab'],'cd')
append_o(['ab'],['cd', 'ef'])
extend_o(['ab'],['cd', 'ef'])
append_o(['ab'],['cd'])
extend_o(['ab'],['cd'])

sản xuất:

append: ab,cd,
extend: ab,c,d,
append: ab,['cd', 'ef'],
extend: ab,cd,ef,
append: ab,['cd'],
extend: ab,cd,

Nối và mở rộng là một trong những cơ chế mở rộng trong python.

Nối thêm: Thêm một phần tử vào cuối danh sách.

my_list = [1,2,3,4]

Để thêm một yếu tố mới vào danh sách, chúng ta có thể sử dụng phương thức chắp thêm theo cách sau.

my_list.append(5)

Vị trí mặc định mà phần tử mới sẽ được thêm vào luôn ở vị trí (độ dài + 1).

Chèn: Phương pháp chèn đã được sử dụng để khắc phục các hạn chế của chắp thêm. Với insert, chúng ta có thể xác định rõ ràng vị trí chính xác mà chúng ta muốn phần tử mới của chúng ta được chèn vào.

Mô tả phương thức chèn (chỉ mục, đối tượng). Phải có hai đối số, đầu tiên là chỉ mục chúng ta muốn chèn phần tử của mình và thứ hai là phần tử.

Example: my_list = [1,2,3,4]
my_list[4, 'a']
my_list
[1,2,3,4,'a']

Mở rộng: Điều này rất hữu ích khi chúng tôi muốn tham gia hai hoặc nhiều danh sách vào một danh sách. Nếu không mở rộng, nếu chúng ta muốn tham gia hai danh sách, đối tượng kết quả sẽ chứa danh sách danh sách.

a = [1,2]
b = [3]
a.append(b)
print (a)
[1,2,[3]]

Nếu chúng ta cố gắng truy cập phần tử ở vị trí 2, chúng ta sẽ nhận được một danh sách ([3]), thay vì phần tử. Để tham gia hai danh sách, chúng tôi sẽ phải sử dụng phụ lục.

a = [1,2]
b = [3]
a.extend(b)
print (a)
[1,2,3]

Để tham gia nhiều danh sách

a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]