第三章数据类型

3.1整型（int）

3.1.1 整型的长度

在py2中有：int 、long

在32位机器上，整数的位数为32位，取值范围为-231～231-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-263～263-1，即-9223372036854775808～9223372036854775807
超出长度之后就会变为long类型。

在py3中有：int（int/long）

3.1.2整除

py2：

整型除法只能保留整数位

2.注意：在python2中使用除法时，只能保留整数位，如果想要保留小数位，可以先导入一个模块。

from __future__ import division
v = 9 /2
print (v) #4.5

py3：只有int没有long，所有数字都是int类型。

3.2布尔类型（bool）

布尔值就是用于表示真假的只有True/False

其他类型转换成布尔值：

str ''' ""是false，其他都是true
list []
tuple()
dict{}
NONE
数字转布尔：0是false，其他都是true

对于none、空字符串、空列表、空元组、空集合都是false

3.3字符串（str）

字符串是写代码中最常见的，在python内存中字符串是按Unicode编码存储的，字符串是不可变的

3.3.1字符串自己的方法

1.独有方法

1.1upper/lower 大小写

v = 'alex'
v1 = v.upper()#大写
v2 = v.isupper()#判断字符串是否都是大写
print(v1,v2)

v = 'alex'
v1 = v.lower()#小写
v2 = v.islower()#判断字符串是否都是小写
print(v1,v2)

1.2 strip/rstrip/lstrip+\t+\n+指定字符串（删除空格、空行等）

v1 = "alex "
print(v1.strip())# 输出alex

v2 = "alex\t"
print(v2.strip())输出alex

v3 = "alex\n"
print(v3.strip())输出alex

v1 = "alexa"#去掉指定的字符串
print(v1.strip('al'))输出exa

1.3 replace 替换('被替换的字符/子序列','要替换为的内容')

message = input('请说话：')  #我去你大爷的家里玩
print(message)
data = message.replace('大爷','**',1)
print(data)#我去你**的家里玩

1.4 split 切割('根据什么东西进行分割') ./split('根据什么东西进行分割',1) /.rsplit

message = '小黑现在一脸懵逼，因为昨天晚上一直在学习，直到深夜。'
#result = message.split('，')根据, 从左到右切割
#result = message.split('，',1)根据第一个,切割从右到左切割
print(result)

1.5 编码encode，把字符串转换成二进制

name = '李杰' # 解释器读取到内存后，按照unicode编码存储：8个字节。
v1 = name.encode('utf-8')
 print(v1)
v2 = name.encode('gbk')
 print(v2)

1.6 format

v = '我是{0}，今年{}岁'.format('alex',19)
print(v)#我是alex，今年19岁

1.7 join

name = 'alex' # al_e_x
result = "_".join(name) # 循环每个元素，并在元素和元素之间加入连接符。
print(result)

1.8 endswith\starswith 以什么开头/结果

name = 'alex'
# 判断是否已al开头
"""
#方式一：
flag = name.startswith('al')
print(flag)
"""
"""
# 方式二：
val = name[0:2]
if val == 'al':
    print('是以al开头')
else:
    print('不是')

1.9 isdecimal 判断是否是十进制数字

v = '1'
# v = '二'
# v = '②'
v1 = v.isdigit()  # '1'-> True; '二'-> False; '②' --> True
v2 = v.isdecimal() # '1'-> True; '二'-> False; '②' --> False
v3 = v.isnumeric() # '1'-> True; '二'-> True; '②' --> True
print(v1,v2,v3)
# 以后推荐用 isdecimal 判断是否是 10进制的数。

# ############## 应用 ##############

v = ['alex','eric','tony']

for i in v:
    print(i)

num = input('请输入序号：')
if num.isdecimal():
    num = int(num)
    print(v[num])
else:
    print('你输入的不是数字')
v = '1'
v = '二'
v = ''

2.公共方法

2.1 len 长度计算长度（字符串->计算字符串中的字符个数）

计算长度(len)
value = "alex"
number = len(value)
print(number) #4

2.2 索引取值（0作为开始）

value = 'alexasdfasdfasdfasdfas'
v1 = value[4]
print(v1) #a

value_len = len(value) # 4
index = 0
while True:
    val = value[index]
    print(val)
    if index == value_len-1:
        break

    index += 1

"""
# v = "oldboy"
# v1 = v[0]  # 0 1 2 3 ...
# v2 = v[-3]
# print(v2)

2.3 切片

# v = "oldboy"
# v1 = v[2:4] #   2 =< 索引位置 <3
# v2 = v[3:5]
# v2 = v[3:-1]
# v2 = v[3:]
# v2 = v[:-1]
# print(v2)

# 示例: 取最后两个字符
# data = input('请输入：')
# 方式一
# v = data[-2:]
# print(v)
# 方式二
# total_len = len(data)
# v = data[total_len-2:total_len]
# print(v)

需求：让用户输入任意字符串，获取字符串之后并计算其中有多少个数字。
total = 0
text = input('请输入内容：') # ads2kjf5adja453421sdfsdf
index_len = len(text)
index = 0
while True:
    val = text[index]
    #print(val) # "a"
    # 判断val是否是数字
    #     - 是数字：total + 1
    #     -   不是：继续玩下走，执行下一次循环去检查下一个字符。
    flag = val.isdigit()
    if flag:
        total = total + 1 # total += 1
    if index == index_len - 1:
        break
    index += 1

print(total)

2.4 步长

name = 'alex'

# val = name[0:-1:2]#ae
# val = name[1:-1:2]#lx
# val = name[1::2]#lx
# val = name[::2]#ae
# val = name[-1:0:-2]#xl
# print(val)
# 笔试题：请将字符串反转。
val = name[::-1]
print(val)#xela

2.5 for循环（注意：for和while的应用场景；有穷尽优先使用for循环，无穷尽用while）

# name = 'alex'
# for item in name:
#     print(item)
#     continue
#     print('123')
# print('结束')

# 1. for循环打印字符串的每个元素： for > while

# 2. 请打印： 1 - 10 for循环 + range
# for i in range(1,11): # [1,2,3,4,5,6,7,8,9,10,11,12,14]  "12345678910"
#     print(i)

# 3. 请打印： 1 2 3 4 5 6 8 9 10
"""
for i in range(1,11):
    if i == 7:
        pass
    else:
        print(i)
"""
for i in range(1,11):
    if i !=7:
       print(i)

3.4 列表list

想要表示多个“事物”，可以使用列表

users = ['李邵奇','李奇航'，99]

3.4.1 独有方法

1.1 append 在列表的最后追加一个元素

users = []
users.append('alex')
print(users)#alex

users = []
while True:
    name = input('请输入姓名:')
    users.append(name)
    print(users)
    
# 录入用户和密码
users = []
for i in range(0,3):
    name = input('请输入用户名和密码:')
    users.append(name)
print(users) # ['alex,123', 'oldboy,888', 'lishaoqi,123']

# 用户和密码校验
username = input('请输入要登陆用户名：')
password = input('请输入要登陆密码：')
for item in users:
    result = item.split(',') # ['alex','123']
    user = result[0]
    pwd = result[1]
    if user == username and pwd == password:
        print('登陆成功')
        break

1.2 insert，在指定的索引位置插入元素

users = ['李邵奇','利奇航','张三丰','李子森']
users.insert(1,'小黑')
print(users)#['李邵奇','小黑'，'利奇航','张三丰','李子森']

1.3 删除 remove（值） / pop（指定位置删除）

users = ['李邵奇','张三丰','利奇航','张三丰','李子森']
users.remove('张三丰')
print(users)

users = ['李邵奇','张三丰','利奇航','张三丰','李子森']
users.pop(2)#['李邵奇', '张三丰', '张三丰', '李子森']
users.pop() # 默认删除最后一个['李邵奇','张三丰','利奇航','张三丰']
print(users)

1.4 clear

users = ['李邵奇','张三丰','利奇航','张三丰','李子森']
users.clear()
print(users)

1.5 del

users = ['李邵奇','张三丰','利奇航','张三丰','李子森']
del users[1]
print(users)['张三丰','利奇航','张三丰','李子森']

1.6 sort排列

v1 = [11,22,3111,32,13]
print(v1)

v1.sort(reverse=False) # 从小到大（默认）[11, 13,22,32,311]
v1.sort(reverse=True) # 从大到小[3111, 32, 22, 13, 11]
print(v1)

1.7 extend扩展

users = [1,2,3]
users.extend('alex')
print(users) #[1, 2, 3, 'a', 'l', 'e', 'x']

1.8 reverse，反转

v1 = [1,2,3111,32,13]
v1.reverse()
print(v1) #输出[13, 32, 3111, 2, 1]

3.4.2公共方法

1.1 len

users = ['李邵奇','李奇航'，99]
val = len(users)
print(val)  #输出是3

1.2 索引

users = ['李邵奇','李奇航'，99]
val = len[0]
print(val) #李邵奇

1.3 切片

users = ['李邵奇','李奇航'，99]
val = users[0:2]
print(val) #['李邵奇', '李奇航']

1.4 步长

users = ['李邵奇','李奇航'，99]
val = users[0:2:2]
print(val) #['李邵奇']

1.5 for

'''
users = ['李少奇','李启航','张三丰','李子树']
for i in users:
    print(i)
