Hướng dẫn python append vs extend performance - python append và mở rộng hiệu suất

Trong Python, sự khác biệt giữa phương thức expend () và extend () là:append() and extend() method is that:

• Phương thức append () thêm một phần tử vào cuối danh sách.append() method adds a single element to the end of a list.
• Phương thức mở rộng () thêm nhiều mục.extend() method adds multiple items.

Dưới đây là một bảng gian lận nhanh chóng mô tả sự khác biệt.

Trong hướng dẫn toàn diện này, bạn sẽ xem xét chi tiết về sự khác biệt giữa append () và extend ().append() and extend().

append () vs extend (): tổng quan

Trong Python, một danh sách là một loại dữ liệu có thể thay đổi được sử dụng để lưu trữ các yếu tố. Danh sách hỗ trợ dễ dàng truy cập vào các yếu tố. Bạn có thể thêm, cập nhật và xóa các mục.

Trong Python, bạn cần phải đối phó với danh sách rất nhiều.

Khi làm việc với một danh sách, bạn thường muốn thêm các yếu tố vào nó sau khi tạo.

Ví dụ: nếu danh sách của bạn đại diện cho một hàng đợi cho một bữa trưa, bạn muốn có thể thêm/xóa người tham gia bất cứ lúc nào.

Trong hướng dẫn này, chúng tôi sẽ tập trung vào hai cách để thêm các yếu tố vào cuối (phía bên phải) của một danh sách:

• Phương thức append ().append() method.
• Phương thức mở rộng (). extend() method.

Các phương pháp này được tích hợp vào kiểu dữ liệu danh sách.list data type.

Hãy bắt đầu thêm các phần tử vào danh sách với phương thức append ().append() method.

Loại danh sách Python hỗ trợ phương thức append (). Phương pháp này thêm một phần tử vào phần cuối (phía bên phải) của một danh sách hiện có.append() method. This method adds an element to the end (right-hand side) of an existing list.

Cú pháp cho phương thức phụ lục là:

list.append(element)

Where:

• Danh sách là danh sách hiện có mà chúng tôi muốn thêm một phần tử. is the existing list to which we want to add an element.
• Phần tử là phần tử được thêm vào cuối danh sách. is the element to be added to the end of list.

Phương pháp này chỉ chấp nhận một đối số tại một thời điểm. Nói cách khác, bạn không thể thêm nhiều yếu tố cùng một lúc.

Có lẽ cách phổ biến nhất để sử dụng phương thức append () là bằng cách thêm một giá trị duy nhất vào cuối danh sách.append() method is by adding a single value to the end of a list.

ví dụ 1

Ví dụ: hãy để thêm một số vào cuối danh sách các số:

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

print(a)

Output:

[1, 2, 3, 4]

Như bạn có thể thấy, danh sách các số ban đầu đã được cập nhật và bây giờ có thêm một số ở cuối của nó.

Ví dụ 2

Một ví dụ khác, hãy để cố gắng thêm nhiều số vào danh sách các số bằng phương thức append ().append() method.

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

print(a)

Như đã đề cập, phương thức append () không mất nhiều hơn một đối số. Do đó, việc làm điều này dẫn đến một lỗi:append() method does not take more than one argument. Thus, doing this results in an error:

TypeError: append() takes exactly one argument (2 given)

Tại thời điểm này, bạn có thể xem xét một cách giải quyết của việc thêm nhiều số làm danh sách.

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

print(a)

Output:

1.42491698265
0.657584905624

Nhưng như bạn có thể thấy, điều này không hoạt động như bạn muốn.

Thay vì thêm các phần tử một cách riêng biệt, phương thức append () chỉ cần thêm toàn bộ danh sách vào cuối danh sách khác như một phần tử duy nhất.append() method just adds the whole list to the end of the other list as a single element.

Vì vậy, bây giờ danh sách các số bao gồm ba số và một danh sách các số.

Nếu bạn muốn thêm nhiều phần tử vào danh sách bằng phương thức append (), bạn cần tạo một vòng lặp. append() method, you need to create a loop.

Ví dụ 3

Hãy để thêm nhiều phần tử vào cuối danh sách với một vòng lặp và phương thức append ():append() method:

1.42491698265
0.657584905624

Output:

1.42491698265
0.657584905624

