Một hàm Python có thể nhận số lượng đối số không giới hạn không?

Xác định các chức năng của riêng bạn là một kỹ năng cần thiết để viết mã rõ ràng và hiệu quả. Trong hướng dẫn này, bạn sẽ khám phá các kỹ thuật có sẵn để xác định các hàm Python nhận đối số tùy chọn. Khi bạn thành thạo các đối số tùy chọn trong Python, bạn sẽ có thể xác định các hàm mạnh hơn và linh hoạt hơn

Trong hướng dẫn này, bạn sẽ học

  • Sự khác biệt giữa tham số và đối số là gì
  • Cách xác định hàm với đối số tùy chọn và giá trị tham số mặc định
  • Cách xác định chức năng bằng cách sử dụng
    # optional_params.py
    
    shopping_list = {}
    
    # ...
    
    def add_item[item_name, quantity]:
        if item_name in shopping_list.keys[]:
            shopping_list[item_name] += quantity
        else:
            shopping_list[item_name] = quantity
    
    add_item["Bread", 1]
    print[shopping_list]
    
    4 và
    # optional_params.py
    
    shopping_list = {}
    
    # ...
    
    def add_item[item_name, quantity]:
        if item_name in shopping_list.keys[]:
            shopping_list[item_name] += quantity
        else:
            shopping_list[item_name] = quantity
    
    add_item["Bread", 1]
    print[shopping_list]
    
    5
  • Cách xử lý thông báo lỗi về đối số tùy chọn

Để tận dụng tối đa hướng dẫn này, bạn sẽ cần làm quen với việc xác định các hàm với các đối số bắt buộc

Tiền thưởng miễn phí. Nhấp vào đây để nhận Bảng cheat Python và tìm hiểu kiến ​​thức cơ bản về Python 3, như làm việc với các kiểu dữ liệu, từ điển, danh sách và hàm Python

Tạo hàm trong Python để sử dụng lại mã

Bạn có thể coi một hàm như một chương trình nhỏ chạy bên trong một chương trình khác hoặc bên trong một hàm khác. Chương trình chính gọi chương trình nhỏ và gửi thông tin mà chương trình nhỏ sẽ cần khi nó chạy. Khi chức năng hoàn thành tất cả các hành động của nó, nó có thể gửi một số dữ liệu trở lại chương trình chính đã gọi nó

Mục đích chính của một hàm là cho phép bạn sử dụng lại mã bên trong nó bất cứ khi nào bạn cần, sử dụng các đầu vào khác nhau nếu được yêu cầu

Khi bạn sử dụng các hàm, bạn đang mở rộng vốn từ vựng Python của mình. Điều này cho phép bạn trình bày giải pháp cho vấn đề của mình một cách rõ ràng và ngắn gọn hơn

Trong Python, theo quy ước, bạn nên đặt tên hàm bằng các chữ cái viết thường với các từ được phân tách bằng dấu gạch dưới, chẳng hạn như

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
6. Các quy ước này được mô tả trong PEP 8, là hướng dẫn về phong cách của Python. Bạn sẽ cần thêm dấu ngoặc đơn sau tên hàm khi bạn gọi nó. Vì các hàm đại diện cho các hành động, nên cách tốt nhất là bắt đầu tên hàm của bạn bằng một động từ để làm cho mã của bạn dễ đọc hơn

Loại bỏ các quảng cáo

Xác định chức năng không có tham số đầu vào

Trong hướng dẫn này, bạn sẽ sử dụng ví dụ về một chương trình cơ bản tạo và duy trì danh sách mua sắm và in nó ra khi bạn sẵn sàng đi siêu thị

Bắt đầu bằng cách tạo một danh sách mua sắm

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

Bạn đang sử dụng từ điển để lưu trữ tên mặt hàng làm khóa và số lượng bạn cần mua của từng mặt hàng làm giá trị. Bạn có thể xác định một chức năng để hiển thị danh sách mua sắm

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]

Khi bạn chạy tập lệnh này, bạn sẽ nhận được bản in danh sách mua sắm

$ python optional_params.py
1x Bread
2x Milk
1x Chocolate
1x Butter
1x Coffee

Hàm bạn đã xác định không có tham số đầu vào vì dấu ngoặc đơn trong chữ ký hàm trống. Chữ ký là dòng đầu tiên trong định nghĩa hàm

def show_list[]:

Bạn không cần bất kỳ tham số đầu vào nào trong ví dụ này vì từ điển

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
7 là một biến toàn cục. Điều này có nghĩa là nó có thể được truy cập từ mọi nơi trong chương trình, kể cả từ bên trong định nghĩa hàm. Đây được gọi là phạm vi toàn cầu. Bạn có thể đọc thêm về phạm vi trong Phạm vi Python & Quy tắc LEGB. Giải quyết tên trong mã của bạn

