Nếu bạn muốn tránh
def function_name[arg1, arg2,..., argN]:
# Function's code goes here...
pass
Lập trình hướng đối tượng có thể là một thách thức để tham gia nếu bạn chưa quen với Python, nhưng đây thực sự có thể là thời điểm tốt để bắt đầu chơi với nó.
class Thing:
shared = "foo"
def __init__[self]:
"""
This gets called when you create a new Thing[]
"""
self.bar = "baz" # default value for new instances
def get_bar[self]:
return self.bar
def set_bar[self, value]:
self.bar = value
Bây giờ, hãy tạo hai trường hợp.
first = Thing[]
second = Thing[]
Các phương pháp
def function_name[arg1, arg2,..., argN]:
# Function's code goes here...
pass
def function_name[arg1, arg2,..., argN]:
# Function's code goes here...
pass
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
.
Nếu bạn thay đổi thuộc tính lớp thông qua một trường hợp, nó cũng sẽ không được thay đổi trong các trường hợp khác.
second.shared = "poo"
print[first.shared]
# "foo"
Nhưng nếu bạn thay đổi nó trong bản thân lớp, nó sẽ được thay đổi trong tất cả các trường hợp không ghi đè riêng biệt giá trị được chia sẻ.
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Để tóm tắt lại, bạn tạo một thể hiện
def function_name[arg1, arg2,..., argN]:
# Function's code goes here...
pass
def function_name[arg1, arg2,..., argN]:
# Function's code goes here...
pass
def function_name[arg1, arg2,..., argN]:
# Function's code goes here...
pass
def function_name[arg1, arg2,..., argN]:
# Function's code goes here...
pass
function_name[arg1, arg2, ..., argN]
Có rất nhiều lớp học; Điểm bán hàng chính có lẽ là bạn có thể tạo các lớp con kế thừa từ lớp cha mẹ của chúng nhưng có thể ghi đè một số hành vi [ví dụ phổ biến thường liên quan đến các khái niệm trong thế giới thực như động vật hoặc phương tiện, nhưng một lớp học có thể là bất cứ điều gì bạn muốn tạo ra một loại và gói gọn hành vi của nó, và có lẽ ghi đè một số phương thức trong các loại dẫn xuất].
Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: Sử dụng câu lệnh Python Return một cách hiệu quả This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Using the Python return Statement Effectively
Câu lệnh Python
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
Sử dụng câu lệnh
function_name[arg1, arg2, ..., argN]
Trong hướng dẫn này, bạn sẽ học:
- Cách sử dụng câu lệnh Python
1 trong các chức năng của bạnPythonfunction_name[arg1, arg2, ..., argN]
1 statement in your functionsfunction_name[arg1, arg2, ..., argN] - Cách trả về đơn hoặc nhiều giá trị từ các chức năng của bạnsingle or multiple values from your functions
- Những thực hành tốt nhất cần quan sát khi sử dụng các câu
1best practices to observe when usingfunction_name[arg1, arg2, ..., argN]
1 statementsfunction_name[arg1, arg2, ..., argN]
Với kiến thức này, bạn sẽ có thể viết các chức năng dễ đọc hơn, có thể duy trì và súc tích hơn trong Python. Nếu bạn hoàn toàn mới đối với các chức năng Python, thì bạn có thể kiểm tra xác định chức năng Python của riêng bạn trước khi đi sâu vào hướng dẫn này.
Bắt đầu với các chức năng Python
Hầu hết các ngôn ngữ lập trình cho phép bạn gán tên cho một khối mã thực hiện tính toán cụ thể. Các khối mã được đặt tên này có thể được sử dụng lại nhanh chóng vì bạn có thể sử dụng tên của chúng để gọi chúng từ các địa điểm khác nhau trong mã của bạn.
Các lập trình viên gọi các chương trình con, quy trình, quy trình hoặc chức năng được đặt tên này có tên này tùy thuộc vào ngôn ngữ họ sử dụng. Trong một số ngôn ngữ, có một sự khác biệt rõ ràng giữa một thói quen hoặc quy trình và một hàm.subroutines, routines, procedures, or functions depending on the language they use. In some languages, there’s a clear difference between a routine or procedure and a function.
Đôi khi sự khác biệt đó mạnh đến mức bạn cần sử dụng một từ khóa cụ thể để xác định quy trình hoặc chương trình con và từ khóa khác để xác định hàm. Ví dụ, ngôn ngữ lập trình cơ bản trực quan sử dụng
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
Nói chung, một thủ tục là một khối mã được đặt tên thực hiện một tập hợp các hành động mà không tính toán giá trị hoặc kết quả cuối cùng. Mặt khác, một hàm là một khối mã được đặt tên thực hiện một số hành động với mục đích tính toán một giá trị hoặc kết quả cuối cùng, sau đó được gửi lại cho mã người gọi. Cả quy trình và chức năng có thể hành động dựa trên một tập hợp các giá trị đầu vào, thường được gọi là đối số.procedure is a named code block that performs a set of actions without computing a final value or result. On the other hand, a function is a named code block that performs some actions with the purpose of computing a final value or result, which is then sent back to the caller code. Both procedures and functions can act upon a set of input values, commonly known as arguments.
Trong Python, các loại khối mã được đặt tên này được gọi là chức năng vì chúng luôn gửi lại giá trị cho người gọi. Tài liệu Python xác định một chức năng như sau:
Một loạt các câu lệnh trả về một số giá trị cho người gọi. Nó cũng có thể được thông qua không hoặc nhiều đối số có thể được sử dụng trong việc thực hiện cơ thể. [Nguồn]
Mặc dù tài liệu chính thức nói rằng một hàm, trả về một số giá trị cho người gọi, nhưng bạn sẽ sớm thấy rằng các chức năng có thể trả về bất kỳ đối tượng Python nào cho mã người gọi.
Nói chung, một hàm có các đối số [nếu có], thực hiện một số hoạt động và trả về một giá trị [hoặc đối tượng]. Giá trị mà một hàm trả về người gọi thường được gọi là giá trị trả về hàm. Tất cả các hàm Python có giá trị trả về, rõ ràng hoặc ẩn. Bạn sẽ bao gồm sự khác biệt giữa các giá trị trả về rõ ràng và ẩn sau này trong hướng dẫn này.takes arguments [if any], performs some operations, and returns a value [or object]. The value that a function returns to the caller is generally known as the function’s return value. All Python functions have a return value, either explicit or implicit. You’ll cover the difference between explicit and implicit return values later in this tutorial.
Để viết hàm Python, bạn cần một tiêu đề bắt đầu bằng từ khóa
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
Thành phần thứ hai của một hàm là khối mã hoặc cơ thể của nó. Python xác định các khối mã bằng cách sử dụng thụt lề thay vì dấu ngoặc,
function_name[arg1, arg2, ..., argN]
>>> def return_42[]:
... return 42 # An explicit return statement
...
>>> return_42[] # The caller code gets 42
42
function_name[arg1, arg2, ..., argN]
>>> def return_42[]:
... return 42 # An explicit return statement
...
>>> return_42[] # The caller code gets 42
42
def function_name[arg1, arg2,..., argN]:
# Function's code goes here...
pass
Khi bạn mã hóa chức năng Python, bạn cần xác định tiêu đề với từ khóa
function_name[arg1, arg2, ..., argN]
Trong ví dụ trên, bạn sử dụng câu lệnh
>>> def return_42[]:
... return 42 # An explicit return statement
...
>>> return_42[] # The caller code gets 42
42
>>> def return_42[]:
... return 42 # An explicit return statement
...
>>> return_42[] # The caller code gets 42
42
Để sử dụng một chức năng, bạn cần gọi nó. Một cuộc gọi chức năng bao gồm tên hàm tên theo sau là các đối số chức năng trong ngoặc đơn:
function_name[arg1, arg2, ..., argN]
Bạn chỉ cần chuyển các đối số cho một cuộc gọi chức năng chỉ khi hàm yêu cầu chúng. Mặt khác, dấu ngoặc đơn luôn được yêu cầu trong một cuộc gọi chức năng. Nếu bạn quên chúng, thì bạn đã thắng được gọi chức năng nhưng tham khảo nó như một đối tượng chức năng.
Để làm cho các chức năng của bạn trả về một giá trị, bạn cần sử dụng câu lệnh Python
function_name[arg1, arg2, ..., argN]
Hiểu tuyên bố Python function_name[arg1, arg2, ..., argN]
1
function_name[arg1, arg2, ..., argN]
Câu lệnh Python
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
Giá trị trả về của hàm Python có thể là bất kỳ đối tượng Python nào. Tất cả mọi thứ trong Python là một đối tượng. Vì vậy, các chức năng của bạn có thể trả về các giá trị số [
>>> def return_42[]:
... return 42 # An explicit return statement
...
>>> return_42[] # The caller code gets 42
42
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Bạn có thể bỏ qua giá trị trả về của một hàm và sử dụng giá trị trả lại trần mà không có giá trị trả về. Bạn cũng có thể bỏ qua toàn bộ câu lệnh
function_name[arg1, arg2, ..., argN]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Trong hai phần tiếp theo, bạn sẽ đề cập đến những điều cơ bản về cách thức câu lệnh
function_name[arg1, arg2, ..., argN]
Báo cáo rõ ràng function_name[arg1, arg2, ..., argN]
1
function_name[arg1, arg2, ..., argN]
Một câu lệnh
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
>>>
>>> def return_42[]:
... return 42 # An explicit return statement
...
>>> return_42[] # The caller code gets 42
42
Khi bạn xác định
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
function_name[arg1, arg2, ..., argN]
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
Nếu bạn xác định một hàm với câu lệnh
function_name[arg1, arg2, ..., argN]
>>>
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
>>> def return_42[]:
... return 42 # An explicit return statement
...
>>> return_42[] # The caller code gets 42
42
Khi bạn xác định
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
function_name[arg1, arg2, ..., argN]
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>>
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>> def return_42[]:
... return 42 # An explicit return statement
...
>>> return_42[] # The caller code gets 42
42
Khi bạn xác định
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
function_name[arg1, arg2, ..., argN]
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
Nếu bạn xác định một hàm với câu lệnh
function_name[arg1, arg2, ..., argN]
>>>
first = Thing[]
second = Thing[]
>>> def return_42[]:
... return 42 # An explicit return statement
...
>>> return_42[] # The caller code gets 42
42
Khi bạn xác định
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
function_name[arg1, arg2, ..., argN]
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
>>>
first = Thing[]
second = Thing[]
Danh sách hiểu được đánh giá và sau đó chức năng trả về với danh sách kết quả. Lưu ý rằng bạn chỉ có thể sử dụng các biểu thức trong câu lệnh
function_name[arg1, arg2, ..., argN]
Ví dụ nữa, giả sử bạn cần tính giá trị trung bình của một mẫu của các giá trị số. Để làm điều đó, bạn cần chia tổng các giá trị cho số lượng giá trị. Ở đây, một ví dụ sử dụng các hàm tích hợp
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
>>>
first = Thing[]
second = Thing[]
Trong
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
Tuyên bố function_name[arg1, arg2, ..., argN]
1
function_name[arg1, arg2, ..., argN]
Hàm Python sẽ luôn có giá trị trả về. Không có khái niệm về thủ tục hoặc thói quen trong Python. Vì vậy, nếu bạn không sử dụng rõ ràng giá trị trả về trong câu lệnh
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Giả sử bạn viết một chức năng thêm
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
function_name[arg1, arg2, ..., argN]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
>>>
first = Thing[]
second = Thing[]
Nếu bạn không cung cấp một câu lệnh
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
Một ví dụ về một hàm trả về
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
first = Thing[]
second = Thing[]
function_name[arg1, arg2, ..., argN]
>>>
first = Thing[]
second = Thing[]
Cuộc gọi đến
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Bất kể các chức năng của bạn là bao lâu và phức tạp, bất kỳ chức năng nào không có câu lệnh
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Trả lại vs in
Nếu bạn làm việc trong một phiên tương tác, thì bạn có thể nghĩ rằng in một giá trị và trả về một giá trị là các hoạt động tương đương. Xem xét hai chức năng sau và đầu ra của chúng:
>>>
first = Thing[]
second = Thing[]
Cả hai chức năng dường như làm điều tương tự. Trong cả hai trường hợp, bạn thấy
first = Thing[]
second = Thing[]
>>> def return_42[]:
... return 42 # An explicit return statement
...
>>> return_42[] # The caller code gets 42
42
>>>
first = Thing[]
second = Thing[]
Bây giờ không có sự khác biệt có thể nhìn thấy. Trong cả hai trường hợp, bạn có thể thấy
>>> return 42
File "", line 1
SyntaxError: 'return' outside function
Bây giờ, giả sử bạn đang tiến sâu hơn vào Python và bạn bắt đầu viết kịch bản đầu tiên của mình. Bạn mở một trình soạn thảo văn bản và nhập mã sau:
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
Hãy thử nó một mình. Lưu tập lệnh của bạn vào một tệp có tên
first = Thing[]
second = Thing[]
Nếu bạn chạy
first = Thing[]
second = Thing[]
Nếu bạn muốn tập lệnh của bạn hiển thị kết quả của việc gọi
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
Bây giờ, khi bạn chạy
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
Vì vậy, nếu bạn làm việc trong một phiên tương tác, thì Python sẽ hiển thị kết quả của bất kỳ cuộc gọi chức năng nào trực tiếp đến màn hình của bạn. Nhưng nếu bạn đang viết một tập lệnh và bạn muốn xem một hàm giá trị trả về hàm, thì bạn cần sử dụng rõ ràng
first = Thing[]
second = Thing[]
Trả về nhiều giá trị
Bạn có thể sử dụng câu lệnh
function_name[arg1, arg2, ..., argN]
Ví dụ: giả sử bạn cần viết một hàm lấy một mẫu dữ liệu số và trả về một bản tóm tắt các biện pháp thống kê. Để mã hóa chức năng đó, bạn có thể sử dụng mô -đun tiêu chuẩn Python
first = Thing[]
second = Thing[]
Ở đây, một triển khai có thể thực hiện chức năng của bạn:
first = Thing[]
second = Thing[]
Trong
first = Thing[]
second = Thing[]
function_name[arg1, arg2, ..., argN]
Khi bạn đã mã hóa
first = Thing[]
second = Thing[]
>>>
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Ở đây, bạn giải nén ba giá trị trả về của
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Hàm tích hợp
first = Thing[]
second = Thing[]
>>>
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Ở đây, bạn giải nén ba giá trị trả về của
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Hàm tích hợp first = Thing[]
second = Thing[]
75 cũng là một ví dụ về hàm trả về nhiều giá trị. Hàm lấy hai số [không phức tạp] làm đối số và trả về hai số, thương số của hai giá trị đầu vào và phần còn lại của bộ phận:
first = Thing[]
second = Thing[]
Cuộc gọi đến
first = Thing[]
second = Thing[]
Sử dụng tuyên bố Python
function_name[arg1, arg2, ..., argN]
Cho đến nay, bạn đã đề cập đến những điều cơ bản về cách thức tuyên bố của Python function_name[arg1, arg2, ..., argN]
1. Bây giờ bạn biết cách viết các chức năng trả về một hoặc nhiều giá trị cho người gọi. Ngoài ra, bạn đã học được rằng nếu bạn không thêm một câu lệnh function_name[arg1, arg2, ..., argN]
1 rõ ràng với giá trị trả về rõ ràng cho một hàm nhất định, thì Python sẽ thêm nó cho bạn. Giá trị đó sẽ là >>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
8.
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Trong phần này, bạn sẽ bao gồm một số ví dụ sẽ hướng dẫn bạn thông qua một tập hợp các thực tiễn lập trình tốt để sử dụng hiệu quả câu lệnh
function_name[arg1, arg2, ..., argN]
Trả lại
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Một số lập trình viên dựa vào tuyên bố
1 ngầm mà Python thêm vào bất kỳ chức năng nào mà không có một chức năng rõ ràng. Điều này có thể gây nhầm lẫn cho các nhà phát triển đến từ các ngôn ngữ lập trình khác trong đó một hàm không có giá trị trả về được gọi là thủ tục.function_name[arg1, arg2, ..., argN]Có những tình huống trong đó bạn có thể thêm một
84 rõ ràng vào các chức năng của bạn. Tuy nhiên, trong các tình huống khác, bạn có thể dựa vào hành vi mặc định của Python:first = Thing[] second = Thing[]
Nếu chức năng của bạn thực hiện các hành động nhưng không có giá trị
function_name[arg1, arg2, ..., argN]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Nếu chức năng của bạn có nhiều câu lệnh
function_name[arg1, arg2, ..., argN]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
first = Thing[]
second = Thing[]
- Những thực hành này có thể cải thiện khả năng đọc và khả năng duy trì của mã của bạn bằng cách truyền đạt rõ ràng ý định của bạn.
- Khi nói đến việc trả lại
8, bạn có thể sử dụng một trong ba phương pháp có thể:>>> num = return_42[] >>> num 42 >>> return_42[] * 2 84 >>> return_42[] + 5 47 - Bỏ qua câu lệnh
1 và dựa vào hành vi mặc định là trả vềfunction_name[arg1, arg2, ..., argN]
8.>>> num = return_42[] >>> num 42 >>> return_42[] * 2 84 >>> return_42[] + 5 47
Sử dụng giá trị trả lại mà không có giá trị trả về, cũng trả về
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
>>>
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Ở đây, bạn giải nén ba giá trị trả về của
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Hàm tích hợp first = Thing[]
second = Thing[]
75 cũng là một ví dụ về hàm trả về nhiều giá trị. Hàm lấy hai số [không phức tạp] làm đối số và trả về hai số, thương số của hai giá trị đầu vào và phần còn lại của bộ phận:
first = Thing[]
second = Thing[]
Cuộc gọi đến
first = Thing[]
second = Thing[]
Sử dụng tuyên bố Python
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Nếu bạn đã quen với việc bắt đầu các chức năng của mình như thế này, thì rất có thể bạn sẽ không bỏ lỡ câu lệnh
function_name[arg1, arg2, ..., argN]
Thực tiễn này có thể tăng năng suất của bạn và làm cho các chức năng của bạn ít dễ bị lỗi hơn. Nó cũng có thể giúp bạn tiết kiệm rất nhiều thời gian gỡ lỗi.
Tránh các biểu thức phức tạp
Như bạn đã thấy trước đây, nó là một thực tế phổ biến để sử dụng kết quả của một biểu thức làm giá trị trả về trong các hàm Python. Nếu biểu thức mà bạn sử dụng trở nên quá phức tạp, thì thực tế này có thể dẫn đến các chức năng khó hiểu, gỡ lỗi và duy trì.
Ví dụ: nếu bạn đang thực hiện một tính toán phức tạp, thì sẽ dễ đọc hơn để tính toán kết quả cuối cùng bằng cách sử dụng các biến tạm thời với các tên có ý nghĩa.temporary variables with meaningful names.
Xem xét chức năng sau đây tính toán phương sai của mẫu dữ liệu số:
>>>
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Biểu thức mà bạn sử dụng ở đây khá phức tạp và khó hiểu. Nó cũng khó gỡ lỗi vì bạn đã thực hiện nhiều hoạt động trong một biểu thức duy nhất. Để giải quyết vấn đề cụ thể này, bạn có thể tận dụng phương pháp phát triển gia tăng giúp cải thiện khả năng đọc của chức năng.
Hãy xem thực hiện thay thế sau đây của
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
>>>
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Biểu thức mà bạn sử dụng ở đây khá phức tạp và khó hiểu. Nó cũng khó gỡ lỗi vì bạn đã thực hiện nhiều hoạt động trong một biểu thức duy nhất. Để giải quyết vấn đề cụ thể này, bạn có thể tận dụng phương pháp phát triển gia tăng giúp cải thiện khả năng đọc của chức năng.
Hãy xem thực hiện thay thế sau đây của
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Trong lần thực hiện thứ hai này của
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Các biến tạm thời như second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
04, first = Thing[]
second = Thing[]
70 và second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
06 thường hữu ích khi gỡ lỗi mã của bạn. Ví dụ, nếu có điều gì đó không ổn với một trong số họ, thì bạn có thể gọi first = Thing[]
second = Thing[]
39 để biết những gì xảy ra trước khi câu lệnh function_name[arg1, arg2, ..., argN]
1 chạy.
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
first = Thing[]
second = Thing[]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
first = Thing[]
second = Thing[]
function_name[arg1, arg2, ..., argN]
Nói chung, bạn nên tránh sử dụng các biểu thức phức tạp trong câu lệnh
function_name[arg1, arg2, ..., argN]
Trả về giá trị so với Globals sửa đổi
Các chức năng mà don lồng có một câu lệnh
function_name[arg1, arg2, ..., argN]
Sửa đổi các biến toàn cầu thường được coi là một thực hành lập trình xấu. Cũng giống như các chương trình có biểu thức phức tạp, các chương trình sửa đổi các biến toàn cầu có thể khó gỡ lỗi, hiểu và duy trì.self-contained functions that take some arguments and return a useful value [or values] without causing any side effect on global variables.
Khi bạn sửa đổi một biến toàn cầu, bạn có khả năng ảnh hưởng đến tất cả các chức năng, lớp, đối tượng và bất kỳ phần nào khác trong các chương trình của bạn dựa vào biến toàn cầu đó.
Để hiểu một chương trình sửa đổi các biến toàn cầu, bạn cần nhận thức được tất cả các phần của chương trình có thể thấy, truy cập và thay đổi các biến đó. Vì vậy, thực tiễn tốt khuyến nghị viết các chức năng độc lập có một số đối số và trả về một giá trị [hoặc giá trị] hữu ích mà không gây ra bất kỳ tác dụng phụ nào đối với các biến toàn cầu.
>>>
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Biểu thức mà bạn sử dụng ở đây khá phức tạp và khó hiểu. Nó cũng khó gỡ lỗi vì bạn đã thực hiện nhiều hoạt động trong một biểu thức duy nhất. Để giải quyết vấn đề cụ thể này, bạn có thể tận dụng phương pháp phát triển gia tăng giúp cải thiện khả năng đọc của chức năng.
Hãy xem thực hiện thay thế sau đây của
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Trong lần thực hiện thứ hai này của
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
>>>
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Biểu thức mà bạn sử dụng ở đây khá phức tạp và khó hiểu. Nó cũng khó gỡ lỗi vì bạn đã thực hiện nhiều hoạt động trong một biểu thức duy nhất. Để giải quyết vấn đề cụ thể này, bạn có thể tận dụng phương pháp phát triển gia tăng giúp cải thiện khả năng đọc của chức năng.
Hãy xem thực hiện thay thế sau đây của
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Nói chung, nó là một thực tiễn tốt để tránh các chức năng sửa đổi các biến toàn cầu. Nếu có thể, hãy cố gắng viết các chức năng độc lập với một câu lệnh
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
Sử dụng function_name[arg1, arg2, ..., argN]
1 với các điều kiện
function_name[arg1, arg2, ..., argN]
Các hàm Python không bị hạn chế để có một tuyên bố
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
Một cách phổ biến để viết các chức năng với nhiều câu lệnh
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
Giả sử bạn cần mã hóa một hàm lấy một số và trả về giá trị tuyệt đối của nó. Nếu số lớn hơn
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Ở đây, một triển khai có thể cho chức năng này:
>>>
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Hãy xem cuộc gọi sau đây đến
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
>>>
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Hãy xem cuộc gọi sau đây đến
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
>>>
second.shared = "poo"
print[first.shared]
# "foo"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Hãy xem cuộc gọi sau đây đến
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
>>>
second.shared = "poo"
print[first.shared]
# "foo"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Hãy xem cuộc gọi sau đây đến
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Khi bạn gọi second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
36 bằng cách sử dụng second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
14 làm đối số, kết quả là bạn sẽ nhận được >>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
8. Điều đó bởi vì dòng thực thi đi đến cuối hàm mà không đạt được bất kỳ câu lệnh function_name[arg1, arg2, ..., argN]
1 rõ ràng nào. Thật không may, giá trị tuyệt đối của second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
14 là second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
14, không phải >>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
8.
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Để khắc phục sự cố này, bạn có thể thêm câu lệnh
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Bây giờ,
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
>>>
second.shared = "poo"
print[first.shared]
# "foo"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Hãy xem cuộc gọi sau đây đến
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
- Khi bạn gọi
36 bằng cách sử dụngsecond.bar = "ick" print[second.bar] # "ick" print[first.bar] # "baz"
14 làm đối số, kết quả là bạn sẽ nhận đượcsecond.bar = "ick" print[second.bar] # "ick" print[first.bar] # "baz"
8. Điều đó bởi vì dòng thực thi đi đến cuối hàm mà không đạt được bất kỳ câu lệnh>>> num = return_42[] >>> num 42 >>> return_42[] * 2 84 >>> return_42[] + 5 47
1 rõ ràng nào. Thật không may, giá trị tuyệt đối củafunction_name[arg1, arg2, ..., argN]
14 làsecond.bar = "ick" print[second.bar] # "ick" print[first.bar] # "baz"
14, không phảisecond.bar = "ick" print[second.bar] # "ick" print[first.bar] # "baz"
8.>>> num = return_42[] >>> num 42 >>> return_42[] * 2 84 >>> return_42[] + 5 47 - Để khắc phục sự cố này, bạn có thể thêm câu lệnh
1 thứ ba, trong một mệnh đềfunction_name[arg1, arg2, ..., argN]
54 mới hoặc trong một điều khoảnsecond.bar = "ick" print[second.bar] # "ick" print[first.bar] # "baz"
55 cuối cùng:second.bar = "ick" print[second.bar] # "ick" print[first.bar] # "baz" - Bây giờ,
36 kiểm tra mọi điều kiện có thể,second.bar = "ick" print[second.bar] # "ick" print[first.bar] # "baz"
57,second.bar = "ick" print[second.bar] # "ick" print[first.bar] # "baz"
58 vàsecond.bar = "ick" print[second.bar] # "ick" print[first.bar] # "baz"
59. Mục đích của ví dụ này là chỉ ra rằng khi bạn sử dụng các câu lệnh có điều kiện để cung cấp nhiều câu lệnhsecond.bar = "ick" print[second.bar] # "ick" print[first.bar] # "baz"
1, bạn cần đảm bảo rằng mọi tùy chọn có thể đều có câu lệnhfunction_name[arg1, arg2, ..., argN]
1 riêng. Nếu không, chức năng của bạn sẽ có một lỗi ẩn.function_name[arg1, arg2, ..., argN] - Cuối cùng, bạn có thể thực hiện
36 một cách ngắn gọn, hiệu quả và pythonic hơn bằng cách sử dụng một câu lệnhsecond.bar = "ick" print[second.bar] # "ick" print[first.bar] # "baz"
38:second.bar = "ick" print[second.bar] # "ick" print[first.bar] # "baz"
Trong trường hợp này, chức năng của bạn nhấn vào câu lệnh
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
>>>
second.shared = "poo"
print[first.shared]
# "foo"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Hãy xem cuộc gọi sau đây đến
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
>>>
second.shared = "poo"
print[first.shared]
# "foo"
Nói chung,
second.shared = "poo"
print[first.shared]
# "foo"
second.shared = "poo"
print[first.shared]
# "foo"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.shared = "poo"
print[first.shared]
# "foo"
Giả sử bạn muốn viết một hàm vị ngữ có hai giá trị và trả về
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
>>>
second.shared = "poo"
print[first.shared]
# "foo"
Vì
second.shared = "poo"
print[first.shared]
# "foo"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
- Một tuyên bố rõ ràng
38second.bar = "ick" print[second.bar] # "ick" print[first.bar] # "baz" - Một biểu thức có điều kiện [toán tử ternary]
- Chức năng Python tích hợp
19second.shared = "poo" print[first.shared] # "foo"
Nếu bạn sử dụng phương pháp đầu tiên, thì bạn có thể viết
second.shared = "poo"
print[first.shared]
# "foo"
>>>
second.shared = "poo"
print[first.shared]
# "foo"
Tuyên bố
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.shared = "poo"
print[first.shared]
# "foo"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Mặt khác, nếu bạn sử dụng biểu thức có điều kiện Python hoặc toán tử ternary, thì bạn có thể viết chức năng vị ngữ của mình như sau:
>>>
second.shared = "poo"
print[first.shared]
# "foo"
Ở đây, bạn sử dụng một biểu thức có điều kiện để cung cấp giá trị trả về cho
second.shared = "poo"
print[first.shared]
# "foo"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Cuối cùng, nếu bạn sử dụng
second.shared = "poo"
print[first.shared]
# "foo"
second.shared = "poo"
print[first.shared]
# "foo"
>>>
second.shared = "poo"
print[first.shared]
# "foo"
second.shared = "poo"
print[first.shared]
# "foo"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Các vòng ngắn mạch
Một câu lệnh
function_name[arg1, arg2, ..., argN]
second.shared = "poo"
print[first.shared]
# "foo"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.shared = "poo"
print[first.shared]
# "foo"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Để mô phỏng
second.shared = "poo"
print[first.shared]
# "foo"
>>>
second.shared = "poo"
print[first.shared]
# "foo"
Nếu bất kỳ
second.shared = "poo"
print[first.shared]
# "foo"
second.shared = "poo"
print[first.shared]
# "foo"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
second.shared = "poo"
print[first.shared]
# "foo"
second.shared = "poo"
print[first.shared]
# "foo"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Hàm này thực hiện đánh giá ngắn mạch. Ví dụ, giả sử rằng bạn vượt qua một điều có thể chứa một triệu vật phẩm. Nếu mục đầu tiên trong đó có thể xảy ra là đúng, thì vòng lặp chỉ chạy một lần thay vì một triệu lần. Điều này có thể giúp bạn tiết kiệm rất nhiều thời gian xử lý khi chạy mã của bạn.short-circuit evaluation. For example, suppose that you pass an iterable that contains a million items. If the first item in that iterable happens to be true, then the loop runs only one time rather than a million times. This can save you a lot of processing time when running your code.
Điều quan trọng cần lưu ý là để sử dụng câu lệnh
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Nhận ra mã chết
Ngay khi một hàm nhấn vào câu lệnh
function_name[arg1, arg2, ..., argN]
Xem xét chức năng sau, thêm mã sau câu lệnh
function_name[arg1, arg2, ..., argN]
>>>
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Tuyên bố
second.shared = "poo"
print[first.shared]
# "foo"
function_name[arg1, arg2, ..., argN]
Điều đáng chú ý là nếu bạn sử dụng các câu lệnh có điều kiện để cung cấp nhiều câu lệnh
function_name[arg1, arg2, ..., argN]
function_name[arg1, arg2, ..., argN]
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
>>>
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Mặc dù cuộc gọi đến
first = Thing[]
second = Thing[]
function_name[arg1, arg2, ..., argN]
second.shared = "poo"
print[first.shared]
# "foo"
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
Trả lại nhiều đối tượng được đặt tên
Khi bạn viết một hàm trả về nhiều giá trị trong một câu lệnh
function_name[arg1, arg2, ..., argN]
second.shared = "poo"
print[first.shared]
# "foo"
second.shared = "poo"
print[first.shared]
# "foo"
>>> num = return_42[]
>>> num
42
>>> return_42[] * 2
84
>>> return_42[] + 5
47
Bộ khởi tạo của
second.shared = "poo"
print[first.shared]
# "foo"
second.shared = "poo"
print[first.shared]
# "foo"
80 giữ tên của lớp giống như tuple mà bạn đang tạo ra. Nó cần phải là một chuỗi. holds the name of the tuple-like class that you’re creating. It needs to be a string.second.shared = "poo" print[first.shared] # "foo"
81 giữ tên của các trường hoặc thuộc tính của lớp giống như tuple. Nó có thể là một chuỗi các chuỗi nhưsecond.shared = "poo" print[first.shared] # "foo"
82 hoặc một chuỗi duy nhất với mỗi tên được phân tách bằng khoảng trắng hoặc dấu phẩy, chẳng hạn nhưsecond.shared = "poo" print[first.shared] # "foo"
83 hoặcsecond.shared = "poo" print[first.shared] # "foo"
84. holds the names of the fields or attributes of the tuple-like class. It can be a sequence of strings such assecond.shared = "poo" print[first.shared] # "foo"
82 or a single string with each name separated by whitespace or commas, such assecond.shared = "poo" print[first.shared] # "foo"
83 orsecond.shared = "poo" print[first.shared] # "foo"
84.second.shared = "poo" print[first.shared] # "foo"
Sử dụng
second.shared = "poo"
print[first.shared]
# "foo"
first = Thing[]
second = Thing[]
second.shared = "poo"
print[first.shared]
# "foo"
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Bên trong
first = Thing[]
second = Thing[]
second.shared = "poo"
print[first.shared]
# "foo"
second.shared = "poo"
print[first.shared]
# "foo"
second.shared = "poo"
print[first.shared]
# "foo"
second.shared = "poo"
print[first.shared]
# "foo"
second.shared = "poo"
print[first.shared]
# "foo"
Bạn có thể tạo một đối tượng
second.shared = "poo"
print[first.shared]
# "foo"
second.shared = "poo"
print[first.shared]
# "foo"
function_name[arg1, arg2, ..., argN]
Ở đây, cách thức hoạt động của
first = Thing[]
second = Thing[]
>>>
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Khi bạn gọi
first = Thing[]
second = Thing[]
second.shared = "poo"
print[first.shared]
# "foo"
Cuối cùng, bạn cũng có thể sử dụng một thao tác giải nén có thể lặp lại để lưu trữ từng giá trị trong biến độc lập của riêng nó.
Chức năng trả lại: Đóng cửa
Trong Python, các chức năng là các đối tượng hạng nhất. Đối tượng hạng nhất là một đối tượng có thể được gán cho một biến, được truyền dưới dạng đối số cho một hàm hoặc được sử dụng làm giá trị trả về trong một hàm. Vì vậy, bạn có thể sử dụng một đối tượng hàm làm giá trị trả về trong bất kỳ câu lệnh
function_name[arg1, arg2, ..., argN]
Một hàm có chức năng làm đối số, kết quả là trả về một hàm hoặc cả hai đều là hàm bậc cao hơn. Chức năng của nhà máy đóng cửa là một ví dụ phổ biến về chức năng bậc cao trong Python. Loại chức năng này có một số đối số và trả về một hàm bên trong. Hàm bên trong thường được gọi là đóng cửa.closure.
Một đóng cửa mang thông tin về phạm vi thực thi kèm theo của nó. Điều này cung cấp một cách để giữ lại thông tin trạng thái giữa các cuộc gọi chức năng. Các chức năng của nhà máy đóng cửa là hữu ích khi bạn cần viết mã dựa trên khái niệm đánh giá lười biếng hoặc bị trì hoãn.
Giả sử bạn cần viết một hàm trợ giúp có một số và trả về kết quả của việc nhân số đó với một yếu tố nhất định. Bạn có thể mã hóa chức năng đó như sau:
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
second.bar = "ick"
print[second.bar]
# "ick"
print[first.bar]
# "baz"
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Việc triển khai sau đây của
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
>>>
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Khi bạn gọi
first = Thing[]
second = Thing[]
second.shared = "poo"
print[first.shared]
# "foo"
Cuối cùng, bạn cũng có thể sử dụng một thao tác giải nén có thể lặp lại để lưu trữ từng giá trị trong biến độc lập của riêng nó.
Chức năng trả lại: Đóng cửa
>>>
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Khi bạn gọi
first = Thing[]
second = Thing[]
second.shared = "poo"
print[first.shared]
# "foo"
Cuối cùng, bạn cũng có thể sử dụng một thao tác giải nén có thể lặp lại để lưu trữ từng giá trị trong biến độc lập của riêng nó.
Chức năng trả lại: Đóng cửadecorator function takes a function object as an argument and returns a function object. The decorator processes the decorated function in some way and returns it or replaces it with another function or callable object.
Các nhà trang trí rất hữu ích khi bạn cần thêm logic bổ sung cho các chức năng hiện có mà không cần sửa đổi chúng. Ví dụ: bạn có thể mã hóa một trình trang trí để ghi nhật ký các cuộc gọi chức năng, xác thực các đối số vào một hàm, đo thời gian thực hiện của một hàm nhất định, v.v.
Ví dụ sau đây cho thấy chức năng trang trí mà bạn có thể sử dụng để có ý tưởng về thời gian thực hiện của một hàm Python nhất định:
>>>
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Cú pháp
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Python chạy các chức năng trang trí ngay khi bạn nhập hoặc chạy mô -đun hoặc tập lệnh. Vì vậy, khi bạn gọi
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Trong trường hợp này, bạn sử dụng
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Các ví dụ phổ biến khác về các nhà trang trí trong Python là
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Trả về các đối tượng do người dùng xác định: mẫu nhà máy
Câu lệnh Python
function_name[arg1, arg2, ..., argN]
Mẫu nhà máy xác định một giao diện để tạo các đối tượng trên con ruồi để đáp ứng với các điều kiện mà bạn có thể dự đoán khi bạn viết một chương trình. Bạn có thể triển khai một nhà máy của các đối tượng do người dùng xác định bằng cách sử dụng một chức năng lấy một số đối số khởi tạo và trả về các đối tượng khác nhau theo đầu vào cụ thể.
Giả sử bạn viết một ứng dụng vẽ. Bạn cần tạo các hình dạng khác nhau khi bay để đáp ứng với các lựa chọn của người dùng. Chương trình của bạn sẽ có hình vuông, vòng tròn, hình chữ nhật, v.v. Để tạo ra những hình dạng đó một cách nhanh chóng, trước tiên bạn cần tạo các lớp hình dạng mà bạn sẽ sử dụng:
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Khi bạn có một lớp cho mỗi hình dạng, bạn có thể viết một hàm có tên của hình dạng dưới dạng chuỗi và danh sách các đối số tùy chọn [
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Hàm này tạo ra một thể hiện hình dạng cụ thể và trả lại cho người gọi. Bây giờ bạn có thể sử dụng
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
>>>
def function_name[arg1, arg2,..., argN]:
# Function's code goes here...
pass
Cú pháp
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Python chạy các chức năng trang trí ngay khi bạn nhập hoặc chạy mô -đun hoặc tập lệnh. Vì vậy, khi bạn gọi Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
30, bạn thực sự gọi giá trị trả lại của Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
32, đây là đối tượng hàm Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
36. Cuộc gọi đến Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
30 được trang trí sẽ trả về giá trị trung bình của mẫu và cũng sẽ đo thời gian thực hiện của Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
30 ban đầu.
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Trong trường hợp này, bạn sử dụng
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
>>>
def function_name[arg1, arg2,..., argN]:
# Function's code goes here...
pass
Cú pháp
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Python chạy các chức năng trang trí ngay khi bạn nhập hoặc chạy mô -đun hoặc tập lệnh. Vì vậy, khi bạn gọi Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
30, bạn thực sự gọi giá trị trả lại của Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
32, đây là đối tượng hàm Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
36. Cuộc gọi đến Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
30 được trang trí sẽ trả về giá trị trung bình của mẫu và cũng sẽ đo thời gian thực hiện của Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
30 ban đầu.
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Trong trường hợp này, bạn sử dụng
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Các ví dụ phổ biến khác về các nhà trang trí trong Python là
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Trả về các đối tượng do người dùng xác định: mẫu nhà máy
>>>
def function_name[arg1, arg2,..., argN]:
# Function's code goes here...
pass
Câu lệnh Python
function_name[arg1, arg2, ..., argN]
Hai cuộc gọi đầu tiên đến
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
first = Thing[]
second = Thing[]
first = Thing[]
second = Thing[]
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Thing.shared = "zoom"
print[first.shared]
# "zoom"
print[second.shared]
# "poo", still
Sự kết luận
Câu lệnh Python
function_name[arg1, arg2, ..., argN]
Trong hướng dẫn này, bạn đã học được cách:
- Sử dụng hiệu quả câu lệnh Python
1 trong các chức năng của bạnPythonfunction_name[arg1, arg2, ..., argN]
1 statement in your functionsfunction_name[arg1, arg2, ..., argN] - Trả lại một hoặc nhiều giá trị từ các chức năng của bạn cho mã người gọisingle or multiple values from your functions to the caller code
- Áp dụng các thực tiễn tốt nhất khi sử dụng câu lệnh
1best practices when using thefunction_name[arg1, arg2, ..., argN]
1 statementfunction_name[arg1, arg2, ..., argN]
Ngoài ra, bạn đã học được một số trường hợp sử dụng nâng cao hơn cho tuyên bố
function_name[arg1, arg2, ..., argN]
Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: Sử dụng câu lệnh Python Return một cách hiệu quả This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Using the Python return Statement Effectively