'''
'''
users = ['李少奇', '李启航', '张三丰', '李子树']
for i in users:
    #第一次循环：i=李少奇
李
少
奇
李
启
航
张
三
丰
李
子
树
    for ele in i :
        print(ele)
'''

#练习题：请通过for循环和数字计算器实现
#方式一：

users = ['李少奇', '李启航', '张三丰', '李子树']
count = 0
for i in users:
    print(count,i)
    count +=1
   
#方式二
users = ['李少奇', '李启航', '张三丰', '李子树']
users_len = len(users)
for index in range(0,users_len):
    print(index,users[index])

1.6 删除（数字、字符串、布尔除外）

users = ['李少奇', '李启航', '张三丰', '李子树']
#方式1
users.pop(1)
print(users)
#方式2
del users[1]
print(users)

1.7 修改（数字、字符串、布尔除外

users= ['李少奇', '李启航',99]
users[2] = 66 #['李少奇', 66,99]

users[0] = '李杰'['李杰', '李启航',99]
users[0][1]  #表示是李少奇中的少，不可修改

3.4.3列表嵌套

#示例四：嵌套
v3= [11,[1,2,3],33]
v3[1][2]= '李杰'   #[11,[1,2,'李杰'],33]

3.4.4强制转换

v2 = list('addggdgg')
print(v2)  #['a', 'd', 'd', 'g', 'g', 'd', 'g', 'g']

v1 = list((11,22,33,))
print(v1) *[11, 22, 33]

3.5字典dict

帮助用户去表示一个事务的信息（事务是多个属性的）

有序
#有序：元组，列表
#无序：字典（在py3.6之后字典是有序的

基本格式：

data = {键：值，键：值，键：值，}

练习题
info = {'name':刘伟,'age':18,'gender':'男','hobby':'同桌'} ：
info['name']# 刘伟
info['age'] #18

3.5.1 独有方法

info = {'name':'刘伟','age':18,'gender':'男','hobby':'同桌'}
info.keys()  #获取字典中的所有键 'name','age','gender;'hobby'

info.values()    #获取字典中的所有键 '刘伟','18','男’;'同桌'

# for item in info.keys():
#     print(item)#'name','age','gender','hobby'
# for item in info.values():
#     print(item)#'刘伟',18,'男','同桌'

1.1 keys,获取字典中所有的键。（'name','age','gender;'hobby'）列表和字典不能做key

info = {'name':'刘伟','age':18,'gender':'男','hobby':'同桌'}
for item in info.keys():
     print(item)

1.2 values，获取字典中所有的值（'刘伟','18','男’;'同桌）

info = {'name':'刘伟','age':18,'gender':'男','hobby':'同桌'}
for item in info.values():
    print(item)

1.3 items，获取字典中的所有键值对

info = {'name':'刘伟','age':18,'gender':'男','hobby':'同桌'}
for v1,v2 in info.items():
    print(v1,v2)
# 输出  name 刘伟
       age 18
       gender 男
       hobby 同桌

1.4 get

info = {'k1':'v1','k2':'v2'}
# print(info['k1'])  
v2=info.get('k1',666)  #输出v1
v2 = info.get('k111')  #输出none，默认是空的，转换成bool也是false
print(v2)

1.5 pop

info = {'k1':'v1','k2':'v2'}
result = info.pop('k2')
print(info,result)  #输出{'k1': 'v1'} v2

# del info['k1']  #{'k2': 'v2'}

1.6 update 添加内容时不存在的添加，存在的覆盖

info = {'k1':'v1','k2':'v2'}
# info['k3'] = 'v3'
info.update({'k3':'v3','k4':'v4'})
print(info)  #{'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k4': 'v4'}

3.5.2 公共方法

1.1 len

info = {'name':'刘伟','age':18,'gender':'男','hobby':'同桌'}
print(len(info))  #输出4

1.2 索引

info = {'name':'刘伟','age':18,'gender':'男','hobby':'同桌'}
info['nmae']
info['age']

1.3 切片【无】

1.4 步长【无】

1.5 for

info = {'name':'刘伟','age':18,'gender':'男','hobby':'同桌'}
for item in info.items():
    print(item)
    
for item in info.keys():
     print(item)
     
for item in info.values():
     print(item)

1.6 删除del

info = {'name':'刘伟','age':18,'gender':'男','hobby':'同桌'}
del info['name']
print(info)
 输出{'age': 18, 'gender': '男', 'hobby': '同桌'}

1.7 修改可以改值，一般不改键,存在的话会修改，不存在会添加

#改值
info = {'name':'刘伟','age':18,'gender':'男','hobby':'同桌'}
info['age'] = 19
print(info)
#输出{'name': '刘伟', 'age': 19, 'gender': '男', 'hobby': '同桌'}
#改建
一定要改建是先删除在增加
del info['hobby']
info['xxx'] = 'xxx'

3.6元组tuple

元组书写规范:

users = [13,33,'老男孩']  #列表（可变）

users = (13,33,'老男孩')  #元组（不可变）

3.6.1 独有方法（无）

3.6.2 公共方法

1.1 len (排除：int/bool)

info = {'name':'刘伟','age':18,'gender':'男','hobby':'同桌'}
 print(len(info))  #输出4

1.2 索引(排除：int/bool)

users = (13,33,'老男孩')

print(users[0]) #13
print(users[-1]) #老男孩

1.3 切片(排除：int/bool)

users = (13,33,'老男孩')
print(users[0:2])#13,33

1.4 步长(排除：int/bool)

users = (13,33,'老男孩')
print(users[0:2:2])#13，

1.5 删除(排除：str/int/bool/tuple)

1.6 修改(排除：str/int/bool/tuple)

1.7 for循环(排除：int/bool)

users = (11, 22, 33, "老男孩")
for item in users:
    print(item)  11  22   33   老男孩

3.6.3特殊：元组中的元素不可被修改或删除(元组嵌套)

#示例一
v1 = (11,22,33)
v1[2]=9  #不可 执行
v1=999  #正确

#示例二：可以嵌套
v1 = (11,22,33(11,22,33))

#示例三：嵌套
v2=[11,22,33(11,22,33)]
v2[-1][1] = 99  #错误
v2[-1] = 123 #正确

#示例四：嵌套
v3= (11,[1,2,3],33)
v3[1] = 666 #错误
v3[1][2]= 123

3.7集合set

空集合的写法:

1.空集合
'''
v1 = set()
v= {}  ##空字典
print(tyoe(v))

