Review Điều gì là đúng về chức năng python?

Thủ Thuật về Điều gì là đúng về hiệu suất cao python? Mới Nhất

Khoa Minh Hoàng đang tìm kiếm từ khóa Điều gì là đúng về hiệu suất cao python? được Cập Nhật vào lúc : 2022-12-24 03:50:08 . Với phương châm chia sẻ Mẹo về trong nội dung bài viết một cách Chi Tiết 2022. Nếu sau khi Read nội dung bài viết vẫn ko hiểu thì hoàn toàn có thể lại Comments ở cuối bài để Admin lý giải và hướng dẫn lại nha.

Xuyên suốt những 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 lúc nào nên chia chương trình của tớ thành những hiệu suất cao riêng biệt do người tiêu dùng xác định và bạn sẽ có nhu yếu các công cụ nào để thực hiện việc này

Nội dung chính Show

Hàm trong PythonTầm quan trọng của những hàm PythonTính trừu tượng và kĩ năng sử dụng lạitính mô đunTách không khí tênGọi hàm và định nghĩaTruyền đối sốĐối số vị tríĐối số từ khóaThông số mặc địnhGiá trị tham số mặc định hoàn toàn có thể thay đổiPass-By-Value vs Pass-By-Reference trong PascalPass-By-Value vs Pass-By-Reference trong PythonTóm tắt thông qua đối sốPhản ứng phụTuyên bố >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 109Thoát khỏi một chức năngTrả lại tài liệu cho những người dân gọiXem lại tác dụng phụDanh sách đối số có độ dài thay đổiĐối số Tuple đóng góiGiải nén Tuple đối sốĐóng gói từ điển đối sốGiải nén từ điển đối sốĐể tất cả chúng cùng nhauNhiều lần giải nén trong một lệnh gọi hàm PythonĐối số chỉ từ khóaĐối số chỉ vị trítài liệuChú thích hàm PythonPhần kết luậnCác hiệu suất cao của Python là gì?3 hiệu suất cao trong Python là gì?Điều nào sau đây không đúng về những hàm Python?Điều gì mô tả tốt nhất một hiệu suất cao trong Python?

Đây là những gì bạn sẽ học trong hướng dẫn này

Các hàm hoạt động và sinh hoạt giải trí ra làm sao trong Python và tại sao chúng lại hữu íchCách xác định và gọi hàm Python của riêng bạnCơ chế truyền đối số cho hàm của bạnCách trả lại tài liệu từ hiệu suất cao của bạn về môi trường tự nhiên thiên nhiên gọi

Tải xuống PDF miễn phí. Bảng cheat Python 3

Hàm trong Python

Bạn hoàn toàn có thể quen thuộc với khái niệm toán học của hàm. Hàm là quan hệ hoặc ánh xạ giữa một hoặc nhiều đầu vào và một tập hợp những đầu ra. Trong toán học, một hàm thường được màn biểu diễn như vậy này

Ở đây,

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 16 là một hiệu suất cao hoạt động và sinh hoạt giải trí trên những đầ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, những hiệu suất cao 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 thích hợp đến mức hầu như tất cả những ngôn từ lập trình tân tiến đều tương hỗ cả hàm tích hợp và hàm do người tiêu dùng định nghĩa

Trong 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ụ rõ ràng hoặc một nhóm tác vụ có liên quan. Trong những hướng dẫn trước của loạt bài này, bạn đã được ra mắt về một số trong những hàm tích hợp do Python đáp ứng. , 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 0

Mỗi hiệu suất cao tích hợp này thực hiện một trách nhiệm rõ ràng. Mã hoàn thành xong trách nhiệm được xác định ở đâu đó, nhưng bạn tránh việc phải biết mã đó hoạt động và sinh hoạt giải trí ở đâu hoặc thậm chí ra làm sao. Tất cả những gì bạn nên phải biết là giao diện của hiệu suất cao

Những đối số (nếu có) nó cầnGiá trị nào (nếu có) nó trả về

Sau đó, bạn gọi hàm và chuyển những đố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 việc làm hữu ích của nó. Khi hiệu suất cao kết thúc, quá trình thực thi sẽ quay trở lại mã của bạn nơi nó đã tạm dừng. Hàm hoàn toàn có thể hoặc không thể trả về tài liệu để mã của bạn sử dụng, như những ví dụ trên

Khi bạn xác định hàm Python của riêng mình, nó sẽ hoạt động và sinh hoạt giải trí in 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 tớ 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à đúng chuẩn nó hoạt động và sinh hoạt giải trí ra làm sao vì bạn đã viết nó

Khi hiệu suất cao kết thúc, thực thi trở lại vị trí mà hiệu suất cao đã được gọi. Tùy thuộc vào cách bạn thiết kế giao diện của hàm, tài liệu hoàn toàn có thể được truyền vào khi hàm được gọi và những giá trị trả về hoàn toàn có thể được truyền lại khi hàm kết thúc

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

Tầm quan trọng của những hàm Python

Hầu như tất cả những ngôn từ lập trình được sử dụng ngày này đều tương hỗ một dạng hàm do người tiêu dùng định nghĩa, tuy nhiên chúng không phải lúc nào thì cũng khá được gọi là hàm. Trong những ngôn từ khác, bạn hoàn toàn có thể thấy chúng được gọi là một trong những ngôn từ sau

chương trình conthủ tụcphương phápchương trình con

Vì vậy, tại sao phải xác định hiệu suất cao? . Bây giờ tất cả chúng ta hãy đi qua một số trong những

Tính trừu tượng và kĩ năng sử dụng lại

Giả sử bạn viết một số trong những 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í rất khác nhau trong ứng dụng của bạn. Những gì bạn nên làm?

Sau này, hoàn toàn có thể bạn sẽ quyết định rằng mã được đề cập nê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 phải sửa chữa hoặc bạn sẽ muốn cải tổ nó theo một cách nào đó. Nếu những 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 những thay đổi thiết yếu ở mọi vị trí

