ทุกคนที่มี Python นานพอถูกกัด (หรือฉีกเป็นชิ้น ๆ ) โดยปัญหาต่อไปนี้:

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

[5]สามเณรงูใหญ่คาดว่าจะได้ฟังก์ชั่นนี้เสมอกลับรายการที่มีเพียงองค์ประกอบหนึ่ง: ผลลัพธ์จะแตกต่างกันมากและน่าประหลาดใจมาก (สำหรับมือใหม่):

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

ผู้จัดการของฉันเคยพบกับคุณสมบัตินี้ครั้งแรกและเรียกมันว่า "ข้อบกพร่องในการออกแบบที่น่าทึ่ง" ของภาษา ฉันตอบว่าพฤติกรรมนั้นมีคำอธิบายพื้นฐานและเป็นเรื่องที่ทำให้งงงวยและคาดไม่ถึงถ้าคุณไม่เข้าใจ internals อย่างไรก็ตามฉันไม่สามารถตอบคำถามต่อไปนี้ (กับตัวเอง): อะไรคือเหตุผลในการเชื่อมอาร์กิวเมนต์เริ่มต้นที่คำจำกัดความของฟังก์ชั่นและไม่ทำงานในการดำเนินการ? ฉันสงสัยว่าพฤติกรรมที่มีประสบการณ์นั้นมีประโยชน์ในทางปฏิบัติ (ใครใช้ตัวแปรคงที่ใน C โดยไม่ต้องปรับปรุงบั๊ก)

แก้ไข :

Baczek เป็นตัวอย่างที่น่าสนใจ เมื่อรวมกับความคิดเห็นและ Utaal ของคุณโดยเฉพาะฉันขออธิบายเพิ่มเติม:

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

สำหรับฉันดูเหมือนว่าการตัดสินใจการออกแบบนั้นสัมพันธ์กับตำแหน่งที่จะวางขอบเขตของพารามิเตอร์: ภายในฟังก์ชันหรือ "ร่วมกัน" ด้วยหรือไม่

ทำผูกพันภายในฟังก์ชั่นจะหมายความว่าxมีผลผูกพันกับค่าเริ่มต้นที่ระบุเมื่อฟังก์ชั่นที่เรียกว่าไม่ได้กำหนดสิ่งที่จะนำเสนอข้อบกพร่องลึก: defบรรทัดจะเป็น "ลูกผสม" ในแง่ที่เป็นส่วนหนึ่งของการผูก วัตถุฟังก์ชั่น) จะเกิดขึ้นที่คำจำกัดความและส่วนหนึ่ง (การกำหนดพารามิเตอร์เริ่มต้น) ที่เวลาเรียกใช้ฟังก์ชั่น

พฤติกรรมที่เกิดขึ้นจริงนั้นสอดคล้องกันมากขึ้น: ทุกอย่างในบรรทัดนั้นจะถูกประเมินเมื่อประมวลผลบรรทัดนั้นซึ่งหมายถึงนิยามของฟังก์ชัน

จริงๆแล้วนี่ไม่ใช่ข้อบกพร่องด้านการออกแบบและไม่ใช่เพราะเรื่องภายในหรือประสิทธิภาพ
มันมาจากความจริงที่ว่าฟังก์ชั่นใน Python เป็นวัตถุชั้นหนึ่งและไม่เพียง แต่ส่วนหนึ่งของรหัส

ทันทีที่คุณคิดอย่างนี้มันก็สมเหตุสมผลแล้ว: ฟังก์ชั่นคือวัตถุที่ถูกประเมินตามคำนิยามของมัน พารามิเตอร์เริ่มต้นเป็นชนิดของ "ข้อมูลสมาชิก" ดังนั้นสถานะของพวกเขาอาจเปลี่ยนจากการโทรหนึ่งไปยังอีกสายหนึ่ง - เหมือนกับในวัตถุอื่น ๆ

ในกรณีใด ๆ Effbot มีคำอธิบายที่ดีมากในเหตุผลสำหรับพฤติกรรมนี้ในการเริ่มต้นค่าพารามิเตอร์ในหลาม
ฉันพบว่ามันชัดเจนมากและฉันขอแนะนำให้อ่านเพื่อความรู้ที่ดีขึ้นเกี่ยวกับการทำงานของวัตถุ

สมมติว่าคุณมีรหัสต่อไปนี้

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

def eat(food=fruits):
    ...

เมื่อฉันเห็นคำแถลงการณ์เกี่ยวกับการกินสิ่งที่น่าประหลาดใจอย่างน้อยที่สุดก็คือการคิดว่าถ้าไม่ได้ระบุพารามิเตอร์ตัวแรกมันจะเท่ากับ tuple ("apples", "bananas", "loganberries")

อย่างไรก็ตามในภายหลังในรหัสฉันควรทำสิ่งที่ชอบ

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

ถ้าพารามิเตอร์เริ่มต้นถูกผูกไว้ที่การทำงานของฟังก์ชั่นมากกว่าการประกาศฟังก์ชั่นแล้วฉันจะประหลาดใจ (ในทางที่ไม่ดีมาก) เพื่อค้นพบว่าผลไม้มีการเปลี่ยนแปลง นี่จะเป็น IMO ที่น่าประหลาดใจยิ่งกว่าการค้นพบว่าfooฟังก์ชันของคุณด้านบนเปลี่ยนแปลงรายการ

ปัญหาที่แท้จริงอยู่กับตัวแปรที่ไม่แน่นอนและทุกภาษามีปัญหานี้บ้าง นี่คือคำถาม: สมมติว่าใน Java ฉันมีรหัสต่อไปนี้:

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?

ตอนนี้แผนที่ของฉันใช้ค่าของStringBufferคีย์เมื่อมันถูกวางลงในแผนที่หรือมันเก็บกุญแจโดยอ้างอิง? ไม่ว่าจะด้วยวิธีใดมีคนประหลาดใจ บุคคลที่พยายามดึงวัตถุออกจากการMapใช้ค่าที่เหมือนกันกับวัตถุที่ใส่ไว้ด้วยหรือบุคคลที่ไม่สามารถดึงวัตถุได้แม้ว่ากุญแจที่ใช้อยู่นั้นจะเป็นวัตถุเดียวกัน ที่ใช้เพื่อใส่ลงในแผนที่ (นี่คือเหตุผลที่ Python ไม่อนุญาตให้ใช้ชนิดข้อมูลในตัวที่ไม่สามารถใช้เป็นคีย์พจนานุกรมได้)

ตัวอย่างของคุณเป็นตัวอย่างที่ดีที่ผู้ใช้ใหม่ของ Python จะต้องประหลาดใจและถูกกัด แต่ฉันจะเถียงว่าถ้าเรา "แก้ไข" สิ่งนี้ก็จะสร้างสถานการณ์ที่แตกต่างออกไปซึ่งพวกเขาจะถูกกัดแทนและสิ่งนั้นจะง่ายกว่า นอกจากนี้ยังเป็นกรณีเสมอเมื่อจัดการกับตัวแปรที่ไม่แน่นอน คุณมักพบกรณีที่มีคนคาดหวังอย่างใดอย่างหนึ่งอย่างใดอย่างหนึ่งหรือพฤติกรรมตรงข้ามขึ้นอยู่กับรหัสที่พวกเขากำลังเขียน

ฉันชอบวิธีการปัจจุบันของ Python: อาร์กิวเมนต์ของฟังก์ชันเริ่มต้นจะถูกประเมินเมื่อมีการกำหนดฟังก์ชันและวัตถุนั้นจะเป็นค่าเริ่มต้นเสมอ ฉันคิดว่าพวกเขาสามารถใช้กรณีพิเศษโดยใช้รายการที่ว่างเปล่า แต่การห่อแบบพิเศษนั้นจะทำให้เกิดความประหลาดใจมากยิ่งขึ้น

