Bất cứ ai cũng mày mò với Python đủ lâu đã bị cắn (hoặc bị xé thành từng mảnh) bởi vấn đề sau:

def foo(a=[]):
    a.append(5)
    return a

Người mới dùng Python sẽ mong đợi hàm này luôn trả về một danh sách chỉ có một phần tử : [5]. Thay vào đó, kết quả rất khác biệt và rất đáng kinh ngạc (đối với người mới):

>>> foo()
[5]
>>> foo()
[5, 5]
>>> foo()
[5, 5, 5]
>>> foo()
[5, 5, 5, 5]
>>> foo()

Một người quản lý của tôi đã có lần gặp gỡ đầu tiên với tính năng này và gọi nó là "lỗ hổng thiết kế ấn tượng" của ngôn ngữ. Tôi đã trả lời rằng hành vi đó có một lời giải thích cơ bản, và nó thực sự rất khó hiểu và bất ngờ nếu bạn không hiểu nội bộ. Tuy nhiên, tôi không thể trả lời (cho chính mình) câu hỏi sau: lý do ràng buộc đối số mặc định ở định nghĩa hàm và không phải khi thực hiện chức năng là gì? Tôi nghi ngờ hành vi có kinh nghiệm có một cách sử dụng thực tế (ai thực sự sử dụng biến tĩnh trong C, không có lỗi sinh sản?)

Chỉnh sửa :

Baczek đã làm một ví dụ thú vị. Cùng với hầu hết các bình luận của bạn và của Utaal nói riêng, tôi đã nói rõ hơn:

>>> def a():
...     print("a executed")
...     return []
... 
>>>            
>>> def b(x=a()):
...     x.append(5)
...     print(x)
... 
a executed
>>> b()
[5]
>>> b()
[5, 5]

Đối với tôi, dường như quyết định thiết kế có liên quan đến nơi đặt phạm vi của các tham số: bên trong hàm hoặc "cùng" với nó?

Thực hiện liên kết bên trong hàm có nghĩa xlà được ràng buộc một cách hiệu quả với mặc định đã chỉ định khi hàm được gọi, không được xác định, một cái gì đó sẽ có một lỗ hổng sâu: defdòng sẽ là "lai" theo nghĩa là một phần của liên kết (của đối tượng hàm) sẽ xảy ra ở định nghĩa và một phần (gán tham số mặc định) tại thời điểm gọi hàm.

Hành vi thực tế phù hợp hơn: mọi thứ của dòng đó được đánh giá khi dòng đó được thực thi, nghĩa là tại định nghĩa hàm.

Trên thực tế, đây không phải là một lỗi thiết kế, và nó không phải là do nội bộ, hoặc hiệu suất.
Nó đơn giản xuất phát từ thực tế là các hàm trong Python là các đối tượng hạng nhất và không chỉ là một đoạn mã.

Ngay khi bạn nghĩ về cách này, thì nó hoàn toàn có ý nghĩa: một hàm là một đối tượng được đánh giá theo định nghĩa của nó; tham số mặc định là loại "dữ liệu thành viên" và do đó trạng thái của chúng có thể thay đổi từ cuộc gọi này sang cuộc gọi khác - chính xác như trong bất kỳ đối tượng nào khác.

Trong mọi trường hợp, Effbot có một lời giải thích rất hay về lý do cho hành vi này trong Giá trị tham số mặc định trong Python .
Tôi thấy nó rất rõ ràng và tôi thực sự khuyên bạn nên đọc nó để có kiến ​​thức tốt hơn về cách các đối tượng chức năng hoạt động.

Giả sử bạn có đoạn mã sau

fruits = ("apples", "bananas", "loganberries")

def eat(food=fruits):
    ...

Khi tôi thấy tuyên bố về việc ăn uống, điều đáng ngạc nhiên nhất là nghĩ rằng nếu tham số đầu tiên không được đưa ra, thì nó sẽ bằng với bộ dữ liệu ("apples", "bananas", "loganberries")

Tuy nhiên, được cho là sau này trong mã, tôi làm một cái gì đó như

def some_random_function():
    global fruits
    fruits = ("blueberries", "mangos")

sau đó nếu các tham số mặc định bị ràng buộc khi thực thi chức năng thay vì khai báo hàm thì tôi sẽ ngạc nhiên (theo cách rất tệ) khi phát hiện ra rằng trái cây đã bị thay đổi. Điều này sẽ khiến IMO đáng kinh ngạc hơn là phát hiện ra rằng foochức năng của bạn ở trên đang làm thay đổi danh sách.

Vấn đề thực sự nằm ở các biến có thể thay đổi và tất cả các ngôn ngữ đều có vấn đề này ở một mức độ nào đó. Đây là một câu hỏi: giả sử trong Java tôi có đoạn mã sau:

StringBuffer s = new StringBuffer("Hello World!");
Map<StringBuffer,Integer> counts = new HashMap<StringBuffer,Integer>();
counts.put(s, 5);
s.append("!!!!");
System.out.println( counts.get(s) );  // does this work?

Bây giờ, bản đồ của tôi có sử dụng giá trị của StringBufferkhóa khi nó được đặt vào bản đồ hay nó lưu trữ khóa theo tham chiếu? Dù bằng cách nào, một người nào đó ngạc nhiên; hoặc người đã cố gắng đưa đối tượng ra khỏi Mapgiá trị bằng cách sử dụng một giá trị giống hệt với giá trị mà họ đặt vào hoặc người dường như không thể truy xuất đối tượng của họ mặc dù khóa họ đang sử dụng là cùng một đối tượng đã được sử dụng để đưa nó vào bản đồ (đây thực sự là lý do tại sao Python không cho phép các loại dữ liệu tích hợp có thể thay đổi của nó được sử dụng làm khóa từ điển).

Ví dụ của bạn là một trường hợp tốt trong trường hợp người mới sử dụng Python sẽ ngạc nhiên và bị cắn. Nhưng tôi lập luận rằng nếu chúng ta "sửa" điều này, thì điều đó sẽ chỉ tạo ra một tình huống khác khi chúng bị cắn thay vào đó, và điều đó thậm chí sẽ ít trực quan hơn. Hơn nữa, đây luôn là trường hợp khi xử lý các biến có thể thay đổi; bạn luôn gặp phải trường hợp ai đó có thể trực giác mong đợi một hoặc hành vi ngược lại tùy thuộc vào mã họ đang viết.

Cá nhân tôi thích cách tiếp cận hiện tại của Python: các đối số hàm mặc định được đánh giá khi hàm được xác định và đối tượng đó luôn là mặc định. Tôi cho rằng họ có thể sử dụng một trường hợp đặc biệt bằng cách sử dụng một danh sách trống, nhưng loại vỏ đặc biệt đó sẽ gây ra sự ngạc nhiên hơn nữa, chưa kể đến việc không tương thích ngược.

Phần có liên quan của tài liệu :

