第三章数据类型

第三章 数据类型

3.1 整型（int）

任意大小的整数，当然包括负整数

>>> 100
100
>>> -9999
-9999
>>>

3.1.1 整型的长度

python2：

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

python3：

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

3.1.2 整除

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

>>> from __future__ import division
>>> value = 3/2
>>> print(value)
1.5
>>>
>>> value = 10/3
>>> print(value)
3.33333333333

3.2 布尔（bool）

一个布尔值只有True,False两种值，要么是true要么是false

布尔值就是用于表示真假。True和False。

>>> True
True
>>> 3 > 2
True
>>> False
False
>>> 3 > 5
False
>>> 30 > 66
False
>>> 444 > 333
True
>>>

其他类型转换成布尔值：

• str
• ...

对于：None / "" / 0 .... -> false

3.3 字符串（str）

字符串是写代码中最常见的，python内存中的字符串是按照：unicode 编码存储。对于字符串是不可变。

3.3.1 字符串相加

字符串拼接,相加的规则就是必须都是字符串才能相加

>>> a = "hello"
>>> b = "word"
>>> print(a+b)
helloword

3.3.2 字符串相乘

字符串的乘法就是将多个字符串拼接到一起,乘法的规则:只能是字符串和数字相乘

>>> a = "hello"
>>> b = 5
>>> print(a*b)
hellohellohellohellohello

• 字符串中是不能进行减法和除法操作的

3.3.3 索引

​ 索引就是对字符串中的每个元素从左到右进行有序的编码，从0开始，所以每个字符串中的第一个元素的索引就是0.

​ 当索引是负数是，表示从右到左取元素，由于-0等于0，所以，-1就代表了从右到左的第一个元素

• 示例

>>> name = "ABCDE"
>>> print(name[0])
A
>>> print(name[1])
B
>>> print(name[2])
C
>>> print(name[-1])
E
>>> print(name[-2])
D
>>> print(name[-0])
A

3.3.4 切片

​ 切片就是通过索引取出字符串的某一段，[第一个位置是开始:第二个位置是终止]中间必须使用分号。

​ 默认终止的索引是不会包含在获取的内容中

• 示例

>>> name = "ABCDE"
>>> print(name[:1])
A
>>> print(name[1:])
BCDE
>>> print(name[1:4])
BCD
>>> print(name[1:-1])
BCD
>>> print(name[1:-2])
BC

3.3.5 步长

中括号里第一个参数是起始位置,第二参数是终止位置,第三个参数现在告诉大家是步长(每次走几步)

>>> name = "ABCDE"
>>>
>>> print(name[:1:2])
A
>>> print(name[::2])
ACE
>>> print(name[::-2]) # 负数就是倒着取
ECA
>>>

3.3.6 字符串方法详解

【补充】首字母大写、大小写翻转、每个隔开的（特殊字符和数字）单词首字母大写

 s = 'alex Wusir' #首字母大写
 s1 = s.capitalize()  #首字母大写# print(s1) #Alex wusir

 s3 = s.swapcase() #大小写翻转
 print(s3) #ALEX wUSIR

 a = 'zhangyang zy yy'
 a1 = a.title() #每个隔开的（特殊字符和数字）单词首字母大写
 print(a1) #Zhangyang Zy Yy

1.全部大写 upper()

• 示例

>>> name = 'abcdef'
>>> new_name = name.upper()
>>> print(new_name)
ABCDEF

#######

>>> name = 'ABCdef123'
>>> new_name = name.upper()
>>> print(new_name)
ABCDEF123
>>>
##################
v = 'ALEX'
v1 = v.upper()
print(v1)
v2 = v.isupper() # 判断是否全部是大写
print(v2)

2.全部小写 lower()

• 示例

>>> name = 'ABCDEF'
>>> new_name = name.lower()
>>> print(new_name)
abcdef

################

>>> name = 'ABCdef123'
>>> new_name = name.lower()
>>> print(new_name)
abcdef123

3.字符串替换 replace()

replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次

• replace()方法语法：

str.replace(old, new[, max])

• 参数

old -- 将被替换的子字符串。
new -- 新字符串，用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次

• 示例

message = input('请说话：')
print(message)
data = message.replace('大爷',"**",2)# 将大爷替换成**，替换不超过2次
print(data)

