C++中的指针和引用 ，可以参考博客
https://www.cnblogs.com/heyonggang/archive/2012/12/13/2815730.html
问题导入？
如果你使?Python声明了?个变量并同时为其赋值，即a = 20，你是否将这条语句简单理解为：1. 计算机开辟了?块地址别名为a的内存；2. 往这块内存存储了数据20？
如果你对上述问题的回答为是，那么你对诸如“Python是?门动态类型语?”、“Python效率远不如C语?等静态语言效率高”等说法也?定不了解其本质。问题解答：
变量由三部分组成：
标识，表示对象所储存的内存地址，使用内置函数id()获取
类型，表示对象的数据类型，使用内置函数type获取
值，表示对象所储存的具体数据，使用print打印输出。
在Python中：
1.变量和对象是分开储存的，
2.和其他编程语言一样的是，变量是对象内存地址的别名，即a代表了地址0x1002；
3.和其他编程语?不?样的是，Python中的变量和数据（对象）分开存储：变量a的地址0x1001处仅保存了数据20存储的内存地址0x1002。
4.变量a所标示的内存空间存储数据20所在内存地址的过程称为引?。5.变量是对象的一个引用，对对象的操作都是通过引用来完成的
6.赋值操作 = 就是给对象添加一个引用
python中一切的传递都是引用（地址），无论是赋值还是函数调用，即python中所有的变量赋值、参数传递等都是引?传递。
python中数值类型（int和float），布尔型bool，字符串，元组都是不可变对象,列表list，字典dict，集合set都是可变对象，自定义的类对象也是可变对象?。对于不可变对象，我们?法在内存中直接修改这个变量（如 100，"student"），如果我们尝试对不可变类型进?修改，就会断开原始的引?，重新分配内存地址；修改可变对象的值不会断开原始引?，是直接在原始值上进?修改，因此这些和原始值有引?关系的变量的“值”都被修改了。
函数调?时，传递给函数的参数中保存的仍然是变量的引?（真实值的地址），函数参数是?个局部变量，初始时，参数和函数外部的值指向同?个内存地址。
- 如果参数是不可变对象，则断开原始引?，重新进?新的引?，函数外部的值不受影响
- 如果参数是可变对象，直接修改原始值，函数外部的值同步变化
- 解释器对常?的不可变类型进?了优化，把常?的数值、短字符串赋值给某些变量时，这些变量都指向相同的内存地址
?
?示例一：
a='123'执行上面这个赋值语句的时候，Python解释器首先在内存中创建一个字符串"123"对象。之后在内存中创建一个名为"a"的变量，将"a"指向"123"（将"123"的地址保存到“a”中）
?接着执行
b=a#指向同一个对象因为a已经存在，所以不会创建a，会创建变量"b"，并将"b"指向"a"指向的字符串"123"
然后执行
a = "456"#不可变对象，对其进行修改时会断开原来的引用a还是存在的，Python会新分配一块内存来存储新的值，会创建字符串"456", 然后将"456"的地址赋给"a"
?对于不可变对象，我们?法在内存中直接修改这个变量（如 100，"student"），如果我们尝试对不可变类型进?修改，就会断开原始的引?，重新分配内存地址.那么下面的代码就不难理解
a=100 print(id(a))#1888557553104 a=a+1 print(id(a))#1888557553136对于可变对象，修改可变对象的值不会断开原始引?
lst=[1,2,3] print(id(lst)) lst.append(4)#2167621434240 print(id(lst))#2167621434240给出一段代码检验是否理解
a=100 b=a a=a+1 print(a,b) print(id(a),id(b)) lst1=[1,2,3] lst2=lst1 lst1.remove(2) print(lst1,lst2) print(id(lst1),id(lst2)) ''' 运行结果 101 100 2413522146800 2413522146768 [1, 3] [1, 3] 2413527186432 2413527186432 '''解释器对常?的不可变类型进?了优化，把常?的数值、短字符串赋值给某些变量时，这些变量都指向相同的内存地址，即python中的驻留机制。
a=100 b=100 c=100 print(id(a),id(b),id(c)) lst1=[1,2] lst2=[1,2] lst3=[1,2] print(id(lst1),id(lst2),id(lst3)) ''' 运行结果 1872572732880 1872572732880 1872572732880 1872577903488 1872577900416 1872579060160 '''
函数参数
参数的传递本质上是一种赋值操作，函数的参数也是一种引用传递。
def foo(arg): arg = 2 print(arg) a = 1 foo(a) # 输出：2 print(a) # 输出：1
?
变量 a 指向?1，调用函数 foo(a) 时，arg=a,，这时两个变量都指向 1。在函数里面 arg 重新赋值为 2 之后，不可变对象不可修改时原先引用会断开，而 a的引用没变。因此 print(a) 还是 1。
再来看下一段代码def bar(args): args.append(1) b = [] print(b)# 输出：[] print(id(b)) # 输出：4324106952 bar(b) print(b) ＃ 输出：[1] print(id(b)) # 输出：4324106952
执行 append 方法前 b 和 arg 都指向同一个对象，执行 append 方法时，并没有重新赋值操作，也就没有新的引用过程，append 方法只是对列表对象插入一个元素，对象还是那个对象，只是对象里面的内容变了。因为 b 和 arg 都是绑定在同一个对象上，执行 b.append 或者 arg.append 方法本质上都是对同一个对象进行操作，因此 b 的内容在调用函数后发生了变化（但id没有变，还是原来那个对象）。
?python中+=在可变对象运算中的特殊用法
num = 100 def update(a): a+=10 print(a) #打印110 update(num) print(num) #打印100 num1 = 100 def update1(a): a=a+10 print(a) #打印110 update(num1) print(num1) #打印100 ''' python中所有的变量都是引用类型 num和update(a)，实参num和形参a都指向同一片内存地址 a += 10 这里对a做出修改的操作 因为a是数值类型，属于不可变类型，不能修改 所以,python会创建一个临时变量a，用来存储110 所以print(num) 打印的仍然是100 '''list = [2] def test1(num): num += num print(num) #打印[2,2] test1(list) print(list) #打印[2,2] #从结果而言，修改了可变类型的值 list2 = [3] def test2(num): num = num + num #num+num 的结果是[3,3] 这里表示将[3,3]这个列表赋值给num这个临时变量 print(num) #打印[3,3] test2(list2) print(list2)#打印[3] ''' 在python中 +=运算符表示对当前变量进行操作 并不完全等同于 + '''简单的加法中，列表的运算还是创建了一个新的列表对象；但在简写的加法运算+=实现中，则并没有创建新的列表对象。这一点要十分注意。验证一下是否理解
def add_list(p): p = p + [1] p1 = [1,2,3] add_list(p1) print p1 >>> [1, 2, 3] def add_list(p): p += [1] p2 = [1,2,3] proc2(p2) print p2 >>>[1, 2, 3, 1]词典的引用
a = [] b = {'num':0, 'sqrt':0} resurse = [1,2,3] for i in resurse: b['num'] = i b['sqrt'] = i * i a.append(b) print a #输出 [{'num': 3, 'sqrt': 9}, {'num': 3, 'sqrt': 9}, {'num': 3, 'sqrt': 9}]但我们实际想要的结果是这样的：
输出 [{'num': 1, 'sqrt': 1}, {'num': 2, 'sqrt': 4}, {'num': 3, 'sqrt': 9}]
这是由于a中的元素就是b的引用。可以修改为：
a = [] resurse = [1,2,3] for i in resurse: a.append({"num": i, "sqrt": i * i}) print(a) #输出[{'num': 1, 'sqrt': 1}, {'num': 2, 'sqrt': 4}, {'num': 3, 'sqrt': 9}]
呕心沥血之作，。。。。，看了好长时间
