Hướng dẫn define a new function in python - xác định một hàm mới trong python

Trong lập trình, một hàm là một khối mã có thể tái sử dụng thực thi một chức năng nhất định khi nó được gọi.

Các chức năng là các phần không thể thiếu của mọi ngôn ngữ lập trình vì chúng giúp làm cho mã của bạn trở nên mô -đun hơn và có thể tái sử dụng.

Trong bài viết này, tôi sẽ chỉ cho bạn cách xác định một chức năng trong Python và gọi nó, để bạn có thể chia mã các ứng dụng Python của bạn thành các khối nhỏ hơn.

Tôi cũng sẽ chỉ cho bạn cách các đối số và từ khóa trả về hoạt động trong các hàm Python.

Cú pháp cơ bản để xác định chức năng trong Python

Trong Python, bạn xác định một hàm với từ khóa

def myfunction[]:
    print["Hello World"]

19, sau đó viết định danh chức năng [tên] theo sau là dấu ngoặc đơn và dấu hai chấm.

Điều tiếp theo bạn phải làm là đảm bảo bạn thụt lề với một tab hoặc 4 khoảng trống, sau đó chỉ định những gì bạn muốn chức năng làm cho bạn.

def functionName[]:
    # What to make the function do

Các ví dụ cơ bản về một chức năng trong Python

Theo cú pháp cơ bản ở trên, một ví dụ về chức năng Python cơ bản in ấn Hello Hello World vào thiết bị đầu cuối trông như thế này:

def myfunction[]:
    print["Hello World"]

Để gọi chức năng này, hãy viết tên của hàm theo sau là dấu ngoặc đơn:, write the name of the function followed by parentheses:

myfunction[]

Tiếp theo, hãy chạy mã của bạn trong thiết bị đầu cuối bằng cách nhập

def myfunction[]:
    print["Hello World"]

20 để hiển thị những gì bạn muốn chức năng làm:

Một ví dụ cơ bản khác về số Subtractig 2 trông như thế này:

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

Đối số trong các chức năng Python

Trong khi xác định một hàm trong Python, bạn có thể chuyển [các] đối số vào hàm bằng cách đặt chúng vào trong dấu ngoặc đơn.

Cú pháp cơ bản để làm điều này trông như hình dưới đây:

def functionName[arg1, arg2]:
    # What to do with function

Khi hàm được gọi, thì bạn cần chỉ định giá trị cho các đối số:

functionName[valueForArg1, valueForArg2]

Đây là một ví dụ về các đối số trong hàm Python:

def addNum[num1, num2]:
    print[num1 + num2]
addNum[2, 4]

# Output: 6

Trong ví dụ trên:

Tôi đã chuyển 2 đối số vào hàm có tên
```
def myfunction[]:
    print["Hello World"]
```
21
Tôi đã bảo nó in tổng của 2 đối số vào thiết bị đầu cuối
Sau đó tôi đã gọi nó với các giá trị cho 2 đối số được chỉ định

N.B .: Bạn có thể chỉ định bao nhiêu đối số như bạn muốn.: You can specify as many arguments as you want.

Cách sử dụng từ khóa trả về trong Python

Trong Python, bạn có thể sử dụng từ khóa

def myfunction[]:
    print["Hello World"]

22 để thoát một hàm để quay trở lại nơi được gọi. Đó là, gửi một cái gì đó ra khỏi chức năng.

Câu lệnh trả về có thể chứa một biểu thức để thực thi khi hàm được gọi.

Ví dụ dưới đây cho thấy cách từ khóa trả về hoạt động trong Python:

def multiplyNum[num1]:
    return num1 * 8

result = multiplyNum[8]
print[result]

# Output: 64

Những gì mã ở trên làm?

Tôi đã xác định một hàm có tên

def myfunction[]:
    print["Hello World"]

23 và chuyển nó

def myfunction[]:
    print["Hello World"]

24 như một đối số

Bên trong hàm, tôi đã sử dụng từ khóa trả về để chỉ định rằng tôi muốn
```
def myfunction[]:
    print["Hello World"]
```
24 được nhân với 8
Sau đó, tôi đã gọi hàm, đã chuyển
```
def myfunction[]:
    print["Hello World"]
```
26 vào đó là giá trị cho đối số
```
def myfunction[]:
    print["Hello World"]
```
24 và gán lệnh gọi hàm cho một biến tôi đặt tên
```
def myfunction[]:
    print["Hello World"]
```
28
Với biến kết quả, tôi đã có thể in những gì tôi dự định làm với chức năng cho thiết bị đầu cuối

Sự kết luận

Trong bài viết này, bạn đã học cách xác định và gọi các chức năng trong Python. Bạn cũng đã học cách truyền các đối số vào một hàm và sử dụng từ khóa trả về, vì vậy bạn có thể sáng tạo hơn với các chức năng bạn viết.

Nếu bạn thấy bài viết này hữu ích, đừng ngần ngại chia sẻ nó với bạn bè và gia đình của bạn.

Học mã miễn phí. Chương trình giảng dạy nguồn mở của Freecodecamp đã giúp hơn 40.000 người có được việc làm với tư cách là nhà phát triển. Bắt đầu

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: Xác định và gọi các chức năng Python This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Defining and Calling Python Functions

Làm thế nào để bạn tạo một chức năng mới?define your own Python function. You’ll learn when to divide your program into separate user-defined functions and what tools you’ll need to do this.

Để tạo chức năng của riêng bạn, bạn cần phải làm bốn điều:.

Viết loại trả về của hàm ..functions work in Python and why they’re beneficial
Viết tên của hàm ..define and call your own Python function
Bên trong ngoặc đơn [], liệt kê bất kỳ tham số nào mà hàm mất ..passing arguments to your function
Bên trong dấu ngoặc xoăn {}, viết mã sẽ chạy bất cứ khi nào chức năng được gọi. Đây được gọi là cơ thể của chức năng ..return data from your function back to the calling environment

Làm thế nào để bạn xác định một chức năng?

Một định nghĩa kỹ thuật của một hàm là: Một mối quan hệ từ một tập hợp các đầu vào đến một tập hợp các đầu ra có thể trong đó mỗi đầu vào có liên quan đến chính xác một đầu ra.function. A function is a relationship or mapping between one or more inputs and a set of outputs. In mathematics, a function is typically represented like this:

Cú pháp để xác định chức năng mới là gì?

Cú pháp để tạo một hàm: hãy để func = hàm mới [[arg1, arg2, ... argn], functionbody]; Hàm được tạo với các đối số arg1 ... argn và hàm đã cho.function is a self-contained block of code that encapsulates a specific task or related group of tasks. In previous tutorials in this series, you’ve been introduced to some of the built-in functions provided by Python.

def myfunction[]:
    print["Hello World"]

33, for example, takes one argument and returns that object’s unique integer identifier:

4 loại chức năng trong Python là gì?

>>> s = 'foobar'
>>> id[s]
56313440

Sau đây là các loại chức năng Python khác nhau:.

4 loại chức năng trong Python là gì?

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

Sau đây là các loại chức năng Python khác nhau:.

4 loại chức năng trong Python là gì?

def myfunction[]:
    print["Hello World"]

Sau đây là các loại chức năng Python khác nhau:.

Chức năng tích hợp Python ..arguments [if any] it takes
Chức năng đệ quy Python ..values [if any] it returns

Chức năng Python Lambda ..

Các chức năng do người dùng Python xác định ..

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

Tầm quan trọng của các chức năng Python

Hầu như tất cả các ngôn ngữ lập trình được sử dụng ngày nay đều hỗ trợ một hình thức các hàm do người dùng xác định, mặc dù chúng không phải là các chức năng. Trong các ngôn ngữ khác, bạn có thể thấy chúng được gọi là một trong những điều sau đây:

Chương trình con
Thủ tục
Phương pháp
Chương trình con

Vì vậy, tại sao bận tâm xác định chức năng? Có một số lý do rất tốt. Bây giờ, hãy để một vài người đi qua.

Trừu tượng hóa và tái sử dụng

Giả sử bạn viết một số mã làm một cái gì đó hữu ích. Khi bạn tiếp tục phát triển, bạn thấy rằng nhiệm vụ được thực hiện bởi mã đó là một nhiệm vụ bạn cần thường xuyên, ở nhiều vị trí khác nhau trong ứng dụng của bạn. Những gì bạn nên làm? Chà, bạn chỉ có thể sao chép lại mã nhiều lần, sử dụng khả năng sao chép và dán trình soạn thảo của bạn.

Sau đó, bạn có thể quyết định rằng mã trong câu hỏi cần phải được sửa đổi. Bạn có thể tìm thấy một cái gì đó sai với nó cần được sửa chữa, hoặc bạn sẽ muốn nâng cao nó theo một cách nào đó. Nếu các bản sao của mã được phân tán trên tất cả các ứng dụng của bạn, thì bạn sẽ cần thực hiện các thay đổi cần thiết ở mọi vị trí.

Một giải pháp tốt hơn là xác định hàm Python thực hiện nhiệm 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 nhiệm vụ, bạn chỉ cần gọi chức năng. Xuống dòng, nếu bạn quyết định thay đổi cách thức hoạt động, thì bạn chỉ cần thay đổi mã ở một vị trí, đó là nơi xác định hàm. Các thay đổi sẽ tự động được chọn bất cứ nơi nào chức năng được gọi.define a Python function that performs the task. Anywhere in your application that you need to accomplish the task, you simply call the function. Down the line, if you decide to change how it works, then you only need to change the code in one location, which is the place where the function is defined. The changes will automatically be picked up anywhere the function is called.

Sự trừu tượng của chức năng thành một định nghĩa chức năng là một ví dụ về nguyên tắc phát triển phần mềm của don Lặp lại [khô]. Đây được cho là động lực mạnh nhất để sử dụng các chức năng.abstraction of functionality into a function definition is an example of the Don’t Repeat Yourself [DRY] Principle of software development. This is arguably the strongest motivation for using functions.

Mô -đun

Các chức năng cho phép các quy trình phức tạp được chia thành các bước nhỏ hơn. Ví dụ, hãy tưởng tượng rằng bạn có một chương trình đọc trong một tệp, xử lý nội dung tệp và sau đó ghi một tệp đầu ra. Mã của bạn có thể trông như thế này:complex processes to be broken up into smaller steps. Imagine, for example, that you have a program that reads in a file, processes the file contents, and then writes an output file. Your code could look like this:

def myfunction[]:
    print["Hello World"]

Trong ví dụ này, chương trình chính là một loạt các mã được nối với nhau theo một chuỗi dài, với khoảng trắng và bình luận để giúp tổ chức nó. Tuy nhiên, nếu mã trở nên dài hơn và phức tạp hơn nhiều, thì bạn sẽ có một thời gian ngày càng khó khăn khi quấn đầu xung quanh nó.

Ngoài ra, bạn có thể cấu trúc mã giống như sau:

def myfunction[]:
    print["Hello World"]

Ví dụ này được mô đun hóa. Thay vì tất cả các mã được xâu chuỗi lại với nhau, nó đã chia thành các chức năng riêng biệt, mỗi chức năng tập trung vào một nhiệm vụ cụ thể. Những nhiệm vụ đó được đọc, xử lý và viết. Chương trình chính bây giờ chỉ cần gọi lần lượt từng người trong số này.modularized. Instead of all the code being strung together, it’s broken out into separate functions, each of which focuses on a specific task. Those tasks are read, process, and write. The main program now simply needs to call each of these in turn.

Trong cuộc sống, bạn làm điều này mọi lúc, ngay cả khi bạn không nghĩ rõ ràng về nó theo cách đó. Nếu bạn muốn di chuyển một số kệ chứa đầy những thứ từ một bên trong nhà để xe của bạn, thì bạn hy vọng sẽ chỉ đứng đó và nghĩ vô mục đích, thì Oh Oh, Geez. Tôi cần phải di chuyển tất cả những thứ đó ở đó! Làm thế nào để làm điều đó???" Bạn đã chia công việc thành các bước có thể quản lý được:

Lấy tất cả những thứ ra khỏi kệ. all the stuff off the shelves.
Hãy tách các kệ ra. the shelves apart.
Mang các bộ phận kệ trên nhà để xe đến vị trí mới. the shelf parts across the garage to the new location.
Lắp lại các kệ. the shelves.
Mang theo những thứ trên nhà để xe. the stuff across the garage.
Đặt những thứ trở lại trên kệ. the stuff back on the shelves.

Phá vỡ một nhiệm vụ lớn thành các nhiệm vụ phụ nhỏ hơn, có kích thước cắn giúp làm cho nhiệm vụ lớn dễ suy nghĩ và quản lý hơn. Khi các chương trình trở nên phức tạp hơn, nó ngày càng có lợi để mô đun hóa chúng theo cách này.