ส่วนที่เกี่ยวข้องของเอกสาร :

ค่าพารามิเตอร์เริ่มต้นจะถูกประเมินจากซ้ายไปขวาเมื่อมีการดำเนินการกำหนดฟังก์ชัน นี่หมายความว่านิพจน์ได้รับการประเมินหนึ่งครั้งเมื่อมีการกำหนดฟังก์ชันและใช้ค่า“ คำนวณล่วงหน้า” เดียวกันสำหรับการโทรแต่ละครั้ง สิ่งนี้สำคัญอย่างยิ่งที่จะต้องเข้าใจเมื่อพารามิเตอร์เริ่มต้นเป็นวัตถุที่ไม่แน่นอนเช่นรายการหรือพจนานุกรม: หากฟังก์ชันแก้ไขวัตถุ (เช่นการต่อท้ายรายการในรายการ) ค่าเริ่มต้นจะได้รับการแก้ไข โดยทั่วไปนี่ไม่ใช่สิ่งที่ตั้งใจไว้ วิธีนี้คือการใช้Noneเป็นค่าเริ่มต้นและทดสอบอย่างชัดเจนในเนื้อหาของฟังก์ชันเช่น:

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

ฉันไม่รู้อะไรเลยเกี่ยวกับผลงานภายในของ Python interpreter (และฉันก็ไม่ใช่ผู้เชี่ยวชาญในการแปลและล่ามด้วย) ดังนั้นอย่าโทษฉันถ้าฉันเสนออะไรที่ไม่ถูกต้องหรือเป็นไปไม่ได้

โดยมีเงื่อนไขว่าวัตถุหลามไม่แน่นอนฉันคิดว่าสิ่งนี้ควรนำมาพิจารณาเมื่อออกแบบสิ่งเริ่มต้นอาร์กิวเมนต์ เมื่อคุณยกตัวอย่างรายการ:

a = []

คุณคาดหวังที่จะได้รับใหม่aรายการอ้างอิงโดย

ทำไมต้องเป็นa=[]อิน

def x(a=[]):

ยกตัวอย่างรายการใหม่ในนิยามฟังก์ชันและไม่ใช่ในการเรียกใช้หรือไม่ มันเหมือนกับที่คุณถามว่า "ถ้าผู้ใช้ไม่ได้ระบุอาร์กิวเมนต์ให้ยกตัวอย่างรายการใหม่และใช้มันราวกับว่ามันถูกสร้างขึ้นโดยผู้โทร" ฉันคิดว่านี่ไม่ชัดเจนแทน:

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

ผู้ใช้คุณต้องการaเริ่มต้นกับวันที่และเวลาที่คุณต้องการกำหนดหรือดำเนินการxหรือไม่? ในกรณีนี้เช่นเดียวกับก่อนหน้านี้ฉันจะใช้ลักษณะการทำงานแบบเดียวกับถ้าอาร์กิวเมนต์เริ่มต้น "การมอบหมาย" เป็นคำสั่งแรกของฟังก์ชั่น ( datetime.now()เรียกว่าเมื่อเรียกใช้ฟังก์ชั่น) ในทางกลับกันหากผู้ใช้ต้องการการแมปเวลานิยามเขาสามารถเขียน:

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

ฉันรู้ว่าฉันรู้: นั่นคือการปิด Python อาจจัดเตรียมคำหลักเพื่อบังคับใช้การโยงเวลาแบบ จำกัด :

def x(static a=b):

เหตุผลก็คือค่อนข้างง่ายที่จะทำการผูกเมื่อรันโค้ดและคำจำกัดความของฟังก์ชั่นถูกดำเนินการดี ... เมื่อฟังก์ชั่นถูกกำหนด

เปรียบเทียบสิ่งนี้:

class BananaBunch:
    bananas = []

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

รหัสนี้ทนทุกข์ทรมานจากเหตุการณ์ที่ไม่คาดคิดที่เหมือนกัน bananas เป็นแอททริบิวต์คลาสดังนั้นเมื่อคุณเพิ่มรายการเข้าไปแอปจะถูกเพิ่มไปยังอินสแตนซ์ทั้งหมดของคลาสนั้น เหตุผลนั้นเหมือนกันหมด

มันเป็นแค่ "มันทำงานอย่างไร" และทำให้มันทำงานแตกต่างกันในกรณีของฟังก์ชั่นอาจจะซับซ้อนและในกรณีของคลาสอาจเป็นไปไม่ได้หรืออย่างน้อยก็ทำให้วัตถุ instantiation ช้าลงมากอย่างที่คุณจะต้องเก็บรหัสคลาสไว้ และดำเนินการเมื่อมีการสร้างวัตถุ

ใช่มันไม่คาดคิด แต่เมื่อเงินลดลงมันเข้ากันได้อย่างสมบูรณ์แบบกับวิธีการทำงานของ Python โดยทั่วไป ในความเป็นจริงมันเป็นเครื่องช่วยสอนที่ดีและเมื่อคุณเข้าใจว่าทำไมสิ่งนี้ถึงเกิดขึ้น

ที่กล่าวว่ามันควรมีคุณสมบัติเด่นในการสอน Python ที่ดี เพราะอย่างที่คุณพูดถึงทุกคนประสบปัญหานี้ไม่ช้าก็เร็ว

ทำไมคุณไม่ใคร่ครวญ

ฉันประหลาดใจจริง ๆไม่มีใครได้ทำการวิปัสสนาที่ลึกซึ้งที่เสนอโดย Python ( 2และ3ใช้) บน callables

รับฟังก์ชั่นเล็ก ๆ น้อย ๆ ที่เรียบง่ายที่funcกำหนดเป็น:

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

เมื่อ Python พบมันสิ่งแรกที่มันจะทำคือรวบรวมมันเพื่อสร้างcodeวัตถุสำหรับฟังก์ชั่นนี้ ขณะที่ขั้นตอนการรวบรวมนี้จะทำหลามประเมิน * แล้วเก็บข้อโต้แย้งเริ่มต้น (รายการที่ว่างเปล่า[]นี่) ในวัตถุฟังก์ชั่นของตัวเอง ตามคำตอบที่กล่าวไว้ด้านบน: รายการaสามารถถูกพิจารณาว่าเป็นสมาชิกของฟังก์ชันfuncได้

งั้นลองทำวิปัสสนาก่อนและหลังเพื่อตรวจสอบว่ารายการถูกขยายภายในวัตถุฟังก์ชันอย่างไร ฉันกำลังใช้Python 3.xสิ่งนี้สำหรับ Python 2 เช่นเดียวกัน (ใช้__defaults__หรือfunc_defaultsใน Python 2; ใช่สองชื่อสำหรับสิ่งเดียวกัน)

ฟังก์ชั่นก่อนที่จะดำเนินการ:

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

หลังจาก Python ดำเนินการคำจำกัดความนี้จะใช้พารามิเตอร์เริ่มต้นที่ระบุ ( a = []ที่นี่) และอัดไว้ใน__defaults__แอตทริบิวต์สำหรับวัตถุฟังก์ชั่น (ส่วนที่เกี่ยวข้อง: Callables):

>>> func.__defaults__
([],)

ตกลงดังนั้นรายการที่ว่างเปล่าเป็นรายการเดียวใน__defaults__ตามที่คาดไว้

ฟังก์ชั่นหลังจากการดำเนินการ:

ตอนนี้เราจะเรียกใช้ฟังก์ชันนี้:

>>> func()

ตอนนี้เรามาดู__defaults__กันอีกครั้ง:

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

ประหลาดใจ? ค่าภายในวัตถุเปลี่ยนแปลง! ตอนนี้การเรียกฟังก์ชันที่ต่อเนื่องจะผนวกเข้ากับlistวัตถุฝังตัวนั้น:

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

