Tại sao từ điển nhanh hơn trong python?

Phương pháp nhanh nhất sẽ tùy thuộc vào việc có hay không khóa 'ccc'
.

Nếu chìa khóa thường ở đó, phương pháp nhanh nhất là

try:
    vlx = tbl['ccc']
except KeyError:
    vlx = 'Unknown key'

Càng nhanh càng tốt nếu có khóa, nhưng sẽ chậm
nếu thiếu khóa.

Nếu khóa thường bị thiếu, thì điều này sẽ nhanh hơn

if 'ccc' in tbl:
    vlx = tbl['ccc']
else:
    vlx = 'Unknown key'

nhưng nếu có chìa khóa thì nó sẽ hoạt động gấp đôi so với mức cần thiết

Một cách khác, có thể chậm hơn cả hai cách khác, là cái này

vlx = tbl.get['ccc', 'Unknown key']

Đừng căng thẳng về phương pháp “nhanh nhất”. Cả ba phương pháp có thể sẽ
đủ nhanh cho những gì bạn đang làm. Và nếu không, bạn có thể
lập hồ sơ chương trình của mình, tìm ra những phần chậm và tập trung
vào việc tăng tốc những phần chậm.

Tôi cá là bạn có thể gặp phản biện này nhiều lần về việc sử dụng Python, đặc biệt là từ những người đến từ thế giới

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

1 hoặc

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

2 hoặc

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

3. Điều này đúng trong nhiều trường hợp, chẳng hạn, việc lặp lại hoặc sắp xếp các mảng, danh sách hoặc từ điển trong Python đôi khi có thể bị chậm. Rốt cuộc, Python được phát triển để làm cho việc lập trình trở nên thú vị và dễ dàng. Do đó, những cải tiến của mã Python về tính ngắn gọn và dễ đọc phải đi kèm với chi phí hiệu suất

Phải nói rằng, nhiều nỗ lực đã được thực hiện trong những năm gần đây để cải thiện hiệu suất của Python. Giờ đây, chúng tôi có thể xử lý các tập dữ liệu lớn một cách hiệu quả bằng cách sử dụng numpy, scipy, pandas, và nulla, vì tất cả các thư viện này đã triển khai các đường dẫn mã quan trọng của chúng trong

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

1/

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

2. Có một dự án thú vị khác, dự án Pypy, giúp tăng tốc mã Python lên 4. 4 lần so với Cpython [triển khai Python gốc]

Ngoài các tài nguyên bên ngoài này, chúng ta có thể làm gì để tăng tốc mã Python trong thực hành viết mã hàng ngày của mình?

Như thường lệ, nếu bạn muốn tự chạy lại mã trong bài đăng này, tất cả dữ liệu và sổ ghi chép cần thiết có thể được truy cập từ Github của tôi

1. Làm quen với các chức năng tích hợp

Python đi kèm với nhiều hàm tích hợp được triển khai trong

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

1, rất nhanh và được bảo trì tốt [Hình 1]. Ít nhất chúng ta nên làm quen với các tên hàm này và biết tìm nó ở đâu [một số hàm liên quan đến tính toán thường được sử dụng là

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

0,

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

1,

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

2,

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

3,

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

4,

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

5]. Vì vậy, bất cứ khi nào cần thực hiện một phép tính đơn giản, chúng ta có thể sử dụng phím tắt phù hợp thay vì viết phiên bản của riêng mình một cách vụng về.

Hãy sử dụng các hàm có sẵn

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

4 và

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

5 làm ví dụ. Như bạn có thể thấy trong Hình 2, nó là 36. 1 và 20. Nhanh hơn 9 lần khi sử dụng

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

4 và

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

5 so với các hàm do chính chúng tôi viết, tương ứng.

2.

if 'ccc' in tbl:
    vlx = tbl['ccc']
else:
    vlx = 'Unknown key'

30 so với.

if 'ccc' in tbl:
    vlx = tbl['ccc']
else:
    vlx = 'Unknown key'

31

Cả hai chức năng có thể sắp xếp danh sách

Nếu chúng ta chỉ muốn lấy một danh sách đã sắp xếp và không quan tâm đến danh sách ban đầu, thì

