Hướng dẫn what is faster than append in python? - cái gì nhanh hơn append trong python?

Cũng đáng chỉ ra rằng câu trả lời cho câu hỏi này dựa trên kích thước nhỏ của danh sách/tuple được thêm vào mỗi lần lặp. Đối với các danh sách lớn hơn, mở rộng rõ ràng là vượt trội (và liệt kê so với các bộ dữ liệu không tạo ra sự khác biệt). Bắt đầu với câu trả lời của Mgilson, tôi đã kiểm tra hành vi cho các bộ sưu tập với 600 mục, thay vì 2: Gọi phụ lục 600 lần mất gấp 8 lần so với extend() với danh sách/tuple được xác định thủ công (tức là [v,v,v,v,v,v,v...]):

42.4969689846
5.45146393776
5.38034892082

Phần lớn năm giây này thực sự là sự sáng tạo danh sách/tuple. Chuẩn bị nó trước khi cuộc gọi timeit mang lại thời gian để mở rộng đến

1.42491698265
0.657584905624

cho danh sách và tuple, tương ứng.

Đối với một trường hợp thực tế hơn (và công bằng hơn), người ta có thể tự động tạo dữ liệu trong cuộc gọi chức năng:

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')

.

Thời gian là:

53.8211231232
57.1711571217
19.8829259872
28.5986201763

Như chúng ta có thể thấy, mở rộng với sự hiểu biết danh sách vẫn nhanh hơn hai lần so với việc thêm vào. Ngoài ra, sự hiểu biết tuple có vẻ chậm hơn đáng kể so với danh sách hiểu và append_comp chỉ giới thiệu chi phí tạo danh sách không cần thiết.

Một sự hiểu biết sâu sắc về danh sách Python là nền tảng cho giáo dục Python của bạn. Hôm nay, tôi tự hỏi: Điều gì khác biệt giữa hai phương pháp danh sách được sử dụng thường xuyên nhất:

1.42491698265
0.657584905624
0 so với extend()?

Tôi đã quay một video nhỏ giải thích sự khác biệt và phương pháp nào nhanh hơn bạn có thể chơi nó khi bạn đọc qua hướng dẫn này:

Danh sách python append () vs extend () - sự khác biệt về ngữ nghĩa và tốc độ

Ở đây, câu trả lời ngắn gọn -

1.42491698265
0.657584905624
0 so với extend():

  • Phương pháp
    1.42491698265
    0.657584905624
    
    4 thêm phần tử
    1.42491698265
    0.657584905624
    
    5 vào cuối
    1.42491698265
    0.657584905624
    
    6.
  • Phương pháp
    1.42491698265
    0.657584905624
    
    7 thêm tất cả các yếu tố trong
    1.42491698265
    0.657584905624
    
    8 vào cuối
    1.42491698265
    0.657584905624
    
    6.

Sự khác biệt giữa

1.42491698265
0.657584905624
0 và extend() là phần trước chỉ thêm một yếu tố và phần sau thêm một bộ sưu tập các phần tử vào danh sách.

Bạn có thể thấy điều này trong ví dụ sau:

>>> l = []
>>> l.append(1)
>>> l.append(2)
>>> l
[1, 2]
>>> l.extend([3, 4, 5])
>>> l
[1, 2, 3, 4, 5]

Trong mã, trước tiên bạn thêm các phần tử số nguyên 1 và 2 vào danh sách bằng cách sử dụng hai cuộc gọi vào phương thức

1.42491698265
0.657584905624
0. (Nếu bạn cần hiểu sâu hơn, hãy xem bài viết chi tiết của tôi về phương thức append () trên blog này.)

Sau đó, bạn sử dụng phương thức mở rộng để thêm ba phần tử 3, 4 và 5 trong một cuộc gọi của phương thức extend().

Những bài viết liên quan:

  • Hướng dẫn cuối cùng về danh sách Python

Tại đây, bảng gian lận PDF miễn phí của bạn cho bạn thấy tất cả các phương thức danh sách Python trên một trang đơn giản. Nhấp vào hình ảnh để tải xuống tệp PDF có độ phân giải cao, in nó và đăng nó lên tường văn phòng của bạn:

