Cách định nghĩa hàm trong Python 3

Giới thiệu

Hàm (function) là một khối lệnh thực hiện một hành động và sau khi được định nghĩa, có thể được sử dụng lại. Hàm làm cho mã trở nên mô-đun hơn, cho phép bạn sử dụng cùng một mã nhiều lần.

Python có một số hàm tích hợp mà bạn có thể quen thuộc, bao gồm:

• print() sẽ in một đối tượng ra thiết bị đầu cuối
• int() sẽ chuyển đổi kiểu dữ liệu chuỗi hoặc số thành kiểu dữ liệu số nguyên
• len() trả về độ dài của một đối tượng

Tên hàm bao gồm dấu ngoặc đơn và có thể bao gồm các tham số.

Trong hướng dẫn này, chúng ta sẽ tìm hiểu cách định nghĩa các hàm của riêng bạn để sử dụng trong các dự án mã hóa của bạn.

Điều kiện tiên quyết

Bạn phải cài đặt Python 3 và thiết lập môi trường lập trình trên máy tính hoặc máy chủ của mình. Nếu bạn không thiết lập môi trường lập trình, bạn có thể tham khảo hướng dẫn cài đặt và thiết lập cho môi trường lập trình cục bộ hoặc cho môi trường lập trình trên máy chủ của bạn phù hợp với hệ điều hành của bạn (Ubuntu, CentOS, Debian, v.v.)

Định nghĩa hàm

Chúng ta hãy bắt đầu bằng cách biến chương trình kinh điển “Hello, World!” thành một hàm.

Chúng ta sẽ tạo một tệp văn bản mới trong trình soạn thảo văn bản theo lựa chọn của mình và gọi chương trình hello.py. Sau đó, chúng ta sẽ định nghĩa hàm.

Một hàm được định nghĩa bằng cách sử dụng từ khóa def, theo sau là tên bạn chọn, theo sau là một tập hợp các dấu ngoặc đơn chứa bất kỳ tham số nào mà hàm sẽ sử dụng (chúng có thể để trống) và kết thúc bằng dấu hai chấm.

Trong trường hợp này, chúng ta sẽ định nghĩa một hàm có tên là hello():

def hello():

Điều này thiết lập câu lệnh ban đầu để tạo hàm.

Từ đây, chúng ta sẽ thêm dòng thứ hai với thụt lề 4 khoảng trắng để cung cấp hướng dẫn về chức năng của hàm. Trong trường hợp này, chúng ta sẽ in Hello, World! vào bảng điều khiển:

def hello():
    print("Hello, World!")

Hàm của chúng ta hiện đã được định nghĩa đầy đủ, nhưng nếu chúng ta chạy chương trình tại thời điểm này, sẽ không có gì xảy ra vì chúng ta không gọi hàm.

Vì vậy, bên ngoài khối hàm đã định nghĩa của chúng ta, hãy gọi hàm bằng hello():

def hello():
    print("Hello, World!")

hello()

Bây giờ, hãy chạy chương trình:

python hello.py

Bạn sẽ nhận được kết quả sau:

Output
Hello, World!

Các hàm có thể phức tạp hơn hàm hello() mà chúng ta đã định nghĩa ở trên. Ví dụ, chúng ta có thể sử dụng vòng lặp for, câu lệnh điều kiện và nhiều thứ khác trong khối hàm của mình.

Ví dụ, hàm được định nghĩa bên dưới sử dụng câu lệnh điều kiện để kiểm tra xem đầu vào cho biến name có chứa nguyên âm hay không, sau đó sử dụng vòng lặp for để lặp lại các chữ cái trong chuỗi name.

# Define function names()
def names():
    # Set up name variable with input
    name = str(input('Enter your name: '))
    # Check whether name has a vowel
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')

    # Iterate over name
    for letter in name:
        print(letter)

# Call the function
names()

