Hướng dẫn are for loops faster in python? - cho các vòng lặp nhanh hơn trong python?

Mục lục:

• • • Báo cáo vấn đề
    • Sự chuẩn bị
    • Vòng lặp đơn giản
    • Vòng lồng nhau
    • Kết quả tóm tắt
    • Kết luận

Python là một trong những ngôn ngữ lập trình phổ biến nhất hiện nay. Nó có một ngôn ngữ cấp cao và được giải thích với cú pháp thanh lịch và có thể đọc được. Tuy nhiên, Python thường chậm hơn đáng kể so với Java, C#và đặc biệt là C, C ++ hoặc Fortran. Đôi khi các vấn đề về hiệu suất và tắc nghẽn có thể ảnh hưởng nghiêm trọng đến khả năng sử dụng của các ứng dụng.

May mắn thay, trong hầu hết các trường hợp, có những giải pháp để cải thiện hiệu suất của các chương trình Python. Có những lựa chọn mà các nhà phát triển có thể thực hiện để cải thiện tốc độ mã của họ. Ví dụ, lời khuyên chung là sử dụng các thói quen python hoặc bên thứ ba được tối ưu hóa, thường được viết bằng C hoặc Cython. Bên cạnh đó, nó nhanh hơn để làm việc với các biến cục bộ so với Globals, do đó, nó là một thực tế tốt để sao chép một biến toàn cầu vào một địa phương trước vòng lặp. Và như thế.

Cuối cùng, luôn có khả năng viết các chức năng Python của riêng mình trong C, C ++ hoặc Cython, gọi chúng từ ứng dụng và thay thế các thói quen tắc nghẽn Python. Nhưng đây thường là một giải pháp cực đoan và hiếm khi cần thiết cho thực tiễn.

Thông thường các vấn đề về hiệu suất phát sinh khi sử dụng các vòng python, đặc biệt là với một số lượng lớn các lần lặp. Có một số thủ thuật hữu ích để cải thiện mã của bạn và làm cho nó chạy nhanh hơn, nhưng điều đó vượt quá phạm vi ở đây.

Bài viết này so sánh hiệu suất của một số phương pháp khi tổng hợp hai phần tử khôn ngoan:

• Sử dụng vòng lặp trong khi
• Sử dụng vòng lặp cho
• Sử dụng vòng lặp cho toàn bộ danh sách
• Sử dụng thư viện của bên thứ ba

  n = 1_000
  x, y = random.sample(r, n), random.sample(r, n)

  3

Tuy nhiên, hiệu suất không phải là mối quan tâm duy nhất khi phát triển phần mềm. Hơn nữa, theo Donald Knuth trong nghệ thuật lập trình máy tính, tối ưu hóa sớm là gốc rễ của mọi điều ác (hoặc ít nhất là hầu hết) trong lập trình. Rốt cuộc, khả năng đọc của người Viking đếm được, như đã nêu trong Zen of Python của Tim Peters.

Báo cáo vấn đề

Chúng tôi sẽ cố gắng tổng hợp hai phần tử khôn ngoan. Nói cách khác, chúng tôi sẽ lấy hai chuỗi (danh sách hoặc mảng) có cùng kích thước và tạo cái thứ ba với các phần tử thu được bằng cách thêm các phần tử tương ứng từ các đầu vào.

Sự chuẩn bị

Vòng lặp đơn giản

import random
r = [random.randrange(100) for _ in range(100_000)]

Vòng lồng nhau

Kết quả tóm tắt

Vòng lặp đơn giản

Vòng lồng nhau

Kết quả tóm tắt

n = 1_000
x, y = random.sample(r, n), random.sample(r, n)

Python là một trong những ngôn ngữ lập trình phổ biến nhất hiện nay. Nó có một ngôn ngữ cấp cao và được giải thích với cú pháp thanh lịch và có thể đọc được. Tuy nhiên, Python thường chậm hơn đáng kể so với Java, C#và đặc biệt là C, C ++ hoặc Fortran. Đôi khi các vấn đề về hiệu suất và tắc nghẽn có thể ảnh hưởng nghiêm trọng đến khả năng sử dụng của các ứng dụng.

May mắn thay, trong hầu hết các trường hợp, có những giải pháp để cải thiện hiệu suất của các chương trình Python. Có những lựa chọn mà các nhà phát triển có thể thực hiện để cải thiện tốc độ mã của họ. Ví dụ, lời khuyên chung là sử dụng các thói quen python hoặc bên thứ ba được tối ưu hóa, thường được viết bằng C hoặc Cython. Bên cạnh đó, nó nhanh hơn để làm việc với các biến cục bộ so với Globals, do đó, nó là một thực tế tốt để sao chép một biến toàn cầu vào một địa phương trước vòng lặp. Và như thế.