Hướng dẫn what is faster than append in python? - cái gì nhanh hơn append trong python?

Phương thức nào nhanh hơn - extend () hoặc append ()?

Để trả lời câu hỏi này, tôi đã viết một kịch bản ngắn kiểm tra hiệu suất thời gian chạy của việc tạo danh sách lớn các kích thước tăng bằng các phương pháp extend()

1.42491698265
0.657584905624
0.

Luận án của tôi là phương thức extend() phải nhanh hơn cho các kích thước danh sách lớn hơn vì Python có thể nối các phần tử vào danh sách trong một lô thay vì gọi cùng một phương thức.

Tôi đã sử dụng sổ ghi chép của mình với bộ xử lý Intel (R) Core (TM) I7-8565U 1.8GHz (với Turbo tăng lên tới 4,6 GHz) và RAM 8 GB.

Sau đó, tôi đã tạo 100 danh sách với cả hai phương thức, mở rộng () và append (), với kích thước từ 10.000 yếu tố đến 1.000.000 yếu tố. Là các phần tử, tôi chỉ cần tăng số nguyên số lượng bắt đầu từ 0.

Ở đây, mã mà tôi đã sử dụng để đo và vẽ kết quả: phương thức nào nhanh hơn, tính năng () hoặc extend ()?

import time


def list_by_append(n):
    '''Creates a list & appends n elements'''
    lst = []
    for i in range(n):
        lst.append(n)
    return lst


def list_by_extend(n):
    '''Creates a list & extends it with n elements'''
    lst = []
    lst.extend(range(n))
    return lst


# Compare runtime of both methods
list_sizes = [i * 10000 for i in range(100)]
append_runtimes = []
extend_runtimes = []

for size in list_sizes:

    # Get time stamps
    time_0 = time.time()
    list_by_append(size)
    time_1 = time.time()
    list_by_extend(size)
    time_2 = time.time()

    # Calculate runtimes
    append_runtimes.append((size, time_1 - time_0))
    extend_runtimes.append((size, time_2 - time_1))


# Plot everything
import matplotlib.pyplot as plt
import numpy as np

append_runtimes = np.array(append_runtimes)
extend_runtimes = np.array(extend_runtimes)

print(append_runtimes)
print(extend_runtimes)

plt.plot(append_runtimes[:,0], append_runtimes[:,1], label='append()')
plt.plot(extend_runtimes[:,0], extend_runtimes[:,1], label='extend()')

plt.xlabel('list size')
plt.ylabel('runtime (seconds)')

plt.legend()
plt.savefig('append_vs_extend.jpg')
plt.show()

Mã này bao gồm ba phần cấp cao:

  • Trong phần đầu tiên, bạn xác định hai hà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')
    
    7 và
    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')
    
    8 lấy đối số đầu vào kích thước danh sách số nguyên
    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')
    
    9 và tạo danh sách các phần tử số nguyên tăng liên tục bằng các phương thức
    1.42491698265
    0.657584905624
    
    0 và extend().
  • Trong phần thứ hai, bạn so sánh thời gian chạy của cả hai hàm bằng 100 giá trị khác nhau cho kích thước 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')
    
    9.
  • Trong phần thứ ba, bạn vẽ mọi thứ bằng thư viện Python Matplotlib.

Ở đây, cốt truyện kết quả so sánh thời gian chạy của hai phương thức nối () vs extend (). Trên trục X, bạn có thể thấy kích thước danh sách từ 0 đến 1.000.000 yếu tố. Trên trục Y, bạn có thể thấy thời gian chạy tính bằng giây cần thiết để thực hiện các chức năng tương ứng.

Hướng dẫn what is faster than append in python? - cái gì nhanh hơn append trong python?

Biểu đồ kết quả cho thấy cả hai phương pháp đều cực kỳ nhanh đối với một vài hàng chục ngàn yếu tố. Trên thực tế, chúng nhanh đến mức chức năng

53.8211231232
57.1711571217
19.8829259872
28.5986201763
3 của mô -đun thời gian không thể nắm bắt được thời gian trôi qua.