ดังนั้นคุณก็มีเหตุผลว่าทำไม'ข้อบกพร่อง' นี้เกิดขึ้นเพราะข้อโต้แย้งเริ่มต้นเป็นส่วนหนึ่งของฟังก์ชั่นวัตถุ ไม่มีอะไรแปลก ๆ เกิดขึ้นที่นี่มันน่าแปลกใจนิดหน่อย

วิธีการทั่วไปในการต่อสู้สิ่งนี้คือการใช้Noneเป็นค่าเริ่มต้นแล้วเริ่มต้นในเนื้อหาของฟังก์ชัน:

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

aเนื่องจากร่างกายฟังก์ชั่นที่จะดำเนินการอีกครั้งในแต่ละครั้งที่คุณเคยได้รับสดรายการใหม่ที่ว่างเปล่าถ้าไม่มีข้อโต้แย้งก็ผ่านไปได้สำหรับ

ในการตรวจสอบเพิ่มเติมว่ารายการใน__defaults__นั้นเหมือนกับที่ใช้ในฟังก์ชั่นfuncคุณสามารถเปลี่ยนฟังก์ชั่นของคุณเพื่อส่งคืนidรายการที่aใช้ภายในร่างกายของฟังก์ชัน จากนั้นเปรียบเทียบกับรายการใน__defaults__(ตำแหน่ง[0]ใน__defaults__) และคุณจะเห็นว่าสิ่งเหล่านี้มีการอ้างอิงถึงอินสแตนซ์รายการเดียวกันอย่างไร:

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

ทั้งหมดที่มีพลังของการใคร่ครวญ!

^*ในการตรวจสอบว่า Python ประเมินค่าอาร์กิวเมนต์เริ่มต้นในระหว่างการรวบรวมฟังก์ชั่นลองดำเนินการดังต่อไปนี้:

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

ตามที่คุณจะสังเกตเห็นจะinput()มีการเรียกก่อนกระบวนการสร้างฟังก์ชันและเชื่อมโยงกับชื่อbarนั้น

ฉันเคยคิดว่าการสร้างวัตถุที่รันไทม์จะเป็นวิธีที่ดีกว่า ฉันไม่แน่ใจตอนนี้เนื่องจากคุณสูญเสียคุณสมบัติที่มีประโยชน์บางอย่างแม้ว่ามันอาจจะคุ้มค่าโดยไม่คำนึงถึงเพียงเพื่อป้องกันความสับสนของมือใหม่ ข้อเสียของการทำเช่นนี้คือ:

1. ประสิทธิภาพ

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

หากมีการใช้การประเมินเวลาโทรฟังก์ชันราคาแพงจะถูกเรียกใช้ทุกครั้งที่มีการใช้ฟังก์ชันของคุณโดยไม่มีการโต้แย้ง คุณอาจจ่ายราคาแพงในการโทรแต่ละครั้งหรือต้องการแคชค่าด้วยตนเองจากภายนอกสร้างมลพิษให้กับเนมสเปซของคุณและเพิ่มการใช้คำฟุ่มเฟื่อย

2. การบังคับใช้พารามิเตอร์ที่ถูกผูกไว้

เคล็ดลับที่มีประโยชน์คือการผูกพารามิเตอร์ของแลมบ์ดากับการเชื่อมปัจจุบันของตัวแปรเมื่อสร้างแลมบ์ดา ตัวอย่างเช่น:

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

นี่จะส่งคืนรายการฟังก์ชันที่ส่งคืน 0,1,2,3 ... ตามลำดับ หากลักษณะการทำงานที่มีการเปลี่ยนแปลงที่พวกเขาแทนจะผูกiกับการเรียกร้องเวลา9ค่าของฉันดังนั้นคุณจะได้รับรายชื่อของฟังก์ชั่นที่ทุกคนกลับมา

วิธีเดียวที่จะใช้สิ่งนี้ได้ก็คือการสร้างการปิดเพิ่มเติมโดยมีการเชื่อมโยง i:

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

3. วิปัสสนา

พิจารณารหัส:

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

เราสามารถรับข้อมูลเกี่ยวกับข้อโต้แย้งและค่าเริ่มต้นโดยใช้inspectโมดูลซึ่ง

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

ข้อมูลนี้มีประโยชน์มากสำหรับสิ่งต่าง ๆ เช่นการสร้างเอกสาร metaprogramming มัณฑนากร ฯลฯ

ทีนี้สมมติว่าพฤติกรรมของค่าเริ่มต้นสามารถเปลี่ยนแปลงได้ดังนั้นสิ่งนี้จึงเท่ากับ:

_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=[]

อย่างไรก็ตามเราสูญเสียความสามารถในการไตร่ตรองและดูว่าอาร์กิวเมนต์เริ่มต้นคืออะไร เนื่องจากวัตถุไม่ได้ถูกสร้างขึ้นเราจึงไม่สามารถรับสิ่งเหล่านี้ได้โดยไม่เรียกใช้ฟังก์ชัน สิ่งที่ดีที่สุดที่เราสามารถทำได้คือการเก็บรหัสแหล่งที่มาและส่งคืนเป็นสตริง

5 คะแนนในการป้องกันของ Python

1. ความเรียบง่าย : พฤติกรรมนั้นง่ายในแง่ต่อไปนี้: คนส่วนใหญ่ตกหลุมพรางนี้เพียงครั้งเดียวไม่ใช่หลายครั้ง

2. ความสอดคล้อง : Python ส่งผ่านวัตถุเสมอไม่ใช่ชื่อ พารามิเตอร์เริ่มต้นคือส่วนหนึ่งของส่วนหัวของฟังก์ชั่น (ไม่ใช่ส่วนของฟังก์ชั่น) ดังนั้นจึงควรได้รับการประเมิน ณ เวลาโหลดโมดูล (และเฉพาะที่เวลาโหลดโมดูลยกเว้นอยู่ซ้อนกัน) ไม่ใช่เวลาเรียกใช้ฟังก์ชัน

3. ประโยชน์ : ตามที่ Frederik Lundh ชี้ให้เห็นในคำอธิบายของเขาว่า "ค่าพารามิเตอร์เริ่มต้นใน Python"พฤติกรรมปัจจุบันอาจมีประโยชน์สำหรับการตั้งโปรแกรมขั้นสูง (ใช้เท่าที่จำเป็น)

4. เอกสารเพียงพอ : ในเอกสารหลามพื้นฐานที่สุด, กวดวิชาที่ปัญหาจะมีการประกาศเสียงดังเป็น"คำเตือนที่สำคัญ"ในครั้งแรกส่วนย่อยของมาตรา "เพิ่มเติมเกี่ยวกับการกำหนดฟังก์ชั่น" คำเตือนยังใช้ตัวหนาซึ่งไม่ค่อยได้ใช้นอกส่วนหัว RTFM: อ่านคู่มืออย่างละเอียด

5. การเรียนรู้เมตา : การตกหลุมพรางนั้นเป็นช่วงเวลาที่มีประโยชน์มาก (อย่างน้อยถ้าคุณเป็นผู้เรียนไตร่ตรอง) เพราะคุณจะเข้าใจจุด "ความสอดคล้อง" ด้านบนได้ดีขึ้นและนั่นจะสอนคุณเกี่ยวกับงูหลาม

พฤติกรรมนี้อธิบายได้ง่ายโดย:

1. ประกาศฟังก์ชั่น (ชั้น ฯลฯ ) จะดำเนินการเพียงครั้งเดียวการสร้างวัตถุค่าเริ่มต้นทั้งหมด
2. ทุกอย่างถูกส่งผ่านโดยการอ้างอิง

ดังนั้น:

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

1. a ไม่เปลี่ยนแปลง - ทุกการเรียกการมอบหมายจะสร้างวัตถุ int ใหม่ - วัตถุใหม่จะถูกพิมพ์
2. b ไม่เปลี่ยนแปลง - อาร์เรย์ใหม่สร้างจากค่าเริ่มต้นและพิมพ์
3. c การเปลี่ยนแปลง - การดำเนินการจะดำเนินการกับวัตถุเดียวกัน - และมันจะถูกพิมพ์

