python传参和赋值

python的赋值

Assignment statements are used to (re)bind names to values and to modify attributes or items of mutable objects ——官方文档

赋值语句用于(重新)将名称绑定到值，并修改可变对象的属性或项

python中一切皆对象，数字是对象，列表是对象，函数是对象

简单理解，python的变量可以看作一个简简单单的“标签”，除了变量名没有任何意义，直到它被一个有意义的实体(对象)所赋值，赋值的过程其实就是一个变量绑定对象的过程，可以看作是给对象贴了个标签（这个比喻相对严谨）

赋值过程

无论是可变类型（如list）的对象或是不可变类型（如int）的对象, 给变量赋值的过程都意味着绑定或重新绑定

绑定过程不是只有一次，绑定过对象的变量仍可以重新绑定其它对象(包括其它类型的对象)，没有被变量绑定的对象将可能被垃圾回收

赋值int

绑定整数对象池中的一个整形对象

a = 1
b = a
c = 1
d = 2
print("a",id(a))
print("b",id(b))
print("c",id(c))
print("d",id(d))

1是一个对象，在整数对象池中是固定的（即一个特定的内存位置存储着1），如上一三两行实现了ac均绑定了整数对象1，第二行意为将a绑定的对象也绑到b上，如此，abc均绑定了对象1，所以显示相同的地址

小整数对象池和大整数对象池

整数在程序中的使用非常广泛，Python为了优化速度，使用了小整数对象池， 避免为整数频繁申请和销毁内存空间。

Python 对小整数的定义是 [-5, 256] 这些整数对象是提前建立好的，不会被垃圾回收。在一个 Python 的程序中，无论这个整数处于LEGB中的哪个位置，所有位于这个范围内的整数使用的都是同一个对象。同理，单个字母也是这样的。

大整数对象池。说明：终端是每次执行一次，所以每次的大整数都重新创建，而在pycharm中，每次运行是所有代码都加载都内存中，属于一个整体，所以这个时候会有一个大整数对象池，即处于一个代码块的大整数是同一个对象。

——引自：python中小整数对象池和大整数对象池

is是判断是否是同一个对象的操作符，返回值是布尔型；类似于：两个人是一个人等价于两个人的身份证号码相同（如果都有身份证），两个变量绑定了相同的对象 <==> id(变量1) == id(变量2)

赋值list

绑定一个list对象给变量

# 1
a = []
b = []
print("a is b?",a is b)
#2
goo = [1,2,3]
gll = [1,2,3]
gtt = [1,2,3,4]
print(id(goo),id(gll),id(gtt))
#3
c = b
print("c is b?",c is b)
#4
c.append(1)
print("c:",c)
print("b:",b)

#1 和 #2展示了：对于构造一个可变类型的对象并绑定给变量，无论当前是否有和其暂态相同的对象，都会创建新的对象，而不使用旧的对象。因为它是可变类型，有无限的可能（增删改），暂态相同并不代表永远相同，所以是否相同是不确定的事情，而python或是说程序永远不会去做不确定的事儿。这是与不可变对象的区别。

#3 是将b绑定的对象给c绑定上，即bc绑定了同一个对象，那么对c的操作必定会影响对b的操作

#4 是对c进行了操作，进而影响了b, 因为对c的append()追加元素操作，实际上是bc共同绑定的对象的追加变更，很多人称python可变对象的这个特点跟C++的引用一样，其实是不准确和错误的。学python的确可以借鉴C++,但不应照单全收，因为两者的机制有非常大的区别。

高级赋值操作

批量赋值

a,b,c = 1,2,3
print(a)
print(b)
print(c)

拆包与装包

# 装包：按位置将变量赋值后多余的装列表里
a,b,*c,d = 1,2,3,4,5,6
print(a,b,c,d)
# 拆包：打开列表取出值
print(*c)

python传参

python的传参过程与赋值过程类似（更像是实参给形参批量赋值），实质也是对象的绑定

C++有传值，传引用，python的参数传递是？就叫他 传对象 吧！

传不可变对象

