programming python

Python giảm độ dài danh sách

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python là một hàm thực hiện một kỹ thuật toán học gọi là gấp hoặc rút gọn.

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 rất hữu ích khi bạn cần áp dụng một chức năng cho một lần lặp và giảm nó thành một giá trị tích lũy duy nhất.

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python phổ biến đối với các nhà phát triển có nền tảng lập trình chức năng, nhưng Python còn cung cấp nhiều hơn thế

Trong hướng dẫn này, bạn sẽ đề cập đến cách thức hoạt động của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 và cách sử dụng nó một cách hiệu quả. Bạn cũng sẽ đề cập đến một số công cụ Python thay thế có thể giống Pythonic hơn, dễ đọc hơn và hiệu quả hơn

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Trong hướng dẫn này, bạn sẽ học

Cách hoạt động của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python

Các trường hợp sử dụng giảm phổ biến hơn là gì

Cách giải quyết các trường hợp sử dụng này bằng cách sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Những công cụ Python thay thế nào có sẵn để giải quyết các trường hợp sử dụng tương tự này

Với kiến thức này, bạn sẽ có thể quyết định nên sử dụng công cụ nào khi giải quyết các vấn đề về giảm hoặc gấp trong Python

Để hiểu rõ hơn về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python, sẽ rất hữu ích nếu bạn có một số kiến thức trước đó về cách làm việc với các lần lặp Python, đặc biệt là cách lặp qua chúng bằng vòng lặp

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Tải xuống miễn phí. Nhận một chương mẫu từ Thủ thuật Python. Cuốn sách chỉ cho bạn các phương pháp hay nhất về Python với các ví dụ đơn giản mà bạn có thể áp dụng ngay lập tức để viết mã Pythonic + đẹp hơn

Khám phá lập trình chức năng trong Python

Lập trình chức năng là một mô hình lập trình dựa trên việc chia nhỏ một vấn đề thành một tập hợp các chức năng riêng lẻ. Lý tưởng nhất là mọi chức năng chỉ nhận một tập hợp các đối số đầu vào và tạo ra một đầu ra

Trong lập trình hàm, các hàm không có bất kỳ trạng thái bên trong nào ảnh hưởng đến đầu ra mà chúng tạo ra cho một đầu vào nhất định. Điều này có nghĩa là bất cứ khi nào bạn gọi một hàm có cùng một nhóm đối số đầu vào, bạn sẽ nhận được kết quả hoặc đầu ra giống nhau

Trong một chương trình chức năng, dữ liệu đầu vào chảy qua một tập hợp các chức năng. Mỗi chức năng hoạt động trên đầu vào của nó và tạo ra một số đầu ra. Lập trình hàm cố gắng tránh các kiểu dữ liệu có thể thay đổi và thay đổi trạng thái càng nhiều càng tốt. Nó hoạt động với dữ liệu chảy giữa các chức năng

Các tính năng cốt lõi khác của lập trình chức năng bao gồm những điều sau đây

Việc sử dụng đệ quy thay vì vòng lặp hoặc các cấu trúc khác làm cấu trúc điều khiển luồng chính
Tập trung vào xử lý danh sách hoặc mảng
Tập trung vào những gì sẽ được tính toán hơn là cách tính toán nó
Việc sử dụng các chức năng thuần túy tránh tác dụng phụ
Việc sử dụng các hàm bậc cao

Có một số khái niệm quan trọng trong danh sách này. Đây là một cái nhìn sâu hơn về một số trong số họ

Đệ quy là một kỹ thuật trong đó các hàm gọi chính nó, trực tiếp hoặc gián tiếp, để lặp. Nó cho phép một chương trình lặp qua các cấu trúc dữ liệu có độ dài không xác định hoặc không thể đoán trước
Các hàm thuần túy là các hàm không có tác dụng phụ nào cả. Nói cách khác, chúng là các hàm không cập nhật hoặc sửa đổi bất kỳ biến toàn cục, đối tượng hoặc cấu trúc dữ liệu nào trong chương trình. Các hàm này tạo ra một đầu ra chỉ phụ thuộc vào đầu vào, gần với khái niệm hàm toán học hơn
Các hàm bậc cao hơn là các hàm hoạt động trên các hàm khác bằng cách lấy các hàm làm đối số, hàm trả về hoặc cả hai, như với trình trang trí Python

Vì Python là ngôn ngữ lập trình đa mô hình nên nó cung cấp một số công cụ hỗ trợ phong cách lập trình chức năng

Chức năng như các đối tượng hạng nhất
khả năng đệ quy

Hàm ẩn danh với

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Trình vòng lặp và máy phát điện

Các mô-đun tiêu chuẩn như

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

1 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Các công cụ như

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

90,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

91, v.v.

Mặc dù Python không bị ảnh hưởng nhiều bởi các ngôn ngữ lập trình hàm, nhưng vào năm 1993, đã có nhu cầu rõ ràng về một số tính năng lập trình hàm được liệt kê ở trên

Đáp lại, một số công cụ chức năng đã được thêm vào ngôn ngữ. Theo Guido van Rossum, chúng được đóng góp bởi một thành viên cộng đồng

Python đã mua lại

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

4 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

3, nhờ [tôi tin] một hacker Lisp đã bỏ lỡ chúng và gửi các bản vá đang hoạt động. [Nguồn]

Trong những năm qua, các tính năng mới như khả năng hiểu danh sách, biểu thức trình tạo và các hàm tích hợp như

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

90,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

91,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

9 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

8 được xem là sự thay thế Pythonic cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

4 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1. Guido đã lên kế hoạch xóa

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 và thậm chí

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

0 khỏi ngôn ngữ trong Python 3

May mắn thay, việc loại bỏ này không có hiệu lực, chủ yếu là do cộng đồng Python không muốn từ bỏ các tính năng phổ biến như vậy. Chúng vẫn tồn tại và vẫn được sử dụng rộng rãi trong số các nhà phát triển có nền tảng lập trình chức năng vững chắc

Trong hướng dẫn này, bạn sẽ trình bày cách sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python để xử lý các lần lặp và giảm chúng thành một giá trị tích lũy duy nhất mà không cần sử dụng vòng lặp

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

9. Bạn cũng sẽ tìm hiểu về một số công cụ Python mà bạn có thể sử dụng thay cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 để làm cho mã của bạn Pythonic, dễ đọc và hiệu quả hơn

Loại bỏ các quảng cáo

