Source: C++ Default Arguments in Functions: Using Default Arguments in C++ from morioh.com

anybody tinkering with Python agelong adequate has been bitten (oregon torn to items) by the pursuing content:

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

Python novices would anticipate this relation referred to as with nary parameter to ever instrument a database with lone 1 component: [5]. The consequence is alternatively precise antithetic, and precise astonishing (for a novice):

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

A director of excavation erstwhile had his archetypal brush with this characteristic, and known as it "a melodramatic plan flaw" of the communication. one replied that the behaviour had an underlying mentation, and it is so precise puzzling and sudden if you don't realize the internals. nevertheless, one was not capable to reply (to myself) the pursuing motion: what is the ground for binding the default statement astatine relation explanation, and not astatine relation execution? one uncertainty the skilled behaviour has a applicable usage (who truly utilized static variables successful C, with out breeding bugs?)

Edit:

Baczek made an absorbing illustration. unneurotic with about of your feedback and Utaal's successful peculiar, one elaborated additional:

def a():
    mark("a executed")
    instrument []

           
def b(x=a()):
    x.append(5)
    mark(x)

a executed
>>> b()
[5]
>>> b()
[5, 5]

To maine, it appears that the plan determination was comparative to wherever to option the range of parameters: wrong the relation, oregon "unneurotic" with it?

Doing the binding wrong the relation would average that x is efficaciously sure to the specified default once the relation is known as, not outlined, thing that would immediate a heavy flaw: the def formation would beryllium "hybrid" successful the awareness that portion of the binding (of the relation entity) would hap astatine explanation, and portion (duty of default parameters) astatine relation invocation clip.

The existent behaviour is much accordant: every thing of that formation will get evaluated once that formation is executed, which means astatine relation explanation.

really, this is not a plan flaw, and it is not due to the fact that of internals oregon show. It comes merely from the information that capabilities successful Python are archetypal-people objects, and not lone a part of codification.

arsenic shortly arsenic you deliberation of it this manner, past it wholly makes awareness: a relation is an entity being evaluated connected its explanation; default parameters are benignant of "associate information" and so their government whitethorn alteration from 1 telephone to the another - precisely arsenic successful immoderate another entity.

successful immoderate lawsuit, the effbot (Fredrik Lundh) has a precise good mentation of the causes for this behaviour successful Default Parameter Values successful Python. one recovered it precise broad, and one truly propose speechmaking it for a amended cognition of however relation objects activity.

say you person the pursuing codification

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

def consume(nutrient=fruits):
    ...

once one seat the declaration of consume, the slightest astonishing happening is to deliberation that if the archetypal parameter is not fixed, that it volition beryllium close to the tuple ("apples", "bananas", "loganberries")

nevertheless, say future connected successful the codification, one bash thing similar

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

past if default parameters have been sure astatine relation execution instead than relation declaration, one would beryllium astonished (successful a precise atrocious manner) to detect that fruits had been modified. This would beryllium much astonishing IMO than discovering that your foo relation supra was mutating the database.

The existent job lies with mutable variables, and each languages person this job to any degree. present's a motion: say successful Java one person the pursuing codification:

StringBuffer s = fresh StringBuffer("hullo planet!");
representation counts = fresh HashMap();
counts.option(s, 5);
s.append("!!!!");
scheme.retired.println( counts.acquire(s) );  // does this activity?