Bây giờ các con số được thêm vào cuối danh sách theo cách bạn muốn.

Tuy nhiên, vì việc thêm nhiều yếu tố trong một lần là một điều phổ biến cần làm, có một phương pháp riêng để làm điều đó.

Để thêm nhiều phần tử vào cuối danh sách, hãy sử dụng phương thức Extend ().extend() method.

extend()

Trong Python, bạn có thể sử dụng phương thức Extend () để thêm nhiều phần tử vào cuối danh sách. Tương tự như phương thức append (), phương thức mở rộng () sửa đổi danh sách ban đầu.extend() method to add multiple elements to the end of a list. Similar to the append() method, the extend() method modifies the original list.

Cú pháp của phương thức mở rộng () là: extend() method is:

1.42491698265
0.657584905624

Where:

• Danh sách là tên của danh sách bạn muốn thêm các yếu tố vào. is the name of the list you want to add elements to.
• Các yếu tố là một điều không thể thay đổi, chẳng hạn như một danh sách, có các yếu tố bạn muốn thêm vào cuối danh sách. is an iterable, such as a list, that has the elements you want to add to the end of list.

Đằng sau hậu trường, phương thức mở rộng () các vòng lặp thông qua các yếu tố được cung cấp dưới dạng đối số và thêm chúng vào cuối danh sách.extend() method loops through the elements provided as arguments and adds them to the end of the list.

Một trường hợp sử dụng phổ biến cho phương thức mở rộng () là thêm một số phần tử vào danh sách hiện có. extend() method is to add a number of elements to an existing list.

ví dụ 1

Ví dụ: hãy để thêm một số vào cuối danh sách các số:

1.42491698265
0.657584905624

Output:

1.42491698265
0.657584905624

Như bạn có thể thấy, danh sách các số ban đầu đã được cập nhật và bây giờ có thêm một số ở cuối của nó.append() method you saw in the previous chapter.

Ví dụ 2extend() function argument does not need to be a list. As I mentioned, it can be any iterable type in Python.

Một ví dụ khác, hãy để cố gắng thêm nhiều số vào danh sách các số bằng phương thức append ().

Như đã đề cập, phương thức append () không mất nhiều hơn một đối số. Do đó, việc làm điều này dẫn đến một lỗi:

Tại thời điểm này, bạn có thể xem xét một cách giải quyết của việc thêm nhiều số làm danh sách.extend() method.

Ví dụ 2

Một ví dụ khác, hãy để cố gắng thêm nhiều số vào danh sách các số bằng phương thức append ().

1.42491698265
0.657584905624

Output:

1.42491698265
0.657584905624

Ví dụ 3

Hãy để thêm nhiều phần tử vào cuối danh sách với một vòng lặp và phương thức append ():extend() method:

1.42491698265
0.657584905624

Output:

1.42491698265
0.657584905624

Điều này hoạt động bởi vì một chuỗi là có thể sử dụng được. Nói cách khác, một chuỗi là một chuỗi các ký tự.

Trong mã trên, phương thức mở rộng () các vòng lặp qua ký tự chuỗi theo ký tự và thêm từng ký tự vào cuối danh sách.extend() method loops through the string character by character and adds each character to the end of the list.

Lưu ý rằng bạn không thể mở rộng một phần tử duy nhất với phương thức mở rộng (). Điều này là do loại đối số cần phải có thể sử dụng được, nghĩa là, một cái gì đó có thể được lặp đi quaextend() method. This is because the type of argument needs to be iterable, that is, something that can be looped through

Ví dụ 4

Ví dụ, một số nguyên không thể được lặp qua. Do đó, việc thêm một số nguyên bằng cách sử dụng phương thức mở rộng () không thành công.extend() method fails.

Đây là một minh họa:

Để thêm một phần tử duy nhất với phương thức mở rộng (), bạn cần đặt phần tử vào một điều khác.extend() method, you need to place the element into an iterable.

Ví dụ 5

Hãy để sử dụng phương thức mở rộng () để thêm một phần tử vào cuối danh sách. Để làm điều này, yếu tố cần được gói bên trong một điều không thể.extend() method to add a single element to the end of a list. To do this, the element needs to be wrapped inside of an iterable.

import timeit

def append_loop(foo, reps):
    for i in range(reps):
        foo.append(i)