Bắt đầu với

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python thực hiện một kỹ thuật toán học thường được gọi là gấp hoặc rút gọn. Bạn đang thực hiện thao tác gấp hoặc rút gọn khi giảm danh sách các mục thành một giá trị tích lũy duy nhất. Python's

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 hoạt động trên bất kỳ lần lặp nào — không chỉ danh sách — và thực hiện các bước sau

Áp dụng một chức năng [hoặc có thể gọi] cho hai mục đầu tiên trong một lần lặp và tạo một phần kết quả
Sử dụng kết quả từng phần đó, cùng với mục thứ ba trong lần lặp, để tạo một kết quả từng phần khác
Lặp lại quy trình cho đến khi hết khả năng lặp lại và sau đó trả về một giá trị tích lũy duy nhất

Ý tưởng đằng sau

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python là lấy một hàm hiện có, áp dụng tích lũy nó cho tất cả các mục trong một lần lặp và tạo một giá trị cuối cùng duy nhất. Nói chung,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python thuận tiện cho việc xử lý các lần lặp mà không cần viết các vòng lặp

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

9 rõ ràng. Vì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 được viết bằng C, vòng lặp bên trong của nó có thể nhanh hơn vòng lặp Python

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

9 rõ ràng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python ban đầu là một chức năng tích hợp sẵn [và vẫn còn trong Python 2. x], nhưng nó đã được chuyển sang

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

90 trong Python 3. 0. Quyết định này dựa trên một số vấn đề về khả năng đọc và hiệu suất có thể xảy ra

Một lý do khác để chuyển

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 sang

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

1 là việc giới thiệu các hàm tích hợp như

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

91,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

90 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

7, cung cấp các cách hiệu quả hơn, dễ đọc hơn và Pythonic để giải quyết các trường hợp sử dụng phổ biến cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1. Bạn sẽ học cách sử dụng chúng thay thế cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 ở phần sau của hướng dẫn

Trong Trăn 3. x, nếu bạn cần sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1, thì trước tiên bạn phải nhập hàm vào phạm vi hiện tại của mình bằng cách sử dụng câu lệnh

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

102 theo một trong các cách sau

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

103 và sau đó sử dụng các tên đủ điều kiện như

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

105 và sau đó gọi trực tiếp cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Theo tài liệu cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1, chức năng có chữ ký sau

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Tài liệu Python cũng nói rằng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 gần tương đương với hàm Python sau

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Giống như hàm Python này,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 hoạt động bằng cách áp dụng hàm hai đối số cho các mục của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

110 trong một vòng lặp từ trái sang phải, cuối cùng giảm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

110 thành một

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

112 tích lũy duy nhất

Python's

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 cũng chấp nhận đối số thứ ba và tùy chọn có tên là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

114 cung cấp giá trị gốc cho phép tính hoặc phép rút gọn

Trong hai phần tiếp theo, bạn sẽ tìm hiểu sâu về cách hoạt động của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python và ý nghĩa đằng sau mỗi đối số của nó

Các đối số cần thiết.

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

116 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

110

Đối số đầu tiên của hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python là một hàm hai đối số được gọi một cách thuận tiện là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

116. Hàm này sẽ được áp dụng cho các mục trong một lần lặp để tính lũy tích một giá trị cuối cùng

Mặc dù tài liệu chính thức đề cập đến đối số đầu tiên của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 là “một hàm của hai đối số”, nhưng bạn có thể chuyển bất kỳ hàm nào có thể gọi được bằng Python cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 miễn là hàm có thể gọi được chấp nhận hai đối số. Các đối tượng có thể gọi được bao gồm các lớp, các thể hiện triển khai một phương thức đặc biệt có tên là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

122, các phương thức thể hiện, phương thức lớp, phương thức tĩnh và hàm

Ghi chú. Để biết thêm chi tiết về các đối tượng có thể gọi được trong Python, bạn có thể xem tài liệu về Python và cuộn xuống phần “Các loại có thể gọi được. ”

Đối số bắt buộc thứ hai,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

110, sẽ chấp nhận mọi khả năng lặp lại của Python, như tên gọi của nó. Điều này bao gồm danh sách, bộ dữ liệu, đối tượng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

124, trình tạo, trình lặp, bộ, khóa và giá trị từ điển và bất kỳ đối tượng Python nào khác mà bạn có thể lặp lại

Ghi chú. Nếu bạn chuyển một trình vòng lặp tới

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python, thì hàm sẽ cần sử dụng hết trình vòng lặp trước khi bạn có thể nhận được giá trị cuối cùng. Vì vậy, trình lặp trong tay sẽ không còn lười biếng

Để hiểu cách hoạt động của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1, bạn sẽ viết một hàm tính tổng của hai số và in phép toán tương đương ra màn hình. Đây là mã

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Hàm này tính tổng của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

127 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

128, in một thông báo với thao tác sử dụng chuỗi f và trả về kết quả tính toán. Đây là cách nó hoạt động

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

129 là một hàm hai đối số, vì vậy bạn có thể chuyển nó tới

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python cùng với một lần lặp để tính tổng tích lũy của các mục trong lần lặp. Kiểm tra đoạn mã sau sử dụng danh sách các số

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Khi bạn gọi _______ 01, chuyển _______ 6129 và _______ 6133 làm đối số, bạn sẽ nhận được kết quả hiển thị tất cả các hoạt động mà _______ 01 thực hiện để đưa ra kết quả cuối cùng là ____ 6135. Trong trường hợp này, các hoạt động tương đương với

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

136

Cuộc gọi đến

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 trong ví dụ trên áp dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

129 cho hai mục đầu tiên trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133 [

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

140 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

141] và nhận được kết quả là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

141. Sau đó,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 gọi

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

129 bằng cách sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

141 và mục tiếp theo trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133 [là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

147] làm đối số, nhận được kết quả là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

148. Quá trình được lặp lại cho đến khi

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133 hết các mục và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 trả về kết quả cuối cùng là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

135

Loại bỏ các quảng cáo

Đối số tùy chọn.

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

114

Đối số thứ ba cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python, được gọi là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

114, là tùy chọn. Nếu bạn cung cấp một giá trị cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

114, thì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 sẽ cung cấp giá trị đó cho lệnh gọi đầu tiên của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

116 làm đối số đầu tiên của nó

Điều này có nghĩa là lệnh gọi đầu tiên đến

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

116 sẽ sử dụng giá trị của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

114 và mục đầu tiên của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

110 để thực hiện phép tính từng phần đầu tiên của nó. Sau đó,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 tiếp tục làm việc với các mục tiếp theo của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

110

Đây là một ví dụ mà bạn sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

129 với

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

114 được đặt thành

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