Các giá trị tham số mặc định được ước tính từ trái sang phải khi định nghĩa hàm được thực thi. Điều này có nghĩa là biểu thức được ước tính một lần, khi hàm được xác định và giá trị tương tự được tính toán trước đó được sử dụng cho mỗi cuộc gọi. Điều này đặc biệt quan trọng để hiểu khi một tham số mặc định là một đối tượng có thể thay đổi, chẳng hạn như danh sách hoặc từ điển: nếu chức năng sửa đổi đối tượng (ví dụ: bằng cách thêm một mục vào danh sách), giá trị mặc định có hiệu lực được sửa đổi. Đây thường không phải là những gì đã được dự định. Một cách khác là sử dụng Nonelàm mặc định và kiểm tra rõ ràng cho nó trong phần thân của hàm, ví dụ:

def whats_on_the_telly(penguin=None):
    if penguin is None:
        penguin = []
    penguin.append("property of the zoo")
    return penguin

Tôi không biết gì về hoạt động bên trong của trình thông dịch Python (và tôi cũng không phải là chuyên gia về trình biên dịch và phiên dịch), vì vậy đừng đổ lỗi cho tôi nếu tôi đề xuất bất cứ điều gì không thể hoặc không thể.

Với điều kiện các đối tượng python có thể thay đổi, tôi nghĩ rằng điều này nên được tính đến khi thiết kế các đối số mặc định. Khi bạn khởi tạo một danh sách:

a = []

bạn mong đợi để có được một danh sách mới được tham chiếu bởi a.

Tại sao nên a=[]vào

def x(a=[]):

khởi tạo một danh sách mới về định nghĩa hàm và không gọi Giống như bạn đang hỏi "nếu người dùng không cung cấp đối số thì hãy khởi tạo một danh sách mới và sử dụng nó như thể nó được tạo bởi người gọi". Tôi nghĩ rằng điều này là mơ hồ thay vào đó:

def x(a=datetime.datetime.now()):

người dùng, bạn có muốn amặc định cho datetime tương ứng với khi bạn xác định hoặc thực thi xkhông? Trong trường hợp này, như trong phần trước, tôi sẽ giữ hành vi tương tự như thể "gán" đối số mặc định là hướng dẫn đầu tiên của hàm ( datetime.now()được gọi là gọi hàm). Mặt khác, nếu người dùng muốn ánh xạ thời gian định nghĩa, anh ta có thể viết:

b = datetime.datetime.now()
def x(a=b):

Tôi biết, tôi biết: đó là một đóng cửa. Ngoài ra, Python có thể cung cấp một từ khóa để buộc ràng buộc thời gian định nghĩa:

def x(static a=b):

Chà, lý do khá đơn giản là các ràng buộc được thực hiện khi mã được thực thi và định nghĩa hàm được thực thi, à ... khi các hàm được định nghĩa.

So sánh điều này:

class BananaBunch:
    bananas = []

    def addBanana(self, banana):
        self.bananas.append(banana)

Mã này bị chính xác xảy ra bất ngờ tương tự. chuối là một thuộc tính của lớp và do đó, khi bạn thêm mọi thứ vào nó, nó sẽ được thêm vào tất cả các thể hiện của lớp đó. Lý do hoàn toàn giống nhau.

Đó chỉ là "Cách thức hoạt động" và làm cho nó hoạt động khác trong trường hợp chức năng có thể sẽ phức tạp và trong trường hợp lớp có thể là không thể, hoặc ít nhất là làm chậm việc khởi tạo đối tượng rất nhiều, vì bạn sẽ phải giữ mã lớp và thực hiện nó khi các đối tượng được tạo ra.

Vâng, thật bất ngờ. Nhưng một khi đồng xu giảm, nó hoàn toàn phù hợp với cách thức hoạt động của Python nói chung. Trên thực tế, đó là một trợ giúp giảng dạy tốt và một khi bạn hiểu tại sao điều này xảy ra, bạn sẽ mò mẫm con trăn tốt hơn nhiều.

Điều đó nói rằng nó sẽ nổi bật trong bất kỳ hướng dẫn Python tốt nào. Bởi vì như bạn đề cập, mọi người đều gặp phải vấn đề này sớm hay muộn.

Tại sao bạn không hướng nội?

Tôi thực sự ngạc nhiên khi không ai thực hiện nội tâm sâu sắc được cung cấp bởi Python ( 2và 3áp dụng) trên các thiết bị gọi.

Cho một hàm nhỏ đơn giản funcđược định nghĩa là:

>>> def func(a = []):
...    a.append(5)

Khi Python gặp nó, điều đầu tiên nó sẽ làm là biên dịch nó để tạo một codeđối tượng cho hàm này. Trong khi bước biên dịch này được thực hiện, Python đánh giá * và sau đó lưu trữ các đối số mặc định (một danh sách trống []ở đây) trong chính đối tượng hàm . Như câu trả lời hàng đầu đã đề cập: danh sách ahiện có thể được coi là thành viên của hàm func.

Vì vậy, chúng ta hãy thực hiện một số hướng nội, trước và sau để kiểm tra xem danh sách được mở rộng bên trong đối tượng hàm như thế nào . Tôi đang sử dụng Python 3.xcho điều này, đối với Python 2 cũng áp dụng tương tự (sử dụng __defaults__hoặc func_defaultstrong Python 2; có, hai tên cho cùng một thứ).

Chức năng trước khi thực hiện:

>>> def func(a = []):
...     a.append(5)
...     

Sau khi Python thực thi định nghĩa này, nó sẽ lấy bất kỳ tham số mặc định nào được chỉ định ( a = []ở đây) và nhồi nhét chúng trong __defaults__thuộc tính cho đối tượng hàm (phần có liên quan: Callables):

>>> func.__defaults__
([],)

Ok, vì vậy một danh sách trống như là một mục duy nhất __defaults__, đúng như mong đợi.

Chức năng sau khi thực hiện:

Bây giờ chúng ta hãy thực hiện chức năng này:

>>> func()

Bây giờ, chúng ta hãy gặp __defaults__lại những người đó :

>>> func.__defaults__
([5],)

Kinh ngạc? Giá trị bên trong đối tượng thay đổi! Các cuộc gọi liên tiếp đến hàm bây giờ sẽ đơn giản nối thêm vào listđối tượng nhúng đó:

>>> func(); func(); func()
>>> func.__defaults__
([5, 5, 5, 5],)

Vì vậy, bạn có nó, lý do tại sao 'lỗ hổng' này xảy ra, là bởi vì các đối số mặc định là một phần của đối tượng hàm. Không có gì lạ xảy ra ở đây, tất cả chỉ là một chút ngạc nhiên.

Giải pháp phổ biến để chống lại điều này là sử dụng Nonelàm mặc định và sau đó khởi tạo trong thân hàm:

def func(a = None):
    # or: a = [] if a is None else a
    if a is None:
        a = []

Vì thân hàm được thực thi một lần nữa mỗi lần, bạn luôn nhận được một danh sách trống mới nếu không có đối số nào được thông qua a.