present, does my representation usage the worth of the StringBuffer cardinal once it was positioned into the representation, oregon does it shop the cardinal by mention? both manner, person is astonished; both the individual who tried to acquire the entity retired of the representation utilizing a worth an identical to the 1 they option it successful with, oregon the individual who tin't look to retrieve their entity equal although the cardinal they're utilizing is virtually the aforesaid entity that was utilized to option it into the representation (this is really wherefore Python doesn't let its mutable constructed-successful information sorts to beryllium utilized arsenic dictionary keys).

Your illustration is a bully 1 of a lawsuit wherever Python newcomers volition beryllium amazed and bitten. however one'd reason that if we "mounted" this, past that would lone make a antithetic occupation wherever they'd beryllium bitten alternatively, and that 1 would beryllium equal little intuitive. furthermore, this is ever the lawsuit once dealing with mutable variables; you ever tally into circumstances wherever person may intuitively anticipate 1 oregon the other behaviour relying connected what codification they're penning.

one personally similar Python's actual attack: default relation arguments are evaluated once the relation is outlined and that entity is ever the default. one say they might particular-lawsuit utilizing an bare database, however that benignant of particular casing would origin equal much astonishment, not to notation beryllium backwards incompatible.

The applicable portion of the documentation:

Default parameter values are evaluated from near to correct once the relation explanation is executed. This means that the look is evaluated erstwhile, once the relation is outlined, and that the aforesaid “pre-computed” worth is utilized for all telephone. This is particularly crucial to realize once a default parameter is a mutable entity, specified arsenic a database oregon a dictionary: if the relation modifies the entity (e.g. by appending an point to a database), the default worth is successful consequence modified. This is mostly not what was supposed. A manner about this is to usage no arsenic the default, and explicitly trial for it successful the assemblage of the relation, e.g.:
def whats_on_the_telly(penguin=no):
    if penguin is no:
        penguin = []
    penguin.append("place of the zoo")
    instrument penguin

one cognize thing astir the Python interpreter interior workings (and one'm not an adept successful compilers and interpreters both) truthful don't blasted maine if one suggest thing unsensible oregon intolerable.

offered that python objects are mutable one deliberation that this ought to beryllium taken into relationship once designing the default arguments material. once you instantiate a database:

a = []

you anticipate to acquire a fresh database referenced by a.

wherefore ought to the a=[] successful

def x(a=[]):

instantiate a fresh database connected relation explanation and not connected invocation? It's conscionable similar you're asking "if the person doesn't supply the statement past instantiate a fresh database and usage it arsenic if it was produced by the caller". one deliberation this is ambiguous alternatively:

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

person, bash you privation a to default to the datetime corresponding to once you're defining oregon executing x? successful this lawsuit, arsenic successful the former 1, one'll support the aforesaid behaviour arsenic if the default statement "duty" was the archetypal education of the relation (datetime.present() referred to as connected relation invocation). connected the another manus, if the person wished the explanation-clip mapping helium might compose:

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

one cognize, one cognize: that's a closure. Alternatively Python mightiness supply a key phrase to unit explanation-clip binding:

def x(static a=b):

fine, the ground is rather merely that bindings are finished once codification is executed, and the relation explanation is executed, fine... once the features is outlined.

comparison this:

people BananaBunch:
    bananas = []

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

This codification suffers from the direct aforesaid surprising happenstance. bananas is a people property, and therefore, once you adhd issues to it, it's added to each cases of that people. The ground is precisely the aforesaid.

It's conscionable "however It plant", and making it activity otherwise successful the relation lawsuit would most likely beryllium complex, and successful the people lawsuit apt intolerable, oregon astatine slightest dilatory behind entity instantiation a batch, arsenic you would person to support the people codification about and execute it once objects are created.

sure, it is surprising. however erstwhile the penny drops, it suits successful absolutely with however Python plant successful broad. successful information, it's a bully educating assistance, and erstwhile you realize wherefore this occurs, you'll grok python overmuch amended.

That mentioned it ought to characteristic prominently successful immoderate bully Python tutorial. due to the fact that arsenic you notation, everybody runs into this job sooner oregon future.

wherefore don't you introspect?

one'm truly amazed nary 1 has carried out the insightful introspection provided by Python (2 and three use) connected callables.

fixed a elemental small relation func outlined arsenic:

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

once Python encounters it, the archetypal happening it volition bash is compile it successful command to make a codification entity for this relation. piece this compilation measure is performed, Python evaluates* and past shops the default arguments (an bare database [] present) successful the relation entity itself. arsenic the apical reply talked about: the database a tin present beryllium thought of a associate of the relation func.

truthful, fto's bash any introspection, a earlier and last to analyze however the database will get expanded wrong the relation entity. one'm utilizing Python three.x for this, for Python 2 the aforesaid applies (usage __defaults__ oregon func_defaults successful Python 2; sure, 2 names for the aforesaid happening).

relation earlier Execution:

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

last Python executes this explanation it volition return immoderate default parameters specified (a = [] present) and cram them successful the __defaults__ property for the relation entity (applicable conception: Callables):

>>> func.__defaults__
([],)

O.ok, truthful an bare database arsenic the azygous introduction successful __defaults__, conscionable arsenic anticipated.

relation last Execution:

fto's present execute this relation:

>>> func()

present, fto's seat these __defaults__ once more:

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

Astonished? The worth wrong the entity modifications! Consecutive calls to the relation volition present merely append to that embedded database entity:

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

truthful, location you person it, the ground wherefore this 'flaw' occurs, is due to the fact that default arguments are portion of the relation entity. location's thing bizarre going connected present, it's each conscionable a spot amazing.

The communal resolution to fight this is to usage no arsenic the default and past initialize successful the relation assemblage:

def func(a = no):
    # oregon: a = [] if a is no other a
    if a is no:
        a = []

Since the relation assemblage is executed anew all clip, you ever acquire a caller fresh bare database if nary statement was handed for a.

To additional confirm that the database successful __defaults__ is the aforesaid arsenic that utilized successful the relation func you tin conscionable alteration your relation to instrument the id of the database a utilized wrong the relation assemblage. past, comparison it to the database successful __defaults__ (assumption [zero] successful __defaults__) and you'll seat however these are so refering to the aforesaid database case:

>>> def func(a = []): 
...     a.append(5)
...     instrument id(a)
>>>
>>> id(func.__defaults__[zero]) == func()
actual

each with the powerfulness of introspection!

^* To confirm that Python evaluates the default arguments throughout compilation of the relation, attempt executing the pursuing:

def barroom(a=enter('Did you conscionable seat maine with out calling the relation?')): 
    walk  # usage raw_input successful Py2

arsenic you'll announcement, enter() is known as earlier the procedure of gathering the relation and binding it to the sanction barroom is made.

one utilized to deliberation that creating the objects astatine runtime would beryllium the amended attack. one'm little definite present, since you bash suffer any utile options, although it whitethorn beryllium worthy it careless merely to forestall beginner disorder. The disadvantages of doing truthful are:

1. show

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

If telephone-clip valuation is utilized, past the costly relation is known as all clip your relation is utilized with out an statement. You'd both wage an costly terms connected all telephone, oregon demand to manually cache the worth externally, polluting your namespace and including verbosity.

2. Forcing sure parameters

A utile device is to hindrance parameters of a lambda to the actual binding of a adaptable once the lambda is created. For illustration:

funcs = [ lambda one=one: one for one successful scope(10)]

This returns a database of capabilities that instrument zero,1,2,three... respectively. If the behaviour is modified, they volition alternatively hindrance one to the telephone-clip worth of one, truthful you would acquire a database of capabilities that each returned 9.

The lone manner to instrumentality this other would beryllium to make a additional closure with the one sure, i.e.:

def make_func(one): instrument lambda: one
funcs = [make_func(one) for one successful scope(10)]

three. Introspection

see the codification:

def foo(a='trial', b=one hundred, c=[]):
   mark a,b,c

We tin acquire accusation astir the arguments and defaults utilizing the examine module, which

>>> examine.getargspec(foo)
(['a', 'b', 'c'], no, no, ('trial', one hundred, []))

This accusation is precise utile for issues similar papers procreation, metaprogramming, decorators and so forth.

present, say the behaviour of defaults may beryllium modified truthful that this is the equal of:

_undefined = entity()  # sentinel worth

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

nevertheless, we've mislaid the quality to introspect, and seat what the default arguments are. due to the fact that the objects haven't been constructed, we tin't always acquire clasp of them with out really calling the relation. The champion we might bash is to shop disconnected the origin codification and instrument that arsenic a drawstring.

5 factors successful defence of Python

Simplicity: The behaviour is elemental successful the pursuing awareness: about group autumn into this lure lone erstwhile, not respective instances.
Consistency: Python ever passes objects, not names. The default parameter is, evidently, portion of the relation heading (not the relation assemblage). It so ought to beryllium evaluated astatine module burden clip (and lone astatine module burden clip, except nested), not astatine relation telephone clip.
Usefulness: arsenic Frederik Lundh factors retired successful his mentation of "Default Parameter Values successful Python", the actual behaviour tin beryllium rather utile for precocious programming. (usage sparingly.)
adequate documentation: successful the about basal Python documentation, the tutorial, the content is loudly introduced arsenic an "crucial informing" successful the archetypal subsection of conception "much connected Defining features". The informing equal makes use of boldface, which is seldom utilized extracurricular of headings. RTFM: publication the good handbook.
Meta-studying: Falling into the lure is really a precise adjuvant minute (astatine slightest if you are a reflective learner), due to the fact that you volition subsequently amended realize the component "Consistency" supra and that volition thatch you a large woody astir Python.

This behaviour is casual defined by:

relation (people and so forth.) declaration is executed lone erstwhile, creating each default worth objects
all the things is handed by mention

truthful:

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

a doesn't alteration - all duty telephone creates fresh int entity - fresh entity is printed
b doesn't alteration - fresh array is physique from default worth and printed
c adjustments - cognition is carried out connected aforesaid entity - and it is printed

1) The truthful-referred to as job of "Mutable Default statement" is successful broad a particular illustration demonstrating that:
"each features with this job endure besides from akin broadside consequence job connected the existent parameter,"
That is in opposition to the guidelines of purposeful programming, normally undesiderable and ought to beryllium mounted some unneurotic.

illustration:

def foo(a=[]):                 # the aforesaid problematic relation
    a.append(5)
    instrument a

>>> somevar = [1, 2]           # an illustration with out a default parameter
>>> foo(somevar)
[1, 2, 5]
>>> somevar
[1, 2, 5]                      # normally anticipated [1, 2]

resolution: a transcript
An perfectly harmless resolution is to transcript oregon deepcopy the enter entity archetypal and past to bash any with the transcript.

def foo(a=[]):
    a = a[:]     # a transcript
    a.append(5)
    instrument a     # oregon all the things harmless by 1 formation: "instrument a + [5]"

galore builtin mutable sorts person a transcript technique similar some_dict.transcript() oregon some_set.transcript() oregon tin beryllium copied casual similar somelist[:] oregon database(some_list). all entity tin beryllium besides copied by transcript.transcript(any_object) oregon much thorough by transcript.deepcopy() (the second utile if the mutable entity is composed from mutable objects). any objects are basically primarily based connected broadside results similar "record" entity and tin not beryllium meaningfully reproduced by transcript. copying

illustration job for a akin truthful motion

people trial(entity):            # the first problematic people
  def __init__(same, var1=[]):
    same._var1 = var1

somevar = [1, 2]               # an illustration with out a default parameter
t1 = trial(somevar)
t2 = trial(somevar)
t1._var1.append([1])
mark somevar                  # [1, 2, [1]] however normally anticipated [1, 2]
mark t2._var1                 # [1, 2, [1]] however normally anticipated [1, 2]

It shouldn't beryllium neither saved successful immoderate national property of an case returned by this relation. (Assuming that backstage attributes of case ought to not beryllium modified from extracurricular of this people oregon subclasses by normal. one.e. _var1 is a backstage property )

decision:
enter parameters objects shouldn't beryllium modified successful spot (mutated) nor they ought to not beryllium binded into an entity returned by the relation. (If we prefere programming with out broadside results which is powerfully really helpful. seat Wiki astir "broadside consequence" (The archetypal 2 paragraphs are relevent successful this discourse.) .)

2)
lone if the broadside consequence connected the existent parameter is required however undesirable connected the default parameter past the utile resolution is def ...(var1=no): if var1 is no: var1 = [] much..