def append_comp(foo, reps):
    [foo.append(i) for i in range(reps)]

def extend_lst(foo, reps):
    foo.extend([i for i in range(reps)])

def extend_tup(foo, reps):
    foo.extend((i for i in range(reps)))

repetitions = 600

print timeit.timeit('append_loop([], repetitions)', setup='from __main__ import append_loop, repetitions')
print timeit.timeit('append_comp([], repetitions)', setup='from __main__ import append_comp, repetitions')
print timeit.timeit('extend_lst([], repetitions)', setup='from __main__ import extend_lst, repetitions')
print timeit.timeit('extend_tup([], repetitions)', setup='from __main__ import extend_tup, repetitions')

Output:

[1, 2, 3, 4]

Tuy nhiên, thay vì thực hiện theo cách này, hãy sử dụng phương thức append () vì nó phù hợp hơn về mặt ngữ nghĩa.append() method as it is semantically more appropriate.

Tóm tắt lại

Tại thời điểm này, bạn nên có một sự hiểu biết tốt về cách các phương thức expend () và mở rộng () hoạt động trong Python. append() and extend() methods work in Python.

Tóm lại, sự khác biệt giữa các phương thức expend () và extend () là:append() and extend() methods is:

• Phương thức append () thêm một phần tử duy nhất vào danh sách.append() method adds a single element to a list.
• Phương thức mở rộng () thêm nhiều phần tử vào danh sách.extend() method adds multiple elements to a list.

Tiếp theo, hãy để Lôi xem xét hiệu suất của các phương pháp này bằng cách chạy các thử nghiệm đơn giản.

Hiệu suất: expend () vs extend ()

Dựa trên ví dụ trước, bạn có thể thực hiện những điều tương tự bằng cách sử dụng append () và extend ().append() and extend().

Để thêm nhiều yếu tố, bạn có thể sử dụng:

• Mở rộng () bằng cách cho nó một lập luận có thể lặp lại. by giving it an iterable argument.
• append () bằng cách lặp thông qua một phần tử và nối riêng từng phần tử. by looping through an iterable and appending each element separately.

Tương tự như vậy, để thêm một phần tử vào cuối danh sách, bạn có thể sử dụng:

• Phương thức nối () bằng cách chuyển phần tử đơn như một đối số. method by passing the single element as an argument.
• Mở rộng phương thức () bằng cách gói phần tử duy nhất thành một thứ có thể lặp lại và chuyển nó như một đối số. method by wrapping the single element into an iterable and passing it as an argument.

Điều này có thể khiến bạn tự hỏi làm thế nào các phương pháp này so với nhau khi nói đến hiệu suất.

Hãy để so sánh các hiệu suất của các phương thức expend () và extend () bằng cách chạy các thử nghiệm đơn giản.append() and extend() methods by running simple experiments.

Thêm nhiều phần tử: expend () vs extend ()

Hãy cùng chạy một thử nghiệm thêm nhiều yếu tố vào danh sách.

Chúng tôi sẽ so sánh append () với phương pháp vòng lặp để mở rộng () phương thức.append() with for loop approach to extend() method.

Đây là mã:

import timeit

def append_loop(foo, reps):
    for i in range(reps):
        foo.append(i)

def append_comp(foo, reps):
    [foo.append(i) for i in range(reps)]

def extend_lst(foo, reps):
    foo.extend([i for i in range(reps)])

def extend_tup(foo, reps):
    foo.extend((i for i in range(reps)))

repetitions = 600

print timeit.timeit('append_loop([], repetitions)', setup='from __main__ import append_loop, repetitions')
print timeit.timeit('append_comp([], repetitions)', setup='from __main__ import append_comp, repetitions')
print timeit.timeit('extend_lst([], repetitions)', setup='from __main__ import extend_lst, repetitions')
print timeit.timeit('extend_tup([], repetitions)', setup='from __main__ import extend_tup, repetitions')

Output:

import timeit

def append_loop(foo, reps):
    for i in range(reps):
        foo.append(i)

def append_comp(foo, reps):
    [foo.append(i) for i in range(reps)]

def extend_lst(foo, reps):
    foo.extend([i for i in range(reps)])

def extend_tup(foo, reps):
    foo.extend((i for i in range(reps)))

repetitions = 600