Tách không gian tên

Một không gian tên là một khu vực của một chương trình trong đó các định danh có ý nghĩa. Như bạn sẽ thấy bên dưới, khi một hàm Python được gọi, một không gian tên mới được tạo cho chức năng đó, một hàm khác với tất cả các không gian tên khác đã tồn tại.namespace is a region of a program in which identifiers have meaning. As you’ll see below, when a Python function is called, a new namespace is created for that function, one that is distinct from all other namespaces that already exist.

Kết quả thực tế của điều này là các biến có thể được xác định và sử dụng trong hàm Python ngay cả khi chúng có cùng tên với các biến được xác định trong các chức năng khác hoặc trong chương trình chính. Trong những trường hợp này, sẽ không có sự nhầm lẫn hoặc can thiệp vì chúng được giữ trong các không gian tên riêng biệt.

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

Hy vọng rằng, bạn đã đủ thuyết phục về những đức tính của các chức năng và mong muốn tạo ra một số! Hãy để xem làm thế nào.

Các cuộc gọi và định nghĩa chức năng

Cú pháp thông thường để xác định hàm Python như sau:

def myfunction[]:
    print["Hello World"]

Các thành phần của định nghĩa được giải thích trong bảng dưới đây:

Thành phầnNghĩa

`def myfunction[]: print["Hello World"]` 19	Từ khóa thông báo cho Python rằng một hàm đang được xác định
`def myfunction[]: print["Hello World"]` 39	Một định danh python hợp lệ đặt tên cho chức năng
`def myfunction[]: print["Hello World"]` 40	Một danh sách các tham số được phân tách bằng dấu phẩy có thể được chuyển đến hàm
`def myfunction[]: print["Hello World"]` 41	Dấu câu biểu thị phần cuối của tiêu đề chức năng Python [danh sách tên và tham số]
`def myfunction[]: print["Hello World"]` 42	Một khối các câu lệnh Python hợp lệ

Mục cuối cùng,

def myfunction[]:
    print["Hello World"]

42, được gọi là phần thân của hàm. Cơ thể là một khối các câu lệnh sẽ được thực thi khi chức năng được gọi. Cơ thể của hàm python được xác định bằng vết lõm theo quy tắc ngoài mặt. Điều này giống như các khối mã liên quan đến cấu trúc điều khiển, như câu lệnh

def myfunction[]:
    print["Hello World"]

44 hoặc

def myfunction[]:
    print["Hello World"]

45.body of the function. The body is a block of statements that will be executed when the function is called. The body of a Python function is defined by indentation in accordance with the off-side rule. This is the same as code blocks associated with a control structure, like an

def myfunction[]:
    print["Hello World"]

44 or

def myfunction[]:
    print["Hello World"]

45 statement.

Cú pháp để gọi hàm Python như sau:

def myfunction[]:
    print["Hello World"]

def myfunction[]:
    print["Hello World"]

46 là các giá trị được truyền vào hàm. Chúng tương ứng với

def myfunction[]:
    print["Hello World"]

40 trong định nghĩa hàm Python. Bạn có thể xác định một chức năng không có 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ệnh gọi hàm phải luôn bao gồm dấu ngoặc đơn, ngay cả khi chúng trống rỗng.

Như thường lệ, bạn sẽ bắt đầu với một ví dụ nhỏ và thêm độ phức tạp từ đó. Giữ cho truyền thống toán học được tôn vinh theo thời gian, bạn sẽ gọi chức năng Python đầu tiên của mình

def myfunction[]:
    print["Hello World"]

48. Ở đây, một tệp tập lệnh,

def myfunction[]:
    print["Hello World"]

49, xác định và gọi

def myfunction[]:
    print["Hello World"]

48:

def myfunction[]:
    print["Hello World"]

Ở đây, cách thức hoạt động của mã này:

Dòng 1 sử dụng từ khóa
```
def myfunction[]:
    print["Hello World"]
```
19 để chỉ ra rằng một hàm đang được xác định. Thực hiện câu lệnh
def myfunction[]: print["Hello World"]
19 chỉ tạo ra định nghĩa của
def myfunction[]: print["Hello World"]
48. Tất cả các dòng sau được thụt vào [dòng 2 đến 3] trở thành một phần của cơ thể
def myfunction[]: print["Hello World"]
48 và được lưu trữ theo định nghĩa của nó, nhưng chúng vẫn chưa được thực hiện. uses the
```
def myfunction[]:
    print["Hello World"]
```
19 keyword to indicate that a function is being defined. Execution of the
```
def myfunction[]:
    print["Hello World"]
```
19 statement merely creates the definition of
```
def myfunction[]:
    print["Hello World"]
```
48. All the following lines that are indented [lines 2 to 3] become part of the body of
```
def myfunction[]:
    print["Hello World"]
```
48 and are stored as its definition, but they aren’t executed yet.
Dòng 4 là một chút khoảng trắng giữa định nghĩa hàm và dòng đầu tiên của chương trình chính. Mặc dù nó không cần thiết về mặt cú pháp, nhưng thật tuyệt khi có. Để tìm hiểu thêm về khoảng trắng xung quanh các định nghĩa chức năng Python cấp cao nhất, hãy xem viết mã Pythonic tuyệt đẹp với PEP 8. is a bit of whitespace between the function definition and the first line of the main program. While it isn’t syntactically necessary, it is nice to have. To learn more about whitespace around top-level Python function definitions, check out Writing Beautiful Pythonic Code With PEP 8.
Dòng 5 là tuyên bố đầu tiên được thụt vào vì nó không phải là một phần của định nghĩa
```
def myfunction[]:
    print["Hello World"]
```
48. Nó bắt đầu chương trình chính. Khi chương trình chính thực thi, câu lệnh này được thực thi trước. is the first statement that isn’t indented because it isn’t a part of the definition of
```
def myfunction[]:
    print["Hello World"]
```
48. It’s the start of the main program. When the main program executes, this statement is executed first.
Dòng 6 là một cuộc gọi đến
```
def myfunction[]:
    print["Hello World"]
```
48. Lưu ý rằng dấu ngoặc đơn luôn được yêu cầu trong cả định nghĩa hàm và lệnh gọi hàm, ngay cả khi không có tham số hoặc đối số. Việc thực hiện tiến hành
def myfunction[]: print["Hello World"]
48 và các tuyên bố trong phần thân của
def myfunction[]: print["Hello World"]
48 được thực thi. is a call to
```
def myfunction[]:
    print["Hello World"]
```
48. Note that empty parentheses are always required in both a function definition and a function call, even when there are no parameters or arguments. Execution proceeds to
```
def myfunction[]:
    print["Hello World"]
```
48 and the statements in the body of
```
def myfunction[]:
    print["Hello World"]
```
48 are executed.
Dòng 7 là dòng tiếp theo để thực hiện một khi phần thân của
```
def myfunction[]:
    print["Hello World"]
```
48 đã hoàn thành. Thực thi trả về câu lệnh
def myfunction[]: print["Hello World"]
60 này. is the next line to execute once the body of
```
def myfunction[]:
    print["Hello World"]
```
48 has finished. Execution returns to this
```
def myfunction[]:
    print["Hello World"]
```
60 statement.

Trình tự thực thi [hoặc luồng điều khiển] cho

def myfunction[]:
    print["Hello World"]

49 được hiển thị trong sơ đồ sau:control flow] for

def myfunction[]:
    print["Hello World"]

49 is shown in the following diagram:

Khi

def myfunction[]:
    print["Hello World"]

49 được chạy từ dấu nhắc lệnh Windows, kết quả như sau:

def myfunction[]:
    print["Hello World"]

Thỉnh thoảng, bạn có thể muốn xác định một hàm trống không làm gì cả. Điều này được gọi là cuống, thường là trình giữ chỗ tạm thời cho chức năng Python sẽ được thực hiện đầy đủ sau đó. Giống như một khối trong cấu trúc điều khiển có thể trống rỗng, cơ thể của một chức năng cũng không thể. Để xác định chức năng sơ khai, hãy sử dụng

def myfunction[]:
    print["Hello World"]

63Statement:stub, which is usually a temporary placeholder for a Python function that will be fully implemented at a later time. Just as a block in a control structure can’t be empty, neither can the body of a function. To define a stub function, use the

def myfunction[]:
    print["Hello World"]

63statement:

>>>

def myfunction[]:
    print["Hello World"]

Như bạn có thể thấy ở trên, một cuộc gọi đến chức năng sơ khai có giá trị về mặt cú pháp nhưng không làm gì cả.

Đối số thông qua

Cho đến nay trong hướng dẫn này, các chức năng mà bạn đã xác định thiên đường đã đưa ra bất kỳ đối số nào. Điều đó đôi khi có thể hữu ích và thỉnh thoảng bạn sẽ viết các chức năng như vậy. Tuy nhiên, thường xuyên hơn, bạn sẽ muốn truyền dữ liệu vào một chức năng để hành vi của nó có thể thay đổi từ lời mời này sang cấp khác. Hãy cùng xem cách làm điều đó.pass data into a function so that its behavior can vary from one invocation to the next. Let’s see how to do that.

Lập luận vị trí

Cách đơn giản nhất để chuyển các đối số cho hàm Python là với các đối số vị trí [còn được gọi là đối số yêu cầu]. Trong định nghĩa chức năng, bạn chỉ định danh sách các tham số được phân tách bằng dấu phẩy bên trong dấu ngoặc đơn:positional arguments [also called required arguments]. In the function definition, you specify a comma-separated list of parameters inside the parentheses:

>>>

def myfunction[]:
    print["Hello World"]

Như bạn có thể thấy ở trên, một cuộc gọi đến chức năng sơ khai có giá trị về mặt cú pháp nhưng không làm gì cả.

>>>

def myfunction[]:
    print["Hello World"]

Như bạn có thể thấy ở trên, một cuộc gọi đến chức năng sơ khai có giá trị về mặt cú pháp nhưng không làm gì cả.variables that are defined locally to the function. When the function is called, the arguments that are passed [

def myfunction[]:
    print["Hello World"]

67,

def myfunction[]:
    print["Hello World"]

68, and

def myfunction[]:
    print["Hello World"]

69] are bound to the parameters in order, as though by variable assignment:

Đối số thông quaCho đến nay trong hướng dẫn này, các chức năng mà bạn đã xác định thiên đường đã đưa ra bất kỳ đối số nào. Điều đó đôi khi có thể hữu ích và thỉnh thoảng bạn sẽ viết các chức năng như vậy. Tuy nhiên, thường xuyên hơn, bạn sẽ muốn truyền dữ liệu vào một chức năng để hành vi của nó có thể thay đổi từ lời mời này sang cấp khác. Hãy cùng xem cách làm điều đó.

Lập luận vị trí Cách đơn giản nhất để chuyển các đối số cho hàm Python là với các đối số vị trí [còn được gọi là đối số yêu cầu]. Trong định nghĩa chức năng, bạn chỉ định danh sách các tham số được phân tách bằng dấu phẩy bên trong dấu ngoặc đơn: Khi hàm được gọi, bạn chỉ định danh sách các đối số tương ứng:

Các tham số [

def myfunction[]:
    print["Hello World"]

64,

def myfunction[]:
    print["Hello World"]

65 và

def myfunction[]:
    print["Hello World"]

66] hoạt động giống như các biến được xác định cục bộ với hàm. Khi hàm được gọi, các đối số được thông qua [

def myfunction[]:
    print["Hello World"]

67,

def myfunction[]:
    print["Hello World"]

68 và

def myfunction[]:
    print["Hello World"]

69] bị ràng buộc với các tham số theo thứ tự, như thể theo phân công biến:

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

def myfunction[]:
    print["Hello World"]

←

def myfunction[]:
    print["Hello World"]

Trong một số văn bản lập trình, các tham số được đưa ra trong định nghĩa hàm được gọi là các tham số chính thức và các đối số trong lệnh gọi hàm được gọi là các tham số thực tế:formal parameters, and the arguments in the function call are referred to as actual parameters:

Mặc dù các đối số vị trí là cách đơn giản nhất để truyền dữ liệu cho một chức năng, nhưng chúng cũng đủ khả năng linh hoạt nhất. Đối với người mới bắt đầu, thứ tự của các đối số trong cuộc gọi phải khớp với thứ tự của các tham số trong định nghĩa. Tất nhiên, không có gì để ngăn bạn chỉ định các đối số vị trí theo thứ tự, tất nhiên:order of the arguments in the call must match the order of the parameters in the definition. There’s nothing to stop you from specifying positional arguments out of order, of course:

>>>

myfunction[]

Chức năng thậm chí có thể vẫn chạy, như trong ví dụ trên, nhưng nó rất khó có thể tạo ra kết quả chính xác. Nó có trách nhiệm của người lập trình viên xác định chức năng để ghi lại những đối số thích hợp nên là gì và nó có trách nhiệm của người dùng chức năng để nhận thức được thông tin đó và tuân thủ thông tin đó.appropriate arguments should be, and it’s the responsibility of the user of the function to be aware of that information and abide by it.

Với các đối số vị trí, các đối số trong cuộc gọi và các tham số trong định nghĩa phải đồng ý không chỉ theo thứ tự mà cả về số lượng. Đó là lý do đối số vị trí cũng được gọi là các đối số yêu cầu. Bạn có thể bỏ qua bất kỳ khi gọi chức năng:number as well. That’s the reason positional arguments are also referred to as required arguments. You can’t leave any out when calling the function:

>>>

myfunction[]

>>>

myfunction[]

Với các đối số vị trí, các đối số trong cuộc gọi và các tham số trong định nghĩa phải đồng ý không chỉ theo thứ tự mà cả về số lượng. Đó là lý do đối số vị trí cũng được gọi là các đối số yêu cầu. Bạn có thể bỏ qua bất kỳ khi gọi chức năng:

Bạn cũng không thể chỉ định thêm những cái:keyword arguments as follows:

>>>

myfunction[]

>>>

myfunction[]

>>>

myfunction[]

>>>

myfunction[]

>>>

myfunction[]

>>>

myfunction[]

Bạn cũng không thể chỉ định thêm những cái:

Các lập luận vị trí là đơn giản về mặt khái niệm để sử dụng, nhưng họ không tha thứ lắm. Bạn phải chỉ định cùng một số lượng đối số trong cuộc gọi hàm vì có các tham số trong định nghĩa và theo cùng một thứ tự. Trong các phần tiếp theo, bạn sẽ thấy một số kỹ thuật thông qua đối số giúp thư giãn những hạn chế này.default or optional parameters. An example of a function definition with default parameters is shown below:

>>>

myfunction[]

>>>

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

Với các đối số vị trí, các đối số trong cuộc gọi và các tham số trong định nghĩa phải đồng ý không chỉ theo thứ tự mà cả về số lượng. Đó là lý do đối số vị trí cũng được gọi là các đối số yêu cầu. Bạn có thể bỏ qua bất kỳ khi gọi chức năng: must agree in order and number with the parameters declared in the function definition.
Bạn cũng không thể chỉ định thêm những cái: must agree with declared parameters in number, but they may be specified in arbitrary order.
Các lập luận vị trí là đơn giản về mặt khái niệm để sử dụng, nhưng họ không tha thứ lắm. Bạn phải chỉ định cùng một số lượng đối số trong cuộc gọi hàm vì có các tham số trong định nghĩa và theo cùng một thứ tự. Trong các phần tiếp theo, bạn sẽ thấy một số kỹ thuật thông qua đối số giúp thư giãn những hạn chế này. allow some arguments to be omitted when the function is called.

Từ khóa đối số

Khi bạn gọi một hàm, bạn có thể chỉ định các đối số trong mẫu

def myfunction[]:
    print["Hello World"]

76. Trong trường hợp đó, mỗi

def myfunction[]:
    print["Hello World"]

77 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 đó

def myfunction[]:
    print["Hello World"]

48 có thể được gọi với các đối số từ khóa như sau:mutable object. Consider this Python function definition:

>>>

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

>>>

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

>>>

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

Với các đối số vị trí, các đối số trong cuộc gọi và các tham số trong định nghĩa phải đồng ý không chỉ theo thứ tự mà cả về số lượng. Đó là lý do đối số vị trí cũng được gọi là các đối số yêu cầu. Bạn có thể bỏ qua bất kỳ khi gọi chức năng:defined only once when the function is defined [that is, when the

def myfunction[]:
    print["Hello World"]

19 statement is executed]. The default value isn’t re-defined each time the function is called. Thus, each time you call

def myfunction[]:
    print["Hello World"]

48 without a parameter, you’re performing

def myfunction[]:
    print["Hello World"]

91 on the same list.

Bạn có thể chứng minh điều này với

def myfunction[]:
    print["Hello World"]

33:

>>>

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

Mã định danh đối tượng được hiển thị xác nhận rằng, khi

def myfunction[]:
    print["Hello World"]

84 được phép mặc định, giá trị là cùng một đối tượng với mỗi cuộc gọi. Vì các danh sách có thể thay đổi, mỗi cuộc gọi

def myfunction[]:
    print["Hello World"]

91 tiếp theo khiến danh sách sẽ dài hơn. Đây là một cạm bẫy phổ biến và được ghi chép khá rõ khi bạn sử dụng một đối tượng có thể thay đổi làm giá trị mặc định của tham số. Nó có khả năng dẫn đến hành vi mã khó hiểu, và có lẽ tốt nhất là tránh.object identifier displayed confirms that, when

def myfunction[]:
    print["Hello World"]

84 is allowed to default, the value is the same object with each call. Since lists are mutable, each subsequent

def myfunction[]:
    print["Hello World"]

91 call causes the list to get longer. This is a common and pretty well-documented pitfall when you’re using a mutable object as a parameter’s default value. It potentially leads to confusing code behavior, and is probably best avoided.

Là một cách giải quyết, hãy xem xét sử dụng giá trị đối số mặc định báo hiệu không có đối số nào được chỉ định. Hầu hết mọi giá trị sẽ hoạt động, nhưng

def myfunction[]:
    print["Hello World"]

95 là một lựa chọn phổ biến. Khi giá trị sentinel cho biết không có đối số nào được đưa ra, hãy tạo một danh sách trống mới bên trong hàm:no argument has been specified. Most any value would work, but

def myfunction[]:
    print["Hello World"]

95 is a common choice. When the sentinel value indicates no argument is given, create a new empty list inside the function:

>>>

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

Mã định danh đối tượng được hiển thị xác nhận rằng, khi

def myfunction[]:
    print["Hello World"]

84 được phép mặc định, giá trị là cùng một đối tượng với mỗi cuộc gọi. Vì các danh sách có thể thay đổi, mỗi cuộc gọi

def myfunction[]:
    print["Hello World"]

def myfunction[]:
    print["Hello World"]

95 là một lựa chọn phổ biến. Khi giá trị sentinel cho biết không có đối số nào được đưa ra, hãy tạo một danh sách trống mới bên trong hàm:

Lưu ý làm thế nào điều này đảm bảo rằng

def myfunction[]:
    print["Hello World"]

84 hiện thực sự mặc định vào một danh sách trống bất cứ khi nào

def myfunction[]:
    print["Hello World"]

48 được gọi mà không có đối số.

Qua từng giá trị vs vượt qua trong pascal A copy of the argument is passed to the function.
Trong thiết kế ngôn ngữ lập trình, có hai mô hình phổ biến để chuyển một đối số cho một hàm: A reference to the argument is passed to the function.

Vượt qua từng giá trị: Một bản sao của đối số được chuyển đến hàm.

BY-BY-PREFFEMPENT: Một tham chiếu đến đối số được chuyển đến hàm.

Các cơ chế khác tồn tại, nhưng về cơ bản chúng là các biến thể của hai điều này. Trong phần này, bạn sẽ đi đường vòng ngắn từ Python và nhìn ngắn gọn về Pascal, một ngôn ngữ lập trình tạo ra sự khác biệt đặc biệt rõ ràng giữa hai người này. A procedure in Pascal is similar to a Python function.
Ở đây, những gì bạn cần biết về cú pháp Pascal: This operator [
```
def myfunction[]:
    print["Hello World"]
```
98] is used for assignment in Pascal. It’s analogous to the equals sign [
```
def myfunction[]:
    print["Hello World"]
```
99] in Python.
Quy trình: Một thủ tục trong Pascal tương tự như hàm Python. This function displays data to the console, similar to Python’s
```
def myfunction[]:
    print["Hello World"]
```
60.

Đại học đại tràng: Toán tử này [

def myfunction[]:
    print["Hello World"]

98] được sử dụng để gán trong Pascal. Nó tương tự như dấu hiệu bình đẳng [

def myfunction[]:
    print["Hello World"]

99] trong Python.

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

myfunction[]

00: Hàm này hiển thị dữ liệu cho bảng điều khiển, tương tự như Python,

def myfunction[]:
    print["Hello World"]

60.

Với một chút nền tảng đó, ở đây, ví dụ đầu tiên của Pascal: The main program defines an integer variable
```
def myfunction[]:
    print["Hello World"]
```
30.
Ở đây, những gì mà Lừa đang diễn ra: It initially assigns
```
def myfunction[]:
    print["Hello World"]
```
30 the value
```
myfunction[]
```
04.

Dòng 12: Chương trình chính xác định một biến số nguyên
def myfunction[]: print["Hello World"]
30. It then calls procedure

def myfunction[]:
    print["Hello World"]

48, passing

def myfunction[]:
    print["Hello World"]

30 as an argument.

Dòng 15: Ban đầu gán
def myfunction[]: print["Hello World"]
30 Giá trị
myfunction[]
04. Inside

def myfunction[]:
    print["Hello World"]

48, the

myfunction[]

00 statement shows that the corresponding parameter

myfunction[]

09 is initially

myfunction[]

04, the value passed in.

Dòng 17: Sau đó, nó gọi thủ tục
def myfunction[]: print["Hello World"]
48, vượt qua
def myfunction[]: print["Hello World"]
30 như một đối số.

myfunction[]

09 is then assigned the value

myfunction[]

12.

Dòng 5: Bên trong
def myfunction[]: print["Hello World"]
48, câu lệnh
myfunction[]
00 cho thấy tham số tương ứng
myfunction[]
09 ban đầu là
myfunction[]
04, giá trị được truyền vào. This value is verified by this
```
myfunction[]
```
00 statement executed just before
```
def myfunction[]:
    print["Hello World"]
```
48 exits.
Dòng 6:
myfunction[]
09 sau đó được gán giá trị
myfunction[]
12. Back in the calling environment of the main program, this
```
myfunction[]
```
00 statement shows that after
```
def myfunction[]:
    print["Hello World"]
```
48 returns,
```
def myfunction[]:
    print["Hello World"]
```
30 is still
```
myfunction[]
```
04, as it was prior to the procedure call.

Dòng 7: Giá trị này được xác minh bằng câu lệnh

myfunction[]

00 này được thực hiện ngay trước khi

def myfunction[]:
    print["Hello World"]

48 thoát.

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

Dòng 18: Quay lại môi trường gọi của chương trình chính, tuyên bố

myfunction[]

00 này cho thấy rằng sau khi trả về

def myfunction[]:
    print["Hello World"]

48,

def myfunction[]:
    print["Hello World"]

30 vẫn là

myfunction[]

04, vì trước khi gọi thủ tục.passed by value, so

def myfunction[]:
    print["Hello World"]

48 receives only a copy. When the corresponding parameter

myfunction[]

09 is modified,

def myfunction[]:
    print["Hello World"]

30 is unaffected.

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

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

Trong ví dụ này,

def myfunction[]:
    print["Hello World"]

30 được truyền theo giá trị, do đó

def myfunction[]:
    print["Hello World"]

48 chỉ nhận được một bản sao. Khi tham số tương ứng

myfunction[]

09 được sửa đổi,

def myfunction[]:
    print["Hello World"]

30 không bị ảnh hưởng.passed by reference. Changes made to the corresponding parameter

myfunction[]

09 will also modify the argument in the calling environment.

Bây giờ, so sánh điều này với ví dụ tiếp theo:

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

Mã này giống hệt với ví dụ đầu tiên, với một thay đổi. Nó có sự hiện diện của từ

myfunction[]

23 phía trước

myfunction[]

09 trong định nghĩa về thủ tục

def myfunction[]:
    print["Hello World"]

48 trên dòng 3. Điều đó chỉ ra rằng đối số cho

def myfunction[]:
    print["Hello World"]

48 được truyền qua tham chiếu. Các thay đổi được thực hiện cho tham số tương ứng

myfunction[]

09 cũng sẽ sửa đổi đối số trong môi trường gọi.

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

Một lần nữa,
myfunction[]
09 được gán giá trị
myfunction[]
12 bên trong
def myfunction[]: print["Hello World"]
48 như trước. Nhưng lần này, khi
def myfunction[]: print["Hello World"]
48 trở lại,
def myfunction[]: print["Hello World"]
30 trong chương trình chính cũng đã được sửa đổi. then the function has a copy to work on, but it can’t modify the original value in the calling environment.
Trong nhiều ngôn ngữ lập trình, về cơ bản, sự khác biệt giữa các ngôn ngữ qua từng giá trị và tham chiếu vượt qua: then any changes the function makes to the corresponding parameter will affect the value in the calling environment.