Ghi chú. Thoạt nhìn, đó có vẻ như thể một giải pháp hợp lý, nhưng về lâu dài, nó hoàn toàn có thể là một cơn ác mộng về bảo dưỡng. Mặc dù trình soạn thảo mã của bạn hoàn toàn có thể trợ giúp bằng phương pháp đáp ứng hiệu suất cao tìm kiếm và thay thế, nhưng phương pháp này dễ bị lỗi và bạn hoàn toàn có thể thuận tiện và đơn giản đưa những lỗi vào mã của tớ 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 xong tác vụ, bạn chỉ việc gọi hàm. Cuối cùng, nếu bạn quyết định thay đổi phương pháp hoạt động và sinh hoạt giải trí của nó, thì bạn chỉ việc thay đổi mã ở một vị trí, đó là nơi xác định hiệu suất cao. Các thay đổi sẽ tự động được chọn ở bất kỳ đâu mà hiệu suất cao được gọi

Việc trừu tượng hóa hiệu suất cao thành một định nghĩa hiệu suất cao 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 những hiệu suất cao

tính mô đun

Các hiệu suất cao được cho phép chia những quy trình phức tạp thành tiến trình 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 hoàn toàn có thể trông như vậy này

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 1

Trong ví dụ này, chương trình đó đó là một loạt mã được xâu thành một chuỗi dài, với khoảng chừ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 thế nữa và phức tạp hơn nhiều, thì bạn sẽ ngày càng gặp trở ngại vất vả trong việc xoay sở với nó.

Ngoài ra, bạn hoàn toàn có thể cấu trúc mã in như sau

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 2

Ví 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 phân thành những hiệu suất cao riêng biệt, mỗi hiệu suất cao tập trung vào một trách nhiệm rõ ràng. Những tác vụ đó được đọc, xử lý và ghi. Chương trình chính giờ đây chỉ việc 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 ra mắt 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ớm

Trong môi trường tự nhiên thiên nhiên sống đời thường, bạn luôn làm những việc như vậy này, trong cả những lúc bạn không nghĩ rõ ràng về nó theo cách đó. Nếu bạn muốn di tán một số trong những kệ chứa đầy đồ đạc từ bên này sang bên kia ga-ra của tớ, thì kỳ vọng rằng bạn sẽ không riêng gì có đứng đó và nghĩ vu vơ, “Ôi trời. Tôi nên phải di tá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 những kệMang những bộ phận của kệ qua nhà để xe đến vị trí mớiLắp ráp lại những kệMang đồ qua nhà để xeĐặt lại những thứ trên kệ

Chia một trách nhiệm lớn thành những trách nhiệm nhỏ hơn, nhỏ hơn giúp làm cho trách nhiệm lớn dễ suy nghĩ và quản lý hơn. Khi những 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ỏ những quảng cáo

Tách không khí tên

Không gian tên là một vùng của chương trình trong đó những mã định danh có ý nghĩa. Như bạn sẽ thấy phía dưới, khi một hàm Python được gọi, một không khí tên mới được tạo cho hàm đó, một không khí tên khác với tất cả những không khí tên khác đã tồn tại

Kết quả thực tế của điều này là những biến hoàn toàn có thể được xác định và sử dụng trong một hàm Python trong cả những lúc chúng có cùng tên với những biến được định nghĩa trong những 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òn sự nhầm lẫn hoặc can thiệp vì chúng được giữ trong những không khí tên riêng biệt

Điều này nghĩa là lúc bạn viết mã trong một hàm, bạn hoàn toàn có thể sử dụng tên biến và mã định danh mà không phải lo ngại về việc liệu chúng đã được sử dụng ở đâu khác bên phía ngoài hàm chưa. Điều này giúp giảm thiểu đáng kể những lỗi trong mã

Ghi chú. Bạn sẽ tìm hiểu thêm về không khí 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 những hiệu suất cao và mong ước tạo ra một số trong những. 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 4

Các thành phần của định nghĩa được lý giải 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 list những tham số tùy chọn, được phân tách bằng dấu phẩy hoàn toàn 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 (list tên và tham số)>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 30A

Mục ở đầu cuối,

>>> 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 những 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 phương pháp thụt đầu dòng theo quy định. Điều này in như những khối mã được link với cấu trúc điều khiển, ví dụ như câu lệnh >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 32 hoặc >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 33

Cú 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à những 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 hoàn toàn có thể định nghĩa một hàm không sở hữu và 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 gồm có dấu ngoặc đơn, trong cả những lúc chúng trống

Như thường lệ, bạn sẽ khởi đầ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 lăm, bạn sẽ gọi hàm Python đầu tiên của tớ 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 và sinh hoạt giải trí

Dòng 1 sử dụng từ khóa

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 25 để chỉ ra rằng một hiệu suất cao đ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ả những 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 tàng trữ dưới dạng định nghĩa của nó, nhưng chúng không được thực thi

Dòng 4 là một chút ít khoảng chừ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 thiết yếu về mặt cú pháp, nhưng thật tuyệt khi có. Để tìm hiểu thêm về khoảng chừng trắng xung quanh những đị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ề

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 36. Nó khởi đầ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

Dòng 6 là cuộc gọi đến

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 36. Lưu ý rằng dấu ngoặc đơn trống luôn luôn được yêu cầu trong cả định nghĩa hàm và lời gọi hàm, trong cả lúc không còn 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à những câu lệnh trong phần thân của >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 36 được thực thi

Dòng 7 là loại tiếp theo thực thi sau khi phần thân của

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 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

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ơ đồ sau

Khi

>>> 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 hoàn toà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 4

Như bạn hoàn toà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ỏ những quảng cáo

Truyền đối số

Cho đến giờ trong hướng dẫn này, những hàm bạn đã xác định chưa nhận bất kỳ đối số nào. Điều đó đôi khi hoàn toàn có thể hữu ích và thỉnh thoảng bạn sẽ viết những hàm như vậy. Tuy nhiên, thường xuyên hơn, bạn sẽ muốn truyền tài liệu vào một hàm để hành vi của nó hoàn toà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 list 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 0