three) successful any circumstances is the mutable behaviour of default parameters utile.

What you're asking is wherefore this:

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

isn't internally equal to this:

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

but for the lawsuit of explicitly calling func(no, no), which we'll disregard.

successful another phrases, alternatively of evaluating default parameters, wherefore not shop all of them, and measure them once the relation is known as?

1 reply is most likely correct location--it would efficaciously bend all relation with default parameters into a closure. equal if it's each hidden distant successful the interpreter and not a afloat-blown closure, the information's obtained to beryllium saved location. It'd beryllium slower and usage much representation.

This really has thing to bash with default values, another than that it frequently comes ahead arsenic an surprising behaviour once you compose capabilities with mutable default values.

>>> def foo(a):
    a.append(5)
    mark 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]

nary default values successful display successful this codification, however you acquire precisely the aforesaid job.

The job is that foo is modifying a mutable adaptable handed successful from the caller, once the caller doesn't anticipate this. codification similar this would beryllium good if the relation was referred to as thing similar append_5; past the caller would beryllium calling the relation successful command to modify the worth they walk successful, and the behaviour would beryllium anticipated. however specified a relation would beryllium precise improbable to return a default statement, and most likely wouldn't instrument the database (since the caller already has a mention to that database; the 1 it conscionable handed successful).