Để xác minh thêm rằng danh sách trong __defaults__giống như danh sách được sử dụng trong hàm, funcbạn chỉ cần thay đổi chức năng của mình để trả về iddanh sách ađược sử dụng bên trong thân hàm. Sau đó, so sánh nó với danh sách trong __defaults__(vị trí [0]trong __defaults__) và bạn sẽ thấy chúng thực sự tham chiếu đến cùng thể hiện danh sách như thế nào:

>>> def func(a = []): 
...     a.append(5)
...     return id(a)
>>>
>>> id(func.__defaults__[0]) == func()
True

Tất cả với sức mạnh của nội tâm!

^* Để xác minh rằng Python đánh giá các đối số mặc định trong quá trình biên dịch hàm, hãy thử thực hiện các thao tác sau:

def bar(a=input('Did you just see me without calling the function?')): 
    pass  # use raw_input in Py2

như bạn sẽ thấy, input()được gọi trước khi quá trình xây dựng hàm và ràng buộc nó với tên barđược thực hiện.

Tôi đã từng nghĩ rằng việc tạo các đối tượng trong thời gian chạy sẽ là cách tiếp cận tốt hơn. Bây giờ tôi ít chắc chắn hơn, vì bạn đã mất một số tính năng hữu ích, mặc dù nó có thể đáng giá bất kể chỉ đơn giản là để ngăn chặn sự nhầm lẫn của người mới. Những nhược điểm của việc này là:

1. Hiệu suất

def foo(arg=something_expensive_to_compute())):
    ...

Nếu đánh giá thời gian cuộc gọi được sử dụng, thì hàm đắt tiền được gọi mỗi khi hàm của bạn được sử dụng mà không có đối số. Bạn sẽ phải trả một mức giá đắt cho mỗi cuộc gọi hoặc cần lưu trữ thủ công giá trị bên ngoài, gây ô nhiễm không gian tên của bạn và thêm tính dài dòng.

2. Buộc tham số ràng buộc

Một mẹo hữu ích là liên kết các tham số của lambda với ràng buộc hiện tại của một biến khi lambda được tạo. Ví dụ:

funcs = [ lambda i=i: i for i in range(10)]

Điều này trả về một danh sách các hàm trả về 0,1,2,3 ... tương ứng. Nếu hành vi được thay đổi, thay vào đó chúng sẽ liên kết ivới giá trị thời gian cuộc gọi của i, vì vậy bạn sẽ nhận được một danh sách các hàm được trả về 9.

Cách duy nhất để thực hiện điều này nếu không sẽ là tạo thêm một bao đóng với ràng buộc i, nghĩa là:

def make_func(i): return lambda: i
funcs = [make_func(i) for i in range(10)]

3. Hướng nội

Hãy xem xét mã:

def foo(a='test', b=100, c=[]):
   print a,b,c

Chúng tôi có thể nhận thông tin về các đối số và mặc định bằng cách sử dụng inspectmô-đun, trong đó

>>> inspect.getargspec(foo)
(['a', 'b', 'c'], None, None, ('test', 100, []))

Thông tin này rất hữu ích cho những thứ như tạo tài liệu, lập trình siêu dữ liệu, trang trí, v.v.

Bây giờ, giả sử hành vi của các mặc định có thể được thay đổi để điều này tương đương với:

_undefined = object()  # sentinel value

def foo(a=_undefined, b=_undefined, c=_undefined)
    if a is _undefined: a='test'
    if b is _undefined: b=100
    if c is _undefined: c=[]

Tuy nhiên, chúng tôi đã mất khả năng hướng nội và xem các đối số mặc định là gì . Bởi vì các đối tượng chưa được xây dựng, chúng ta không thể nắm giữ chúng mà không thực sự gọi hàm. Điều tốt nhất chúng ta có thể làm là lưu trữ mã nguồn và trả lại dưới dạng chuỗi.

5 điểm khi bảo vệ Python

1. Đơn giản : Hành vi đơn giản theo nghĩa sau: Hầu hết mọi người chỉ rơi vào cái bẫy này một lần chứ không phải vài lần.

2. Tính nhất quán : Python luôn vượt qua các đối tượng, không phải tên. Rõ ràng, tham số mặc định là một phần của tiêu đề hàm (không phải thân hàm). Do đó, nó phải được đánh giá tại thời gian tải mô-đun (và chỉ tại thời gian tải mô-đun, trừ khi được lồng), không phải tại thời gian gọi chức năng.

3. Tính hữu dụng : Như Frederik Lundh đã chỉ ra trong phần giải thích về "Giá trị tham số mặc định trong Python" , hành vi hiện tại có thể khá hữu ích cho lập trình nâng cao. (Sử dụng một cách tiết kiệm.)

4. Tài liệu đầy đủ : Trong tài liệu Python cơ bản nhất, hướng dẫn, vấn đề được thông báo lớn là "Cảnh báo quan trọng" trong phần phụ đầu tiên của Phần "Thông tin thêm về Xác định Hàm" . Cảnh báo thậm chí sử dụng in đậm, hiếm khi được áp dụng bên ngoài các tiêu đề. RTFM: Đọc hướng dẫn sử dụng tốt.

5. Học siêu tốc : Rơi vào bẫy thực sự là một khoảnh khắc rất hữu ích (ít nhất là nếu bạn là người học phản xạ), vì sau đó bạn sẽ hiểu rõ hơn về điểm "Tính nhất quán" ở trên và điều đó sẽ dạy cho bạn rất nhiều về Python.

Hành vi này được giải thích dễ dàng bởi:

1. Khai báo hàm (lớp, v.v.) chỉ được thực hiện một lần, tạo tất cả các đối tượng giá trị mặc định
2. mọi thứ đều được thông qua

Vì thế:

def x(a=0, b=[], c=[], d=0):
    a = a + 1
    b = b + [1]
    c.append(1)
    print a, b, c

1. a không thay đổi - mọi lệnh gọi tạo đối tượng int mới - đối tượng mới được in
2. b không thay đổi - mảng mới được xây dựng từ giá trị mặc định và được in
3. c thay đổi - thao tác được thực hiện trên cùng một đối tượng - và nó được in

Những gì bạn đang hỏi là tại sao điều này:

def func(a=[], b = 2):
    pass

không tương đương nội bộ với điều này:

def func(a=None, b = None):
    a_default = lambda: []
    b_default = lambda: 2
    def actual_func(a=None, b=None):
        if a is None: a = a_default()
        if b is None: b = b_default()
    return actual_func
func = func()

ngoại trừ trường hợp gọi func rõ ràng (Không, Không), chúng tôi sẽ bỏ qua.

Nói cách khác, thay vì đánh giá các tham số mặc định, tại sao không lưu trữ từng tham số và đánh giá chúng khi hàm được gọi?

Một câu trả lời có lẽ ở ngay đó - nó sẽ biến mọi chức năng với các tham số mặc định thành một bao đóng một cách hiệu quả. Ngay cả khi tất cả được ẩn đi trong trình thông dịch và không phải là sự đóng cửa hoàn toàn, dữ liệu vẫn phải được lưu trữ ở đâu đó. Nó sẽ chậm hơn và sử dụng nhiều bộ nhớ hơn.