Khi hàm được gọi, bạn chỉ định một list những đối số tương ứng

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 1

Cá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 và sinh hoạt giải trí in như những biến được xác định cục bộ cho hàm. Khi hàm được gọi, những đố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 link với những tham số theo thứ tự, như thể bằng phép 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 57

Trong một số trong những văn bản lập trình, những tham số được đưa ra trong định nghĩa hàm được gọi là tham số hình thức và những đối số trong lệnh gọi hàm được gọi là tham số thực

Mặc dù những đối số vị trí là cách đơn giản nhất để truyền tài 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 khởi đầu, thứ tự của những đối số trong lệnh gọi phải khớp với thứ tự của những tham số trong định nghĩa. Tất nhiên, không còn gì ngăn bạn chỉ định những đối số vị trí không theo thứ tự

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 2

Hàm thậm chí hoàn toàn có thể vẫn chạy, như trong ví dụ trên, nhưng rất khó hoàn toàn có thể tạo ra kết quả đúng chuẩn. Người lập trình có trách nhiệm xác định hiệu suất cao để ghi lại những đối số phù hợp và trách nhiệm của người tiêu dùng hiệu suất cao là nhận thức được thông tin đó và tuân theo thông tin đó

Với những đối số vị trí, những đối số trong lệnh gọi và những tham số trong định nghĩa phải thống nhất không riêng gì có về thứ tự mà còn về số lượng. Đó là nguyên do đối số vị trí cũng khá đượ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 3

Bạn cũng không thể chỉ định những cái tương hỗ update

>>>

>>> 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 rất khó tha thứ. Bạn phải chỉ định cùng một số trong những đối số trong lệnh gọi hàm như có những tham số trong định nghĩa và theo đúng thứ tự. Trong những phần tiếp theo, bạn sẽ thấy một số trong những kỹ thuật chuyển đối số giúp nới lỏng những hạn chế này

Đối số từ khóa

Khi gọi một hàm, bạn hoàn toàn có thể chỉ định những đố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 hoàn toàn có thể được gọi với những đối số từ khóa như sau

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 5

Tham 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 6

Sử dụng những đối số từ khóa sẽ vô hiệu hạn chế về thứ tự đối số. Mỗi đối số từ khóa chỉ định rõ ràng một tham số rõ ràng theo tên, vì vậy bạn hoàn toà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 7

Tuy nhiên, in 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 8

Vì vậy, những đối số từ khóa được cho phép linh hoạt trong thứ tự những đối số hiệu suất cao được chỉ định, nhưng số lượng đối số vẫn còn cứng nhắc

Bạn hoàn toàn có thể gọi một hàm bằng phương pháp sử dụng cả đối số vị trí và từ khóa

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 9

Khi cả hai đối số vị trí và từ khóa đều xuất hiện, tất cả những đối số vị trí phải xuất hiện trước

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 00

Khi 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ề những tham số vị trí và từ khóa, hãy xem khóa học Real Python Khám phá những tham số hiệu suất cao đặc biệt

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

Thô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 những tham số mặc định được hiển thị phía dưới

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 01

Khi 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 02

Tóm tắt

Các đối số vị trí phải thống nhất về thứ tự và số với những tham số được khai báo trong định nghĩa hàmCác đối số từ khóa phải phù phù phù hợp với những tham số đã khai báo về số lượng, nhưng chúng hoàn toàn có thể được chỉ định theo thứ tự tùy ýTham số mặc định được cho phép bỏ qua một số trong những đối số khi gọi hàm

Giá trị tham số mặc định hoàn toàn có thể thay đổi

Mọi 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 hoàn toàn 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ố list, nối chuỗi >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 71 vào cuối list và trả về kết quả

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 04

Giá trị mặc định cho tham số

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 72 là list trống, vì vậy nếu >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 36 được gọi mà không còn bất kỳ đối số nào, thì giá trị trả về là list 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 05

Mọi thứ đều có ý nghĩa cho tới 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òn 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 hoàn toàn có thể mong đợi mỗi cuộc gọi tiếp theo cũng trả về list đơn lẻ

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 76, in 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, những 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à lúc 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òn tham số, bạn đang thực hiện >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 79 trên cùng một list

Bạn hoàn toàn có thể chứng tỏ điều này với

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 20

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 07

Mã đị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 lệnh gọi. Vì những list hoàn toàn 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 list dài hơn thế nữa. Đâ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 hoàn toàn có thể thay đổi làm giá trị mặc định của tham số. Nó hoàn toàn có thể dẫn đến hành vi mã khó hiểu và có lẽ rằng tốt nhất nên tránh

Như một giải pháp thay thế, hãy xem xét sử dụng một giá trị đối số mặc định báo hiệu rằng không còn đối số nào được chỉ định. Hầu hết mọi giá trị sẽ hoạt động và sinh hoạt giải trí, 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 thêm thêm không còn đối số nào được đưa ra, hãy tạo một list trống mới bên trong hàm

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 08

Lưu ý cách điều này đảm nói rằng giờ đây

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 72 thực sự mặc định là một list trống bất kể lúc nào >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 36 được gọi mà không còn đối số

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

Pass-By-Value vs Pass-By-Reference trong Pascal

Trong thiết kế ngôn từ lập trình, có hai quy mô 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àmChuyể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à những 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 từ lập trình tạo ra sự khác lạ đặc biệt rõ ràng giữa hai ngôn từ này.

Ghi chú. Đừng lo ngại nếu bạn lạ lẫm thuộc với Pascal. Các khái niệm này tương tự như những khái niệm của Python và những ví dụ được hiển thị kèm theo lời lý giải đủ rõ ràng để bạn đã có được ý tưởng chung. Khi bạn đã thấy cách truyền đối số hoạt động và sinh hoạt giải trí trong Pascal, tất cả chúng ta sẽ quay lại Python và bạn sẽ thấy nó so sánh ra làm sao