165

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Vì bạn cung cấp giá trị của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

165 cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

114, nên

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python sử dụng giá trị đó trong lần gọi đầu tiên làm đối số đầu tiên cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

129. Lưu ý rằng trong lần lặp đầu tiên,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

129 sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

165 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

140, là mục đầu tiên của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133, để thực hiện phép tính

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

174

Một điểm khác cần lưu ý là, nếu bạn cung cấp một giá trị cho ________ 6114, thì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 sẽ thực hiện thêm một lần lặp so với khi không có ________ 6114

Nếu bạn dự định sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 để xử lý các lần lặp có khả năng trống, thì bạn nên cung cấp một giá trị cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

114.

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python sẽ sử dụng giá trị này làm giá trị trả về mặc định khi

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

110 trống. Nếu bạn không cung cấp giá trị

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

114, thì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 sẽ tăng giá trị

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

184. Hãy xem ví dụ sau

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Nếu bạn gọi

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 với một

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

110 trống, thì hàm sẽ trả về giá trị được cung cấp cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

114. Nếu bạn không cung cấp

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

114, thì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 sẽ tăng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

184 khi xử lý các lần lặp trống

Ghi chú. Để tìm hiểu sâu hơn về truy nguyên Python là gì, hãy xem Tìm hiểu về Truy nguyên Python

Bây giờ bạn đã quen với cách hoạt động của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1, bạn đã sẵn sàng học cách áp dụng nó vào một số vấn đề lập trình phổ biến

Giảm Iterables Với Python's

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Cho đến giờ, bạn đã học cách hoạt động của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 trong Python và cách sử dụng nó để giảm số lần lặp bằng hàm do người dùng xác định. Bạn cũng đã học được ý nghĩa của từng đối số đối với

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 và cách chúng hoạt động

Trong phần này, bạn sẽ xem xét một số trường hợp sử dụng phổ biến cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 và cách giải quyết chúng bằng hàm. Bạn cũng sẽ tìm hiểu về một số công cụ Python thay thế mà bạn có thể sử dụng thay cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 để làm cho mã của bạn Pythonic, hiệu quả và dễ đọc hơn

Tổng các giá trị số

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

197 của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python là trường hợp sử dụng tổng. Nó liên quan đến việc tính toán tổng tích lũy của một danh sách các số. Giả sử bạn có một danh sách các số như

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

199. Tổng của nó sẽ là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

800. Đây là một ví dụ nhanh về cách giải quyết vấn đề này bằng vòng lặp Python

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Vòng lặp

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

9 lặp qua mọi giá trị trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133 và tích lũy chúng trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

804. Kết quả cuối cùng là tổng của tất cả các giá trị, trong ví dụ này là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

135. Một biến được sử dụng như

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

804 trong ví dụ này đôi khi được gọi là bộ tích lũy

Đây được cho là trường hợp sử dụng phổ biến nhất cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python. Để thực hiện thao tác này với

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1, bạn có một số tùy chọn. Một số trong số đó bao gồm sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 với một trong các chức năng sau

Hàm do người dùng định nghĩa

Hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Một chức năng được gọi là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

811

Để sử dụng hàm do người dùng xác định, bạn cần viết mã hàm cộng hai số. Sau đó, bạn có thể sử dụng chức năng đó với

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1. Đối với ví dụ này, bạn có thể viết lại

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

129 như sau

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

129 cộng hai số,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

127 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

128, rồi trả về kết quả. Với

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

129 tại chỗ, bạn có thể sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 để tính tổng các giá trị trong Python iterable. Đây là cách

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Cuộc gọi đến

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 áp dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

129 cho các mục trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133 để tính tổng tích lũy của chúng. Kết quả cuối cùng là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

135, như mong đợi

Bạn cũng có thể thực hiện tính toán tương tự bằng cách sử dụng hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

0. Trong trường hợp này, bạn cần một hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

0 lấy hai số làm đối số và trả về tổng của chúng. Hãy xem ví dụ sau

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

0 nhận hai đối số và trả về tổng của chúng.

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 áp dụng hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

0 trong một vòng lặp để tính tổng tích lũy của các mục trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133

Tương tự như vậy, bạn có thể tận dụng một mô-đun Python có tên là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

829. Mô-đun này xuất một loạt các hàm tương ứng với các toán tử nội tại của Python. Đối với vấn đề hiện tại, bạn có thể sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

811 cùng với

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python. Kiểm tra ví dụ sau

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Trong ví dụ này,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

832 nhận hai đối số và trả về tổng của chúng. Vì vậy, bạn có thể sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

832 với

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 để tính tổng tất cả các mục của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133. Vì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

832 được viết bằng C và được tối ưu hóa để đạt hiệu quả, nên đây có thể là lựa chọn tốt nhất của bạn khi sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 để giải quyết trường hợp sử dụng tổng. Lưu ý rằng việc sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

811 cũng dễ đọc hơn so với sử dụng hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Trường hợp sử dụng tổng quá phổ biến trong lập trình Python, kể từ phiên bản 2. 3, đã bao gồm một chức năng tích hợp chuyên dụng,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

6, để giải quyết nó.

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

6 được khai báo là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

842

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

843 là đối số tùy chọn của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

6 và mặc định là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

140. Hàm cộng giá trị của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

843 vào các mục của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

110 từ trái sang phải và trả về tổng. Hãy xem ví dụ sau

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Vì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

6 là hàm tích hợp sẵn nên bạn không cần nhập bất cứ thứ gì. Nó luôn có sẵn cho bạn. Sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

6 là cách Pythonic nhất để giải quyết trường hợp sử dụng tổng. Nó rõ ràng, dễ đọc và súc tích. Nó tuân theo một nguyên tắc cốt lõi của Python

Đơn giản là tốt hơn phức tạp. [Nguồn]

Việc bổ sung

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

6 vào ngôn ngữ là một chiến thắng lớn về khả năng đọc và hiệu suất so với việc sử dụng vòng lặp

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 hoặc

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Ghi chú. Để biết thêm chi tiết về việc so sánh hiệu suất của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 với hiệu suất của các công cụ rút gọn Python khác, hãy xem phần Hiệu suất là chìa khóa

Nếu bạn đang xử lý trường hợp sử dụng tổng, thì thực tiễn tốt khuyên bạn nên sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Loại bỏ các quảng cáo

Nhân các giá trị số

Trường hợp sử dụng sản phẩm của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python khá giống với trường hợp sử dụng tổng, nhưng lần này hoạt động là phép nhân. Nói cách khác, bạn cần tính tích của tất cả các giá trị trong một lần lặp