Nếu một biến được truyền theo giá trị, thì hàm có một bản sao để hoạt động, nhưng nó có thể sửa đổi giá trị ban đầu trong môi trường gọi.reference means in these languages. Variable values are stored in memory. In Pascal and similar languages, a reference is essentially the address of that memory location, as demonstrated below:

Nếu một biến được truyền qua tham chiếu, thì bất kỳ thay đổi nào mà hàm thực hiện đối với tham số tương ứng sẽ ảnh hưởng đến giá trị trong môi trường gọi.passed by value, so memory for the corresponding parameter

myfunction[]

09 is allocated in the namespace of

def myfunction[]:
    print["Hello World"]

48, and the value of

def myfunction[]:
    print["Hello World"]

30 is copied there. When

def myfunction[]:
    print["Hello World"]

48 modifies

myfunction[]

09, it’s this local copy that is changed. The value of

def myfunction[]:
    print["Hello World"]

30 in the calling environment remains unaffected.

Trong sơ đồ bên phải,

def myfunction[]:
    print["Hello World"]

30 được truyền qua tham chiếu. Tham số tương ứng

myfunction[]

09 điểm vào địa chỉ thực trong không gian tên chương trình chính trong đó giá trị của

def myfunction[]:
    print["Hello World"]

30 được lưu trữ. Khi

def myfunction[]:
    print["Hello World"]

48 sửa đổi

myfunction[]

09, nó sẽ sửa đổi giá trị ở vị trí đó, giống như khi chương trình chính đang sửa đổi chính

def myfunction[]:
    print["Hello World"]

30.passed by reference. The corresponding parameter

myfunction[]

09 points to the actual address in the main program’s namespace where the value of

def myfunction[]:
    print["Hello World"]

30 is stored. When

def myfunction[]:
    print["Hello World"]

48 modifies

myfunction[]

09, it’s modifying the value in that location, just the same as if the main program were modifying

def myfunction[]:
    print["Hello World"]

30 itself.

By-by-giá trị vs Pass-Ty-Ttef

Các tham số trong Python Pass-By-Value hoặc Pass-Ttefer? Câu trả lời là họ cũng không, chính xác. Điều đó bởi vì một tài liệu tham khảo không có nghĩa là điều tương tự trong Python như ở Pascal.

Hãy nhớ lại rằng trong Python, mỗi phần dữ liệu là một đối tượng. Một tham chiếu trỏ đến một đối tượng, không phải là một vị trí bộ nhớ cụ thể. Điều đó có nghĩa là sự phân công được giải thích theo cách tương tự trong Python như ở Pascal. Hãy xem xét cặp tuyên bố sau đây trong Pascal:object. A reference points to an object, not a specific memory location. That means assignment isn’t interpreted the same way in Python as it is in Pascal. Consider the following pair of statements in Pascal:

Chúng được giải thích theo cách này:

Biến
def myfunction[]: print["Hello World"]
30 tham chiếu một vị trí bộ nhớ cụ thể. references a specific memory location.
Câu lệnh đầu tiên đặt giá trị
myfunction[]
04 ở vị trí đó. puts the value
```
myfunction[]
```
04 in that location.
Tuyên bố tiếp theo ghi đè lên
myfunction[]
04 và đặt
myfunction[]
12 ở đó thay thế. overwrites the
```
myfunction[]
```
04 and puts
```
myfunction[]
```
12 there instead.

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

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

Câu lệnh đầu tiên khiến
def myfunction[]: print["Hello World"]
30 trỏ đến một đối tượng có giá trị là
myfunction[]
04. causes
```
def myfunction[]:
    print["Hello World"]
```
30 to point to an object whose value is
```
myfunction[]
```
04.
Tuyên bố tiếp theo gán lại
def myfunction[]: print["Hello World"]
30 là một tham chiếu mới cho một đối tượng khác có giá trị là
myfunction[]
12. Đã nêu một cách khác, bài tập thứ hai
def myfunction[]: print["Hello World"]
30 cho một đối tượng khác với giá trị
myfunction[]
12. reassigns
```
def myfunction[]:
    print["Hello World"]
```
30 as a new reference to a different object whose value is
```
myfunction[]
```
12. Stated another way, the second assignment rebinds
```
def myfunction[]:
    print["Hello World"]
```
30 to a different object with value
```
myfunction[]
```
12.

Trong Python, khi bạn chuyển một đối số cho một chức năng, một sự phản hồi tương tự xảy ra. Xem xét ví dụ này:rebinding occurs. Consider this example:

>>>

def functionName[arg1, arg2]:
    # What to do with function

Trong chương trình chính, câu lệnh

myfunction[]

58 trên dòng 4 tạo ra một tham chiếu có tên

def myfunction[]:
    print["Hello World"]

30 bị ràng buộc với một đối tượng có giá trị là

myfunction[]

04.

def myfunction[]:
    print["Hello World"]

48 sau đó được gọi trên dòng 5, với

def myfunction[]:
    print["Hello World"]

30 như một đối số. Khi

def myfunction[]:
    print["Hello World"]

48 bắt đầu lần đầu tiên, một tham chiếu mới có tên

myfunction[]

09 được tạo, ban đầu chỉ vào cùng một đối tượng

myfunction[]

04 như

def myfunction[]:
    print["Hello World"]

30 không:

Tuy nhiên, khi câu lệnh

myfunction[]

67 trên dòng 2 được thực thi,

def myfunction[]:
    print["Hello World"]

48 REBINDS

myfunction[]

09 cho một đối tượng mới có giá trị là

myfunction[]

12. Hai tài liệu tham khảo,

def myfunction[]:
    print["Hello World"]

30 và

myfunction[]

09, được tách rời nhau. Không có gì khác mà

def myfunction[]:
    print["Hello World"]

48 sẽ ảnh hưởng đến

def myfunction[]:
    print["Hello World"]

30 và khi

def myfunction[]:
    print["Hello World"]

48 chấm dứt,

def myfunction[]:
    print["Hello World"]

30 vẫn sẽ chỉ vào đối tượng

myfunction[]

04, như trước khi gọi chức năng:rebinds

myfunction[]

09 to a new object whose value is

myfunction[]

12. The two references,

def myfunction[]:
    print["Hello World"]

30 and

myfunction[]

09, are uncoupled from one another. Nothing else that

def myfunction[]:
    print["Hello World"]

48 does will affect

def myfunction[]:
    print["Hello World"]

30, and when

def myfunction[]:
    print["Hello World"]

48 terminates,

def myfunction[]:
    print["Hello World"]

30 will still point to the object

myfunction[]

04, as it did prior to the function call:

Bạn có thể xác nhận tất cả điều này bằng cách sử dụng

def myfunction[]:
    print["Hello World"]

33. Ở đây, một phiên bản tăng cường một chút của ví dụ trên hiển thị các định danh số của các đối tượng liên quan:

>>>

def functionName[arg1, arg2]:
    # What to do with function

Trong chương trình chính, câu lệnh

myfunction[]

58 trên dòng 4 tạo ra một tham chiếu có tên

def myfunction[]:
    print["Hello World"]

30 bị ràng buộc với một đối tượng có giá trị là

myfunction[]

04.

def myfunction[]:
    print["Hello World"]

48 sau đó được gọi trên dòng 5, với

def myfunction[]:
    print["Hello World"]

30 như một đối số. Khi

def myfunction[]:
    print["Hello World"]

48 bắt đầu lần đầu tiên, một tham chiếu mới có tên

myfunction[]

09 được tạo, ban đầu chỉ vào cùng một đối tượng

myfunction[]

04 như

def myfunction[]:
    print["Hello World"]

30 không:

Tuy nhiên, khi câu lệnh

myfunction[]

67 trên dòng 2 được thực thi,

def myfunction[]:
    print["Hello World"]

48 REBINDS

myfunction[]

09 cho một đối tượng mới có giá trị là

myfunction[]

12. Hai tài liệu tham khảo,

def myfunction[]:
    print["Hello World"]

30 và

myfunction[]

09, được tách rời nhau. Không có gì khác mà

def myfunction[]:
    print["Hello World"]

48 sẽ ảnh hưởng đến

def myfunction[]:
    print["Hello World"]

30 và khi

def myfunction[]:
    print["Hello World"]

48 chấm dứt,

def myfunction[]:
    print["Hello World"]

30 vẫn sẽ chỉ vào đối tượng

myfunction[]

04, như trước khi gọi chức năng:

Bạn có thể xác nhận tất cả điều này bằng cách sử dụng

def myfunction[]:
    print["Hello World"]

33. Ở đây, một phiên bản tăng cường một chút của ví dụ trên hiển thị các định danh số của các đối tượng liên quan:

>>>

def functionName[arg1, arg2]:
    # What to do with function

Trong chương trình chính, câu lệnh

myfunction[]

58 trên dòng 4 tạo ra một tham chiếu có tên

def myfunction[]:
    print["Hello World"]

30 bị ràng buộc với một đối tượng có giá trị là

myfunction[]

04.

def myfunction[]:
    print["Hello World"]

48 sau đó được gọi trên dòng 5, với

def myfunction[]:
    print["Hello World"]

30 như một đối số. Khi

def myfunction[]:
    print["Hello World"]

48 bắt đầu lần đầu tiên, một tham chiếu mới có tên

myfunction[]

09 được tạo, ban đầu chỉ vào cùng một đối tượng

myfunction[]

04 như

def myfunction[]:
    print["Hello World"]

30 không:rebound, and the connection to the original object is lost.

Tuy nhiên, khi câu lệnh

myfunction[]

67 trên dòng 2 được thực thi,

def myfunction[]:
    print["Hello World"]

48 REBINDS

myfunction[]

09 cho một đối tượng mới có giá trị là

myfunction[]

12. Hai tài liệu tham khảo,

def myfunction[]:
    print["Hello World"]

30 và

myfunction[]

09, được tách rời nhau. Không có gì khác mà

def myfunction[]:
    print["Hello World"]

48 sẽ ảnh hưởng đến

def myfunction[]:
    print["Hello World"]

30 và khi

def myfunction[]:
    print["Hello World"]

48 chấm dứt,

def myfunction[]:
    print["Hello World"]

30 vẫn sẽ chỉ vào đối tượng

myfunction[]

04, như trước khi gọi chức năng:

>>>

def functionName[arg1, arg2]:
    # What to do with function

Trong chương trình chính, câu lệnh

myfunction[]

58 trên dòng 4 tạo ra một tham chiếu có tên

def myfunction[]:
    print["Hello World"]

30 bị ràng buộc với một đối tượng có giá trị là

myfunction[]

04.

def myfunction[]:
    print["Hello World"]

48 sau đó được gọi trên dòng 5, với

def myfunction[]:
    print["Hello World"]

30 như một đối số. Khi

def myfunction[]:
    print["Hello World"]

48 bắt đầu lần đầu tiên, một tham chiếu mới có tên

myfunction[]

09 được tạo, ban đầu chỉ vào cùng một đối tượng

myfunction[]

04 như

def myfunction[]:
    print["Hello World"]

30 không:

Tuy nhiên, khi câu lệnh

myfunction[]

67 trên dòng 2 được thực thi,

def myfunction[]:
    print["Hello World"]

48 REBINDS

myfunction[]

09 cho một đối tượng mới có giá trị là

myfunction[]

12. Hai tài liệu tham khảo,

def myfunction[]:
    print["Hello World"]

30 và

myfunction[]

09, được tách rời nhau. Không có gì khác mà

def myfunction[]:
    print["Hello World"]

48 sẽ ảnh hưởng đến

def myfunction[]:
    print["Hello World"]

30 và khi

def myfunction[]:
    print["Hello World"]

48 chấm dứt,

def myfunction[]:
    print["Hello World"]

30 vẫn sẽ chỉ vào đối tượng

myfunction[]

04, như trước khi gọi chức năng:

>>>

def functionName[arg1, arg2]:
    # What to do with function

Ở đây,

def myfunction[]:
    print["Hello World"]

48 sử dụng

def myfunction[]:
    print["Hello World"]

30 làm tài liệu tham khảo để thực hiện thay đổi bên trong

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

12. Sự thay đổi đó được phản ánh trong môi trường gọi sau khi

def myfunction[]:
    print["Hello World"]

48 trả về.

Đối số thông qua tóm tắt

Đối số thông qua trong Python có thể được tóm tắt như sau. Vượt qua một đối tượng bất biến, như

