day06——类型转换、赋值、深浅拷贝、可变和不可变类型

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

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