Ví dụ: giả sử bạn có danh sách

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

199. Sản phẩm của nó sẽ là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

857. Bạn có thể tính toán điều này bằng cách sử dụng vòng lặp Python

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

9. Kiểm tra ví dụ sau

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Vòng lặp lặp lại các mục trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133, nhân từng mục với kết quả của lần lặp trước đó. Trong trường hợp này, giá trị ban đầu cho bộ tích lũy

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

860 phải là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

141 thay vì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

140. Vì bất kỳ số nào nhân với 0 đều bằng 0, nên giá trị bắt đầu bằng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

140 sẽ luôn làm cho sản phẩm của bạn bằng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

140

Tính toán này cũng là một trường hợp sử dụng khá phổ biến cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python. Một lần nữa, bạn sẽ đề cập đến ba cách để giải quyết vấn đề. Bạn sẽ sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 với

Hàm do người dùng định nghĩa

Hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Một chức năng được gọi là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

868

Đối với tùy chọn 1, bạn sẽ cần viết mã một hàm tùy chỉnh nhận hai đối số và trả về tích của chúng. Sau đó, bạn sẽ sử dụng hàm này với

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 để tính tích của các mục trong một lần lặp. Hãy xem đoạn mã sau

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

870 nhân hai số,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

127 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

128. Cuộc gọi đến

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 lặp lại các mục của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133 và tính tích của chúng bằng cách áp dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

870 cho các mục kế tiếp. Kết quả cuối cùng là tích của tất cả các mục trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133, trong ví dụ này là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

877

Nếu bạn muốn sử dụng hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

0 để giải quyết trường hợp sử dụng này, thì bạn cần một hàm nhận hai đối số và trả về tích của chúng. Đây là một ví dụ

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Hàm ẩn danh thực hiện điều kỳ diệu bằng cách nhân các mục liên tiếp trong khi

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 lặp lại trên

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133. Một lần nữa, kết quả là tích của tất cả các mục trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133

Bạn cũng có thể sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

868 để giải quyết trường hợp sử dụng sản phẩm.

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

868 lấy hai số và trả về kết quả của phép nhân chúng. Đây là chức năng phù hợp để giải quyết vấn đề trong tầm tay. Kiểm tra ví dụ sau

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Vì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

884 được tối ưu hóa cao, mã của bạn sẽ hoạt động tốt hơn nếu bạn sử dụng hàm này thay vì hàm do người dùng xác định hoặc hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

0. Lưu ý rằng giải pháp này cũng dễ đọc hơn nhiều

Cuối cùng, nếu bạn đang sử dụng Python 3. 8, thì bạn có quyền truy cập vào một giải pháp Pythonic và dễ đọc hơn cho trường hợp sử dụng này. Trăn 3. 8 đã thêm một chức năng mới có tên là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

886, nằm trong mô-đun Python

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

887. Hàm này tương tự như hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

6 nhưng trả về tích của một giá trị

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

843 nhân với một số

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

110

Trong trường hợp của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

891, đối số

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

843 là tùy chọn và mặc định là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

141. Đây là cách nó hoạt động

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Đây cũng là một chiến thắng lớn về khả năng đọc và hiệu quả so với việc sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1. Vì vậy, nếu bạn đang sử dụng Python 3. 8 và giảm sản phẩm là một hoạt động phổ biến trong mã của bạn, thì bạn sẽ được phục vụ tốt hơn bằng cách sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

891 thay vì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python

Loại bỏ các quảng cáo

Tìm giá trị tối thiểu và tối đa

Vấn đề tìm giá trị tối thiểu và tối đa trong một lần lặp cũng là một vấn đề rút gọn mà bạn có thể giải quyết bằng cách sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python. Ý tưởng là so sánh các mục trong iterable để tìm giá trị tối thiểu hoặc tối đa

Giả sử bạn có danh sách các số

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

898. Trong danh sách này, giá trị nhỏ nhất là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

141 và giá trị lớn nhất là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

100. Để tìm những giá trị này, bạn có thể sử dụng vòng lặp Python

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

9. Kiểm tra đoạn mã sau

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Cả hai vòng lặp lặp lại các mục trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

102 và cập nhật giá trị của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

103 hoặc

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

104 theo kết quả so sánh liên tiếp. Lưu ý rằng ban đầu,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

103 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

104 giữ số

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

148, là giá trị đầu tiên trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133. Biến

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

102 giữ các giá trị còn lại trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133. Nói cách khác,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

111

Ghi chú. Trong các ví dụ trên, bạn sử dụng toán tử giải nén lặp lại Python [

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

112] để giải nén hoặc mở rộng các giá trị trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133 thành hai biến. Trong trường hợp đầu tiên, hiệu ứng ròng là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

103 nhận giá trị đầu tiên trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133, là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

148 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

102 thu thập các giá trị còn lại trong danh sách

Kiểm tra các chi tiết trong các ví dụ sau

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Toán tử giải nén có thể lặp lại của Python [

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

112] rất hữu ích khi bạn cần giải nén một chuỗi hoặc có thể lặp lại thành nhiều biến

Để hiểu rõ hơn về các thao tác giải nén trong Python, bạn có thể tham khảo PEP 3132 Extended Iterable Unpacking và PEP 448 Extra Unpacking Generalizations

Bây giờ, hãy nghĩ về cách bạn có thể tìm thấy giá trị tối thiểu và tối đa trong một lần lặp bằng cách sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python. Một lần nữa, bạn có thể sử dụng hàm do người dùng xác định hoặc hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

0 tùy theo nhu cầu của bạn

Đoạn mã sau triển khai một giải pháp sử dụng hai hàm khác nhau do người dùng xác định. Hàm đầu tiên sẽ nhận hai đối số,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

127 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

128, đồng thời trả về giá trị nhỏ nhất của chúng. Hàm thứ hai sẽ sử dụng quy trình tương tự nhưng sẽ trả về giá trị lớn nhất

Dưới đây là các hàm và cách bạn có thể sử dụng chúng với

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python để tìm giá trị tối thiểu và tối đa trong một lần lặp

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Khi bạn chạy

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 với

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

125 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

126, bạn sẽ nhận được giá trị tối thiểu và tối đa trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133, tương ứng.

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 lặp lại các mục của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133, so sánh chúng theo cặp tích lũy và cuối cùng trả về giá trị tối thiểu hoặc tối đa

Ghi chú. Để triển khai

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

125 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

126, bạn đã sử dụng biểu thức điều kiện Python hoặc toán tử bậc ba, làm giá trị

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