Your first foo, with a default statement, shouldn't beryllium modifying a whether or not it was explicitly handed successful oregon acquired the default worth. Your codification ought to permission mutable arguments unsocial except it is broad from the discourse/sanction/documentation that the arguments are expected to beryllium modified. utilizing mutable values handed successful arsenic arguments arsenic section temporaries is an highly atrocious thought, whether or not we're successful Python oregon not and whether or not location are default arguments active oregon not.

If you demand to destructively manipulate a section impermanent successful the class of computing thing, and you demand to commencement your manipulation from an statement worth, you demand to brand a transcript.

Python: The Mutable Default statement

Default arguments acquire evaluated astatine the clip the relation is compiled into a relation entity, astatine the commencement of the programme runtime. once utilized by the relation, aggregate instances by that relation, they are and stay the aforesaid entity successful representation, and once mutated (if the entity is of a mutable kind) they stay mutated connected consecutive calls.

They are mutated and act mutated due to the fact that they are the aforesaid entity all clip the relation is referred to as.

equal codification:

Since the database is certain to the relation once the relation entity is compiled and instantiated, this:

def foo(mutable_default_argument=[]): # brand a database the default statement
    """relation that makes use of a database"""

is about precisely equal to this:

_a_list = [] # make a database successful the globals

def foo(mutable_default_argument=_a_list): # brand it the default statement
    """relation that makes use of a database"""

del _a_list # distance globals sanction binding

objection

present's a objection - you tin confirm that they are the aforesaid entity all clip they are referenced by

