08.类型转换、深浅拷贝
- 01.类型转换
-
- [1.1 int()](#1.1 int())
- [1.2 float](#1.2 float)
- [1.3 str()](#1.3 str())
- [1.4 eval()](#1.4 eval())
- [1.5 list()](#1.5 list())
- 02.深浅拷贝
-
- [2.1 赋值](#2.1 赋值)
- [2.2 浅拷贝（数据半共享）](#2.2 浅拷贝（数据半共享）)
- [2.3 深拷贝（数据完全不共享）](#2.3 深拷贝（数据完全不共享）)
- 03.可变对象
- 04.不可变对象
01.类型转换
02.深浅拷贝
03.可变对象
04.不可变对象
01.类型转换
1.1 int()
int():转换为一个整数，只能转换由纯数字组成的字符串
float->int
python
a = 1.2
print(type(a))
b = int(a)
print(type(b))
#浮点型强转整型会去掉小数点及后面的数值，只保留整数部分
str->int
如果字符串中有数字和正负号（+/-）以外的字符就会报错
+/-写在前面表示正负号，不可以写在后面
python
a = 'a'
print(type(a))
b = int(a) #只能转换由纯数字组成的字符串
print(type(b))
python
a = '123'
print(type(a))
b = int(a)
print(type(b))
python
age = input("请输入您的年龄：") #input默认输入的是字符串类型
if int(age) >= 18:
print("成年了")
1.2 float
float（）：转换为一个小数
整型转换为浮点型，会自动添加一位小数
如果字符串中有正负号、数字和小数点以外的字符，则不支持转换
python
print(float(11))
print(float(-11))
print(float('+11.345'))
print(float('11-'))
1.3 str()
str()：转换为字符串类型，任何类型都可以转换成字符串类型
python
n = 100
print(type(n)) #<class 'int'>
n2 = str(n)
print(n2,type(n2)) #100 <class 'str'>
st = str(-1.80) #float转换成str会取出末位为0的小数部分
print(st,type(st)) #-1.8 <class 'str'>
li = [1,2,3]
print(li,type(li)) #[1, 2, 3] <class 'list'>
st = str(li)
print(st,type(st)) #[1, 2, 3] <class 'str'>1.4 eval()
eval()：用来执行一个字符串表达式，并返回表达式的值
python
print(10 + 10) #20
print('10' + '10') #1010
print('10 + 10') #10 + 10
print(eval('10 + 10')) #20 执行运算，并返回运算值
print(eval('10' + '10')) #1010eval()可以实现list、dict、tuple和str之间的转换
（1）str->list
python
st1 = '[[1,2],[3,4],[5,6]]'
print(st1,type(st1)) #[[1,2],[3,4],[5,6]] <class 'str'>
li = eval(st1)
print(li,type(li)) #[[1, 2], [3, 4], [5, 6]] <class 'list'>（2）str->dict
python
st2 = "{'name':'bingbing','age':18}"
dic = eval(st2)
print(dic,type(dic)) #{'name': 'bingbing', 'age': 18} <class 'dict'>eval()非常强大，但是不够安全，容易被恶意修改数据，不建议使用
1.5 list()
list():将可迭代对象转换成列表
支持转换为list的类型：str、tuple、dict、set
str()->list()
python
print(list('abcdefg')) #['a', 'b', 'c', 'd', 'e', 'f', 'g']
# #print(list(12345)) #报错tuple()->list()
python
print(list((1,2,3,4))) #[1, 2, 3, 4]
dict()->list()
字典转换成列表，会取键名作为列表的值
python
print(list({'name':'xiaoming','age':15})) #['name', 'age']
set() ->list()
基本转换成列表，会先去重，再转换
python
print(list({'a','b','c','d'})) #['b', 'c', 'a', 'd']
print(list({'a','b','c','d','b'})) #['b', 'c', 'a', 'd']02.深浅拷贝
浅拷贝：浅拷贝是对于一个对象的顶层拷贝， 拷贝了最外层的对象，内部的元素只拷贝了一个引用。
深拷贝：深拷贝是对于一个对象所有层次的拷贝 （外层的对象和内部的元素都拷贝了一遍）
浅拷贝：节省资源和内存空间
深拷贝：数据拷贝更加安全
2.1 赋值
赋值：会随着元对象一起变量
赋值：等于完全共享资源，一个值的改变会完全被另一个值共享
python
li = [1,2,3,4]
print(li)
li2 = li
print(li2)
#查看内存地址 id()
print('li内存地址：',id(li))
print('li2内存地址：',id(li2))
#给li列表新增元素
li.append(5)
print('新增后的li',li)
print('新增后的li2',li2)
2.2 浅拷贝（数据半共享）
浅拷贝：会创建新的对象，拷贝第一层的数据，嵌套层会指向原来的内存地址
import copy #导入copy模块
python
li = [1,2,3,[4,5,6]] #定义一个嵌套列表
print(li)
li2 = copy.copy(li) #浅拷贝
print(li2)
#查看内存地址 id()
print('li内存地址：',id(li))
print('li2内存地址：',id(li2))
#内存地址不一样，说明不是同一个对象
#给li列表新增元素
li.append(5)
print('新增后的li',li)
print('新增后的li2',li2)
#查看内存地址 id()
print('li内存地址：',id(li))
print('li2内存地址：',id(li2))
#往嵌套列表添加元素
li[3].append(7)
print('li:',li)
print('li2:',li2)
print('li[3]内存地址：',id(li[3]))
print('li2[3]内存地址：',id(li2[3]))
#外层的内存地址不同，但是内层的内存地址相同
优点：拷贝速度快，占用空间少，拷贝效率高
2.3 深拷贝（数据完全不共享）
深拷贝：外层的对象和内部的元素都拷贝了一遍
import copy #导入copy模块
python
li = [1,2,3,[4,5,6]] #定义一个嵌套列表
print(li)
li2 = copy.deepcopy(li) #深拷贝
print(li2)
#查看内存地址 id()
print('li内存地址：',id(li))
print('li2内存地址：',id(li2))
#内存地址不一样，说明不是同一个对象
#给li列表新增元素
li.append(5)
print('新增后的li',li)
print('新增后的li2',li2)
#查看内存地址 id()
print('li内存地址：',id(li))
print('li2内存地址：',id(li2))
#往嵌套列表添加元素
li[3].append(7)
print('li:',li)
print('li2:',li2)
print('li[3]内存地址：',id(li[3]))
print('li2[3]内存地址：',id(li2[3]))
#外层的内存地址不同，内层的内存地址也不相同
#深拷贝数据变化只影响自己本身，跟原来的对象没有关联
03.可变对象
可变对象：存储空间保存的数据允许被修改，这种数据就是可变类型。
==常见的可变类型有: ==
列表 list 字典 dict 集合 set
含义：变量对应的值可以修改，但是内存地址不会发生改变
python
li = [1,2,3,4]
print('li的原内存地址：',id(li),li)
li.append(5)
print('li的现内存地址：',id(li),li)
python
dic = {'name':'xiaoming','age':20}
print('dic的原内存地址：',id(dic),dic)
dic['name'] = 'jack'
print('dic的现内存地址：',id(dic),dic)
python
set = {1,2,3,4,5}
print('set的原内存地址：',id(set),set)
set.remove(4)
print('set的现内存地址：',id(set),set)
04.不可变对象
不可变对象：存储空间保存的数据不允许被修改，这种数据就是不可变类型。
==常见的不可变类型有: ==
1.数值类型 int, bool, float, complex
2.字符串 str
3.元组 tuple
含义：变量对应的值不能被修改，如果修改就会生成一个新的值从而分配新的内存空间
python
n = 10
print('原地址：',id(n),n)
n = 15
print('现地址：',id(n),n)
#内存地址不一样：修改n的值就会生成新的值，重新赋值给变量n
python
str = 'a'
print('原地址：',id(str),str)
str = 'book'
print('现地址：',id(str),str)
python
tua = (1,2,3,4)
print('tua的原内存地址：',id(tua),tua)
tua = ('a',"b",'c')
print('tua的现内存地址：',id(tua),tua)
注意：前面所说的深浅拷贝只针对可变对象，不可变对象没有深浅拷贝