4.去除字符 strip()

• strip()的语法

str.strip([chars])

• 参数

chars 代表要去除的字符，默认是空格

strip() 是去除头尾。

• 示例

name = '  AB, CD, E, F,  G  '
new_name = name.strip()
print("--->",new_name,"<---")
---> AB, CD, E, F,  G <---

lstrip() 是去除左边的字符

• 示例

name = '  AB, CD, E, F,  G  '
new_name = name.lstrip()
print("--->",new_name,"<---")
---> AB, CD, E, F,  G   <---

rstrip()是去除右边的字符

• 示例

name = '  AB, CD, E, F,  G  '
new_name = name.rstrip()
print("--->",new_name,"<---")
--->   AB, CD, E, F,  G <---

5.字符切割 split()

通过指定分隔符对字符串进行切片

• split() 语法：

str.split(分隔符, 分割次数)

split() 从左到右切割

rsplit() 从右到左切割

• 示例

>>> message = "小黑现在一脸懵逼，因为昨天晚上一直在学习，直到深夜。"
>>> result = message.rsplit('，',1)
>>> print(result)
['小黑现在一脸懵逼，因为昨天晚上一直在学习', '直到深夜。']
>>> result = message.rsplit('，')
>>> print(result)
['小黑现在一脸懵逼', '因为昨天晚上一直在学习', '直到深夜。']

6.判断是否是数字： isdecimal/.isdigit()

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('你输入的不是数字')

7.是否以什么开头.startswith()

name = 'AB, CD, E, F,G  '
new_name = name.startswith("A")
print("--->",new_name,"<---")
---> True <---
##############################
name = 'AB, CD, E, F,G  '
new_name = name.startswith("a")
print("--->",new_name,"<---")
---> False <---

8. 是否以什么结尾.endswith()

name = 'AB, CD, E, F,G'
new_name = name.endswith("G")
print("--->",new_name,"<---")
---> True <---
##############################
name = 'AB, CD, E, F,G'
new_name = name.endswith("g")
print("--->",new_name,"<---")
---> False <---

9. 格式化输出.format()

name = 'AB, CD, E, F,G,{}'
new_name = name.format("呵呵呵")
print("--->",new_name,"<---")
---> AB, CD, E, F,G,呵呵呵 <---

10.连接字符串.join()

name = 'AB, CD, E, F,G'
new_name = "_".join(name)
print("--->",new_name,"<---")
---> A_B_,_ _C_D_,_ _E_,_ _F_,_G <---

11.统计次数.count()

name = 'AB, CD, E, F,G,ABC,AC'
new_name = name.count("A")
print("--->",new_name,"<---")
---> 3 <---

12.指定编码格式.encode()

name = 'ABCDEF'
new_name = name.encode("GBK")
print("--->",new_name,"<---")
---> b'ABCDEF' <---
#######################
name = 'ABCDEF'
new_name = name.encode("UTF-8")
print("--->",new_name,"<---")
---> b'ABCDEF' <---
######################
name = '努力'
new_name = name.encode("UTF-8")
print("--->",new_name,"<---")
---> b'xe5x8axaaxe5x8ax9b' <---
######################
name = '努力'
new_name = name.encode("GBK")
print("--->",new_name,"<---")
---> b'xc5xacxc1xa6' <---

3.4 列表(list)

列表是python的基础数据类型之一 ,它是以[ ]括起来, 每个元素用’ , ‘隔开而且可以存放各种数据类型:

比如：

lis = ["alex", "WuSir", "ritian", "barry", "wenzhou"]

3.4.1. 列表的索引

列表也拥有索引:

>>> lis = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
>>> print(lis[0])
alex
>>> print(lis[1])
WuSir
>>> print(lis[2])
ritian
>>> print(lis[3])
barry

3.4.2. 列表的切片

列表可以根据索引进行切片

lis = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
>>> print(lis[0:3])
['alex', 'WuSir', 'ritian']
>>> print(lis[0:-1])
['alex', 'WuSir', 'ritian', 'barry']
>>> print(lis[1::2])
['WuSir', 'barry']
>>>

3.4.3 列表的嵌套