myfunction[]

89,

myfunction[]

92,

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

16 hoặc

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

17, cho chức năng Python hoạt động như giá trị qua. Hàm có thể sửa đổi đối tượng trong môi trường gọi.Passing an immutable object, like an

myfunction[]

89,

myfunction[]

92,

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

16, or

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

17, to a Python function acts like pass-by-value. The function can’t modify the object in the calling environment.

Vượt qua một đối tượng có thể thay đổi, chẳng hạn như

myfunction[]

93,
myfunction[]
90 hoặc
myfunction[]
91 hoạt động phần nào nhưng không chính xác như một sự tham khảo. Chức năng có thể gán lại việc bán buôn đối tượng, nhưng nó có thể thay đổi các mục tại chỗ trong đối tượng và những thay đổi này sẽ được phản ánh trong môi trường gọi. such as a

myfunction[]

93,

myfunction[]

90, or

myfunction[]

91 acts somewhat—but not exactly—like pass-by-reference. The function can’t reassign the object wholesale, but it can change items in place within the object, and these changes will be reflected in the calling environment.

Phản ứng phụ

Vì vậy, trong Python, bạn có thể sửa đổi một đối số từ trong một hàm để sự thay đổi được phản ánh trong môi trường gọi. Nhưng bạn có nên làm điều này không? Đây là một ví dụ về những gì mà người ta đề cập trong Lập trình Lingo là một tác dụng phụ.side effect.

Tổng quát hơn, một chức năng Python được cho là gây ra tác dụng phụ nếu nó sửa đổi môi trường gọi của nó theo bất kỳ cách nào. Thay đổi giá trị của một đối số chức năng chỉ là một trong những khả năng.

Khi họ bị ẩn hoặc bất ngờ, các tác dụng phụ có thể dẫn đến các lỗi chương trình rất khó theo dõi. Nói chung, nó tốt nhất để tránh chúng.

Tuyên bố

def myfunction[]:
    print["Hello World"]

Những gì một chức năng Python để làm sau đó? Rốt cuộc, trong nhiều trường hợp, nếu một hàm không gây ra một số thay đổi trong môi trường gọi, thì có rất nhiều điểm trong việc gọi nó. Làm thế nào một chức năng ảnh hưởng đến người gọi của nó?

Vâng, một khả năng là sử dụng các giá trị trả về chức năng. Một câu lệnh

def myfunction[]:
    print["Hello World"]

22 trong hàm Python phục vụ hai mục đích:function return values. A

def myfunction[]:
    print["Hello World"]

22 statement in a Python function serves two purposes:

Nó ngay lập tức chấm dứt chức năng và chuyển kiểm soát thực thi trở lại cho người gọi.
Nó cung cấp một cơ chế mà chức năng có thể chuyển dữ liệu trở lại cho người gọi.

Thoát một chức năng

Trong một hàm, câu lệnh

def myfunction[]:
    print["Hello World"]

22 gây ra thoát ngay lập tức khỏi hàm Python và chuyển thực thi lại cho người gọi:

>>>

def functionName[arg1, arg2]:
    # What to do with function

Trong ví dụ này, tuyên bố

def myfunction[]:
    print["Hello World"]

22 thực sự là thừa. Một chức năng sẽ trở lại với người gọi khi nó rơi ra khỏi phần cuối, đó là, sau khi câu lệnh cuối cùng của cơ thể chức năng được thực thi. Vì vậy, chức năng này sẽ hoạt động giống hệt nhau mà không có câu lệnh

def myfunction[]:
    print["Hello World"]

22.falls off the end—that is, after the last statement of the function body is executed. So, this function would behave identically without the

def myfunction[]:
    print["Hello World"]

22 statement.

Tuy nhiên, các tuyên bố

def myfunction[]:
    print["Hello World"]

22 don don cần phải ở cuối chức năng. Chúng có thể xuất hiện bất cứ nơi nào trong một cơ thể chức năng, và thậm chí nhiều lần. Xem xét ví dụ này:

>>>

def functionName[arg1, arg2]:
    # What to do with function

Hai cuộc gọi đầu tiên đến

def myfunction[]:
    print["Hello World"]

48 don lồng gây ra bất kỳ đầu ra nào, bởi vì câu lệnh

def myfunction[]:
    print["Hello World"]

22 được thực thi và chức năng thoát ra sớm, trước khi đạt được câu lệnh

def myfunction[]:
    print["Hello World"]

60 trên dòng 6.

Loại mô hình này có thể hữu ích để kiểm tra lỗi trong một hàm. Bạn có thể kiểm tra một số điều kiện lỗi khi bắt đầu chức năng, với các câu lệnh

def myfunction[]:
    print["Hello World"]

22 được bảo lãnh nếu có vấn đề:error checking in a function. You can check several error conditions at the start of the function, with

def myfunction[]:
    print["Hello World"]

22 statements that bail out if there’s a problem:

def functionName[arg1, arg2]:
    # What to do with function

Nếu không gặp phải điều kiện lỗi nào, thì chức năng có thể tiến hành xử lý bình thường.

Trả lại dữ liệu cho người gọi

Ngoài việc thoát một hàm, câu lệnh

def myfunction[]:
    print["Hello World"]

22 cũng được sử dụng để chuyển dữ liệu trở lại cho người gọi. Nếu câu lệnh

def myfunction[]:
    print["Hello World"]

22 bên trong hàm python được theo sau bởi một biểu thức, thì trong môi trường gọi, thì gọi gọi sẽ đánh giá giá trị của biểu thức đó:pass data back to the caller. If a

def myfunction[]:
    print["Hello World"]

22 statement inside a Python function is followed by an expression, then in the calling environment, the function call evaluates to the value of that expression:

>>>

def functionName[arg1, arg2]:
    # What to do with function

Ở đây, giá trị của biểu thức

def myfunction[]:
    print["Hello World"]

48 trên dòng 5 là

myfunction[]

96, sau đó được gán cho biến

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

35.

Một hàm có thể trả về bất kỳ loại đối tượng. Trong Python, điều đó có nghĩa là khá nhiều bất cứ điều gì. Trong môi trường gọi, cuộc gọi chức năng có thể được sử dụng theo cách cú pháp theo bất kỳ cách nào có ý nghĩa đối với loại đối tượng mà hàm trả về.object. In Python, that means pretty much anything whatsoever. In the calling environment, the function call can be used syntactically in any way that makes sense for the type of object the function returns.

Ví dụ: trong mã này,

def myfunction[]:
    print["Hello World"]

48 trả về từ điển. Trong môi trường gọi sau đó, biểu thức

def myfunction[]:
    print["Hello World"]

48 đại diện cho một từ điển và

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

38 là một tham chiếu chính hợp lệ vào từ điển đó:

>>>

def functionName[arg1, arg2]:
    # What to do with function

Trong ví dụ tiếp theo,

def myfunction[]:
    print["Hello World"]

48 trả về một chuỗi mà bạn có thể cắt như bất kỳ chuỗi nào khác:

>>>

functionName[valueForArg1, valueForArg2]

Ở đây,

def myfunction[]:
    print["Hello World"]

48 Trả về một danh sách có thể được lập chỉ mục hoặc cắt lát:

>>>

functionName[valueForArg1, valueForArg2]

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

def myfunction[]:
    print["Hello World"]

22, thì chúng đã đóng gói và trả về dưới dạng một bộ thuật:

>>>

functionName[valueForArg1, valueForArg2]

Khi không có giá trị trả về, hàm Python trả về giá trị Python đặc biệt

def myfunction[]:
    print["Hello World"]

95:

>>>

functionName[valueForArg1, valueForArg2]

Điều tương tự cũng xảy ra nếu cơ thể chức năng không chứa câu lệnh

def myfunction[]:
    print["Hello World"]

22 và chức năng rơi ra khỏi cuối:

>>>

functionName[valueForArg1, valueForArg2]

Hãy nhớ lại rằng

def myfunction[]:
    print["Hello World"]

95 là giả khi được đánh giá trong bối cảnh Boolean.

Vì các chức năng thoát khỏi câu lệnh

def myfunction[]:
    print["Hello World"]

22 trần hoặc rơi ra khỏi trả về kết thúc

def myfunction[]:
    print["Hello World"]

95, một cuộc gọi đến một hàm như vậy có thể được sử dụng trong bối cảnh boolean:

>>>

functionName[valueForArg1, valueForArg2]

Ở đây, các cuộc gọi đến cả

def myfunction[]:
    print["Hello World"]

48 và

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

48 là giả, vì vậy

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

49 cũng vậy và mệnh đề

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

50 được thực thi.

Xem lại các tác dụng phụ

Giả sử bạn muốn viết một hàm có một đối số số nguyên và nhân đôi nó. Đó là, bạn muốn truyền một biến số nguyên cho hàm và khi hàm trở lại, giá trị của biến trong môi trường gọi phải gấp đôi so với. Trong Pascal, bạn có thể thực hiện điều này bằng cách sử dụng từng tham chiếu:

functionName[valueForArg1, valueForArg2]

Thực hiện mã này tạo ra đầu ra sau, xác minh rằng

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

51 thực sự sửa đổi

def myfunction[]:
    print["Hello World"]

30 trong môi trường gọi điện:

functionName[valueForArg1, valueForArg2]

Trong Python, công việc giành chiến thắng này. Như bạn đã biết, các số nguyên Python là bất biến, do đó, một hàm Python có thể thay đổi một đối số số nguyên theo tác dụng phụ:

>>>

functionName[valueForArg1, valueForArg2]

Ở đây, các cuộc gọi đến cả

def myfunction[]:
    print["Hello World"]

48 và

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

48 là giả, vì vậy

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

49 cũng vậy và mệnh đề

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

50 được thực thi.

>>>

functionName[valueForArg1, valueForArg2]

Ở đây, các cuộc gọi đến cả

def myfunction[]:
    print["Hello World"]

48 và

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

48 là giả, vì vậy

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

49 cũng vậy và mệnh đề

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

50 được thực thi.

Xem lại các tác dụng phụ

>>>

def addNum[num1, num2]:
    print[num1 + num2]
addNum[2, 4]

# Output: 6

Thực hiện mã này tạo ra đầu ra sau, xác minh rằng

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

51 thực sự sửa đổi

def myfunction[]:
    print["Hello World"]

30 trong môi trường gọi điện:

>>>

def addNum[num1, num2]:
    print[num1 + num2]
addNum[2, 4]

# Output: 6

Tuy nhiên, bạn có thể sử dụng giá trị trả về để có được hiệu ứng tương tự. Chỉ cần viết

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

51 để nó có một đối số số nguyên, nhân đôi nó và trả về giá trị nhân đôi. Sau đó, người gọi chịu trách nhiệm cho việc gán sửa đổi giá trị ban đầu:

Điều này được cho là thích hợp để sửa đổi bằng hiệu ứng phụ. Nó rất rõ ràng rằng

def myfunction[]:
    print["Hello World"]

30 đang được sửa đổi trong môi trường gọi vì người gọi đang tự làm như vậy. Dù sao đi nữa, đó là lựa chọn duy nhất, bởi vì sửa đổi theo hiệu ứng phụ không hoạt động trong trường hợp này.

>>>

def addNum[num1, num2]:
    print[num1 + num2]
addNum[2, 4]

# Output: 6

Tuy nhiên, ngay cả trong trường hợp có thể sửa đổi một đối số theo tác dụng phụ, sử dụng giá trị trả lại vẫn có thể rõ ràng hơn. Giả sử bạn muốn tăng gấp đôi mọi mục trong danh sách. Bởi vì các danh sách có thể thay đổi, bạn có thể xác định chức năng Python sửa đổi danh sách tại chỗ:

Không giống như

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

51 Trong ví dụ trước,

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

56 thực sự hoạt động như dự định. Nếu tài liệu cho chức năng nêu rõ rằng nội dung đối số danh sách được thay đổi, thì đây có thể là một triển khai hợp lý.

>>>

def addNum[num1, num2]:
    print[num1 + num2]
addNum[2, 4]

# Output: 6

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

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

56 để chuyển danh sách mong muốn trở lại bằng giá trị trả về và cho phép người gọi thực hiện bài tập, tương tự như cách

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

51 được viết lại trong ví dụ trước:

>>>

def addNum[num1, num2]:
    print[num1 + num2]
addNum[2, 4]

# Output: 6

Hoặc cách tiếp cận hoạt động tốt như nhau. Như thường lệ, đây là vấn đề của phong cách và sở thích cá nhân khác nhau. Tác dụng phụ aren nhất thiết phải hoàn thành cái ác, và chúng có vị trí của họ, nhưng vì hầu như mọi thứ đều có thể được trả lại từ một chức năng, điều tương tự thường có thể được thực hiện thông qua các giá trị trở lại.