Hàm names() mà chúng ta định nghĩa ở trên thiết lập một câu lệnh điều kiện và một vòng lặp for, cho thấy cách mã có thể được tổ chức trong một định nghĩa hàm. Tuy nhiên, tùy thuộc vào mục đích của chúng ta với chương trình và cách chúng ta muốn thiết lập mã, chúng ta có thể muốn định nghĩa câu lệnh điều kiện và vòng lặp for là hai hàm riêng biệt.

Định nghĩa các hàm trong một chương trình làm cho mã của chúng ta có tính mô-đun và có thể tái sử dụng để chúng ta có thể gọi các hàm giống nhau mà không cần viết lại chúng.

Làm việc với các tham số

Cho đến nay, chúng ta đã xem xét các hàm có dấu ngoặc đơn rỗng không có đối số, nhưng chúng ta có thể định nghĩa các tham số trong định nghĩa hàm trong dấu ngoặc đơn của chúng.

Tham số là một thực thể được đặt tên trong định nghĩa hàm, chỉ định một đối số mà hàm có thể chấp nhận.

Hãy tạo một chương trình nhỏ có các tham số x, y và z. Chúng ta sẽ tạo một hàm cộng các tham số lại với nhau theo các cấu hình khác nhau. Tổng của các tham số này sẽ được hàm in ra. Sau đó, chúng ta sẽ gọi hàm và truyền các số vào hàm.