Đây là những gì bạn nên phải 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 PythonDấu hai chấm bằng. Toán tử này (>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 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ị tài 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

Với một chút í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 đúng chuẩn định một biến số nguyên >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 17Dòng 15. Ban đầu nó gán cho >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 17 giá trị >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 92Dòng 17. Sau đó, nó gọi thủ tục >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 36, chuyển >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 17 làm đối sốDòng 5. Bên trong >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 36, câu lệnh >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 88 đã cho tất cả chúng ta biết 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àoDòng 6. >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 97 sau đó được gán giá trị >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 000dòng 7. Giá trị này được xác minh bởi câu lệnh >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 88 này được thực thi ngay trước khi thoát >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 36Dòng 18. Trở lại môi trường tự nhiên thiên nhiên gọi của chương trình chính, câu lệnh >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 88 này đã cho tất cả chúng ta biết 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, in như trước khi gọi thủ tục

Chạy mã này tạo ra đầu ra sau

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 10

Trong 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 biến thành ảnh hưởng

Ghi chú. Nếu bạn muốn thấy điều này hoạt động và sinh hoạt giải trí, thì bạn hoàn toàn có thể tự chạy mã bằng trình biên dịch Pascal trực tuyến

Chỉ cần tuân theo tiến trình sau

Sao chép mã từ hộp mã ở trênTruy cập Trình biên dịch Pascal trực tuyếnTrong 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 1Nhấ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 11

Mã này giống với ví dụ đầu tiên, với một thay đổi. Đó là sự việc hiện hữu 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 tiếp tục sửa đổi đối số trong môi trường tự nhiên thiên nhiên gọi

Đầu ra từ mã này in như trước, ngoại trừ dòng ở đầu cuối

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 12

Mộ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 khá được sửa đổi

Trong nhiều ngôn từ lập trình, về cơ bản đó là sự việc khác lạ 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 và sinh hoạt giải trí, nhưng nó không thể sửa đổi giá trị ban đầu trong môi trường tự nhiên thiên nhiên gọiNế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 tự nhiên thiên nhiên 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 những ngôn từ này. Các giá trị biến được tàng trữ trong bộ nhớ. Trong Pascal và những ngôn từ tương tự, tham chiếu về cơ bản là địa chỉ của vị trí bộ nhớ đó, như minh họa phía 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 khí 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 khí 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 tự nhiên thiên nhiên gọi vẫn không biến thành ảnh hưởng

Trong 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 khí tên của chương trình chính nơi tàng 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í đó, in như khi chương trình chính đang sửa đổi chính >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 17

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

Pass-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à chính bới một tham chiếu không còn nghĩa hoàn toàn in như trong Python như trong Pascal

Nhớ lại rằng trong Python, mọi phần tài 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ớ rõ ràng. Điều đó 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 13

Chúng được lý giải theo cách này

Biến >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 17 tham chiếu đến một vị trí bộ nhớ cụ thểCâu lệnh đầu tiên đặt giá trị >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 92 vào vị trí đóCâu lệnh tiếp theo ghi đè lên >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 92 và thay vào đó đặt >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 000 ở đó

trái lại, trong Python, những câu lệnh gán tương tự như sau

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 14

Các câu lệnh gán này còn có ý nghĩa như sau

Câu lệnh đầu tiên làm cho >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 17 trỏ đến một đối tượng có mức giá trị là >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 92Câu lệnh tiếp theo gán lại >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 17 làm tham chiếu mới cho một đối tượng khác có mứ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 link lại >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 17 với một đối tượng khác có mức giá trị >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 000

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 15

Trong 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 mang tên là >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 17 gắn với một đối tượng có mứ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 khởi đầu lần đầu tiên, một tham chiếu mới mang 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 17

Tuy 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 link lại >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 97 với một đối tượng mới có mứ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, in như trước khi gọi hàm

Bạn hoàn toàn có thể xác nhận tất cả điều này bằng phương pháp 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 ít của ví dụ trên hiển thị số nhận dạng số của những đối tượng liên quan

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 16

Khi

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 36 khởi đầ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 tự nhiên thiên nhiên gọi bị mất

Truyền đối số trong Python có phần phối 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à vì những tên tham số được link với những đối tượng trên mục nhập hàm trong Python và phép gán cũng là quá trình link tên với một đối tượng. Bạn cũng hoàn toàn có thể thấy những 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 phương pháp 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, những đố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 nỗ lực 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 hoàn toàn có thể thấy, khi quay lại môi trường tự nhiên thiên nhiên 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 trách nhiệm >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 086, tham chiếu sẽ phục hồi và link với đối tượng ban đầu bị mất

Điều đó nghĩa là một hàm Python không bao giờ hoàn toàn có thể sửa đổi những đối số của nó? . Xem những gì xảy ra ở đây

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 18

Trong 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 sỉ 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 link với một đối tượng khác và link với >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 72 sẽ bị mất

Tuy nhiên,

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 36 hoàn toàn có thể sử dụng tham chiếu để thực hiện những 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 hoàn toà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 tự nhiên thiên nhiên 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 tự nhiên thiên nhiên gọi sau khi >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 36 trả về

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

Tóm tắt thông qua đối số

Truyền đối số trong Python hoàn toàn có thể được tóm tắt như sau. Truyền một đối tượng không bao giờ thay đổi, ví dụ 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 và sinh hoạt giải trí in như truyền theo giá trị. Chức năng không thể sửa đổi đối tượng trong môi trường tự nhiên thiên nhiên gọi

Truyền một đối tượng hoàn toàn có thể thay đổi, ví dụ như ,

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 078 hoặc >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 079 hoạt động và sinh hoạt giải trí phần nào — nhưng không đúng chuẩn — in như truyền theo tham chiếu. Hàm không thể chỉ định lại toàn bộ đối tượng nhưng hoàn toàn có thể thay đổi những 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 tự nhiên thiên nhiên gọi

Phản ứng phụ

Vì vậy, trong Python, bạn hoàn toà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 tự nhiên thiên nhiên 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 tự nhiên thiên nhiên 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 kĩ năng

Ghi chú. Có lẽ bạn đã quen thuộc với những tác dụng phụ trong nghành sức khỏe con người, trong đó thuật ngữ này thường đề cập đến hậu quả không mong ước của thuốc. Thông thường, hậu quả là không mong ước, ví dụ như nôn mửa hoặc an thần. Mặt khác, tác dụng phụ hoàn toàn có thể được sử dụng có chủ ý. Ví dụ, một số trong những loại thuốc gây kích thích thèm ăn, hoàn toàn có thể được sử dụng để tạo lợi thế, trong cả những lúc đó không phải là mục tiêu 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ả hiệu suất cao và người tiêu dùng hiệu suất cao nhận thức rõ ràng về thời điểm và phương pháp môi trường tự nhiên thiên nhiên gọi hoàn toàn có thể được sửa đổi, thì điều đó hoàn toàn có thể ổn. Nhưng một lập trình viên hoàn toàn có thể không phải lúc nào thì cũng ghi lại đúng chuẩn những tác dụng phụ hoặc thậm chí họ hoàn toàn có thể không biết rằng những tác dụng phụ đang xảy ra

Khi chúng bị ẩn hoặc không mong đợi, những tác dụng phụ hoàn toàn có thể dẫn đến những 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

Hàm Python để làm gì sau đó? . Làm thế nào một hiệu suất cao nên ảnh hưởng đến người gọi của nó?

Chà, một kĩ năng là sử dụng những 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 đíchNó ngay lập tức kết thúc hiệu suất cao và chuyển quyền trấn áp thực thi trở lại người gọiNó đáp ứng một cơ chế mà hiệu suất cao hoàn toàn có thể chuyển tài liệu trở lại người gọi

Thoát khỏi một hiệu suất cao

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 20

Trong 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 ở đầu cuối của thân hàm được thực thi. Vì vậy, hiệu suất cao này sẽ hoạt động và sinh hoạt giải trí giống hệt nhau mà không còn câu lệnh >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 109

Tuy nhiên, câu lệnh

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 109 tránh việc phải ở cuối hàm. Chúng hoàn toàn 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 21

Hai 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, chính bới 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 6

Loại quy mô này hoàn toàn có thể hữu ích để kiểm tra lỗi trong một hiệu suất cao. Bạn hoàn toàn có thể kiểm tra một số trong những điều kiện lỗi khi khởi đầu hiệu suất cao, với những câu lệnh

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 109 xử lý và xử lý nếu có sự cố

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 22

Nếu không gặp phải tình trạng lỗi nào, thì hiệu suất cao hoàn toàn có thể tiến hành xử lý thông thường

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

Trả lại tài liệu cho những người dân gọi

Ngoài việc thoát khỏi một hiệu suất cao, câu lệnh

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 109 còn được sử dụng để truyền tài 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 tự nhiên thiên nhiên 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 123

Một hàm hoàn toàn có thể trả về bất kỳ loại đối tượng nào. Trong Python, điều đó nghĩa là bất kể thứ gì. Trong môi trường tự nhiên thiên nhiên gọi, lệnh gọi hàm hoàn toàn có thể được sử dụng về mặt cú pháp theo bất kỳ cách nào phù phù 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 tự nhiên thiên nhiên 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 24

Trong ví dụ tiếp theo,

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 36 trả về một chuỗi mà bạn hoàn toà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 list hoàn toàn có thể được lập chỉ mục hoặc cắt lát

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 26

Nế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 27

Khi không còn mứ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 29

Nhớ lại điều đó là sai khi được đánh giá trong ngữ cảnh Boolean

Vì những 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 hoàn toà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, những 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 thi

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

Xem 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 tự nhiên thiên nhiên gọi phải gấp hai giá trị ban đầu. Trong Pascal, bạn hoàn toàn có thể thực hiện việc này bằng phương pháp sử dụng tham chiếu chuyển qua

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 41

Việ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 tự nhiên thiên nhiên gọi

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 42

Trong Python, điều này sẽ không hoạt động và sinh hoạt giải trí. Như bạn đã biết, số nguyên trong Python là không bao giờ thay đổi, 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 43

Tuy nhiên, bạn hoàn toà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 phụ trách về trách nhiệm 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 tự nhiên thiên nhiên 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, chính bới sửa đổi bằng tác dụng phụ không hoạt động và sinh hoạt giải trí trong trường hợp này

Tuy nhiên, trong cả trong trường hợp hoàn toàn 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 hoàn toàn có thể rõ ràng hơn. Giả sử bạn muốn nhân đôi mọi mục trong list. Vì list hoàn toàn có thể thay đổi, nên bạn hoàn toàn có thể xác định hàm Python để sửa đổi list tại chỗ

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 45

Không in 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 và sinh hoạt giải trí như dự kiến. Nếu tài liệu về hàm nêu rõ rằng nội dung của đối số list đã bị thay đổi, thì đây hoàn toàn có thể là một cách triển khai hợp lý

Tuy nhiên, bạn cũng hoàn toàn có thể viết

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 144 để chuyển lại list mong ước bằng giá trị trả về và được 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 46

Một trong hai cách tiếp cận hoạt động và sinh hoạt giải trí tốt như nhau. Như thường lệ, đây là vấn đề về phong cách và sở thích thành viên rất 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 hoàn toàn có thể được trả về từ một hàm, nên điều tương tự cũng hoàn toàn có thể được thực hiện thông qua những giá trị trả về.

Danh sách đối số có độ dài thay đổi

Trong một số trong những trường hợp, khi bạn định nghĩa một hàm, bạn hoàn toàn có thể không biết trước mình yêu thích 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 hoàn toàn có thể khởi đầu với một chiếc gì đó như vậy này

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 47

Tấ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 48

Tuy 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 49

Bạn hoàn toàn có thể thử xác định

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 147 với những tham số tùy chọn

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 30

Điều này được cho phép một số trong những lượng đối số rất 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 31

Nhưng cách tiếp cận này vẫn gặp phải một số trong những vấn đề. Đối với người mới khởi đầu, nó vẫn chỉ được cho phép tối đa năm đối số, không phải là một số trong những tùy ý. Tệ hơn thế nữa, không còn cách nào để phân biệt Một trong những đối số đã được chỉ định và những đối số được phép mặc định. Hàm không còn 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 32

Rõ ràng, điều này cũng tiếp tục không làm được

Bạn hoàn toàn có thể viết

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 147 để lấy một đối số list

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 33

Ít nhất điều này hoạt động và sinh hoạt giải trí. Nó được cho phép một số trong những lượng giá trị tùy ý và tạo ra một kết quả đúng chuẩn. Là một phần thưởng tương hỗ update, nó cũng hoạt động và sinh hoạt giải trí khi đối số là một bộ

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 34

Hạn chế là bước tương hỗ update phải nhóm những giá trị vào một list hoặc bộ tài liệu hoàn toàn có thể không phải là vấn đề mà người tiêu dùng hàm mong đợi và nó không được thanh lịch cho lắm. Bất cứ lúc nào bạn tìm thấy mã Python trông không phù hợp, hoàn toàn 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 đáp ứng một phương pháp để truyền vào một hàm một số trong những lượng đối số rất khác nhau với việc đóng gói và giải nén bộ đối số bằng phương pháp sử dụng toán tử dấu hoa thị (

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 150)

Loại bỏ những 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 hoàn toàn 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 35

Trong đị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, những đối số được đóng gói thành một bộ mà hàm hoàn toàn 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 thì cũng hoàn toàn 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ẩn

Sử dụng đóng gói tuple, bạn hoàn toàn có thể dọn sạch

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 147 như vậy này

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 36

Tốt hơn thế nữa, bạn hoàn toàn có thể quét dọn và sắp xếp nó hơn thế nữa bằng phương pháp 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 những giá trị số trong bất kỳ lần lặp nào.

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 37

Bây giờ,

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 147 được viết đúng chuẩn và hoạt động và sinh hoạt giải trí như dự tính

Tuy nhiên, tùy thuộc vào cách mã này sẽ được sử dụng, hoàn toàn 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 nhất hoàn toàn có thể, bạn nên thêm mã để kiểm tra xem những đố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 những 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 hoàn toàn có thể kiểm tra Ngoại lệ Python. Một lời ra mắt

Giải nén Tuple đối số

Một hoạt động và sinh hoạt giải trí 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 thêm thêm đối số đó là một bộ nên được giải nén và chuyển đến hàm dưới dạng những giá trị riêng biệt

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 39

Trong 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 phải 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 những 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 ứng

Mặ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 riêng gì có hoạt động và sinh hoạt giải trí với những bộ. Toán tử dấu hoa thị (

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 150) hoàn toàn 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 hoàn toàn có thể được giải nén

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 90

Bạn thậm chí hoàn toàn 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 list >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 175 nên được giải nén và những mục được chuyển đến >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 36 dưới dạng những giá trị riêng lẻ. Đặc tả tham số >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 153 làm cho những giá trị được đóng gói sao lưu vào bộ tài 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), hoàn toàn có thể được sử dụng với những 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 thêm thêm rằng những đối số tương ứng, dự kiến ​​là những 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 92