3.7.1独有方法

1.1 add 添加

v = {1,2}
v.add('lishaoqi')
print(v)   #{1, 2, 'lishaoqi'}

1.2 discard 删除，集合是无序的不能通过索引删除

v = {1,2,'lishaoqi'}
v.discard("lishaoqi")
print(v)  # {1, 2}

1.3 update 往里面添加，批量添加

v = {1,2,'lishaoqi'}
v.update({11,22,33})
print(v)  # {1, 2, 33, 22, 11, 'lishaoqi'}

1.4 clear

v = {1,2,'lishaoqi'}
v.clear()
print(v)   #set()

1.5 intersection交集

v = {1,2,'李少'}
result = v.intersection({1,'小黑','李少'})
print(result)  #{1, '李少'}

1.6 union 并集

v = {1,2,'李少'}
result = v.union({1,'小黑','李少'})
print(result)   #{1, 2, '李少', '小黑'}

1.7 difference

v = {1,2,'李少奇'}
result = v.difference({1,'小黑','李少奇'}) #v中有且({1,'小黑','李少奇'})没有
print(result)   #{2}

1.8 symmetric.difference对称差集

v = {1,2,'李少奇'}
result = v.symmetric_difference({1,'小黑','李少奇'}) 
print(result)   #{2, '小黑'}