seeing that the database is created earlier the relation has completed compiling to a relation entity,
observing that the id is the aforesaid all clip the database is referenced,
observing that the database stays modified once the relation that makes use of it is referred to as a 2nd clip,
observing the command successful which the output is printed from the origin (which one conveniently numbered for you):

illustration.py

mark('1. planetary range being evaluated')

def create_list():
    '''noisily make a database for utilization arsenic a kwarg'''
    l = []
    mark('three. database being created and returned, id: ' + str(id(l)))
    instrument l

mark('2. example_function astir to beryllium compiled to an entity')

def example_function(default_kwarg1=create_list()):
    mark('appending "a" successful default default_kwarg1')
    default_kwarg1.append("a")
    mark('database with id: ' + str(id(default_kwarg1)) + 
          ' - is present: ' + repr(default_kwarg1))

mark('four. example_function compiled: ' + repr(example_function))


if __name__ == '__main__':
    mark('5. calling example_function doubly!:')
    example_function()
    example_function()

and moving it with python illustration.py:

1. planetary range being evaluated
2. example_function astir to beryllium compiled to an entity
three. database being created and returned, id: 140502758808032
four. example_function compiled: 
5. calling example_function doubly!:
appending "a" successful default default_kwarg1
database with id: 140502758808032 - is present: ['a']
appending "a" successful default default_kwarg1
database with id: 140502758808032 - is present: ['a', 'a']

Does this break the rule of "slightest Astonishment"?

This command of execution is often complicated to fresh customers of Python. If you realize the Python execution exemplary, past it turns into rather anticipated.

The accustomed education to fresh Python customers:

however this is wherefore the accustomed education to fresh customers is to make their default arguments similar this alternatively:

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

This makes use of the no singleton arsenic a sentinel entity to archer the relation whether or not oregon not we've gotten an statement another than the default. If we acquire nary statement, past we really privation to usage a fresh bare database, [], arsenic the default.

arsenic the tutorial conception connected power travel says:

If you don’t privation the default to beryllium shared betwixt consequent calls, you tin compose the relation similar this alternatively:
def f(a, L=no):
    if L is no:
        L = []
    L.append(a)
    instrument L

Already engaged subject, however from what one publication present, the pursuing helped maine realizing however it's running internally:

def barroom(a=[]):
     mark id(a)
     a = a + [1]
     mark id(a)
     instrument a

>>> barroom()
4484370232
4484524224
[1]
>>> barroom()
4484370232
4484524152
[1]
>>> barroom()
4484370232 # ne\'er alteration, this is 'people place' of the relation
4484523720 # ever a fresh entity 
[1]
>>> id(barroom.func_defaults[zero])
4484370232

The shortest reply would most likely beryllium "explanation is execution", so the entire statement makes nary strict awareness. arsenic a much contrived illustration, you whitethorn mention this:

def a(): instrument []

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

Hopefully it's adequate to entertainment that not executing the default statement expressions astatine the execution clip of the def message isn't casual oregon doesn't brand awareness, oregon some.

one hold it's a gotcha once you attempt to usage default constructors, although.

It's a show optimization. arsenic a consequence of this performance, which of these 2 relation calls bash you deliberation is sooner?

def print_tuple(some_tuple=(1,2,three)):
    mark some_tuple

print_tuple()        #1
print_tuple((1,2,three)) #2