Trong trường hợp này, những đố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 hoàn toàn 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 thì cũng hoàn toàn 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ư thể là tiêu chuẩn. Bạn tránh việc 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 những quy ước mã hóa Python sẽ biết ngay ý của bạn

Giả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ộ tài 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 phải giải nén, với những 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 93

Cá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 94

Trê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ừ những 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 những 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à list đối số vị trí có độ dài thay đổi và >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 196 là list đối số từ khóa có độ dài thay đổi

Ghi 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—hoàn toàn 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ư thể bạn hoàn toàn có thể cần trong một giao diện hiệu suất cao

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 đã ra mắt tương hỗ cho những khái quát hóa giải nén tương hỗ update, như được nêu trong PEP 448. Một điều mà những tăng cấp cải tiến này được 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 97

Bạn cũng hoàn toàn 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 98

Ghi 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 201

Nhân tiện, những 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 riêng gì có áp dụng cho những biến, như trong ví dụ trên. Bạn cũng hoàn toàn có thể sử dụng chúng với những chữ hoàn toàn có thể lặp lại

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 99

Ở đây, những list 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ộ tài liệu và những 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 hiệu suất cao Python trong phiên bản 3. x hoàn toàn có thể được xác định sao cho nó nhận những đối số chỉ từ khóa. Đây là những đối số hiệu suất cao phải được chỉ định bởi từ khóa. Hãy mày mò một tình huống mà điều này hoàn toàn 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ố trong những 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ư vậy này sẽ làm để khởi đầu

