Python là khai báo hay thủ tục?

Giới thiệu

Phần này giải thích khái niệm cơ bản về lập trình chức năng;

Ngôn ngữ lập trình hỗ trợ phân tách vấn đề theo nhiều cách khác nhau

• Hầu hết các ngôn ngữ lập trình là thủ tục. chương trình là danh sách các hướng dẫn cho máy tính biết phải làm gì với đầu vào của chương trình. C, Pascal và thậm chí Unix shell là các ngôn ngữ thủ tục

• Trong các ngôn ngữ khai báo, bạn viết một đặc tả mô tả vấn đề cần giải quyết và ngôn ngữ triển khai tìm ra cách thực hiện tính toán hiệu quả. SQL là ngôn ngữ khai báo mà bạn có thể quen thuộc nhất;

• Các chương trình hướng đối tượng thao tác các tập hợp các đối tượng. Các đối tượng có trạng thái bên trong và hỗ trợ các phương thức truy vấn hoặc sửa đổi trạng thái bên trong này theo một cách nào đó. Smalltalk và Java là ngôn ngữ hướng đối tượng. C++ và Python là những ngôn ngữ hỗ trợ lập trình hướng đối tượng, nhưng không bắt buộc sử dụng các tính năng hướng đối tượng

• Lập trình chức năng phân tách một vấn đề thành một tập hợp các chức năng. Lý tưởng nhất là các hàm chỉ nhận đầu vào và tạo đầu ra và không có bất kỳ trạng thái bên trong nào ảnh hưởng đến đầu ra được tạo cho một đầu vào nhất định. Các ngôn ngữ chức năng nổi tiếng bao gồm họ ML [ML tiêu chuẩn, OCaml và các biến thể khác] và Haskell

Các nhà thiết kế của một số ngôn ngữ máy tính chọn nhấn mạnh một cách tiếp cận cụ thể để lập trình. Điều này thường gây khó khăn khi viết chương trình sử dụng cách tiếp cận khác. Các ngôn ngữ khác là ngôn ngữ đa mô hình hỗ trợ một số cách tiếp cận khác nhau. Lisp, C++ và Python là đa mô hình; . Trong một chương trình lớn, các phần khác nhau có thể được viết bằng các cách tiếp cận khác nhau;

Trong một chương trình chức năng, đầ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. Kiểu chức năng không khuyến khích các chức năng có tác dụng phụ sửa đổi trạng thái bên trong hoặc thực hiện các thay đổi khác không hiển thị trong giá trị trả về của chức năng. Các chức năng hoàn toàn không có tác dụng phụ được gọi là chức năng thuần túy. Tránh tác dụng phụ có nghĩa là không sử dụng cấu trúc dữ liệu được cập nhật khi chương trình chạy;

Một số ngôn ngữ rất nghiêm ngặt về độ tinh khiết và thậm chí không có các câu lệnh gán chẳng hạn như

for line in file:
    # do something for each line
    ...

for line in file:
    # do something for each line
    ...

Các chương trình Python được viết theo kiểu chức năng thường sẽ không đi đến mức cực đoan là tránh tất cả I/O hoặc tất cả các nhiệm vụ; . Ví dụ: việc triển khai một hàm sẽ vẫn sử dụng phép gán cho các biến cục bộ, nhưng sẽ không sửa đổi các biến toàn cục hoặc có các tác dụng phụ khác

Lập trình hàm có thể được coi là đối lập với lập trình hướng đối tượng. Các đối tượng là những viên nang nhỏ chứa một số trạng thái bên trong cùng với một tập hợp các lệnh gọi phương thức cho phép bạn sửa đổi trạng thái này và các chương trình bao gồm việc thực hiện đúng tập hợp các thay đổi trạng thái. Lập trình hàm muốn tránh thay đổi trạng thái càng nhiều càng tốt và hoạt động với dữ liệu chảy giữa các hàm. Trong Python, bạn có thể kết hợp hai cách tiếp cận bằng cách viết các hàm nhận và trả về các thể hiện đại diện cho các đối tượng trong ứng dụng của bạn [e-mail, giao dịch, v.v. ]