def give_me_a_num(a):
    a = a+1
    print("give_me_a_num's a:",a)

def main():
    a = 1
    print("main's origin a:",a)
    give_me_a_num(a)
    print("main's a:",a)
    
main()

a在main里是绑定的整数1，传过去给give_a_num的a, 说你也绑定这个对象吧，于是give_me_a_num里的a的值是1，

接着give_me_a_num里发生了状况，里面的a不喜欢1这个对象了，舍弃，重新绑定了对象a+1,也就是2，

而main里的a一直对1不离不弃，所以这个a一直是1

这样一气呵成，并没什么不妥；但很多人看了这个以后断定：python的参数传递和C++的值传递一样

传可变对象

def give_me_a_girl(girl):
    girl["lover"] = "Mike"
    print("give_me_a_girl's girl:\n\t",girl)

def main():
    girl = {"name":"Mark","age":20,"lover":"Tim"}
    print("main's origin girl:\n\t",girl)
    give_me_a_girl(girl)
    print("main's girl:\n\t",girl)
    print("\nTim:\"Mark,you changed!You don't love me anymore.\"")
main()

这里girl是一个字典，是一个可变对象，main里面的变量girl绑定了这个对象，传给了give_me_a_girl里的girl,它也绑定了这个对象，并且对所绑定的对象做了相应的修改，因为main和give_me_a_gril里的girl绑定的是同一个对象，所以main’s girl也是改变了的，本质是其绑定的对象发生了改变。

这是python传可变对象的实质，如果give_me_a_girl里面的girl重新绑定了新的对象，再做变化，就不会再影响到main’s girl了；但是很多人看了这种实例，就断言：python传参方式和C++里的引用传递一样

默认值参数

def make_cake(cream,butter = 0,fruit = 3):
    print("做了蛋糕")
    print("奶油{}斤,黄油{}两,水果{}块".format(cream,butter,fruit))
make_cake(1,3)
make_cake(1,2,4)
make_cake(4)
make_cake(2,fruit = 8) #python比较高级的地方

make_cake()的使用比较方便，有两个默认参数，传参时第一个实参不可省，确认是给cream的，剩下两个可以按顺序给或不给（默认），使用key=value的方式可以打破顺序

拆包装包实现可变参数的函数

def get(git_id,*args,**kwargs): #git_id要写前面，否则贪婪匹配，不会给它剩
    print("装包后：")
    print("git_id:",git_id)
    print("args:",args)
    print("kwargs:",kwargs)
    print("对传过来的参数拆包：".format())
    print("*args:",*args)
    print("kwargs拆包后传给fun:",end="")
    fun(**kwargs) #相当于fun(a=1,b=2)
    
def fun(b,a): #注意键名和参数名对应
    print(a,b)

get(1,2,3,4,5,6,a=1,b=2) #调用时前面第一个之后装包给元组，剩下给字典

*args作为形参时是用来接收多余的未命名参数，而**kwargs是用来接收key=value这种类型的命名参数，args是元组，kwargs是字典。

拆装包实现对象的拷贝

# 方便的使用方法
def rich(*money):
    print("今天赚了{}元钱".format(sum(money)))
    
rich(2,3,4,5)

def rich(*money):
    print(id(money))
    print("今天赚了{}元钱".format(sum(money)))
    
def main():
    today_come = [1,2,3,4,5,6]
    print(id(today_come))
    rich(*today_come)
    
main()

可以看到rich()‘s money和 main()’s today_come 的id不一样，也就是两者没有绑定一样的对象了，因为拆包后会装到一个新的包里，这样互相就不影响了

想到这里，，，

def give_me_a_girl(**girl):
    girl["lover"] = "Mike"
    print("give_me_a_girl's socalled girl:\n\t",girl)

def main():
    girl = {"name":"Mark","age":20,"lover":"Tim"}
    print("Tim's origin girl:\n\t",girl)
    give_me_a_girl(**girl)
    print("Tim's normal girl:\n\t",girl)
    print("\nTim: \"I love you,Mark!\"")

main()