##注意：对于集合来说，后面的可以是列表

v = {1,2,'李少奇'}
result = v.symmetric_difference([1,'小黑','李少奇'])
print(result)   #{2, '小黑'}

3.7.2公共方法

1.1 len

v = {1,2,'李少奇'}
print(len(v))   #3

1.2 索引（无）

1.3 切片（无）

1.4 步长（无）

1.5 删除（无）

1.6 修改（无）

1.7 for循环

v = {1,2,'李少奇'}
for item in v:
  print(item)

1.8 嵌套问题

###列表/字典/集合---》不能放在集合中，不能作为字典的key
###特殊情况
# info = {1,2,3,4,True,'国风',None,}
# print(info)  #{1, 2, 3, 4, None, '国风'}，没有True是认为和1重复了所有不显示
# info = {2,3,4,True,'国风',None,}
# print(info)   #{True, 2, 3, 4, None, '国风'}
info = {1:'alex',
        True:'oldboy'}
print(info)  # {1: 'oldboy'}

3.8嵌套（相关的题）

message = """欢迎致电10086
          1、话费查询；
          2、流量服务；
          3、业务办理；
          4、人工服务"""
print(message)

index = input("请输入你要选择的业务：")
index = int(index)
if index ==1:
    print("话费查询")
elif index ==2:
    print("流量服务")
