Trong toán học, hàm biểu diễn mối quan hệ ánh xạ giữa đầu vào và đầu ra, ví dụ như f(x) = 2x + 1. Trong Python, điều này được hiện thực hóa như sau:

def f(x):
    return 2 * x + 1

Hàm trong Python là một khối mã đã được định nghĩa trước, bao gồm ba thành phần chính: đầu vào (tham số), xử lý logic bên trong và đầu ra (giá trị trả về).

Định nghĩa và gọi hàm

Việc sử dụng hàm gồm hai bước: định nghĩa và gọi.

• Định nghĩa: Mô tả cách hàm hoạt động thông qua từ khóa def.
• Gọi hàm: Truyền dữ liệu thực tế để thực thi logic và nhận kết quả.

Ví dụ định nghĩa hàm cộng:

def add(a, b):
    total = a + b
    return total

Gọi hàm và lưu kết quả:

result = add(1, 3)
print('1+3 =', result)

Ví dụ ứng dụng: Quản lý người dùng

user_db = {"alice": "pass123"}

def register(name, pwd):
    if name in user_db:
        print("Tên người dùng đã tồn tại")
    else:
        user_db[name] = pwd
        print("Đăng ký thành công")

def authenticate(name, pwd):
    if name not in user_db:
        print("Người dùng không tồn tại")
    elif user_db[name] == pwd:
        print("Đăng nhập thành công")
    else:
        print("Mật khẩu sai")

Tham số hàm

Tham số xác định thông tin cần cung cấp khi gọi hàm. Có thể không có tham số:

def greet():
    print("Xin chào!")

Tham số hình thức và thực tế

• Hình thức: Tên biến trong định nghĩa hàm (a, b trong def add(a, b)).
• Thực tế: Giá trị hoặc biến truyền vào khi gọi (add(3, 5) hoặc add(x, y) với x=3, y=5).

Gợi ý kiểu (Type Hints)

Từ Python 3.5, hỗ trợ chú thích kiểu dữ liệu:

def multiply(x: float, y: float) -> float:
    return x * y

Lưu ý: Gợi ý kiểu chỉ mang tính hướng dẫn, không bắt buộc kiểm tra tại runtime.

Tham số mặc định

Tham số có giá trị mặc định trở thành tùy chọn khi gọi:

def power(base, exp=2):
    return base ** exp

power(3)      # 9
power(3, 3)   # 27

Tham số mặc định phải đặt sau tham số bắt buộc.

Tham số vị trí và từ khóa

power(2, 3)       # Vị trí
power(exp=3, base=2)  # Từ khóa (không cần đúng thứ tự)

Tham số không xác định

Sử dụng *args cho tham số vị trí và **kwargs cho tham số từ khóa:

def flexible_sum(*numbers, **named_numbers):
    total = sum(numbers)
    total += sum(named_numbers.values())
    return total

flexible_sum(1, 2, x=3, y=4)  # Kết quả: 10

Ràng buộc cách truyền tham số

• /: Các tham số trước dấu này chỉ chấp nhận truyền theo vị trí.
• *: Các tham số sau dấu này chỉ chấp nhận truyền theo từ khóa.

def strict_func(pos_only, /, standard, *, kw_only):
    return pos_only + standard + kw_only

# strict_func(1, 2, kw_only=3)  # Hợp lệ
# strict_func(1, standard=2, kw_only=3)  # Hợp lệ
# strict_func(pos_only=1, standard=2, kw_only=3)  # Lỗi

Giá trị trả về

Hàm có thể trả về bất kỳ đối tượng nào. Dùng return để kết thúc và trả kết quả:

def compute(a, b):
    return a + b, a - b  # Trả về tuple

s, d = compute(5, 3)  # s=8, d=2

Nếu không có return, hàm trả về None.

Phạm vi biến

Biến trong hàm là cục bộ và không ảnh hưởng đến biến cùng tên ở nơi khác. Để sửa đổi biến toàn cục, dùng global:

counter = 0

def increment():
    global counter
    counter += 1

Lưu ý: Với các đối tượng có thể thay đổi (list, dict), bạn có thể sửa đổi nội dung mà không cần global.

Hàm lồng nhau và closure

Hàm có thể được định nghĩa bên trong hàm khác. Hàm con có thể truy cập tham số của hàm cha:

def validator(func):
    def wrapper(x, y):
        if not all(isinstance(i, (int, float)) for i in (x, y)):
            raise TypeError("Chỉ chấp nhận số")
        return func(x, y)
    return wrapper

@validator
def divide(a, b):
    return a / b

Hàm vô danh (Lambda)

Dùng cho các hàm đơn giản:

double = lambda x: x * 2

Hàm bậc cao

Hàm có thể nhận hàm khác làm tham số. Các hàm tiêu biểu: map, filter, reduce.

# map: Áp dụng hàm lên từng phần tử
squared = list(map(lambda x: x**2, [1, 2, 3]))  # [1, 4, 9]

# filter: Lọc phần tử theo điều kiện
evens = list(filter(lambda x: x % 2 == 0, [1, 2, 3, 4]))  # [2, 4]

# reduce: Tổng hợp dãy thành một giá trị
from functools import reduce
total = reduce(lambda x, y: x + y, [1, 2, 3, 4])  # 10

Đệ quy

Hàm gọi lại chính nó. Cần có điều kiện dừng:

def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)