Vì sao lại là None?#
def add(a, b):
print(a + b)
result = add(2, 3)
print(result)
Hai dòng đầu ra (output) là gì? Hãy viết chúng ra.
Hầu hết mọi người nghĩ sẽ là 5 rồi 5. Hàm rõ ràng tạo ra 5, và chúng ta đã lưu nó vào result.
5
None
print và return không phải là một, và đây là dòng mà điều đó thôi không còn là chuyện tiểu tiết kỹ thuật. print đưa các ký tự lên màn hình cho người đọc. return trao một giá trị lại cho đoạn mã đã gọi nó.
Hàm của chúng ta đã in ra 5 và không trả về (return) gì, nên result chứa None, cách Python nói “hoàn toàn không có giá trị”. Đổi print(a + b) thành return a + b thì cả hai dòng đều là 5.
Định nghĩa không phải là chạy#
Câu lệnh (statement) def không thực thi thân hàm. Nó tạo ra hàm rồi đi tiếp. Thân hàm chỉ chạy khi có gì đó gọi nó:
def greet():
print("hi")
print("start")
greet()
print("end")
start
hi
end
"hi" không được in ra đầu tiên dù nó xuất hiện đầu tiên trong tệp (file). Python đọc def, ghi nhớ nó, rồi đi tiếp đến print("start"). Chỉ khi đến greet() nó mới rẽ vào thân hàm, và khi thân hàm xong, nó quay lại đúng chỗ đã rời đi.
Việc rẽ vào rồi quay lại đó là toàn bộ ý tưởng về luồng thực thi (flow of execution), và nhờ nó mà phần còn lại của trang này trở nên dễ hiểu.
Tham số (parameter) và đối số (argument)#
Hai từ này được dùng lẫn lộn khi nói chuyện nhưng được phân biệt trong bài thi, nên đáng bỏ ra ba mươi giây:
| Thuật ngữ | Nằm ở đâu | Ví dụ |
|---|---|---|
| Tham số (parameter) | trong dòng def: một tên giữ chỗ | def area(side): → side |
| Đối số (argument) | tại lời gọi: giá trị thực được trao đi | area(10) → 10 |
Phiên bản một câu: bạn định nghĩa tham số và bạn truyền đối số.
return và print: lỗi đắt giá#
Hai thứ này trông có thể thay thế cho nhau khi bạn kiểm tra bằng mắt, vì cả hai đều đưa con số lên màn hình. Chúng hoàn toàn không giống nhau:
def square_p(x):
print(x * x)
def square_r(x):
return x * x
a = square_p(5)
b = square_r(5)
print(a)
print(b)
25
None
25
Hãy đọc kỹ đầu ra đó, vì cả ba dòng đều quan trọng. Số 25 ở trên cùng đến từ bên trong square_p: nó được in ra ngay lúc hàm chạy. Sau đó print(a) cho ra None, vì square_p không trao lại gì cả. Rồi print(b) cho ra 25, giá trị mà square_r trả về.
print hiển thị giá trị cho người đọc. return trao giá trị lại cho đoạn mã. Nếu bạn muốn dùng một kết quả (cộng nó với thứ khác, so sánh nó, kiểm tra nó, đưa nó vào danh sách (list)), thì nó phải được trả về.
Hàm in ra trông hoàn toàn đúng khi bạn tự chạy thử. Nó thất bại ngay khi có gì đó kiểm tra kết quả: một câu assert, một trình chấm tự động, hoặc chính đoạn mã sau này của bạn. Màn hình hiện 25 mà bài kiểm thử vẫn thất bại, một tình huống thật sự gây bối rối cho đến khi bạn biết sự khác biệt này.
Hàm nào cũng trả về một thứ gì đó#
def add(a, b):
total = a + b
result = add(2, 3)
print(result)
None
Phép cộng đã diễn ra. Đáp số đã được lưu trong total. Rồi hàm kết thúc, total không còn tồn tại, và nơi gọi nhận được None: đó là thứ Python trả về khi một hàm chạy hết thân hàm mà không gặp return.
return cũng dừng hàm ngay lập tức, điều này rất dễ quên:
def classify(n):
if n < 0:
return "negative"
print("checking...")
return "non-negative"
print(classify(-5))
print(classify(5))
negative
checking...
non-negative
Lời gọi đầu tiên không bao giờ đến được print("checking..."). Không có gì sau return trên nhánh đã đi sẽ chạy.
Biến cục bộ, và chúng đi đâu#
Biến (variable) được tạo bên trong một hàm là biến cục bộ (local) của hàm đó. Phạm vi (scope) của nó, tức nơi nhìn thấy được tên đó, là thân hàm, và thời gian tồn tại (lifetime) của nó kết thúc khi lời gọi kết thúc:
def f():
x = 10
f()
print(x)
Traceback (most recent call last):
File "scope.py", line 5, in <module>
print(x)
^
NameError: name 'x' is not defined
x thật sự đã tồn tại, trong chốc lát. Đến khi dòng 5 chạy thì nó đã mất. Đây không phải là hạn chế cần tìm cách né: đây là tính năng cho phép bạn dùng i hoặc total trong năm mươi hàm khác nhau mà chúng không đụng độ nhau. Cách lấy một giá trị ra ngoài là return nó.
Biến toàn cục, và lỗi nghe vô lý#
Biến được định nghĩa bên ngoài mọi hàm là biến toàn cục (global), và hàm có thể đọc nó:
count = 0
def show():
print(count)
show()
0
Nhưng nếu thử thay đổi nó, bạn sẽ gặp một trong những lỗi trông kỳ lạ nhất của Python:
count = 0
def bump():
count = count + 1
bump()
Traceback (most recent call last):
File "bump.py", line 6, in <module>
bump()
File "bump.py", line 4, in bump
count = count + 1
^^^^^
UnboundLocalError: cannot access local variable 'count' where it is not associated with a value
Biến toàn cục count ở ngay đó, vậy mà Python nói không truy cập được. Lý do: gán cho một tên ở bất kỳ đâu trong hàm sẽ làm tên đó thành cục bộ trong toàn bộ hàm, kể cả ở những dòng trước phép gán (assignment). Vì vậy count + 1 đang cố đọc một count cục bộ chưa được gán giá trị.
Từ khóa (keyword) global ghi đè điều đó:
count = 0
def bump():
global count
count = count + 1
bump()
print(count)
1
Cách này chạy được, nhưng bạn vẫn gần như không bao giờ nên dùng. Hàm với tay ra ngoài sửa biến toàn cục thì khó kiểm thử (kết quả của nó phụ thuộc vào trạng thái bạn không nhìn thấy tại lời gọi), khó dùng lại ở nơi khác, và khó gỡ lỗi (debug): khi giá trị sai, mọi hàm đụng đến nó đều là nghi phạm. Hãy truyền giá trị vào dưới dạng đối số và trao kết quả lại bằng return.
Điều gì xảy ra với thứ bạn truyền vào#
Đây là câu hỏi dò từng bước kinh điển, và cả hai nửa được đặt cùng nhau là có lý do:
def bump(n):
n += 1
def add_item(items):
items.append("new")
number = 5
things = ["a"]
bump(number)
add_item(things)
print(number)
print(things)
5
['a', 'new']
Cùng một dạng, kết quả trái ngược. Tham số là một tên khác của thứ bạn đã truyền vào, nên items.append(...) chạm đến đúng danh sách của nơi gọi, còn n += 1 trên một số chỉ trỏ tên cục bộ n sang chỗ khác và không đụng đến number. Số, chuỗi (string) và tuple (bộ giá trị) hoàn toàn không thể thay đổi tại chỗ, nên gán lại một giá trị như vậy bên trong hàm không bao giờ nhìn thấy được ở bên ngoài.
Phiên bản trong bài thi thường trông như sau:
def increment(a, b):
a = a + 1
b += 1
x = 42
y = 7
increment(x, y)
print(x, y)
42 7
Cả += lẫn = a + 1 đều không thoát ra khỏi hàm khi giá trị là một số. Toàn bộ câu chuyện vì sao giá trị khả biến (mutable) hành xử khác đi nằm trong bài Vì sao sửa danh sách này lại làm đổi danh sách kia.
Trả về nhiều hơn một giá trị#
def min_max(nums):
return min(nums), max(nums)
lo, hi = min_max([4, 9, 1])
print(lo, hi)
1 9
Python không có tính năng trả về nhiều giá trị. Dấu phẩy tạo ra một tuple, và lo, hi = giải nén nó. Điều đó có nghĩa là số lượng phải khớp nhau:
def min_max(nums):
return min(nums), max(nums)
lo, hi, extra = min_max([4, 9, 1])
Traceback (most recent call last):
File "mm.py", line 4, in <module>
lo, hi, extra = min_max([4, 9, 1])
^^^^^^^^^^^^^
ValueError: not enough values to unpack (expected 3, got 2)
Nếu một nhánh trong hàm trả về hai giá trị và nhánh khác trả về None, nơi gọi không thể dùng kết quả một cách an toàn: giải nén None sẽ gây lỗi, còn kiểm tra nó thì làm rối mọi chỗ gọi. Hãy quyết định hàm trao lại thứ gì và làm cho mọi nhánh đều trao lại cùng dạng đó.
Hàm gọi hàm#
Chia một bài toán lớn thành các bài toán nhỏ hơn mới là mục đích thực sự của hàm, và việc này được gọi là phân rã chức năng (functional decomposition):
def square(x):
return x * x
def sum_of_squares(a, b):
return square(a) + square(b)
print(sum_of_squares(3, 4))
25
Khi mọi thứ đã nằm trong hàm, quy ước thông thường là đặt mã cấp cao nhất vào một hàm main() và gọi nó một lần ở cuối, để tệp đọc như một danh sách các khả năng, tiếp theo là một dòng khởi động chương trình:
def area(w, h):
return w * h
def main():
print(area(3, 4))
main()
12
Docstring, và kiểm thử bằng assert#
Docstring là một chuỗi đặt trong ba dấu nháy, nằm ở dòng đầu tiên của thân hàm. Nó không phải là chú thích: Python giữ nó lại, và các công cụ đọc nó:
def square(x):
"""Return the square of a number."""
return x * x
print(square.__doc__)
Return the square of a number.
assert kiểm tra một điều gì đó có đúng không và không nói gì khi điều đó đúng. Sự im lặng đó chính là đạt:
def is_even(n):
return n % 2 == 0
assert is_even(4) == True
assert is_even(7) == False
print("all tests passed")
all tests passed
Lưu ý rằng cả trường hợp đúng lẫn trường hợp sai đều được kiểm thử. Một bộ kiểm thử chỉ kiểm tra những trường hợp đáng lẽ đạt sẽ vui vẻ chấp nhận một hàm trả về True cho mọi thứ. Khi một câu assert thật sự thất bại, nó thất bại rất ồn ào:
def is_even(n):
return n % 2 == 0
assert is_even(3) == True
Traceback (most recent call last):
File "t.py", line 4, in <module>
assert is_even(3) == True
^^^^^^^^^^^^^^^^^^
AssertionError
Và đây là điều mà phần đầu tiên dẫn tới: assert xem xét một giá trị được trả về. Hàm in đáp số ra thay vì trả về thì hoàn toàn không thể kiểm thử theo cách này.
Những chỗ dễ sai#
- In ra thay vì trả về. Đầu ra trông đúng và mọi bài kiểm thử đều thất bại. Đây là lỗi mất điểm phổ biến nhất về hàm.
- Quên gọi hàm. Định nghĩa một hàm mà không bao giờ gọi nó sẽ cho ra một chương trình chạy được, không in gì, và không báo lỗi.
- Dùng biến cục bộ sau khi hàm kết thúc.
NameError. Hãy trả về nó. - Gán cho biến toàn cục mà không khai báo
global.UnboundLocalError, chỉ vào một dòng mà tên đó trông hoàn toàn đã được định nghĩa. - Mong đối số là số sẽ thay đổi. Nó sẽ không đổi. Hãy trả về giá trị mới và gán nó tại chỗ gọi.
- Không ngờ đối số là danh sách sẽ thay đổi. Nó sẽ đổi, nếu hàm thay đổi nó.
- Giải nén không khớp. Hứng hai giá trị trả về bằng ba tên, hoặc ba giá trị bằng một tên.
- Viết mã sau
returntrên cùng một nhánh. Đoạn mã đó không bao giờ chạy, và cũng không bao giờ cảnh báo bạn. - Đặt tên biến trùng với tên hàm.
square = square(4)thay hàm bằng một số, và lần gọi tiếp theo gây raTypeError.
Tự kiểm tra trong ứng dụng Kestrel Exams miễn phí
30 câu hỏi luyện tập về def, tham số, return, phạm vi, global và kiểm thử bằng assert, mọi đáp án liên quan đến mã đều đã được kiểm tra bằng cách chạy thật. Miễn phí, dùng được khi không có mạng, không cần tài khoản.
Câu hỏi thường gặp#
print và return trong Python khác nhau thế nào?
print hiển thị giá trị cho người đọc; return trao giá trị lại cho đoạn mã đã gọi hàm. Hàm in ra thay vì trả về sẽ cho bạn None khi bạn gán kết quả của nó, và đó là lý do bài kiểm thử đơn vị (unit test) cho hàm đó thất bại dù con số đúng đã hiện trên màn hình.
Tham số và đối số khác nhau thế nào?
Tham số là tên trong phần định nghĩa hàm, đóng vai trò giữ chỗ. Đối số là giá trị thực được truyền vào khi gọi. Trong def area(side), tham số là side; trong area(10), đối số là 10.
Vì sao hàm của tôi trả về None?
Vì hàm không có câu lệnh return, hoặc vì quá trình thực thi đã đến cuối thân hàm mà không gặp câu lệnh đó. Hàm không có return vẫn trả về một thứ: None.
Vì sao tôi không dùng được biến bên ngoài hàm đã tạo ra nó?
Vì biến đó là cục bộ trong hàm. Phạm vi của nó là thân hàm và thời gian tồn tại của nó kết thúc khi lời gọi kết thúc. Dùng nó bên ngoài sẽ gây ra NameError: name 'x' is not defined. Muốn lấy giá trị ra ngoài, hãy trả về nó.
Vì sao tôi gặp UnboundLocalError khi biến rõ ràng có tồn tại?
Vì gán cho một tên ở bất kỳ đâu trong hàm sẽ làm tên đó thành cục bộ trong toàn bộ hàm, nên count = count + 1 cố đọc một biến cục bộ chưa được gán giá trị. Hãy truyền giá trị vào và trả về giá trị mới, hoặc khai báo global count nếu thật sự bắt buộc.
Hàm có làm thay đổi biến tôi truyền vào không?
Chỉ khi giá trị là khả biến và hàm thay đổi nó. Thêm phần tử vào một tham số là danh sách sẽ làm thay đổi danh sách của nơi gọi. Gán lại một tham số, kể cả n += 1 trên một số, thì không.
Có chỗ nào chưa rõ? Có chủ đề nào bạn muốn chúng tôi viết? Hãy cho chúng tôi biết. Chúng tôi đọc mọi tin nhắn, và một lời đề nghị là cách nhanh nhất để có bài hướng dẫn mới: một số bài ở đây ra đời vì có người hỏi.