one'll springiness you a trace. present's the disassembly (seat http://docs.python.org/room/dis.html):

`#`1

zero LOAD_GLOBAL              zero (print_tuple)
three CALL_FUNCTION            zero
6 POP_TOP
7 LOAD_CONST               zero (no)
10 RETURN_VALUE

`#`2

 zero LOAD_GLOBAL              zero (print_tuple)
 three LOAD_CONST               four ((1, 2, three))
 6 CALL_FUNCTION            1
 9 POP_TOP
10 LOAD_CONST               zero (no)
thirteen RETURN_VALUE

one uncertainty the skilled behaviour has a applicable usage (who truly utilized static variables successful C, with out breeding bugs ?)

arsenic you tin seat, location is a show payment once utilizing immutable default arguments. This tin brand a quality if it's a often referred to as relation oregon the default statement takes a agelong clip to concept. besides, carnivore successful head that Python isn't C. successful C you person constants that are beautiful overmuch escaped. successful Python you don't person this payment.

This behaviour is not amazing if you return the pursuing into information:

The behaviour of publication-lone people attributes upon duty makes an attempt, and that
features are objects (defined fine successful the accepted reply).

The function of (2) has been lined extensively successful this thread. (1) is apt the astonishment inflicting cause, arsenic this behaviour is not "intuitive" once coming from another languages.

(1) is described successful the Python tutorial connected lessons. successful an effort to delegate a worth to a publication-lone people property:

...each variables recovered extracurricular of the innermost range are publication-lone (an effort to compose to specified a adaptable volition merely make a fresh section adaptable successful the innermost range, leaving the identically named outer adaptable unchanged).

expression backmost to the first illustration and see the supra factors:

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

present foo is an entity and a is an property of foo (disposable astatine foo.func_defs[zero]). Since a is a database, a is mutable and is frankincense a publication-compose property of foo. It is initialized to the bare database arsenic specified by the signature once the relation is instantiated, and is disposable for speechmaking and penning arsenic agelong arsenic the relation entity exists.

Calling foo with out overriding a default makes use of that default's worth from foo.func_defs. successful this lawsuit, foo.func_defs[zero] is utilized for a inside relation entity's codification range. adjustments to a alteration foo.func_defs[zero], which is portion of the foo entity and persists betwixt execution of the codification successful foo.

present, comparison this to the illustration from the documentation connected emulating the default statement behaviour of another languages, specified that the relation signature defaults are utilized all clip the relation is executed:

def foo(a, L=no):
    if L is no:
        L = []
    L.append(a)
    instrument L

Taking (1) and (2) into relationship, 1 tin seat wherefore this accomplishes the desired behaviour:

once the foo relation entity is instantiated, foo.func_defs[zero] is fit to no, an immutable entity.
once the relation is executed with defaults (with nary parameter specified for L successful the relation telephone), foo.func_defs[zero] (no) is disposable successful the section range arsenic L.
Upon L = [], the duty can't win astatine foo.func_defs[zero], due to the fact that that property is publication-lone.
Per (1), a fresh section adaptable besides named L is created successful the section range and utilized for the the rest of the relation telephone. foo.func_defs[zero] frankincense stays unchanged for early invocations of foo.

It whitethorn beryllium actual that:

person is utilizing all communication/room characteristic, and
Switching the behaviour present would beryllium sick-suggested, however

it is wholly accordant to clasp to some of the options supra and inactive brand different component:

It is a complicated characteristic and it is unlucky successful Python.

The another solutions, oregon astatine slightest any of them both brand factors 1 and 2 however not three, oregon brand component three and downplay factors 1 and 2. however each 3 are actual.

It whitethorn beryllium actual that switching horses successful midstream present would beryllium asking for important breakage, and that location may beryllium much issues created by altering Python to intuitively grip Stefano's beginning snippet. And it whitethorn beryllium actual that person who knew Python internals fine may explicate a minefield of penalties. nevertheless,

The current behaviour is not Pythonic, and Python is palmy due to the fact that precise small astir the communication violates the rule of slightest astonishment anyplace close this severely. It is a existent job, whether or not oregon not it would beryllium omniscient to uproot it. It is a plan flaw. If you realize the communication overmuch amended by attempting to hint retired the behaviour, one tin opportunity that C++ does each of this and much; you larn a batch by navigating, for case, delicate pointer errors. however this is not Pythonic: group who attention astir Python adequate to persevere successful the expression of this behaviour are group who are drawn to the communication due to the fact that Python has cold less surprises than another communication. Dabblers and the funny go Pythonistas once they are astonished astatine however small clip it takes to acquire thing running--not due to the fact that of a plan fl--one average, hidden logic puzzle--that cuts towards the intuitions of programmers who are drawn to Python due to the fact that it conscionable plant.

A elemental workaround utilizing no

>>> def barroom(b, information=no):
...     information = information oregon []
...     information.append(b)
...     instrument information
... 
>>> barroom(three)
[three]
>>> barroom(three)
[three]
>>> barroom(three)
[three]
>>> barroom(three, [34])
[34, three]
>>> barroom(three, [34])
[34, three]

one americium going to show an alternate construction to walk a default database worth to a relation (it plant as fine with dictionaries).

arsenic others person extensively commented, the database parameter is sure to the relation once it is outlined arsenic opposed to once it is executed. due to the fact that lists and dictionaries are mutable, immoderate alteration to this parameter volition impact another calls to this relation. arsenic a consequence, consequent calls to the relation volition have this shared database which whitethorn person been altered by immoderate another calls to the relation. Worse but, 2 parameters are utilizing this relation's shared parameter astatine the aforesaid clip oblivious to the modifications made by the another.

incorrect technique (most likely...):

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

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

b = foo()
b.append(7)
# The worth of 6 appended to adaptable 'a' is present portion of the database held by 'b'.
>>> b
[5, 6, 7]  

# though 'a' is anticipating to have 6 (the past component it appended to the database),
# it really receives the past component appended to the shared database.
# It frankincense receives the worth 7 antecedently appended by 'b'.
>>> a.popular()             
7

You tin confirm that they are 1 and the aforesaid entity by utilizing id:

>>> id(a)
5347866528

>>> id(b)
5347866528

Per Brett Slatkin's "effectual Python: fifty nine circumstantial methods to compose amended Python", point 20: usage no and Docstrings to specify dynamic default arguments (p. forty eight)

The normal for attaining the desired consequence successful Python is to supply a default worth of no and to papers the existent behaviour successful the docstring.

This implementation ensures that all telephone to the relation both receives the default database oregon other the database handed to the relation.

most popular methodology:

def foo(list_arg=no):
   """
   :param list_arg:  A database of enter values. 
                     If no supplied, utilized a database with a default worth of 5.
   """
   if not list_arg:
       list_arg = [5]
   instrument list_arg

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

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

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

location whitethorn beryllium morganatic usage instances for the 'incorrect technique' whereby the programmer meant the default database parameter to beryllium shared, however this is much apt the objection than the regulation.

The options present are:

usage no arsenic your default worth (oregon a nonce entity), and control connected that to make your values astatine runtime; oregon
usage a lambda arsenic your default parameter, and telephone it inside a attempt artifact to acquire the default worth (this is the kind of happening that lambda abstraction is for).

The 2nd action is good due to the fact that customers of the relation tin walk successful a callable, which whitethorn beryllium already current (specified arsenic a kind)

You tin acquire circular this by changing the entity (and so the necktie with the range):

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

disfigured, however it plant.

once we bash this:

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

... we delegate the statement a to an unnamed database, if the caller does not walk the worth of a.

To brand issues easier for this treatment, fto's quickly springiness the unnamed database a sanction. however astir pavlo ?

def foo(a=pavlo):
   ...

astatine immoderate clip, if the caller doesn't archer america what a is, we reuse pavlo.

If pavlo is mutable (modifiable), and foo ends ahead modifying it, an consequence we announcement the adjacent clip foo is referred to as with out specifying a.

truthful this is what you seat (retrieve, pavlo is initialized to []):

 >>> foo()
 [5]

present, pavlo is [5].

Calling foo() once more modifies pavlo once more:

>>> foo()
[5, 5]

Specifying a once calling foo() ensures pavlo is not touched.

>>> ivan = [1, 2, three, four]
>>> foo(a=ivan)
[1, 2, three, four, 5]
>>> ivan
[1, 2, three, four, 5]

truthful, pavlo is inactive [5, 5].

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

one generally exploit this behaviour arsenic an alternate to the pursuing form:

singleton = no

def use_singleton():
    planetary singleton

    if singleton is no:
        singleton = _make_singleton()

    instrument singleton.use_me()

If singleton is lone utilized by use_singleton, one similar the pursuing form arsenic a substitute:

# _make_singleton() is known as lone erstwhile once the def is executed
def use_singleton(singleton=_make_singleton()):
    instrument singleton.use_me()

one've utilized this for instantiating case lessons that entree outer sources, and besides for creating dicts oregon lists for memoization.

Since one don't deliberation this form is fine recognized, one bash option a abbreviated remark successful to defender towards early misunderstandings.

all another reply explains wherefore this is really a good and desired behaviour, oregon wherefore you shouldn't beryllium needing this anyhow. excavation is for these cussed ones who privation to workout their correct to crook the communication to their volition, not the another manner about.

We volition "hole" this behaviour with a decorator that volition transcript the default worth alternatively of reusing the aforesaid case for all positional statement near astatine its default worth.

import examine
from transcript import deepcopy  # transcript would neglect connected heavy arguments similar nested dicts

def sanify(relation):
    def wrapper(*a, **kw):
        # shop the default values
        defaults = examine.getargspec(relation).defaults # for python2
        # concept a fresh statement database
        new_args = []
        for one, arg successful enumerate(defaults):
            # let passing positional arguments
            if one successful scope(len(a)):
                new_args.append(a[one])
            other:
                # transcript the worth
                new_args.append(deepcopy(arg))
        instrument relation(*new_args, **kw)
    instrument wrapper

present fto's redefine our relation utilizing this decorator:

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

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

This is peculiarly neat for features that return aggregate arguments. comparison:

# the 'accurate' attack
def barroom(a=no, b=no, c=no):
    if a is no:
        a = []
    if b is no:
        b = []
    if c is no:
        c = []
    # eventually bash the existent activity

with

# the nasty decorator hack
@sanify
def barroom(a=[], b=[], c=[]):
    # wow, plant correct retired of the container!

It's crucial to line that the supra resolution breaks if you attempt to usage key phrase args, similar truthful:

foo(a=[four])

The decorator might beryllium adjusted to let for that, however we permission this arsenic an workout for the scholar ;)