if 'ccc' in tbl:
    vlx = tbl['ccc']
else:
    vlx = 'Unknown key'

30 nhanh hơn một chút so với

if 'ccc' in tbl:
    vlx = tbl['ccc']
else:
    vlx = 'Unknown key'

31 cả về sắp xếp cơ bản và khi sử dụng các tham số chính [tham số

if 'ccc' in tbl:
    vlx = tbl['ccc']
else:
    vlx = 'Unknown key'

34 chỉ định một hàm được gọi trên mỗi phần tử danh sách trước đó

Điều này là do phương pháp

if 'ccc' in tbl:
    vlx = tbl['ccc']
else:
    vlx = 'Unknown key'

30 sửa đổi danh sách tại chỗ trong khi

if 'ccc' in tbl:
    vlx = tbl['ccc']
else:
    vlx = 'Unknown key'

36] xây dựng danh sách được sắp xếp mới và giữ nguyên danh sách ban đầu. Nói cách khác, thứ tự của các giá trị bên trong

if 'ccc' in tbl:
    vlx = tbl['ccc']
else:
    vlx = 'Unknown key'

37 thực sự đã thay đổi. Tuy nhiên,

if 'ccc' in tbl:
    vlx = tbl['ccc']
else:
    vlx = 'Unknown key'

31 linh hoạt hơn so với

if 'ccc' in tbl:
    vlx = tbl['ccc']
else:
    vlx = 'Unknown key'

30. Điều này là do

if 'ccc' in tbl:
    vlx = tbl['ccc']
else:
    vlx = 'Unknown key'

31 chấp nhận bất kỳ lần lặp nào trong khi

if 'ccc' in tbl:
    vlx = tbl['ccc']
else:
    vlx = 'Unknown key'

30 chỉ được xác định cho danh sách. Do đó, nếu chúng ta muốn sắp xếp thứ gì đó ngoài danh sách, thì

if 'ccc' in tbl:
    vlx = tbl['ccc']
else:
    vlx = 'Unknown key'

31 là chức năng phù hợp để sử dụng. Ví dụ: chúng ta có thể nhanh chóng sắp xếp một từ điển theo khóa hoặc giá trị của nó [Hình 4].

3. Sử dụng các ký hiệu thay vì tên của họ

Như thể hiện trong Hình 5, khi chúng ta cần một đối tượng dictionary hoặc list trống, thay vì sử dụng

vlx = tbl.get['ccc', 'Unknown key']

63 hoặc

vlx = tbl.get['ccc', 'Unknown key']

64, chúng ta có thể gọi trực tiếp

vlx = tbl.get['ccc', 'Unknown key']

65 [đối với tập hợp rỗng, chúng ta cần sử dụng chính

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

4] và

vlx = tbl.get['ccc', 'Unknown key']

67. Thủ thuật này có thể không nhất thiết phải tăng tốc mã, nhưng làm cho mã trở nên Pythonic hơn.

4. hiểu danh sách

Thông thường, khi chúng ta cần tạo danh sách mới từ danh sách cũ dựa trên các quy tắc nhất định, chúng ta sử dụng vòng lặp

vlx = tbl.get['ccc', 'Unknown key']

68 để lặp qua danh sách cũ và chuyển đổi các giá trị của nó dựa trên quy tắc và lưu vào danh sách mới. Ví dụ: giả sử chúng ta muốn tìm tất cả các số chẵn từ

vlx = tbl.get['ccc', 'Unknown key']

69, chúng ta có thể sử dụng các mã sau

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

3

Tuy nhiên, có một cách ngắn gọn và thanh lịch hơn để đạt được điều này. Như thể hiện trong Hình 6, chúng tôi đặt vòng lặp gốc chỉ trong một dòng mã. Hơn nữa, tốc độ được cải thiện gần 2 lần.

Kết hợp với quy tắc 3, ta có thể biến list thành từ điển hoặc bộ cũng được, chỉ cần thay

vlx = tbl.get['ccc', 'Unknown key']

67 thành

vlx = tbl.get['ccc', 'Unknown key']