>>>

>>> s = 'foobar' >>> id(s) 56313440 20

Như 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 để đồng ý điều này làm đối số, để người tiêu dùng hoàn toàn có thể chỉ định điều gì khác?

>>>

>>> s = 'foobar' >>> id(s) 56313440 21

Điều này hoạt động và sinh hoạt giải trí như quảng cáo, nhưng có một vài điều không mong ước về giải pháp này

Chuỗi

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 210 được gộp chung với những 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 sót 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òn cách nào để giả định một giá trị mặc định

Bạn hoàn toàn có thể nghĩ rằng bạn hoàn toàn có thể khắc phục vấn đề thứ hai bằng phương pháp chỉ định một tham số có mức giá trị mặc định, có lẽ rằng như vậy này

>>>

>>> s = 'foobar' >>> id(s) 56313440 22

Thật rủi ro, điều này sẽ không hoạt động và sinh hoạt giải trí 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ự tính. Điều này nghĩa là không còn 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 24

Như bạn đã thấy trước đây, khi cả hai loại đối số được đưa ra, tất cả những đố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 25

Mộ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ần

Các thông số chỉ dành riêng cho từ khóa giúp xử lý và xử lý 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 26

Trong 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ỉ hoàn toàn có thể được chỉ định bởi một đối số từ khóa được đặt tên