sure, this is a plan flaw successful Python

one've publication each the another solutions and one'm not satisfied. This plan does break the rule of slightest astonishment.

The defaults may person been designed to beryllium evaluated once the relation is known as, instead than once the relation is outlined. This is however Javascript does it:

relation foo(a=[]) 
  a.propulsion(5);
  instrument a;

console.log(foo()); // [5]
console.log(foo()); // [5]
console.log(foo()); // [5]

arsenic additional grounds that this is a plan flaw, Python center builders are presently discussing introducing fresh syntax to hole this job. seat this article: advanced-sure statement defaults for Python.

For equal much grounds that this a plan flaw, if you Google "Python gotchas", this plan is talked about arsenic a gotcha, normally the archetypal gotcha successful the database, successful the archetypal 9 Google outcomes (1, 2, three, four, 5, 6, 7, eight, 9). successful opposition, if you Google "Javascript gotchas", the behaviour of default arguments successful Javascript is not talked about arsenic a gotcha equal erstwhile.

Gotchas, by explanation, break the rule of slightest astonishment. They astonish. fixed location are superiour designs for the behaviour of default statement values, the inescapable decision is that Python's behaviour present represents a plan flaw.

one opportunity this arsenic person who loves Python. We tin beryllium followers of Python, and inactive acknowledge that everybody who is unpleasantly amazed by this facet of Python is unpleasantly amazed due to the fact that it is a real "gotcha".