Sử dụng các biến toàn cầu theo cách này không phải là một cách làm tốt. Nó có thể dẫn đến một số chức năng thực hiện các thay đổi đối với cùng một cấu trúc dữ liệu, điều này có thể dẫn đến các lỗi khó tìm. Bạn sẽ thấy cách cải thiện điều này sau trong hướng dẫn này khi bạn chuyển từ điển cho hàm dưới dạng đối số

Trong phần tiếp theo, bạn sẽ định nghĩa một hàm có các tham số đầu vào

Xác định hàm với các đối số đầu vào bắt buộc

Thay vì viết trực tiếp danh sách mua sắm vào mã, giờ đây bạn có thể khởi tạo một từ điển trống và viết một hàm cho phép bạn thêm các mục vào danh sách mua sắm

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]

Hàm lặp qua các khóa của từ điển và nếu khóa tồn tại, số lượng sẽ tăng lên. Nếu mục không phải là một trong các khóa, khóa sẽ được tạo và giá trị

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
8 được gán cho nó. Bạn có thể chạy tập lệnh này để hiển thị từ điển đã in

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
0

Bạn đã bao gồm hai tham số trong chữ ký hàm

  1. # optional_params.py
    
    shopping_list = {}
    
    # ...
    
    def add_item[item_name, quantity]:
        if item_name in shopping_list.keys[]:
            shopping_list[item_name] += quantity
        else:
            shopping_list[item_name] = quantity
    
    add_item["Bread", 1]
    print[shopping_list]
    
    9
  2. # optional_params.py
    
    shopping_list = {}
    
    # ...
    
    def add_item[item_name, quantity]:
        if item_name in shopping_list.keys[]:
            shopping_list[item_name] += quantity
        else:
            shopping_list[item_name] = quantity
    
    add_item["Bread", 1]
    print[shopping_list]
    
    00

Các tham số chưa có bất kỳ giá trị nào. Tên tham số được sử dụng trong mã trong định nghĩa hàm. Khi bạn gọi hàm, bạn truyền các đối số trong dấu ngoặc đơn, mỗi đối số cho một tham số. Đối số là một giá trị bạn chuyển đến hàm

Sự khác biệt giữa tham số và đối số thường có thể bị bỏ qua. Đó là một sự khác biệt tinh tế nhưng quan trọng. Đôi khi bạn có thể tìm thấy các tham số được gọi là tham số chính thức và đối số là tham số thực tế

Các đối số bạn nhập khi gọi

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
01 là các đối số bắt buộc. Nếu bạn cố gọi hàm mà không có đối số, bạn sẽ gặp lỗi

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
4

Traceback sẽ cung cấp một

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
02 nói rằng các đối số là bắt buộc

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
6

Bạn sẽ xem thêm các thông báo lỗi liên quan đến việc sử dụng sai số lượng đối số hoặc sử dụng chúng sai thứ tự trong phần sau của hướng dẫn này

Loại bỏ các quảng cáo

Sử dụng các đối số tùy chọn của Python với các giá trị mặc định

Trong phần này, bạn sẽ tìm hiểu cách xác định hàm nhận đối số tùy chọn. Các hàm có đối số tùy chọn giúp bạn sử dụng chúng linh hoạt hơn. Bạn có thể gọi hàm có hoặc không có đối số và nếu không có đối số trong lệnh gọi hàm thì giá trị mặc định sẽ được sử dụng

Giá trị mặc định được gán cho tham số đầu vào

Bạn có thể sửa hàm

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
01 để tham số
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
00 có giá trị mặc định

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
9

Trong chữ ký hàm, bạn đã thêm giá trị mặc định

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
8 vào tham số
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
00. Điều này không có nghĩa là giá trị của
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
00 sẽ luôn là
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
8. Nếu bạn truyền một đối số tương ứng với
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
00 khi gọi hàm, thì đối số đó sẽ được sử dụng làm giá trị cho tham số. Tuy nhiên, nếu bạn không chuyển bất kỳ đối số nào thì giá trị mặc định sẽ được sử dụng

Các tham số có giá trị mặc định không thể được theo sau bởi các tham số thông thường. Bạn sẽ đọc thêm về thứ tự mà bạn có thể xác định các tham số sau trong hướng dẫn này

Hàm

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
01 hiện có một tham số bắt buộc và một tham số tùy chọn. Trong ví dụ mã trên, bạn gọi
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
01 hai lần. Cuộc gọi hàm đầu tiên của bạn có một đối số duy nhất, tương ứng với tham số bắt buộc
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
9. Trong trường hợp này,
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
00 mặc định là
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
8. Lệnh gọi hàm thứ hai của bạn có hai đối số, vì vậy giá trị mặc định không được sử dụng trong trường hợp này. Bạn có thể thấy đầu ra của điều này dưới đây

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}
0