print timeit.timeit('append_loop([], repetitions)', setup='from __main__ import append_loop, repetitions')
print timeit.timeit('append_comp([], repetitions)', setup='from __main__ import append_comp, repetitions')
print timeit.timeit('extend_lst([], repetitions)', setup='from __main__ import extend_lst, repetitions')
print timeit.timeit('extend_tup([], repetitions)', setup='from __main__ import extend_tup, repetitions')

Như bạn có thể thấy, việc nối thêm ~ 5 lần dài hơn so với kéo dài.

Vì vậy, hiệu suất khôn ngoan, sử dụng phương thức mở rộng () khi thêm nhiều phần tử vào danh sách.extend() method when adding multiple elements to a list.

Thêm một phần tử duy nhất: append () vs extend ()

Một ví dụ khác, hãy để so sánh hiệu suất của việc thêm một phần tử vào cuối danh sách bằng cách:

• Sử dụng phương thức append () bằng cách truyền một phần tử duy nhất làm đối số.append() method by passing a single element as an argument.
• Sử dụng phương thức mở rộng () bằng cách gói phần tử thành một điều khác.extend() method by wrapping the element into an iterable.

Đây là mã:

import timeit

def append_loop(foo, reps):
    for i in range(reps):
        foo.append(i)

def append_comp(foo, reps):
    [foo.append(i) for i in range(reps)]

def extend_lst(foo, reps):
    foo.extend([i for i in range(reps)])

def extend_tup(foo, reps):
    foo.extend((i for i in range(reps)))

repetitions = 600

print timeit.timeit('append_loop([], repetitions)', setup='from __main__ import append_loop, repetitions')
print timeit.timeit('append_comp([], repetitions)', setup='from __main__ import append_comp, repetitions')
print timeit.timeit('extend_lst([], repetitions)', setup='from __main__ import extend_lst, repetitions')
print timeit.timeit('extend_tup([], repetitions)', setup='from __main__ import extend_tup, repetitions')

Output:

import timeit

def append_loop(foo, reps):
    for i in range(reps):
        foo.append(i)

def append_comp(foo, reps):
    [foo.append(i) for i in range(reps)]

def extend_lst(foo, reps):
    foo.extend([i for i in range(reps)])

def extend_tup(foo, reps):
    foo.extend((i for i in range(reps)))

repetitions = 600

print timeit.timeit('append_loop([], repetitions)', setup='from __main__ import append_loop, repetitions')
print timeit.timeit('append_comp([], repetitions)', setup='from __main__ import append_comp, repetitions')
print timeit.timeit('extend_lst([], repetitions)', setup='from __main__ import extend_lst, repetitions')
print timeit.timeit('extend_tup([], repetitions)', setup='from __main__ import extend_tup, repetitions')

Như bạn có thể thấy, việc nối thêm ~ 5 lần dài hơn so với kéo dài.

Vì vậy, hiệu suất khôn ngoan, sử dụng phương thức mở rộng () khi thêm nhiều phần tử vào danh sách.

Thêm một phần tử duy nhất: append () vs extend () append() vs extend() in Python.

Một ví dụ khác, hãy để so sánh hiệu suất của việc thêm một phần tử vào cuối danh sách bằng cách:

Sử dụng phương thức append () bằng cách truyền một phần tử duy nhất làm đối số.

Sử dụng phương thức mở rộng () bằng cách gói phần tử thành một điều khác. append() and extend() methods are not the only ways to add elements to the end of a list.

Như bạn có thể thấy, kéo dài chất thải nhiều thời gian hơn một chút so với việc thêm.

• Tuy nhiên, bạn không nên chú ý quá nhiều đến thời gian của các phương pháp này. Thay vào đó, bạn nên sử dụng một cách tiếp cận chính xác về mặt ngữ nghĩa. Nói cách khác, thay vì nhìn vào các số hiệu suất, hãy sử dụng mã mô tả chính xác những gì bạn đang cố gắng thực hiện.insert() method.
• Dù sao, điều này hoàn thành hướng dẫn của chúng tôi về append () vs extend () trong python.+ operator.

Để kết thúc, hãy cùng xem hai cách tiếp cận thay thế để thêm các yếu tố vào danh sách.

insert()

Các phương pháp tương tự khácinsert() method can be used to insert an element at a specific index in a list.