สิ่งที่คุณถามคือเหตุผลนี้:

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

ไม่เท่ากับภายในนี้:

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()

ยกเว้นกรณีของการเรียก func อย่างชัดเจน (ไม่มี, ไม่มี) ซึ่งเราจะไม่สนใจ

กล่าวอีกนัยหนึ่งแทนที่จะประเมินพารามิเตอร์เริ่มต้นทำไมไม่เก็บแต่ละพารามิเตอร์ไว้และประเมินค่าเมื่อเรียกใช้ฟังก์ชัน

คำตอบเดียวน่าจะอยู่ตรงนั้น - มันจะเปลี่ยนทุกฟังก์ชั่นด้วยพารามิเตอร์เริ่มต้นให้เป็นการปิด แม้ว่ามันจะถูกซ่อนอยู่ในล่ามและไม่ใช่การปิดเต็มรูปแบบ แต่ข้อมูลก็จะถูกเก็บไว้ที่ใดที่หนึ่ง มันจะช้ากว่าและใช้หน่วยความจำมากขึ้น

1) ปัญหาที่เรียกว่า "อาร์กิวเมนต์เริ่มต้นที่ไม่แน่นอน" เป็นตัวอย่างพิเศษที่แสดงให้เห็นว่า:
"ฟังก์ชั่นทั้งหมดที่มีปัญหานี้ประสบจากปัญหาผลข้างเคียงที่คล้ายกันกับพารามิเตอร์จริง "
ซึ่งขัดกับกฎของการเขียนโปรแกรมการทำงาน มักจะมองไม่เห็นและควรได้รับการแก้ไขทั้งสองอย่างพร้อมกัน

ตัวอย่าง:

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]

วิธีการแก้ปัญหาคือการคัดลอก
วิธีการแก้ปัญหาความปลอดภัยอย่างแน่นอนคือการcopyหรือdeepcopyวัตถุป้อนข้อมูลครั้งแรกแล้วที่จะทำสิ่งที่มีการคัดลอก

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

หลายประเภทในตัวไม่แน่นอนมีวิธีการคัดลอกเหมือนsome_dict.copy()หรือsome_set.copy()หรือสามารถคัดลอกง่ายเหมือนหรือsomelist[:] list(some_list)ทุกวัตถุสามารถคัดลอกได้copy.copy(any_object)อย่างละเอียดโดยหรือมากกว่านั้นcopy.deepcopy()(ประโยชน์หลังหากวัตถุที่ไม่แน่นอนประกอบด้วยองค์ประกอบจากวัตถุที่ไม่แน่นอน) วัตถุบางอย่างมีพื้นฐานมาจากผลข้างเคียงเช่น "ไฟล์" วัตถุและไม่สามารถทำซ้ำอย่างมีความหมายโดยการคัดลอก การทำสำเนา

ตัวอย่างปัญหาสำหรับคำถาม SO ที่คล้ายกัน

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]

ไม่ควรบันทึกในแอตทริบิวต์สาธารณะใด ๆของอินสแตนซ์ที่ส่งคืนโดยฟังก์ชันนี้ (สมมติว่าแอตทริบิวต์ส่วนตัวของอินสแตนซ์ไม่ควรแก้ไขจากภายนอกคลาสหรือคลาสย่อยนี้โดยการประชุมนั่น_var1คือแอตทริบิวต์ส่วนตัว)

สรุป:
วัตถุอินพุตพารามิเตอร์ไม่ควรแก้ไขในตำแหน่ง (กลายพันธุ์) และไม่ควรผูกเข้ากับวัตถุที่ส่งคืนโดยฟังก์ชัน (หากเราทำการเขียนโปรแกรมล่วงหน้าโดยไม่มีผลข้างเคียงซึ่งขอแนะนำอย่างยิ่งให้ดูที่วิกิเกี่ยวกับ "ผลข้างเคียง" (สองย่อหน้าแรกมีความเกี่ยวข้องในบริบทนี้))

2)
เฉพาะในกรณีที่จำเป็นต้องใช้ผลข้างเคียงของพารามิเตอร์จริง แต่ไม่ต้องการค่าพารามิเตอร์เริ่มต้นโซลูชันที่มีประโยชน์คือdef ...(var1=None): if var1 is None: var1 = [] More

3) ในบางกรณีเป็นพฤติกรรมที่ไม่แน่นอนของค่าเริ่มต้นที่มีประโยชน์

สิ่งนี้ไม่มีส่วนเกี่ยวข้องกับค่าเริ่มต้นนอกจากนี้มันมักจะเกิดขึ้นเป็นพฤติกรรมที่ไม่คาดคิดเมื่อคุณเขียนฟังก์ชันด้วยค่าเริ่มต้นที่ไม่แน่นอน

>>> 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]

ไม่มีค่าเริ่มต้นที่เห็นได้ในรหัสนี้ แต่คุณได้รับปัญหาเดียวกันทั้งหมด

ปัญหาคือว่าfooมีการปรับเปลี่ยนตัวแปรไม่แน่นอนผ่านจากผู้โทรเมื่อโทรไม่คาดหวังนี้ รหัสเช่นนี้จะดีถ้าฟังก์ชั่นที่เรียกว่าสิ่งที่ต้องการappend_5; จากนั้นผู้เรียกจะเรียกใช้ฟังก์ชันเพื่อปรับเปลี่ยนค่าที่ส่งผ่านและพฤติกรรมที่คาดหวัง แต่ฟังก์ชั่นดังกล่าวจะไม่น่าจะเป็นอาร์กิวเมนต์ที่เป็นค่าเริ่มต้นและอาจจะไม่กลับรายการ (เนื่องจากผู้เรียกมีการอ้างอิงไปยังรายการนั้นอยู่แล้วมันเพิ่งผ่านไป)

ต้นฉบับของคุณที่fooมีอาร์กิวเมนต์เริ่มต้นไม่ควรแก้ไขaว่ามีการส่งผ่านอย่างชัดเจนในหรือได้รับค่าเริ่มต้น รหัสของคุณควรปล่อยให้อาร์กิวเมนต์ที่ไม่สามารถเปลี่ยนแปลงได้เพียงอย่างเดียวเว้นแต่ว่าจะชัดเจนจากบริบท / ชื่อ / เอกสารที่ควรมีการแก้ไข การใช้ค่าที่เปลี่ยนแปลงไม่ได้ที่ส่งผ่านเป็นอาร์กิวเมนต์เป็นตัวกำหนดเวลาท้องถิ่นเป็นแนวคิดที่ไม่ดีอย่างมากไม่ว่าเราจะอยู่ใน Python หรือไม่และมีข้อโต้แย้งเริ่มต้นที่เกี่ยวข้อง

หากคุณต้องการจัดการชั่วคราวในท้องถิ่นแบบทำลายล้างในระหว่างการคำนวณบางสิ่งและคุณต้องเริ่มการจัดการของคุณจากค่าอาร์กิวเมนต์คุณต้องทำสำเนา

หัวข้อยุ่งอยู่แล้ว แต่จากสิ่งที่ฉันอ่านที่นี่สิ่งต่อไปนี้ช่วยให้ฉันรู้ว่ามันทำงานอย่างไรภายใน:

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

เป็นการเพิ่มประสิทธิภาพ จากฟังก์ชั่นนี้คุณคิดว่าการโทรทั้งสองฟังก์ชั่นใดเร็วกว่ากัน?

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

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