Bạn cũng có thể chuyển các đối số bắt buộc và tùy chọn vào một hàm dưới dạng đối số từ khóa. Đối số từ khóa cũng có thể được gọi là đối số được đặt tên

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
0

Bây giờ bạn có thể xem lại chức năng đầu tiên mà bạn đã xác định trong hướng dẫn này và cấu trúc lại nó để nó cũng chấp nhận một đối số mặc định

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
1

Bây giờ khi bạn sử dụng

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
45, bạn có thể gọi nó mà không cần đối số đầu vào hoặc chuyển giá trị Boolean làm đối số cờ. Nếu bạn không truyền bất kỳ đối số nào khi gọi hàm, thì danh sách mua sắm được hiển thị bằng cách hiển thị tên và số lượng của từng mặt hàng. Hàm sẽ hiển thị cùng một đầu ra nếu bạn chuyển
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
46 làm đối số khi gọi hàm. Tuy nhiên, nếu bạn sử dụng
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
47, chỉ có tên mục được hiển thị

Bạn nên tránh sử dụng cờ trong trường hợp giá trị của cờ làm thay đổi đáng kể hành vi của hàm. Một chức năng chỉ nên chịu trách nhiệm cho một điều. Nếu bạn muốn một cờ để đẩy hàm vào một đường dẫn thay thế, bạn có thể cân nhắc viết một hàm riêng thay thế

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

Trong các ví dụ bạn đã làm ở trên, bạn đã sử dụng số nguyên

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
8 làm giá trị mặc định trong một trường hợp và giá trị Boolean
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
46 trong trường hợp kia. Đây là những giá trị mặc định phổ biến mà bạn sẽ tìm thấy trong định nghĩa hàm. Tuy nhiên, loại dữ liệu bạn nên sử dụng cho các giá trị mặc định tùy thuộc vào chức năng bạn đang xác định và cách bạn muốn chức năng được sử dụng

Các số nguyên

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
60 và
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
8 là các giá trị mặc định phổ biến được sử dụng khi giá trị của tham số cần phải là số nguyên. Điều này là do
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
60 và
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
8 thường là các giá trị dự phòng hữu ích để có. Trong hàm
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
01 bạn đã viết trước đó, đặt số lượng cho mặt hàng mới thành
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
8 là tùy chọn hợp lý nhất

Tuy nhiên, nếu bạn có thói quen mua hai thứ khi đi siêu thị, thì việc đặt giá trị mặc định thành

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
66 có thể phù hợp hơn với bạn

Khi tham số đầu vào cần là một chuỗi, giá trị mặc định phổ biến được sử dụng là chuỗi rỗng [

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
67]. Điều này gán một giá trị có kiểu dữ liệu là chuỗi nhưng không đặt thêm bất kỳ ký tự nào. Bạn có thể sửa đổi
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
01 để cả hai đối số đều là tùy chọn

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
2

Bạn đã sửa đổi hàm để cả hai tham số đều có giá trị mặc định và do đó hàm có thể được gọi mà không cần tham số đầu vào

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
3

Dòng mã này sẽ thêm một mục vào từ điển

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
7 với một chuỗi trống làm khóa và giá trị là
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
8. Việc kiểm tra xem một đối số đã được truyền hay chưa khi hàm được gọi và chạy một số mã tương ứng là điều khá phổ biến. Bạn có thể thay đổi chức năng trên để làm điều này

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
4

Trong phiên bản này, nếu không có mục nào được chuyển đến hàm, thì hàm sẽ đặt số lượng thành

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
60. Chuỗi trống có giá trị sai, có nghĩa là
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
92 trả về
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
93, trong khi bất kỳ chuỗi nào khác sẽ có giá trị trung thực. Khi một từ khóa
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
94 được theo sau bởi một giá trị trung thực hoặc sai, câu lệnh
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
94 sẽ diễn giải những giá trị này là
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
46 hoặc
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
93. Bạn có thể đọc thêm về giá trị thật và giả trong Python Booleans. Tối ưu hóa mã của bạn với các giá trị thật

Do đó, bạn có thể sử dụng biến trực tiếp trong câu lệnh

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
94 để kiểm tra xem đối số tùy chọn có được sử dụng hay không

Một giá trị phổ biến khác thường được sử dụng làm giá trị mặc định là

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
99. Đây là cách Python đại diện cho không có gì, mặc dù nó thực sự là một đối tượng đại diện cho giá trị null. Bạn sẽ thấy một ví dụ về thời điểm
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
99 là giá trị mặc định hữu ích để sử dụng trong phần tiếp theo

Loại bỏ các quảng cáo

Các loại dữ liệu không nên được sử dụng làm đối số mặc định