Trong Python, các phương thức expend () và extend () không phải là cách duy nhất để thêm các phần tử vào cuối danh sách.

import timeit

def append_loop(foo, reps):
    for i in range(reps):
        foo.append(i)

def append_comp(foo, reps):
    [foo.append(i) for i in range(reps)]

def extend_lst(foo, reps):
    foo.extend([i for i in range(reps)])

def extend_tup(foo, reps):
    foo.extend((i for i in range(reps)))

repetitions = 600

print timeit.timeit('append_loop([], repetitions)', setup='from __main__ import append_loop, repetitions')
print timeit.timeit('append_comp([], repetitions)', setup='from __main__ import append_comp, repetitions')
print timeit.timeit('extend_lst([], repetitions)', setup='from __main__ import extend_lst, repetitions')
print timeit.timeit('extend_tup([], repetitions)', setup='from __main__ import extend_tup, repetitions')

Where:

• Ngoài ra, còn có hai cách khác mà bạn có thể sử dụng: is the index at which you want to add the element.
• Phương thức chèn (). is the element to be inserted in the list.

Toán tử +.insert() to add an element to the end of a list too.

Hãy để giới thiệu ngắn gọn các phương pháp này.

import timeit

def append_loop(foo, reps):
    for i in range(reps):
        foo.append(i)

def append_comp(foo, reps):
    [foo.append(i) for i in range(reps)]

def extend_lst(foo, reps):
    foo.extend([i for i in range(reps)])

def extend_tup(foo, reps):
    foo.extend((i for i in range(reps)))

repetitions = 600

print timeit.timeit('append_loop([], repetitions)', setup='from __main__ import append_loop, repetitions')
print timeit.timeit('append_comp([], repetitions)', setup='from __main__ import append_comp, repetitions')
print timeit.timeit('extend_lst([], repetitions)', setup='from __main__ import extend_lst, repetitions')
print timeit.timeit('extend_tup([], repetitions)', setup='from __main__ import extend_tup, repetitions')

Output:

[1, 2, 3, 4]

Trong Python, phương thức chèn () có thể được sử dụng để chèn một phần tử tại một chỉ mục cụ thể trong danh sách.

Cú pháp như sau:append() this way.

Chỉ mục là chỉ mục mà bạn muốn thêm phần tử.

import timeit

def append_loop(foo, reps):
    for i in range(reps):
        foo.append(i)

def append_comp(foo, reps):
    [foo.append(i) for i in range(reps)]

def extend_lst(foo, reps):
    foo.extend([i for i in range(reps)])

def extend_tup(foo, reps):
    foo.extend((i for i in range(reps)))

repetitions = 600

print timeit.timeit('append_loop([], repetitions)', setup='from __main__ import append_loop, repetitions')
print timeit.timeit('append_comp([], repetitions)', setup='from __main__ import append_comp, repetitions')
print timeit.timeit('extend_lst([], repetitions)', setup='from __main__ import extend_lst, repetitions')
print timeit.timeit('extend_tup([], repetitions)', setup='from __main__ import extend_tup, repetitions')

Output:

53.8211231232
57.1711571217
19.8829259872
28.5986201763

Phần tử là phần tử được chèn vào danh sách.

Điều này có nghĩa là bạn có thể sử dụng chèn () để thêm một phần tử vào cuối danh sách.

Chẳng hạn, hãy để chèn một số ở cuối danh sách:

Phương thức này chỉ cho phép bạn chèn một phần tử tại một thời điểm.

53.8211231232
57.1711571217
19.8829259872
28.5986201763

Output:

1.42491698265
0.657584905624

Nếu bạn cố gắng thêm nhiều yếu tố làm danh sách vào cuối danh sách, bạn sẽ nhận được kết quả tương tự khi sử dụng append () theo cách này.

Ví dụ:append() and extend() methods in Python lists.

Toán tử +

• Append () có thể được sử dụng để thêm một phần tử cùng một lúc.append() can be used to add one element at a time.
• Phương thức mở rộng () có thể được sử dụng để thêm nhiều phần tử cùng một lúc. extend() method can be used to add multiple elements at once.

Cảm ơn vì đã đọc.

Mã hóa hạnh phúc!

Đọc thêm

Trang web lập trình tốt nhất

50 câu hỏi phỏng vấn Python