132. Để tìm hiểu sâu hơn về biểu thức điều kiện là gì và cách chúng hoạt động, hãy xem Câu lệnh có điều kiện trong Python [if/elif/else]

Bạn cũng có thể sử dụng hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

0 để giải bài toán cực tiểu và cực đại. Hãy xem các ví dụ sau

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Lần này, bạn sử dụng hai hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

0 để tìm xem liệu ________ 6127 có nhỏ hơn hoặc lớn hơn ________ 6128 hay không. Trong trường hợp này,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python áp dụng hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

0 cho từng giá trị trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

133, so sánh nó với kết quả của phép tính trước đó. Khi kết thúc quá trình, bạn nhận được giá trị tối thiểu hoặc tối đa

Vấn đề tối thiểu và tối đa phổ biến trong lập trình đến nỗi Python đã thêm các hàm tích hợp để thực hiện các phép giảm này. Các chức năng này được gọi thuận tiện là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

90 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

91 và bạn không cần nhập bất kỳ thứ gì để có thể sử dụng chúng. Đây là cách họ làm việc

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Khi bạn sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

90 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

91 để tìm mục tối thiểu và tối đa trong một lần lặp, mã của bạn dễ đọc hơn nhiều so với việc sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python. Ngoài ra, vì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

90 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

91 là các hàm C được tối ưu hóa cao, nên bạn cũng có thể nói rằng mã của mình sẽ hiệu quả hơn

Vì vậy, khi giải quyết vấn đề này bằng Python, tốt nhất nên sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

90 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

91 thay vì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Kiểm tra xem tất cả các giá trị có đúng không

Trường hợp sử dụng hoàn toàn đúng của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python liên quan đến việc tìm hiểu xem tất cả các mục trong một lần lặp có đúng hay không. Để giải quyết vấn đề này, bạn có thể sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 cùng với hàm do người dùng xác định hoặc hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Bạn sẽ bắt đầu bằng cách viết mã một vòng lặp

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

9 để tìm hiểu xem tất cả các mục trong một lần lặp có đúng không. Đây là mã

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Nếu tất cả các giá trị trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

110 là đúng, thì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

155 trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156. Nếu không, nó sẽ trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157. Nó cũng trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156 với các lần lặp trống.

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

155 thực hiện đánh giá ngắn mạch. Điều này có nghĩa là hàm trả về ngay khi tìm thấy giá trị sai mà không xử lý phần còn lại của các mục trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

110

Để giải quyết vấn đề này bằng cách sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python, bạn sẽ cần viết một hàm nhận hai đối số và trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156 nếu cả hai đối số đều đúng. Nếu một hoặc cả hai đối số là sai, thì hàm sẽ trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157. Đây là mã

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Hàm này nhận hai đối số,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

127 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

128. Sau đó, bạn sử dụng toán tử

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

166 để kiểm tra xem cả hai đối số có đúng không. Giá trị trả về sẽ là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156 nếu cả hai đối số đều đúng. Nếu không, nó sẽ là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157

Trong Python, các đối tượng sau được coi là sai

Các hằng số như

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

169 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157

Các loại số có giá trị bằng 0 như

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

140,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

172,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

173,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

174 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

175

Các dãy và tập rỗng như

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

176,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

177,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

178,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

179,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

180 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

181

Các đối tượng triển khai

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

182 với giá trị trả về là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157 hoặc

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

184 với giá trị trả về là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

140

Bất kỳ đối tượng nào khác sẽ được coi là đúng

Bạn cần sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

186 để chuyển đổi giá trị trả về của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

166 thành

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156 hoặc

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157. Nếu bạn không sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

186 thì hàm của bạn sẽ không hoạt động như mong đợi vì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

166 trả về một trong các đối tượng trong biểu thức thay vì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156 hoặc

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157. Kiểm tra các ví dụ sau

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

166 trả về giá trị đầu tiên trong biểu thức nếu nó sai. Mặt khác, nó trả về giá trị cuối cùng trong biểu thức bất kể giá trị thực của nó là gì. Đó là lý do tại sao bạn cần sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

186 trong trường hợp này.

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

186 trả về giá trị Boolean [

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156 hoặc

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157] do đánh giá một biểu thức Boolean hoặc một đối tượng. Kiểm tra các ví dụ sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

186

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

186 sẽ luôn trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156 hoặc

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157 sau khi đánh giá biểu thức hoặc đối tượng trong tầm tay

Ghi chú. Để hiểu rõ hơn về toán tử và biểu thức Python, bạn có thể xem qua Toán tử và biểu thức trong Python

Bạn có thể chuyển

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

03 đến

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 để kiểm tra xem tất cả các mục của một lần lặp có đúng hay không. Đây là cách nó hoạt động

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Nếu bạn chuyển

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

03 làm đối số cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1, thì bạn sẽ nhận được

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156 nếu tất cả các mục trong lần lặp là đúng. Nếu không, bạn sẽ nhận được

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157

Trong ví dụ thứ ba, bạn chuyển

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156 đến

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

114 của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 để có hành vi tương tự như

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

155 và để tránh

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

184

Bạn cũng có thể sử dụng hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

0 để giải quyết trường hợp sử dụng hoàn toàn đúng của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1. Dưới đây là một số ví dụ

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

0 này khá giống với hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

03 và sử dụng cùng một biểu thức làm giá trị trả về. Nó trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156 nếu cả hai đối số đều đúng. Nếu không, nó sẽ trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157

Lưu ý rằng không giống như

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

155, khi bạn sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 để giải quyết trường hợp sử dụng hoàn toàn đúng, sẽ không có đánh giá đoản mạch vì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 không quay lại cho đến khi nó đi qua toàn bộ quá trình lặp lại. Điều này có thể thêm thời gian xử lý cho mã của bạn

Ví dụ: giả sử bạn có danh sách

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

23 và bạn cần kiểm tra xem tất cả các mục trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

24 có đúng không. Trong trường hợp này,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

155 sẽ kết thúc ngay khi vòng lặp của nó xử lý cặp mục đầu tiên [

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

141 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

140] vì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

140 là sai. Bạn không cần phải tiếp tục lặp lại vì bạn đã có câu trả lời cho vấn đề trong tay

Mặt khác, giải pháp

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 sẽ không hoàn thành cho đến khi nó xử lý tất cả các mục trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

24. Đó là năm lần lặp lại sau. Bây giờ hãy tưởng tượng điều này sẽ ảnh hưởng gì đến hiệu suất mã của bạn nếu bạn đang xử lý một lần lặp lớn