1) Vấn đề được gọi là "Đối số mặc định có thể thay đổi" nói chung là một ví dụ đặc biệt chứng minh rằng:
"Tất cả các chức năng với vấn đề này cũng gặp phải vấn đề tác dụng phụ tương tự trên tham số thực tế ",
đó là trái với quy tắc lập trình chức năng, thường không thể khắc phục và nên được cố định cả hai cùng nhau.

Thí dụ:

def foo(a=[]):                 # the same problematic function
    a.append(5)
    return a

>>> somevar = [1, 2]           # an example without a default parameter
>>> foo(somevar)
[1, 2, 5]
>>> somevar
[1, 2, 5]                      # usually expected [1, 2]

Giải pháp : một bản sao
Một giải pháp tuyệt đối an toàn là trước tiên copyhoặc deepcopyđối tượng đầu vào và sau đó làm bất cứ điều gì với bản sao.

def foo(a=[]):
    a = a[:]     # a copy
    a.append(5)
    return a     # or everything safe by one line: "return a + [5]"

Nhiều kiểu biến đổi dựng sẵn có một phương thức sao chép như some_dict.copy()hoặc some_set.copy()hoặc có thể được sao chép dễ dàng như somelist[:]hoặc list(some_list). Mọi đối tượng cũng có thể được sao chép bằng copy.copy(any_object)hoặc kỹ lưỡng hơn bằng cách copy.deepcopy()(hữu ích sau nếu đối tượng có thể thay đổi được cấu thành từ các đối tượng có thể thay đổi). Một số đối tượng về cơ bản dựa trên các tác dụng phụ như đối tượng "tập tin" và không thể được sao chép một cách có ý nghĩa bằng bản sao. sao chép

Ví dụ vấn đề cho một câu hỏi SO tương tự

class Test(object):            # the original problematic class
  def __init__(self, var1=[]):
    self._var1 = var1

somevar = [1, 2]               # an example without a default parameter
t1 = Test(somevar)
t2 = Test(somevar)
t1._var1.append([1])
print somevar                  # [1, 2, [1]] but usually expected [1, 2]
print t2._var1                 # [1, 2, [1]] but usually expected [1, 2]

Nó không nên được lưu trong bất kỳ thuộc tính công khai nào của một thể hiện được trả về bởi hàm này. (Giả sử rằng các thuộc tính riêng của cá thể không nên được sửa đổi từ bên ngoài lớp này hoặc các lớp con theo quy ước. Tức là_var1 là thuộc tính riêng)

Kết luận:
Các đối tượng tham số đầu vào không nên được sửa đổi tại chỗ (bị đột biến) cũng như không nên liên kết chúng vào một đối tượng được hàm trả về. (Nếu chúng tôi lập trình trước mà không có tác dụng phụ được khuyến khích mạnh mẽ. Hãy xem Wiki về "tác dụng phụ" (Hai đoạn đầu tiên có liên quan trong bối cảnh này.).)

2)
Chỉ khi tác dụng phụ đối với tham số thực tế là bắt buộc nhưng không mong muốn đối với tham số mặc định thì giải pháp hữu ích là def ...(var1=None): if var1 is None: var1 = [] Khác ..

3) Trong một số trường hợp , hành vi có thể thay đổi của các tham số mặc định hữu ích .

Điều này thực sự không liên quan gì đến các giá trị mặc định, ngoài ra nó thường xuất hiện dưới dạng một hành vi không mong muốn khi bạn viết các hàm với các giá trị mặc định có thể thay đổi.

>>> def foo(a):
    a.append(5)
    print a

>>> a  = [5]
>>> foo(a)
[5, 5]
>>> foo(a)
[5, 5, 5]
>>> foo(a)
[5, 5, 5, 5]
>>> foo(a)
[5, 5, 5, 5, 5]

Không có giá trị mặc định trong tầm nhìn trong mã này, nhưng bạn nhận được chính xác cùng một vấn đề.

Vấn đề là rằng foođược sửa đổi một biến có thể thay đổi được thông qua vào từ người gọi, khi người gọi không mong đợi điều này. Mã như thế này sẽ ổn nếu hàm được gọi là như thế append_5; sau đó người gọi sẽ gọi hàm để sửa đổi giá trị mà họ truyền vào và hành vi sẽ được mong đợi. Nhưng một hàm như vậy sẽ rất khó có thể đưa ra một đối số mặc định và có thể sẽ không trả về danh sách (vì người gọi đã có một tham chiếu đến danh sách đó; một đối số mà nó vừa truyền vào).

Bản gốc của bạn foo, với một đối số mặc định, không nên sửa đổi acho dù nó được truyền rõ ràng hay có giá trị mặc định. Mã của bạn nên để các đối số có thể thay đổi một mình trừ khi rõ ràng từ ngữ cảnh / tên / tài liệu mà các đối số được cho là được sửa đổi. Sử dụng các giá trị có thể thay đổi được truyền vào dưới dạng đối số làm tạm thời cục bộ là một ý tưởng cực kỳ tồi tệ, cho dù chúng ta có ở trong Python hay không và có các đối số mặc định có liên quan hay không.

Nếu bạn cần thao tác triệt để tạm thời cục bộ trong quá trình tính toán một cái gì đó và bạn cần bắt đầu thao tác của mình từ một giá trị đối số, bạn cần tạo một bản sao.

Đã là chủ đề bận rộn, nhưng từ những gì tôi đọc ở đây, những điều sau đây đã giúp tôi nhận ra cách thức hoạt động bên trong:

def bar(a=[]):
     print id(a)
     a = a + [1]
     print id(a)
     return a

>>> bar()
4484370232
4484524224
[1]
>>> bar()
4484370232
4484524152
[1]
>>> bar()
4484370232 # Never change, this is 'class property' of the function
4484523720 # Always a new object 
[1]
>>> id(bar.func_defaults[0])
4484370232

Đó là một tối ưu hóa hiệu suất. Kết quả của chức năng này, bạn nghĩ cuộc gọi nào trong hai chức năng này nhanh hơn?

def print_tuple(some_tuple=(1,2,3)):
    print some_tuple

print_tuple()        #1
print_tuple((1,2,3)) #2