def addNum[num1, num2]:
    print[num1 + num2]
addNum[2, 4]

# Output: 6

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

>>>

def addNum[num1, num2]:
    print[num1 + num2]
addNum[2, 4]

# Output: 6

Trong một số trường hợp, khi bạn xác định một chức năng, bạn có thể không biết trước đó có bao nhiêu đối số mà bạn sẽ muốn. Giả sử, ví dụ, bạn muốn viết một hàm Python tính toán trung bình của một số giá trị. Bạn có thể bắt đầu với một cái gì đó như thế này:

Tất cả đều tốt nếu bạn muốn trung bình ba giá trị:

>>>

def addNum[num1, num2]:
    print[num1 + num2]
addNum[2, 4]

# Output: 6

Tuy nhiên, như bạn đã thấy, khi các đối số vị trí được sử dụng, số lượng đối số được thông qua phải đồng ý với số lượng tham số được khai báo. Rõ ràng sau đó, tất cả đều không tốt với việc triển khai

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

59 này cho bất kỳ số lượng giá trị nào khác ngoài ba:

>>>

def addNum[num1, num2]:
    print[num1 + num2]
addNum[2, 4]

# Output: 6

Bạn có thể cố gắng xác định

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

59 với các tham số tùy chọn:

Điều này cho phép một số lượng khác nhau được chỉ định. Các cuộc gọi sau ít nhất là chính xác về mặt cú pháp:

Nhưng cách tiếp cận này vẫn phải chịu một vài vấn đề. Đối với người mới bắt đầu, nó vẫn chỉ cho phép tối đa năm đối số, không phải là một số tùy ý. Tệ hơn nữa, không có cách nào để phân biệt giữa các đối số được chỉ định và các đối số được phép mặc định. Chức năng không có cách nào để biết có bao nhiêu đối số đã được thông qua, vì vậy nó không biết những gì cần chia cho:

Khi một tên tham số trong định nghĩa hàm python được đi trước bởi dấu hoa thị [

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

62], nó chỉ ra việc đóng gói đối số. Bất kỳ đối số tương ứng nào trong lệnh gọi hàm được đóng gói thành một bộ thuật mà hàm có thể đề cập đến tên tham số đã cho. Đây là một ví dụ:argument tuple packing. Any corresponding arguments in the function call are packed into a tuple that the function can refer to by the given parameter name. Here’s an example:

>>>

def addNum[num1, num2]:
    print[num1 + num2]
addNum[2, 4]

# Output: 6

Trong định nghĩa của

def myfunction[]:
    print["Hello World"]

48, đặc tả tham số

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

65 chỉ ra đóng gói tple. Trong mỗi cuộc gọi đến

def myfunction[]:
    print["Hello World"]

48, các đối số được đóng gói thành một bộ thuật mà hàm có thể đề cập đến tên

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

67. Bất kỳ tên nào cũng có thể được sử dụng, nhưng

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

67 thường được chọn đến mức nó thực tế là một tiêu chuẩn.

Sử dụng đóng gói Tuple, bạn có thể dọn dẹp

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

59 như thế này:

>>>

def multiplyNum[num1]:
    return num1 * 8

result = multiplyNum[8]
print[result]

# Output: 64

Trong định nghĩa của

def myfunction[]:
    print["Hello World"]

48, đặc tả tham số

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

65 chỉ ra đóng gói tple. Trong mỗi cuộc gọi đến

def myfunction[]:
    print["Hello World"]

48, các đối số được đóng gói thành một bộ thuật mà hàm có thể đề cập đến tên

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

67. Bất kỳ tên nào cũng có thể được sử dụng, nhưng

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

67 thường được chọn đến mức nó thực tế là một tiêu chuẩn.

>>>

def multiplyNum[num1]:
    return num1 * 8

result = multiplyNum[8]
print[result]

# Output: 64

Trong định nghĩa của

def myfunction[]:
    print["Hello World"]

48, đặc tả tham số

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

65 chỉ ra đóng gói tple. Trong mỗi cuộc gọi đến

def myfunction[]:
    print["Hello World"]

48, các đối số được đóng gói thành một bộ thuật mà hàm có thể đề cập đến tên

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

67. Bất kỳ tên nào cũng có thể được sử dụng, nhưng

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

67 thường được chọn đến mức nó thực tế là một tiêu chuẩn.

Sử dụng đóng gói Tuple, bạn có thể dọn dẹp

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

59 như thế này:

>>>

def multiplyNum[num1]:
    return num1 * 8

result = multiplyNum[8]
print[result]

# Output: 64

Trong định nghĩa của

def myfunction[]:
    print["Hello World"]

48, đặc tả tham số

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

65 chỉ ra đóng gói tple. Trong mỗi cuộc gọi đến

def myfunction[]:
    print["Hello World"]

48, các đối số được đóng gói thành một bộ thuật mà hàm có thể đề cập đến tên

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

67. Bất kỳ tên nào cũng có thể được sử dụng, nhưng

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

67 thường được chọn đến mức nó thực tế là một tiêu chuẩn.

Sử dụng đóng gói Tuple, bạn có thể dọn dẹp

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

59 như thế này:

Tốt hơn hết, bạn có thể dọn dẹp nó hơn nữa bằng cách thay thế vòng lặp

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

70 bằng hàm Python tích hợp

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

71, tổng hợp các giá trị số trong bất kỳ điều kiện nào:unpacked and passed to the function as separate values:

>>>

def multiplyNum[num1]:
    return num1 * 8

result = multiplyNum[8]
print[result]

# Output: 64

Bây giờ,

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

59 được viết chính xác và hoạt động như dự định.

Tuy nhiên, tùy thuộc vào cách sử dụng mã này, vẫn có thể có việc phải làm. Như đã viết,

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

59 sẽ tạo ra một ngoại lệ

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

74 nếu bất kỳ đối số nào không phải là số lượng:tuple unpacking, it doesn’t only work with tuples. The asterisk [

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

62] operator can be applied to any iterable in a Python function call. For example, a list or set can be unpacked as well:

>>>

def multiplyNum[num1]:
    return num1 * 8

result = multiplyNum[8]
print[result]

# Output: 64

Để mạnh mẽ nhất có thể, bạn nên thêm mã để kiểm tra xem các đối số thuộc loại thích hợp. Sau đó trong loạt bài hướng dẫn này, bạn sẽ học cách bắt các ngoại lệ như

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

74 và xử lý chúng một cách thích hợp. Bạn cũng có thể kiểm tra các ngoại lệ Python: Giới thiệu.

>>>

def multiplyNum[num1]:
    return num1 * 8

result = multiplyNum[8]
print[result]

# Output: 64

Đối số tuple giải nén

Một hoạt động tương tự có sẵn ở phía bên kia của phương trình trong một cuộc gọi hàm Python. Khi một đối số trong một cuộc gọi hàm được đi trước bởi dấu hoa thị [

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

62], nó chỉ ra rằng đối số là một tuple nên được giải nén và truyền cho hàm dưới dạng các giá trị riêng biệt:

Trong ví dụ này,

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

77 trong lệnh gọi hàm chỉ ra rằng

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

78 là một tuple cần được giải nén. Các giá trị chưa đóng gói

myfunction[]

96,

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

80 và

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

81 được gán cho các tham số

def myfunction[]:
    print["Hello World"]

30,

def myfunction[]:
    print["Hello World"]

31 và

def myfunction[]:
    print["Hello World"]

32, tương ứng.dictionary packing and unpacking. Preceding a parameter in a Python function definition by a double asterisk [

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

91] indicates that the corresponding arguments, which are expected to be

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

93 pairs, should be packed into a dictionary:

>>>

def multiplyNum[num1]:
    return num1 * 8

result = multiplyNum[8]
print[result]

# Output: 64

Mặc dù loại giải nén này được gọi là Tuple giải nén, nhưng nó không chỉ hoạt động với các bộ dữ liệu. Toán tử Asterisk [

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

62] có thể được áp dụng cho bất kỳ điều đáng thể nào trong một cuộc gọi chức năng Python. Ví dụ, một danh sách hoặc bộ cũng có thể được giải nén:keyword args] is nearly standard. You don’t have to adhere to it, but if you do, then anyone familiar with Python coding conventions will know straightaway what you mean.

Bạn thậm chí có thể sử dụng đóng gói Tuple và giải nén cùng một lúc:

Ở đây,

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

86 chỉ ra rằng danh sách
def subtractNum[]: print[34 - 4] subtractNum[] # Output: 30
87 nên được giải nén và các mục được chuyển đến
def myfunction[]: print["Hello World"]
48 dưới dạng các giá trị riêng lẻ. Thông số kỹ thuật tham số
def subtractNum[]: print[34 - 4] subtractNum[] # Output: 30
65 làm cho các giá trị được đóng gói sao lưu vào tuple
def subtractNum[]: print[34 - 4] subtractNum[] # Output: 30
67. is analogous to argument tuple unpacking. When the double asterisk [

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

91] precedes an argument in a Python function call, it specifies that the argument is a dictionary that should be unpacked, with the resulting items passed to the function as keyword arguments:

>>>

def multiplyNum[num1]:
    return num1 * 8

result = multiplyNum[8]
print[result]

# Output: 64

Đối số đóng gói từ điển

>>>

def multiplyNum[num1]:
    return num1 * 8

result = multiplyNum[8]
print[result]

# Output: 64

Python có một toán tử tương tự, dấu hoa thị kép [

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

91], có thể được sử dụng với các tham số chức năng Python và các đối số để chỉ định đóng gói từ điển và giải nén. Trước một tham số trong định nghĩa hàm python bằng dấu hoa thị kép [

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

91] chỉ ra rằng các đối số tương ứng, dự kiến sẽ là các cặp ____393, nên được đóng gói vào từ điển:

>>>

def multiplyNum[num1]:
    return num1 * 8

result = multiplyNum[8]
print[result]

# Output: 64

Trong trường hợp này, các đối số

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

94,

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

95 và

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

96 được đóng gói vào một từ điển mà hàm có thể tham chiếu theo tên

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

97. Một lần nữa, bất kỳ tên nào cũng có thể được sử dụng, nhưng đặc thù

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

97 [viết tắt của từ khóa Args] là gần như tiêu chuẩn. Bạn không cần phải tuân thủ nó, nhưng nếu bạn làm, thì bất kỳ ai quen thuộc với các quy ước mã hóa Python sẽ biết ngay ý nghĩa của bạn.

Từ điển tranh luận Giải nén

Từ điển đối số Giải nén là tương tự như đối số giải nén. Khi dấu hoa thị kép [

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

91] đi 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 nên được giải nén, với các mục kết quả được chuyển đến hàm làm đối số từ khóa:

Các mục trong Từ điển

def functionName[arg1, arg2]:
    # What to do with function

00 được giải nén và được chuyển đến

def myfunction[]:
    print["Hello World"]

48 dưới dạng đối số từ khóa. Vì vậy,

def functionName[arg1, arg2]:
    # What to do with function

02 tương đương với

def functionName[arg1, arg2]:
    # What to do with function

03:

>>>

>>> s = 'foobar'
>>> id[s]
56313440

Trong thực tế, hãy kiểm tra điều này:

Nhiều gói trong một cuộc gọi chức năng Python

Python phiên bản 3.5 đã giới thiệu hỗ trợ cho việc giải nén bổ sung, như được nêu trong PEP 448. Một điều mà các cải tiến này cho phép là nhiều lần giải nén trong một cuộc gọi chức năng Python duy nhất:multiple unpackings in a single Python function call:

>>>

>>> s = 'foobar'
>>> id[s]
56313440

Bạn cũng có thể chỉ định nhiều bộ phận từ điển trong cuộc gọi chức năng Python:

>>>

Bạn cũng có thể chỉ định nhiều bộ phận từ điển trong cuộc gọi chức năng Python:

>>> s = 'foobar'
>>> id[s]
56313440

>>>

>>> s = 'foobar'
>>> id[s]
56313440

Bạn cũng có thể chỉ định nhiều bộ phận từ điển trong cuộc gọi chức năng Python:

>>> s = 'foobar'
>>> id[s]
56313440

Nhân tiện, các toán tử giải nén

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

62 và

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

91 don don chỉ áp dụng cho các biến, như trong các ví dụ trên. Bạn cũng có thể sử dụng chúng với các chữ có thể hiểu được:keyword-only arguments. These are function arguments that must be specified by keyword. Let’s explore a situation where this might be beneficial.

Ở đây, các danh sách theo nghĩa đen