65. Hãy viết lại mã trong Hình 5, chúng ta có thể bỏ qua bước gán và hoàn thành bước lặp bên trong ký hiệu, như thế này

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

Để phá vỡ điều này, hãy bắt đầu từ cuối. Hàm “

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

12” trả về cho chúng ta một danh sách các bộ dữ liệu [Hình 4]. Ở đây, chúng tôi đã sử dụng phép gán nhiều lần để giải nén bộ, vì đối với mỗi bộ trong danh sách, chúng tôi đã gán

if 'ccc' in tbl:
    vlx = tbl['ccc']
else:
    vlx = 'Unknown key'

34 cho mục đầu tiên của nó và

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

14 cho mục thứ hai của nó [vì chúng tôi biết có hai mục bên trong mỗi bộ trong trường hợp này]. Cuối cùng, mỗi cặp

if 'ccc' in tbl:
    vlx = tbl['ccc']
else:
    vlx = 'Unknown key'

34 và

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

14 được giữ trong một cuốn từ điển

5. Sử dụng

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

17 cho giá trị và chỉ mục

Đôi khi, khi chúng ta duyệt qua một danh sách, chúng ta muốn sử dụng cả giá trị và chỉ số của nó trong biểu thức. Như thể hiện trong Hình 7, chúng ta nên sử dụng

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

17, biến các giá trị của một danh sách thành các cặp chỉ số và giá trị. Điều này cũng tăng tốc mã của chúng tôi khoảng 2 lần.

6. Sử dụng

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

19 để đóng gói và giải nén nhiều lần lặp

Trong một số trường hợp, chúng tôi sẽ cần lặp qua hai hoặc nhiều danh sách. Sau đó, chúng ta có thể sử dụng hàm

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

19 để chuyển đổi nhiều danh sách thành một danh sách các bộ dữ liệu [Hình 8]. Lưu ý rằng các danh sách có cùng độ dài sẽ tốt hơn, nếu không,

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

19 sẽ dừng ngay khi danh sách ngắn hơn kết thúc.

Ngược lại, để truy cập các mục trong mỗi bộ trong danh sách, chúng ta cũng có thể giải nén danh sách bộ bằng cách thêm dấu hoa thị [*] và sử dụng nhiều phép gán, như thế này,

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

22

7. Kết hợp

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

4 và

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

24

Khi chúng ta muốn kiểm tra xem một giá trị có tồn tại trong danh sách hay không, một cách vụng về là xây dựng một hàm như thế này

if 'ccc' in tbl:
    vlx = tbl['ccc']
else:
    vlx = 'Unknown key'

3

Sau đó gọi

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

25 để xem liệu

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

14 có bên trong

vlx = tbl.get['ccc', 'Unknown key']

69 không. Tuy nhiên, một cách Pythonic để làm điều này chỉ là sử dụng in bằng cách gọi

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

28 như trong Hình 9. Nó giống như bạn đang hỏi Python theo nghĩa đen rằng “hey python, bạn có thể vui lòng cho tôi biết nếu

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

14 bên trong

vlx = tbl.get['ccc', 'Unknown key']

69”.

Để hiệu quả hơn, trước tiên chúng ta nên loại bỏ các mục trùng lặp khỏi danh sách bằng cách sử dụng

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

4 và sau đó kiểm tra tư cách thành viên trong đối tượng đã đặt. Bằng cách đó, chúng tôi đã giảm số lượng phần tử cần kiểm tra. Ngoài ra,

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

24 là một hoạt động rất nhanh trên các bộ theo thiết kế

Như bạn có thể thấy trong Hình 9, mặc dù phải mất 20 mili giây để xây dựng đối tượng đã đặt, nhưng đây chỉ là khoản đầu tư một lần và bản thân bước kiểm tra cũng chỉ sử dụng 5. 2µs. Đó là cải tiến gấp 1962 lần

8. Kiểm tra xem một biến có đúng không

Chắc chắn, chúng tôi sẽ sử dụng rất nhiều câu lệnh

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

33 để kiểm tra các biến rỗng, danh sách trống, từ điển trống, v.v. Chúng ta cũng có thể tiết kiệm một chút thời gian từ đây