Thiết kế theo chức năng có vẻ như là một hạn chế kỳ lạ để làm việc theo. Tại sao bạn nên tránh các đối tượng và tác dụng phụ?

• khả năng chứng minh chính thức

• tính mô đun

• Khả năng kết hợp

• Dễ gỡ lỗi và thử nghiệm

vòng lặp

Tôi sẽ bắt đầu bằng cách xem xét một tính năng của ngôn ngữ Python, đây là nền tảng quan trọng để viết các chương trình kiểu chức năng. vòng lặp

Trình vòng lặp là một đối tượng đại diện cho một luồng dữ liệu; . Trình lặp Python phải hỗ trợ một phương thức được gọi là không có đối số và luôn trả về phần tử tiếp theo của luồng. Nếu không còn phần tử nào trong luồng, phải tăng ngoại lệ. Tuy nhiên, các trình vòng lặp không nhất thiết phải là hữu hạn;

Hàm tích hợp nhận một đối tượng tùy ý và cố gắng trả về một trình vòng lặp sẽ trả về nội dung hoặc phần tử của đối tượng, tăng nếu đối tượng không hỗ trợ phép lặp. Một số kiểu dữ liệu có sẵn của Python hỗ trợ phép lặp, phổ biến nhất là danh sách và từ điển. Một đối tượng được gọi nếu bạn có thể lấy một trình vòng lặp cho nó

Bạn có thể thử nghiệm giao diện lặp theo cách thủ công

>>> L = [1, 2, 3]
>>> it = iter[L]
>>> it  

>>> it.__next__[]  # same as next[it]
1
>>> next[it]
2
>>> next[it]
3
>>> next[it]
Traceback [most recent call last]:
  File "", line 1, in 
StopIteration
>>>

Python mong đợi các đối tượng có thể lặp lại trong một số ngữ cảnh khác nhau, quan trọng nhất là câu lệnh. Trong câu lệnh

>>> S = {2, 3, 5, 7, 11, 13}
>>> for i in S:
..     print[i]
2
3
5
7
11
13

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

Các trình lặp có thể được cụ thể hóa dưới dạng danh sách hoặc bộ dữ liệu bằng cách sử dụng hàm tạo hoặc

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

Trình tự giải nén cũng hỗ trợ các trình vòng lặp. nếu bạn biết một trình vòng lặp sẽ trả về N phần tử, bạn có thể giải nén chúng thành một N-tuple

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> a, b, c = iterator
>>> a, b, c
[1, 2, 3]

Các hàm tích hợp như và có thể nhận một đối số trình vòng lặp duy nhất và sẽ trả về phần tử lớn nhất hoặc nhỏ nhất. Các toán tử

>>> S = {2, 3, 5, 7, 11, 13}
>>> for i in S:
..     print[i]
2
3
5
7
11
13

>>> S = {2, 3, 5, 7, 11, 13}
>>> for i in S:
..     print[i]
2
3
5
7
11
13

>>> line_list = ['  line 1\n', 'line 2  \n', ' \n', '']

>>> # Generator expression -- returns iterator
>>> stripped_iter = [line.strip[] for line in line_list]

>>> # List comprehension -- returns list
>>> stripped_list = [line.strip[] for line in line_list]

Lưu ý rằng bạn chỉ có thể đi tiếp trong một trình vòng lặp; . Các đối tượng iterator có thể tùy chọn cung cấp các khả năng bổ sung này, nhưng giao thức iterator chỉ xác định phương thức. Do đó, các chức năng có thể sử dụng tất cả đầu ra của trình vòng lặp và nếu bạn cần làm điều gì đó khác với cùng một luồng, bạn sẽ phải tạo một trình vòng lặp mới