Bạn đã sử dụng số nguyên và chuỗi làm giá trị mặc định trong các ví dụ trên và

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
99 là một giá trị mặc định phổ biến khác. Đây không phải là loại dữ liệu duy nhất bạn có thể sử dụng làm giá trị mặc định. Tuy nhiên, không phải tất cả các loại dữ liệu nên được sử dụng

Trong phần này, bạn sẽ thấy tại sao không nên sử dụng các kiểu dữ liệu có thể thay đổi làm giá trị mặc định trong các định nghĩa hàm. Đối tượng có thể thay đổi là đối tượng có thể thay đổi giá trị, chẳng hạn như danh sách hoặc từ điển. Bạn có thể tìm hiểu thêm về các loại dữ liệu có thể thay đổi và không thể thay đổi trong Tính bất biến trong Python và trong tài liệu chính thức của Python

Bạn có thể thêm từ điển chứa tên mặt hàng và số lượng làm tham số đầu vào cho chức năng bạn đã xác định trước đó. Bạn có thể bắt đầu bằng cách tạo tất cả các đối số cần thiết

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
5

Bây giờ bạn có thể truyền

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
7 vào hàm khi bạn gọi nó. Điều này làm cho hàm trở nên khép kín hơn vì nó không dựa vào một biến có tên là
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
7 để tồn tại trong phạm vi đang gọi hàm. Thay đổi này cũng làm cho chức năng linh hoạt hơn khi bạn có thể sử dụng nó với các từ điển đầu vào khác nhau

Bạn cũng đã thêm câu lệnh

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}
04 để trả lại từ điển đã sửa đổi. Về mặt kỹ thuật, dòng này không bắt buộc ở giai đoạn này vì từ điển là loại dữ liệu có thể thay đổi và do đó, hàm sẽ thay đổi trạng thái của từ điển tồn tại trong mô-đun chính. Tuy nhiên, bạn sẽ cần câu lệnh
shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}
04 sau này khi bạn đặt đối số này là tùy chọn, vì vậy tốt nhất bạn nên thêm nó ngay bây giờ

Để gọi hàm, bạn cần gán dữ liệu do hàm trả về cho một biến

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
6

Bạn cũng có thể thêm tham số

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
7 vào
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
45, hàm đầu tiên bạn đã xác định trong hướng dẫn này. Giờ đây, bạn có thể có một số danh sách mua sắm trong chương trình của mình và sử dụng các chức năng tương tự để thêm các mục và hiển thị danh sách mua sắm

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
7

Bạn có thể thấy đầu ra của mã này dưới đây. Danh sách các mặt hàng cần mua từ cửa hàng phần cứng được hiển thị đầu tiên. Phần thứ hai của đầu ra hiển thị các mặt hàng cần thiết từ siêu thị

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
8

Bây giờ, bạn sẽ thêm một giá trị mặc định cho tham số

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
7 trong
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
01 để nếu không có từ điển nào được chuyển đến hàm thì từ điển trống sẽ được sử dụng. Tùy chọn hấp dẫn nhất là biến giá trị mặc định thành một từ điển trống. Bạn sẽ sớm thấy tại sao đây không phải là một ý tưởng hay, nhưng bạn có thể thử tùy chọn này ngay bây giờ

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
9

Khi bạn chạy tập lệnh này, bạn sẽ nhận được kết quả bên dưới hiển thị các mặt hàng cần thiết từ cửa hàng quần áo, điều này có thể tạo ấn tượng rằng mã này hoạt động như dự kiến

$ python optional_params.py
1x Bread
2x Milk
1x Chocolate
1x Butter
1x Coffee
0

Tuy nhiên, mã này có một lỗ hổng nghiêm trọng có thể dẫn đến kết quả không mong muốn và sai. Bạn có thể thêm danh sách mua sắm mới cho các mặt hàng cần thiết từ cửa hàng điện tử bằng cách sử dụng

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
01 mà không có đối số tương ứng với
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
7. Điều này dẫn đến giá trị mặc định được sử dụng mà bạn hy vọng sẽ tạo ra một từ điển trống mới

$ python optional_params.py
1x Bread
2x Milk
1x Chocolate
1x Butter
1x Coffee
1

Bạn sẽ thấy vấn đề khi nhìn vào đầu ra từ mã này

$ python optional_params.py
1x Bread
2x Milk
1x Chocolate
1x Butter
1x Coffee
2

Cả hai danh sách mua sắm đều giống nhau mặc dù bạn đã chỉ định đầu ra từ

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
01 cho các biến khác nhau mỗi khi bạn gọi hàm. Sự cố xảy ra vì từ điển là loại dữ liệu có thể thay đổi

Bạn đã chỉ định một từ điển trống làm giá trị mặc định cho tham số

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
7 khi bạn xác định hàm. Lần đầu tiên bạn gọi hàm, từ điển này trống. Tuy nhiên, vì từ điển là loại có thể thay đổi nên khi bạn gán giá trị cho từ điển, từ điển mặc định sẽ không còn trống nữa