May mắn thay, Python cung cấp công cụ phù hợp để giải quyết vấn đề hoàn toàn đúng theo cách Pythonic, dễ đọc và hiệu quả. chức năng tích hợp sẵn

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Bạn có thể sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

32 để kiểm tra xem tất cả các mục trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

110 có đúng không. Đây là cách hoạt động của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

9 vòng lặp qua các mục trong một lần lặp, kiểm tra giá trị thực của từng mục. Nếu

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

9 tìm thấy một mục sai, thì nó sẽ trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157. Nếu không, nó sẽ trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156. Nếu bạn gọi

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

9 với một iterable trống, thì bạn nhận được

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156 vì không có mục sai nào trong một iterable trống

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

9 là một hàm C được tối ưu hóa cho hiệu suất. Chức năng này cũng được thực hiện bằng cách sử dụng đánh giá ngắn mạch. Vì vậy, nếu bạn đang giải quyết vấn đề hoàn toàn đúng trong Python, thì bạn nên cân nhắc sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

9 thay vì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Loại bỏ các quảng cáo

Kiểm tra xem có giá trị nào là đúng không

Một trường hợp sử dụng phổ biến khác cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python là trường hợp sử dụng any-true. Lần này, bạn cần tìm hiểu xem ít nhất một mục trong một lần lặp có đúng không. Để giải quyết vấn đề này, bạn cần viết một hàm nhận một iterable và trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156 nếu bất kỳ mục nào trong iterable là true và ngược lại là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157. Hãy xem cách triển khai sau đây cho chức năng này

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Nếu ít nhất một mục trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

110 là đúng, thì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

48 trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156. Nó chỉ trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157 nếu tất cả các mục là sai hoặc nếu iterable trống. Hàm này cũng thực hiện đánh giá ngắn mạch vì nó trả về ngay khi tìm thấy giá trị thực, nếu có

Để giải quyết vấn đề này bằng cách sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python, bạn cần viết mã một hàm nhận hai đối số và trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156 nếu ít nhất một trong số chúng là đúng. Nếu cả hai đều sai, thì hàm sẽ trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157

Đây là một triển khai khả thi cho chức năng này

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

54 trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156 nếu ít nhất một trong các đối số của nó là đúng. Nếu cả hai đối số đều sai, thì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

54 trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157. Như với

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

03 trong phần trên,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

54 sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

186 để chuyển đổi kết quả của biểu thức

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

61 thành

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156 hoặc

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157

Toán tử Python

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

64 hoạt động hơi khác so với

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

166. Nó trả về đối tượng thực sự đầu tiên hoặc đối tượng cuối cùng trong biểu thức. Kiểm tra các ví dụ sau

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Toán tử Python

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

64 trả về đối tượng đúng đầu tiên hoặc, nếu cả hai đều sai, đối tượng cuối cùng. Vì vậy, bạn cũng cần sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

186 để nhận giá trị trả về nhất quán từ

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Khi bạn đã có chức năng này, bạn có thể tiếp tục giảm. Hãy xem các cuộc gọi sau tới

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Bạn đã giải quyết vấn đề bằng cách sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python. Lưu ý rằng trong ví dụ thứ ba, bạn chuyển

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157 cho trình khởi tạo của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 để tái tạo hành vi của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

48 ban đầu và cũng để tránh một

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

184

Ghi chú. Giống như các ví dụ trong phần trước, các ví dụ về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 này không thực hiện đánh giá ngắn mạch. Điều đó có nghĩa là chúng có thể ảnh hưởng đến hiệu suất mã của bạn

Bạn cũng có thể sử dụng hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

0 với

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 để giải quyết trường hợp sử dụng any-true. Đây là cách bạn có thể làm điều đó

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

0 này khá giống với hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

54. Nó trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156 nếu một trong hai đối số của nó là đúng. Nếu cả hai đối số đều sai, thì nó trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157

Mặc dù giải pháp này chỉ cần một dòng mã nhưng nó vẫn có thể khiến mã của bạn không thể đọc được hoặc ít nhất là khó hiểu. Một lần nữa, Python cung cấp một công cụ để giải quyết vấn đề bất kỳ đúng một cách hiệu quả mà không cần sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1. chức năng tích hợp sẵn

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

84 lặp lại các mục trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

110, kiểm tra giá trị thực của từng mục cho đến khi tìm thấy mục thực. Hàm trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156 ngay khi tìm thấy giá trị thực. Nếu

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

8 không tìm thấy giá trị thực, thì nó trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157. Đây là một ví dụ

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Một lần nữa, bạn không cần nhập

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

8 để sử dụng nó trong mã của mình.

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

8 hoạt động như mong đợi. Nó trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157 nếu tất cả các mục trong iterable là sai. Nếu không, nó sẽ trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

156. Lưu ý rằng nếu bạn gọi

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

8 với một iterable trống, thì bạn nhận được

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

157 vì không có mục thực sự nào trong một iterable trống

Như với

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

8 là một hàm C được tối ưu hóa cho hiệu suất. Nó cũng được thực hiện bằng cách sử dụng đánh giá ngắn mạch. Vì vậy, nếu bạn đang giải quyết vấn đề bất kỳ trong Python, thì hãy cân nhắc sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

8 thay vì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Loại bỏ các quảng cáo

So sánh

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Một hàm Python có tên là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

00 tồn tại trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

2 và hoạt động tương tự như

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

04 chấp nhận một đối số bắt buộc,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

110, có thể là bất kỳ Python iterable nào. Đối số thứ hai tùy chọn,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

06, cần phải là một hàm [hoặc một đối tượng có thể gọi được] nhận hai đối số và trả về một giá trị

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

00 trả về một iterator. Mỗi mục trong trình vòng lặp này sẽ là kết quả tích lũy của phép tính mà

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

06 thực hiện. Tính toán mặc định là tổng. Nếu bạn không cung cấp hàm cho

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

00, thì mỗi mục trong trình vòng lặp kết quả sẽ là tổng tích lũy của các mục trước đó trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

110 cộng với mục hiện có

Kiểm tra các ví dụ sau

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Lưu ý rằng giá trị cuối cùng trong trình vòng lặp kết quả là cùng một giá trị mà

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 trả về. Đây là điểm tương đồng chính giữa hai chức năng này

Ghi chú. Vì

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

00 trả về một trình vòng lặp, nên bạn cần gọi

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

13 để sử dụng trình vòng lặp và lấy một đối tượng danh sách làm đầu ra