elif index ==3:
    content = """业务办理
    1、修改密码；
    2、更改套餐；
    3、停机"""
    print(content)
    value = input("请输入要办理的业务：")
    value = int(value)
    if value == 1:
        print("修改密码")
    elif value == 2:
        print("更改套餐")
    elif value == 3:
        print("停机")
    else :
        print("错误")
elif index ==3:
    print("人工服务")
else:
    print("输入错误")

需求：用户三次登录，允许用户最多尝试3次，没尝试三次后，如果还没输入正确，就问用户是否还想继续玩，
# 如果回答y，就继续让其猜3次，以此往复

#功能分解
'''
count = 1
while count <=3:
    print (count)
    user = input("请输入用户名：")
    pwd = input("请输入密码：")
    if user == "alex" and pwd == '123':
        print("登录成功")
    else:
        print('登录失败')
    if count ==3:
        choice = input('请输入是否继续(Y/N)')
        if choice == 'N':
            break
        elif choice =='Y':
            count =1
            continue
        else:
            print('输入错误')
        break
    count += 1
'''
#用户登入三次（三次输出机会）且每次输错误时显示剩余错误次数（提示：使用字符串格式化）
#用户登录
user = input ("请输入用户名：")
pwd = input ("请输入密码：")
if user == "alex" and pwd == '123':
    print("登录成功")
else:
    print('登录失败')
#功能2：三次机会提示
    #第一种方法：
count = 1
while count <= 3:
    timer = 3-count
    template = ('用户名或密码输入错误，剩余%s次机会'%(timer,))
    print(template)
    count += 1

#第二种方法：
count = 2
while count >= 0:
    print(count)
    count -=1