Tôi sẽ cho bạn một gợi ý. Đây là phần tháo gỡ (xem http://docs.python.org/l Library / dis.html ):

#1

0 LOAD_GLOBAL              0 (print_tuple)
3 CALL_FUNCTION            0
6 POP_TOP
7 LOAD_CONST               0 (None)
10 RETURN_VALUE

#2

 0 LOAD_GLOBAL              0 (print_tuple)
 3 LOAD_CONST               4 ((1, 2, 3))
 6 CALL_FUNCTION            1
 9 POP_TOP
10 LOAD_CONST               0 (None)
13 RETURN_VALUE

Tôi nghi ngờ hành vi có kinh nghiệm có một cách sử dụng thực tế (ai thực sự sử dụng biến tĩnh trong C, không có lỗi sinh sản?)

Như bạn có thể thấy, có là một lợi ích hiệu suất khi sử dụng đối số mặc định không thay đổi. Điều này có thể tạo sự khác biệt nếu đó là một hàm được gọi thường xuyên hoặc đối số mặc định mất nhiều thời gian để xây dựng. Ngoài ra, hãy nhớ rằng Python không C. Trong C, bạn có các hằng số khá miễn phí. Trong Python bạn không có lợi ích này.

Python: Đối số mặc định có thể thay đổi

Các đối số mặc định được đánh giá tại thời điểm hàm được biên dịch thành đối tượng hàm. Khi được sử dụng bởi hàm, nhiều lần bởi hàm đó, chúng là và vẫn là cùng một đối tượng.

Khi chúng có thể thay đổi, khi bị đột biến (ví dụ, bằng cách thêm một phần tử vào nó), chúng vẫn bị đột biến trong các cuộc gọi liên tiếp.

Họ ở lại đột biến bởi vì họ là cùng một đối tượng mỗi lần.

Mã tương đương:

Vì danh sách được liên kết với hàm khi đối tượng hàm được biên dịch và khởi tạo, nên:

def foo(mutable_default_argument=[]): # make a list the default argument
    """function that uses a list"""

gần như chính xác tương đương với điều này:

_a_list = [] # create a list in the globals

def foo(mutable_default_argument=_a_list): # make it the default argument
    """function that uses a list"""

del _a_list # remove globals name binding

Trình diễn

Đây là một minh chứng - bạn có thể xác minh rằng chúng là cùng một đối tượng mỗi lần chúng được tham chiếu bởi

• thấy rằng danh sách được tạo trước khi hàm hoàn thành biên dịch thành đối tượng hàm,
• quan sát rằng id giống nhau mỗi khi danh sách được tham chiếu,
• quan sát rằng danh sách vẫn thay đổi khi hàm sử dụng nó được gọi là lần thứ hai,
• quan sát thứ tự đầu ra được in từ nguồn (mà tôi thuận tiện đánh số cho bạn):

example.py

print('1. Global scope being evaluated')

def create_list():
    '''noisily create a list for usage as a kwarg'''
    l = []
    print('3. list being created and returned, id: ' + str(id(l)))
    return l

print('2. example_function about to be compiled to an object')

def example_function(default_kwarg1=create_list()):
    print('appending "a" in default default_kwarg1')
    default_kwarg1.append("a")
    print('list with id: ' + str(id(default_kwarg1)) + 
          ' - is now: ' + repr(default_kwarg1))

print('4. example_function compiled: ' + repr(example_function))


if __name__ == '__main__':
    print('5. calling example_function twice!:')
    example_function()
    example_function()

và chạy nó với python example.py:

1. Global scope being evaluated
2. example_function about to be compiled to an object
3. list being created and returned, id: 140502758808032
4. example_function compiled: <function example_function at 0x7fc9590905f0>
5. calling example_function twice!:
appending "a" in default default_kwarg1
list with id: 140502758808032 - is now: ['a']
appending "a" in default default_kwarg1
list with id: 140502758808032 - is now: ['a', 'a']

Điều này có vi phạm nguyên tắc "Ít ngạc nhiên nhất" không?

Thứ tự thực hiện này thường gây nhầm lẫn cho người dùng mới của Python. Nếu bạn hiểu mô hình thực thi Python, thì nó trở nên khá được mong đợi.

Hướng dẫn thông thường cho người dùng Python mới:

Nhưng đây là lý do tại sao hướng dẫn thông thường cho người dùng mới là tạo các đối số mặc định của họ như thế này:

def example_function_2(default_kwarg=None):
    if default_kwarg is None:
        default_kwarg = []

Điều này sử dụng singleton đơn lẻ làm đối tượng canh gác để cho biết chức năng cho dù chúng ta có nhận được một đối số khác ngoài mặc định hay không. Nếu chúng tôi không có đối số, thì chúng tôi thực sự muốn sử dụng một danh sách trống mới [], làm mặc định.

Như phần hướng dẫn về luồng điều khiển nói:

Nếu bạn không muốn mặc định được chia sẻ giữa các cuộc gọi tiếp theo, bạn có thể viết hàm như thế này:

def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L

Câu trả lời ngắn nhất có lẽ là "định nghĩa là thực thi", do đó toàn bộ lập luận không có ý nghĩa nghiêm ngặt. Như một ví dụ dễ hiểu hơn, bạn có thể trích dẫn điều này:

def a(): return []

def b(x=a()):
    print x

Hy vọng rằng nó đủ để cho thấy rằng việc không thực thi các biểu thức đối số mặc định tại thời điểm thực thi của defcâu lệnh là không dễ dàng hoặc không có ý nghĩa, hoặc cả hai.

Tôi đồng ý rằng đó là một gotcha khi bạn cố gắng sử dụng các hàm tạo mặc định.

Một cách giải quyết đơn giản bằng cách sử dụng Không có

>>> def bar(b, data=None):
...     data = data or []
...     data.append(b)
...     return data
... 
>>> bar(3)
[3]
>>> bar(3)
[3]
>>> bar(3)
[3]
>>> bar(3, [34])
[34, 3]
>>> bar(3, [34])
[34, 3]

Hành vi này không đáng ngạc nhiên nếu bạn cân nhắc những điều sau:

1. Hành vi của các thuộc tính lớp chỉ đọc khi thử gán, và đó
2. Hàm là các đối tượng (được giải thích tốt trong câu trả lời được chấp nhận).

Vai trò của (2) đã được đề cập rộng rãi trong chủ đề này. (1) có thể là yếu tố gây ngạc nhiên, vì hành vi này không "trực quan" khi đến từ các ngôn ngữ khác.

(1) được mô tả trong hướng dẫn Python trên các lớp . Trong nỗ lực gán giá trị cho thuộc tính lớp chỉ đọc:

... tất cả các biến được tìm thấy bên ngoài phạm vi trong cùng là chỉ đọc ( một nỗ lực ghi vào biến đó sẽ chỉ tạo ra một biến cục bộ mới trong phạm vi trong cùng, không thay đổi tên bên ngoài có tên giống hệt nhau ).

Nhìn lại ví dụ ban đầu và xem xét các điểm trên:

def foo(a=[]):
    a.append(5)
    return a

Đây foolà một đối tượng và alà một thuộc tính của foo(có sẵn tạifoo.func_defs[0] ). Vì alà một danh sách, acó thể thay đổi và do đó là một thuộc tính đọc-ghi của foo. Nó được khởi tạo vào danh sách trống như được chỉ định bởi chữ ký khi hàm được khởi tạo và có sẵn để đọc và ghi miễn là đối tượng hàm tồn tại.

Gọi foomà không ghi đè mặc định sử dụng giá trị của mặc định đó từ foo.func_defs. Trong trường hợp này, foo.func_defs[0]được sử dụng cho aphạm vi mã của đối tượng hàm. Thay đổi để athay đổifoo.func_defs[0] , là một phần của foođối tượng và vẫn tồn tại giữa quá trình thực thi mã foo.

Bây giờ, so sánh ví dụ này với ví dụ từ tài liệu mô phỏng hành vi đối số mặc định của các ngôn ngữ khác , sao cho mặc định chữ ký hàm được sử dụng mỗi khi hàm được thực thi:

def foo(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L

Lấy (1) và (2) , người ta có thể thấy lý do tại sao điều này thực hiện hành vi mong muốn:

• Khi foođối tượng hàm được khởi tạo,foo.func_defs[0] được đặt thành None, một đối tượng bất biến.
• Khi chức năng được thực thi với mặc định (không có tham số nào được chỉ định Ltrong lệnh gọi hàm), foo.func_defs[0](None ) có sẵn trong phạm vi cục bộ như L.
• Trên L = [] , bài tập không thể thành công tại foo.func_defs[0], vì thuộc tính đó là chỉ đọc.
• Mỗi (1) , một biến cục bộ mới cũng được đặt tên Lđược tạo trong phạm vi cục bộ và được sử dụng cho phần còn lại của lệnh gọi hàm. foo.func_defs[0]do đó vẫn không thay đổi cho các yêu cầu trong tương lai của foo.

Tôi sẽ trình bày một cấu trúc thay thế để chuyển một giá trị danh sách mặc định cho một hàm (nó hoạt động tốt như nhau với từ điển).

Như những người khác đã nhận xét rộng rãi, tham số danh sách được liên kết với hàm khi nó được định nghĩa trái ngược với khi nó được thực thi. Vì danh sách và từ điển có thể thay đổi, nên mọi thay đổi đối với tham số này sẽ ảnh hưởng đến các lệnh gọi khác đến chức năng này. Do đó, các cuộc gọi tiếp theo đến chức năng sẽ nhận được danh sách chia sẻ này có thể đã bị thay đổi bởi bất kỳ cuộc gọi nào khác đến chức năng. Tệ hơn nữa, hai tham số đang sử dụng tham số chia sẻ của chức năng này cùng một lúc không biết đến những thay đổi được thực hiện bởi cái kia.

Phương pháp sai (có thể ...) :

def foo(list_arg=[5]):
    return list_arg

a = foo()
a.append(6)
>>> a
[5, 6]

b = foo()
b.append(7)
# The value of 6 appended to variable 'a' is now part of the list held by 'b'.
>>> b
[5, 6, 7]  

# Although 'a' is expecting to receive 6 (the last element it appended to the list),
# it actually receives the last element appended to the shared list.
# It thus receives the value 7 previously appended by 'b'.
>>> a.pop()             
7

Bạn có thể xác minh rằng chúng là một và cùng một đối tượng bằng cách sử dụng id:

>>> id(a)
5347866528

>>> id(b)
5347866528

"Python hiệu quả: 59 cách cụ thể để viết Python tốt hơn" của Per Brett Slatkin, Mục 20: Sử dụng Nonevà tài liệu để chỉ định các đối số mặc định động (trang 48)

Quy ước để đạt được kết quả mong muốn trong Python là cung cấp giá trị mặc định Nonevà ghi lại hành vi thực tế trong chuỗi doc.

Việc thực hiện này đảm bảo rằng mỗi cuộc gọi đến hàm sẽ nhận được danh sách mặc định hoặc nếu không thì danh sách được truyền cho hàm.

Phương pháp ưa thích :

def foo(list_arg=None):
   """
   :param list_arg:  A list of input values. 
                     If none provided, used a list with a default value of 5.
   """
   if not list_arg:
       list_arg = [5]
   return list_arg

a = foo()
a.append(6)
>>> a
[5, 6]

b = foo()
b.append(7)
>>> b
[5, 7]

c = foo([10])
c.append(11)
>>> c
[10, 11]

Có thể có các trường hợp sử dụng hợp pháp cho 'Phương thức sai', theo đó, lập trình viên dự định tham số danh sách mặc định sẽ được chia sẻ, nhưng đây có thể là ngoại lệ nhiều hơn quy tắc.

Các giải pháp ở đây là:

1. Sử dụng Nonelàm giá trị mặc định của bạn (hoặc nonce object) và bật giá trị đó để tạo giá trị của bạn khi chạy; hoặc là
2. Sử dụng lambdalàm tham số mặc định của bạn và gọi nó trong khối thử để lấy giá trị mặc định (đây là loại trừu tượng lambda dành cho).

Tùy chọn thứ hai là tốt vì người dùng của chức năng có thể chuyển qua một cuộc gọi, có thể đã tồn tại (chẳng hạn như một type)

Khi chúng tôi làm điều này:

def foo(a=[]):
    ...

... chúng tôi gán đối số acho một tên không tên sách , nếu người gọi không vượt qua giá trị của a.

Để làm cho mọi thứ đơn giản hơn cho cuộc thảo luận này, hãy tạm thời đặt tên cho danh sách không tên. Thế còn pavlo?

def foo(a=pavlo):
   ...

Bất cứ lúc nào, nếu người gọi không cho chúng tôi biết đó alà gì , chúng tôi sẽ sử dụng lại pavlo.

Nếu pavlocó thể thay đổi (có thể sửa đổi) và fookết thúc sửa đổi nó, một hiệu ứng chúng ta nhận thấy lần sau foođược gọi mà không chỉ định a.

Vì vậy, đây là những gì bạn thấy (Hãy nhớ, pavlođược khởi tạo thành []):

 >>> foo()
 [5]

Bây giờ, pavlolà [5].

Gọi foo()lại sửa đổi pavlomột lần nữa:

>>> foo()
[5, 5]

Chỉ định akhi gọi foo()đảm bảo pavlokhông bị chạm.

>>> ivan = [1, 2, 3, 4]
>>> foo(a=ivan)
[1, 2, 3, 4, 5]
>>> ivan
[1, 2, 3, 4, 5]

Vì vậy, pavlovẫn còn [5, 5].

>>> foo()
[5, 5, 5]

Đôi khi tôi khai thác hành vi này như là một thay thế cho mẫu sau:

singleton = None

def use_singleton():
    global singleton

    if singleton is None:
        singleton = _make_singleton()

    return singleton.use_me()

Nếu singletonchỉ được sử dụng bởi use_singleton, tôi thích mẫu sau thay thế:

# _make_singleton() is called only once when the def is executed
def use_singleton(singleton=_make_singleton()):
    return singleton.use_me()

Tôi đã sử dụng điều này để khởi tạo các lớp máy khách truy cập các tài nguyên bên ngoài và cũng để tạo các ký tự hoặc danh sách để ghi nhớ.

Vì tôi không nghĩ rằng mô hình này là nổi tiếng, tôi đã đưa ra một nhận xét ngắn để bảo vệ chống lại những hiểu lầm trong tương lai.

Bạn có thể làm tròn điều này bằng cách thay thế đối tượng (và do đó, buộc bằng phạm vi):

def foo(a=[]):
    a = list(a)
    a.append(5)
    return a

Xấu xí, nhưng nó hoạt động.

Có thể đúng là:

1. Ai đó đang sử dụng mọi tính năng ngôn ngữ / thư viện và
2. Chuyển đổi hành vi ở đây sẽ không được khuyến khích, nhưng

nó hoàn toàn phù hợp để giữ cả hai tính năng trên mà vẫn tạo ra một điểm khác:

3. Đây là một tính năng khó hiểu và thật không may trong Python.

Các câu trả lời khác, hoặc ít nhất một số trong số chúng tạo ra điểm 1 và 2 nhưng không phải là 3, hoặc tạo điểm 3 và hạ điểm 1 và 2. Nhưng cả ba đều đúng.

Có thể đúng là việc chuyển ngựa giữa dòng ở đây sẽ yêu cầu phá vỡ đáng kể và có thể có nhiều vấn đề hơn được tạo ra bằng cách thay đổi Python để xử lý trực quan đoạn mở của Stefano. Và có thể đúng là ai đó biết rõ nội bộ Python có thể giải thích một hậu quả của tôi. Tuy nhiên,

Hành vi hiện tại không phải là Pythonic và Python thành công vì rất ít về ngôn ngữ vi phạm nguyên tắc ít gây ngạc nhiên ở bất cứ đâu ở gầnđiều này thật tệ Đó là một vấn đề thực sự, liệu có nên khôn ngoan khi nhổ nó hay không. Đó là một lỗ hổng thiết kế. Nếu bạn hiểu ngôn ngữ tốt hơn nhiều bằng cách cố gắng tìm ra hành vi, tôi có thể nói rằng C ++ thực hiện tất cả những điều này và hơn thế nữa; bạn học được rất nhiều bằng cách điều hướng, ví dụ, lỗi con trỏ tinh tế. Nhưng đây không phải là Pythonic: những người quan tâm đến Python đủ kiên trì khi đối mặt với hành vi này là những người bị cuốn hút bởi ngôn ngữ này vì Python có ít bất ngờ hơn nhiều so với ngôn ngữ khác. Dabblers và người tò mò trở thành Pythonistas khi họ ngạc nhiên về việc mất ít thời gian để làm một cái gì đó hoạt động - không phải vì một thiết kế fl - ý tôi là, câu đố logic ẩn - cắt giảm trực giác của các lập trình viên bị thu hút bởi Python bởi vì nó chỉ hoạt động .

Đây không phải là một lỗ hổng thiết kế . Bất cứ ai đi qua đây là làm điều gì đó sai.

Có 3 trường hợp tôi thấy bạn có thể gặp phải vấn đề này ở đâu:

1. Bạn có ý định sửa đổi đối số là tác dụng phụ của hàm. Trong trường hợp này, không bao giờ có ý nghĩa để có một đối số mặc định. Ngoại lệ duy nhất là khi bạn lạm dụng danh sách đối số để có các thuộc tính hàm, ví dụ:cache={} , và bạn sẽ không được gọi hàm với một đối số thực tế.
2. Bạn có ý định để lại đối số không được sửa đổi, nhưng bạn đã vô tình làm sửa đổi nó. Đó là một lỗi, sửa nó.
3. Bạn dự định sửa đổi đối số để sử dụng bên trong hàm, nhưng không mong đợi sửa đổi có thể xem được bên ngoài hàm. Trong trường hợp đó, bạn cần tạo một bản sao của đối số, cho dù đó là mặc định hay không! Python không phải là ngôn ngữ gọi theo giá trị nên nó không tạo ra bản sao cho bạn, bạn cần phải rõ ràng về nó.

Ví dụ trong câu hỏi có thể rơi vào loại 1 hoặc 3. Thật kỳ lạ khi cả hai đều sửa đổi danh sách đã qua và trả về nó; bạn nên chọn cái này hay cái khác

"Lỗi" này đã cho tôi rất nhiều giờ làm việc ngoài giờ! Nhưng tôi bắt đầu thấy một tiềm năng sử dụng của nó (nhưng tôi vẫn thích nó ở thời điểm thực hiện)

Tôi sẽ cung cấp cho bạn những gì tôi thấy là một ví dụ hữu ích.

def example(errors=[]):
    # statements
    # Something went wrong
    mistake = True
    if mistake:
        tryToFixIt(errors)
        # Didn't work.. let's try again
        tryToFixItAnotherway(errors)
        # This time it worked
    return errors

def tryToFixIt(err):
    err.append('Attempt to fix it')

def tryToFixItAnotherway(err):
    err.append('Attempt to fix it by another way')

def main():
    for item in range(2):
        errors = example()
    print '\n'.join(errors)

main()

in như sau

Attempt to fix it
Attempt to fix it by another way
Attempt to fix it
Attempt to fix it by another way

Chỉ cần thay đổi chức năng là:

def notastonishinganymore(a = []): 
    '''The name is just a joke :)'''
    a = a[:]
    a.append(5)
    return a

Tôi nghĩ rằng câu trả lời cho câu hỏi này nằm ở cách python truyền dữ liệu cho tham số (truyền theo giá trị hoặc bằng tham chiếu), chứ không phải khả năng biến đổi hoặc cách python xử lý câu lệnh "def".

Giới thiệu ngắn gọn. Đầu tiên, có hai loại dữ liệu trong python, một loại là loại dữ liệu cơ bản đơn giản, như số và một loại dữ liệu khác là các đối tượng. Thứ hai, khi truyền dữ liệu cho các tham số, python chuyển loại dữ liệu cơ bản theo giá trị, nghĩa là tạo một bản sao cục bộ của giá trị cho một biến cục bộ, nhưng truyền đối tượng theo tham chiếu, tức là con trỏ tới đối tượng.

Thừa nhận hai điểm trên, hãy giải thích điều gì đã xảy ra với mã trăn. Đó chỉ là do chuyển qua tham chiếu cho các đối tượng, nhưng không liên quan gì đến biến đổi / bất biến, hoặc có thể cho rằng thực tế là câu lệnh "def" chỉ được thực thi một lần khi được định nghĩa.

[] là một đối tượng, vì vậy python chuyển tham chiếu của [] sang a, tức alà chỉ là một con trỏ tới [] nằm trong bộ nhớ dưới dạng đối tượng. Chỉ có một bản sao của [] với, tuy nhiên, nhiều tài liệu tham khảo về nó. Đối với foo () đầu tiên, danh sách [] được thay đổi thành 1 theo phương thức chắp thêm. Nhưng Lưu ý rằng chỉ có một bản sao của đối tượng danh sách và đối tượng này bây giờ trở thành 1 . Khi chạy foo () thứ hai, trang web effbot nói gì (các mục không được đánh giá nữa) là sai. ađược đánh giá là đối tượng danh sách, mặc dù bây giờ nội dung của đối tượng là 1 . Đây là hiệu ứng của việc vượt qua bằng cách tham khảo! Kết quả của foo (3) có thể dễ dàng xuất phát theo cùng một cách.

Để xác nhận thêm câu trả lời của tôi, chúng ta hãy xem hai mã bổ sung.

====== Số 2 ========

def foo(x, items=None):
    if items is None:
        items = []
    items.append(x)
    return items

foo(1)  #return [1]
foo(2)  #return [2]
foo(3)  #return [3]

[]là một đối tượng, vì vậy None(cái trước là có thể thay đổi trong khi cái sau là bất biến. Nhưng khả năng biến đổi không liên quan gì đến câu hỏi). Không có nơi nào trong không gian nhưng chúng tôi biết nó ở đó và chỉ có một bản sao của Không có ở đó. Vì vậy, mỗi khi foo được gọi, các mục được đánh giá (trái ngược với một số câu trả lời rằng nó chỉ được đánh giá một lần) là Không, để rõ ràng, tham chiếu (hoặc địa chỉ) của Không có. Sau đó, trong foo, mục được đổi thành [], nghĩa là trỏ đến một đối tượng khác có địa chỉ khác.

====== Số 3 =======

def foo(x, items=[]):
    items.append(x)
    return items

foo(1)    # returns [1]
foo(2,[]) # returns [2]
foo(3)    # returns [1,3]

Việc gọi foo (1) làm cho các mục trỏ đến một đối tượng danh sách [] với một địa chỉ, giả sử, 11111111. nội dung của danh sách được thay đổi thành 1 trong hàm foo trong phần tiếp theo, nhưng địa chỉ không bị thay đổi, vẫn là 11111111 Sau đó, foo (2, []) đang đến. Mặc dù [] trong foo (2, []) có cùng nội dung với tham số mặc định [] khi gọi foo (1), địa chỉ của chúng khác nhau! Vì chúng tôi cung cấp tham số rõ ràng, itemsphải lấy địa chỉ của cái mới này[] , giả sử 2222222 và trả lại sau khi thực hiện một số thay đổi. Bây giờ foo (3) được thực thi. từ chỉxđược cung cấp, các mục phải lấy lại giá trị mặc định của nó. Giá trị mặc định là gì? Nó được đặt khi xác định hàm foo: đối tượng danh sách nằm trong 11111111. Vì vậy, các mục được đánh giá là địa chỉ 11111111 có phần tử 1. Danh sách nằm ở 2222222 cũng chứa một phần tử 2, nhưng nó không được chỉ ra bởi các mục hơn. Do đó, một phụ lục 3 sẽ tạo ra items[1,3].

Từ những giải thích trên, chúng ta có thể thấy rằng trang web effbot được đề xuất trong câu trả lời được chấp nhận không thể đưa ra câu trả lời có liên quan cho câu hỏi này. Hơn nữa, tôi nghĩ rằng một điểm trong trang web effbot là sai. Tôi nghĩ rằng mã liên quan đến UI.Button là chính xác:

for i in range(10):
    def callback():
        print "clicked button", i
    UI.Button("button %s" % i, callback)

Mỗi nút có thể giữ một chức năng gọi lại riêng biệt sẽ hiển thị giá trị khác nhau i. Tôi có thể cung cấp một ví dụ để hiển thị điều này:

x=[]
for i in range(10):
    def callback():
        print(i)
    x.append(callback) 

Nếu chúng tôi thực hiện, x[7]()chúng tôi sẽ nhận được 7 như mong đợi và x[9]()sẽ cung cấp cho 9, một giá trị khác i.

TLDR: Mặc định thời gian xác định là nhất quán và biểu cảm rõ ràng hơn.

Xác định hàm ảnh hưởng đến hai phạm vi: phạm vi xác định chứa hàm và phạm vi thực thi được chứa bởi hàm. Mặc dù khá rõ ràng làm thế nào các khối ánh xạ tới phạm vi, câu hỏi là nơi def <name>(<args=defaults>):thuộc về:

...                           # defining scope
def name(parameter=default):  # ???
    ...                       # execution scope

Các def namephần phải đánh giá trong phạm vi quy định - chúng tôi muốn namecó sẵn ở đó, sau khi tất cả. Đánh giá chức năng chỉ bên trong chính nó sẽ làm cho nó không thể truy cập.

Vì parameterlà một tên không đổi, chúng ta có thể "đánh giá" nó cùng lúc với def name. Điều này cũng có lợi thế là nó tạo ra hàm với một chữ ký đã biết name(parameter=...):, thay vì để trần name(...):.

Bây giờ, khi nào cần đánh giá default?

Tính nhất quán đã nói "theo định nghĩa": mọi thứ khác def <name>(<args=defaults>):cũng được đánh giá tốt nhất theo định nghĩa. Trì hoãn các phần của nó sẽ là sự lựa chọn đáng kinh ngạc.

Hai lựa chọn không tương đương nhau: Nếu defaultđược đánh giá ở thời điểm xác định, nó vẫn có thể ảnh hưởng đến thời gian thực hiện. Nếu defaultđược đánh giá tại thời điểm thực hiện, nó không thể ảnh hưởng đến thời gian xác định. Chọn "tại định nghĩa" cho phép thể hiện cả hai trường hợp, trong khi chọn "tại thực thi" chỉ có thể diễn tả một:

def name(parameter=defined):  # set default at definition time
    ...

def name(parameter=default):     # delay default until execution time
    parameter = default if parameter is None else parameter
    ...

Mỗi câu trả lời khác giải thích lý do tại sao đây thực sự là một hành vi tốt đẹp và mong muốn, hoặc tại sao bạn không nên cần điều này. Của tôi là dành cho những người cứng đầu muốn thực hiện quyền uốn cong ngôn ngữ theo ý muốn của họ, không phải cách khác.

Chúng tôi sẽ "sửa" hành vi này với một trình trang trí sẽ sao chép giá trị mặc định thay vì sử dụng lại cùng một thể hiện cho mỗi đối số vị trí còn lại ở giá trị mặc định của nó.

import inspect
from copy import copy

def sanify(function):
    def wrapper(*a, **kw):
        # store the default values
        defaults = inspect.getargspec(function).defaults # for python2
        # construct a new argument list
        new_args = []
        for i, arg in enumerate(defaults):
            # allow passing positional arguments
            if i in range(len(a)):
                new_args.append(a[i])
            else:
                # copy the value
                new_args.append(copy(arg))
        return function(*new_args, **kw)
    return wrapper

Bây giờ hãy xác định lại chức năng của chúng tôi bằng cách sử dụng trang trí này:

@sanify
def foo(a=[]):
    a.append(5)
    return a

foo() # '[5]'
foo() # '[5]' -- as desired

Điều này đặc biệt gọn gàng cho các hàm có nhiều đối số. Đối chiếu:

# the 'correct' approach
def bar(a=None, b=None, c=None):
    if a is None:
        a = []
    if b is None:
        b = []
    if c is None:
        c = []
    # finally do the actual work

với

# the nasty decorator hack
@sanify
def bar(a=[], b=[], c=[]):
    # wow, works right out of the box!

Điều quan trọng cần lưu ý là giải pháp trên sẽ bị hỏng nếu bạn cố gắng sử dụng từ khóa args, như vậy:

foo(a=[4])

Trình trang trí có thể được điều chỉnh để cho phép điều đó, nhưng chúng tôi để điều này như một bài tập cho người đọc;)