>>>

>>> s = 'foobar' >>> id(s) 56313440 27

Lưu ý rằng điều này chỉ hoàn toàn có thể thực hiện được trong Python 3. Trong phiên bản 2. x của Python, chỉ định những tham số tương hỗ update 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 được cho phép hàm Python nhận một số trong những lượng đối số rất khác nhau, theo sau là một hoặc nhiều tùy chọn tương hỗ update 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 hoàn toàn có thể được chỉ định tùy chọn, thì bạn hoàn toàn có thể thêm một đối số chỉ từ khóa tương hỗ update

>>>

>>> s = 'foobar' >>> id(s) 56313440 28

Nếu tham số chỉ từ khóa được đáp ứng 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 đáp ứng

>>>

>>> s = 'foobar' >>> id(s) 56313440 29

Mặt khác, nếu tham số không được đáp ứng giá trị mặc định, thì tham số đó sẽ trở thành bắt buộc và việc không riêng gì có đị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 sở hữu và nhận một số trong những lượng đối số vị trí rất khác nhau?

>>>

>>> s = 'foobar' >>> id(s) 56313440 41

Nế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 hoàn toàn có thể thêm tham số đối số biến giả không liên quan và chỉ việc bỏ qua tham số đó

>>>

>>> s = 'foobar' >>> id(s) 56313440 42

Vấ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 hoàn toàn có thể được đưa vào

>>>

>>> s = 'foobar' >>> id(s) 56313440 43