ฉันจะให้คำแนะนำแก่คุณ นี่คือการถอดแยกชิ้นส่วน (ดูที่http://docs.python.org/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

ฉันสงสัยว่าพฤติกรรมที่มีประสบการณ์นั้นมีประโยชน์ในทางปฏิบัติ (ใครใช้ตัวแปรคงที่ใน C โดยไม่ต้องมีการปรับปรุงบั๊ก)

ในขณะที่คุณสามารถดูมีเป็นประโยชน์ประสิทธิภาพการทำงานเมื่อเริ่มต้นใช้อาร์กิวเมนต์ไม่เปลี่ยนรูป สิ่งนี้สามารถสร้างความแตกต่างได้หากเป็นฟังก์ชันที่มีการเรียกบ่อยครั้งหรืออาร์กิวเมนต์เริ่มต้นใช้เวลานานในการสร้าง อย่าลืมว่า Python ไม่ใช่ซีใน C คุณมีค่าคงที่ที่ค่อนข้างอิสระ ใน Python คุณไม่มีสิทธิประโยชน์นี้

Python: อาร์กิวเมนต์เริ่มต้นที่ไม่แน่นอน

อาร์กิวเมนต์เริ่มต้นจะถูกประเมินในเวลาที่ฟังก์ชันถูกรวบรวมเป็นวัตถุฟังก์ชัน เมื่อใช้โดยฟังก์ชั่นหลายครั้งโดยฟังก์ชั่นเหล่านั้นพวกเขาเป็นและยังคงวัตถุเดียวกัน

เมื่อพวกเขาไม่แน่นอนเมื่อกลายพันธุ์ (ตัวอย่างเช่นโดยการเพิ่มองค์ประกอบเข้าไป) พวกเขายังคงกลายพันธุ์ในการโทรติดต่อกัน

พวกเขายังคงอยู่เพราะพวกเขาเป็นวัตถุเดียวกันทุกครั้ง

รหัสเทียบเท่า:

เนื่องจากรายการถูกผูกไว้กับฟังก์ชันเมื่อวัตถุฟังก์ชันรวบรวมและสร้างอินสแตนซ์นี้:

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

เกือบจะเทียบเท่ากับสิ่งนี้ทั้งหมด:

_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

สาธิต

นี่คือการสาธิต - คุณสามารถตรวจสอบว่าพวกเขาเป็นวัตถุเดียวกันทุกครั้งที่มีการอ้างอิง

• เห็นว่ารายการถูกสร้างขึ้นก่อนที่ฟังก์ชั่นเสร็จสิ้นการรวบรวมวัตถุฟังก์ชั่น
• การสังเกตว่า id เหมือนกันทุกครั้งที่มีการอ้างอิงรายการ
• การสังเกตว่ารายการยังคงเปลี่ยนไปเมื่อฟังก์ชันที่ใช้เรียกว่าครั้งที่สอง
• สังเกตลำดับที่พิมพ์ออกมาจากแหล่งที่มา (ซึ่งฉันสะดวกสำหรับคุณ):

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()

และรันด้วย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']

สิ่งนี้ละเมิดหลักการของ "ความประหลาดใจน้อยที่สุด" หรือไม่?

ลำดับของการดำเนินการนี้มักทำให้ผู้ใช้ใหม่ของ Python สับสน หากคุณเข้าใจรูปแบบการดำเนินการของ Python มันจะกลายเป็นสิ่งที่คาดหวัง

คำสั่งปกติสำหรับผู้ใช้ Python ใหม่:

แต่นี่คือสาเหตุที่คำสั่งปกติสำหรับผู้ใช้ใหม่คือการสร้างอาร์กิวเมนต์เริ่มต้นเช่นนี้แทน:

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

สิ่งนี้ใช้ None Singleton เป็นวัตถุแมวมองเพื่อบอกฟังก์ชั่นว่าเราได้รับข้อโต้แย้งอื่นที่ไม่ใช่ค่าเริ่มต้น หากเราไม่ได้รับการโต้แย้งเราต้องการใช้รายการเปล่าใหม่[]เป็นค่าเริ่มต้น

ในขณะที่ส่วนการสอนเกี่ยวกับการไหลของการควบคุมกล่าวว่า:

หากคุณไม่ต้องการให้มีการแชร์ค่าเริ่มต้นระหว่างการโทรครั้งต่อไปคุณสามารถเขียนฟังก์ชั่นแบบนี้แทน:

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

คำตอบที่สั้นที่สุดน่าจะเป็น "คำจำกัดความคือการประมวลผล" ดังนั้นอาร์กิวเมนต์ทั้งหมดจึงไม่สมเหตุสมผล เป็นตัวอย่างที่วางแผนไว้มากขึ้นคุณอาจอ้างถึงสิ่งนี้:

def a(): return []

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

หวังว่าจะเพียงพอที่จะแสดงให้เห็นว่าการไม่ดำเนินการนิพจน์อาร์กิวเมนต์เริ่มต้น ณ เวลาดำเนินการของdefคำสั่งนั้นไม่ใช่เรื่องง่ายหรือไม่สมเหตุสมผลหรือทั้งสองอย่าง

ฉันยอมรับว่าเป็น gotcha เมื่อคุณพยายามใช้ตัวสร้างเริ่มต้น

วิธีแก้ปัญหาง่ายๆโดยใช้ None

>>> 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]

พฤติกรรมนี้ไม่น่าแปลกใจหากคุณพิจารณาสิ่งต่อไปนี้:

1. พฤติกรรมของแอตทริบิวต์คลาสอ่านอย่างเดียวเมื่อพยายามกำหนดและ
2. ฟังก์ชั่นเป็นวัตถุ (อธิบายได้ดีในคำตอบที่ยอมรับ)

บทบาทของ(2)ครอบคลุมในหัวข้อนี้อย่างกว้างขวาง (1)น่าจะเป็นสาเหตุของความประหลาดใจเนื่องจากพฤติกรรมนี้ไม่ได้ "หยั่งรู้" เมื่อมาจากภาษาอื่น

(1)อธิบายไว้ในหลามสอนในชั้นเรียน ในความพยายามที่จะกำหนดค่าให้กับคุณลักษณะคลาสแบบอ่านอย่างเดียว:

... ตัวแปรทั้งหมดที่พบนอกขอบเขตด้านในสุดนั้นเป็นแบบอ่านอย่างเดียว ( ความพยายามในการเขียนตัวแปรดังกล่าวจะสร้างตัวแปรท้องถิ่นขึ้นมาใหม่ในขอบเขตด้านในสุดโดยไม่เปลี่ยนแปลงตัวแปรภายนอกที่มีชื่อเหมือนกัน )

มองย้อนกลับไปที่ตัวอย่างดั้งเดิมและพิจารณาประเด็นข้างต้น:

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

นี่fooคือวัตถุและaเป็นคุณลักษณะของfoo(มีให้ที่foo.func_defs[0]) เนื่องจากaเป็นรายการที่ไม่แน่นอนและจึงแอตทริบิวต์อ่านเขียนของa fooมันจะเริ่มต้นในรายการที่ว่างเปล่าตามที่ระบุโดยลายเซ็นเมื่อฟังก์ชั่นจะถูกยกตัวอย่างและสามารถใช้ได้สำหรับการอ่านและการเขียนตราบเท่าที่วัตถุฟังก์ชั่นที่มีอยู่

การโทรfooโดยไม่ลบล้างค่าเริ่มต้นจะใช้ค่าเริ่มต้นfoo.func_defsนั้น ในกรณีนี้foo.func_defs[0]จะใช้สำหรับaภายในขอบเขตรหัสของวัตถุฟังก์ชั่น การเปลี่ยนแปลงการaเปลี่ยนแปลงfoo.func_defs[0]ซึ่งเป็นส่วนหนึ่งของfooวัตถุและยังคงอยู่ระหว่างการดำเนินการของรหัสในfooวัตถุและยังคงอยู่ระหว่างการดำเนินการของรหัสใน

ตอนนี้เปรียบเทียบสิ่งนี้กับตัวอย่างจากเอกสารประกอบเกี่ยวกับการเลียนแบบพฤติกรรมการโต้เถียงเริ่มต้นของภาษาอื่น ๆเช่นการใช้ค่าเริ่มต้นลายเซ็นของฟังก์ชั่นทุกครั้งที่มีการดำเนินการฟังก์ชั่น:

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