#合并
count = 2
while count >= 0:
    user = input("请输入用户名：")
    pwd = input("请输入密码：")
    if user == "alex" and pwd == '123':
        print("登录成功")
        break
    else:#else可以不写
        template = ('用户名或密码输入错误，剩余%s次机会' % (count,))
        print(template)
    count -=1

count = 2
while count >= 0:
    user = input("请输入用户名：")
    pwd = input("请输入密码：")
    if user == "alex" and pwd == '123':
        print("登录成功")
        break

    template = ('用户名或密码输入错误，剩余%s次机会' % (count,))
    print(template)
    count -=1
else:
    print('三次机会用完')

# 录入用户和密码
users = []
for i in range(0,3):
    name = input('请输入用户名和密码:')
    users.append(name)
print(users) # ['alex,123', 'oldboy,888', 'lishaoqi,123']

# 用户和密码校验
username = input('请输入要登陆用户名：')
password = input('请输入要登陆密码：')
for item in users:
    result = item.split(',') # ['alex','123']
    user = result[0]
    pwd = result[1]
    if user == username and pwd == password:
        print('登陆成功')
        break

#通过循环，打印1,2,3,4,5,6, 8,9,10  快速注释 Ctrl+/
"""
count = 1
while count <=6:
    print(count)
    count = count +1
count = 8
while count <=10:
    print(count)
    count = count +1

##元组里面嵌套可变类型，如果深拷贝的时候就会拷贝
'''
v1 = (1,2,3,[1,2,3],4)
import copy
v2 = copy.copy(v1)
print(id(v1),id(v2))
v3 = copy.deepcopy(v1)
print(id(v1),id(v3))

3.9判断字符串是否有敏感字符

1. str

v = ‘python全栈21期'
if "全栈"in v
   print（"含敏感字符"）

2.list

v= ['oldboy','李启航'，'李少奇']
if '李少奇' in v:
   print("含敏感字符")

3. dict

v= ['k1':'v1','k2':'v2'，'k3':'v3']
#判断k1是否在其中，v2是否在其中，k2：v2是否在其中
if x in v： ##默认按键判断，即，判断x是否是字典的键

if 'k1' in v:
    pass
#v2是否在其中
方式一：循环判断
flag='不存在'
for v in v.values():
    if v == 'v2'
    flag = '存在'
 print（flag）
 方式二：
 if 'v2'in list(v.values()) #强制转换成列表['v1','v2',v3]
     pass
#k2：v2是否在其中
value = v.get('k2')
if value =='v2'
   print('存在')
 else：
   print('不存在')

#让用户任意输入字符串，然后判断此字符串是否含有指定的敏感字符
list = ['李启航','李少奇','渣渣辉']
content = input('请输入内容：')
success = True
for v in list:
    if v in content:
        success = False
        break
if success:
    print(content)
else:
    print('含有敏感字符')

3.10内存相关

面试问题: ==和is的区别 ?

答 : ==是比较值是否相等,is是比较内存地址是否相等

1.示例一,值相等，但是不同的内存地址

v1 = [11,22,33]
v2 = [11,22,33]

v1 =666
v2 =666

v1 = 'asdf'
v2 = 'asdf'
#重新开辟内存并赋值
#按理v1和v2是不同的内存地址，但是python中有缓存机制，所有有一些特殊：
  1.整型：-5 - 256 会缓存到一个ID地址，所以内存地址一样
  2.字符串： 'xxx'会缓存到一个ID地址，所以内存地址一样
  但'f_*'*数字 （数字》1--->重新开辟内存

2.示例二，值不同，内存地址不同

v1 = [11,22,33,44]
v2 = [11,22,33]

3. 示例三

v1 = [11,22,33,]
v2 = v1 #v2的地址也是指向v1的地址

#内部可以修改的是字典，列表，集合
v1 = [11,22,33,]
v2 = v1
v1.append(666)
print(v2)

#重新赋值
v1 = [11,22,33,]
v2 = v1
v1 = [1,2,3,4]
print(v2)    #输出[11, 22, 33]
赋值和修改是不一样的，

#重新赋值
v1 = 'alex'
v2 = v1
v1 = 'oldboy'
print(v2)  #输出alex

4. 示例四

v = [1,2,3]
values = [11,22,v] #v指向v这个列表

v.append(9)
print(v2) #输出[11,22,[1,2,3,9]]

values[2].append(999)
print(v)  #[1, 2, 3, 999]

v = [1,2,3]
values = [11,22,v]
v = 999
print(values)  #[11, 22, [1, 2, 3]]

values[2] = 666
print(v)   #[1, 2, 3]

5. 示例五

v1 = [1,2]
v2 = [2,3]
v3 = [11,22,v1,v2,v1]

6.查看内存地址，通过id查看内存地址

v1 = [1,2,3]
v2 = [1,2,3]
print(id(v1),id(v2))   #1502734668360 1502734668872
'''
'''
v1 = [1,2,3]
v2 = v1
print(id(v1),id(v2))  #2707199185480 2707199185480
'''
v1 = [1,2,3]
v2 = v1
v1 = 999
print(id(v1),id(v2))   #2776635433776 2776633922120

在python中对于数字（整型，浮点数）-5到256是常用数字，ID内存会一样，大于256的ID内存会不一样

v1 = [1,2,3,4]
v2 = [1,2,3,4,5,6]
v1 == v2
False
v1 is v2
False

V1 = [1,2]
V2 = [1,2]
V1 ==V2
True
v1 is v2
False

V1 = [1,2,3]
V2 = V1
V1 == V2
True
v1 is v2
True

V1 = 10   ##因为python的有缓存的小数据池，在里               面ID相同
V2 = 10
V1 == V2
True
V1 is V2 
True

3.11深浅拷贝

3.11.1深浅拷贝对于不同数据类型的作用

1.对于数字int，字符串str，布尔值bool深浅拷贝都一样，内存地址不变

2.对于列表深拷贝是找到所有可变的数据拷贝

3.对于可变的如列表，元组，字典等，浅拷贝只能拷贝第一个数据，深拷贝可以都拷贝地址不同

3.11.2 深浅拷贝的格式

1 .copy.copy() 浅拷贝：只拷贝一层

2.copy.deepcopy() 深拷贝：拷贝嵌套层次中的所有可变数据类型

##应该每次都拷贝一份（但是由于小数据池的存在，所以为拷贝） 小数据池是指1-255的数据
'''
v1= 'alex'
import copy
# v2 =copy.copy (v1)
# print(id(v1),id(v2))#内存地址一样
v3 = copy.deepcopy(v1)
print(id(v1),id(v3))  #内存地址一样

v1= [1,2,3,4,[11,22,33]]
import copy
v2 = copy.copy(v1)
print(id(v1),id(v2))  内存地址不同
print(id(v1[4]),id(v2[4]))  内存地址相同

import copy
v1 = [1,2,3]
v2 = copy.deepcopy(v1)
print(v1 is v2)#False
print(v1 == v2) #True
print(v1[0] is v2[0]) #True

import copy
v1 = [1,2,3,{'k1':123,'k2':456}]
v2 = copy.deepcopy(v1)
print(v1 is v2)#False
print(v1 == v2) #True
print(v1[0] is v2[0])#True
print(v1[3] == v2[3])#True
print(v1[3] is v2[3])  #False  因为[3]是可变的数据类型，所以深拷贝之后内存地址会变
'''
##总结
#浅拷贝：只拷贝一层
#深拷贝：拷贝嵌套层次中的所有可变数据类型
###特殊情况:对于元组来说，因为它是不可变类型，所有深浅拷贝都不变
'''
v1 = (1,2,3,4)
import copy
v2 = copy.copy(v1)
print(id(v1),id(v2))
v3 = copy.deepcopy(v1)
print(id(v1),id(v3))
'''
##元组里面嵌套可变类型，如果深拷贝的时候就会拷贝
'''
v1 = (1,2,3,[1,2,3],4)
import copy
v2 = copy.copy(v1)
print(id(v1),id(v2))
v3 = copy.deepcopy(v1)
print(id(v1),id(v3))
'''