Khi bạn gọi hàm lần thứ hai và giá trị mặc định cho

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
7 được yêu cầu một lần nữa, từ điển mặc định không còn trống vì nó được điền vào lần đầu tiên bạn gọi hàm. Vì bạn đang gọi cùng một chức năng nên bạn đang sử dụng cùng một từ điển mặc định được lưu trữ trong bộ nhớ

Hành vi này không xảy ra với các loại dữ liệu không thay đổi. Giải pháp cho vấn đề này là sử dụng một giá trị mặc định khác, chẳng hạn như

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
99, sau đó tạo một từ điển trống bên trong hàm khi không có đối số tùy chọn nào được chuyển

$ python optional_params.py
1x Bread
2x Milk
1x Chocolate
1x Butter
1x Coffee
3

Bạn có thể kiểm tra xem một từ điển đã được chuyển thành đối số hay chưa bằng cách sử dụng câu lệnh

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
94. Bạn không nên dựa vào bản chất giả tạo của
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
99 mà thay vào đó hãy kiểm tra rõ ràng xem đối số có phải là
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
99 không. Việc dựa vào thực tế là
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
99 sẽ được coi là một giá trị sai có thể gây ra sự cố nếu một đối số khác là sai được thông qua

Bây giờ, khi bạn chạy lại tập lệnh của mình, bạn sẽ nhận được đầu ra chính xác vì một từ điển mới được tạo mỗi khi bạn sử dụng hàm có giá trị mặc định cho

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
7

$ python optional_params.py
1x Bread
2x Milk
1x Chocolate
1x Butter
1x Coffee
4

Bạn phải luôn tránh sử dụng loại dữ liệu có thể thay đổi làm giá trị mặc định khi xác định hàm có tham số tùy chọn

Loại bỏ các quảng cáo

Thông báo lỗi liên quan đến đối số đầu vào

Một trong những thông báo lỗi phổ biến nhất mà bạn sẽ gặp phải là khi bạn gọi một hàm có đối số bắt buộc, nhưng bạn không chuyển đối số trong lệnh gọi hàm

$ python optional_params.py
1x Bread
2x Milk
1x Chocolate
1x Butter
1x Coffee
5

Tại đây, bạn gọi

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
01 mà không chuyển các đối số bắt buộc là
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
9 và
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
00. Bạn sẽ nhận được một
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
02 bất cứ khi nào một đối số bắt buộc bị thiếu

$ python optional_params.py
1x Bread
2x Milk
1x Chocolate
1x Butter
1x Coffee
6

Thông báo lỗi là một thông báo hữu ích trong trường hợp này. Thông báo lỗi không phải lúc nào cũng hữu ích như thông báo này. Tuy nhiên, việc thiếu các tham số bắt buộc không phải là thông báo lỗi duy nhất mà bạn gặp phải khi học cách xác định hàm với các tham số bắt buộc và tùy chọn

Khi không có tham số nào trong định nghĩa hàm có giá trị mặc định, bạn có thể sắp xếp thứ tự các tham số theo bất kỳ cách nào bạn muốn. Điều tương tự cũng áp dụng khi tất cả các tham số có giá trị mặc định. Tuy nhiên, khi bạn có một số tham số có giá trị mặc định và những tham số khác không có, thì thứ tự xác định tham số là rất quan trọng

Bạn có thể thử hoán đổi thứ tự của các tham số có và không có giá trị mặc định trong định nghĩa của

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
01

$ python optional_params.py
1x Bread
2x Milk
1x Chocolate
1x Butter
1x Coffee
7

Thông báo lỗi bạn sẽ nhận được khi chạy mã này giải thích quy tắc khá rõ ràng

$ python optional_params.py
1x Bread
2x Milk
1x Chocolate
1x Butter
1x Coffee
8

Các tham số không có giá trị mặc định phải luôn xuất hiện trước các tham số có giá trị mặc định. Trong ví dụ trên,

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
9 và
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
00 phải luôn được gán một giá trị làm đối số. Đặt các tham số có giá trị mặc định trước sẽ khiến lệnh gọi hàm trở nên mơ hồ. Sau đó, hai đối số bắt buộc đầu tiên có thể được theo sau bởi một đối số thứ ba tùy chọn

Sử dụng
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
4 và
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
5

Có hai loại đối số tùy chọn Python khác mà bạn cần biết về. Trong các phần trước của hướng dẫn này, bạn đã học cách tạo một hàm với đối số tùy chọn. Nếu cần thêm đối số tùy chọn, bạn có thể tạo thêm tham số với giá trị mặc định khi định nghĩa hàm