เมื่อคำนึงถึง(1)และ(2)เราจะเห็นว่าทำไมสิ่งนี้ถึงบรรลุถึงพฤติกรรมที่ต้องการ:

• เมื่อfooฟังก์ชั่นวัตถุเป็นอินสแตนซ์foo.func_defs[0]ตั้งNoneเป็นวัตถุที่ไม่เปลี่ยนรูป
• เมื่อฟังก์ชั่นถูกดำเนินการด้วยค่าเริ่มต้น (ไม่มีพารามิเตอร์ที่ระบุไว้สำหรับLในการเรียกใช้ฟังก์ชั่น), foo.func_defs[0]( None) จะสามารถใช้ได้ในขอบเขตท้องถิ่นเป็นLมีให้บริการในขอบเขตท้องถิ่น
• เมื่อL = []การมอบหมายไม่สามารถสำเร็จได้foo.func_defs[0]เนื่องจากแอตทริบิวต์นั้นเป็นแบบอ่านอย่างเดียว
• ต่อ(1) , ตัวแปรท้องถิ่นใหม่ชื่อยังLถูกสร้างขึ้นในขอบเขตท้องถิ่นและใช้สำหรับส่วนที่เหลือของการเรียกฟังก์ชั่น จึงยังคงไม่เปลี่ยนแปลงสำหรับสวดในอนาคตของfoo.func_defs[0]foo

ฉันจะแสดงให้เห็นถึงโครงสร้างทางเลือกเพื่อส่งผ่านรายการค่าเริ่มต้นไปยังฟังก์ชั่น (มันใช้ได้ดีกับพจนานุกรม)

ในขณะที่คนอื่น ๆ ได้แสดงความคิดเห็นอย่างกว้างขวางพารามิเตอร์รายการจะถูกผูกไว้กับฟังก์ชั่นเมื่อมันถูกกำหนดเมื่อเทียบกับเมื่อมันถูกดำเนินการ เนื่องจากรายการและพจนานุกรมไม่สามารถเปลี่ยนแปลงได้การเปลี่ยนแปลงใด ๆ ในพารามิเตอร์นี้จะส่งผลต่อการเรียกใช้ฟังก์ชันนี้อื่น ๆ ดังนั้นการเรียกฟังก์ชั่นที่ตามมาจะได้รับรายการที่แบ่งปันนี้ซึ่งอาจมีการเปลี่ยนแปลงโดยการโทรอื่น ๆ ไปยังฟังก์ชั่น ยิ่งไปกว่านั้นสองพารามิเตอร์กำลังใช้พารามิเตอร์ที่ใช้ร่วมกันของฟังก์ชั่นนี้ในเวลาเดียวกันโดยไม่คำนึงถึงการเปลี่ยนแปลงที่ทำโดยคนอื่น

วิธีการที่ไม่ถูกต้อง (อาจ ... ) :

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

คุณสามารถตรวจสอบว่าพวกเขาเป็นหนึ่งและวัตถุเดียวกันโดยใช้id:

>>> id(a)
5347866528

>>> id(b)
5347866528

Bython Slatkin ของ "Python ที่มีประสิทธิภาพ: 59 วิธีเฉพาะในการเขียน Python ที่ดีกว่า", รายการ 20: ใช้Noneและเอกสารประกอบเพื่อระบุอาร์กิวเมนต์เริ่มต้นแบบไดนามิก (หน้า 48)

แบบแผนสำหรับการบรรลุผลลัพธ์ที่ต้องการใน Python คือการให้ค่าเริ่มต้นNoneและเพื่อบันทึกพฤติกรรมที่เกิดขึ้นจริงใน docstring

การใช้งานนี้ทำให้มั่นใจได้ว่าการเรียกใช้ฟังก์ชันแต่ละครั้งจะได้รับรายการเริ่มต้นหรือรายการที่ส่งผ่านไปยังฟังก์ชันนั้นอีกครั้ง

วิธีที่ต้องการ :

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]

อาจมีกรณีการใช้งานที่ถูกต้องสำหรับ 'วิธีการที่ไม่ถูกต้อง' โดยโปรแกรมเมอร์ตั้งใจให้พารามิเตอร์รายการเริ่มต้นถูกแชร์ แต่มีแนวโน้มว่าเป็นข้อยกเว้นมากกว่ากฎ

การแก้ปัญหาที่นี่คือ:

1. ใช้Noneเป็นค่าเริ่มต้นของคุณ (หรือ nonce object) และเปิดเพื่อสร้างค่าของคุณในขณะทำงาน หรือ
2. ใช้lambdaเป็นพารามิเตอร์เริ่มต้นของคุณและเรียกมันว่าภายในบล็อกลองเพื่อรับค่าเริ่มต้น (นี่คือประเภทของสิ่งที่แลมบ์ดาเป็นนามธรรม)

ตัวเลือกที่สองนั้นดีเพราะผู้ใช้ฟังก์ชั่นสามารถส่งผ่าน callable ซึ่งอาจมีอยู่แล้ว (เช่น a type)

เมื่อเราทำสิ่งนี้:

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

... เรากำหนดอาร์กิวเมนต์aให้กับบุคคลที่ไม่มีชื่อรายการที่ชื่อหากผู้เรียกไม่ผ่านค่าของ

เพื่อให้สิ่งที่ง่ายขึ้นสำหรับการสนทนานี้ให้ตั้งชื่อรายการที่ไม่มีชื่อเป็นการชั่วคราว แล้วไงpavloล่ะ

def foo(a=pavlo):
   ...

เมื่อใดก็ได้หากผู้โทรไม่ได้บอกเราว่าเราaคืออะไรเราจะใช้ซ้ำpavloเป็นเรานำมาใช้ใหม่

หากpavloไม่แน่นอน (แก้ไขได้) และfooจบลงด้วยการปรับเปลี่ยนผลกระทบที่เราสังเกตเห็นในครั้งต่อไปfooจะถูกเรียกโดยไม่ระบุaจะเรียกว่าไม่ต้องระบุ

ดังนั้นนี่คือสิ่งที่คุณเห็น (โปรดจำไว้ว่าpavloเริ่มต้นเป็น []):

 >>> foo()
 [5]

ตอนนี้ pavloคือ [5]

การโทรfoo()แก้ไขpavloอีกครั้งอีกครั้ง:

>>> foo()
[5, 5]

การระบุaเมื่อไม่foo()แน่ใจว่าได้โทรpavloแล้ว

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

ดังนั้นยังคงเป็นpavlo[5, 5]

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

บางครั้งฉันใช้ประโยชน์จากพฤติกรรมนี้แทนรูปแบบต่อไปนี้:

singleton = None

def use_singleton():
    global singleton

    if singleton is None:
        singleton = _make_singleton()

    return singleton.use_me()

หากsingletonใช้โดยuse_singletonเฉพาะฉันชอบรูปแบบต่อไปนี้แทน:

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

ฉันใช้สิ่งนี้เพื่อสร้างอินสแตนซ์ของคลาสไคลเอนต์ที่เข้าถึงทรัพยากรภายนอกและสำหรับการสร้าง dicts หรือรายการสำหรับบันทึก

เนื่องจากฉันไม่คิดว่ารูปแบบนี้เป็นที่รู้จักกันดีฉันจะใส่ความคิดเห็นสั้น ๆ เพื่อป้องกันความเข้าใจผิดในอนาคต

คุณสามารถปัดเศษสิ่งนี้ด้วยการแทนที่วัตถุ (ดังนั้นการผูกด้วยขอบเขต):

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

น่าเกลียด แต่ก็ใช้งานได้

มันอาจเป็นจริงที่:

