id 和 ==

is 用于判断两个变量引用对象是否为同一个，就是所引用的对象的内存地址是否一致
== 用于判断引用变量的值是否相等。只判断值和数据类型

>>> a = 1
>>> b = 1           变量a 和变量 b 引用同一个对象
>>> id(a)         
20073576
>>> id(b)
20073576           使用id() 查看变量引用的对象的内存地址，a和b一致
>>> type(a)
<type 'int'>
>>> type(b)
<type 'int'>       数据类型也是相同的
>>> a is b          
True
>>> a  == b            所引用的变量相等所以就是True
True
>>> a = '1'           
>>> b = 1             
>>> type(a)
<type 'str'>
>>> type(b)           
<type 'int'>             引用的变量有所不同，一个是字符串类型的，一个是int整数型的
>>> a  is  b
False
>>> a  == b
False          所以两个是不想等的 就是False
>>> a
[1, 2, 3]
>>> b
[1, 2, 3]
>>> type(a)
<type 'list'>
>>> type(b)
<type 'list'>           数据类型相等，都是列表
>>> id(a)
140374326326408
>>> id(b)
140374326413792            所指向的内存地址不同
>>> a is b             导致a is b 返回的是 False
False
>>> a == b         因为两个变量的数值和类型都相同所以返回的就是True
True
copy和deepcopy
copy：浅拷贝
deepcopy：深拷贝
1 当被复制的对象完全是不可变数据类型的时候，两者效果相同，都是引用。新生成的变量引用的对象与之前的变量完全一致：
import copy       
x = 1
y = (2,3,4)
a = (x,y)
b = copy.copy(a)                  b对a的浅拷贝
c = copy.deepcopy(a)         c对a的深拷贝
print(a,type(a),id(a),id(a[1]))         输出a，a的类型及其他的内存地址对比查看情况
print(b,type(b),id(b),id(b[1]))         
print(c,type(c),id(c),id(c[1]))

实验效果

(1, (2, 3, 4)) <class 'tuple'> 140124916856648 140124916753176
(1, (2, 3, 4)) <class 'tuple'> 140124916856648 140124916753176
(1, (2, 3, 4)) <class 'tuple'> 140124916856648 140124916753176
如果拷贝的是一个拥有可变类型的数据，那么deepcopy依然是深拷贝，copy是浅拷贝
2 当被复制的外层父对象是不可变数据类型，里面子对象是可变数据类型的时候：

浅拷贝：完全的引用，新生成的变量完全引用了原来变量所引用的父对象以及子对象
深拷贝：生成新的父对象以及子对象，新的变量引用新生成的父对象和子对象

import copy
x = 1
li = [2,4,6]
a = (x,li)   # 外层父对象不可变，内层子对象可变
b = copy.deepcopy(a)   # 深拷贝
c = copy.copy(a)  # 浅拷贝
print(a,type(a),id(a),id(a[1]))    
print(b,type(b),id(b),id(b[1]))  
print(c,type(c),id(c),id(c[1]))

效果演示

(1, [2, 4, 6]) <class 'tuple'> 140115481012040 140115360539592
(1, [2, 4, 6]) <class 'tuple'> 140115481012488 140115360541064
(1, [2, 4, 6]) <class 'tuple'> 140115481012040 140115360539592

3 当被复制的外层父对象是可变数据类型，里面子对象是不可变数据类型的时候：
不论是深拷贝还是浅拷贝，都生成新的父对象，引用原来的子对象

import copy
x = 1
li = (2,4,6)
a = [x,li]   # 外层父对象是可变数据类型，内层子对象是不可变数据类型
b = copy.deepcopy(a)
c = copy.copy(a)
print(a,type(a),id(a),id(a[1]))
print(b,type(b),id(b),id(b[1]))   # 输出深拷贝的数据信息
print(c,type(c),id(c),id(c[1]))    # 输出浅拷贝的数据信息

效果展示

[1, (2, 4, 6)] <class 'list'> 139881985471432 139882105840336
[1, (2, 4, 6)] <class 'list'> 139881985471624 139882105840336
[1, (2, 4, 6)] <class 'list'> 139881985472904 139882105840336
4 当被复制的外层父对象是可变数据类型，里面子对象是可变数据类型的时候
import copy
x = 1
li = [2,4,6]
a = [x,li]   # 父对象和子对象都是可变的数据类型
b = copy.deepcopy(a)
c = copy.copy(a)
print(a,type(a),id(a),id(a[1]))
print(b,type(b),id(b),id(b[1]))
print(c,type(c),id(c),id(c[1]))

效果展示

[1, [2, 4, 6]] <class 'list'> 139784093750408 139784093750216
[1, [2, 4, 6]] <class 'list'> 139784093751688 139784093751624
# 深拷贝的时候，新生成父对象和子对象，新变量引用新生成的父对象以及子对象
[1, [2, 4, 6]] <class 'list'> 139784093751560 139784093750216
#浅拷贝的时候，生成新的父对象，引用原来的子对象