This "bug" gave maine a batch of additional time activity hours! however one'm opening to seat a possible usage of it (however one would person appreciated it to beryllium astatine the execution clip, inactive)

one'm gonna springiness you what one seat arsenic a utile illustration.

def illustration(errors=[]):
    # statements
    # thing went incorrect
    error = actual
    if error:
        tryToFixIt(errors)
        # Didn't activity.. fto's attempt once more
        tryToFixItAnotherway(errors)
        # This clip it labored
    instrument errors

def tryToFixIt(err):
    err.append('effort to hole it')

def tryToFixItAnotherway(err):
    err.append('effort to hole it by different manner')

def chief():
    for point successful scope(2):
        errors = illustration()
    mark '\n'.articulation(errors)

chief()

prints the pursuing

effort to hole it
effort to hole it by different manner
effort to hole it
effort to hole it by different manner

This is not a plan flaw. anybody who journeys complete this is doing thing incorrect.

location are three circumstances one seat wherever you mightiness tally into this job:

You mean to modify the statement arsenic a broadside consequence of the relation. successful this lawsuit it ne\'er makes awareness to person a default statement. The lone objection is once you're abusing the statement database to person relation attributes, e.g. cache=, and you wouldn't beryllium anticipated to telephone the relation with an existent statement astatine each.
You mean to permission the statement unmodified, however you by accident did modify it. That's a bug, hole it.
You mean to modify the statement for usage wrong the relation, however didn't anticipate the modification to beryllium viewable extracurricular of the relation. successful that lawsuit you demand to brand a transcript of the statement, whether or not it was the default oregon not! Python is not a telephone-by-worth communication truthful it doesn't brand the transcript for you, you demand to beryllium express astir it.

The illustration successful the motion might autumn into class 1 oregon three. It's unusual that it some modifies the handed database and returns it; you ought to choice 1 oregon the another.

conscionable alteration the relation to beryllium:

def notastonishinganymore(a = []): 
    '''The sanction is conscionable a gag :)'''
    a = a[:]
    a.append(5)
    instrument a

TLDR: specify-clip defaults are accordant and strictly much expressive.

Defining a relation impacts 2 scopes: the defining range containing the relation, and the execution range contained by the relation. piece it is beautiful broad however blocks representation to scopes, the motion is wherever def (): belongs to:

...                           # defining range
def sanction(parameter=default):  # ???
    ...                       # execution range

The def sanction portion essential measure successful the defining range - we privation sanction to beryllium disposable location, last each. Evaluating the relation lone wrong itself would brand it inaccessible.

Since parameter is a changeless sanction, we tin "measure" it astatine the aforesaid clip arsenic def sanction. This besides has the vantage it produces the relation with a identified signature arsenic sanction(parameter=...):, alternatively of a naked sanction(...):.

present, once to measure default?

Consistency already says "astatine explanation": the whole lot other of def (): is champion evaluated astatine explanation arsenic fine. Delaying components of it would beryllium the astonishing prime.

The 2 selections are not equal, both: If default is evaluated astatine explanation clip, it tin inactive impact execution clip. If default is evaluated astatine execution clip, it can't impact explanation clip. selecting "astatine explanation" permits expressing some circumstances, piece selecting "astatine execution" tin explicit lone 1:

def sanction(parameter=outlined):  # fit default astatine explanation clip
    ...

def sanction(parameter=default):     # hold default till execution clip
    parameter = default if parameter is no other parameter
    ...

"Least Astonishment" and the Mutable Default Argument