Tuy nhiên, có thể định nghĩa một hàm chấp nhận bất kỳ số lượng đối số tùy chọn nào. Bạn thậm chí có thể xác định các hàm chấp nhận bất kỳ số lượng đối số từ khóa nào. Đối số từ khóa là đối số có từ khóa và giá trị được liên kết với chúng, như bạn sẽ tìm hiểu trong các phần tiếp theo

Để xác định các hàm có số lượng đối số đầu vào và từ khóa thay đổi, bạn sẽ cần tìm hiểu về

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
4 và
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
5. Trong hướng dẫn này, chúng ta sẽ xem xét những điểm quan trọng nhất mà bạn cần biết về các đối số tùy chọn Python này. Bạn có thể khám phá thêm về
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
4 và
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
5 nếu muốn tìm hiểu thêm

Các hàm chấp nhận bất kỳ số lượng đối số nào

Trước khi xác định một hàm chấp nhận bất kỳ số lượng đối số nào, bạn cần làm quen với toán tử giải nén. Bạn có thể bắt đầu với một danh sách chẳng hạn như danh sách sau

>>>

$ python optional_params.py
1x Bread
2x Milk
1x Chocolate
1x Butter
1x Coffee
9

Biến

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
24 trỏ đến một danh sách và đến lượt danh sách đó có bốn mục trong đó. Nếu bạn sử dụng
# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
24 làm đối số cho
# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
26, thì bạn đang chuyển một biến cho
# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
26

>>>

def show_list[]:
0

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
26 hiển thị danh sách, như bạn mong đợi. Tuy nhiên, nếu bạn phải sử dụng
# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
29 trong ngoặc đơn của
# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
26, bạn sẽ nhận được một kết quả khác

>>>

def show_list[]:
1

Lần này,

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
26 hiển thị bốn chuỗi riêng biệt thay vì danh sách. Điều này tương đương với việc viết như sau

>>>

def show_list[]:
2

Khi dấu hoa thị hoặc biểu tượng ngôi sao [

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
32] được sử dụng ngay trước một trình tự, chẳng hạn như
# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
24, nó sẽ giải nén trình tự thành các thành phần riêng lẻ của nó. Khi một chuỗi chẳng hạn như danh sách được giải nén, các mục của nó được trích xuất và xử lý như các đối tượng riêng lẻ

Bạn có thể nhận thấy rằng

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
26 có thể lấy bất kỳ số đối số nào. Bạn đã sử dụng nó với một đối số đầu vào và bốn đối số đầu vào trong các ví dụ trên. Bạn cũng có thể sử dụng
# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
26 với dấu ngoặc đơn trống và nó sẽ in ra một dòng trống

Bây giờ bạn đã sẵn sàng để xác định các hàm của riêng mình chấp nhận một số lượng đối số đầu vào khác nhau. Hiện tại, bạn có thể đơn giản hóa

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
36 để chỉ chấp nhận tên của các mặt hàng bạn muốn trong danh sách mua sắm. Bạn sẽ đặt số lượng thành
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
8 cho mỗi mặt hàng. Sau đó, bạn sẽ quay lại bao gồm các số lượng như một phần của đối số đầu vào trong phần tiếp theo

Chữ ký hàm bao gồm số lượng đối số đầu vào có thể thay đổi bằng cách sử dụng

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
4 trông như thế này

def show_list[]:
3

Bạn sẽ thường thấy các chữ ký hàm sử dụng tên

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
4 để biểu thị loại đối số tùy chọn này. Tuy nhiên đây chỉ là tên tham số. Không có gì đặc biệt về cái tên
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
4. Chính
# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
32 trước đó cung cấp cho tham số này các thuộc tính cụ thể của nó, mà bạn sẽ đọc bên dưới. Thông thường, tốt hơn là sử dụng tên tham số phù hợp nhất với nhu cầu của bạn để làm cho mã dễ đọc hơn, như trong ví dụ bên dưới

def show_list[]:
4

Đối số đầu tiên khi gọi

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
36 là đối số bắt buộc. Sau đối số đầu tiên, hàm có thể chấp nhận bất kỳ số lượng đối số bổ sung nào. Trong trường hợp này, bạn đã thêm bốn đối số bổ sung khi gọi hàm. Đây là đầu ra của đoạn mã trên

def show_list[]:
5

Bạn có thể hiểu điều gì đang xảy ra với tham số

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
43 bằng cách xem một ví dụ đơn giản

>>>

def show_list[]:
6

Khi bạn hiển thị kiểu dữ liệu, bạn có thể thấy rằng

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
43 là một tuple. Do đó, tất cả các đối số bổ sung được chỉ định làm mục trong bộ dữ liệu
# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
43. Sau đó, bạn có thể sử dụng bộ này trong định nghĩa hàm như bạn đã làm trong định nghĩa chính của
# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
36 ở trên, trong đó bạn đang lặp qua bộ
# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
43 bằng cách sử dụng vòng lặp
# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
48