1. มีคนใช้คุณสมบัติทุกภาษา / ไลบรารีและ
2. การเปลี่ยนพฤติกรรมที่นี่จะไม่เหมาะสม แต่

มันสอดคล้องกันโดยสิ้นเชิงกับคุณสมบัติทั้งสองด้านบนและยังคงเป็นประเด็นต่อไป:

3. มันเป็นคุณสมบัติที่ทำให้เกิดความสับสนและเป็นโชคร้ายใน Python

คำตอบอื่น ๆ หรืออย่างน้อยบางคนทำคะแนน 1 และ 2 แต่ไม่ใช่ 3 หรือทำคะแนน 3 และชี้ลง 1 และ 2 แต่ทั้งสามเป็นจริง

อาจเป็นเรื่องจริงที่การสลับม้าในกลางน้ำที่นี่จะขอให้มีการแตกหักที่สำคัญและอาจมีปัญหามากกว่านี้ที่เกิดจากการเปลี่ยน Python ให้จัดการสนิปเพตของ Stefano โดยสังเขป และมันอาจเป็นความจริงที่คนที่รู้จัก Python ภายในสามารถอธิบายผลที่เกิดขึ้นจริงได้ อย่างไรก็ตาม

พฤติกรรมที่มีอยู่ไม่ได้เป็น Pythonic และ Python ก็ประสบความสำเร็จเพราะมีน้อยมากเกี่ยวกับภาษาที่ละเมิดหลักการของความประหลาดใจอย่างน้อยทุกที่ที่อยู่ใกล้นี้ไม่ดี มันเป็นปัญหาที่แท้จริงไม่ว่าจะเป็นการถอนรากหรือไม่ก็ตาม มันเป็นข้อบกพร่องในการออกแบบ หากคุณเข้าใจภาษาที่ดีขึ้นโดยพยายามติดตามพฤติกรรมฉันสามารถพูดได้ว่า C ++ ทำสิ่งนี้และอื่น ๆ ทั้งหมด คุณเรียนรู้มากโดยการนำตัวอย่างเช่นข้อผิดพลาดตัวชี้ที่ละเอียดอ่อน แต่นี่ไม่ใช่ Pythonic: คนที่สนใจเกี่ยวกับ Python มากพอที่จะอดทนต่อการเผชิญกับพฤติกรรมนี้คือคนที่ถูกดึงดูดให้ใช้ภาษาเพราะ Python มีความประหลาดใจน้อยกว่าภาษาอื่น ๆ Dabblers และผู้อยากรู้อยากเห็นกลายเป็น Pythonistas เมื่อพวกเขาประหลาดใจในเวลาเพียงเล็กน้อยที่จะทำให้บางสิ่งบางอย่างทำงานได้ - ไม่ใช่เพราะการออกแบบ - ฉันหมายถึงปริศนาตรรกะที่ซ่อนอยู่ - ที่ตัดกับสัญชาตญาณของโปรแกรมเมอร์ เพราะมันใช้งานได้จริง

นี้ไม่ได้เป็นข้อบกพร่องในการออกแบบ ใครก็ตามที่เดินทางข้ามสิ่งนี้กำลังทำสิ่งผิดปกติ

มี 3 กรณีที่ฉันเห็นว่าคุณอาจพบปัญหานี้:

1. คุณตั้งใจจะแก้ไขข้อโต้แย้งเป็นผลข้างเคียงของฟังก์ชั่น ในกรณีนี้มันไม่มีเหตุผลที่จะมีอาร์กิวเมนต์เริ่มต้น ข้อยกเว้นเพียงอย่างเดียวคือเมื่อคุณใช้รายการอาร์กิวเมนต์ในทางที่ผิดเพื่อให้มีฟังก์ชั่นฟังก์ชั่นเช่นcache={}และคุณจะไม่ถูกคาดหวังให้เรียกใช้ฟังก์ชันด้วยอาร์กิวเมนต์จริงเลย
2. คุณตั้งใจจะปล่อยให้อาร์กิวเมนต์ไม่ได้แก้ไข แต่คุณได้ทำการแก้ไขโดยไม่ตั้งใจ นั่นเป็นข้อผิดพลาดแก้ไขได้
3. คุณตั้งใจจะแก้ไขอาร์กิวเมนต์เพื่อใช้ภายในฟังก์ชั่น แต่ไม่ได้คาดหวังว่าการแก้ไขจะสามารถดูได้นอกฟังก์ชั่น ในกรณีที่คุณต้องทำสำเนาของการโต้แย้งไม่ว่าจะเป็นค่าเริ่มต้นหรือไม่! Python ไม่ใช่ภาษาการโทรตามค่าดังนั้นจึงไม่ได้คัดลอกสำหรับคุณคุณต้องมีความชัดเจนเกี่ยวกับเรื่องนี้

ตัวอย่างในคำถามอาจอยู่ในหมวดที่ 1 หรือ 3 มันแปลกที่ทั้งคู่แก้ไขรายการที่ส่งผ่านแล้วส่งคืน คุณควรเลือกอย่างใดอย่างหนึ่ง

"บั๊ก" นี้ให้เวลาทำงานล่วงเวลาเยอะมาก! แต่ฉันเริ่มเห็นความเป็นไปได้ที่จะใช้มัน (แต่ฉันก็อยากให้มันเป็นช่วงเวลาการประหารชีวิต)

ฉันจะให้สิ่งที่ฉันเห็นเป็นตัวอย่างที่มีประโยชน์

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()

พิมพ์ดังต่อไปนี้

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

เพียงเปลี่ยนฟังก์ชั่นเป็น:

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

ฉันคิดว่าคำตอบสำหรับคำถามนี้อยู่ในวิธีที่ python ส่งผ่านข้อมูลไปยังพารามิเตอร์ (ผ่านค่าหรืออ้างอิง) ไม่ใช่ความแปรปรวนหรือวิธีที่ python จัดการกับคำสั่ง "def"

แนะนำสั้น ๆ เริ่มแรกมีชนิดข้อมูลสองชนิดในหลามหนึ่งคือชนิดข้อมูลพื้นฐานอย่างง่ายเช่นตัวเลขและชนิดข้อมูลอื่นคือวัตถุ ประการที่สองเมื่อส่งข้อมูลไปยังพารามิเตอร์ python ผ่านข้อมูลพื้นฐานระดับประถมศึกษาปีตามค่าคือทำสำเนาท้องถิ่นของค่าไปยังตัวแปรท้องถิ่น แต่ผ่านวัตถุโดยอ้างอิงคือตัวชี้ไปยังวัตถุ

การยอมรับจุดสองจุดด้านบนลองอธิบายสิ่งที่เกิดขึ้นกับรหัสหลาม เป็นเพียงเพราะผ่านการอ้างอิงสำหรับวัตถุ แต่ไม่มีส่วนเกี่ยวข้องกับการเปลี่ยนแปลง / เปลี่ยนแปลงไม่ได้หรือเนื้อหาที่คำสั่ง "def" ถูกเรียกใช้งานเพียงครั้งเดียวเมื่อมีการกำหนด

[] เป็นวัตถุดังนั้น python จึงส่งผ่านการอ้างอิงของ [] ไปยังaกล่าวaคือเป็นเพียงตัวชี้ไปยัง [] ซึ่งอยู่ในหน่วยความจำในฐานะวัตถุ อย่างไรก็ตามมี [] สำเนาเพียงหนึ่งชุดที่มีการอ้างอิงจำนวนมาก สำหรับ foo แรก () รายการ [] จะเปลี่ยนเป็น1โดยใช้วิธีต่อท้าย แต่ทราบว่ามีเพียงหนึ่งสำเนาของวัตถุรายการและวัตถุนี้ตอนนี้กลายเป็น1 เมื่อเรียกใช้ foo ตัวที่สอง () หน้าเว็บ effbot พูดว่าอะไร (ไม่มีการประเมินรายการใด ๆ เพิ่มเติม) ผิด aได้รับการประเมินให้เป็นวัตถุของรายการถึงแม้ว่าตอนนี้เนื้อหาของวัตถุที่เป็น1 นี่คือผลของการส่งต่อโดยการอ้างอิง! ผลที่ได้จาก foo (3) นั้นสามารถหาได้ง่ายในวิธีเดียวกัน

