to function argumentsthough the assignment to argument names is automatic and implicit python' pass-by-assignment scheme isn' quite the same as ++' reference parameters optionbut it turns out to be very similar to the argument-passing model of the language (and othersin practiceimmutable arguments are effectively passed "by value objects such as integers and strings are passed by object reference instead of by copyingbut because you can' change immutable objects in place anyhowthe effect is much like making copy mutable arguments are effectively passed "by pointer objects such as lists and dictionaries are also passed by object referencewhich is similar to the way passes arrays as pointers--mutable objects can be changed in place in the functionmuch like arrays of courseif you've never used cpython' argument-passing mode will seem simpler still--it involves just the assignment of objects to namesand it works the same whether the objects are mutable or not arguments and shared references to illustrate argument-passing properties at workconsider the following codedef ( ) is assigned to (referencesthe passed object changes local variable only (bprint( and both reference same initially is not changed in this example the variable is assigned the object at the moment the function is called with ( )but lives only within the called function changing inside the function has no effect on the place where the function is calledit simply resets the local variable to completely different object that' what is meant by lack of name aliasing--assignment to an argument name inside function ( = does not magically change variable like in the scope of the function call argument names may share passed objects initially (they are essentially pointers to those objects)but only temporarilywhen the function is first called as soon as an argument name is reassignedthis relationship ends at leastthat' the case for assignment to argument names themselves when arguments are passed mutable objects like lists and dictionarieswe also need to be aware that inplace changes to such objects may live on after function exitsand hence impact callers here' an example that demonstrates this behavior arguments