%%timeit
i, z = 0, []
while i < n:
    z.append(x[i] + y[i])
    i += 1

Cuối cùng, luôn có khả năng viết các chức năng Python của riêng mình trong C, C ++ hoặc Cython, gọi chúng từ ứng dụng và thay thế các thói quen tắc nghẽn Python. Nhưng đây thường là một giải pháp cực đoan và hiếm khi cần thiết cho thực tiễn.

Thông thường các vấn đề về hiệu suất phát sinh khi sử dụng các vòng python, đặc biệt là với một số lượng lớn các lần lặp. Có một số thủ thuật hữu ích để cải thiện mã của bạn và làm cho nó chạy nhanh hơn, nhưng điều đó vượt quá phạm vi ở đây.

Bài viết này so sánh hiệu suất của một số phương pháp khi tổng hợp hai phần tử khôn ngoan:

Sử dụng vòng lặp trong khi

%%timeit
z = []
for i in range(n):
    z.append(x[i] + y[i])

Cuối cùng, luôn có khả năng viết các chức năng Python của riêng mình trong C, C ++ hoặc Cython, gọi chúng từ ứng dụng và thay thế các thói quen tắc nghẽn Python. Nhưng đây thường là một giải pháp cực đoan và hiếm khi cần thiết cho thực tiễn.

Thông thường các vấn đề về hiệu suất phát sinh khi sử dụng các vòng python, đặc biệt là với một số lượng lớn các lần lặp. Có một số thủ thuật hữu ích để cải thiện mã của bạn và làm cho nó chạy nhanh hơn, nhưng điều đó vượt quá phạm vi ở đây.

Bài viết này so sánh hiệu suất của một số phương pháp khi tổng hợp hai phần tử khôn ngoan:

Sử dụng vòng lặp trong khi

