Xuyên suốt các hướng dẫn trước trong loạt bài này, bạn đã thấy nhiều ví dụ minh họa việc sử dụng. Trong hướng dẫn này, bạn sẽ học cách xác định hàm Python của riêng mình. Bạn sẽ tìm hiểu khi nào nên chia chương trình của mình thành các chức năng riêng biệt do người dùng xác định và bạn sẽ cần những công cụ nào để thực hiện việc này
Đây là những gì bạn sẽ học trong hướng dẫn này
- Các hàm hoạt động như thế nào trong Python và tại sao chúng lại hữu ích
- Cách xác định và gọi hàm Python của riêng bạn
- Cơ chế truyền đối số cho hàm của bạn
- Cách trả lại dữ liệu từ chức năng của bạn về môi trường gọi
Tải xuống PDF miễn phí. Bảng cheat Python 3
Hàm trong Python
Bạn có thể quen thuộc với khái niệm toán học của hàm. Hàm là mối quan hệ hoặc ánh xạ giữa một hoặc nhiều đầu vào và một tập hợp các đầu ra. Trong toán học, một hàm thường được biểu diễn như thế này
Ở đây,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
16 là một chức năng hoạt động trên các đầu vào >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
18. Đầu ra của hàm là >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
19. Tuy nhiên, các chức năng lập trình tổng quát và linh hoạt hơn nhiều so với định nghĩa toán học này. Trên thực tế, việc định nghĩa và sử dụng hàm phù hợp rất quan trọng đối với việc phát triển phần mềm phù hợp đến mức hầu như tất cả các ngôn ngữ lập trình hiện đại đều hỗ trợ cả hàm tích hợp và hàm do người dùng định nghĩaTrong lập trình, một hàm là một khối mã độc lập đóng gói một tác vụ cụ thể hoặc một nhóm tác vụ có liên quan. Trong các hướng dẫn trước của loạt bài này, bạn đã được giới thiệu về một số hàm tích hợp do Python cung cấp. , ví dụ, lấy một đối số và trả về mã định danh số nguyên duy nhất của đối tượng đó
>>>
>>> s = 'foobar'
>>> id[s]
56313440
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
21 trả về độ dài của đối số được truyền cho nó>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
22 lấy một iterable làm đối số của nó và trả về >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
23 nếu bất kỳ mục nào trong iterable là và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
24 nếu không>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
0Mỗi chức năng tích hợp này thực hiện một nhiệm vụ cụ thể. Mã hoàn thành nhiệm vụ được xác định ở đâu đó, nhưng bạn không cần biết mã đó hoạt động ở đâu hoặc thậm chí như thế nào. Tất cả những gì bạn cần biết là giao diện của chức năng
- Những đối số [nếu có] nó cần
- Giá trị nào [nếu có] nó trả về
Sau đó, bạn gọi hàm và chuyển các đối số thích hợp. Việc thực thi chương trình chuyển sang phần thân mã được chỉ định và thực hiện công việc hữu ích của nó. Khi chức năng kết thúc, quá trình thực thi sẽ quay trở lại mã của bạn nơi nó đã dừng lại. Hàm có thể hoặc không thể trả về dữ liệu để mã của bạn sử dụng, như các ví dụ trên
Khi bạn xác định hàm Python của riêng mình, nó sẽ hoạt động giống như vậy. Từ một nơi nào đó trong mã của bạn, bạn sẽ gọi hàm Python của mình và việc thực thi chương trình sẽ chuyển sang phần thân mã tạo nên hàm
Ghi chú. Trong trường hợp này, bạn sẽ biết mã ở đâu và chính xác nó hoạt động như thế nào vì bạn đã viết nó
Khi chức năng kết thúc, thực thi trở lại vị trí mà chức năng đã được gọi. Tùy thuộc vào cách bạn thiết kế giao diện của hàm, dữ liệu có thể được truyền vào khi hàm được gọi và các giá trị trả về có thể được truyền lại khi hàm kết thúc
Loại bỏ các quảng cáoTầm quan trọng của các hàm Python
Hầu như tất cả các ngôn ngữ lập trình được sử dụng ngày nay đều hỗ trợ một dạng hàm do người dùng định nghĩa, mặc dù chúng không phải lúc nào cũng được gọi là hàm. Trong các ngôn ngữ khác, bạn có thể thấy chúng được gọi là một trong những ngôn ngữ sau
- chương trình con
- thủ tục
- phương pháp
- chương trình con
Vì vậy, tại sao phải xác định chức năng? . Bây giờ chúng ta hãy đi qua một số
Tính trừu tượng và khả năng sử dụng lại
Giả sử bạn viết một số mã làm điều gì đó hữu ích. Khi bạn tiếp tục phát triển, bạn thấy rằng tác vụ do mã đó thực hiện là tác vụ bạn cần thường xuyên, ở nhiều vị trí khác nhau trong ứng dụng của bạn. Những gì bạn nên làm?
Sau này, có thể bạn sẽ quyết định rằng mã được đề cập cần phải được sửa đổi. Bạn sẽ tìm thấy điều gì đó không ổn với nó cần được sửa chữa hoặc bạn sẽ muốn cải thiện nó theo một cách nào đó. Nếu các bản sao của mã nằm rải rác khắp ứng dụng của bạn, thì bạn sẽ cần thực hiện các thay đổi cần thiết ở mọi vị trí
Ghi chú. Thoạt nhìn, đó có vẻ là một giải pháp hợp lý, nhưng về lâu dài, nó có thể là một cơn ác mộng về bảo trì. Mặc dù trình soạn thảo mã của bạn có thể trợ giúp bằng cách cung cấp chức năng tìm kiếm và thay thế, nhưng phương pháp này dễ bị lỗi và bạn có thể dễ dàng đưa các lỗi vào mã của mình mà rất khó tìm thấy
Một giải pháp tốt hơn là xác định hàm Python thực hiện tác vụ. Bất cứ nơi nào trong ứng dụng của bạn mà bạn cần hoàn thành tác vụ, bạn chỉ cần gọi hàm. Cuối cùng, nếu bạn quyết định thay đổi cách thức hoạt động của nó, thì bạn chỉ cần thay đổi mã ở một vị trí, đó là nơi xác định chức năng. Các thay đổi sẽ tự động được chọn ở bất kỳ đâu mà chức năng được gọi
Việc trừu tượng hóa chức năng thành một định nghĩa chức năng là một ví dụ về Nguyên tắc không lặp lại chính mình [DRY] trong phát triển phần mềm. Đây được cho là động lực mạnh nhất để sử dụng các chức năng
tính mô đun
Các chức năng cho phép chia các quy trình phức tạp thành các bước nhỏ hơn. Ví dụ, hãy tưởng tượng rằng bạn có một chương trình đọc tệp, xử lý nội dung tệp và sau đó ghi tệp đầu ra. Mã của bạn có thể trông như thế này
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
1Trong ví dụ này, chương trình chính là một loạt mã được xâu thành một chuỗi dài, với khoảng trắng và nhận xét để giúp tổ chức chương trình. Tuy nhiên, nếu mã trở nên dài hơn và phức tạp hơn nhiều, thì bạn sẽ ngày càng gặp khó khăn trong việc xoay sở với nó.
Ngoài ra, bạn có thể cấu trúc mã giống như sau
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
2Ví dụ này được mô đun hóa. Thay vì tất cả mã được xâu chuỗi lại với nhau, nó được chia thành các chức năng riêng biệt, mỗi chức năng tập trung vào một nhiệm vụ cụ thể. Những tác vụ đó được đọc, xử lý và ghi. Chương trình chính bây giờ chỉ cần gọi lần lượt từng cái này
Ghi chú. Từ khóa
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
25 giới thiệu một định nghĩa hàm Python mới. Bạn sẽ tìm hiểu tất cả về điều này rất sớmTrong cuộc sống, bạn luôn làm những việc như thế này, ngay cả khi bạn không nghĩ rõ ràng về nó theo cách đó. Nếu bạn muốn di chuyển một số kệ chứa đầy đồ đạc từ bên này sang bên kia ga-ra của mình, thì hy vọng rằng bạn sẽ không chỉ đứng đó và nghĩ vẩn vơ, “Ôi trời. Tôi cần phải di chuyển tất cả những thứ đó ở đó. Làm thế nào để làm điều đó???"
- Lấy tất cả những thứ ra khỏi kệ
- Tháo rời các kệ
- Mang các bộ phận của kệ qua nhà để xe đến vị trí mới
- Lắp ráp lại các kệ
- Mang đồ qua nhà để xe
- Đặt lại những thứ trên kệ
Chia một nhiệm vụ lớn thành các nhiệm vụ nhỏ hơn, nhỏ hơn giúp làm cho nhiệm vụ lớn dễ suy nghĩ và quản lý hơn. Khi các chương trình trở nên phức tạp hơn, việc mô đun hóa chúng theo cách này ngày càng trở nên có lợi.
Loại bỏ các quảng cáoTách không gian tên
Không gian tên là một vùng của chương trình trong đó các mã định danh có ý nghĩa. Như bạn sẽ thấy bên dưới, khi một hàm Python được gọi, một không gian tên mới được tạo cho hàm đó, một không gian tên khác với tất cả các không gian tên khác đã tồn tại
Kết quả thực tế của điều này là các biến có thể được xác định và sử dụng trong một hàm Python ngay cả khi chúng có cùng tên với các biến được xác định trong các hàm khác hoặc trong chương trình chính. Trong những trường hợp này, sẽ không có sự nhầm lẫn hoặc can thiệp vì chúng được giữ trong các không gian tên riêng biệt
Điều này có nghĩa là khi bạn viết mã trong một hàm, bạn có thể sử dụng tên biến và mã định danh mà không phải lo lắng về việc liệu chúng đã được sử dụng ở đâu khác bên ngoài hàm chưa. Điều này giúp giảm thiểu đáng kể các lỗi trong mã
Ghi chú. Bạn sẽ tìm hiểu thêm về không gian tên ở phần sau của loạt bài này
Hy vọng rằng bạn đã đủ thuyết phục về ưu điểm của các chức năng và mong muốn tạo ra một số. Hãy xem làm thế nào
Gọi hàm và định nghĩa
Cú pháp thông thường để xác định hàm Python như sau
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
4Các thành phần của định nghĩa được giải thích trong bảng dưới đây
ComponentMeaning
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
25Từ khóa thông báo cho Python rằng một hàm đang được xác định>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
27Một mã định danh Python hợp lệ đặt tên cho hàm>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
28Một danh sách các tham số tùy chọn, được phân tách bằng dấu phẩy có thể được truyền cho hàm>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
29Dấu câu biểu thị phần cuối của tiêu đề hàm Python [danh sách tên và tham số]>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
30A Mục cuối cùng,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
30, được gọi là phần thân của hàm. Phần thân là một khối các câu lệnh sẽ được thực hiện khi hàm được gọi. Phần thân của hàm Python được xác định bằng cách thụt đầu dòng theo quy định. Điều này giống như các khối mã được liên kết với cấu trúc điều khiển, chẳng hạn như câu lệnh >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
32 hoặc >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
33Cú pháp gọi hàm Python như sau
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
3>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
34 là các giá trị được truyền vào hàm. Chúng tương ứng với >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
28 trong định nghĩa hàm Python. Bạn có thể định nghĩa một hàm không nhận bất kỳ đối số nào, nhưng dấu ngoặc đơn vẫn được yêu cầu. Cả định nghĩa hàm và lời gọi hàm phải luôn bao gồm dấu ngoặc đơn, ngay cả khi chúng trốngNhư thường lệ, bạn sẽ bắt đầu với một ví dụ nhỏ và thêm độ phức tạp từ đó. Hãy ghi nhớ truyền thống toán học lâu đời, bạn sẽ gọi hàm Python đầu tiên của mình là
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36. Đây là tệp script, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
37, xác định và gọi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
9Đây là cách mã này hoạt động
Dòng 1 sử dụng từ khóa
25 để chỉ ra rằng một chức năng đang được xác định. Việc thực thi câu lệnh>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
25 chỉ tạo ra định nghĩa của>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
36. Tất cả các dòng sau được thụt vào [dòng 2 đến dòng 3] trở thành một phần của phần thân của>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
36 và được lưu trữ dưới dạng định nghĩa của nó, nhưng chúng chưa được thực thi>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
Dòng 4 là một chút khoảng trắng giữa định nghĩa hàm và dòng đầu tiên của chương trình chính. Mặc dù nó không cần thiết về mặt cú pháp, nhưng thật tuyệt khi có. Để tìm hiểu thêm về khoảng trắng xung quanh các định nghĩa hàm Python cấp cao nhất, hãy xem Viết mã Pythonic đẹp với PEP 8
Dòng 5 là câu lệnh đầu tiên không được thụt lề vì nó không phải là một phần của định nghĩa về
36. Nó bắt đầu chương trình chính. Khi chương trình chính thực thi, câu lệnh này được thực hiện đầu tiên>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
Dòng 6 là cuộc gọi đến
36. Lưu ý rằng dấu ngoặc đơn trống luôn được yêu cầu trong cả định nghĩa hàm và lời gọi hàm, ngay cả khi không có tham số hoặc đối số. Quá trình thực thi tiếp tục đến>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
36 và các câu lệnh trong phần thân của>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
36 được thực thi>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
Dòng 7 là dòng tiếp theo thực thi sau khi phần thân của
36 kết thúc. Việc thực thi trả về câu lệnh>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
48 này>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
Trình tự thực hiện [hoặc luồng điều khiển] cho
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
37 được hiển thị trong sơ đồ sauKhi
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
37 được chạy từ dấu nhắc lệnh của Windows, kết quả như sau>>> s = 'foobar'
>>> id[s]
56313440
2Đôi khi, bạn có thể muốn định nghĩa một hàm rỗng không làm gì cả. Đây được gọi là sơ khai, thường là trình giữ chỗ tạm thời cho hàm Python sẽ được triển khai đầy đủ sau này. Giống như một khối trong cấu trúc điều khiển không thể để trống, phần thân của hàm cũng vậy. Để định nghĩa một hàm sơ khai, hãy sử dụng câu lệnh
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
51>>>
>>> s = 'foobar'
>>> id[s]
56313440
4Như bạn có thể thấy ở trên, lệnh gọi hàm sơ khai hợp lệ về mặt cú pháp nhưng không thực hiện bất kỳ điều gì
Loại bỏ các quảng cáoTruyền đối số
Cho đến giờ trong hướng dẫn này, các hàm bạn đã xác định chưa nhận bất kỳ đối số nào. Điều đó đôi khi có thể hữu ích và thỉnh thoảng bạn sẽ viết các hàm như vậy. Tuy nhiên, thường xuyên hơn, bạn sẽ muốn truyền dữ liệu vào một hàm để hành vi của nó có thể thay đổi từ lần gọi này sang lần gọi tiếp theo. Hãy xem làm thế nào để làm điều đó
Đối số vị trí
Cách đơn giản nhất để truyền đối số cho hàm Python là sử dụng đối số vị trí [còn gọi là đối số bắt buộc]. Trong định nghĩa hàm, bạn chỉ định danh sách tham số được phân tách bằng dấu phẩy bên trong dấu ngoặc đơn
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
0Khi hàm được gọi, bạn chỉ định một danh sách các đối số tương ứng
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
1Các tham số [
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
52, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
53 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
54] hoạt động giống như các biến được xác định cục bộ cho hàm. Khi hàm được gọi, các đối số được truyền [>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
55, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
56 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
57] được liên kết với các tham số theo thứ tự, như thể bằng cách gán biếnĐối số tham số
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
52←>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
55 >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
53←>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
61_______ 054←>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
57Trong một số văn bản lập trình, các tham số được đưa ra trong định nghĩa hàm được gọi là tham số hình thức và các đối số trong lệnh gọi hàm được gọi là tham số thực
Mặc dù các đối số vị trí là cách đơn giản nhất để truyền dữ liệu đến một hàm, nhưng chúng cũng kém linh hoạt nhất. Đối với người mới bắt đầu, thứ tự của các đối số trong lệnh gọi phải khớp với thứ tự của các tham số trong định nghĩa. Tất nhiên, không có gì ngăn bạn chỉ định các đối số vị trí không theo thứ tự
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
2Hàm thậm chí có thể vẫn chạy, như trong ví dụ trên, nhưng rất khó có thể tạo ra kết quả chính xác. Lập trình viên có trách nhiệm xác định chức năng để ghi lại các đối số phù hợp và trách nhiệm của người dùng chức năng là nhận thức được thông tin đó và tuân theo thông tin đó
Với các đối số vị trí, các đối số trong lệnh gọi và các tham số trong định nghĩa phải thống nhất không chỉ về thứ tự mà còn về số lượng. Đó là lý do đối số vị trí cũng được gọi là đối số bắt buộc. Bạn không thể bỏ bất kỳ phần nào khi gọi hàm
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
3Bạn cũng không thể chỉ định những cái bổ sung
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
4Đối số vị trí dễ sử dụng về mặt khái niệm, nhưng chúng không dễ tha thứ. Bạn phải chỉ định cùng một số đối số trong lệnh gọi hàm như có các tham số trong định nghĩa và theo đúng thứ tự. Trong các phần tiếp theo, bạn sẽ thấy một số kỹ thuật chuyển đối số giúp nới lỏng các hạn chế này
Đối số từ khóa
Khi gọi một hàm, bạn có thể chỉ định các đối số ở dạng
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
64. Trong trường hợp đó, mỗi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
65 phải khớp với một tham số trong định nghĩa hàm Python. Ví dụ: hàm được xác định trước đó >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 có thể được gọi với các đối số từ khóa như sau>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
5Tham chiếu một từ khóa không khớp với bất kỳ tham số nào đã khai báo sẽ tạo ra một ngoại lệ
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
6Sử dụng các đối số từ khóa sẽ loại bỏ hạn chế về thứ tự đối số. Mỗi đối số từ khóa chỉ định rõ ràng một tham số cụ thể theo tên, vì vậy bạn có thể chỉ định chúng theo bất kỳ thứ tự nào và Python sẽ vẫn biết đối số nào đi với tham số nào
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
7Tuy nhiên, giống như đối số vị trí, số lượng đối số và tham số vẫn phải khớp với nhau
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
8Vì vậy, các đối số từ khóa cho phép linh hoạt trong thứ tự các đối số chức năng được chỉ định, nhưng số lượng đối số vẫn còn cứng nhắc
Bạn có thể gọi một hàm bằng cách sử dụng cả đối số vị trí và từ khóa
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
9Khi cả hai đối số vị trí và từ khóa đều xuất hiện, tất cả các đối số vị trí phải xuất hiện trước
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
00Khi bạn đã chỉ định một đối số từ khóa, không thể có bất kỳ đối số vị trí nào ở bên phải của nó
Để tìm hiểu thêm về các tham số vị trí và từ khóa, hãy xem khóa học Real Python Khám phá các tham số chức năng đặc biệt
Loại bỏ các quảng cáoThông số mặc định
Nếu một tham số được chỉ định trong định nghĩa hàm Python có dạng
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
67, thì >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
68 sẽ trở thành giá trị mặc định cho tham số đó. Các tham số được xác định theo cách này được gọi là tham số mặc định hoặc tùy chọn. Một ví dụ về định nghĩa hàm với các tham số mặc định được hiển thị bên dưới>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
01Khi phiên bản này của
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 được gọi, bất kỳ đối số nào bị bỏ qua sẽ nhận giá trị mặc định của nó>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
02Tóm tắt
- Các đối số vị trí phải thống nhất về thứ tự và số với các tham số được khai báo trong định nghĩa hàm
- Các đối số từ khóa phải phù hợp với các tham số đã khai báo về số lượng, nhưng chúng có thể được chỉ định theo thứ tự tùy ý
- Tham số mặc định cho phép bỏ qua một số đối số khi gọi hàm
Giá trị tham số mặc định có thể thay đổi
Mọi thứ có thể trở nên kỳ lạ nếu bạn chỉ định một giá trị tham số mặc định là một đối tượng có thể thay đổi. Xem xét định nghĩa hàm Python này
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
03>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 lấy một tham số danh sách, nối chuỗi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
71 vào cuối danh sách và trả về kết quả>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
04Giá trị mặc định cho tham số
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
72 là danh sách trống, vì vậy nếu >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 được gọi mà không có bất kỳ đối số nào, thì giá trị trả về là danh sách có một phần tử duy nhất là >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
71>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
05Mọi thứ đều có ý nghĩa cho đến nay. Bây giờ, bạn mong đợi điều gì sẽ xảy ra nếu
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 được gọi mà không có bất kỳ tham số nào lần thứ hai và thứ ba? >>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
06Ối. Bạn có thể mong đợi mỗi cuộc gọi tiếp theo cũng trả về danh sách đơn lẻ
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
76, giống như cuộc gọi đầu tiên. Thay vào đó, giá trị trả lại tiếp tục tăng. Chuyện gì đã xảy ra thế?Trong Python, các giá trị tham số mặc định chỉ được xác định một lần khi hàm được xác định [nghĩa là khi câu lệnh
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
25 được thực thi]. Giá trị mặc định không được xác định lại mỗi khi hàm được gọi. Do đó, mỗi lần bạn gọi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 mà không có tham số, bạn đang thực hiện >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
79 trên cùng một danh sáchBạn có thể chứng minh điều này với
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
20>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
07Mã định danh đối tượng được hiển thị xác nhận rằng, khi
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
72 được phép đặt mặc định, giá trị là cùng một đối tượng với mỗi cuộc gọi. Vì các danh sách có thể thay đổi, nên mỗi lệnh gọi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
79 tiếp theo sẽ khiến danh sách dài hơn. Đây là một cạm bẫy phổ biến và được ghi lại khá rõ ràng khi bạn đang sử dụng một đối tượng có thể thay đổi làm giá trị mặc định của tham số. Nó có khả năng dẫn đến hành vi mã khó hiểu và có lẽ tốt nhất nên tránhNhư một giải pháp thay thế, hãy cân nhắc sử dụng một giá trị đối số mặc định báo hiệu rằng không có đối số nào được chỉ định. Hầu hết mọi giá trị sẽ hoạt động, nhưng
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
83 là một lựa chọn phổ biến. Khi giá trị sentinel cho biết không có đối số nào được đưa ra, hãy tạo một danh sách trống mới bên trong hàm>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
08Lưu ý cách điều này đảm bảo rằng giờ đây
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
72 thực sự mặc định là một danh sách trống bất cứ khi nào >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 được gọi mà không có đối sốLoại bỏ các quảng cáoPass-By-Value vs Pass-By-Reference trong Pascal
Trong thiết kế ngôn ngữ lập trình, có hai mô hình phổ biến để truyền đối số cho hàm
- Pass-by-giá trị. Một bản sao của đối số được chuyển đến hàm
- Chuyển qua tham chiếu. Một tham chiếu đến đối số được chuyển đến hàm
Các cơ chế khác tồn tại, nhưng về cơ bản chúng là các biến thể của hai cơ chế này. Trong phần này, bạn sẽ đi một đoạn ngắn từ Python và xem xét ngắn gọn về Pascal, một ngôn ngữ lập trình tạo ra sự khác biệt đặc biệt rõ ràng giữa hai ngôn ngữ này.
Ghi chú. Đừng lo lắng nếu bạn không quen thuộc với Pascal. Các khái niệm này tương tự như các khái niệm của Python và các ví dụ được hiển thị kèm theo lời giải thích đủ chi tiết để bạn có được ý tưởng chung. Khi bạn đã thấy cách truyền đối số hoạt động trong Pascal, chúng ta sẽ quay lại Python và bạn sẽ thấy nó so sánh như thế nào
Đây là những gì bạn cần biết về cú pháp Pascal
- thủ tục. Một thủ tục trong Pascal tương tự như một hàm trong Python
- Dấu hai chấm bằng. Toán tử này [
86] dùng để gán trong Pascal. Nó tương tự như dấu bằng [>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
87] trong Python>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
88. Hàm này hiển thị dữ liệu ra bàn điều khiển, tương tự như hàm>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
48 của Python>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
Với một chút nền tảng đó, đây là ví dụ Pascal đầu tiên
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
09Đây là những gì đang xảy ra
- Dòng 12. Chương trình chính xác định một biến số nguyên
17>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
- Dòng 15. Ban đầu nó gán cho
17 giá trị>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
92>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
- Dòng 17. Sau đó, nó gọi thủ tục
36, chuyển>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
17 làm đối số>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
- Dòng 5. Bên trong
36, câu lệnh>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
88 cho thấy tham số tương ứng>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
97 ban đầu là>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
92, giá trị được truyền vào>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
- Dòng 6.
97 sau đó được gán giá trị>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
000>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
- dòng 7. Giá trị này được xác minh bởi câu lệnh
88 này được thực thi ngay trước khi thoát>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
36>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
- Dòng 18. Trở lại môi trường gọi của chương trình chính, câu lệnh
88 này cho thấy rằng sau khi>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
36 trả về,>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
17 vẫn là>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
92, giống như trước khi gọi thủ tục>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
Chạy mã này tạo ra đầu ra sau
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
10Trong ví dụ này,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 được truyền theo giá trị, vì vậy, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 chỉ nhận được một bản sao. Khi tham số tương ứng >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
97 được sửa đổi, thì >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 không bị ảnh hưởngGhi chú. Nếu bạn muốn thấy điều này hoạt động, thì bạn có thể tự chạy mã bằng trình biên dịch Pascal trực tuyến
Chỉ cần làm theo các bước sau
- Sao chép mã từ hộp mã ở trên
- Truy cập Trình biên dịch Pascal trực tuyến
- Trong hộp mã ở bên trái, hãy thay thế mọi nội dung hiện có bằng mã bạn đã sao chép ở bước 1
- Nhấp vào Thực hiện
Bạn sẽ thấy đầu ra tương tự như trên
Bây giờ, hãy so sánh điều này với ví dụ tiếp theo
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
11Mã này giống với ví dụ đầu tiên, với một thay đổi. Đó là sự hiện diện của từ
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
011 ở phía trước của >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
97 trong định nghĩa của thủ tục >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 trên dòng 3. Điều đó chỉ ra rằng đối số của >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 được chuyển qua tham chiếu. Các thay đổi được thực hiện đối với tham số tương ứng >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
97 cũng sẽ sửa đổi đối số trong môi trường gọiĐầu ra từ mã này giống như trước, ngoại trừ dòng cuối cùng
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
12Một lần nữa,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
97 được gán giá trị >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
000 bên trong >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 như trước. Nhưng lần này, khi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 quay trở lại, thì >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 trong chương trình chính cũng đã được sửa đổiTrong nhiều ngôn ngữ lập trình, về cơ bản đó là sự khác biệt giữa pass-by-value và pass-by-reference
- Nếu một biến được truyền theo giá trị, thì hàm có một bản sao để hoạt động, nhưng nó không thể sửa đổi giá trị ban đầu trong môi trường gọi
- Nếu một biến được truyền theo tham chiếu, thì bất kỳ thay đổi nào mà hàm thực hiện đối với tham số tương ứng sẽ ảnh hưởng đến giá trị trong môi trường gọi
Lý do tại sao xuất phát từ ý nghĩa của một tài liệu tham khảo trong các ngôn ngữ này. Các giá trị biến được lưu trữ trong bộ nhớ. Trong Pascal và các ngôn ngữ tương tự, tham chiếu về cơ bản là địa chỉ của vị trí bộ nhớ đó, như minh họa bên dưới
Trong sơ đồ bên trái,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 có bộ nhớ được phân bổ trong không gian tên của chương trình chính. Khi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 được gọi, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 được truyền theo giá trị, vì vậy bộ nhớ cho tham số tương ứng >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
97 được phân bổ trong không gian tên của >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 và giá trị của >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 được sao chép vào đó. Khi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 sửa đổi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
97, bản sao cục bộ này được thay đổi. Giá trị của >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 trong môi trường gọi vẫn không bị ảnh hưởngTrong sơ đồ bên phải,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 được chuyển qua tham chiếu. Tham số tương ứng >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
97 trỏ đến địa chỉ thực trong không gian tên của chương trình chính nơi lưu trữ giá trị của >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17. Khi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 sửa đổi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
97, nó sẽ sửa đổi giá trị ở vị trí đó, giống như khi chương trình chính đang sửa đổi chính >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17Loại bỏ các quảng cáoPass-By-Value vs Pass-By-Reference trong Python
Các tham số trong Python có truyền theo giá trị hoặc theo tham chiếu không? . Đó là bởi vì một tham chiếu không có nghĩa hoàn toàn giống như trong Python như trong Pascal
Nhớ lại rằng trong Python, mọi phần dữ liệu đều là một đối tượng. Một tham chiếu trỏ đến một đối tượng, không phải là một vị trí bộ nhớ cụ thể. Điều đó có nghĩa là phép gán không được hiểu theo cùng một cách trong Python như trong Pascal. Xét cặp câu lệnh sau trong Pascal
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
13Chúng được giải thích theo cách này
- Biến
17 tham chiếu đến một vị trí bộ nhớ cụ thể>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
- Câu lệnh đầu tiên đặt giá trị
92 vào vị trí đó>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
- Câu lệnh tiếp theo ghi đè lên
92 và thay vào đó đặt>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
000 ở đó>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
Ngược lại, trong Python, các câu lệnh gán tương tự như sau
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
14Các câu lệnh gán này có ý nghĩa như sau
- Câu lệnh đầu tiên làm cho
17 trỏ đến một đối tượng có giá trị là>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
92>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
- Câu lệnh tiếp theo gán lại
17 làm tham chiếu mới cho một đối tượng khác có giá trị là>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
000. Nói cách khác, phép gán thứ hai liên kết lại>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
17 với một đối tượng khác có giá trị>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
000>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
Trong Python, khi bạn truyền một đối số cho một hàm, một rebinding tương tự sẽ xảy ra. Hãy xem xét ví dụ này
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
15Trong chương trình chính, câu lệnh
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
046 trên dòng 4 tạo một tham chiếu có tên là >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 gắn với một đối tượng có giá trị là >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
92. Sau đó, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 được gọi ở dòng 5, với đối số là >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17. Khi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 bắt đầu lần đầu tiên, một tham chiếu mới có tên là >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
97 được tạo, tham chiếu này ban đầu trỏ đến cùng một đối tượng >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
92 như >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17Tuy nhiên, khi câu lệnh
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
055 trên dòng 2 được thực thi, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 liên kết lại >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
97 với một đối tượng mới có giá trị là >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
000. Hai tài liệu tham khảo, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
97, không được tách rời khỏi nhau. Không có gì khác mà >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 làm sẽ ảnh hưởng đến >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 và khi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 kết thúc, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 sẽ vẫn trỏ đến đối tượng >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
92, giống như trước khi gọi hàmBạn có thể xác nhận tất cả điều này bằng cách sử dụng
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
20. Đây là phiên bản tăng cường một chút của ví dụ trên hiển thị số nhận dạng số của các đối tượng liên quan>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
16Khi
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 bắt đầu lần đầu tiên, cả >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
97 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 đều trỏ đến cùng một đối tượng, có >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
20 là >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
071. Sau khi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 thực hiện câu lệnh >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
055 trên dòng 3, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
97 trỏ đến một đối tượng khác có >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
20 là >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
076. Kết nối với đối tượng ban đầu trong môi trường gọi bị mấtTruyền đối số trong Python có phần kết hợp giữa truyền theo giá trị và truyền theo tham chiếu. Những gì được truyền cho hàm là một tham chiếu đến một đối tượng, nhưng tham chiếu được truyền theo giá trị
Ghi chú. Cơ chế truyền đối số của Python đã được gọi là chuyển từng lần gán. Điều này là do các tên tham số được liên kết với các đối tượng trên mục nhập hàm trong Python và phép gán cũng là quá trình liên kết tên với một đối tượng. Bạn cũng có thể thấy các thuật ngữ truyền theo đối tượng, tham chiếu theo đối tượng hoặc chia sẻ theo đối tượng
Điểm mấu chốt ở đây là một hàm Python không thể thay đổi giá trị của một đối số bằng cách gán lại tham số tương ứng cho một thứ khác. Ví dụ sau minh họa điều này
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17Ở đây, các đối tượng kiểu
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
077, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
078, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
079, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
080 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
081 được truyền cho >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 dưới dạng đối số. >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 cố gắng gán từng cái cho đối tượng chuỗi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
084, nhưng như bạn có thể thấy, khi quay lại môi trường gọi, tất cả chúng đều không thay đổi. Ngay sau khi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 thực thi nhiệm vụ >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
086, tham chiếu sẽ phục hồi và kết nối với đối tượng ban đầu bị mấtĐiều đó có nghĩa là một hàm Python không bao giờ có thể sửa đổi các đối số của nó? . Xem những gì xảy ra ở đây
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
18Trong trường hợp này, đối số của
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 là một. Khi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 được gọi, một tham chiếu đến >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
72 được chuyển. Bạn đã thấy rằng >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 không thể chỉ định lại giá trị bán buôn của >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
72. Nếu >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 được gán cho một thứ khác, thì nó sẽ được liên kết với một đối tượng khác và kết nối với >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
72 sẽ bị mấtTuy nhiên,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 có thể sử dụng tham chiếu để thực hiện các sửa đổi bên trong >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
72. Ở đây, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 đã sửa đổi phần tử đầu tiên. Bạn có thể thấy rằng khi hàm trả về, trên thực tế, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
72 đã bị thay đổi trong môi trường gọi. Khái niệm tương tự áp dụng cho một cuốn từ điển>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
19Ở đây,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 sử dụng >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 làm tham chiếu để thực hiện thay đổi bên trong >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
100. Sự thay đổi đó được phản ánh trong môi trường gọi sau khi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 trả vềLoại bỏ các quảng cáoTóm tắt thông qua đối số
Truyền đối số trong Python có thể được tóm tắt như sau. Truyền một đối tượng bất biến, chẳng hạn như
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
077, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
080, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
104 hoặc , cho một hàm Python hoạt động giống như truyền theo giá trị. Chức năng không thể sửa đổi đối tượng trong môi trường gọiTruyền một đối tượng có thể thay đổi, chẳng hạn như ,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
078 hoặc >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
079 hoạt động phần nào — nhưng không chính xác — giống như truyền theo tham chiếu. Hàm không thể chỉ định lại toàn bộ đối tượng nhưng có thể thay đổi các mục tại chỗ trong đối tượng và những thay đổi này sẽ được phản ánh trong môi trường gọiPhản ứng phụ
Vì vậy, trong Python, bạn có thể sửa đổi một đối số từ bên trong một hàm để thay đổi được phản ánh trong môi trường gọi. Nhưng bạn có nên làm điều này?
Tổng quát hơn, một hàm Python được cho là gây ra tác dụng phụ nếu nó sửa đổi môi trường gọi của nó theo bất kỳ cách nào. Thay đổi giá trị của đối số hàm chỉ là một trong những khả năng
Ghi chú. Có lẽ bạn đã quen thuộc với các tác dụng phụ trong lĩnh vực sức khỏe con người, trong đó thuật ngữ này thường đề cập đến hậu quả không mong muốn của thuốc. Thông thường, hậu quả là không mong muốn, chẳng hạn như nôn mửa hoặc an thần. Mặt khác, tác dụng phụ có thể được sử dụng có chủ ý. Ví dụ, một số loại thuốc gây kích thích thèm ăn, có thể được sử dụng để tạo lợi thế, ngay cả khi đó không phải là mục đích chính của thuốc
Khái niệm này tương tự trong lập trình. Nếu tác dụng phụ là một phần được ghi chép rõ ràng trong đặc tả chức năng và người dùng chức năng nhận thức rõ ràng về thời điểm và cách thức môi trường gọi có thể được sửa đổi, thì điều đó có thể ổn. Nhưng một lập trình viên có thể không phải lúc nào cũng ghi lại chính xác các tác dụng phụ hoặc thậm chí họ có thể không biết rằng các tác dụng phụ đang xảy ra
Khi chúng bị ẩn hoặc không mong đợi, các tác dụng phụ có thể dẫn đến các lỗi chương trình rất khó theo dõi. Nói chung, tốt nhất là tránh chúng
Tuyên bố >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
109
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
Hàm Python để làm gì sau đó? . Làm thế nào một chức năng nên ảnh hưởng đến người gọi của nó?
Chà, một khả năng là sử dụng các giá trị trả về của hàm. Câu lệnh
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
109 trong hàm Python phục vụ hai mục đích- Nó ngay lập tức kết thúc chức năng và chuyển quyền kiểm soát thực thi trở lại người gọi
- Nó cung cấp một cơ chế mà chức năng có thể chuyển dữ liệu trở lại người gọi
Thoát khỏi một chức năng
Trong một hàm, câu lệnh
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
109 khiến hàm Python bị thoát ngay lập tức và chuyển việc thực thi trở lại trình gọi>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
20Trong ví dụ này, câu lệnh
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
109 thực sự là thừa. Một hàm sẽ trở lại nơi gọi khi nó kết thúc—nghĩa là sau khi câu lệnh cuối cùng của thân hàm được thực thi. Vì vậy, chức năng này sẽ hoạt động giống hệt nhau mà không có câu lệnh >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
109Tuy nhiên, câu lệnh
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
109 không cần phải ở cuối hàm. Chúng có thể xuất hiện ở bất kỳ đâu trong thân hàm và thậm chí nhiều lần. Hãy xem xét ví dụ này>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
21Hai lệnh gọi đầu tiên đến
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 không tạo ra bất kỳ kết quả nào, bởi vì câu lệnh >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
109 được thực thi và hàm thoát sớm, trước khi đạt đến câu lệnh >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
48 trên dòng 6Loại mô hình này có thể hữu ích để kiểm tra lỗi trong một chức năng. Bạn có thể kiểm tra một số điều kiện lỗi khi bắt đầu chức năng, với các câu lệnh
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
109 giải quyết nếu có sự cố>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
22Nếu không gặp phải tình trạng lỗi nào, thì chức năng có thể tiến hành xử lý bình thường
Loại bỏ các quảng cáoTrả lại dữ liệu cho người gọi
Ngoài việc thoát khỏi một chức năng, câu lệnh
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
109 còn được sử dụng để truyền dữ liệu trở lại người gọi. Nếu một câu lệnh >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
109 bên trong hàm Python được theo sau bởi một biểu thức, thì trong môi trường gọi, lệnh gọi hàm ước tính giá trị của biểu thức đó>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
23Ở đây, giá trị của biểu thức
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 trên dòng 5 là >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
084, giá trị này sau đó được gán cho biến >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
123Một hàm có thể trả về bất kỳ loại đối tượng nào. Trong Python, điều đó có nghĩa là bất cứ thứ gì. Trong môi trường gọi, lệnh gọi hàm có thể được sử dụng về mặt cú pháp theo bất kỳ cách nào phù hợp với loại đối tượng mà hàm trả về
Ví dụ, trong mã này,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 trả về một từ điển. Khi đó, trong môi trường gọi, biểu thức >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 đại diện cho một từ điển và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
126 là một tham chiếu khóa hợp lệ trong từ điển đó>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
24Trong ví dụ tiếp theo,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 trả về một chuỗi mà bạn có thể cắt như bất kỳ chuỗi nào khác>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
25Ở đây,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 trả về một danh sách có thể được lập chỉ mục hoặc cắt lát>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
26Nếu nhiều biểu thức được phân tách bằng dấu phẩy được chỉ định trong câu lệnh
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
109, thì chúng sẽ được đóng gói và trả về dưới dạng>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
27Khi không có giá trị trả về nào được đưa ra, một hàm Python trả về giá trị Python đặc biệt
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
83>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
28Điều tương tự cũng xảy ra nếu thân hàm hoàn toàn không chứa câu lệnh
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
109 và hàm bị lỗi ở cuối>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
29Nhớ lại điều đó là sai khi được đánh giá trong ngữ cảnh Boolean
Vì các hàm thoát ra thông qua một câu lệnh
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
109 trống hoặc rơi ra khỏi kết thúc trả về >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
83, nên có thể sử dụng lệnh gọi tới một hàm như vậy trong ngữ cảnh Boolean>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
40Ở đây, các cuộc gọi đến cả
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
136 đều là giả, vì vậy >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
137 cũng vậy và mệnh đề >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
138 được thực thiLoại bỏ các quảng cáoXem lại tác dụng phụ
Giả sử bạn muốn viết một hàm nhận một đối số nguyên và nhân đôi nó. Nghĩa là, bạn muốn truyền một biến số nguyên cho hàm và khi hàm trả về, giá trị của biến trong môi trường gọi phải gấp đôi giá trị ban đầu. Trong Pascal, bạn có thể thực hiện việc này bằng cách sử dụng tham chiếu chuyển qua
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
41Việc thực thi mã này tạo ra kết quả sau, xác minh rằng
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
139 thực sự sửa đổi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 trong môi trường gọi>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
42Trong Python, điều này sẽ không hoạt động. Như bạn đã biết, số nguyên trong Python là bất biến, do đó, hàm Python không thể thay đổi đối số số nguyên bằng tác dụng phụ
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
43Tuy nhiên, bạn có thể sử dụng giá trị trả về để có được hiệu ứng tương tự. Chỉ cần viết
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
139 để nó nhận một đối số số nguyên, nhân đôi nó và trả về giá trị nhân đôi. Sau đó, người gọi chịu trách nhiệm về nhiệm vụ sửa đổi giá trị ban đầu>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
44Điều này được cho là thích hợp hơn để sửa đổi bởi tác dụng phụ. Rất rõ ràng rằng
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 đang được sửa đổi trong môi trường cuộc gọi vì người gọi đang tự làm như vậy. Dù sao, đó là lựa chọn duy nhất, bởi vì sửa đổi bằng tác dụng phụ không hoạt động trong trường hợp nàyTuy nhiên, ngay cả trong trường hợp có thể sửa đổi đối số bằng tác dụng phụ, việc sử dụng giá trị trả về vẫn có thể rõ ràng hơn. Giả sử bạn muốn nhân đôi mọi mục trong danh sách. Vì danh sách có thể thay đổi, nên bạn có thể xác định hàm Python để sửa đổi danh sách tại chỗ
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
45Không giống như
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
139 trong ví dụ trước, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
144 thực sự hoạt động như dự định. Nếu tài liệu về hàm nêu rõ rằng nội dung của đối số danh sách đã bị thay đổi, thì đây có thể là một cách triển khai hợp lýTuy nhiên, bạn cũng có thể viết
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
144 để chuyển lại danh sách mong muốn bằng giá trị trả về và cho phép người gọi thực hiện phép gán, tương tự như cách viết lại >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
139 trong ví dụ trước>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
46Một trong hai cách tiếp cận hoạt động tốt như nhau. Như thường lệ, đây là vấn đề về phong cách và sở thích cá nhân khác nhau. Các tác dụng phụ không nhất thiết phải hoàn toàn xấu xa và chúng có vị trí của chúng, nhưng vì hầu như mọi thứ đều có thể được trả về từ một hàm, nên điều tương tự cũng có thể được thực hiện thông qua các giá trị trả về.
Danh sách đối số có độ dài thay đổi
Trong một số trường hợp, khi bạn định nghĩa một hàm, bạn có thể không biết trước mình muốn nó nhận bao nhiêu đối số. Ví dụ, giả sử bạn muốn viết một hàm Python để tính giá trị trung bình của một vài giá trị. Bạn có thể bắt đầu với một cái gì đó như thế này
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
47Tất cả đều ổn nếu bạn muốn tính trung bình ba giá trị
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
48Tuy nhiên, như bạn đã thấy, khi sử dụng đối số vị trí, số lượng đối số được truyền vào phải bằng với số lượng tham số được khai báo. Rõ ràng sau đó, tất cả đều không ổn với việc triển khai
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
147 này cho bất kỳ số lượng giá trị nào khác ngoài ba>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
49Bạn có thể thử xác định
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
147 với các tham số tùy chọn>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
30Điều này cho phép một số lượng đối số khác nhau được chỉ định. Các cuộc gọi sau ít nhất là đúng về mặt cú pháp
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
31Nhưng cách tiếp cận này vẫn gặp phải một số vấn đề. Đối với người mới bắt đầu, nó vẫn chỉ cho phép tối đa năm đối số, không phải là một số tùy ý. Tệ hơn nữa, không có cách nào để phân biệt giữa các đối số đã được chỉ định và những đối số được phép mặc định. Hàm không có cách nào để biết có bao nhiêu đối số thực sự được truyền vào, vì vậy nó không biết chia cho cái gì
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
32Rõ ràng, điều này cũng sẽ không làm được
Bạn có thể viết
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
147 để lấy một đối số danh sách>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
33Ít nhất điều này hoạt động. Nó cho phép một số lượng giá trị tùy ý và tạo ra một kết quả chính xác. Là một phần thưởng bổ sung, nó cũng hoạt động khi đối số là một bộ
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
34Hạn chế là bước bổ sung phải nhóm các giá trị vào một danh sách hoặc bộ dữ liệu có thể không phải là điều mà người dùng hàm mong đợi và nó không được thanh lịch cho lắm. Bất cứ khi nào bạn tìm thấy mã Python trông không phù hợp, có thể có một tùy chọn tốt hơn
Trong trường hợp này, thực sự có. Python cung cấp một cách để truyền vào một hàm một số lượng đối số khác nhau với việc đóng gói và giải nén bộ đối số bằng cách sử dụng toán tử dấu hoa thị [
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
150]Loại bỏ các quảng cáoĐối số Tuple đóng gói
Khi một tên tham số trong định nghĩa hàm Python được đặt trước dấu hoa thị [
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
150], nó biểu thị việc đóng gói bộ đối số. Mọi đối số tương ứng trong lời gọi hàm được đóng gói thành một đối số mà hàm có thể tham chiếu tới bằng tên tham số đã cho. Đây là một ví dụ>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
35Trong định nghĩa của
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36, đặc tả tham số >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
153 biểu thị việc đóng gói bộ. Trong mỗi lệnh gọi đến >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36, các đối số được đóng gói thành một bộ mà hàm có thể tham chiếu bằng tên >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
155. Bất kỳ tên nào cũng có thể được sử dụng, nhưng >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
155 thường được chọn đến mức thực tế nó là một tiêu chuẩnSử dụng đóng gói tuple, bạn có thể dọn sạch
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
147 như thế này>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36Tốt hơn nữa, bạn có thể dọn dẹp nó hơn nữa bằng cách thay thế vòng lặp
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
158 bằng hàm Python tích hợp sẵn >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
159, tính tổng các giá trị số trong bất kỳ lần lặp nào.>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
37Bây giờ,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
147 được viết chính xác và hoạt động như dự kiếnTuy nhiên, tùy thuộc vào cách mã này sẽ được sử dụng, có thể vẫn còn nhiều việc phải làm. Như đã viết,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
147 sẽ tạo ra một ngoại lệ >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
162 nếu bất kỳ đối số nào không phải là số>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
38Để mạnh mẽ nhất có thể, bạn nên thêm mã để kiểm tra xem các đối số có thuộc loại phù hợp không. Ở phần sau của loạt bài hướng dẫn này, bạn sẽ học cách nắm bắt các ngoại lệ như
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
162 và xử lý chúng một cách thích hợp. Bạn cũng có thể kiểm tra Ngoại lệ Python. Một lời giới thiệuGiải nén Tuple đối số
Một hoạt động tương tự có sẵn ở phía bên kia của phương trình trong lệnh gọi hàm Python. Khi một đối số trong lệnh gọi hàm được đặt trước dấu hoa thị [
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
150], điều đó cho biết đối số đó là một bộ nên được giải nén và chuyển đến hàm dưới dạng các giá trị riêng biệt>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
39Trong ví dụ này,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
165 trong lệnh gọi hàm chỉ ra rằng >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
166 là một bộ cần được giải nén. Các giá trị chưa giải nén >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
084, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
168 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
169 được gán cho các tham số >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
18 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
19 tương ứngMặc dù kiểu giải nén này được gọi là giải nén theo bộ, nhưng nó không chỉ hoạt động với các bộ. Toán tử dấu hoa thị [
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
150] có thể được áp dụng cho bất kỳ lần lặp nào trong lệnh gọi hàm Python. Ví dụ: một hoặc bộ cũng có thể được giải nén>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
90Bạn thậm chí có thể sử dụng đóng gói và giải nén tuple cùng một lúc
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
91Ở đây,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
174 chỉ ra rằng danh sách >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
175 nên được giải nén và các mục được chuyển đến >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 dưới dạng các giá trị riêng lẻ. Đặc tả tham số >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
153 làm cho các giá trị được đóng gói sao lưu vào bộ dữ liệu >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
155Đóng gói từ điển đối số
Python có một toán tử tương tự, dấu hoa thị kép [
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
179], có thể được sử dụng với các tham số và đối số của hàm Python để chỉ định đóng gói và giải nén từ điển. Trước một tham số trong định nghĩa hàm Python bằng dấu hoa thị kép [>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
179] cho biết rằng các đối số tương ứng, dự kiến là các cặp >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
181, nên được đưa vào từ điển>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
92Trong trường hợp này, các đối số
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
182, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
183 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
184 được đóng gói trong một từ điển mà hàm có thể tham chiếu theo tên >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
185. Một lần nữa, bất kỳ tên nào cũng có thể được sử dụng, nhưng tên đặc biệt >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
185 [viết tắt của từ khóa args] gần như là tiêu chuẩn. Bạn không cần phải tuân theo nó, nhưng nếu bạn làm như vậy, thì bất kỳ ai quen thuộc với các quy ước mã hóa Python sẽ biết ngay ý của bạnGiải nén từ điển đối số
Giải nén từ điển đối số tương tự như giải nén bộ dữ liệu đối số. Khi dấu hoa thị kép [
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
179] đứng trước một đối số trong lệnh gọi hàm Python, nó chỉ định rằng đối số đó là một từ điển cần được giải nén, với các mục kết quả được chuyển đến hàm dưới dạng đối số từ khóa>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
93Các mục trong từ điển
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
188 được giải nén và chuyển đến >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 dưới dạng đối số từ khóa. Vì vậy, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
190 tương đương với >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
191>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
94Trên thực tế, hãy kiểm tra điều này
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
95Ở đây,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
192 tạo một từ điển từ các cặp khóa/giá trị được chỉ định. Sau đó, toán tử dấu hoa thị kép [>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
179] giải nén nó và chuyển các từ khóa tới >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36Để tất cả chúng cùng nhau
Hãy coi
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
153 là danh sách đối số vị trí có độ dài thay đổi và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
196 là danh sách đối số từ khóa có độ dài thay đổiGhi chú. Để có cái nhìn khác về
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
153 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
196, hãy xem Python args và kwargs. làm sáng tỏTất cả ba—tham số vị trí tiêu chuẩn,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
153 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
196—có thể được sử dụng trong một định nghĩa hàm Python. Nếu vậy, thì chúng nên được chỉ định theo thứ tự đó>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
96Điều này mang lại sự linh hoạt gần như bạn có thể cần trong một giao diện chức năng
Nhiều lần giải nén trong một lệnh gọi hàm Python
Python phiên bản 3. 5 đã giới thiệu hỗ trợ cho các khái quát hóa giải nén bổ sung, như được nêu trong PEP 448. Một điều mà những cải tiến này cho phép là nhiều lần giải nén trong một lệnh gọi hàm Python
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
97Bạn cũng có thể chỉ định nhiều lần giải nén từ điển trong lệnh gọi hàm Python
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
98Ghi chú. Cải tiến này chỉ có trong phiên bản Python 3. 5 hoặc muộn hơn. Nếu bạn thử điều này trong phiên bản cũ hơn, thì bạn sẽ nhận được một ngoại lệ
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
201Nhân tiện, các toán tử giải nén
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
150 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
179 không chỉ áp dụng cho các biến, như trong ví dụ trên. Bạn cũng có thể sử dụng chúng với các chữ có thể lặp lại>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
99Ở đây, các danh sách theo nghĩa đen
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
204 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
205 được chỉ định để giải nén bộ dữ liệu và các từ điển theo nghĩa đen >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
206 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
207 được chỉ định để giải nén từ điểnĐối số chỉ từ khóa
Một chức năng Python trong phiên bản 3. x có thể được xác định sao cho nó nhận các đối số chỉ từ khóa. Đây là các đối số chức năng phải được chỉ định bởi từ khóa. Hãy khám phá một tình huống mà điều này có thể có lợi
Giả sử bạn muốn viết một hàm Python nhận vào một số lượng đối số chuỗi thay đổi, nối chúng lại với nhau và phân tách bằng dấu chấm [
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
208] và in chúng ra bàn điều khiển. Một cái gì đó như thế này sẽ làm để bắt đầu>>>
>>> s = 'foobar'
>>> id[s]
56313440
20Như hiện tại, tiền tố đầu ra được mã hóa cứng thành chuỗi
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
209. Điều gì sẽ xảy ra nếu bạn muốn sửa đổi hàm để chấp nhận điều này làm đối số, để người dùng có thể chỉ định điều gì khác? >>>
>>> s = 'foobar'
>>> id[s]
56313440
21Điều này hoạt động như quảng cáo, nhưng có một vài điều không mong muốn về giải pháp này
Chuỗi
210 được gộp chung với các chuỗi cần nối. Chỉ cần nhìn vào lệnh gọi hàm, không rõ ràng rằng đối số đầu tiên được xử lý khác với phần còn lại. Để biết điều đó, bạn phải quay lại và xem định nghĩa hàm>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
210 không phải là tùy chọn. Nó luôn phải được đưa vào và không có cách nào để giả định một giá trị mặc định>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
Bạn có thể nghĩ rằng bạn có thể khắc phục vấn đề thứ hai bằng cách chỉ định một tham số có giá trị mặc định, có lẽ như thế này
>>>
>>> s = 'foobar'
>>> id[s]
56313440
22Thật không may, điều này không hoạt động hoàn toàn đúng.
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
210 là một tham số vị trí, vì vậy trình thông dịch giả định rằng đối số đầu tiên được chỉ định trong lệnh gọi hàm là tiền tố đầu ra dự định. Điều này có nghĩa là không có cách nào để bỏ qua nó và lấy giá trị mặc định>>>
>>> s = 'foobar'
>>> id[s]
56313440
23Điều gì sẽ xảy ra nếu bạn cố chỉ định
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
210 làm đối số từ khóa? >>>
>>> s = 'foobar'
>>> id[s]
56313440
24Như bạn đã thấy trước đây, khi cả hai loại đối số được đưa ra, tất cả các đối số vị trí phải xuất hiện trước bất kỳ đối số từ khóa nào
Tuy nhiên, bạn cũng không thể chỉ định nó lần cuối
>>>
>>> s = 'foobar'
>>> id[s]
56313440
25Một lần nữa,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
210 là một tham số vị trí, do đó, nó được gán đối số đầu tiên được chỉ định trong lệnh gọi [trong trường hợp này là >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
215]. Sau đó, khi nó được chỉ định lại làm đối số từ khóa ở cuối, Python nghĩ rằng nó đã được chỉ định hai lầnCác thông số chỉ dành cho từ khóa giúp giải quyết tình trạng khó xử này. Trong định nghĩa hàm, chỉ định
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
153 để biểu thị số lượng biến đối số vị trí, sau đó chỉ định >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
210 sau đó>>>
>>> s = 'foobar'
>>> id[s]
56313440
26Trong trường hợp đó,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
210 trở thành tham số chỉ từ khóa. Giá trị của nó sẽ không bao giờ được lấp đầy bởi một đối số vị trí. Nó chỉ có thể được chỉ định bởi một đối số từ khóa được đặt tên>>>
>>> s = 'foobar'
>>> id[s]
56313440
27Lưu ý rằng điều này chỉ có thể thực hiện được trong Python 3. Trong phiên bản 2. x của Python, chỉ định các tham số bổ sung sau tham số đối số biến
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
153 gây ra lỗiĐối số chỉ từ khóa cho phép hàm Python nhận một số lượng đối số khác nhau, theo sau là một hoặc nhiều tùy chọn bổ sung làm đối số từ khóa. Nếu bạn muốn sửa đổi
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
220 để ký tự phân tách cũng có thể được chỉ định tùy chọn, thì bạn có thể thêm một đối số chỉ từ khóa bổ sung>>>
>>> s = 'foobar'
>>> id[s]
56313440
28Nếu tham số chỉ từ khóa được cung cấp giá trị mặc định trong định nghĩa hàm [như trong ví dụ trên] và từ khóa bị bỏ qua khi hàm được gọi, thì giá trị mặc định sẽ được cung cấp
>>>
>>> s = 'foobar'
>>> id[s]
56313440
29Mặt khác, nếu tham số không được cung cấp giá trị mặc định, thì tham số đó sẽ trở thành bắt buộc và việc không chỉ định tham số sẽ dẫn đến lỗi
>>>
>>> s = 'foobar'
>>> id[s]
56313440
40Điều gì sẽ xảy ra nếu bạn muốn xác định một hàm Python chỉ nhận một đối số từ khóa nhưng không nhận một số lượng đối số vị trí khác nhau?
>>>
>>> s = 'foobar'
>>> id[s]
56313440
41Nếu bạn muốn biến
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
221 thành tham số chỉ có từ khóa, thì bạn có thể thêm tham số đối số biến giả không liên quan và chỉ cần bỏ qua tham số đó>>>
>>> s = 'foobar'
>>> id[s]
56313440
42Vấn đề với giải pháp này là
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
222 hấp thụ mọi đối số vị trí không liên quan có thể được đưa vào>>>
>>> s = 'foobar'
>>> id[s]
56313440
43Trong ví dụ này, không nên có đối số bổ sung [vì chính đối số đó đã thông báo]. Thay vì thành công một cách lặng lẽ, nó thực sự sẽ dẫn đến một lỗi. Thực tế là nó không phải là lộn xộn nhất. Tệ nhất, nó có thể gây ra một kết quả có vẻ sai lệch
>>>
>>> s = 'foobar'
>>> id[s]
56313440
44Để khắc phục điều này, phiên bản 3 cho phép tham số đối số biến trong định nghĩa hàm Python chỉ là dấu hoa thị [
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
150], với tên được bỏ qua>>>
>>> s = 'foobar'
>>> id[s]
56313440
45Tham số đối số biến trần
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
150 chỉ ra rằng không có bất kỳ tham số vị trí nào nữa. Hành vi này tạo ra các thông báo lỗi thích hợp nếu các thông báo lỗi bổ sung được chỉ định. Nó cho phép các tham số chỉ từ khóa theo dõiĐối số chỉ vị trí
Kể từ Python 3. 8, các tham số chức năng cũng có thể được khai báo chỉ theo vị trí, nghĩa là các đối số tương ứng phải được cung cấp theo vị trí và không thể được chỉ định bằng từ khóa
Để chỉ định một số tham số là chỉ vị trí, bạn chỉ định dấu gạch chéo [
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
225] trong danh sách tham số của định nghĩa hàm. Bất kỳ tham số nào ở bên trái dấu gạch chéo [>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
225] phải được chỉ định theo vị trí. Ví dụ: trong định nghĩa hàm sau, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
17 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
18 là các tham số chỉ vị trí, nhưng >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
19 có thể được chỉ định bằng từ khóa>>>
>>> s = 'foobar'
>>> id[s]
56313440
46Điều này có nghĩa là các cuộc gọi sau là hợp lệ
>>>
>>> s = 'foobar'
>>> id[s]
56313440
47Tuy nhiên, cuộc gọi sau tới
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 không hợp lệ>>>
>>> s = 'foobar'
>>> id[s]
56313440
48Cả hai chỉ định vị trí và chỉ từ khóa đều có thể được sử dụng trong cùng một định nghĩa hàm
>>>
>>> s = 'foobar'
>>> id[s]
56313440
49trong ví dụ này
17 và>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
18 chỉ dành cho vị trí>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
175 và>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
234 chỉ là từ khóa>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
19 và>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
236 có thể được chỉ định theo vị trí hoặc theo từ khóa>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
Để biết thêm thông tin về các tham số chỉ vị trí, hãy xem phần
tài liệu
Khi câu lệnh đầu tiên trong phần thân của hàm Python là một chuỗi ký tự, nó được gọi là chuỗi tài liệu của hàm. Một chuỗi tài liệu được sử dụng để cung cấp tài liệu cho một chức năng. Nó có thể chứa mục đích của hàm, những đối số mà hàm nhận, thông tin về giá trị trả về hoặc bất kỳ thông tin nào khác mà bạn cho là hữu ích
Sau đây là một ví dụ về định nghĩa hàm với chuỗi tài liệu
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
00Về mặt kỹ thuật, các chuỗi tài liệu có thể sử dụng bất kỳ cơ chế trích dẫn nào của Python, nhưng quy ước được đề xuất là trích dẫn ba lần bằng cách sử dụng các ký tự trích dẫn kép [
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
237], như minh họa ở trên. Nếu chuỗi tài liệu nằm trên một dòng, thì dấu ngoặc kép đóng phải nằm trên cùng một dòng với dấu ngoặc kép mởCác chuỗi tài liệu nhiều dòng được sử dụng cho tài liệu dài hơn. Một chuỗi tài liệu nhiều dòng phải bao gồm một dòng tóm tắt, theo sau là một dòng trống, tiếp theo là một mô tả chi tiết hơn. Các trích dẫn đóng phải nằm trên một dòng
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
01Định dạng chuỗi tài liệu và quy ước ngữ nghĩa được trình bày chi tiết trong PEP 257
Khi một chuỗi tài liệu được xác định, trình thông dịch Python sẽ gán nó cho một thuộc tính đặc biệt của hàm có tên là
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
238. Thuộc tính này là một trong những bộ định danh chuyên biệt trong Python, đôi khi được gọi là thuộc tính ma thuật hoặc phương thức ma thuật vì chúng cung cấp chức năng ngôn ngữ đặc biệtGhi chú. Các thuộc tính này cũng được gọi bằng các thuộc tính dunder biệt danh đầy màu sắc và các phương thức dunder. Từ dunder kết hợp d từ double và under từ ký tự gạch dưới [
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
239]. Bạn sẽ gặp nhiều thuộc tính và phương thức khác trong các hướng dẫn trong tương lai của loạt bài nàyBạn có thể truy cập chuỗi tài liệu của hàm bằng biểu thức
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
240. Các tài liệu cho các ví dụ trên có thể được hiển thị như sau>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
02Trong trình thông dịch Python tương tác, bạn có thể nhập
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
241 để hiển thị chuỗi tài liệu cho >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
27>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
03Việc chỉ định một chuỗi tài liệu cho mỗi hàm Python mà bạn xác định được coi là một phương pháp mã hóa tốt. Để biết thêm về docstrings, hãy xem
Chú thích hàm Python
Kể từ phiên bản 3. 0, Python cung cấp một tính năng bổ sung để ghi lại một hàm được gọi là chú thích hàm. Chú thích cung cấp một cách để đính kèm siêu dữ liệu vào các tham số của hàm và trả về giá trị
Để thêm chú thích vào tham số hàm Python, hãy chèn dấu hai chấm [
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
29] theo sau bởi bất kỳ biểu thức nào sau tên tham số trong định nghĩa hàm. Để thêm chú thích vào giá trị trả về, hãy thêm các ký tự >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
244 và bất kỳ biểu thức nào giữa dấu ngoặc đơn đóng của danh sách tham số và dấu hai chấm kết thúc tiêu đề hàm. Đây là một ví dụ>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
04Chú thích cho tham số
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
175 là chuỗi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
246, cho >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
234 là chuỗi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
248 và cho giá trị trả về của hàm là chuỗi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
249Trình thông dịch Python tạo một từ điển từ các chú thích và gán chúng cho một thuộc tính dunder đặc biệt khác của hàm có tên là
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
250. Các chú thích cho hàm Python >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 hiển thị ở trên có thể được hiển thị như sau>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
05Các phím cho các tham số là tên tham số. Chìa khóa cho giá trị trả về là chuỗi
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
252>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
06Lưu ý rằng các chú thích không bị hạn chế đối với các giá trị chuỗi. Chúng có thể là bất kỳ biểu thức hoặc đối tượng nào. Ví dụ: bạn có thể chú thích bằng các đối tượng kiểu
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
07Chú thích thậm chí có thể là một đối tượng tổng hợp như từ điển hoặc từ điển, vì vậy có thể đính kèm nhiều mục siêu dữ liệu vào tham số và trả về giá trị
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
08Trong ví dụ trên, một chú thích được gắn vào tham số
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
253 và giá trị trả về. Mỗi chú thích là một từ điển chứa mô tả chuỗi và đối tượng kiểuNếu bạn muốn gán giá trị mặc định cho tham số có chú thích, thì giá trị mặc định sẽ nằm sau chú thích
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
09Chú thích làm gì? . Họ chỉ là loại ở đó. Hãy xem lại một trong những ví dụ ở trên, nhưng với một vài sửa đổi nhỏ
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
10Những gì đang xảy ra ở đây? . Nhưng cuộc gọi tiếp theo tới
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
36 phá vỡ tất cả các quy tắc. Các đối số lần lượt là >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
080 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
257 và giá trị trả về là một bộ. Tuy nhiên, thông dịch viên cho phép tất cả trượt mà không phàn nàn gì cảChú thích không áp đặt bất kỳ hạn chế ngữ nghĩa nào đối với mã. Chúng chỉ đơn giản là các bit siêu dữ liệu được đính kèm với các tham số hàm Python và giá trị trả về. Python cẩn thận cất chúng vào một từ điển, gán từ điển cho thuộc tính dunder
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
250 của hàm, và thế là xong. Chú thích là hoàn toàn tùy chọn và hoàn toàn không có bất kỳ tác động nào đến việc thực thi hàm PythonĐể trích dẫn Amahl trong Amahl và những vị khách ban đêm, “Vậy thì có ích lợi gì?”
Đối với người mới bắt đầu, chú thích tạo tài liệu tốt. Tất nhiên, bạn có thể chỉ định thông tin tương tự trong chuỗi tài liệu, nhưng việc đặt nó trực tiếp trong định nghĩa hàm sẽ làm rõ hơn. Các loại đối số và giá trị trả về hiển thị rõ ràng đối với tiêu đề hàm như thế này
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
11Cấp, trình thông dịch không bắt buộc tuân thủ các loại được chỉ định, nhưng ít nhất chúng rõ ràng đối với người đọc định nghĩa hàm
Lặn sâu. Thực thi kiểm tra loại
Nếu muốn, bạn có thể thêm mã để thực thi các loại được chỉ định trong chú thích hàm. Đây là một hàm kiểm tra loại thực tế của từng đối số so với những gì được chỉ định trong chú thích cho tham số tương ứng. Nó hiển thị
23 nếu chúng khớp và>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
24 nếu chúng không khớp>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
>>>
12>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
[Mô-đun
264 chứa các hàm lấy thông tin hữu ích về các đối tượng trực tiếp—trong trường hợp này là hàm>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
36. ]>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len[a] 4
Nếu muốn, một hàm được xác định giống như hàm ở trên có thể thực hiện một số loại hành động khắc phục khi nó phát hiện ra rằng các đối số được truyền vào không tuân theo các loại được chỉ định trong chú thích
Trên thực tế, sơ đồ sử dụng chú thích để thực hiện kiểm tra kiểu tĩnh trong Python được mô tả trong PEP 484. Có sẵn một trình kiểm tra kiểu tĩnh miễn phí dành cho Python có tên là mypy, được xây dựng trên đặc tả PEP 484
Cũng có một lợi ích khác khi sử dụng chú thích. Định dạng được tiêu chuẩn hóa trong đó thông tin chú thích được lưu trữ trong thuộc tính
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
250 phù hợp với việc phân tích chữ ký hàm bằng các công cụ tự độngKhi nói đến nó, các chú thích không có gì đặc biệt kỳ diệu. Bạn thậm chí có thể định nghĩa của riêng mình mà không cần cú pháp đặc biệt mà Python cung cấp. Đây là một định nghĩa hàm Python với các chú thích đối tượng kiểu được đính kèm với các tham số và giá trị trả về
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
13Sau đây về cơ bản là chức năng tương tự, với từ điển
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
250 được xây dựng thủ công>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
14Hiệu ứng giống hệt nhau trong cả hai trường hợp, nhưng hiệu ứng đầu tiên hấp dẫn hơn và dễ đọc hơn ngay từ cái nhìn đầu tiên
Trên thực tế, thuộc tính
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
250 không khác biệt đáng kể so với hầu hết các thuộc tính khác của hàm. Ví dụ, nó có thể được sửa đổi động. Bạn có thể chọn sử dụng thuộc tính giá trị trả về để đếm số lần một hàm được thực thi>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len[a]
4
15Chú thích hàm Python không gì khác hơn là từ điển siêu dữ liệu. Điều xảy ra là bạn có thể tạo chúng bằng cú pháp thuận tiện được trình thông dịch hỗ trợ. Họ là bất cứ điều gì bạn chọn để làm cho họ
Phần kết luận
Khi các ứng dụng phát triển lớn hơn, việc mô đun hóa mã bằng cách chia mã thành các chức năng nhỏ hơn với kích thước có thể quản lý ngày càng trở nên quan trọng. Bây giờ bạn hy vọng có tất cả các công cụ bạn cần để làm điều này
Bạn đã học
- Cách tạo hàm do người dùng định nghĩa trong Python
- Một số cách khác nhau để bạn có thể truyền đối số cho một hàm
- Cách bạn có thể trả lại dữ liệu từ một chức năng cho người gọi nó
- Cách thêm tài liệu vào các chức năng bằng tài liệu và chú thích
Tiếp theo trong loạt bài này là hai hướng dẫn về tìm kiếm và khớp mẫu. Bạn sẽ có cái nhìn sâu hơn về một mô-đun Python có tên là re, mô-đun này chứa chức năng tìm kiếm và so khớp bằng cú pháp mẫu linh hoạt được gọi là biểu thức chính quy
« Kỹ thuật định dạng chuỗi Python
Biểu thức chính quy. Regex trong Python [Phần 1] »
Đánh dấu là đã hoàn thành
Xem ngay Hướng dẫn này có một khóa học video liên quan do nhóm Real Python tạo. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn. Định nghĩa và gọi hàm Python
🐍 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ề John Sturtz
John là một Pythonista cuồng nhiệt và là thành viên của nhóm hướng dẫn Real Python
» Thông tin thêm về JohnMỗ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
Jaya
Joanna
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ẻ EmailBà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. 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