>>> lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
>>> print(lis[3])
['qwe', 20, ['k1', ['tt', 3, '1']], 89]
>>> print(lis[3][2])
['k1', ['tt', 3, '1']]
>>> print(lis[3][2][0])
k1
>>> print(lis[3][2][1])
['tt', 3, '1']

3.4.4 列表方法详解

1.追加.append()

user_list = ["alex","wusir","ritian","jing"]
user_list.append("摸摸哒")
print(user_list)
['alex', 'wusir', 'ritian', 'jing', '摸摸哒']

2.插入.insert()

user_list = ["alex","wusir","ritian","jing"]
user_list.insert(0,"摸摸哒")
print(user_list)
['摸摸哒', 'alex', 'wusir', 'ritian', 'jing']

3.按索引删除.pop()

user_list = ["alex","wusir","ritian","jing"]
user_list.pop(3)
print(user_list)
['alex', 'wusir', 'ritian']

4.按内容删除.remove()

user_list = ["alex","wusir","ritian","jing"]
user_list.remove("alex")
print(user_list)
['wusir', 'ritian', 'jing']

5.清空列表.clear()

user_list = ["alex","wusir","ritian","jing"]
user_list.clear()
print(user_list)
[]

6.del(按索引删除,可以切片删除)

a = ['kngiht','kevin','qaz',1,2,3]
del a[2:4]
print(a)     #['kngiht', 'kevin', 2, 3] 按索引切片删除

7.迭代添加.extend ()

user_list = ["alex","wusir","ritian","jing"]
user_list.extend(["摸摸哒","呵呵哒","佩琦"])
print(user_list)
['alex', 'wusir', 'ritian', 'jing', '摸摸哒', '呵呵哒', '佩琦']

8.反转列表内容.reverse()

user_list = ["alex","wusir","ritian","jing"]
user_list.reverse()
print(user_list)
['jing', 'ritian', 'wusir', 'alex']

9.排序.sort()

## 正向排序
user_list = [1,2,3,4,5,5,6,5,4,3,2,16,100,20]
user_list.sort()
print(user_list)
[1, 2, 2, 3, 3, 4, 4, 5, 5, 5, 6, 16, 20, 100]

## 反向排序
user_list = [1,2,3,4,5,5,6,5,4,3,2,16,100,20]
user_list.sort(reverse=True)
print(user_list)
[100, 20, 16, 6, 5, 5, 5, 4, 4, 3, 3, 2, 2, 1]

3.5 元组（tuple）

​ 不可变的列表,又被成为只读列表,元祖也是python的基本数据类型之一,用小括号括起来,里面可以放任何数据类型的数据,查询可以,循环也可以,切片也可以.但就是不能改.

>>> lis = ("alex", "WuSir", "ritian", "barry", "wenzhou")
>>>
>>> print(lis[0])
alex
>>> print(lis[1:4])
('WuSir', 'ritian', 'barry')
>>> print(lis[1:])
('WuSir', 'ritian', 'barry', 'wenzhou')
>>> print(lis[1:-1])
('WuSir', 'ritian', 'barry')
>>> print(lis[::-1])
('wenzhou', 'barry', 'ritian', 'WuSir', 'alex')
>>>

关于不可变, 注意: 这里元组的不可变的意思是子元素不可变. 而子元素内部的子元素是可以变, 这取决于子元素是否是可变对象.

元组中如果只有一个元素. 一定要添加一个逗号, 否则就不是元组

>>> tup = ("keep")
>>> print(type(tup)) # type是查看数据类型
<class 'str'>
>>> tup = ("keep",)
>>> print(type(tup))
<class 'tuple'>

元祖嵌套

>>> tu = ('今天姐姐不在家','姐夫和小姨子在客厅聊天',('姐夫问小姨子税后多少钱',' 小姨子低声说道说和姐夫还提钱'))
>>>
>>> print(tu1)
今天姐姐不在家
>>> print(tu2)
姐夫和小姨子在客厅聊天
>>> print(tu3)
姐夫问小姨子税后多少钱
>>> print(tu4)
小姨子低声说道说和姐夫还提钱

元组（不可变）

• 公共
  • 索引
  • 切片
  • 步长
  • for
  • len

3.6 字典（dict）

字典(dict)是python中唯⼀的⼀个映射类型.他是以{ }括起来的键值对组成。 python3.6后字典是有序的

