Python的函數(shù)默認(rèn)參數(shù)在定義時只被初始化一次，若使用可變對象（如列表或字典）作為默認(rèn)參數(shù)，可能導(dǎo)致意外行為。例如，使用空列表作為默認(rèn)參數(shù)時，多次調(diào)用函數(shù)會重複使用同一個列表，而非每次生成新列表。此行為引發(fā)的問題包括：1. 函數(shù)調(diào)用間數(shù)據(jù)意外共享；2. 後續(xù)調(diào)用結(jié)果受之前調(diào)用影響，增加調(diào)試難度；3. 造成邏輯錯誤且難以察覺；4. 對新手和有經(jīng)驗開發(fā)者均易產(chǎn)生困惑。為避免問題，最佳實踐是將默認(rèn)值設(shè)為None，並在函數(shù)內(nèi)部創(chuàng)建新對象，例如使用my_list=None代替my_list=[]，並在函數(shù)中初始化列表。此外，應(yīng)審慎判斷是否需要共享狀態(tài)、顯式聲明意圖並清晰記錄API行為。

Python's handling of mutable default arguments in function definitions can be a bit tricky, and if you're not aware of how it works, it can lead to unexpected behavior.

The issue comes from using a mutable object — like a list or dictionary — as a default argument in a function definition. The key point is that default arguments are evaluated only once , when the function is defined, not each time the function is called.

This might seem like a small detail, but it can cause bugs that are hard to track down.

What happens when you use a mutable default argument?

Let's look at a common example:

 def add_item(item, my_list=[]):
    my_list.append(item)
    return my_list

If you call this function multiple times without providing my_list , like this:

 print(add_item('a')) # ['a']
print(add_item('b')) # ['a', 'b']

You might expect each call to start with a new empty list, but instead, the same list is reused across all calls.

Why? Because the default value [] was created once when the function was defined, not each time it's called.

Why is this behavior problematic?

This behavior becomes an issue because it goes against what most people intuitively expect. When writing functions, we usually think of default values as being set fresh every time the function runs.

Here are some specific problems this causes:

• Accidental data sharing between function calls
  One call can affect the result of later calls, which makes debugging harder.

• Hard-to-catch logic errors
  You might spend time chasing down why your list keeps growing even though you didn't intend it to.

• Confusion for beginners (and sometimes pros)
  This is a classic gotcha in Python interviews and real-world code alike.

How to avoid the problem

To prevent this kind of behavior, a common best practice is to use None as the default value and create a new mutable object inside the function:

 def add_item(item, my_list=None):
    if my_list is None:
        my_list = []
    my_list.append(item)
    return my_list

Now calling the function without my_list will correctly give you a fresh list each time.

Other tips:

• Always consider whether a mutable default makes sense for your function.
• If you do want shared state, make it explicit — don't rely on this hidden behavior.
• Document the intended behavior clearly, especially if you're writing a library or API.

In short, Python evaluates default arguments once, which is fine for immutable types like numbers or strings, but leads to surprises with mutable ones. Avoid the trap by using None as a placeholder and initializing the object inside the function.

That's basically how it works — not complicated, but definitely something to watch out for.

以上是Python如何處理函數(shù)中的可變默認(rèn)參數(shù)，為什麼這會出現(xiàn)問題？的詳細(xì)內(nèi)容。更多資訊請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！