Như thể hiện trong Hình 10, chúng ta không cần nêu rõ ràng

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

34 hoặc

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

35 trong câu lệnh

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

33, thay vào đó chúng ta chỉ cần sử dụng tên biến. Điều này tiết kiệm tài nguyên được sử dụng bởi hàm ma thuật

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

37 để so sánh các giá trị ở cả hai phía.

Tương tự như vậy, nếu chúng ta cần kiểm tra xem biến có trống không, chúng ta chỉ cần nói

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

38

9. Đếm các giá trị duy nhất sử dụng

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

39

Giả sử chúng ta đang cố đếm các giá trị duy nhất trong danh sách mà chúng ta đã tạo trong Quy tắc 1,

if 'ccc' in tbl:
    vlx = tbl['ccc']
else:
    vlx = 'Unknown key'

37. Một cách là tạo một từ điển trong đó các khóa là số và các giá trị được tính. Khi chúng tôi lặp lại danh sách, chúng tôi có thể tăng số lượng của nó nếu nó đã có trong từ điển và thêm nó vào từ điển nếu nó chưa có

vlx = tbl.get['ccc', 'Unknown key']

6

Tuy nhiên, một cách hiệu quả hơn để thực hiện việc này là chỉ sử dụng

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

11 từ các bộ sưu tập trong một dòng mã,

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

12. Có, nó là đơn giản. Như thể hiện trong Hình 11, nó nhanh hơn khoảng 10 lần so với hàm chúng ta đã viết

Nếu chúng ta muốn biết 10 số phổ biến nhất thì dụ

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

11 cũng có phương thức

sorted_dict3 = {key: value for key, value in sorted[a_dict.items[], key=lambda item: item[1]]}.

14 rất tiện dụng.

Nói tóm lại, bộ sưu tập là một mô-đun tuyệt vời, chúng ta nên lưu nó vào hộp công cụ hàng ngày của mình và sử dụng nó bất cứ khi nào có thể

10. Đặt vòng lặp

vlx = tbl.get['ccc', 'Unknown key']

68 bên trong hàm

Có thể có lúc chúng ta đã xây dựng một chức năng và cần lặp lại chức năng này trong một số lần nhất định. Một cách hiển nhiên là chúng ta xây dựng một hàm rồi đặt hàm này vào một vòng lặp

vlx = tbl.get['ccc', 'Unknown key']

68

Tuy nhiên, như trong Hình 12, thay vì thực hiện hàm lặp đi lặp lại 1 triệu lần [độ dài của a_long_list là 1.000.000], chúng tôi đã tích hợp vòng lặp

vlx = tbl.get['ccc', 'Unknown key']

68 bên trong hàm. Điều này giúp chúng tôi tiết kiệm khoảng 22% thời gian chạy.

Đó là tất cả. Cảm ơn bạn đã đọc bài viết này. Tôi hy vọng rằng một số thủ thuật có thể hữu ích cho bạn. Ngoài ra, một số cách tiếp cận khác mà bạn đã sử dụng để tăng tốc mã Python của mình là gì?

Dưới đây là các liên kết bạn có thể quan tâm

• Cách sắp xếp danh sách bằng cách sử dụng

  if 'ccc' in tbl:
      vlx = tbl['ccc']
  else:
      vlx = 'Unknown key'
  

  30 và

  if 'ccc' in tbl:
      vlx = tbl['ccc']
  else:
      vlx = 'Unknown key'
  

  31
• Khi nào nên sử dụng khả năng hiểu danh sách trong Python
• Chuyển đổi mã thành Python đẹp, thành ngữ
• Ưu điểm và nhược điểm của ngôn ngữ lập trình Python

Như mọi khi, tôi hoan nghênh phản hồi, phê bình mang tính xây dựng và nghe về các dự án khoa học dữ liệu của bạn. Tôi có thể liên hệ với tôi trên Linkedin và bây giờ trên trang web của tôi nữa

Tại sao từ điển Python quá nhanh?

Tại sao từ điển quá nhanh?

Từ điển có nhanh hơn vòng lặp for không?

Ưu điểm của từ điển Python là gì?