Điều này không giống với việc chuyển một bộ làm đối số trong lời gọi hàm. Sử dụng

# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
49 cho phép bạn sử dụng hàm linh hoạt hơn vì bạn có thể thêm bao nhiêu đối số tùy thích mà không cần đặt chúng vào một bộ trong lệnh gọi hàm

Nếu bạn không thêm bất kỳ đối số bổ sung nào khi gọi hàm, thì bộ dữ liệu sẽ trống

>>>

def show_list[]:
7

Khi bạn thêm

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
4 vào định nghĩa hàm, thông thường bạn sẽ thêm chúng sau tất cả các tham số bắt buộc và tùy chọn. Bạn có thể có các đối số chỉ từ khóa tuân theo
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
4, nhưng đối với hướng dẫn này, bạn có thể giả sử rằng
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
4 thường sẽ được thêm vào sau tất cả các đối số khác, ngoại trừ
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
5, mà bạn sẽ tìm hiểu trong phần sau

Loại bỏ các quảng cáo

Hàm chấp nhận bất kỳ số lượng đối số từ khóa nào

Khi bạn xác định hàm có tham số, bạn có thể chọn gọi hàm bằng cách sử dụng đối số không phải từ khóa hoặc đối số từ khóa

>>>

def show_list[]:
8

Trong lệnh gọi hàm đầu tiên, các đối số được truyền theo vị trí, trong khi ở lệnh gọi thứ hai, chúng được truyền theo từ khóa. Nếu bạn sử dụng các đối số từ khóa, bạn không còn cần phải nhập các đối số theo thứ tự chúng được xác định

>>>

def show_list[]:
9

Bạn có thể thay đổi hành vi mặc định này bằng cách khai báo đối số chỉ vị trí hoặc đối số chỉ từ khóa

Khi xác định một hàm, bạn có thể bao gồm bất kỳ số lượng đối số từ khóa tùy chọn nào bằng cách sử dụng

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
5, viết tắt của đối số từ khóa. Chữ ký chức năng trông như thế này

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
0

Tên tham số

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
5 đứng trước hai dấu hoa thị [
# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
56]. Dấu sao đôi hoặc dấu hoa thị hoạt động tương tự như dấu hoa thị đơn mà bạn đã sử dụng trước đó để giải nén các mục khỏi chuỗi. Ngôi sao đôi được sử dụng để giải nén các mục từ ánh xạ. Ánh xạ là một loại dữ liệu có các giá trị được ghép nối dưới dạng các mục, chẳng hạn như từ điển

Tên tham số

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
5 thường được sử dụng trong định nghĩa hàm, nhưng tham số có thể có bất kỳ tên nào khác miễn là nó đứng trước toán tử
# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
56. Bây giờ bạn có thể viết lại
# optional_params.py

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list[]:
    for item_name, quantity in shopping_list.items[]:
        print[f"{quantity}x {item_name}"]

show_list[]
36 để nó chấp nhận bất kỳ số lượng đối số từ khóa nào

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
1

Đầu ra từ mã này hiển thị các mục trong từ điển

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
7, hiển thị tất cả bốn thứ bạn muốn mua và số lượng tương ứng của chúng. Bạn đã bao gồm thông tin này làm đối số từ khóa khi bạn gọi hàm

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
2

Trước đó, bạn đã biết rằng

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
4 là một bộ và các đối số không phải từ khóa tùy chọn được sử dụng trong lệnh gọi hàm được lưu trữ dưới dạng các mục trong bộ. Các đối số từ khóa tùy chọn được lưu trữ trong một từ điển và các đối số từ khóa được lưu trữ dưới dạng các cặp khóa-giá trị trong từ điển này

>>>

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
3

Để tìm hiểu thêm về

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
4 và
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
5, bạn có thể đọc Python args và kwargs. Làm sáng tỏ và bạn sẽ tìm thấy nhiều chi tiết hơn về các đối số từ khóa và không phải từ khóa trong các hàm và thứ tự các đối số có thể được sử dụng trong Xác định hàm Python của riêng bạn

Phần kết luận

Xác định chức năng của riêng bạn để tạo một chương trình con độc lập là một trong những khối xây dựng quan trọng khi viết mã. Các chức năng mạnh mẽ và hữu ích nhất là những chức năng thực hiện một nhiệm vụ rõ ràng và bạn có thể sử dụng một cách linh hoạt. Sử dụng các đối số tùy chọn là một kỹ thuật quan trọng để đạt được điều này

