python黑魔法之参数传递
我们都听说，python世界里面，万物皆对象。
怎么说万物皆对象呢？最常见的：
>classA:pass >a=A()
我们说a是一个对象。
那么既然是万物了，其实A也是对象。3也是对象。True也是对象。"hello"也是对象。
>defFunc():pass
o~yee,Func也是对象。
那么对象之间的传递是如何呢？我们看看下面两个简单的例子：
>a=3 >b=a >b=3+1 >printb 4 >printa 3 >a=[] >b=a >b.append(1) >printa [1] >printb [1]
不是都说python所有对象都是引用传递吗？为毛第一个b不是3？
好吧。事实是，在python的实现上，对象分为mutable和immutable。
这里说的对象分类，是说在实现上具备这样的特性。而非对象本身的属性。
什么是immutable？表示对象本身不可改变。这里先记住一点，是对象本身不可改变。
什么叫做对象本身不可改变呢？
一个简单的例子：
>a=(1,2,3) >a[0]=10
TypeError:'tuple'objectdoesnotsupportitemassignment
元组的元素在初始化后就不能再被改变。也就是说，元组对象具备immutable的特性。
那么很简单，相对的，mutable就是可变的。比如：
>a={}
>a[0]=10
有了上面的两个例子，相信大家已经有了基本的认识。
那么，在python世界中，哪些是具备immutable特性，哪些又是mutable的呢？
简单讲，基本类型都是immutable,而object都是mutable的。
比如说：int,float,bool,tuple都是immutable。
再比如：dict,set,list,classinstance都是mutable的。
那么问题来了。既然说基本类型是immutable，那么最上面的b=3+1为什么不会像tuple一样，抛异常呢？
原因在于，int对+操作会执行自己的__add__方法。而__add__方法会返回一个新的对象。
事实是，当基本类型被改变时，并不是改变其自身，而是创建了一个新的对象。最终返回的是新的对象的引用。
怎么证明？
我们可以使用一个叫做id()的函数。该函数会返回对象的一个唯一id（目前的实现可以间接理解为对象的内存地址）。
那么我们看下：
>a=3 >id(a) 140248135804168 >id(3) 140248135804168 >id(4) 140248135804144 >a=a+1 >id(a) 140248135804144
yousee?当我们执行a=a+1后，id(a)已经改变了。
深究一点，为什么会这样呢？
其实，a=a+1经历了两个过程：
- 1、a+1
- 2、a赋值
第2步只是一个引用的改变。重点在第1步。a+1，那么python实际上会调用a.__add__(1)。
对于int类型__add__函数的实现逻辑，是创建了一个新的int对象，并返回。
不知道细心的你有没有发现一个特别的地方？
id(4)的值等于id(3+1)。这个只是python对int，和bool做的特殊优化。不要以为其他基本类型只要值一样都会指向相同的对象。
有个特殊的例子，str。做个简单的实验：
>a="hello" >id(a) 4365413232 >b="hell" >id(b) 4365386208 >id(a[:-1]) 4365410928 >id(a[:-1]) 4365413760
看到了吗？虽然值相同，但是还是指向（创建）了不同的对象，尤其是最后两句，哪怕执行相同的操作，依然创建了不同的对象。
python这么傻，每次都创建新的对象？
nonono他只是缓存了“一些”结果。我们可以再试试看：
>a="hello"
>ret=set()
>foriinrange(1000):
ret.add(id(a[:-1]))
>printret
{4388133312,4388204640}
看到了吗？python还是挺聪明的。不过具体的缓存机制我没有深究过，期望有同学能分享下。
再次回到我们的主题，python中参数是如何传递的？
答案是，引用传递。
平时使用静态语言的同学（比如我），可能会用下面的例子挑战我了：
deffun(data): data=3 a=100 func(a) printa#100
不是尼玛引用传递吗？为毛在执行func(a)后，a的值没有改变呢？这里犯了一个动态语言基本的错误。
data=3，语义上是动态语言的赋值语句。千万不要和C++之类的语言一个理解。
看看我们传入一个mutable的对象：
>deffunc(m):
m[3]=100
>a={}
>printa
{}
>func(a)
>printa
{3:100}
现在同学们知道该如何进行参数传递了吧？好嘞，进阶！
像很多语言如C++，js，swift...一样，python的函数声明支持默认参数：
deffunc(a=[]):pass
不知道什么意思？自己看书去！
我这里要说的是，如果我们的默认参数是mutable类型的对象，会有什么黑魔法产产生？
我们看看下面的函数：
deffunc(a=[]): a.append(3) returna
可能有同学会说了：我去！这么简单？来骗代码的吧？
但是，真的这么简单吗？我们看下下面的调用结果：
>printfunc() [3] >printfunc() [3,3] >printfunc() [3,3,3]
这真的是你想要的结果吗？
No，我要的是[3]，[3],[3]!
原因？好吧，我们再用下id()神奇看看：
deffunc(a=[]): printid(a) a.append(3) returna >printfunc() 4365426272 [3] >printfunc() 4365426272 [3,3] >printfunc() 4365426272 [3,3,3]
明白没？原来在python中，*默认参数不是每次执行时都创建的！*
这下你再想想，曾经嘲笑过的代码（至少我）为什么要多此一举：
deffunc(a=None): ifaisNone: a=[]
这里在顺带提一下==,is:
==:值比较
is:比较左右两边是否是同一个对象。aisb==>id(a)==id(b)
ok,let'smoveon!
我们都知道，在python中，不定参数我们可以这样定义：
deffunc(*args,**kv):pass
什么你不知道？看书去！
那args和kv到底是什么情况呢？到底是mutable还是immutable呢？
再一次请出id()神器：
deffunc(*args): printid(args) >a=[1,2] >printid(a) 4364874816 >func(*a) 4364698832 >func(*a) 4364701496
看到了吧？实际上args也会产生一个新的对象。但是值是填入的传入参数。那么每一个item也会复制吗？
我们再看看：
deffunc(*args): printid(args[0]) >a=[1,2] >printid(a[0]) 140248135804216 >func(*a) 140248135804216
答案是，No。值会像普通list赋值一样，指向原先list（a)所引用的对象。
那么为什么会这样呢？
python的源码就是这么写的.......
最最后，还记得我说过的一句话吗？
immutable限制的是对象本身不可变
意思就是说，对象的immtable只是限制自身的属性能否被改变，而不会影响到其引用的对象。
看下下面的例子：
>a=[1,2] >b=(a,3) >b[1]=100 TypeError:'tuple'objectdoesnotsupportitemassignment >printb ([1,2],3) >b[0][0]=10 >printb ([10,2],3)
最最最后，我有个对象，它本身应该是mutable的，但是我想让他具备类似immutable的特性，可以吗？
答案是，可以模拟！
还是之前说的，immutable限制的是其自身属性不能改变。
那么，我们的可以通过重定义（重载）属性改变函数，来模拟immutable特性。
python可以吗？O~Yee
在python的类函数中，有这样的两个函数：__setattr__和__delattr__。分别会在对象属性赋值和删除时执行。
那么我们可以进行简单重载来模拟immutable:
classA:
def__setattr__(self,name,val):
raiseTypeError("immutableobjectcouldnotsetattr")
以上就是为大家介绍的python黑魔法，希望对大家的学习有所帮助。