Mặt khác, nếu bạn cung cấp hàm hai đối số [hoặc có thể gọi được] cho đối số

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

06 của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

00, thì các mục trong trình vòng lặp kết quả sẽ là kết quả tích lũy của phép tính được thực hiện bởi

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

06. Đây là một ví dụ sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

868

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Trong ví dụ này, một lần nữa bạn có thể thấy rằng mục cuối cùng trong giá trị được trả về của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

00 bằng với giá trị được trả về của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Xem xét hiệu suất và khả năng đọc

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python có thể có hiệu suất rất tệ vì nó hoạt động bằng cách gọi hàm nhiều lần. Điều này có thể làm cho mã của bạn chậm và không hiệu quả. Việc sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 cũng có thể ảnh hưởng đến khả năng đọc mã của bạn khi bạn sử dụng nó với các hàm phức tạp do người dùng xác định hoặc các hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Xuyên suốt hướng dẫn này, bạn đã học được rằng Python cung cấp một loạt công cụ có thể thay thế

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 một cách duyên dáng, ít nhất là cho các trường hợp sử dụng chính của nó. Dưới đây là những điểm chính của bài đọc của bạn cho đến thời điểm này

Sử dụng một chức năng chuyên dụng để giải quyết các trường hợp sử dụng cho Python's

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 bất cứ khi nào có thể. Các hàm như

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

91,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

90,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

891, v.v. sẽ giúp mã của bạn nhanh hơn, dễ đọc hơn, dễ bảo trì hơn và Pythonic

Tránh các hàm phức tạp do người dùng định nghĩa khi sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1. Những loại chức năng này có thể làm cho mã của bạn khó đọc và khó hiểu. Thay vào đó, bạn có thể sử dụng vòng lặp

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

9 rõ ràng và dễ đọc

Tránh các hàm phức tạp của

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

0 khi sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1. Chúng cũng có thể làm cho mã của bạn khó đọc và khó hiểu

Điểm thứ hai và thứ ba là mối quan tâm của chính Guido khi anh ấy nói như sau

Vì vậy, bây giờ
>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10
1. Đây thực sự là điều tôi luôn ghét nhất, bởi vì, ngoài một vài ví dụ liên quan đến
>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110
37 hoặc
>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110
112, hầu như mỗi khi tôi thấy một cuộc gọi
>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10
1 với một đối số chức năng không tầm thường, tôi cần phải lấy bút và giấy để vẽ biểu đồ. . Vì vậy, theo suy nghĩ của tôi, khả năng áp dụng của
>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10
1 bị giới hạn khá nhiều đối với các toán tử kết hợp và trong tất cả các trường hợp khác, tốt hơn hết là viết ra vòng lặp tích lũy một cách rõ ràng. [Nguồn]

Hai phần tiếp theo sẽ giúp bạn thực hiện lời khuyên chung này trong mã của bạn. Họ cũng cung cấp thêm một số lời khuyên giúp bạn sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python một cách hiệu quả khi bạn thực sự cần sử dụng nó

Hiệu suất là chìa khóa

Nếu bạn định sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 để giải quyết các trường hợp sử dụng mà bạn đã trình bày trong hướng dẫn này, thì mã của bạn sẽ chậm hơn đáng kể so với mã sử dụng các hàm dựng sẵn chuyên dụng. Trong các ví dụ sau, bạn sẽ sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

44 để đo nhanh thời gian thực thi của các đoạn mã Python nhỏ và biết được hiệu suất chung của chúng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

45 có một số đối số, nhưng đối với những ví dụ này, bạn sẽ chỉ cần sử dụng các đối số sau

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

46 giữ tuyên bố rằng bạn cần thời gian

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

47 nhận các câu lệnh bổ sung cho thiết lập chung, như câu lệnh

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

102

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

49 giữ một từ điển chứa không gian tên chung mà bạn cần sử dụng để chạy

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Hãy xem các ví dụ sau đây về trường hợp sử dụng tổng bằng cách sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 với các công cụ khác nhau và sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

6 của Python cho mục đích so sánh

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Mặc dù bạn sẽ nhận được các số khác nhau tùy thuộc vào phần cứng của mình, nhưng bạn có thể sẽ nhận được phép đo thời gian tốt nhất bằng cách sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

6. Hàm tích hợp này cũng là giải pháp Pythonic dễ đọc nhất cho bài toán tổng

Ghi chú. Để biết thêm cách tiếp cận chi tiết về cách tính thời gian cho mã của bạn, hãy xem Các hàm hẹn giờ trong Python. Ba cách để theo dõi mã của bạn

Lựa chọn tốt thứ hai của bạn là sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 với

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

811. Các chức năng trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

829 được viết bằng C và được tối ưu hóa cao cho hiệu suất. Vì vậy, chúng nên hoạt động tốt hơn hàm do người dùng xác định, hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

0 hoặc vòng lặp

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Loại bỏ các quảng cáo

Số lượng khả năng đọc

Khả năng đọc mã cũng là một mối quan tâm quan trọng khi sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python. Mặc dù

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 nói chung sẽ hoạt động tốt hơn vòng lặp Python

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

9, nhưng như chính Guido đã nói, một vòng lặp Pythonic sạch sẽ thường dễ theo dõi hơn so với sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Có gì mới trong Python 3. 0 củng cố ý tưởng này khi nói như sau

Sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

90 nếu bạn thực sự cần nó; . [Nguồn]

Để hiểu rõ hơn về tầm quan trọng của khả năng đọc, hãy tưởng tượng rằng bạn đang bắt đầu học Python và đang cố gắng giải một bài tập về tính tổng của tất cả các số chẵn trong một phép lặp.

Nếu bạn đã biết về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python và đã thực hiện một số lập trình chức năng trong quá khứ, thì bạn có thể đưa ra giải pháp sau

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

Trong chức năng này, bạn sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 để cộng dồn các số chẵn trong một lần lặp. Hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

0 nhận hai đối số,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

68 và

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

69, rồi trả về tổng của chúng nếu chúng chẵn. Mặt khác, nó trả về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

68, giữ kết quả của tổng trước đó

Ngoài ra, bạn đặt

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

114 thành

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

140 vì nếu không, tổng của bạn sẽ có giá trị ban đầu là

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

141 [giá trị đầu tiên trong

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

110], đây không phải là số chẵn và sẽ gây ra lỗi cho hàm của bạn

Chức năng hoạt động như bạn mong đợi và bạn hài lòng với kết quả. Tuy nhiên, bạn tiếp tục đào sâu vào Python và tìm hiểu về

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