• 有序字典？ 如果想用怎么办？

from collections import OrderedDict

info = OrderedDict()
info['k1'] = 123  #本质就是调用__setitem__
info['k2'] = 456

#info['k1']  #__getitem__

print(info.keys())
print(info.values())
print(info.items())

和列表list比较，字典dict有以下几个特点：

1. 查找和插入的速度极快，不会随着key的增加而变慢；
2. 需要占用大量的内存，内存浪费多。

而list相反：

1. 查找和插入的时间随着元素的增加而增加；
2. 占用空间小，浪费内存很少。

在dict中key是 唯⼀的.在保存的时候, 根据key来计算出⼀个内存地址. 然后将key-value保存在这个地址中，这种算法被称为hash算法。

可以改变的都是不可哈希的, 那么可哈希就意味着不可变. 这个是为了能准确的计算内存地址⽽规定的.

3.6.1 语法

{'key1':1,'key2':2}

注意: key必须是不可变(可哈希)的. value没有要求.可以保存任意类型的数据

数据类型划分：可变数据类型,不可变数据类型

字典无序

不可变数据类型：元组,bool,int str  -->可哈希
可变数据类型：list,dict,set      --> 不可哈希
dict key(键) 必须是不可变数据类型(可哈希)    value(值)：任意数据类型

3.6.2 字典方法

1.增加

dic = {'age':18,'name':'jin','sex':'male',}
1.1
dic['hight']=180 # 没有键值对会新增
print(dic)#{'age': 18, 'name': 'jin', 'sex': 'male', 'hight': 180}
dic['age']=16 #如果有键，则值会覆盖
print(dic)#{'age': 16, 'name': 'jin', 'sex': 'male', 'hight': 180}

1.2
dic.setdefault('weight') #有键值对，不做任何改变，没有则添加
dic.setdefault('weight',150)
dic.setdefault('name','erge')
print(dic)#{'age': 16, 'name': 'jin', 'sex': 'male', 'hight': 180, 'weight': None}

2.删除

2.1 pop
print(dic.pop('age'))#16   返回age对应的值
print(dic.pop('二哥',None)) #None  为了防止删除的时候没有要删除的键，而报错设置一个返回值，也可以是字符串'没有此键'
print(dic.pop('name',None)) #jin 删除有的键，即使设置了返回值None也不会返回，而是返回删除成功的值 jin
print(dic) #{'name': 'jin', 'sex': 'male', 'hight': 180, 'weight': None}

2.2 popitem
print(dic.popitem()) #随机删除一个元素，并把删除元素的键和值放在一个元组里返回:(key, value)。
#返回值 ('weight', None)
print(dic) #{'sex': 'male', 'hight': 180}
2.3 del
del dic['sex'] #del +键，按键来删除
print(dic) #{'hight': 180}

del dic #删除字典
print(dic)

2.4 clear 清空字典
dic.clear(dic)
print(dic)

3.更改

3.1
dic['age']=16 #如果有键，则值会覆盖

3.2
dic = {'name':'zy','age':18,'sex':'male'}
dic2 = {'name':'alex','weight':'150'}
dic2.update(dic) #一样的键，值会覆盖，不一样的键,会新增
print(dic2) #{'name': 'zy', 'weight': '150', 'age': 18, 'sex': 'male'}

4.查询

dic1 = {'name':'zy','age':18,'sex':'male',}
4.1
print(dic1.keys()) #dict_keys(['name', 'age', 'sex'])
print(dic1.values()) #dict_values(['zy', 18, 'male'])
print(dic1.items()) #dict_items([('name', 'zy'), ('age', 18), ('sex', 'male')])


print(dic1['name']) #返回值 zy
print(dic1['name1']) #会报错，找不到这个键 KeyError: 'name1'
4.2
#这时可以用dic1.get() 设置一个返回值  如下：
print(dic1.get('name1','没有这个键')) #没有这个键

用循环查询
for i in dic1: #dic1与dicdic1.keys()一样,只打印出键
    print(i)  #name age sex

for i in dic1.keys():  #name age sex
    print(i)

for i in dic1.values():
    print(i) #zy 18 male

for i in dic1.items():  #返回的是元组，元组里是键值对
    print(i) #('name', 'zy') ('age', 18) ('sex', 'male')