%%timeit
z = [x[i] + y[i] for i in range(n)

Cuối cùng, luôn có khả năng viết các chức năng Python của riêng mình trong C, C ++ hoặc Cython, gọi chúng từ ứng dụng và thay thế các thói quen tắc nghẽn Python. Nhưng đây thường là một giải pháp cực đoan và hiếm khi cần thiết cho thực tiễn.

Thông thường các vấn đề về hiệu suất phát sinh khi sử dụng các vòng python, đặc biệt là với một số lượng lớn các lần lặp. Có một số thủ thuật hữu ích để cải thiện mã của bạn và làm cho nó chạy nhanh hơn, nhưng điều đó vượt quá phạm vi ở đây.

Bài viết này so sánh hiệu suất của một số phương pháp khi tổng hợp hai phần tử khôn ngoan:

Sử dụng vòng lặp trong khi

Sử dụng vòng lặp cho toàn bộ danh sách

Sử dụng thư viện của bên thứ ba

n = 1_000
x, y = random.sample(r, n), random.sample(r, n)

x_, y_ = np.array(x, dtype=np.int64), np.array(y, dtype=np.int64)

Tóm tắt hai mảng

n = 1_000
x, y = random.sample(r, n), random.sample(r, n)

Đầu ra là:

1,03 Pha ± 5,09 ns mỗi vòng (trung bình ± std. Dev. Của 7 lần chạy, 1000000 vòng mỗi)

Điều đó nhanh hơn gần 85 lần so với khi chúng tôi sử dụng toàn bộ danh sách. Và mã cực kỳ đơn giản và thanh lịch.

n = 1_000
x, y = random.sample(r, n), random.sample(r, n)

Nó có thể thậm chí còn tốt hơn. Nếu chúng tôi ổn với việc sử dụng số nguyên 32 bit thay vì 64 bit, chúng tôi có thể lưu cả bộ nhớ và thời gian trong một số trường hợp:

x_, y_ = np.array(x, dtype=np.int32), np.array(y, dtype=np.int32)

Chúng ta có thể thêm hai mảng này như trước:

Đầu ra là:

1,03 Pha ± 5,09 ns mỗi vòng (trung bình ± std. Dev. Của 7 lần chạy, 1000000 vòng mỗi)

Điều đó nhanh hơn gần 85 lần so với khi chúng tôi sử dụng toàn bộ danh sách. Và mã cực kỳ đơn giản và thanh lịch.

n = 1_000
x, y = random.sample(r, n), random.sample(r, n)

Nó có thể thậm chí còn tốt hơn. Nếu chúng tôi ổn với việc sử dụng số nguyên 32 bit thay vì 64 bit, chúng tôi có thể lưu cả bộ nhớ và thời gian trong một số trường hợp:

Chúng ta có thể thêm hai mảng này như trước:

814 ns ± 5,8 ns mỗi vòng (trung bình ± std. Dev. Của 7 lần chạy, 1000000 vòng mỗi)

n = 1_000
x, y = random.sample(r, n), random.sample(r, n)

m, n = 100, 1_000
x = [random.sample(r, n) for _ in range(m)]
y = [random.sample(r, n) for _ in range(m)]

Vòng lồng nhau

%%timeit
i, z = 0, []
while i < m:
    j, z_ = 0, []
    while j < n:
        z_.append(x[i][j] + y[i][j])
        j += 1
    z.append(z_)
    i += 1

Đầu ra là:

Bây giờ, hãy so sánh các vòng python lồng nhau.

%%timeit
z = []
for i in range(m):
    z_ = []
    for j in range(n):
         z_.append(x[i][j] + y[i][j])
    z.append(z_)

Đầu ra là:

Sử dụng Python thuần túy

n = 1_000
x, y = random.sample(r, n), random.sample(r, n)

Đầu ra là:

Chúng tôi sẽ làm việc với hai danh sách được gọi là X và Y một lần nữa. Mỗi trong số chúng sẽ chứa 100 danh sách bên trong với 1.000 phần tử số nguyên giả. Do đó, X và Y thực sự sẽ đại diện cho các ma trận với 100 hàng và 1.000 cột:

Hãy cùng xem hiệu suất của việc thêm chúng bằng cách sử dụng hai vòng trong khi các vòng lặp:

19,7 ms ± 271 Pha mỗi vòng (trung bình ± std.

16,4 ms ± 303 Pha mỗi vòng (trung bình ± std.

Chúng ta có thể thấy rằng trong trường hợp các vòng lặp lồng nhau, các toàn bộ danh sách nhanh hơn thông thường cho các vòng lặp, nhanh hơn trong khi.

Trong trường hợp này, chúng tôi có 100.000 phần tử số nguyên (100 × 1.000) trong mỗi danh sách. Ví dụ này chậm hơn một chút so với cái có 100.000 phần tử và một vòng lặp duy nhất. Đó là kết luận cho cả ba cách tiếp cận (danh sách toàn diện, thông thường cho và trong khi các vòng lặp).

Đầu ra là:

Sử dụng python với numpy

x_, y_ = np.array(x, dtype=np.int32), np.array(y, dtype=np.int32)

n = 1_000
x, y = random.sample(r, n), random.sample(r, n)

n = 1_000
x, y = random.sample(r, n), random.sample(r, n)

Đầu ra là:

x_, y_ = np.array(x, dtype=np.int64), np.array(y, dtype=np.int64)

Và hãy để kiểm tra hiệu suất:

69,9 Pha ± 909 ns mỗi vòng (trung bình ± std. Nhưng nó có thể thậm chí còn nhanh hơn nếu chúng ta sử dụng số nguyên 32 bit:

%%timeit
i, z = 0, []
while i < n:
    z.append(x[i] + y[i])
    i += 1

%%timeit
i, z = 0, []
while i < n:
    z.append(x[i] + y[i])
    i += 1

%%timeit
i, z = 0, []
while i < n:
    z.append(x[i] + y[i])
    i += 1

n = 1_000
x, y = random.sample(r, n), random.sample(r, n)

n = 1_000
x, y = random.sample(r, n), random.sample(r, n)

814 ns

2,87 s

34,1 s

34,3 s

Kết luận

Bài viết này so sánh hiệu suất của các vòng python khi thêm hai danh sách hoặc mảng phần tử khôn ngoan. Kết quả cho thấy rằng các toàn bộ danh sách nhanh hơn thông thường cho vòng lặp, nhanh hơn vòng lặp trong khi. Các vòng đơn giản nhanh hơn một chút so với các vòng lồng nhau trong cả ba trường hợp.

n = 1_000
x, y = random.sample(r, n), random.sample(r, n)

Xin lưu ý rằng các kết luận hoặc quan hệ giữa các kết quả thu được ở đây không được áp dụng, hợp lệ hoặc hữu ích trong mọi trường hợp! Chúng được trình bày để minh họa. Cách thích hợp để xử lý sự thiếu hiệu quả là khám phá các tắc nghẽn và thực hiện các bài kiểm tra riêng.