01.类型转换
02.深浅拷贝
03.可变对象
04.不可变对象

01.类型转换

1.1 int()

int():转换为一个整数，只能转换由纯数字组成的字符串
float->int

a = 1.2
print(type(a))
b = int(a)
print(type(b))
#浮点型强转整型会去掉小数点及后面的数值，只保留整数部分

str->int
如果字符串中有数字和正负号（+/-）以外的字符就会报错
+/-写在前面表示正负号，不可以写在后面

a = 'a'
print(type(a))
b = int(a)   #只能转换由纯数字组成的字符串
print(type(b))

a = '123'
print(type(a))
b = int(a)
print(type(b))

age = input("请输入您的年龄：") #input默认输入的是字符串类型
if int(age) >= 18:
print("成年了")

1.2 float

float（）：转换为一个小数
整型转换为浮点型，会自动添加一位小数
如果字符串中有正负号、数字和小数点以外的字符，则不支持转换

print(float(11))
print(float(-11))
print(float('+11.345'))
print(float('11-'))

1.3 str()

str()：转换为字符串类型，任何类型都可以转换成字符串类型

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()：用来执行一个字符串表达式，并返回表达式的值

print(10 + 10) #20
print('10' + '10') #1010
print('10 + 10') #10 + 10
print(eval('10 + 10')) #20 执行运算，并返回运算值
print(eval('10' + '10')) #1010

eval()可以实现list、dict、tuple和str之间的转换
（1）str->list

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

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

print(list('abcdefg')) #['a', 'b', 'c', 'd', 'e', 'f', 'g']
# #print(list(12345)) #报错

tuple()->list()

print(list((1,2,3,4))) #[1, 2, 3, 4]

dict()->list()
字典转换成列表，会取键名作为列表的值

print(list({'name':'xiaoming','age':15})) #['name', 'age']

set() ->list()
基本转换成列表，会先去重，再转换

print(list({'a','b','c','d'})) #['b', 'c', 'a', 'd']
print(list({'a','b','c','d','b'})) #['b', 'c', 'a', 'd']

02.深浅拷贝

浅拷贝：浅拷贝是对于一个对象的顶层拷贝， 拷贝了最外层的对象，内部的元素只拷贝了一个引用。
深拷贝：深拷贝是对于一个对象所有层次的拷贝 （外层的对象和内部的元素都拷贝了一遍）
浅拷贝：节省资源和内存空间
深拷贝：数据拷贝更加安全

2.1 赋值

赋值：会随着元对象一起变量
赋值：等于完全共享资源，一个值的改变会完全被另一个值共享

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模块

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模块

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

含义：变量对应的值可以修改，但是内存地址不会发生改变

li = [1,2,3,4]
print('li的原内存地址：',id(li),li)
li.append(5)
print('li的现内存地址：',id(li),li)

dic = {'name':'xiaoming','age':20}
print('dic的原内存地址：',id(dic),dic)
dic['name'] = 'jack'
print('dic的现内存地址：',id(dic),dic)

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

含义：变量对应的值不能被修改，如果修改就会生成一个新的值从而分配新的内存空间

n = 10
print('原地址：',id(n),n)
n = 15
print('现地址：',id(n),n)
#内存地址不一样：修改n的值就会生成新的值，重新赋值给变量n

str = 'a'
print('原地址：',id(str),str)
str = 'book'
print('现地址：',id(str),str)

tua = (1,2,3,4)
print('tua的原内存地址：',id(tua),tua)
tua = ('a',"b",'c')
print('tua的现内存地址：',id(tua),tua)

注意：前面所说的深浅拷贝只针对可变对象，不可变对象没有深浅拷贝

学习地址：https://www.bilibili.com/video/BV1FS421K7Hs/?p=16&spm_id_from=pageDriver&vd_source=279585e3656eb1829d1f31997be26270