1. 计算长度.len()

dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
items_dic = dic.update({"悟空":"金箍棒"})
print(len(dic))
4

3.6.3 字典的嵌套

>>> dic = {
...     'name':'汪峰',
...     'age':48,
...     'wife':[{'name':'国际章','age':38}],
...     'children':['第一个熊孩子','第二个熊孩子']
... }
>>>
>>>
>>> d1 = dic['wife'][0]['name']
>>> print(d1)
国际章
>>> d2 = dic['children']
>>> print(d2)
['第一个熊孩子', '第二个熊孩子']
>>> d3 = dic['children'][0]
>>> print(d3)
第一个熊孩子

3.7 集合（set）

​ set集合是python的⼀个基本数据类型. ⼀般不是很常⽤. set中的元素是不重复的.⽆序的.⾥ ⾯的元素必须是可hash的(不可变数据类型)

3.7.1集合的方法

1.添加.add()

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s1.add("蔡徐坤")
print(s1)
{'刘能', '蔡徐坤', '⽪⻓⼭', '赵四'}

2. 删除.discard()

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s1.discard("赵四")
print(s1)
{'刘能', '⽪⻓⼭'}

3.交集.intersection()

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s1.intersection(s2)
print(s)
{'⽪⻓⼭'}

4.并集.union()

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s1.union(s2)
print(s)
{'赵四', '冯乡⻓', '刘能', '⽪⻓⼭', '刘科⻓'}

5.差集.difference()

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s1.difference(s2)
print(s)
{'赵四', '刘能'}

##################

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s2.difference(s1)
print(s)
{'冯乡⻓', '刘科⻓'}

6.反交集.symmetric_difference()

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s2.symmetric_difference(s1)
print(s)
{'赵四', '刘能', '冯乡⻓', '刘科⻓'}

7.计算长度.len()

s1 = {"刘能", "赵四", "⽪⻓⼭"}
print(len(s1)) #3

3.7.2 嵌套问题

1. # 1. 列表/字典/集合(可变数据类型) -> 不能放在集合中、不能作为字典的key（unhashable）
   # 数据类型划分：可变数据类型,不可变数据类型
   # 不可变数据类型：元组,bool,int str  -->可哈希
   # 可变数据类型：list,dict,set      --> 不可哈希
   
   # info = {1, 2, 3, 4, True, "国风", None, (1, 2, 3)}
   # print(info)
   # 2. hash -> 哈希是怎么回事？
   # 因为在内部会将值进行哈希算法并得到一个数值（对应内存地址），以后用于快速查找。
    
   可使用的对象包括： 数字 、字符串、元组，不可使用hash函数的是 列表、字典。
   hash的特征：hash值的计算过程是以依据这个值的特征计算的，这要求被hash的值必须固定，因此被hash的值必须不可变。
   用途: 文件签名 、 md5加密 、 密码验证
   # 3. 特殊情况
   # info = {0, 2, 3, 4, False, "国风", None, (1, 2, 3)}  #False为0，与0重复
   # print(info)
   
   # info = {            
   #     1:'alex',
   #     True:'oldboy'
   # }
   # print(info)  #{1: 'oldboy'}
   

3.8 公共功能

• len
• 索引
• 切片
• 步长
• for循环

3.9 内存相关

3.9.1 id,查看内存地址

>>> v1 = [11,22,33]
>>> v2 = [11,22,33]
>>> print(id(v1),id(v2)) # 比较两个变量的内存值
4472652360 4473773640	
# 对于 -5 ~ 256 的整数来说会有小地址池的概念，不会创建新的内存地址

>>> v1 = "我，你，他，它，她"
>>> v2 = "我，你，他，它，她"
>>> print(id(v1),id(v2))
4473666128 4473665840

 # 赋值，就是把v2指向了v1的内存地址，所以他们的内存地址一样
>>> v1 = "我，你，他，它，她"
>>> v2 = v1 
>>> print(id(v1),id(v2))
4473666128 4473666128

# 重新赋值，v1的内存地址变了，但是v2的内存地址没变
>>> v1 = "我，你，他，它，她"
>>> v2 = v1    
>>> v1 = "我，你，他，它，她，天"   v1现在指向"我，你，他，它，她，天"的地址，v2还是原来的
>>> print(id(v1),id(v2))
4473665840 4473666128
>>> print(v2)
我，你，他，它，她

