1.类型转换

1.1 int(x):转化为一个整数，只能转换由纯数字组成的字符串

float->int

浮点型强转整形会去掉小数点后面的数，只保留整数部分

a = 1.2
print(type(a))   #<class 'float'>
b = int(a)
print(type(b))    #<class 'int'>print(int(1.8))   #1

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

a = int('123')
print(a,type(a))   #123 <class 'int'>

从控制台输入数字的时候可以使用强制转换，input输入时默认输入的是字符串类型

age = int(input("请输入年龄"))
if age > 18:print("成年了")

1.2 float(x)：转换为一个小数

整形转换为浮点型会自动添加一位小数

如果字符串中由正负号，数字和小数点以外的字符，不支持转换

print(float(11))   #11.0
print(float(-23))   #-23.0
print(float('+2.3456'))  #2.345
#print(float(10-))   报错

1.3 str(x)：将对象转换为字符串类型，任何类型都可以转换

浮点型转换成str会自动去除末位为0的小数部分，保留一位小数

a = 100
print(type(a),a)   #<class 'int'> 100b = str(a)
print(type(b),b)   #<class 'str'> 100st = str(-1.8)
print(type(st),st)  #<class 'str'> -1.8st1 = str(-1.00000)
print(type(st1),st1)  #<class 'str'> -1.0st2 = str(-1.02300)
print(type(st2),st2)   #<class 'str'> -1.023

转换列表：

list = [1,2,3]
st = str(list)
print(type(st),st)   #<class 'str'> [1, 2, 3]

1.4 eval (x)：用来计算在字符串中的有效python表达式，并返回表达式的值

eval非常长强大，但不够安全，容易被恶意修改数据

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

eval（）可以实现list、dict、tuple和str之间的转换；相当于去掉字符串的引号

st1 = '[[1,2],[3,4],[5,6]]'
print(type(st1),st1)   #<class 'str'> [[1,2],[3,4],[5,6]]li = eval(st1)
print(type(li),li)   #<class 'list'> [[1, 2], [3, 4], [5, 6]]

st2 = "{'name':'panda','age':5}"
print(type(st2),st2)  #<class 'str'> {'name':'panda','age':5}
dic = eval(st2)
print(type(dic),dic)  #<class 'dict'> {'name':'panda','age':5}

1.5 tuple(x)：将可迭代对象转换为元组类型

list = [1,2,3,4]
tua = tuple(list)
print(tua,type(tua))  #(1, 2, 3, 4) <class 'tuple'>

1.6 list(x)：将可迭代对象转换为列表类型

支持转换为list的类型:str 、tuple、dict、set

字典转换成列表，会取键名作为列表的值。

集合转化成列表会先去重，在转换（字母无序）。

print(list('abcdef'))      #['a','b','c','d','e','f']
print(list((1,2,3,4)))   #[1,2,3,4]
print(list({'name':'panda','age':5}))    #['name','age']
print(list({'a','b','c','b'}))    #['c','b','a']

2.深浅拷贝（只针对可变对象）

2.1赋值：对于列表，字典，集合这种类型，复制就等于完全共享资源，一个值的改变会完全被另一个值共享。赋值后的对象会随着原对象一起变换。

li = [1,2,3,4]
li2 = li
print('li',li)   #li [1, 2, 3, 4]
print('li2',li2)   #li2 [1, 2, 3, 4]
li.append(5)
print('赋值后：li',li)  #赋值后：li [1, 2, 3, 4, 5]
print('赋值后：li2',li2)  #赋值后：li2 [1, 2, 3, 4, 5]

2.2浅拷贝（数据半共享）

会创建新的对象，拷贝第一层的数据，嵌套层会指向原来的内存地址

首先需要导入copy模块

查看内存地址：id（）

外层的内存地址不同，内层的内存地址相同。大多数形况下都使用浅拷贝

优点：拷贝速度快，且占用空间少，拷贝效率高。

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]]
print(id(li))   #2256239241864
print(id(li2))  #2256239241992内存地址不一样，不是同一对象
li.append(8)
print('赋值后：li', li)  #赋值后：li [1, 2, 3, [4, 5, 6],8]
print('赋值后：li2', li2)  #赋值后：li [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)  #赋值后：li [1, 2, 3, [4, 5, 6,7]]
print(id(li[3]))   #2288402279240
print(id(li2[3]))   #2288402279240 内存地址相同

2.3深拷贝（数据完全不共享）

外层对象和内层元素都拷贝一遍，深拷贝数据变化只影响自己本身，和原来的对象没有关联。

也要导入copy模块

import copy #导入copy模块
li = [1,2,3,[4,5,6]]
li2 = copy.deepcopy(li)
print('li',li)    #li [1, 2, 3, [4, 5, 6]]
print('li2',li2)   #li2 [1, 2, 3, [4, 5, 6]]
print(id(li))   #2704884215048
print(id(li2))  #2704884214792内存地址不一样，不是同一对象
li.append(8)
print('赋值后：li', li)  #赋值后：li [1, 2, 3, [4, 5, 6],8]
print('赋值后：li2', li2)  #赋值后：li [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)  #赋值后：li [1, 2, 3, [4, 5, 6,]]
print(id(li[3]))   #2704883434440
print(id(li2[3]))   #2704884215304 内存地址不同

3.可变对象

含义：存储空间保存的数据允许被修改，这种数据就是可变类型（变量对应的值可以被修改，但是内存地址不会发生改变）

常见的可变类型：列表（list）、字典（dict）、集合（set)  

li = [1,2,3,4]
print(li,id(li))   #[1, 2, 3, 4] 1886619741320
li.append(5)    #添加元素
print(li,id(li))   #[1, 2, 3, 4, 5] 1886619741320dic = {'name':'pande','age':5}
print(dic,id(dic))     #{'name': 'pande', 'age': 5} 2103573679704
dic['name'] = 'monkey'   #修改元素
print(dic,id(dic))     #{'name': 'monkey', 'age': 5} 2103573679704set = {1,2,3,4,5}
print(set,id(set))   #{1, 2, 3, 4, 5} 2769478186152
set.remove(3)    #删除元素
print(set,id(set))   #{1, 2, 4, 5} 2769478186152

4.不可变对象

含义：存储空间保存的数据不允许被修改，这种数据就是不可变类型（变量对应的值不能被修改，修改的话就会生成新的值，从而分配新的内存空间）

常见的不可变类型：数值类型（int 、bool、float、complex）、字符串（str）、元组（tuple）

元组不支持新增修改和删除操作。

n = 10
print(n,id(n))   #10 140719911371312
n = 15
print(n,id(n))   #15 140719911371472str = 'hello'
print(str,id(str))   #hello 2348660297456
str = 'world'
print(str,id(str))   #world 2348660297520tua = (1,2,3)
print(tua,id(tua))   #(1, 2, 3) 1535623178104
tua =('a','b','c')
print(tua,id(tua))   #('a', 'b', 'c') 1535623178504