Nhưng khi bạn tăng quy mô của danh sách lên hàng trăm ngàn yếu tố, phương pháp extend() bắt đầu giành chiến thắng:

Đối với các danh sách lớn với một triệu yếu tố, thời gian chạy của phương thức extend() nhanh hơn 60% so với thời gian chạy của phương thức

1.42491698265
0.657584905624
0.

Lý do là hàng loạt đã được đề cập của các hoạt động nối tiếp.

Tuy nhiên, hiệu ứng chỉ phát ra cho các danh sách rất lớn. Đối với danh sách nhỏ, bạn có thể chọn một trong hai phương thức. Chà, để rõ ràng mã của bạn, vẫn sẽ có ý nghĩa khi thích extend() hơn

1.42491698265
0.657584905624
0 nếu bạn cần thêm một loạt các phần tử thay vì chỉ một yếu tố duy nhất.

Kỹ năng mã hóa của bạn - những gì cấp độ tiếp theo?

Nếu bạn yêu thích mã hóa và bạn muốn làm điều này toàn thời gian từ sự thoải mái của chính ngôi nhà của mình, bạn sẽ gặp may mắn:

Tôi đã tạo ra một hội thảo trên web miễn phí cho bạn thấy cách tôi bắt đầu như một người làm việc tự do Python sau khi các nghiên cứu khoa học máy tính của tôi làm việc tại nhà (và thấy con tôi lớn lên) trong khi kiếm được thu nhập toàn thời gian chỉ làm việc bán thời gian.

Hội thảo trên web: Làm thế nào để trở thành freelancer Python sáu con số?

Tham gia 21.419 Coders Python đầy tham vọng. Nó vui! ??

Hướng dẫn what is faster than append in python? - cái gì nhanh hơn append trong python?

Trong khi làm việc như một nhà nghiên cứu trong các hệ thống phân tán, Tiến sĩ Christian Mayer đã tìm thấy tình yêu của mình đối với việc dạy các sinh viên khoa học máy tính.

Để giúp học sinh đạt được thành công cao hơn của Python, ông đã thành lập trang web giáo dục chương trình Finxter.com. Ông là tác giả của cuốn sách lập trình phổ biến Python Oneer (Nostarch 2020), đồng tác giả của loạt sách Break Break Python, những cuốn sách tự xuất bản, người đam mê khoa học máy tính, freelancer và chủ sở hữu của một trong 10 blog Python lớn nhất trên toàn thế giới.

Niềm đam mê của ông là viết, đọc và mã hóa. Nhưng niềm đam mê lớn nhất của anh là phục vụ các lập trình viên đầy tham vọng thông qua Finxter và giúp họ tăng cường các kỹ năng của họ. Bạn có thể tham gia học viện email miễn phí của anh ấy ở đây.

Là mở rộng hay nối liền Python nhanh hơn?

.extend with list comprehension is still over two times faster than appending.

Là mở rộng chậm hơn so với phần phụ lục?

Đối với các danh sách lớn với một triệu yếu tố, thời gian chạy của phương thức mở rộng () nhanh hơn 60% so với thời gian chạy của phương thức append ().60% faster than the runtime of the append() method.

Có phải thêm thêm nhanh hơn danh sách phụ lục?

Các bộ này nhanh hơn nhiều, nói chung.Kiểm tra tư cách thành viên trong danh sách là O (n), tuyến tính về kích thước của danh sách.Thêm vào một tập hợp là O (1), độc lập với số lượng các mục trong danh sách.. Testing for membership in a list is O(n), linear in the size of the list. Adding to a set is O(1), independent of the number of the items in the list.

Numpy có phải phụ lục nhanh hơn danh sách phụ lục không?

Các mảng Numpy không phải lúc nào cũng nhanh hơn danh sách "append ()" thêm các giá trị vào phần cuối của cả danh sách và mảng numpy.Nó là một chức năng phổ biến và rất thường được sử dụng.Kịch bản bên dưới cho thấy sự so sánh giữa các danh sách của danh sách () và Numpy's append (). " append() " adds values to the end of both lists and NumPy arrays. It is a common and very often used function. The script below demonstrates a comparison between the lists' append() and NumPy's append() .