6 và các biểu thức trình tạo. Bạn quyết định làm lại chức năng của mình bằng các công cụ mới này và chức năng của bạn bây giờ trông như sau

>>>

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

Khi bạn nhìn vào mã này, bạn cảm thấy thực sự tự hào, và bạn nên. Bạn đã làm một công việc tuyệt vời. Đó là một hàm Python tuyệt đẹp gần như đọc bằng tiếng Anh đơn giản. Nó cũng hiệu quả và Pythonic. Bạn nghĩ sao?

Phần kết luận

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python cho phép bạn thực hiện các thao tác rút gọn trên các lần lặp bằng cách sử dụng các hàm có thể gọi Python và các hàm

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 áp dụng một chức năng cho các mục trong một lần lặp và giảm chúng thành một giá trị tích lũy duy nhất

Trong hướng dẫn này, bạn đã học

Giảm hoặc gấp là gì và khi nào nó có thể hữu ích

Cách sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 của Python để giải các bài toán rút gọn phổ biến như tính tổng hoặc nhân các số

Những công cụ Pythonic nào bạn có thể sử dụng để thay thế hiệu quả

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 trong mã của mình

Với kiến thức này, bạn sẽ có thể quyết định công cụ nào phù hợp nhất với nhu cầu mã hóa của mình khi giải quyết các vấn đề rút gọn trong Python

Trong những năm qua,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 đã được thay thế bằng nhiều công cụ Pythonic hơn như

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

90,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers, 100]
100 + 0 = 100
100 + 1 = 101
101 + 2 = 103
103 + 3 = 106
106 + 4 = 110
110

8, trong số những công cụ khác. Tuy nhiên,

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 vẫn còn đó và vẫn phổ biến trong giới lập trình viên chức năng. Nếu bạn có câu hỏi hoặc suy nghĩ về việc sử dụng

>>> from functools import reduce

>>> numbers = [0, 1, 2, 3, 4]

>>> reduce[my_add, numbers]
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10

1 hoặc bất kỳ giải pháp thay thế Python nào của nó, thì hãy nhớ đăng chúng trong phần nhận xét bên dưới

Đánh dấu là đã hoàn thành

🐍 Thủ thuật Python 💌

Nhận một Thủ thuật Python ngắn và hấp dẫn được gửi đến hộp thư đến của bạn vài ngày một lần. Không có thư rác bao giờ. Hủy đăng ký bất cứ lúc nào. Được quản lý bởi nhóm Real Python

Gửi cho tôi thủ thuật Python »

Giới thiệu về Leodanis Pozo Ramos

Leodanis là một kỹ sư công nghiệp yêu thích Python và phát triển phần mềm. Anh ấy là một nhà phát triển Python tự học với hơn 6 năm kinh nghiệm. Anh ấy là một nhà văn đam mê kỹ thuật với số lượng bài báo được xuất bản ngày càng tăng trên Real Python và các trang web khác

» Tìm hiểu thêm về Leodanis

Mỗi hướng dẫn tại Real Python được tạo bởi một nhóm các nhà phát triển để nó đáp ứng các tiêu chuẩn chất lượng cao của chúng tôi. Các thành viên trong nhóm đã làm việc trong hướng dẫn này là

Aldren

Geir Arne

Joanna

Gia-cốp

Mirko

Bậc thầy Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng nghìn hướng dẫn, khóa học video thực hành và cộng đồng các Pythonista chuyên gia

Nâng cao kỹ năng Python của bạn »

Bậc thầy Kỹ năng Python trong thế giới thực
Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng Pythonistas chuyên gia

Nâng cao kỹ năng Python của bạn »

Bạn nghĩ sao?

Đánh giá bài viết này

Tweet Chia sẻ Chia sẻ Email

Bài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?

Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. Nhận các mẹo để đặt câu hỏi hay và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi

Bạn có thể thay đổi độ dài của danh sách trong Python không?

Các. phương thức mở rộng[] sẽ tăng độ dài của danh sách theo số phần tử được cung cấp cho phương thức , vì vậy nếu bạn muốn thêm nhiều phần tử vào danh sách .

Bạn có thể sử dụng LEN[] trong danh sách không?

Hàm len[] là một trong những hàm có sẵn của Python. Nó trả về chiều dài của một đối tượng. Ví dụ: nó có thể trả về số lượng mục trong danh sách . Bạn có thể sử dụng hàm với nhiều kiểu dữ liệu khác nhau.

Khám phá lập trình chức năng trong Python

Bắt đầu với >>> from functools import reduce >>> numbers = [0, 1, 2, 3, 4] >>> reduce[my_add, numbers] 0 + 1 = 1 1 + 2 = 3 3 + 3 = 6 6 + 4 = 10 10 1 của Python

Đối số tùy chọn. >>> from functools import reduce >>> numbers = [0, 1, 2, 3, 4] >>> reduce[my_add, numbers] 0 + 1 = 1 1 + 2 = 3 3 + 3 = 6 6 + 4 = 10 10 114

Giảm Iterables Với Python's >>> from functools import reduce >>> numbers = [0, 1, 2, 3, 4] >>> reduce[my_add, numbers] 0 + 1 = 1 1 + 2 = 3 3 + 3 = 6 6 + 4 = 10 10 1

Tổng các giá trị số

Nhân các giá trị số

Tìm giá trị tối thiểu và tối đa

Kiểm tra xem tất cả các giá trị có đúng không

Kiểm tra xem có giá trị nào là đúng không

Xem xét hiệu suất và khả năng đọc

Hiệu suất là chìa khóa

Số lượng khả năng đọc

Phần kết luận

Bạn có thể thay đổi độ dài của danh sách trong Python không?

Bạn có thể sử dụng LEN[] trong danh sách không?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề

Bắt đầu với
`>>> from functools import reduce >>> numbers = [0, 1, 2, 3, 4] >>> reduce[my_add, numbers] 0 + 1 = 1 1 + 2 = 3 3 + 3 = 6 6 + 4 = 10 10`
1 của Python

Đối số tùy chọn.
`>>> from functools import reduce >>> numbers = [0, 1, 2, 3, 4] >>> reduce[my_add, numbers] 0 + 1 = 1 1 + 2 = 3 3 + 3 = 6 6 + 4 = 10 10`
114

Giảm Iterables Với Python's
`>>> from functools import reduce >>> numbers = [0, 1, 2, 3, 4] >>> reduce[my_add, numbers] 0 + 1 = 1 1 + 2 = 3 3 + 3 = 6 6 + 4 = 10 10`
1