>>> m = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
..      'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}
>>> for key in m:
..     print[key, m[key]]
Jan 1
Feb 2
Mar 3
Apr 4
May 5
Jun 6
Jul 7
Aug 8
Sep 9
Oct 10
Nov 11
Dec 12

>>> stripped_list = [line.strip[] for line in line_list
..                  if line != ""]

>>> L = [['Italy', 'Rome'], ['France', 'Paris'], ['US', 'Washington DC']]
>>> dict[iter[L]]
{'Italy': 'Rome', 'France': 'Paris', 'US': 'Washington DC'}

for line in file:
    # do something for each line
    ...

>>> S = {2, 3, 5, 7, 11, 13}
>>> for i in S:
..     print[i]
2
3
5
7
11
13

Biểu thức trình tạo và hiểu danh sách

Hai thao tác phổ biến trên đầu ra của iterator là 1] thực hiện một số thao tác cho mọi phần tử, 2] chọn một tập hợp con các phần tử đáp ứng một số điều kiện. Ví dụ: đưa ra một danh sách các chuỗi, bạn có thể muốn loại bỏ khoảng trắng ở cuối mỗi dòng hoặc trích xuất tất cả các chuỗi chứa một chuỗi con đã cho

Liệt kê khả năng hiểu và biểu thức trình tạo [dạng ngắn. “listcomps” và “genexps”] là một ký hiệu ngắn gọn cho các hoạt động như vậy, mượn từ ngôn ngữ lập trình chức năng Haskell [https. //www. haskell. tổ chức/]. Bạn có thể loại bỏ tất cả khoảng trắng khỏi một luồng chuỗi bằng đoạn mã sau

>>> line_list = ['  line 1\n', 'line 2  \n', ' \n', '']

>>> # Generator expression -- returns iterator
>>> stripped_iter = [line.strip[] for line in line_list]

>>> # List comprehension -- returns list
>>> stripped_list = [line.strip[] for line in line_list]

Bạn chỉ có thể chọn một số phần tử nhất định bằng cách thêm điều kiện

>>> stripped_list = [line.strip[] for line in line_list
..                  if line != ""]

>>> stripped_list = [line.strip[] for line in line_list
..                  if line != ""]

Với khả năng hiểu danh sách, bạn lấy lại danh sách Python; . Các biểu thức trình tạo trả về một trình vòng lặp tính toán các giá trị khi cần thiết, không cần cụ thể hóa tất cả các giá trị cùng một lúc. Điều này có nghĩa là khả năng hiểu danh sách không hữu ích nếu bạn đang làm việc với các trình vòng lặp trả về một luồng vô hạn hoặc một lượng dữ liệu rất lớn. Biểu thức trình tạo thích hợp hơn trong những tình huống này

Biểu thức trình tạo được bao quanh bởi dấu ngoặc đơn [“[]”] và cách hiểu danh sách được bao quanh bởi dấu ngoặc vuông [“[]”]. Biểu thức trình tạo có dạng

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

Một lần nữa, để hiểu danh sách, chỉ có các dấu ngoặc bên ngoài là khác nhau [dấu ngoặc vuông thay vì dấu ngoặc đơn]

Các phần tử của đầu ra được tạo sẽ là các giá trị kế tiếp của

>>> stripped_list = [line.strip[] for line in line_list
..                  if line != ""]

>>> stripped_list = [line.strip[] for line in line_list
..                  if line != ""]

Biểu thức trình tạo luôn phải được viết bên trong dấu ngoặc đơn, nhưng dấu ngoặc đơn báo hiệu lệnh gọi hàm cũng được tính. Nếu bạn muốn tạo một trình vòng lặp sẽ được chuyển ngay đến một hàm, bạn có thể viết

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

Các mệnh đề

>>> stripped_list = [line.strip[] for line in line_list
..                  if line != ""]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

Nói cách khác, một biểu thức hiểu danh sách hoặc trình tạo danh sách tương đương với mã Python sau

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

Điều này có nghĩa là khi có nhiều mệnh đề

>>> stripped_list = [line.strip[] for line in line_list
..                  if line != ""]

>>> stripped_list = [line.strip[] for line in line_list
..                  if line != ""]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

Để tránh đưa sự mơ hồ vào ngữ pháp của Python, nếu

>>> stripped_list = [line.strip[] for line in line_list
..                  if line != ""]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

máy phát điện

Trình tạo là một lớp hàm đặc biệt giúp đơn giản hóa tác vụ viết trình vòng lặp. Các hàm thông thường tính toán một giá trị và trả về giá trị đó, nhưng các trình tạo trả về một trình vòng lặp trả về một luồng giá trị

Chắc chắn bạn đã quen với cách hoạt động của các lệnh gọi hàm thông thường trong Python hoặc C. Khi bạn gọi một hàm, nó sẽ nhận được một không gian tên riêng nơi các biến cục bộ của nó được tạo. Khi hàm đạt đến câu lệnh

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

Đây là ví dụ đơn giản nhất về hàm tạo

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

Bất kỳ hàm nào chứa từ khóa đều là hàm tạo;

Khi bạn gọi một hàm tạo, nó không trả về một giá trị nào; . Khi thực hiện biểu thức

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

Đây là cách sử dụng mẫu của trình tạo

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

Bạn cũng có thể viết

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

Bên trong một hàm tạo,

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

Bạn có thể đạt được hiệu ứng của trình tạo theo cách thủ công bằng cách viết lớp của riêng bạn và lưu trữ tất cả các biến cục bộ của trình tạo dưới dạng biến thể hiện. Ví dụ: trả về một danh sách các số nguyên có thể được thực hiện bằng cách đặt

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

Bộ thử nghiệm đi kèm với thư viện của Python, Lib/test/test_generators. py, chứa một số ví dụ thú vị hơn. Đây là một trình tạo thực hiện duyệt theo thứ tự của cây bằng cách sử dụng trình tạo đệ quy

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

Hai ví dụ khác trong

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

Chức năng tích hợp sẵn

Hãy xem chi tiết hơn về các hàm tích hợp thường được sử dụng với các trình vòng lặp

Hai trong số các hàm tích hợp sẵn của Python và sao chép các tính năng của biểu thức trình tạo

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

Tất nhiên, bạn có thể đạt được hiệu quả tương tự với việc hiểu danh sách

trả về một trình vòng lặp trên tất cả các phần tử chuỗi đáp ứng một điều kiện nhất định và được sao chép tương tự bằng cách hiểu danh sách. Vị ngữ là một hàm trả về giá trị thực của một số điều kiện;

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

Điều này cũng có thể được viết dưới dạng hiểu danh sách

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

đếm các phần tử trong 2 bộ lặp trả về có thể lặp lại chứa số lượng [từ đầu] và từng phần tử

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

thường được sử dụng khi lặp qua một danh sách và ghi lại các chỉ mục mà tại đó các điều kiện nhất định được đáp ứng

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

thu thập tất cả các phần tử của iterable vào một danh sách, sắp xếp danh sách và trả về kết quả đã sắp xếp. Các đối số chính và đảo ngược được chuyển qua phương thức của danh sách được xây dựng

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

[Để thảo luận chi tiết hơn về sắp xếp, hãy xem. ]

Các và tích hợp xem xét các giá trị thực của nội dung của một lần lặp. trả về

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

lấy một phần tử từ mỗi lần lặp và trả về chúng trong một tuple

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> a, b, c = iterator
>>> a, b, c
[1, 2, 3]

Nó không xây dựng danh sách trong bộ nhớ và sử dụng hết tất cả các trình vòng lặp đầu vào trước khi quay lại; . [Thuật ngữ kỹ thuật cho hành vi này là đánh giá lười biếng. ]

Trình lặp này được thiết kế để sử dụng với các lần lặp có cùng độ dài. Nếu các lần lặp có độ dài khác nhau, luồng kết quả sẽ có cùng độ dài với lần lặp ngắn nhất

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> a, b, c = iterator
>>> a, b, c
[1, 2, 3]

Tuy nhiên, bạn nên tránh làm điều này vì một phần tử có thể được lấy từ các trình vòng lặp dài hơn và bị loại bỏ. Điều này có nghĩa là bạn không thể tiếp tục sử dụng các trình vòng lặp nữa vì bạn có nguy cơ bỏ qua một phần tử bị loại bỏ

Mô-đun itertools

Mô-đun chứa một số trình vòng lặp thường được sử dụng cũng như các chức năng để kết hợp một số trình vòng lặp. Phần này sẽ giới thiệu nội dung của mô-đun bằng cách hiển thị các ví dụ nhỏ

Các chức năng của mô-đun rơi vào một vài lớp rộng

• Các hàm tạo một trình vòng lặp mới dựa trên một trình vòng lặp hiện có

• Các hàm xử lý các phần tử của iterator làm đối số hàm

• Các chức năng để chọn các phần của đầu ra của trình vòng lặp

• Một chức năng để nhóm đầu ra của một iterator

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> a, b, c = iterator
>>> a, b, c
[1, 2, 3]

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> a, b, c = iterator
>>> a, b, c
[1, 2, 3]

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> a, b, c = iterator
>>> a, b, c
[1, 2, 3]

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> a, b, c = iterator
>>> a, b, c
[1, 2, 3]

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> a, b, c = iterator
>>> a, b, c
[1, 2, 3]

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> a, b, c = iterator
>>> a, b, c
[1, 2, 3]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> a, b, c = iterator
>>> a, b, c
[1, 2, 3]

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> a, b, c = iterator
>>> a, b, c
[1, 2, 3]

>>> m = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
..      'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}
>>> for key in m:
..     print[key, m[key]]
Jan 1
Feb 2
Mar 3
Apr 4
May 5
Jun 6
Jul 7
Aug 8
Sep 9
Oct 10
Nov 11
Dec 12

>>> m = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
..      'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}
>>> for key in m:
..     print[key, m[key]]
Jan 1
Feb 2
Mar 3
Apr 4
May 5
Jun 6
Jul 7
Aug 8
Sep 9
Oct 10
Nov 11
Dec 12

>>> m = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
..      'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}
>>> for key in m:
..     print[key, m[key]]
Jan 1
Feb 2
Mar 3
Apr 4
May 5
Jun 6
Jul 7
Aug 8
Sep 9
Oct 10
Nov 11
Dec 12

>>> m = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
..      'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}
>>> for key in m:
..     print[key, m[key]]
Jan 1
Feb 2
Mar 3
Apr 4
May 5
Jun 6
Jul 7
Aug 8
Sep 9
Oct 10
Nov 11
Dec 12

>>> m = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
..      'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}
>>> for key in m:
..     print[key, m[key]]
Jan 1
Feb 2
Mar 3
Apr 4
May 5
Jun 6
Jul 7
Aug 8
Sep 9
Oct 10
Nov 11
Dec 12

>>> m = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
..      'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}
>>> for key in m:
..     print[key, m[key]]
Jan 1
Feb 2
Mar 3
Apr 4
May 5
Jun 6
Jul 7
Aug 8
Sep 9
Oct 10
Nov 11
Dec 12

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

>>> m = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
..      'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}
>>> for key in m:
..     print[key, m[key]]
Jan 1
Feb 2
Mar 3
Apr 4
May 5
Jun 6
Jul 7
Aug 8
Sep 9
Oct 10
Nov 11
Dec 12

for i in iter[obj]:
    print[i]

for i in obj:
    print[i]

>>> m = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
..      'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}
>>> for key in m:
..     print[key, m[key]]
Jan 1
Feb 2
Mar 3
Apr 4
May 5
Jun 6
Jul 7
Aug 8
Sep 9
Oct 10
Nov 11
Dec 12

Mô-đun funcool

Mô-đun chứa một số chức năng bậc cao hơn. Hàm bậc cao hơn nhận một hoặc nhiều hàm làm đầu vào và trả về một hàm mới. Công cụ hữu ích nhất trong mô-đun này là chức năng

Đối với các chương trình được viết theo phong cách chức năng, đôi khi bạn sẽ muốn xây dựng các biến thể của các chức năng hiện có có một số tham số được điền vào. Hãy xem xét một hàm Python

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

Hàm tạo for nhận các đối số

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

Đây là một ví dụ nhỏ nhưng thực tế

>>> m = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
..      'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}
>>> for key in m:
..     print[key, m[key]]
Jan 1
Feb 2
Mar 3
Apr 4
May 5
Jun 6
Jul 7
Aug 8
Sep 9
Oct 10
Nov 11
Dec 12

thực hiện tích lũy một thao tác trên tất cả các phần tử của iterable và do đó, không thể áp dụng cho các iterable vô hạn. func phải là một hàm nhận hai phần tử và trả về một giá trị duy nhất. lấy hai phần tử đầu tiên A và B được trả về bởi iterator và tính toán

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

>>> m = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
..      'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}
>>> for key in m:
..     print[key, m[key]]
Jan 1
Feb 2
Mar 3
Apr 4
May 5
Jun 6
Jul 7
Aug 8
Sep 9
Oct 10
Nov 11
Dec 12

Nếu bạn sử dụng with , bạn sẽ thêm tất cả các phần tử của iterable. Trường hợp này phổ biến đến mức có một phần mềm tích hợp đặc biệt được gọi để tính toán trường hợp này

>>> L = [['Italy', 'Rome'], ['France', 'Paris'], ['US', 'Washington DC']]
>>> dict[iter[L]]
{'Italy': 'Rome', 'France': 'Paris', 'US': 'Washington DC'}

Tuy nhiên, đối với nhiều cách sử dụng, có thể rõ ràng hơn nếu chỉ viết vòng lặp rõ ràng

>>> L = [['Italy', 'Rome'], ['France', 'Paris'], ['US', 'Washington DC']]
>>> dict[iter[L]]
{'Italy': 'Rome', 'France': 'Paris', 'US': 'Washington DC'}

Một chức năng liên quan là. Nó thực hiện phép tính tương tự, nhưng thay vì chỉ trả về kết quả cuối cùng,

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

>>> L = [['Italy', 'Rome'], ['France', 'Paris'], ['US', 'Washington DC']]
>>> dict[iter[L]]
{'Italy': 'Rome', 'France': 'Paris', 'US': 'Washington DC'}

Các chức năng nhỏ và biểu thức lambda

Khi viết các chương trình kiểu hàm, bạn sẽ thường cần các hàm nhỏ hoạt động như các vị từ hoặc kết hợp các phần tử theo một cách nào đó

Nếu có sẵn Python hoặc chức năng mô-đun phù hợp, bạn hoàn toàn không cần xác định chức năng mới

>>> L = [['Italy', 'Rome'], ['France', 'Paris'], ['US', 'Washington DC']]
>>> dict[iter[L]]
{'Italy': 'Rome', 'France': 'Paris', 'US': 'Washington DC'}

Nếu chức năng bạn cần không tồn tại, bạn cần viết nó. Một cách để viết các hàm nhỏ là sử dụng biểu thức.

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

>>> L = [['Italy', 'Rome'], ['France', 'Paris'], ['US', 'Washington DC']]
>>> dict[iter[L]]
{'Italy': 'Rome', 'France': 'Paris', 'US': 'Washington DC'}

Một cách khác là chỉ sử dụng câu lệnh

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

>>> L = [['Italy', 'Rome'], ['France', 'Paris'], ['US', 'Washington DC']]
>>> dict[iter[L]]
{'Italy': 'Rome', 'France': 'Paris', 'US': 'Washington DC'}

Lựa chọn thay thế nào là thích hợp hơn?

Một lý do cho sở thích của tôi là

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

>>> L = [['Italy', 'Rome'], ['France', 'Paris'], ['US', 'Washington DC']]
>>> dict[iter[L]]
{'Italy': 'Rome', 'France': 'Paris', 'US': 'Washington DC'}

Bạn có thể tìm ra nó, nhưng phải mất thời gian để gỡ rối biểu thức để tìm ra điều gì đang xảy ra. Sử dụng một câu lệnh ngắn

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

>>> L = [['Italy', 'Rome'], ['France', 'Paris'], ['US', 'Washington DC']]
>>> dict[iter[L]]
{'Italy': 'Rome', 'France': 'Paris', 'US': 'Washington DC'}

Nhưng sẽ là tốt nhất nếu tôi chỉ đơn giản sử dụng một vòng lặp

>>> S = {2, 3, 5, 7, 11, 13}
>>> for i in S:
..     print[i]
2
3
5
7
11
13

>>> L = [['Italy', 'Rome'], ['France', 'Paris'], ['US', 'Washington DC']]
>>> dict[iter[L]]
{'Italy': 'Rome', 'France': 'Paris', 'US': 'Washington DC'}

Hoặc biểu thức tích hợp và trình tạo

>>> L = [['Italy', 'Rome'], ['France', 'Paris'], ['US', 'Washington DC']]
>>> dict[iter[L]]
{'Italy': 'Rome', 'France': 'Paris', 'US': 'Washington DC'}

Nhiều cách dùng của sẽ rõ ràng hơn khi được viết dưới dạng vòng lặp

>>> S = {2, 3, 5, 7, 11, 13}
>>> for i in S:
..     print[i]
2
3
5
7
11
13

Fredrik Lundh đã từng đề xuất bộ quy tắc sau để tái cấu trúc việc sử dụng

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

1. Viết một hàm lambda

2. Viết một bình luận giải thích cái quái gì mà lambda làm

3. Nghiên cứu bình luận một lúc và nghĩ ra một cái tên nắm bắt được bản chất của bình luận

4. Chuyển đổi lambda thành câu lệnh def, sử dụng tên đó

5. Xóa bình luận

Tôi thực sự thích những quy tắc này, nhưng bạn có quyền không đồng ý về việc liệu phong cách không có lambda này có tốt hơn không

Lịch sử sửa đổi và lời cảm ơn

Tác giả xin cảm ơn những người sau đây đã góp ý, sửa chữa và hỗ trợ với các bản thảo khác nhau của bài viết này. Ian Bicking, Nick Coghlan, Nick Efford, Raymond Hettinger, Jim Jewett, Mike Krell, Leandro Lameiro, Jussi Salmela, Collin Winter, Blake Winton

Phiên bản 0. 1. đăng ngày 30 tháng 6 năm 2006

Phiên bản 0. 11. đăng ngày 1 tháng 7 năm 2006. sửa lỗi đánh máy

Phiên bản 0. 2. đăng ngày 10 tháng 7 năm 2006. Đã hợp nhất các phần genexp và listcomp thành một. sửa lỗi đánh máy

Phiên bản 0. 21. Đã thêm nhiều tài liệu tham khảo được đề xuất trong danh sách gửi thư gia sư

Phiên bản 0. 30. Thêm một phần vào mô-đun

>>> L = [1, 2, 3]
>>> iterator = iter[L]
>>> t = tuple[iterator]
>>> t
[1, 2, 3]

Người giới thiệu