def functionName[arg1, arg2]:
    # What to do with function

13 và

def functionName[arg1, arg2]:
    # What to do with function

14 được chỉ định để giải nén tple và từ điển theo nghĩa đen

def functionName[arg1, arg2]:
    # What to do with function

15 và

def functionName[arg1, arg2]:
    # What to do with function

16 được chỉ định để giải nén từ điển.

>>>

>>> s = 'foobar'
>>> id[s]
56313440

Bạn cũng có thể chỉ định nhiều bộ phận từ điển trong cuộc gọi chức năng Python:

>>>

>>> s = 'foobar'
>>> id[s]
56313440

Bạn cũng có thể chỉ định nhiều bộ phận từ điển trong cuộc gọi chức năng Python:

```
>>> s = 'foobar'
>>> id[s]
56313440
```
2
Nhân tiện, các toán tử giải nén
```
def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30
```
62 và
```
def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30
```
91 don don chỉ áp dụng cho các biến, như trong các ví dụ trên. Bạn cũng có thể sử dụng chúng với các chữ có thể hiểu được:

Ở đây, các danh sách theo nghĩa đen

def functionName[arg1, arg2]:
    # What to do with function

13 và

def functionName[arg1, arg2]:
    # What to do with function

14 được chỉ định để giải nén tple và từ điển theo nghĩa đen

def functionName[arg1, arg2]:
    # What to do with function

15 và

def functionName[arg1, arg2]:
    # What to do with function

16 được chỉ định để giải nén từ điển.

>>>

>>> s = 'foobar'
>>> id[s]
56313440

Bạn cũng có thể chỉ định nhiều bộ phận từ điển trong cuộc gọi chức năng Python:positional parameter, so the interpreter assumes that the first argument specified in the function call is the intended output prefix. This means there isn’t any way to omit it and obtain the default value:

>>>

>>> s = 'foobar'
>>> id[s]
56313440

Bạn cũng có thể chỉ định nhiều bộ phận từ điển trong cuộc gọi chức năng Python:

>>>

>>> s = 'foobar'
>>> id[s]
56313440

>>> s = 'foobar'
>>> id[s]
56313440

Nhân tiện, các toán tử giải nén

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

62 và

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

91 don don chỉ áp dụng cho các biến, như trong các ví dụ trên. Bạn cũng có thể sử dụng chúng với các chữ có thể hiểu được:

>>>

>>> s = 'foobar'
>>> id[s]
56313440

Ở đây, các danh sách theo nghĩa đen

def functionName[arg1, arg2]:
    # What to do with function

13 và

def functionName[arg1, arg2]:
    # What to do with function

14 được chỉ định để giải nén tple và từ điển theo nghĩa đen

def functionName[arg1, arg2]:
    # What to do with function

15 và

def functionName[arg1, arg2]:
    # What to do with function

16 được chỉ định để giải nén từ điển.

Đối số chỉ từ khóa help solve this dilemma. In the function definition, specify

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

65 to indicate a variable number of positional arguments, and then specify

def functionName[arg1, arg2]:
    # What to do with function

19 after that:

>>>

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

Một hàm Python trong phiên bản 3.x có thể được xác định để nó có các đối số chỉ có từ khóa. Đây là các đối số chức năng phải được chỉ định bởi từ khóa. Hãy để khám phá một tình huống mà điều này có thể có lợi.

>>>

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

Giả sử bạn muốn viết một hàm Python có một số lượng các đối số chuỗi khác nhau, kết hợp chúng với nhau được phân tách bằng một dấu chấm [

def functionName[arg1, arg2]:
    # What to do with function

17] và in chúng vào bảng điều khiển. Một cái gì đó như thế này sẽ làm để bắt đầu:

Khi nó đứng, tiền tố đầu ra được mã hóa cứng cho chuỗi

def functionName[arg1, arg2]:
    # What to do with function

18. Điều gì sẽ xảy ra nếu bạn muốn sửa đổi chức năng để chấp nhận điều này như một đối số, vì vậy người dùng có thể chỉ định một cái gì đó khác? Đây là một khả năng:options as keyword arguments. If you wanted to modify

def functionName[arg1, arg2]:
    # What to do with function

29 so that the separator character can optionally be specified as well, then you could add an additional keyword-only argument:

>>>

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

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

>>>

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

Chuỗi

def functionName[arg1, arg2]:
    # What to do with function

19 được gộp lại cùng với các chuỗi được nối. Chỉ cần nhìn vào cuộc gọi chức năng, rõ ràng là đối số đầu tiên được đối xử khác với phần còn lại. Để biết điều đó, bạn phải quay lại và xem xét định nghĩa chức năng.

>>>

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

def functionName[arg1, arg2]:
    # What to do with function

19 là tùy chọn. Nó luôn luôn phải được đưa vào, và ở đó, không có cách nào để giả định giá trị mặc định.

>>>

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

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

>>>

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

Thật không may, điều này không hoạt động khá đúng.

def functionName[arg1, arg2]:
    # What to do with function

19 là một tham số vị trí, do đó, trình thông dịch giả định rằng đối số đầu tiên được chỉ định trong lệnh gọi hàm là tiền tố đầu ra dự định. Điều này có nghĩa là không có cách nào để bỏ qua nó và có được giá trị mặc định:

>>>

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

Trong ví dụ này, đối số bổ sung không nên ở đó [như chính cuộc tranh luận đã thông báo]. Thay vì lặng lẽ thành công, nó thực sự sẽ dẫn đến một lỗi. Thực tế là nó không bị ràng buộc nhất. Tệ nhất, nó có thể gây ra một kết quả xuất hiện sai lệch:

Để khắc phục điều này, phiên bản 3 cho phép tham số đối số biến trong định nghĩa hàm Python chỉ là dấu hoa thị trần [

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

62], với tên bị bỏ qua:variable argument parameter in a Python function definition to be just a bare asterisk [

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

62], with the name omitted:

>>>

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

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

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

62 chỉ ra rằng không có bất kỳ tham số vị trí nào khác. Hành vi này tạo ra thông báo lỗi thích hợp nếu thêm các thông báo được chỉ định. Nó cho phép các tham số chỉ có từ khóa tuân theo.bare variable argument parameter
def subtractNum[]: print[34 - 4] subtractNum[] # Output: 30
62 indicates that there aren’t any more positional parameters. This behavior generates appropriate error messages if extra ones are specified. It allows keyword-only parameters to follow.

Đối số chỉ có vị trí

Kể từ Python 3.8, các tham số chức năng cũng có thể được khai báo chỉ là vị trí, có nghĩa là các đối số tương ứng phải được cung cấp vị trí và có thể được chỉ định bởi từ khóa.positional-only, meaning the corresponding arguments must be supplied positionally and can’t be specified by keyword.

Để chỉ định một số tham số là chỉ có vị trí, bạn chỉ định một dấu gạch chéo trần [

def functionName[arg1, arg2]:
    # What to do with function

34] trong danh sách tham số của một định nghĩa hàm. Bất kỳ tham số nào ở bên trái của dấu gạch chéo [

def functionName[arg1, arg2]:
    # What to do with function

34] phải được chỉ định vị trí. Ví dụ: trong định nghĩa chức năng sau,

def myfunction[]:
    print["Hello World"]

30 và

def myfunction[]:
    print["Hello World"]

31 là các tham số chỉ có vị trí, nhưng

def myfunction[]:
    print["Hello World"]

32 có thể được chỉ định bằng từ khóa:

>>>

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

Điều này có nghĩa là các cuộc gọi sau là hợp lệ:

>>>

def myfunction[]:
    print["Hello World"]

Tuy nhiên, cuộc gọi sau đây đến

def myfunction[]:
    print["Hello World"]

48 không hợp lệ:

>>>

def myfunction[]:
    print["Hello World"]

Cả hai người chỉ định chỉ có vị trí và chỉ có từ khóa có thể được sử dụng trong cùng một định nghĩa chức năng:

>>>

def myfunction[]:
    print["Hello World"]

Trong ví dụ này:

def myfunction[]: print["Hello World"]
30 và
def myfunction[]: print["Hello World"]
31 chỉ là vị trí. are positional-only.

def subtractNum[]: print[34 - 4] subtractNum[] # Output: 30
87 và
def functionName[arg1, arg2]: # What to do with function
43 chỉ là từ khóa. are keyword-only.

def myfunction[]: print["Hello World"]
32 và
def functionName[arg1, arg2]: # What to do with function
45 có thể được chỉ định vị trí hoặc từ khóa. may be specified positionally or by keyword.

Để biết thêm thông tin về các tham số chỉ có vị trí, hãy xem các điểm nổi bật phát hành Python 3.8.

Docstrings

Khi tuyên bố đầu tiên trong phần thân của hàm Python là một chuỗi theo nghĩa đen, nó được gọi là chức năng của Doc DomaString. Một tài liệu được sử dụng để cung cấp tài liệu cho một chức năng. Nó có thể chứa mục đích của chức năng, những đối số mà nó cần, thông tin về các giá trị trả về hoặc bất kỳ thông tin nào khác mà bạn nghĩ sẽ hữu ích.docstring. A docstring is used to supply documentation for a function. It can contain the function’s purpose, what arguments it takes, information about return values, or any other information you think would be useful.

Sau đây là một ví dụ về định nghĩa hàm với DocString:

>>>

def myfunction[]:
    print["Hello World"]

Về mặt kỹ thuật, Docstrings có thể sử dụng bất kỳ cơ chế trích dẫn Python nào, nhưng quy ước được đề xuất là ba lần sử dụng các ký tự trích dẫn kép [

def functionName[arg1, arg2]:
    # What to do with function

46], như được hiển thị ở trên. Nếu DocString phù hợp với một dòng, thì các trích dẫn đóng sẽ nằm trên cùng một dòng với các trích dẫn mở.triple-quote using double-quote characters [

def functionName[arg1, arg2]:
    # What to do with function

46], as shown above. If the docstring fits on one line, then the closing quotes should be on the same line as the opening quotes.

Các tài liệu đa dòng được sử dụng cho tài liệu dài hơn. Một tài liệu đa dòng nên bao gồm một dòng tóm tắt, theo sau là một dòng trống, theo sau là một mô tả chi tiết hơn. Các báo giá đóng nên tự mình trên một dòng: are used for lengthier documentation. A multi-line docstring should consist of a summary line, followed by a blank line, followed by a more detailed description. The closing quotes should be on a line by themselves:

>>>

def myfunction[]:
    print["Hello World"]

Định dạng DocString và các quy ước ngữ nghĩa được trình bày chi tiết trong PEP 257.

Khi một tài liệu được xác định, trình thông dịch Python gán nó cho một thuộc tính đặc biệt của hàm gọi là

def functionName[arg1, arg2]:
    # What to do with function

47. Thuộc tính này là một trong những bộ định danh chuyên dụng trong Python đôi khi được gọi là thuộc tính ma thuật hoặc phương thức ma thuật vì chúng cung cấp chức năng ngôn ngữ đặc biệt.magic attributes or magic methods because they provide special language functionality.

Bạn có thể truy cập vào một chức năng của DocString với biểu thức

def functionName[arg1, arg2]:
    # What to do with function

48. Các tài liệu cho các ví dụ trên có thể được hiển thị như sau:

>>>

def myfunction[]:
    print["Hello World"]

Trong trình thông dịch Python tương tác, bạn có thể nhập

def functionName[arg1, arg2]:
    # What to do with function

49 để hiển thị tài liệu cho

def myfunction[]:
    print["Hello World"]

39:

>>>

def myfunction[]:
    print["Hello World"]

Nó đã xem xét thực hành mã hóa tốt để chỉ định một tài liệu cho từng chức năng Python mà bạn xác định. Để biết thêm về DocStrings, hãy xem tài liệu mã Python: Hướng dẫn đầy đủ.

Chú thích chức năng Python

Kể từ phiên bản 3.0, Python cung cấp một tính năng bổ sung để ghi lại một hàm gọi là chú thích chức năng. Các chú thích cung cấp một cách để đính kèm siêu dữ liệu vào các tham số chức năng và giá trị trả về.function annotation. Annotations provide a way to attach metadata to a function’s parameters and return value.

Để thêm một chú thích vào tham số chức năng Python, chèn một dấu hai chấm [

def myfunction[]:
    print["Hello World"]

41] theo sau là bất kỳ biểu thức nào sau tên tham số trong định nghĩa hàm. Để thêm một chú thích vào giá trị trả về, hãy thêm các ký tự

def functionName[arg1, arg2]:
    # What to do with function

52 và bất kỳ biểu thức nào giữa dấu ngoặc đơn của danh sách tham số và dấu hai chấm kết thúc tiêu đề hàm. Đây là một ví dụ:

>>>

def myfunction[]:
    print["Hello World"]

Chú thích cho tham số

def subtractNum[]:
    print[34 - 4]

subtractNum[]
# Output: 30

87 là chuỗi

def functionName[arg1, arg2]:
    # What to do with function

54, cho

def functionName[arg1, arg2]:
    # What to do with function

43 Chuỗi

def functionName[arg1, arg2]:
    # What to do with function

56 và cho giá trị trả về hàm, chuỗi

def functionName[arg1, arg2]:
    # What to do with function

57.

Trình thông dịch Python tạo ra một từ điển từ các chú thích và gán chúng cho một thuộc tính Dunder đặc biệt khác của hàm gọi là

def functionName[arg1, arg2]:
    # What to do with function

58. Các chú thích cho hàm Python

def myfunction[]:
    print["Hello World"]

48 được hiển thị ở trên có thể được hiển thị như sau:

>>>

def myfunction[]:
    print["Hello World"]

Các khóa cho các tham số là tên tham số. Khóa cho giá trị trả về là chuỗi

def functionName[arg1, arg2]:
    # What to do with function

60:

>>>

def myfunction[]:
    print["Hello World"]

Lưu ý rằng các chú thích aren giới hạn trong các giá trị chuỗi. Họ có thể là bất kỳ biểu thức hoặc đối tượng. Ví dụ: bạn có thể chú thích với các đối tượng loại:

>>>

def myfunction[]:
    print["Hello World"]

Chú thích thậm chí có thể là một đối tượng tổng hợp như danh sách hoặc từ điển, do đó, nó có thể gắn nhiều mục siêu dữ liệu vào các tham số và giá trị trả về:

>>>

def myfunction[]:
    print["Hello World"]

Trong ví dụ trên, một chú thích được gắn vào tham số

def functionName[arg1, arg2]:
    # What to do with function

61 và với giá trị trả về. Mỗi chú thích là một từ điển chứa một mô tả chuỗi và một đối tượng loại.

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ẽ đi sau khi chú thích:

>>>

def myfunction[]:
    print["Hello World"]

Chú thích làm gì? Thành thật mà nói, họ không làm gì nhiều. Họ chỉ là loại ở đó. Hãy cùng xem xét một trong những ví dụ từ trên cao, nhưng với một vài sửa đổi nhỏ:

>>>

def myfunction[]:
    print["Hello World"]

Những gì đang xảy ra ở đây? Các chú thích cho

def myfunction[]:
    print["Hello World"]

48 chỉ ra rằng đối số đầu tiên là

myfunction[]

89, đối số thứ hai

myfunction[]

92 và giá trị trả về

def functionName[arg1, arg2]:
    # What to do with function

65. Nhưng cuộc gọi tiếp theo đến

def myfunction[]:
    print["Hello World"]

48 phá vỡ tất cả các quy tắc! Các đối số lần lượt là

myfunction[]

92 và

def functionName[arg1, arg2]:
    # What to do with function

65 và giá trị trả về là một tuple. Tuy nhiên, thông dịch viên cho phép tất cả trượt mà không có khiếu nại nào cả.

Chú thích don lồng áp đặt bất kỳ hạn chế ngữ nghĩa nào đối với mã. Chúng chỉ đơn giản là các bit của siêu dữ liệu được gắn vào các tham số hàm Python và giá trị trả về. Python một cách nghiêm túc cất chúng trong một từ điển, gán từ điển cho chức năng của thuộc tính Dunder ____458, và đó là nó. Các chú thích là hoàn toàn tùy chọn và don lồng có bất kỳ tác động nào đến việc thực thi chức năng Python.semantic restrictions on the code whatsoever. They’re simply bits of metadata attached to the Python function parameters and return value. Python dutifully stashes them in a dictionary, assigns the dictionary to the function’s

def functionName[arg1, arg2]:
    # What to do with function

58 dunder attribute, and that’s it. Annotations are completely optional and don’t have any impact on Python function execution at all.

Để trích dẫn Amahl ở Amahl và khách truy cập ban đêm, thì đó là những gì mà sử dụng nó sau đó?

Đối với người mới bắt đầu, chú thích làm tài liệu tốt. Tất nhiên, bạn có thể chỉ định cùng một thông tin trong DocString, nhưng việc đặt nó trực tiếp vào định nghĩa chức năng thêm rõ ràng. Các loại đối số và giá trị trả về là rõ ràng trên tầm nhìn cho một tiêu đề chức năng như sau:documentation. You can specify the same information in the docstring, of course, but placing it directly in the function definition adds clarity. The types of the arguments and the return value are obvious on sight for a function header like this:

def myfunction[]:
    print["Hello World"]

Được cấp, thông dịch viên không thực thi tuân thủ các loại được chỉ định, nhưng ít nhất họ đã rõ ràng với ai đó đọc định nghĩa chức năng.

Diễn lặn sâu: Thực thi kiểm tra loại
Nếu bạn có xu hướng, bạn có thể thêm mã để thực thi các loại được chỉ định trong các chú thích chức năng. Ở đây, một chức năng kiểm tra loại thực tế của mỗi đối số so với những gì mà quy định trong phần chú thích cho tham số tương ứng. Nó sẽ hiển thị
def myfunction[]:
    print["Hello World"]
36 nếu họ khớp với ANS
def myfunction[]:
    print["Hello World"]
37 nếu họ don lồng:
>>>
def myfunction[]:
    print["Hello World"]
15
[Mô -đun
def functionName[arg1, arg2]:
    # What to do with function
    
72 chứa các chức năng có được thông tin hữu ích về các đối tượng trực tiếp trong trường hợp này, chức năng
def myfunction[]:
    print["Hello World"]
48.]
Một hàm được xác định như ở trên có thể, nếu muốn, thực hiện một số loại hành động khắc phục khi phát hiện ra rằng các đối số được thông qua không phù hợp với các loại được chỉ định trong các chú thích.
Trên thực tế, một sơ đồ sử dụng các chú thích để thực hiện kiểm tra loại tĩnh trong Python được mô tả trong PEP 484. Một trình kiểm tra loại tĩnh miễn phí cho Python được gọi là MyPy có sẵn, được xây dựng trên đặc tả PEP 484.

Có một lợi ích khác để sử dụng các chú thích là tốt. Định dạng được tiêu chuẩn hóa trong đó thông tin chú thích được lưu trữ trong thuộc tính

def functionName[arg1, arg2]:
    # What to do with function

58 cho vay để phân tích chữ ký chức năng bằng các công cụ tự động.

Khi nói đến nó, các chú thích không phải là bất cứ điều gì đặc biệt kỳ diệu. Bạn thậm chí có thể định nghĩa của riêng bạn mà không cần cú pháp đặc biệt mà Python cung cấp. Ở đây, một định nghĩa chức năng Python với các chú thích đối tượng loại được gắn vào các tham số và giá trị trả về:

>>>

def myfunction[]:
    print["Hello World"]

Sau đây về cơ bản là cùng một chức năng, với từ điển

def functionName[arg1, arg2]:
    # What to do with function

58 được xây dựng thủ công:

>>>

def myfunction[]:
    print["Hello World"]

Hiệu quả giống hệt nhau trong cả hai trường hợp, nhưng lần đầu tiên hấp dẫn hơn và có thể đọc được ngay từ cái nhìn đầu tiên.

Trên thực tế, thuộc tính

def functionName[arg1, arg2]:
    # What to do with function

58 không khác biệt đáng kể so với hầu hết các thuộc tính khác của một hàm. Ví dụ, nó có thể được sửa đổi một cách động. Bạn có thể chọn sử dụng thuộc tính giá trị trả về để đếm số lần một hàm được thực thi:

>>>

def myfunction[]:
    print["Hello World"]

Chú thích chức năng Python không gì khác hơn từ điển của siêu dữ liệu. Nó chỉ xảy ra rằng bạn có thể tạo chúng với cú pháp thuận tiện mà người được thông dịch hỗ trợ. Họ bất cứ điều gì bạn chọn để làm cho họ.

Sự kết luận

Khi các ứng dụng phát triển lớn hơn, việc mô đun hóa mã ngày càng trở nên quan trọng bằng cách chia nó thành các chức năng nhỏ hơn có kích thước có thể quản lý được. Bây giờ bạn hy vọng có tất cả các công cụ bạn cần để làm điều này.

Bạn đã học:

Cách tạo chức năng do người dùng xác định trong Pythonuser-defined function in Python
Một số cách khác nhau bạn có thể chuyển đối số cho một hàmarguments to a function
Cách bạn có thể trả lại dữ liệu từ một hàm cho người gọi của nóreturn data from a function to its caller
Cách thêm tài liệu vào các chức năng với tài liệu và chú thíchdocstrings and annotations

Tiếp theo trong loạt bài này là hai hướng dẫn bao gồm tìm kiếm và khớp mẫu. Bạn sẽ có một cái nhìn sâu sắc về một mô-đun Python có tên Re, trong đó chứa chức năng tìm kiếm và khớp bằng cách sử dụng cú pháp mẫu đa năng được gọi là biểu thức chính quy.searching and pattern matching. You will get an in-depth look at a Python module called re, which contains functionality for searching and matching using a versatile pattern syntax called a regular expression.

Làm thế nào để bạn tạo một chức năng mới?

Để tạo chức năng của riêng bạn, bạn cần phải làm bốn điều:..

Viết loại trả về của hàm ..

Viết tên của hàm ..

Bên trong ngoặc đơn [], liệt kê bất kỳ tham số nào mà hàm mất ..

Bên trong dấu ngoặc xoăn {}, viết mã sẽ chạy bất cứ khi nào chức năng được gọi.Đây được gọi là cơ thể của chức năng ..

Làm thế nào để bạn xác định một chức năng?

Một định nghĩa kỹ thuật của một hàm là: Một mối quan hệ từ một tập hợp các đầu vào đến một tập hợp các đầu ra có thể trong đó mỗi đầu vào có liên quan đến chính xác một đầu ra.a relation from a set of inputs to a set of possible outputs where each input is related to exactly one output.

Cú pháp để xác định chức năng mới là gì?

Cú pháp để tạo một hàm: hãy để func = hàm mới [[arg1, arg2, ... argn], functionbody];Hàm được tạo với các đối số arg1 ... argn và hàm đã cho.let func = new Function [[arg1, arg2, ... argN], functionBody]; The function is created with the arguments arg1... argN and the given functionBody .

4 loại chức năng trong Python là gì?

Sau đây là các loại chức năng Python khác nhau:..

Chức năng tích hợp Python ..

Chức năng đệ quy Python ..

Chức năng Python Lambda ..

Các chức năng do người dùng Python xác định ..

Cú pháp cơ bản để xác định chức năng trong Python

Các ví dụ cơ bản về một chức năng trong Python

Đối số trong các chức năng Python

Cách sử dụng từ khóa trả về trong Python

Sự kết luận

Làm thế nào để bạn xác định một chức năng?

Tầm quan trọng của các chức năng Python

Trừu tượng hóa và tái sử dụng

Mô -đun

Tách không gian tên

Các cuộc gọi và định nghĩa chức năng

Đối số thông qua

Lập luận vị trí

Bạn cũng không thể chỉ định thêm những cái:

Từ khóa đối số

By-by-giá trị vs Pass-Ty-Ttef

Đối số thông qua tóm tắt

Phản ứng phụ

Tuyên bố def myfunction[]: print["Hello World"] 22

Thoát một chức năng

Trả lại dữ liệu cho người gọi

Xem lại các tác dụng phụ

Sử dụng đóng gói Tuple, bạn có thể dọn dẹp def subtractNum[]: print[34 - 4] subtractNum[] # Output: 30 59 như thế này:

Bạn thậm chí có thể sử dụng đóng gói Tuple và giải nén cùng một lúc:

Từ điển tranh luận Giải nén

Nhiều gói trong một cuộc gọi chức năng Python

>>> s = 'foobar' >>> id[s] 56313440 2

Đối số chỉ có vị trí

Docstrings

Chú thích chức năng Python

Sự kết luận

Làm thế nào để bạn tạo một chức năng mới?

Làm thế nào để bạn xác định một chức năng?

Cú pháp để xác định chức năng mới là gì?

4 loại chức năng trong Python là gì?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề

Tuyên bố
`def myfunction[]: print["Hello World"]`
22

Sử dụng đóng gói Tuple, bạn có thể dọn dẹp
`def subtractNum[]: print[34 - 4] subtractNum[] # Output: 30`
59 như thế này:

`>>> s = 'foobar' >>> id[s] 56313440`
2