Trong ví dụ này, tránh việc có đối số tương hỗ update (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ó hoàn toàn có thể gây ra một kết quả có vẻ như sai lệch

>>>

>>> s = 'foobar' >>> id(s) 56313440 44

Để khắc phục điều này, phiên bản 3 được 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 45

Tham số đối số biến trần

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 150 chỉ ra rằng không còn bất kỳ tham số vị trí nào nữa. Hành vi này tạo ra những thông báo lỗi thích hợp nếu những thông báo lỗi tương hỗ update được chỉ định. Nó được cho phép những tham số chỉ từ khóa theo dõi

Đối số chỉ vị trí

Kể từ Python 3. 8, những tham số hiệu suất cao cũng hoàn toàn có thể được khai báo chỉ theo vị trí, nghĩa là những đối số tương ứng phải được đáp ứng theo vị trí và không thể được chỉ định bằng từ khóa

Để chỉ định một số trong những 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 list 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à những tham số chỉ vị trí, nhưng >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 19 hoàn toàn có thể được chỉ định bằng từ khóa

>>>

>>> s = 'foobar' >>> id(s) 56313440 46

Điều này nghĩa là những cuộc gọi sau là hợp lệ

>>>

>>> s = 'foobar' >>> id(s) 56313440 47

Tuy 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 48

Cả hai chỉ định vị trí và chỉ từ khóa đều hoàn toàn có thể được sử dụng trong cùng một định nghĩa hàm

>>>

>>> s = 'foobar' >>> id(s) 56313440 49

trong ví dụ này

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 17 và >>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 18 chỉ dành riêng 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 hoàn toàn có thể được chỉ định theo vị trí hoặc theo từ khóa

Để biết thêm thông tin về những 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 để đáp ứng tài liệu cho một hiệu suất cao. Nó hoàn toàn có thể chứa mục tiêu 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 00

Về mặt kỹ thuật, những chuỗi tài liệu hoàn toàn có thể sử dụng bất kỳ cơ chế trích dẫn nào của Python, nhưng quy ước được khuyến nghị là trích dẫn ba lần bằng phương pháp sử dụng những 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 thế nữa. Một chuỗi tài liệu nhiều dòng phải gồm có 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ả rõ ràng 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 rõ ràng 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 mang tên là

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 238. Thuộc tính này là một trong một tập hợp những đị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 đáp ứng hiệu suất cao ngôn từ đặc biệt

Ghi chú. Các thuộc tính này cũng khá được gọi là những thuộc tính dunder biệt danh đầy sắc tố và những phương thức dunder. Từ dunder phối 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 những hướng dẫn trong tương lai của loạt bài này

Bạn hoàn toà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 những ví dụ trên hoàn toàn có thể được hiển thị như sau

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 02

Trong trình thông dịch Python tương tác, bạn hoàn toà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 03

Việc chỉ định một chuỗi tài liệu cho từng hàm Python mà bạn xác định được xem 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 đáp ứng một tính năng tương hỗ update để ghi lại một hàm được gọi là chú thích hàm. Chú thích đáp ứng một phương pháp để đính kèm siêu tài liệu vào những 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 những 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 list 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 04

Chú 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 249

Trình thông dịch Python tạo một từ điển từ những 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 mang 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 hoàn toàn có thể được hiển thị như sau

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 05

Các phím cho những tham số là tên gọi 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 06

Lưu ý rằng những chú thích không biến thành hạn chế đối với những giá trị chuỗi. Chúng hoàn toàn có thể là bất kỳ biểu thức hoặc đối tượng nào. Ví dụ: bạn hoàn toàn có thể chú thích bằng những đối tượng kiểu

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 07

Chú thích thậm chí hoàn toàn có thể là một đối tượng tổng hợp như từ điển hoặc từ điển, vì vậy hoàn toàn có thể đính kèm nhiều mục siêu tài liệu vào tham số và trả về giá trị

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 08

Trong 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ểu

Nế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 09

Chú thích làm gì? . Họ chỉ là loại ở đó. Hãy xem lại một trong những ví dụ ở trên, tuy nhiên với một vài sửa đổi nhỏ

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 10

Nhữ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ả những 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 được 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à những bit siêu tài liệu được đính kèm với những tham số hàm Python và giá trị trả về. Python thận trọng 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òn 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 khởi đầu, chú thích tạo tài liệu tốt. Tất nhiên, bạn hoàn toà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ư vậy này

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 11

Cấp, trình thông dịch không bắt buộc tuân thủ nhiều chủng 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 hoàn toàn có thể thêm mã để thực thi nhiều chủng 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ị

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 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

(Mô-đun

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 264 chứa những hàm lấy thông tin hữu ích về những đố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. )

Nếu muốn, một hàm được định nghĩa như hàm ở trên hoàn toàn có thể thực hiện một số trong những loại hành vi khắc phục khi nó phát hiện ra rằng những đối số được truyền vào không tuân theo nhiều chủng 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 riêng cho Python mang tên là mypy, được xây dựng trên đặc tả PEP 484

Cũng có một quyền lợi 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 tàng trữ trong thuộc tính

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 250 phù phù phù hợp với việc phân tích chữ ký hàm bằng những công cụ tự động

Khi nói đến nó, những chú thích không còn gì đặc biệt kỳ diệu. Bạn thậm chí hoàn toàn có thể định nghĩa của riêng mình mà không cần cú pháp đặc biệt mà Python đáp ứng. Đây là một định nghĩa hàm Python với những chú thích đối tượng kiểu được đính kèm với những tham số và giá trị trả về

>>>

>>> a = ['foo', 'bar', 'baz', 'qux'] >>> len(a) 4 13

Sau đây về cơ bản là hiệu suất cao 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 14

Hiệu ứng giống hệt nhau trong cả hai trường hợp, nhưng hiệu ứng đầu tiên mê hoặc 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 lạ đáng kể so với hầu hết những thuộc tính khác của hàm. Ví dụ, nó hoàn toàn có thể được sửa đổi động. Bạn hoàn toà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 15

Chú thích hàm Python không gì khác hơn là từ điển siêu tài liệu. Điều xảy ra là bạn hoàn toàn có thể tạo chúng bằng cú pháp thuận tiện được trình thông dịch tương hỗ. Họ là bất kể điều gì bạn chọn để làm cho họ

Phần kết luận

Khi những ứng dụng phát triển to hơn, việc mô đun hóa mã bằng phương pháp chia mã thành những hiệu suất cao nhỏ hơn với kích thước hoàn toàn có thể quản lý ngày càng trở nên quan trọng. Bây giờ bạn kỳ vọng có tất cả những 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 tiêu dùng định nghĩa trong PythonMột số cách rất khác nhau để bạn hoàn toàn có thể truyền đối số cho một hàmCách bạn hoàn toàn có thể trả lại tài liệu từ một hiệu suất cao cho những người dân gọi nóCách thêm tài liệu vào những hiệu suất cao 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 mang tên là re, mô-đun này chứa hiệu suất cao 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 xong

Xem ngay Hướng dẫn này còn 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à mê hoặc đượ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 thần. Đượ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

» tin tức thêm về John

Mỗi hướng dẫn tại Real Python được tạo bởi một nhóm những nhà phát triển để nó đáp ứng những tiêu chuẩn rất chất lượng của chúng tôi. Các thành viên trong nhóm đã thao tá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 số lượ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à hiệp hội những Pythonistas Chuyên Viên

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 số lượ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 trăm hướng dẫn, khóa học video thực hành và hiệp hội Pythonistas Chuyên Viên

Nâng cao kỹ năng Python của bạn »

Bạn nghĩ sao?

Đánh giá nội dung bài viết này

Tweet Chia sẻ Chia sẻ E-Mail

Bài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?

Mẹo phản hồi. 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 tiêu học hỏi hoặc giúp sức những sinh viên khác. và nhận câu vấn đáp cho những thắc mắc phổ biến trong cổng thông tin tương hỗ của chúng tôi

Các hiệu suất cao của Python là gì?

Có ba loại hàm trong Python. . Các hàm tích hợp, ví dụ như help() để yêu cầu trợ giúp, min() để lấy giá trị nhỏ nhất, print() để in một đối tượng ra terminal,…. Hàm do người tiêu dùng xác định (UDF), là những hàm mà người tiêu dùng tạo để trợ giúp họ;

3 hiệu suất cao trong Python là gì?

Có ba hiệu suất cao trong python mang lại tính thực tế và hữu dụng khi lập trình. Ba hiệu suất cao này, đáp ứng một phong cách lập trình hiệu suất cao trong ngôn từ python hướng đối tượng, là map(), filter() và reduce() .

Điều nào sau đây không đúng về những hàm Python?

" Nó hoàn toàn có thể tàng trữ và hoạt động và sinh hoạt giải trí trên nhiều dòng chương trình " là không đúng về một hiệu suất cao.

Điều gì mô tả tốt nhất một hiệu suất cao trong Python?

Hàm là một khối mã mà chương trình hoàn toàn có thể gọi để thực thi một bộ hướng dẫn được xác định trước . Hàm là bất kỳ phép toán nào trong tập lệnh Python. Hàm là một loại vòng lặp chạy cho tới lúc đáp ứng những giá trị trong tham số của nó. Tải thêm tài liệu liên quan đến nội dung bài viết Điều gì là đúng về hiệu suất cao python? programming python

Clip Điều gì là đúng về hiệu suất cao python? ?

Bạn vừa Read nội dung bài viết Với Một số hướng dẫn một cách rõ ràng hơn về Clip Điều gì là đúng về hiệu suất cao python? tiên tiến nhất

Share Link Download Điều gì là đúng về hiệu suất cao python? miễn phí

Pro đang tìm một số trong những Share Link Down Điều gì là đúng về hiệu suất cao python? Free.

Giải đáp thắc mắc về Điều gì là đúng về hiệu suất cao python?

Nếu sau khi đọc nội dung bài viết Điều gì là đúng về hiệu suất cao python? vẫn chưa hiểu thì hoàn toàn có thể lại phản hồi ở cuối bài để Admin lý giải và hướng dẫn lại nha #Điều #gì #là #đúng #về #chức #năng #python