is，比较内存地址

>>> v1 = {'k1':'v1','k2':[1,2,3]}
>>> v2 = {'k1':'v1','k2':[1,2,3]}
>>> result1 = v1 == v2
>>> result2 = v1 is v2
>>> print(result1)
True
>>> print(result2)
False

重要

is 和 == 的区别？

== 用于比较值是否相等。
is 用于比较内存地址是否相等。

PS：找到内存地址并在其中做操作和赋值 不一样

赋值是重新开辟一块内存空间、可变数据类型

#练习1(内部修改)
v1=[11,22,33]
v2=v1
v1.append(666)
print(v2) #含有666

#练习2(赋值)
v1=[11,22,33]
v2=v1
v1=[1,2,3,4] #此时v1重新赋值为[1,2,3,4]，v1=[11,22,33] 对应的内存地址被回收，只要有指向这个内存地址的，就不会被回收
print(v2) #[11,22,33]

#练习3(重新赋值) 
v1='alex'
v2=v1
v1='old boy'
print(v2) #'alex'

总结：可变数据类型列表/字典/集合 有内部修改和赋值
字符串等不可变的 只有重新赋值（不可在内部修改）

ps:
v=[1,2,3]
value=[11,22,v]
value[2]=666 #对value自己更改，v不会改变
print(v)  #[1, 2, 3]

v=[1,2,3]
value=[11,22,v]
value[2][0]=666 #对v里面修改，v会改变
print(v)  #[666, 2, 3]

python中有小数据池--缓存机制，节省内存

1. 数字 （-5-256）
2. 简单的字符串 ‘ALEX’

a=1
b=1
print(id(a),id(b)) #496846480 496846480  #理论上赋值，是重新开辟内存地址，但python中有缓存机制

3.10 深浅拷贝

浅拷贝：只拷贝第一层

深拷贝：拷贝所有数据（只针对可变数据类型）--- 重新拷贝意味着重新在内存中开辟一块空间

只有一层的深拷贝意义不大，重要的是对于嵌套

1、int+str+bool/tuple 深浅拷贝是一样的（不可变数据类型，类似小数据池的概念）

v1='alex'
v2=copy.copy(v1)
v3=copy.deepcopy(v1)
print(id(v1),id(v3)) #11611168 11611168

2、list+set+dict （可变数据类型）
深浅拷贝不一样的

总结

浅拷贝:仅会拷贝a的框架的内存地址, 里面的任何子元素的内存地址都不会被拷贝.
深拷贝:不仅拷贝a的框架,而且会拷贝a里所有的可变元素的内存地址,注意不可变元素仍不可拷贝

3.11 类型转换

1.数字转字符串

>>> v1 = 666
>>> v2 = str(v1)
>>> print (v2)
666

2.数字转布尔

>>> v1 = 0
>>> v2 = bool(v1)
>>> print (v2)
False
#######################
>>> v1 = 666
>>> v2 = bool(v1)
>>> print (v2)
True

非零值转布尔都是True，0转布尔是False

3.字符串转数字

>>> v1 = "666"
>>> v2 = int(v1)
>>> print (v2)
666
### 字符串内容是数字时，可以转换成数字

>>> v1 = "hello2"
>>> v2 = int(v1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'hello2'
###字符串含有数字以外的字符时，不能转换成数字


>>> v1 = ""
>>> v2 = int(v1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: ''
    
###空字符串不能转换成数字

4.字符串转布尔值

>>> v1 = "66q3"
>>> v2 = bool(v1)
>>> print(v2)
True
### 非空字符串转换布尔值都是True

>>> v1 = ""
>>> v2 = bool(v1)
>>> print(v2)
False
### 空字符串转换布尔值是Fales

5.布尔值转换数字

>>> v1 = True
>>> v2 = int(v1)
>>> print(v2)
1

>>> v1 = False
>>> v2 = int(v1)
>>> print(v2)
0

6.布尔值转换字符串

>>> v1 = True
>>> v2 = str(v1)
>>> print(v2)
True

>>> v1 = False
>>> v2 = str(v1)
>>> print(v2)
False