หากต้องการตรวจสอบคำตอบของฉันเพิ่มเติมให้ดูที่รหัสเพิ่มเติมสองรหัส

====== หมายเลข 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]

[]เป็นวัตถุดังนั้นคือNone(อดีตไม่แน่นอนในขณะที่หลังไม่เปลี่ยนรูป แต่ความผันแปรไม่ได้เกี่ยวข้องกับคำถาม) ไม่มีใครอยู่ในพื้นที่ แต่เรารู้ว่ามันอยู่ที่นั่นและมีสำเนาหนึ่งฉบับไม่มี ดังนั้นทุกครั้งที่มีการเรียก foo ไอเท็มจะถูกประเมิน (ตรงข้ามกับคำตอบที่ได้รับการประเมินเพียงครั้งเดียว) เป็นไม่มีเพื่อให้ชัดเจนการอ้างอิง (หรือที่อยู่) ของไม่มี จากนั้นในรายการ foo จะเปลี่ยนเป็น [] เช่นชี้ไปที่วัตถุอื่นซึ่งมีที่อยู่แตกต่างกัน

====== หมายเลข 3 =======

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

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

การภาวนาของ foo (1) ทำให้รายการชี้ไปที่วัตถุรายการ [] พร้อมที่อยู่พูด 11111111 เนื้อหาของรายการจะเปลี่ยนเป็น1ในฟังก์ชั่น foo ในภาคต่อ แต่ที่อยู่ไม่เปลี่ยนแปลง 11111111 ยังคง จากนั้น foo (2, []) กำลังจะมา แม้ว่า [] ใน foo (2, []) มีเนื้อหาเหมือนกับพารามิเตอร์เริ่มต้น [] เมื่อเรียก foo (1) ที่อยู่ของพวกเขาแตกต่างกัน! เนื่องจากเราระบุพารามิเตอร์อย่างชัดเจนitemsจึงต้องใช้ที่อยู่ของใหม่นี้[]พูด 2222222 และส่งคืนหลังจากทำการเปลี่ยนแปลงบางอย่าง ตอนนี้ foo (3) จะถูกดำเนินการ ตั้งแต่เท่านั้นxให้ไว้รายการจะต้องใช้ค่าเริ่มต้นอีกครั้ง ค่าเริ่มต้นคืออะไร มันถูกตั้งค่าเมื่อกำหนดฟังก์ชั่น foo: วัตถุรายการที่อยู่ใน 11111111 ดังนั้นรายการจะถูกประเมินเป็นที่อยู่ 11111111 ที่มีองค์ประกอบ 1 รายการอยู่ที่ 2222222 ยังมีองค์ประกอบหนึ่ง 2 แต่มันไม่ได้ชี้ไปที่รายการใด ๆ มากกว่า. ดังนั้นการผนวก 3 จะทำให้items[1,3]

จากคำอธิบายข้างต้นเราจะเห็นได้ว่าหน้าเว็บeffbot ที่แนะนำในคำตอบที่ยอมรับนั้นล้มเหลวในการให้คำตอบที่เกี่ยวข้องกับคำถามนี้ ยิ่งไปกว่านั้นฉันคิดว่าจุดหนึ่งในเว็บเพจของ effbot นั้นผิด ฉันคิดว่ารหัสที่เกี่ยวกับ UI.Button นั้นถูกต้อง:

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

iแต่ละปุ่มสามารถถือฟังก์ชั่นการโทรกลับที่แตกต่างกันซึ่งจะแสดงค่าที่แตกต่างกันของ ฉันสามารถให้ตัวอย่างเพื่อแสดงสิ่งนี้:

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

ถ้าเราดำเนินการx[7]()เราจะได้รับ 7 ตามที่คาดไว้และx[9]()ประสงค์ให้ 9 iคุ้มค่าของผู้อื่น

TLDR: การกำหนดค่าเริ่มต้นตามเวลามีความสอดคล้องและแสดงออกอย่างเข้มงวดยิ่งขึ้น

การกำหนดฟังก์ชั่นส่งผลกระทบต่อสองขอบเขต: ขอบเขตการกำหนดที่มีฟังก์ชั่นและขอบเขตการดำเนินการที่มีอยู่โดยฟังก์ชั่น ในขณะที่มันค่อนข้างชัดเจนว่าบล็อกแผนที่เพื่อขอบเขตคำถามที่def <name>(<args=defaults>):เป็นของ:

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

def nameส่วนหนึ่งต้องประเมินผลในการกำหนดขอบเขต - เราต้องการที่nameจะสามารถใช้ได้มีหลังจากทั้งหมด การประเมินฟังก์ชั่นภายในตัวเองเท่านั้นจะทำให้ไม่สามารถเข้าถึงได้

เนื่องจากparameterเป็นชื่ออย่างต่อเนื่องเราสามารถ "ประเมิน" def nameในเวลาเดียวกับ นอกจากนี้ยังมีความได้เปรียบมันผลิตฟังก์ชั่นที่มีลายเซ็นที่รู้จักกันในนามแทนการเปลือยname(parameter=...):name(...):

ตอนนี้เมื่อไหร่ที่จะประเมินdefault?

ความสอดคล้องได้กล่าวว่า "ที่คำจำกัดความ": ทุกสิ่งอื่นของการdef <name>(<args=defaults>):ประเมินที่ดีที่สุดที่คำนิยามเช่นกัน การยืดเวลาบางส่วนออกไปจะเป็นทางเลือกที่น่าอัศจรรย์

ตัวเลือกทั้งสองไม่เท่ากัน: หากdefaultได้รับการประเมิน ณ เวลาที่กำหนดจะยังคงมีผลต่อเวลาดำเนินการ หากdefaultประเมินผล ณ เวลาดำเนินการจะไม่ส่งผลต่อเวลากำหนด การเลือก "at definition" อนุญาตให้แสดงทั้งสองกรณีขณะที่การเลือก "at execution" สามารถแสดงได้เพียงหนึ่งกรณี:

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
    ...

ทุกคำตอบอื่น ๆ อธิบายว่าทำไมนี่จึงเป็นพฤติกรรมที่ดีและต้องการหรือทำไมคุณไม่ควรต้องการสิ่งนี้ ของฉันมีไว้สำหรับคนที่ดื้อรั้นที่ต้องการใช้สิทธิ์ในการงอภาษาตามความต้องการของพวกเขาไม่ใช่วิธีอื่น

เราจะ "แก้ไข" พฤติกรรมนี้ด้วยมัณฑนากรที่จะคัดลอกค่าเริ่มต้นแทนที่จะนำอินสแตนซ์เดียวกันกลับมาใช้ใหม่สำหรับแต่ละอาร์กิวเมนต์ตำแหน่งที่เหลืออยู่ที่ค่าเริ่มต้น

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

ทีนี้เราจะนิยามฟังก์ชันของเราใหม่โดยใช้มัณฑนากรนี้:

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

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

นี่เป็นระเบียบโดยเฉพาะอย่างยิ่งสำหรับฟังก์ชั่นที่รับอาร์กิวเมนต์หลายตัว เปรียบเทียบ:

# 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

กับ

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

เป็นสิ่งสำคัญที่จะต้องทราบว่าโซลูชันด้านบนจะหยุดลงหากคุณพยายามใช้ args คำหลักเช่น:

foo(a=[4])

มัณฑนากรสามารถปรับได้เพื่อให้ได้ แต่เราปล่อยให้สิ่งนี้เป็นการออกกำลังกายสำหรับผู้อ่าน;)