1.类型转换
1.1 int()：转换为一个整数，只能转换由纯数字组成的字符串
a = 1.2
print(type(a)) #<class 'float'>
b = int(a)
print(b,type(b)) #1 <class 'int'>
print(int(1.8)) #1
浮点型强转整型会去掉小数点及后面的数值，只保留整数部分
str -> int
a = int('123')
print(a,type(a))
print(int('bingbing')) #报错
如果字符串中有数字和正负号以外的字符就会报错
print(int('-10'))
+/-写在前面表示正负号，不可以写在后面
用户从控制台输入，判断年龄
num = input("您的年龄是：")
age = int(num)
if age >= 18:
print("已经成年了")
1.2 float()：转换为一个小数
print(float(11)) #整型转化为浮点型，会自动添加一位小数
print(float(-11))
print(float('+11.345'))
print(float('10-')) #如果字符串中有正负号、数字和小数点以外的字符，则不支持转换
1.3 str()：转换为字符串类型，任何类型都可以转换成字符串类型
n = 100
print(type(n)) #<class 'int'>
n2 = str(n)
print(n2,type(n2)) #100 <class 'str'>
st = str(-1.000)
print(st,type(st)) #-1.0 <class 'str'>,float转换成str会取出末位为0的小数部分
li = [1,2,3]
st = str(li)
print(st,type(st)) #[1, 2, 3] <class 'str'>
1.4 eval()
print(10+10) #20
print('10'+'10') #1010
print(eval('10+10')) #20,执行运算，并返回运算值
eval()可以实现list、dict、tuple和str之间的转换
str -> list
stl = "[[1,2],[3,4],[5,6]]"
print(type(stl)) #<class 'str'>
li = eval(stl)
print(li,type(li)) #[[1, 2], [3, 4], [5, 6]] <class 'list'>
str -> dict
st2 = "{'name':'qiqi','age':10}"
dic = eval(st2)
print(dic,type(dic)) #{'name': 'qiqi', 'age': 10} <class 'dict'>
注意：eval()非常强大，但是不够安全，容易被恶意修改数据，不建议使用
1.5 list()：将可迭代对象转换成列表
支持转换为list的类型：str、tuple、dict、set
str -> list
print(list('abbcdefg'))
print(list(12345)) #报错
tuple -> list
print(list((1,2,3,4,5)))
dict -> list
print(list({'name':'qiqi','age':10})) #['name', 'age']
字典转换成列表，会取键名作为列表的值
set -> list
print(list({'a','b','c','b'})) #['b', 'c', 'a']
集合转换成列表，会先去重，再转换
2.深浅拷贝
2.1赋值
li = [1,2,3,4]
print(li)
li2 = li
print('li',li)
print('li2',li2)
#给li列表新增元素
li.append(5)
print('新增后的li',li) #新增后的li [1, 2, 3, 4, 5]
print('新增后的li2',li2) #新增后的li2 [1, 2, 3, 4, 5]
赋值：等于完全共享资源，一个值的改变会完全被另一个值共享
2.2浅拷贝(数据半共享)
会创建新的对象，拷贝第一层的数据，嵌套层会指向原来的内存地址
import copy #导入copy模块
li = [1,2,3,[4,5,6]]
li2 = copy.copy(li) #浅拷贝
print('li',li) #li [1, 2, 3, [4, 5, 6]]
print('li2',li2) #li2 [1, 2, 3, [4, 5, 6]]
#查看内存地址 id()
print('li内存地址:',id(li))
print('li2内存地址',id(li2))
#内存地址不一样，说明不是同一个对象
li.append(8)
print('li',li) #li [1, 2, 3, [4, 5, 6], 8]
print('li2',li2) #li2 [1, 2, 3, [4, 5, 6]]
#往嵌套列表添加元素
li[3].append(7)
print('li',li) #li [1, 2, 3, [4, 5, 6, 7], 8]
print('li2',li2) #li2 [1, 2, 3, [4, 5, 6, 7]]
print('li[3]的内存地址:',id(li[3]))
print('li2[3]的内存地址:',id(li2[3]))
外层的内存地址不同，但是内层的内存地址相同
优点：拷贝速度快，占用空间少，拷贝相率高
2.3深拷贝(数据完全不共享)
外层的对象和内部的元素都拷贝了一遍
import copy #导入copy模块
li = [1,2,3,[4,5,6]]
li2 = copy.deepcopy(li)
print('li',li,id(li))
print('li2',li2,id(li2))
li.append(8)
print('li:',li) #li: [1, 2, 3, [4, 5, 6], 8]
print('li2:',li2) #li2: [1, 2, 3, [4, 5, 6]]
# 在嵌套列表添加元素
li[3].append(7)
print(li,id(li)) #[1, 2, 3, [4, 5, 6, 7], 8] 2847580681024
print(li2,id(li2)) #[1, 2, 3, [4, 5, 6]] 2847580587584
深拷贝数据变化只影响自己本身，跟原来的对象没有关联
3.可变类型
含义：变量对应的值可以修改，但是内存地址不会发生改变
常见的可变类型：list、dict、set
li = [1,2,3,4]
print('li的原内存地址:',id(li))
li.append(5)
print(li)
print('li的现内存地址:',id(li))
dic = {'name':'qiqi','age':'18'}
print(dic,id(dic)) #{'name': 'qiqi', 'age': '18'} 2420393814208
dic['name'] = 'jinjin' #修改元素
print(dic,id(dic)) #{'name': 'jinjin', 'age': '18'} 2420393814208
set = {1,2,3,4,5}
print(set,id(set))
set.remove(3) #删除元素
print(set,id(set))
4.不可变类型
含义：变量对应的值不能被修改，如果修改就会生成一个新的值从而分配新的内存空间
n = 10 #整型
print('原地址',n,id(n))
内存地址不一样：修改n的值就会生成新的值，重新赋值给变量n
st = 'hello'
print(st,id(st))
st = 'qiqi'
print(st,id(st))
tua = (1,2,3)
print(tua,id(tua))
#不支持新增删除和修改操作
tua = ('a','b','c')
print(tua,id(tua))
注意：前面所说的深浅拷贝只针对可变对象，不可变对象没有拷贝的说法