def add_numbers(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    print(a, b, c)

add_numbers(1, 2, 3)

Chúng tôi đã truyền số 1 cho tham số x, 2 cho tham số y và 3 cho tham số z. Các giá trị này tương ứng với từng tham số theo thứ tự được đưa ra.

Về cơ bản, chương trình đang thực hiện phép toán sau dựa trên các giá trị chúng tôi đã truyền cho các tham số:

a = 1 + 2
b = 1 + 3
c = 2 + 3

Hàm này cũng in ra a, b và c, và dựa trên phép toán ở trên, chúng ta mong đợi a bằng 3, b bằng 4 và c bằng 5. Hãy chạy chương trình:

python add_numbers.py

Output
3 4 5

Khi chúng ta truyền 1, 2 và 3 làm tham số cho hàm add_numbers(), chúng ta sẽ nhận được kết quả mong đợi.

Tham số là các đối số thường được định nghĩa là biến trong định nghĩa hàm. Chúng có thể được gán giá trị khi bạn chạy phương thức, truyền các đối số vào hàm.

Đối số từ khóa

Ngoài việc gọi các tham số theo thứ tự, bạn có thể sử dụng các đối số từ khóa (keyword arguments) trong lệnh gọi hàm, trong đó người gọi xác định các đối số theo tên tham số.

Khi bạn sử dụng các đối số từ khóa, bạn có thể sử dụng các tham số không theo thứ tự vì trình thông dịch Python sẽ sử dụng các từ khóa được cung cấp để khớp các giá trị với các tham số.

Hãy tạo một hàm sẽ hiển thị cho chúng ta thông tin hồ sơ của một người dùng. Chúng ta sẽ truyền các tham số cho hàm dưới dạng username (dự định là chuỗi) và followers (dự định là số nguyên).

# Define function with parameters
def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

Trong câu lệnh định nghĩa hàm, username và followers được chứa trong dấu ngoặc đơn của hàm profile_info(). Khối của hàm in ra thông tin về người dùng dưới dạng chuỗi, sử dụng hai tham số.

Bây giờ, chúng ta có thể gọi hàm và gán tham số cho nó:

def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

# Call function with parameters assigned as above
profile_info("sammyshark", 945)

# Call function with keyword arguments
profile_info(username="AlexAnglerfish", followers=342)

Trong lệnh gọi hàm đầu tiên, chúng ta đã điền thông tin với tên người dùng là sammyshark và số người theo dõi là 945, trong lệnh gọi hàm thứ hai, chúng ta đã sử dụng đối số từ khóa, gán giá trị cho các biến đối số.

Hãy chạy chương trình:

python profile.py

Output
Username: sammyshark
Followers: 945
Username: AlexAnglerfish
Followers: 342

Đầu ra cho chúng ta thấy tên người dùng và số lượng người theo dõi của cả hai người dùng.

Điều này cũng cho phép chúng ta sửa đổi thứ tự của các tham số, như trong ví dụ này về cùng một chương trình với một lệnh gọi khác:

def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

# Change order of parameters
profile_info(followers=820, username="cameron-catfish")

Khi chúng ta chạy lại chương trình bằng lệnh python profile.py, chúng ta sẽ nhận được kết quả đầu ra sau:

Output
Username: cameron-catfish
Followers: 820

Vì định nghĩa hàm duy trì cùng thứ tự các câu lệnh print(), nếu chúng ta sử dụng các đối số từ khóa, thì thứ tự chúng ta truyền chúng vào lệnh gọi hàm không quan trọng.

Giá trị đối số mặc định

Chúng ta cũng có thể cung cấp các giá trị mặc định cho một hoặc cả hai tham số. Hãy tạo một giá trị mặc định cho tham số followers với giá trị là 1:

def profile_info(username, followers=1):
    print("Username: " + username)
    print("Followers: " + str(followers))

Bây giờ, chúng ta có thể chạy hàm chỉ với hàm tên người dùng được chỉ định và số lượng người theo dõi sẽ tự động mặc định là 1. Chúng ta vẫn có thể thay đổi số lượng người theo dõi nếu muốn.

def profile_info(username, followers=1):
    print("Username: " + username)
    print("Followers: " + str(followers))

profile_info(username="JOctopus")
profile_info(username="sammyshark", followers=945)

Khi chúng ta chạy chương trình bằng lệnh python profile.py, chúng ta sẽ nhận được kết quả sau:

Output
Username: JOctopus
Followers: 1
Username: sammyshark
Followers: 945

Cung cấp các tham số mặc định có giá trị cho phép chúng ta bỏ qua việc xác định giá trị cho mỗi đối số đã có giá trị mặc định.

Trả về giá trị

Bạn có thể truyền giá trị tham số vào một hàm và hàm cũng có thể tạo ra một giá trị.

Một hàm có thể tạo ra một giá trị bằng câu lệnh return, câu lệnh này sẽ thoát khỏi hàm và tùy chọn truyền lại một biểu thức cho người gọi. Nếu bạn sử dụng câu lệnh return không có đối số, hàm sẽ trả về None.

Cho đến nay, chúng ta đã sử dụng câu lệnh print() thay vì câu lệnh return trong các hàm của mình. Hãy tạo một chương trình thay vì in sẽ trả về một biến.

Trong một tệp văn bản mới có tên là square.py, chúng ta sẽ tạo một chương trình bình phương tham số x và trả về biến y. Chúng ta đưa ra lệnh gọi để in biến result, được hình thành bằng cách chạy hàm square() với 3 được truyền vào.

def square(x):
    y = x ** 2
    return y

result = square(3)
print(result)

Chúng ta có thể chạy chương trình và nhận được kết quả:

python square.py

Output
9

Số nguyên 9 được trả về dưới dạng đầu ra, đây là điều chúng ta mong đợi khi yêu cầu Python tìm bình phương của 3.

Để hiểu rõ hơn về cách hoạt động của câu lệnh return, chúng ta có thể chú thích câu lệnh return trong chương trình:

def square(x):
    y = x ** 2
    # return y

result = square(3)
print(result)

Bây giờ, hãy chạy lại chương trình:

python square.py

Output
None

Nếu không sử dụng câu lệnh return ở đây, chương trình không thể trả về giá trị nên giá trị mặc định là None.

Một ví dụ khác, trong chương trình add_numbers.py ở trên, chúng ta có thể hoán đổi câu lệnh print() cho câu lệnh return.

def add_numbers(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    return a, b, c

sums = add_numbers(1, 2, 3)
print(sums)

Bên ngoài hàm, chúng ta đặt biến sums bằng với kết quả của hàm lấy 1, 2 và 3 như chúng ta đã làm ở trên. Sau đó, chúng ta gọi lệnh in biến sums.

Bây giờ chúng ta hãy chạy lại chương trình khi nó có câu lệnh return:

python add_numbers.py

Output
(3, 4, 5)

Chúng ta nhận được cùng số 3, 4 và 5 làm đầu ra mà chúng ta đã nhận được trước đó bằng cách sử dụng câu lệnh print() trong hàm. Lần này, nó được cung cấp dưới dạng một tuple vì danh sách biểu thức của câu lệnh return có ít nhất một dấu phẩy.

Các hàm thoát ngay lập tức khi chúng chạm vào câu lệnh return, bất kể chúng có trả về giá trị hay không.

def loop_five():
    for x in range(0, 25):
        print(x)
        if x == 5:
            # Stop function at x == 5
            return
    print("This line will not execute.")

loop_five()

Sử dụng câu lệnh return trong vòng lặp for sẽ kết thúc hàm, do đó dòng lệnh nằm ngoài vòng lặp sẽ không chạy. Nếu thay vào đó, chúng ta sử dụng câu lệnh break, thì chỉ có vòng lặp thoát tại thời điểm đó và dòng lệnh print() cuối cùng sẽ chạy.

Câu lệnh return thoát khỏi hàm và có thể trả về giá trị khi được đưa ra cùng với tham số.

Sử dụng main() như một hàm

Mặc dù trong Python, bạn có thể gọi hàm ở cuối chương trình và nó sẽ chạy (như chúng ta đã làm trong các ví dụ ở trên), nhưng nhiều ngôn ngữ lập trình (như C++ và Java) yêu cầu hàm main để thực thi. Việc đưa hàm main() vào, mặc dù không bắt buộc, có thể cấu trúc các chương trình Python của chúng ta theo cách hợp lý, đưa các thành phần quan trọng nhất của chương trình vào một hàm. Nó cũng có thể giúp các lập trình viên không phải Python dễ đọc chương trình của chúng ta hơn.

Chúng ta sẽ bắt đầu bằng cách thêm hàm main() vào chương trình hello.py ở trên. Chúng ta sẽ giữ nguyên hàm hello() của mình, sau đó định nghĩa hàm main():

def hello():
    print("Hello, World!")

def main():

Trong hàm main(), hãy bao gồm một câu lệnh print() để cho chúng ta biết rằng chúng ta đang ở trong hàm main(). Ngoài ra, hãy gọi hàm hello() trong hàm main():

def hello():
    print("Hello, World!")


def main():
    print("This is the main function")
    hello()

Cuối cùng, ở cuối chương trình, chúng ta sẽ gọi hàm main():

def hello():
    print("Hello, World!")

def main():
    print("This is the main function.")
    hello()

main()

Tại thời điểm này, chúng ta có thể chạy chương trình của mình:

python hello.py

Chúng ta sẽ nhận được kết quả sau:

Output
This is the main function.
Hello, World!

Bởi vì chúng ta đã gọi hàm hello() trong hàm main() và sau đó chỉ gọi hàm main() để chạy, nên văn bản Hello, World! chỉ được in một lần, sau chuỗi cho biết chúng ta đang ở trong hàm main.

Tiếp theo, chúng ta sẽ làm việc với nhiều hàm, vì vậy, chúng ta nên xem lại phạm vi biến của các biến toàn cục và cục bộ. Nếu bạn định nghĩa một biến trong một khối hàm, bạn sẽ chỉ có thể sử dụng biến đó trong hàm đó. Nếu bạn muốn sử dụng các biến giữa các hàm, tốt hơn hết là nên khai báo một biến toàn cục.

Trong Python, '__main__' là tên của phạm vi mà mã cấp cao nhất sẽ thực thi. Khi một chương trình được chạy từ đầu vào chuẩn, một tập lệnh hoặc từ một dấu nhắc tương tác, __name__ của chương trình đó được đặt bằng '__main__'.

Do đó, có một quy ước để sử dụng cấu trúc sau:

if __name__ == '__main__':
    # Code to run when this is the main program here

Điều này cho phép các tệp chương trình được sử dụng:

• như chương trình chính và chạy những gì theo sau câu lệnh if.
• như một mô-đun và không chạy những gì theo sau câu lệnh if.

Bất kỳ mã nào không có trong câu lệnh này sẽ được thực thi khi chạy. Nếu bạn đang sử dụng tệp chương trình của mình như một mô-đun, mã không có trong câu lệnh này cũng sẽ được thực thi khi nhập tệp đó trong khi chạy tệp phụ.

Hãy mở rộng chương trình names.py ở trên và tạo một tệp mới có tên là more_names.py. Trong chương trình này, chúng ta sẽ khai báo một biến toàn cục và sửa đổi hàm names() gốc của mình để các hướng dẫn nằm trong hai hàm riêng biệt.

Hàm đầu tiên, has_vowel() sẽ kiểm tra xem chuỗi name có chứa nguyên âm không.

Hàm thứ hai print_letters() sẽ in từng chữ cái của chuỗi name.

# Declare global variable name for use in all functions
name = str(input('Enter your name: '))


# Define function to check if name contains a vowel
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Iterate over letters in name string
def print_letters():
    for letter in name:
        print(letter)

Với thiết lập này, chúng ta hãy định nghĩa hàm main() sẽ chứa lệnh gọi đến cả hàm has_vowel() và hàm print_letters().

# Declare global variable name for use in all functions
name = str(input('Enter your name: '))


# Define function to check if name contains a vowel
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Iterate over letters in name string
def print_letters():
    for letter in name:
        print(letter)


# Define main method that calls other functions
def main():
    has_vowel()
    print_letters()

Cuối cùng, chúng ta sẽ thêm if __name__ == '__main__': vào cuối tệp. Đối với mục đích của chúng ta, vì chúng ta đã đặt tất cả các hàm mà chúng ta muốn thực hiện trong hàm main(), chúng ta sẽ gọi hàm main() theo sau câu lệnh if này.

# Declare global variable name for use in all functions
name = str(input('Enter your name: '))


# Define function to check if name contains a vowel
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Iterate over letters in name string
def print_letters():
    for letter in name:
        print(letter)


# Define main method that calls other functions
def main():
    has_vowel()
    print_letters()


# Execute main() function
if __name__ == '__main__':
    main()

Bây giờ chúng ta có thể chạy chương trình:

python more_names.py

Chương trình sẽ hiển thị cùng một đầu ra như chương trình names.py, nhưng ở đây mã được tổ chức tốt hơn và có thể được sử dụng theo cách mô-đun mà không cần sửa đổi.

Nếu bạn không muốn khai báo hàm main(), bạn có thể kết thúc chương trình như sau:

...
if __name__ == '__main__':
    has_vowel()
    print_letters()

Sử dụng main() như một hàm và câu lệnh if __name__ == '__main__': có thể sắp xếp mã của bạn theo cách hợp lý, giúp mã dễ đọc và có tính mô-đun hơn.

Kết luận

Các hàm là các khối mã lệnh thực hiện các hành động trong một chương trình, giúp mã của chúng ta có thể tái sử dụng và có tính mô-đun.

Để tìm hiểu thêm về cách làm cho mã của bạn có tính mô-đun hơn, bạn có thể đọc hướng dẫn của chúng tôi về Cách viết mô-đun trong Python 3.