第三章数据类型

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))
'''

posted @ 2020-03-15 21:38 炜琴清阅读(136) 评论(0) 编辑收藏举报

刷新页面返回顶部

第三章 数据类型

3.1整型（int）

3.1.1 整型的长度

3.1.2整除

3.2布尔类型（bool）

3.3字符串（str）

3.3.1字符串自己的方法

1.独有方法

2.公共方法

3.4 列表list

3.4.1 独有方法

3.4.2公共方法

1.1 len

3.4.3列表嵌套

3.4.4强制转换

3.5字典dict

3.5.1 独有方法

3.5.2 公共方法

3.6元组tuple

3.6.1 独有方法（无）

3.6.2 公共方法

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

3.7集合set

3.7.1独有方法

3.7.2公共方法

3.8嵌套（相关的题）

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

3.10内存相关

3.11深浅拷贝

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

3.11.2 深浅拷贝的格式

公告

第三章数据类型