Trong hướng dẫn này, bạn đã học

  • Sự khác biệt giữa tham số và đối số là gì
  • Cách xác định hàm với đối số tùy chọn và giá trị tham số mặc định
  • Cách xác định chức năng bằng cách sử dụng
    # optional_params.py
    
    shopping_list = {}
    
    # ...
    
    def add_item[item_name, quantity]:
        if item_name in shopping_list.keys[]:
            shopping_list[item_name] += quantity
        else:
            shopping_list[item_name] = quantity
    
    add_item["Bread", 1]
    print[shopping_list]
    
    4 và
    # optional_params.py
    
    shopping_list = {}
    
    # ...
    
    def add_item[item_name, quantity]:
        if item_name in shopping_list.keys[]:
            shopping_list[item_name] += quantity
        else:
            shopping_list[item_name] = quantity
    
    add_item["Bread", 1]
    print[shopping_list]
    
    5
  • Cách xử lý thông báo lỗi về đối số tùy chọn

Hiểu rõ về các đối số tùy chọn cũng sẽ giúp bạn sử dụng các hàm trong thư viện chuẩn và trong các mô-đun bên thứ ba khác. Hiển thị tài liệu cho các hàm này sẽ hiển thị cho bạn chữ ký hàm mà từ đó bạn có thể xác định đối số nào là bắt buộc, đối số nào là tùy chọn và đối số nào là

# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
4 hoặc
# optional_params.py

shopping_list = {}

# ...

def add_item[item_name, quantity]:
    if item_name in shopping_list.keys[]:
        shopping_list[item_name] += quantity
    else:
        shopping_list[item_name] = quantity

add_item["Bread", 1]
print[shopping_list]
5

Tuy nhiên, kỹ năng chính mà bạn đã học được trong hướng dẫn này là xác định các chức năng của riêng bạn. Bây giờ bạn có thể bắt đầu viết các hàm với các tham số bắt buộc và tùy chọn và với một số đối số không phải từ khóa và từ khóa có thể thay đổi. Nắm vững những kỹ năng này sẽ giúp bạn đưa code Python của mình lên một tầm cao mới

Đánh dấu là đã hoàn thành

Xem ngay Hướng dẫn này có một khóa học video liên quan do nhóm Real Python tạo. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn. Xác định các hàm Python bằng các đối số tùy chọn

🐍 Thủ thuật Python 💌

Nhận một Thủ thuật Python ngắn và hấp dẫn được gửi đến hộp thư đến của bạn vài ngày một lần. Không có thư rác bao giờ. Hủy đăng ký bất cứ lúc nào. Được quản lý bởi nhóm Real Python

Gửi cho tôi thủ thuật Python »

Giới thiệu về Stephen Gruppetta

Stephen từng làm việc với tư cách là nhà vật lý nghiên cứu, phát triển các hệ thống hình ảnh để phát hiện bệnh về mắt. Bây giờ anh ấy dạy viết mã bằng Python cho trẻ em và người lớn. Và anh ấy gần như đã hoàn thành cuốn sách mã hóa Python đầu tiên của mình cho người mới bắt đầu

» Thông tin thêm về Stephen

Mỗi hướng dẫn tại Real Python được tạo bởi một nhóm các nhà phát triển để nó đáp ứng các tiêu chuẩn chất lượng cao của chúng tôi. Các thành viên trong nhóm đã làm việc trong hướng dẫn này là

Aldren

Bartosz

Joanna

Gia-cốp

leodanis

Bậc thầy Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng nghìn hướng dẫn, khóa học video thực hành và cộng đồng các Pythonistas chuyên gia

Nâng cao kỹ năng Python của bạn »

Bậc thầy Kỹ năng Python trong thế giới thực
Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng Pythonistas chuyên gia

Nâng cao kỹ năng Python của bạn »

Bạn nghĩ sao?

Đánh giá bài viết này

Tweet Chia sẻ Chia sẻ Email

Bài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?

Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. Nhận các mẹo để đặt câu hỏi hay và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi

Hàm có thể nhận số lượng đối số không giới hạn không?

Hàm có thể xác định giá trị đối số mặc định, hàm có thể được gọi bằng đối số từ khóa và hàm có thể được viết để chấp nhận bất kỳ số lượng đối số nào .

Một hàm có thể lấy bao nhiêu đối số trong Python?

Trong Python, chúng ta có thể định nghĩa hai loại tham số có độ dài thay đổi. Chúng có thể được coi là các loại tham số tùy chọn đặc biệt. Nói cách khác, không có giới hạn về số lượng đối số được truyền cho tham số khi chúng ta gọi hàm này .

Có thể cho một hàm có tham số vô hạn Python không?

Có. Bạn có thể sử dụng *args làm đối số không phải từ khóa. Sau đó, bạn sẽ có thể chuyển bất kỳ số lượng đối số nào .

Có bao nhiêu đối số có thể nhận tối đa trong Python?

Hàm Python – max[] . Nó có hai hình thức. two or more arguments. It has two forms.

Chủ Đề